From: Chris Duncan <chris@zoso.dev>
Date: Sun, 22 Mar 2026 09:48:47 +0000 (-0700)
Subject: Polish for first release.
X-Git-Tag: v1.0.0~3
X-Git-Url: https://git.codecow.com/?a=commitdiff_plain;h=dc2ace35a0d9aaf4b265e35e35b5c50cd7830f2d;p=nano25519.git

Polish for first release.

Rename project for accuracy. Separate async/sync modules. Add tons of tests. Zero out memory when no longer needed. Reduce global static variables by using WASM linear memory directly.
---

diff --git a/AUTHORS.md b/AUTHORS.md
index f53d78c..037ceac 100644
--- a/AUTHORS.md
+++ b/AUTHORS.md
@@ -5,7 +5,7 @@ SPDX-License-Identifier: GPL-3.0-or-later
 
 # Authors
 
-[nano-nacl](https://codecow.com/nano-nacl.git)
+[nano25519](https://codecow.com/nano25519.git)
 
 - Chris Duncan <chris@codecow.com> (codecow.com)
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e26e789..15aeaa6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,13 +3,21 @@ SPDX-FileCopyrightText: 2026 Chris Duncan <chris@codecow.com>
 SPDX-License-Identifier: GPL-3.0-or-later
 -->
 
+# Changelog
+
 ## v0.0.1
 
 ### Notable Changes
 
-Written in Javascript and AssemblyScript, NanoNaCl leverages WebAssembly to sign
-Nano cryptocurrency transaction blocks and validate block signatures.
+Written in TypeScript and AssemblyScript, nano25519 leverages WebAssembly to
+derive public keys, sign transactions, and validate signatures for Nano
+cryptocurrency.
 
-- Works entirely offline and locally on the device.
+- Fastest available implementation of Ed25519+BLAKE2b required by Nano.
+- Works in both the browser and NodeJS.
+- Optionally import separate modules for fast synchronous functions or
+  non-blocking asynchronous functions.
+- Zero networking. All results are computed entirely offline and locally on the
+  device.
 - Zero external dependencies.
 - Released under the GPLv3 license.
diff --git a/README.md b/README.md
index a7c378f..f564061 100644
--- a/README.md
+++ b/README.md
@@ -3,11 +3,11 @@ SPDX-FileCopyrightText: 2026 Chris Duncan <chris@codecow.com>
 SPDX-License-Identifier: GPL-3.0-or-later
 -->
 
-# nano-nacl
+# nano25519
 
 _Block signing and validation for Nano cryptocurrency using WebAssembly._
 
-NanoNaCl is an AssemblyScript implementation of select Ed25519 functions used by
+nano25519 is an AssemblyScript implementation of select Ed25519 functions used by
 the Nano cryptocurrency. It is modified to hash using BLAKE2b instead of SHA-512
 and can derive public keys from private keys, sign blocks, and verify block
 signatures. All processing takes place client-side and offline.
@@ -24,28 +24,28 @@ For more information about the block format defined for hashing and signing, see
 ## Installation
 
 ```console
-npm i nano-nacl
+npm i nano25519
 ```
 
 ### Browser
 
-NanoNaCl can be used directly on a webpage with a script module:
+nano25519 can be used directly on a webpage with a script module:
 
 ```html
 <script type="module">
   (async () => {
-    const NanoNaCl = await import("https://unpkg.com/nano-nacl@latest");
-    const { derive, sign, verify } = NanoNacl;
+    const nano25519 = await import("https://unpkg.com/nano25519@latest");
+    const { derive, sign, verify } = nano25519;
   })();
 </script>
 ```
 
 ### NodeJS
 
-NanoNaCl can be imported into NodeJS projects:
+nano25519 can be imported into NodeJS projects:
 
 ```javascript
-import { derive, sign, verify } from "nano-nacl";
+import { derive, sign, verify } from "nano25519";
 ```
 
 ## Usage
@@ -62,7 +62,7 @@ versions require hex strings and return the same.
 ```javascript
 // `prv` is a 32-byte Uint8Array private key
 const prv = new Uint8Array(32);
-const pub = NanoNaCl.derive(prvBytes);
+const pub = nano25519.derive(prvBytes);
 // `pub` is a 32-byte Uint8Array public key for a Nano account
 ```
 
@@ -71,7 +71,7 @@ const pub = NanoNaCl.derive(prvBytes);
 ```javascript
 // `prv` is a 64-character hex string private key
 const prv = "0000000000000000000000000000000000000000000000000000000000000000";
-const pub = await NanoNaCl.deriveAsync(prv);
+const pub = await nano25519.deriveAsync(prv);
 // `pub` is a 64-character hex string public key for a Nano account
 ```
 
@@ -83,11 +83,11 @@ const msg = new Uint8Array(32);
 // `prv` is a 32-byte Uint8Array private key
 const prv = new Uint8Array(32);
 // `pub` is a 32-byte Uint8Array public key derived from `prv`
-const pub = NanoNaCl.derive(prv);
+const pub = nano25519.derive(prv);
 // `sk` is a 64-byte Uint8Array secret key joining private and public keys
 const sk = new Uint8Array([...prv, ...pub]);
 
-const sig = NanoNaCl.sign(msg, sk);
+const sig = nano25519.sign(msg, sk);
 // `sig` is a 64-byte Uint8Array signature for the block hash
 ```
 
@@ -99,11 +99,11 @@ const msg = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
 // `prv` is a 64-char hex string private key
 const prv = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
 // `pub` is a 64-char hex string public key derived from `prv`
-const pub = await NanoNaCl.deriveAsync(prv);
+const pub = await nano25519.deriveAsync(prv);
 // `sk` is a 128-char hex string secret key joining private and public keys
 const sk = prv + pub;
 
-const sig = await NanoNaCl.signAsync(msg, sk);
+const sig = await nano25519.signAsync(msg, sk);
 // `sig` is a 128-char hex string signature for the block hash
 ```
 
@@ -117,7 +117,7 @@ const msg = new Uint8Array(32);
 // `pub` is a 32-byte Uint8Array public key for a Nano account
 const pub = new Uint8Array(32);
 
-const v = NanoNaCl.verify(sig, msg, pub);
+const v = nano25519.verify(sig, msg, pub);
 // `v` is a boolean 'true' if the same `prv` that derives `pub` was also used to create `sig` by signing `msg`, else 'false'
 ```
 
@@ -132,14 +132,14 @@ const msg = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
 // `pub` is a 64-char hex string public key for a Nano account
 const pub = "fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210";
 
-const v = await NanoNaCl.verifyAsync(sig, msg, pub);
+const v = await nano25519.verifyAsync(sig, msg, pub);
 // `v` is a boolean 'true' if the same `prv` that derives `pub` was also used to create `sig` by signing `msg`, else 'false'
 ```
 
 ## Notes
 
 The tweetnacl-js implementation was originally selected as the basis for
-NanoNaCl due to its historical reliability and security. Over time, however, it
+nano25519 due to its historical reliability and security. Over time, however, it
 became clear that tweetnacl was designed to optimize size and not speed. Soon
 after, libsodium became the reference from which functionality was ported.
 
@@ -164,14 +164,14 @@ A few basic tests are availabe in the source repository.
 1. Compile, minify, and bundle
 
 ```console
-git clone https://codecow.com/nano-nacl.git
-cd nano-nacl
+git clone https://codecow.com/nano25519.git
+cd nano25519
 npm i
 ```
 
 ## Reporting Bugs
 
-Email: <bug-nano-nacl@codecow.com>
+Email: <bug-nano25519@codecow.com>
 
 ## Acknowledgements
 
diff --git a/asconfig.json b/asconfig.json
index 2828ae2..1fa1753 100644
--- a/asconfig.json
+++ b/asconfig.json
@@ -1,7 +1,7 @@
 {
 	"options": {
-		"outFile": "./build/nano-nacl.wasm",
-		"textFile": "./build/nano-nacl.wat",
+		"outFile": "./build/nano25519.wasm",
+		"textFile": "./build/nano25519.wat",
 		"optimizeLevel": 3,
 		"shrinkLevel": 0,
 		"converge": true,
diff --git a/esbuild/config.mjs b/esbuild/config.mjs
index 344e640..96e8502 100644
--- a/esbuild/config.mjs
+++ b/esbuild/config.mjs
@@ -31,7 +31,7 @@ export const browserOptions = {
 	platform: 'browser',
 	target: 'esnext',
 	entryPoints: [
-		{ in: './index.ts', out: 'browser' }
+		{ in: './src/index.ts', out: 'browser' }
 	],
 	dropLabels: ['NODE']
 }
@@ -44,7 +44,9 @@ export const nodeOptions = {
 	platform: 'node',
 	target: 'node22',
 	entryPoints: [
-		{ in: './index.ts', out: 'index' }
+		{ in: './src/index.ts', out: 'index' },
+		{ in: './src/async.ts', out: 'async' },
+		{ in: './src/sync.ts', out: 'sync' }
 	],
 	packages: 'external',
 	dropLabels: ['BROWSER']
diff --git a/index.html b/index.html
index db7ef49..b72e2b1 100644
--- a/index.html
+++ b/index.html
@@ -15,23 +15,23 @@ SPDX-License-Identifier: GPL-3.0-or-later
 	<script type="module">
 		await libsodium.ready
 		await sodium.ready
-		let NanoNaCl, NANO_ORG_VECTOR, PYTHON_ED25519_BLAKE2B_VECTORS
+		let nano25519, NANO_ORG_VECTOR, PYTHON_ED25519_BLAKE2B_VECTORS
 		try {
-			NanoNaCl = await import('./dist/browser.js')
+			nano25519 = await import('./dist/browser.js')
 		} catch (err) {
 			console.warn(err)
 			try {
-				NanoNaCl = await import('https://unpkg.com/nano-nacl')
+				nano25519 = await import('https://unpkg.com/nano25519')
 			} catch (err) {
 				console.warn(err)
 				try {
-					NanoNaCl = await import('https://cdn.jsdelivr.net/npm/nano-nacl@latest')
+					nano25519 = await import('https://cdn.jsdelivr.net/npm/nano25519@latest')
 				} catch (err) {
-					throw new Error(`Failed to load NanoNaCl ${err}`)
+					throw new Error(`Failed to load nano25519 ${err}`)
 				}
 			}
 		}
-		window.NanoNaCl = NanoNaCl
+		window.nano25519 = nano25519
 		try {
 			({ NANO_ORG_VECTOR, PYTHON_ED25519_BLAKE2B_VECTORS } = await import('./vectors.mjs'))
 		} catch (err) {
@@ -115,12 +115,12 @@ SPDX-License-Identifier: GPL-3.0-or-later
 		const derive = (sk, api) => {
 			const sk8 = new Uint8Array(sk.match(/.{2}/g).map(b => parseInt(b, 16)))
 			switch (api) {
-				case 'NanoNaCl': {
-					const pk8 = NanoNaCl.derive(sk8)
+				case 'nano25519': {
+					const pk8 = nano25519.derive(sk8)
 					return [...pk8].map(b => b.toString(16).padStart(2, '0')).join('')
 				}
-				case 'NanoNaCl (async)': {
-					return NanoNaCl.deriveAsync(sk)
+				case 'nano25519 (async)': {
+					return nano25519.deriveAsync(sk)
 				}
 				case 'NanocurrencyWeb': {
 					return NanocurrencyWeb.wallet.legacyAccounts(sk)[0].publicKey
@@ -143,12 +143,12 @@ SPDX-License-Identifier: GPL-3.0-or-later
 			const h8 = new Uint8Array(h.match(/.{2}/g).map(b => parseInt(b, 16)))
 			const sk8 = new Uint8Array((sk + pk).match(/.{2}/g).map(b => parseInt(b, 16)))
 			switch (api) {
-				case 'NanoNaCl': {
-					const s8 = NanoNaCl.sign(h8, sk8)
+				case 'nano25519': {
+					const s8 = nano25519.sign(h8, sk8)
 					return [...s8].map(b => b.toString(16).padStart(2, '0')).join('')
 				}
-				case 'NanoNaCl (async)': {
-					return NanoNaCl.signAsync(h, sk + pk)
+				case 'nano25519 (async)': {
+					return nano25519.signAsync(h, sk + pk)
 				}
 				case 'NanocurrencyWeb': {
 					const { privateKey } = NanocurrencyWeb.wallet.legacyAccounts(sk)[0]
@@ -172,11 +172,11 @@ SPDX-License-Identifier: GPL-3.0-or-later
 			const s8 = new Uint8Array(s.match(/.{2}/g).map(b => parseInt(b, 16)))
 			const pk8 = new Uint8Array(pk.match(/.{2}/g).map(b => parseInt(b, 16)))
 			switch (api) {
-				case 'NanoNaCl': {
-					return NanoNaCl.verify(s8, h8, pk8)
+				case 'nano25519': {
+					return nano25519.verify(s8, h8, pk8)
 				}
-				case 'NanoNaCl (async)': {
-					return NanoNaCl.verifyAsync(s, h, pk)
+				case 'nano25519 (async)': {
+					return nano25519.verifyAsync(s, h, pk)
 				}
 				case 'NanocurrencyWeb': {
 					return NanocurrencyWeb.tools.verify(pk, s, h)
@@ -214,68 +214,87 @@ SPDX-License-Identifier: GPL-3.0-or-later
 
 			// self-check
 			document.getElementById('status').innerHTML = `RUNNING SELF-CHECK`
-			console.log(`%cNanoNaCl`, 'color:green', 'Checking validation against known values')
+			console.log(`%cnano25519`, 'color:green', 'Checking validation against known values')
 			const zeroes = '0000000000000000000000000000000000000000000000000000000000000000'
 			const expect = []
 			let result, test, passes = 0, failures = 0
 
 			// PASS
-			result = await NanoNaCl.deriveAsync(NANO_ORG_VECTOR.privateKey)
+			result = await nano25519.deriveAsync(NANO_ORG_VECTOR.privateKey)
 			test = result.toLowerCase() === NANO_ORG_VECTOR.publicKey.toLowerCase()
 			check(`async derive from ${NANO_ORG_VECTOR.privateKey}`, test)
 			passes += +test
 			failures += +!test
 
-			result = await NanoNaCl.signAsync(NANO_ORG_VECTOR.blockHash, NANO_ORG_VECTOR.secretKey)
+			result = await nano25519.signAsync(NANO_ORG_VECTOR.blockHash, NANO_ORG_VECTOR.secretKey)
 			test = result.toLowerCase() === NANO_ORG_VECTOR.signature.toLowerCase()
 			check(`async sign message ${NANO_ORG_VECTOR.blockHash}`, test)
 			passes += +test
 			failures += +!test
 
-			result = await NanoNaCl.verifyAsync(NANO_ORG_VECTOR.signature, NANO_ORG_VECTOR.blockHash, NANO_ORG_VECTOR.publicKey)
+			result = await nano25519.verifyAsync(NANO_ORG_VECTOR.signature, NANO_ORG_VECTOR.blockHash, NANO_ORG_VECTOR.publicKey)
 			test = result === true
 			check(`async verify signature ${NANO_ORG_VECTOR.signature}`, test)
 			passes += +test
 			failures += +!test
 
-			result = NanoNaCl.derive(NANO_ORG_VECTOR.privateKeyBytes)
+			result = nano25519.derive(NANO_ORG_VECTOR.privateKeyBytes)
 			test = [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase() === NANO_ORG_VECTOR.publicKey.toLowerCase()
 			check(`derive from ${NANO_ORG_VECTOR.privateKey}`, test)
 			passes += +test
 			failures += +!test
 
-			result = NanoNaCl.sign(NANO_ORG_VECTOR.blockHashBytes, NANO_ORG_VECTOR.secretKeyBytes)
+			result = nano25519.sign(NANO_ORG_VECTOR.blockHashBytes, NANO_ORG_VECTOR.secretKeyBytes)
 			test = [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase() === NANO_ORG_VECTOR.signature.toLowerCase()
 			check(`sign message ${NANO_ORG_VECTOR.blockHash}`, test)
 			passes += +test
 			failures += +!test
 
-			result = NanoNaCl.verify(NANO_ORG_VECTOR.signatureBytes, NANO_ORG_VECTOR.blockHashBytes, NANO_ORG_VECTOR.publicKeyBytes)
+			result = nano25519.verify(NANO_ORG_VECTOR.signatureBytes, NANO_ORG_VECTOR.blockHashBytes, NANO_ORG_VECTOR.publicKeyBytes)
 			test = result === true
 			check(`verify signature ${NANO_ORG_VECTOR.signature}`, test)
 			passes += +test
 			failures += +!test
 
+			// test both strings and bytes as input
 			for (const { privateKey, publicKey, message, signature } of PYTHON_ED25519_BLAKE2B_VECTORS) {
+				result = nano25519.derive(privateKey)
+				test = result.toLowerCase() === publicKey
+				check(`derive from ${privateKey}`, test)
+				passes += +test
+				failures += +!test
+
+				result = nano25519.sign(message, privateKey + publicKey)
+				test = result.toLowerCase() === signature.slice(0, 128)
+				check(`sign message ${message}`, test)
+				passes += +test
+				failures += +!test
+
+				result = nano25519.verify(signature.slice(0, 128), message, publicKey)
+				test = result === true
+				check(`verify signature ${signature.slice(0, 128)}`, test)
+				passes += +test
+				failures += +!test
+
 				const privateKeyBytes = new Uint8Array(privateKey.match(/.{2}/g)?.map(b => parseInt(b, 16)) ?? [])
 				const publicKeyBytes = new Uint8Array(publicKey.match(/.{2}/g)?.map(b => parseInt(b, 16)) ?? [])
 				const secretKeyBytes = new Uint8Array([...privateKeyBytes, ...publicKeyBytes])
 				const messageBytes = new Uint8Array(message.match(/.{2}/g)?.map(b => parseInt(b, 16)) ?? [])
 				const signatureBytes = new Uint8Array(signature.match(/.{2}/g)?.slice(0, 64).map(b => parseInt(b, 16)) ?? [])
 
-				result = NanoNaCl.derive(privateKeyBytes)
+				result = nano25519.derive(privateKeyBytes)
 				test = [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase() === publicKey
 				check(`derive from ${privateKey}`, test)
 				passes += +test
 				failures += +!test
 
-				result = NanoNaCl.sign(messageBytes, secretKeyBytes)
+				result = nano25519.sign(messageBytes, secretKeyBytes)
 				test = [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase() === signature.slice(0, 128)
 				check(`sign message ${message}`, test)
 				passes += +test
 				failures += +!test
 
-				result = NanoNaCl.verify(signatureBytes, messageBytes, publicKeyBytes)
+				result = nano25519.verify(signatureBytes, messageBytes, publicKeyBytes)
 				test = result === true
 				check(`verify signature ${signature.slice(0, 128)}`, test)
 				passes += +test
@@ -283,35 +302,35 @@ SPDX-License-Identifier: GPL-3.0-or-later
 			}
 
 			// XFAIL
-			result = await NanoNaCl.verifyAsync(NANO_ORG_VECTOR.badSignature, NANO_ORG_VECTOR.blockHash, NANO_ORG_VECTOR.publicKey)
+			result = await nano25519.verifyAsync(NANO_ORG_VECTOR.badSignature, NANO_ORG_VECTOR.blockHash, NANO_ORG_VECTOR.publicKey)
 			console.log(result)
 			test = result === false
 			check(`verify() output for non-canonical signature`, test)
 			passes += +test
 			failures += +!test
 
-			result = await NanoNaCl.verifyAsync(NANO_ORG_VECTOR.signature, random(), NANO_ORG_VECTOR.publicKey)
+			result = await nano25519.verifyAsync(NANO_ORG_VECTOR.signature, random(), NANO_ORG_VECTOR.publicKey)
 			console.log(result)
 			test = result === false
 			check(`verify() output for random block hash`, test)
 			passes += +test
 			failures += +!test
 
-			result = await NanoNaCl.verifyAsync(NANO_ORG_VECTOR.signature, zeroes, NANO_ORG_VECTOR.publicKey)
+			result = await nano25519.verifyAsync(NANO_ORG_VECTOR.signature, zeroes, NANO_ORG_VECTOR.publicKey)
 			console.log(result)
 			test = result === false
 			check(`verify() output for bad block hash`, test)
 			passes += +test
 			failures += +!test
 
-			result = await NanoNaCl.verifyAsync(`${zeroes}${zeroes}`, NANO_ORG_VECTOR.blockHash, NANO_ORG_VECTOR.publicKey)
+			result = await nano25519.verifyAsync(`${zeroes}${zeroes}`, NANO_ORG_VECTOR.blockHash, NANO_ORG_VECTOR.publicKey)
 			console.log(result)
 			test = result === false
 			check(`verify() output for bad signature`, test)
 			passes += +test
 			failures += +!test
 
-			result = await NanoNaCl.verifyAsync(NANO_ORG_VECTOR.signature, NANO_ORG_VECTOR.blockHash, zeroes)
+			result = await nano25519.verifyAsync(NANO_ORG_VECTOR.signature, NANO_ORG_VECTOR.blockHash, zeroes)
 			console.log(result)
 			test = result === false
 			check(`verify() output for bad public key`, test)
@@ -382,7 +401,7 @@ SPDX-License-Identifier: GPL-3.0-or-later
 			const validation = document.getElementById('validation')
 			validation.innerText = '⏳'
 			if (signature.length === 128 && blockHash.length === 64 && publicKey.length === 64) {
-				NanoNaCl.verify(signature, blockHash, publicKey)
+				nano25519.verify(signature, blockHash, publicKey)
 					.then(result => {
 						validation.innerText = result
 							? '✔️'
@@ -422,9 +441,9 @@ SPDX-License-Identifier: GPL-3.0-or-later
 </head>
 
 <body>
-	<h1>nano-nacl</h1>
-	<h4><a href="https://www.npmjs.com/package/nano-nacl">https://www.npmjs.com/package/nano-nacl</a></h4>
-	<h2>Speed test for NanoNaCl tool.</h2>
+	<h1>nano25519</h1>
+	<h4><a href="https://www.npmjs.com/package/nano25519">https://www.npmjs.com/package/nano25519</a></h4>
+	<h2>Speed test for nano25519</h2>
 	<p>Times below are in milliseconds and are summarized by various averaging methods.</p>
 	<hr />
 	<label for="signature">Verify Signature</label>
@@ -439,8 +458,8 @@ SPDX-License-Identifier: GPL-3.0-or-later
 	<span>
 		<label for="api">API</label>
 		<select id="api">
-			<option>NanoNaCl</option>
-			<option>NanoNaCl (async)</option>
+			<option>nano25519</option>
+			<option>nano25519 (async)</option>
 			<option>NanocurrencyWeb</option>
 			<option>Sodium</option>
 			<option>TweetNaCl.js</option>
diff --git a/package-lock.json b/package-lock.json
index 9f21649..ea2aff9 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,11 +1,11 @@
 {
-	"name": "nano-nacl",
+	"name": "nano25519",
 	"version": "0.0.1",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
-			"name": "nano-nacl",
+			"name": "nano25519",
 			"version": "0.0.1",
 			"license": "(GPL-3.0-or-later AND MIT)",
 			"devDependencies": {
diff --git a/package.json b/package.json
index 4116c66..2285ed2 100644
--- a/package.json
+++ b/package.json
@@ -1,5 +1,5 @@
 {
-	"name": "nano-nacl",
+	"name": "nano25519",
 	"version": "0.0.1",
 	"description": "Nano cryptocurrency public key derivation, transaction signing, and signature verification using AssemblyScript.",
 	"keywords": [
@@ -13,7 +13,7 @@
 		"wasm"
 	],
 	"homepage": "https://git.codecow.com",
-	"bugs": "bug-nano-nacl@codecow.com",
+	"bugs": "bug-nano25519@codecow.com",
 	"license": "(GPL-3.0-or-later AND MIT)",
 	"author": "Chris Duncan <chris@codecow.com>",
 	"funding": {
@@ -28,13 +28,13 @@
 	],
 	"repository": {
 		"type": "git",
-		"url": "git+https://codecow.com/nano-nacl.git"
+		"url": "git+https://codecow.com/nano25519.git"
 	},
 	"scripts": {
 		"build": "npm run clean && npm run compile && node ./esbuild/dev.mjs",
 		"build:prod": "npm run clean && npm run compile && node ./esbuild/prod.mjs",
 		"clean": "rm -rf {build,dist}",
-		"compile": "asc ./assembly/index.ts && tsc",
+		"compile": "asc ./src/assembly/index.ts && tsc",
 		"prepublishOnly": "npm run test:prod",
 		"test": "npm run build && node ./test.mjs",
 		"test:prod": "npm run build:prod && node ./test.mjs"
@@ -51,6 +51,14 @@
 			"types": "./dist/index.d.ts",
 			"node": "./dist/index.js",
 			"import": "./dist/browser.js"
+		},
+		"./sync": {
+			"types": "./dist/sync.d.ts",
+			"node": "./dist/sync.js"
+		},
+		"./async": {
+			"types": "./dist/async.d.ts",
+			"node": "./dist/async.js"
 		}
 	},
 	"browser": {
diff --git a/assembly/base.ts b/src/assembly/base.ts
similarity index 100%
rename from assembly/base.ts
rename to src/assembly/base.ts
diff --git a/assembly/blake2b.ts b/src/assembly/blake2b.ts
similarity index 97%
rename from assembly/blake2b.ts
rename to src/assembly/blake2b.ts
index 272561a..72a2688 100644
--- a/assembly/blake2b.ts
+++ b/src/assembly/blake2b.ts
@@ -59,16 +59,22 @@ export class Blake2b {
 	t: v128 = v128.splat<u64>(0)
 	v: StaticArray<u64> = new StaticArray<u64>(16)
 
-	init (): Blake2b {
-		// initialize buffers and counters
+	@inline
+	clear (): void {
 		this.b.fill(0)
 		this.c = 0
+		this.h.fill(0)
 		this.m.fill(0)
+		this.p.fill(0)
 		this.t = v128.splat<u64>(0)
 		this.v.fill(0)
+	}
+
+	init (): Blake2b {
+		// reset buffers and counters
+		this.clear()
 
 		// initialize parameter block
-		this.p.fill(0)
 		this.p[0] = 64 // always 64 bytes for this implementation
 		this.p[1] = 0 // no key
 		this.p[2] = 1 // fanout
@@ -119,6 +125,9 @@ export class Blake2b {
 
 		// return byte array of 64-byte chain buffer
 		memory.copy(changetype<usize>(output), changetype<usize>(this.h), 64)
+
+		// clear internal buffers and counters
+		this.clear()
 	}
 
 	// Defined in BLAKE2 section 2.4
diff --git a/assembly/constants.ts b/src/assembly/constants.ts
similarity index 100%
rename from assembly/constants.ts
rename to src/assembly/constants.ts
diff --git a/assembly/fe.ts b/src/assembly/fe.ts
similarity index 100%
rename from assembly/fe.ts
rename to src/assembly/fe.ts
diff --git a/assembly/ge.ts b/src/assembly/ge.ts
similarity index 100%
rename from assembly/ge.ts
rename to src/assembly/ge.ts
diff --git a/assembly/index.ts b/src/assembly/index.ts
similarity index 80%
rename from assembly/index.ts
rename to src/assembly/index.ts
index ff2246d..3a9f7f6 100644
--- a/assembly/index.ts
+++ b/src/assembly/index.ts
@@ -29,8 +29,10 @@ function clamp (k: StaticArray<u8>): void {
 	k[31] |= 64
 }
 
-function crypto_derive (pk: StaticArray<u8>, sk: StaticArray<u8>, seed: StaticArray<u8>): void {
-	blake2b.init().update(changetype<usize>(seed), seed.length).digest(sk)
+const crypto_derive_pk: StaticArray<u8> = new StaticArray<u8>(PUBLICKEY_BYTES)
+function crypto_derive (sk: StaticArray<u8>, seed: StaticArray<u8>): void {
+	const pk = crypto_derive_pk
+	blake2b.init().update(changetype<usize>(seed), 32).digest(sk)
 	clamp(sk)
 
 	ge_scalarmult_base_tobytes(pk, sk)
@@ -41,13 +43,11 @@ function crypto_derive (pk: StaticArray<u8>, sk: StaticArray<u8>, seed: StaticAr
 const crypto_sign_az = new StaticArray<u8>(64)
 const crypto_sign_nonce = new StaticArray<u8>(64)
 const crypto_sign_hram = new StaticArray<u8>(64)
-const crypto_sign_zm = new StaticArray<u8>(SIGNATURE_BYTES)
 const crypto_sign_t = new StaticArray<u8>(PRIVATEKEY_BYTES)
 function crypto_sign (s: StaticArray<u8>, m: usize, mlen: i32, sk: StaticArray<u8>): void {
 	const az = crypto_sign_az
 	const nonce = crypto_sign_nonce
 	const hram = crypto_sign_hram
-	const zm = changetype<usize>(crypto_sign_zm)
 	const t = changetype<usize>(crypto_sign_t)
 
 	// Hash secret key to private scalar `a` and prefix for nonce derivation `z`
@@ -69,11 +69,14 @@ function crypto_sign (s: StaticArray<u8>, m: usize, mlen: i32, sk: StaticArray<u
 	sc_reduce(hram)
 
 	// Compute `S = (r + h*a) mod L` and construct final signature `s = (R || S)`
-	sc_muladd(changetype<StaticArray<u8>>(changetype<usize>(s) + 32), az, hram, nonce)
+	sc_muladd(changetype<StaticArray<u8>>(changetype<usize>(s) + 32), changetype<StaticArray<u8>>(az), hram, nonce)
 
 	// Clean up sensitive data
 	az.fill(0)
+	hram.fill(0)
 	nonce.fill(0)
+	sk.fill(0)
+	memory.fill(t, 0, PRIVATEKEY_BYTES)
 }
 
 const crypto_verify_h = new StaticArray<u8>(64)
@@ -134,30 +137,20 @@ export function getMessagePointer (): usize {
 	return MESSAGE_BUFFER
 }
 
-const derive_pk = new StaticArray<u8>(PUBLICKEY_BYTES)
-const derive_sk = new StaticArray<u8>(SECRETKEY_BYTES)
-const derive_seed = new StaticArray<u8>(PRIVATEKEY_BYTES)
 /**
  * Derives a Nano public key from a private key and writes it to the static
  * output buffer. This mirrors the functionality of
- * `nacl.sign.keyPair.fromSeed()`, returning just the `publicKey` property.
+ * `nacl.sign.keyPair.fromSeed()`, returning both private and public keys as a
+ * concatenated `secretKey` property.
  */
 export function derive (): void {
-	const pk = derive_pk
-	const sk = derive_sk
-	const seed = derive_seed
-
-	for (let i = 0; i < PRIVATEKEY_BYTES; i++) {
-		seed[i] = load<u8>(INPUT_BUFFER + i)
-	}
-
-	crypto_derive(pk, sk, seed)
-	for (let i = 0; i < PUBLICKEY_BYTES; i++) {
-		store<u8>(OUTPUT_BUFFER + i, pk[i])
-	}
+	const sk = changetype<StaticArray<u8>>(OUTPUT_BUFFER)
+	const seed = changetype<StaticArray<u8>>(INPUT_BUFFER)
+	memory.fill(OUTPUT_BUFFER, 0, SECRETKEY_BYTES)
+	crypto_derive(sk, seed)
+	memory.fill(INPUT_BUFFER, 0, PRIVATEKEY_BYTES)
 }
 
-const sign_sk = new StaticArray<u8>(SECRETKEY_BYTES)
 const sign_s = new StaticArray<u8>(SIGNEDMESSAGE_BYTES)
 /**
  * Sign a message using a private key. The signature is written to the static
@@ -168,13 +161,15 @@ const sign_s = new StaticArray<u8>(SIGNEDMESSAGE_BYTES)
  * @param {u64} sk - 64-byte secret key (32-byte private key + 32-byte public key)
  */
 export function sign (mlen: i32): void {
+	if (mlen < 0 || mlen > 32768) throw new Error()
 	const s = sign_s
 	const m = MESSAGE_BUFFER
-	const sk = sign_sk
+	const sk = changetype<StaticArray<u8>>(INPUT_BUFFER)
 
-	memory.copy(changetype<usize>(sk), INPUT_BUFFER, SECRETKEY_BYTES)
+	memory.fill(OUTPUT_BUFFER, 0, SIGNATURE_BYTES)
 	crypto_sign(s, m, mlen, sk)
 	memory.copy(OUTPUT_BUFFER, changetype<usize>(s), SIGNATURE_BYTES)
+	memory.fill(INPUT_BUFFER, 0, SECRETKEY_BYTES)
 }
 
 const verify_s = new StaticArray<u8>(SIGNATURE_BYTES)
@@ -188,19 +183,15 @@ const verify_k = new StaticArray<u8>(PUBLICKEY_BYTES)
  * @param {u64} k - 32-byte public key
  */
 export function verify (mlen: i32): void {
+	if (mlen < 0 || mlen > 32768) throw new Error()
 	const s = verify_s
 	const m = MESSAGE_BUFFER
 	const k = verify_k
 
-	let ptr = INPUT_BUFFER
-	for (let i = 0; i < SIGNATURE_BYTES; i++) {
-		s[i] = load<u8>(usize(i) + ptr)
-	}
-	ptr = INPUT_BUFFER + SIGNATURE_BYTES
-	for (let i = 0; i < PUBLICKEY_BYTES; i++) {
-		k[i] = load<u8>(usize(i) + ptr)
-	}
-
+	memory.fill(OUTPUT_BUFFER, 0, SIGNATURE_BYTES)
+	memory.copy(changetype<usize>(s), INPUT_BUFFER, SIGNATURE_BYTES)
+	memory.copy(changetype<usize>(k), INPUT_BUFFER + SIGNATURE_BYTES, PUBLICKEY_BYTES)
 	const v = crypto_verify(s, m, mlen, k)
 	store<u8>(OUTPUT_BUFFER, v)
+	memory.fill(INPUT_BUFFER, 0, SIGNATURE_BYTES)
 }
diff --git a/assembly/p.ts b/src/assembly/p.ts
similarity index 100%
rename from assembly/p.ts
rename to src/assembly/p.ts
diff --git a/assembly/sc.ts b/src/assembly/sc.ts
similarity index 100%
rename from assembly/sc.ts
rename to src/assembly/sc.ts
diff --git a/assembly/tsconfig.json b/src/assembly/tsconfig.json
similarity index 100%
rename from assembly/tsconfig.json
rename to src/assembly/tsconfig.json
diff --git a/assembly/tsconfig.json.license b/src/assembly/tsconfig.json.license
similarity index 100%
rename from assembly/tsconfig.json.license
rename to src/assembly/tsconfig.json.license
diff --git a/assembly/utils.ts b/src/assembly/utils.ts
similarity index 100%
rename from assembly/utils.ts
rename to src/assembly/utils.ts
diff --git a/src/async.ts b/src/async.ts
new file mode 100644
index 0000000..0db6a36
--- /dev/null
+++ b/src/async.ts
@@ -0,0 +1,62 @@
+//! SPDX-FileCopyrightText: 2026 Chris Duncan <chris@codecow.com>
+//! SPDX-License-Identifier: GPL-3.0-or-later
+
+import { run } from './nano25519'
+
+/**
+ * Asynchronous Nano public key derivation using WebAssembly.
+ * @param {Uint8Array<ArrayBuffer>} k - 64-character private key hex string
+ * @returns Promise for 64-character public key hex string
+ */
+export async function deriveAsync (privateKey: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>
+/**
+ * Asynchronous Nano public key derivation using WebAssembly.
+ * @param {string} k - 64-character private key hex string
+ * @returns Promise for 64-character public key hex string
+ */
+export async function deriveAsync (privateKey: string): Promise<string>
+export async function deriveAsync (privateKey: string | Uint8Array<ArrayBuffer>): Promise<string | Uint8Array<ArrayBuffer>> {
+	return run({ action: 'derive', privateKey })
+}
+
+/**
+ * Asynchronous signing using WebAssembly. To sign Nano blocks, the message
+ * should be a 64-character block hash.
+ * @param {Uint8Array<ArrayBuffer>} m - Variable-length message hex string up to 65536 characters
+ * @param {Uint8Array<ArrayBuffer>} k - 128-character secret key (prv + pub) hex string
+ * @returns Promise for 128-character detached signature hex string
+ */
+export async function signAsync (message: Uint8Array<ArrayBuffer>, secretKey: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>
+/**
+ * Asynchronous signing using WebAssembly. To sign Nano blocks, the message
+ * should be a 64-character block hash.
+ * @param {Uint8Array<ArrayBuffer>} m - Variable-length message hex string up to 65536 characters
+ * @param {Uint8Array<ArrayBuffer>} k - 128-character secret key (prv + pub) hex string
+ * @returns Promise for 128-character detached signature hex string
+ */
+export async function signAsync (message: string, secretKey: string): Promise<string>
+export async function signAsync (message: string | Uint8Array<ArrayBuffer>, secretKey: string | Uint8Array<ArrayBuffer>): Promise<string | Uint8Array<ArrayBuffer>> {
+	return run({ action: 'sign', message, secretKey })
+}
+
+/**
+ * Asynchronous signature verification using WebAssembly. To verify Nano block
+ * signatures, the message should be a 64-character block hash.
+ * @param {Uint8Array<ArrayBuffer>} s - 128-character detached signature hex string
+ * @param {Uint8Array<ArrayBuffer>} m - Variable-length message hex string to up 65536 characters
+ * @param {Uint8Array<ArrayBuffer>} k - 64-character public key hex string
+ * @returns Promise resolving to true if signature matches block hash and public key, else false
+ */
+export async function verifyAsync (signature: Uint8Array<ArrayBuffer>, message: Uint8Array<ArrayBuffer>, publicKey: Uint8Array<ArrayBuffer>): Promise<boolean>
+/**
+ * Asynchronous signature verification using WebAssembly. To verify Nano block
+ * signatures, the message should be a 64-character block hash.
+ * @param {Uint8Array<ArrayBuffer>} s - 128-character detached signature hex string
+ * @param {Uint8Array<ArrayBuffer>} m - Variable-length message hex string to up 65536 characters
+ * @param {Uint8Array<ArrayBuffer>} k - 64-character public key hex string
+ * @returns Promise resolving to true if signature matches block hash and public key, else false
+ */
+export async function verifyAsync (signature: string, message: string, publicKey: string): Promise<boolean>
+export async function verifyAsync (signature: string | Uint8Array<ArrayBuffer>, message: string | Uint8Array<ArrayBuffer>, publicKey: string | Uint8Array<ArrayBuffer>): Promise<boolean> {
+	return !!(await run({ action: 'verify', signature, message, publicKey }))
+}
diff --git a/src/index.ts b/src/index.ts
new file mode 100644
index 0000000..377ada4
--- /dev/null
+++ b/src/index.ts
@@ -0,0 +1,6 @@
+//! SPDX-FileCopyrightText: 2026 Chris Duncan <chris@codecow.com>
+//! SPDX-License-Identifier: GPL-3.0-or-later
+
+export { deriveAsync, signAsync, verifyAsync } from './async'
+export { derive, sign, verify } from './sync'
+
diff --git a/index.ts b/src/nano25519.ts
similarity index 58%
rename from index.ts
rename to src/nano25519.ts
index 79144d5..b799c42 100644
--- a/index.ts
+++ b/src/nano25519.ts
@@ -3,7 +3,7 @@
 
 import { Worker as NodeWorker } from 'node:worker_threads'
 //@ts-expect-error
-import nacl from './build/nano-nacl.wasm'
+import nano25519_wasm from '../build/nano25519.wasm'
 
 type Data = {
 	action: string
@@ -25,15 +25,15 @@ type Exports = {
 	}
 }
 
-const startNanoNaCl = (bytes: number[]): { derive: typeof derive, sign: typeof sign, verify: typeof verify } => {
+const nano25519_init = (bytes: number[]): { derive: typeof derive, sign: typeof sign, verify: typeof verify } => {
 	const wasm: Uint8Array<ArrayBuffer> = Uint8Array.from(bytes)
 	const module = new WebAssembly.Module(wasm)
 	const { exports } = new WebAssembly.Instance(module, {
 		env: {
 			abort: (msg: any, file: any, row: any, col: any) => {
 				// ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void
-				// msg = __liftString(msg >>> 0)
-				// file = __liftString(file >>> 0)
+				msg = msg >>> 0
+				file = file >>> 0
 				row = row >>> 0
 				col = col >>> 0
 				console.error('wasm abort:', `msg ${msg}`, `file ${file}`, `row ${row}`, `col ${col}`)
@@ -61,115 +61,125 @@ const startNanoNaCl = (bytes: number[]): { derive: typeof derive, sign: typeof s
 					console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n))
 				})()
 			},
-			memory: new WebAssembly.Memory({ initial: 4, maximum: 4 })
+			memory: new WebAssembly.Memory({ initial: 1, maximum: 1 })
 		}
 	}) as Exports
 
-	function derive (k: unknown): Uint8Array<ArrayBuffer> {
-		validate('private key', k, 32)
+	function derive (k: unknown): string | Uint8Array<ArrayBuffer> {
+		const privateKey = normalize('private key', 32, 32, k)
 		let buffer: DataView | undefined = new DataView(exports.memory.buffer)
 		let inPtr = exports.getInputPointer()
 		for (let i = 0; i < 32; i++) {
-			buffer.setUint8(inPtr + i, k[i])
+			buffer.setUint8(inPtr + i, privateKey[i])
 		}
 		exports.derive()
 		const outPtr = exports.getOutputPointer()
-		const pk = new Uint8Array(32)
+		const sk = new Uint8Array(32)
 		buffer = new DataView(exports.memory.buffer)
 		for (let i = 0; i < 32; i++) {
-			pk[i] = buffer.getUint8(outPtr + i)
+			sk[i] = buffer.getUint8(outPtr + i + 32)
+			buffer.setUint8(outPtr + i, 0)
+			buffer.setUint8(outPtr + i + 32, 0)
 		}
 		buffer = undefined
-		return pk
+		return typeof k === 'string'
+			? [...sk].map(b => b.toString(16).padStart(2, '0')).join('')
+			: sk
 	}
 
-	function sign (m: unknown, k: unknown): Uint8Array<ArrayBuffer> {
-		validate('message', m)
-		validate('secret key', k, 64)
+	function sign (m: unknown, k: unknown): string | Uint8Array<ArrayBuffer> {
+		const message = normalize('message', 0, 32768, m)
+		const secretKey = normalize('secret key', 64, 64, k)
 		let buffer: DataView | undefined = new DataView(exports.memory.buffer)
 		let mPtr = exports.getMessagePointer()
 		let inPtr = exports.getInputPointer()
-		for (let i = 0; i < m.byteLength; i++) {
-			buffer.setUint8(mPtr + i, m[i])
+		for (let i = 0; i < message.byteLength; i++) {
+			buffer.setUint8(mPtr + i, message[i])
 		}
 		for (let i = 0; i < 64; i++) {
-			buffer.setUint8(inPtr + i, k[i])
+			buffer.setUint8(inPtr + i, secretKey[i])
 		}
-		exports.sign(m.byteLength)
+		exports.sign(message.byteLength)
 		const outPtr = exports.getOutputPointer()
 		const s = new Uint8Array(64)
 		buffer = new DataView(exports.memory.buffer)
 		for (let i = 0; i < 64; i++) {
 			s[i] = buffer.getUint8(outPtr + i)
+			buffer.setUint8(outPtr + i, 0)
 		}
 		buffer = undefined
-		return s
+		return typeof k === 'string'
+			? [...s].map(b => b.toString(16).padStart(2, '0')).join('')
+			: s
 	}
 
-	function verify (s: unknown, m: unknown, k: unknown): Uint8Array<ArrayBuffer> {
-		validate('signature', s, 64)
-		validate('message', m)
-		validate('public key', k, 32)
+	function verify (s: unknown, m: unknown, k: unknown): boolean {
+		const signature = normalize('signature', 64, 64, s)
+		const message = normalize('message', 0, 32768, m)
+		const publicKey = normalize('public key', 32, 32, k)
 		let buffer: DataView | undefined = new DataView(exports.memory.buffer)
 		let mPtr = exports.getMessagePointer()
 		let inPtr = exports.getInputPointer()
-		for (let i = 0; i < m.byteLength; i++) {
-			buffer.setUint8(mPtr + i, m[i])
+		for (let i = 0; i < message.byteLength; i++) {
+			buffer.setUint8(mPtr + i, message[i])
 		}
 		for (let i = 0; i < 64; i++) {
-			buffer.setUint8(inPtr + i, s[i])
+			buffer.setUint8(inPtr + i, signature[i])
 		}
 		inPtr += 64
 		for (let i = 0; i < 32; i++) {
-			buffer.setUint8(inPtr + i, k[i])
+			buffer.setUint8(inPtr + i, publicKey[i])
 		}
-		exports.verify(m.byteLength)
+		exports.verify(message.byteLength)
 		const outPtr = exports.getOutputPointer()
 		const v = new Uint8Array(1)
 		buffer = new DataView(exports.memory.buffer)
 		v[0] = buffer.getUint8(outPtr)
+		for (let i = 0; i < 64; i++) {
+			buffer.setUint8(outPtr + i, 0)
+		}
 		buffer = undefined
-		return v
+		return v[0] === 0
 	}
 
-	function toBytes (type: string, byteLength: number, value?: unknown): Uint8Array<ArrayBuffer> {
-		if (value instanceof ArrayBuffer) {
-			return new Uint8Array(value)
+	function normalize (name: string, byteLengthMin: number, byteLengthMax: number, value: unknown): Uint8Array<ArrayBuffer> {
+		if (typeof name !== 'string') {
+			throw new TypeError(`Invalid name ${name}`)
 		}
-		if (typeof type !== 'string') {
-			throw new TypeError(`toBytes(): Invalid type ${type}`)
+		if (typeof byteLengthMin !== 'number' || typeof byteLengthMax !== 'number') {
+			throw new TypeError(`Invalid byte length for ${name}`)
 		}
-		if (typeof byteLength !== 'number') {
-			throw new TypeError(`toBytes(): Invalid byte length ${byteLength}`)
+		if (typeof value === 'string') {
+			const regex = RegExp(`[A-Fa-f0-9]{${byteLengthMin << 1},${byteLengthMax << 1}}`)
+			if (!regex.test(value)) {
+				throw new TypeError(`Invalid ${name} ${value}`)
+			}
+			value = new Uint8Array(value.match(/[A-Fa-f0-9]{2}/g)?.map(b => parseInt(b, 16)) || [])
 		}
-		const regex = RegExp(`[a-z0-9]{${byteLength << 1}}`, 'i')
-		if (typeof value !== 'string' || !regex.test(value)) {
-			throw new TypeError(`toBytes(): Invalid ${type} ${value}`)
+		if (value instanceof ArrayBuffer) {
+			value = new Uint8Array(value)
 		}
-		const bytes = new Uint8Array(value.match(/.{2}/g)?.map(b => parseInt(b, 16)) || [])
-		if (bytes.byteLength !== byteLength) {
-			throw new TypeError(`toBytes(): Error parsing ${type} ${bytes}`)
+		if (!(value instanceof Uint8Array)) {
+			throw new TypeError(`${name} must be Uint8Array`)
 		}
-		return bytes
-	}
-
-	function validate (type: string, bytes?: unknown, byteLength?: number): asserts bytes is Uint8Array<ArrayBuffer> {
-		if (!(bytes instanceof Uint8Array)) {
-			throw new TypeError(`${type} must be Uint8Array`)
+		if (!('buffer' in value && value.buffer instanceof ArrayBuffer)) {
+			throw new TypeError(`${name} must be backed by an ArrayBuffer`)
 		}
-		if (!('buffer' in bytes)) {
-			throw new TypeError(`${type} must be backed by an ArrayBuffer`)
+		if (value.byteLength < byteLengthMin) {
+			throw new TypeError(`${name} must be at least ${byteLengthMin} bytes`)
 		}
-		if (byteLength != null && bytes.buffer.byteLength !== byteLength) {
-			throw new TypeError(`${type} must be ${byteLength} bytes`)
+		if (value.byteLength > byteLengthMax) {
+			throw new TypeError(`${name} must be no more than ${byteLengthMax} bytes`)
 		}
+		return value as Uint8Array<ArrayBuffer>
 	}
 
 	let isListening = false
 	let host: any = null
 
 	/**
-	 * Parses inbound data when NanoNaCl is started as a Web Worker.
+	 * Parses inbound data when nano25519 is started as a Web Worker. Only called
+	 * by functions in `async` module.
 	 * @param {object} message.data - Worker commands and related data
 	 */
 	function handleMessage (message: unknown): void {
@@ -184,7 +194,7 @@ const startNanoNaCl = (bytes: number[]): { derive: typeof derive, sign: typeof s
 				|| !('action' in message.data)
 				|| typeof message.data.action !== 'string'
 			) {
-				throw new TypeError('Invalid NanoNaClWorker request')
+				throw new TypeError('Invalid nano25519Worker request')
 			}
 			const data: Data = message.data as object & Record<"action", string>
 			if (data.action === 'start') {
@@ -197,27 +207,21 @@ const startNanoNaCl = (bytes: number[]): { derive: typeof derive, sign: typeof s
 				const { action } = data
 				if (action === 'derive') {
 					const { privateKey } = data
-					const privateKeyBytes = toBytes('private key', 32, privateKey)
-					const publicKeyBytes = derive(privateKeyBytes)
-					if (publicKeyBytes == null || !(publicKeyBytes instanceof Uint8Array) || publicKeyBytes.byteLength != 32) {
+					const publicKeyBytes = derive(privateKey)
+					if (publicKeyBytes == null) {
 						throw new TypeError('Invalid public key from WASM derive()')
 					}
 					result = publicKeyBytes
 				} else if (action === 'sign') {
 					const { message, secretKey } = data
-					const messageBytes = toBytes('message', typeof message === 'string' ? message.length >> 1 : 0, message)
-					const secretKeyBytes = toBytes('secret key', 64, secretKey)
-					const signature = sign(messageBytes, secretKeyBytes)
+					const signature = sign(message, secretKey)
 					if (signature == null) {
 						throw new TypeError('Invalid signature from WASM sign()')
 					}
 					result = signature
 				} else if (action === 'verify') {
 					const { message, publicKey, signature } = data
-					const signatureBytes = toBytes('signature', 64, signature)
-					const messageBytes = toBytes('message', typeof message === 'string' ? message.length >> 1 : 0, message)
-					const publicKeyBytes = toBytes('public key', 32, publicKey)
-					const verification = verify(signatureBytes, messageBytes, publicKeyBytes)
+					const verification = verify(signature, message, publicKey)
 					if (verification == null) {
 						throw new TypeError('Invalid verification from WASM verify()')
 					}
@@ -225,6 +229,11 @@ const startNanoNaCl = (bytes: number[]): { derive: typeof derive, sign: typeof s
 				}
 			}
 		} catch (err: unknown) {
+			let buffer: DataView | undefined = new DataView(exports.memory.buffer)
+			let inPtr = exports.getInputPointer()
+			for (let i = 0; i < 128; i++) {
+				buffer.setUint8(inPtr + i, 0)
+			}
 			if (typeof err === 'object' && err != null) {
 				const e = err as { [k: string]: unknown }
 				if (e.message !== 'divide by zero') {
@@ -252,6 +261,10 @@ const startNanoNaCl = (bytes: number[]): { derive: typeof derive, sign: typeof s
 	return { derive, sign, verify }
 }
 
+export const nano25519 = nano25519_init(nano25519_wasm)
+
+const nano25519_worker = `;(${nano25519_init})([${nano25519_wasm}]);`
+
 /**
  * Host code for asynchronous Web Worker
  */
@@ -263,24 +276,24 @@ let url: string
 // Create worker module
 function init (): void {
 	try {
-		url = URL.createObjectURL(new Blob([NanoNaClWorker], { type: 'text/javascript' }))
+		url = URL.createObjectURL(new Blob([nano25519_worker], { type: 'text/javascript' }))
 		BROWSER: worker = new Worker(url, { type: 'module' })
-		NODE: worker = new NodeWorker(NanoNaClWorker, {
+		NODE: worker = new NodeWorker(nano25519_worker, {
 			eval: true,
 			stderr: false,
 			stdout: false
 		})
-		console.log(`NanoNaCl initialized.`)
+		console.log(`nano25519 initialized.`)
 		isWorkerReady = true
 	} catch (err) {
 		isWorkerReady = false
-		throw new Error('NanoNaCl initialization failed.', { cause: err })
+		throw new Error('nano25519 initialization failed.', { cause: err })
 	}
 }
 
 // Reconstruct worker when errors occur
 function reset (): void {
-	console.warn(`NanoNaCl encountered an error. Reinitializing...`)
+	console.warn(`nano25519 encountered an error. Reinitializing...`)
 	isWorkerReady = false
 	worker.terminate()
 	init()
@@ -316,10 +329,16 @@ async function start (): Promise<void> {
 	}
 }
 
-// Send command and relevant data to NanoNaCl worker
-async function dispatch (data: { [key: string]: string | Uint8Array<ArrayBuffer> }): Promise<Uint8Array<ArrayBuffer>> {
+// Send command and relevant data to nano25519 worker
+async function dispatch (data: { [key: string]: string | ArrayBuffer | Uint8Array<ArrayBuffer> }): Promise<Uint8Array<ArrayBuffer>> {
 	return new Promise((resolve, reject) => {
-		const transfer: ArrayBuffer[] = Object.values(data).filter(v => v instanceof Uint8Array).map(({ buffer }) => buffer)
+		const transfer: ArrayBuffer[] = []
+		for (let k of Object.keys(data)) {
+			if (data[k] instanceof Uint8Array) {
+				data[k] = data[k].buffer.slice()
+				transfer.push(data[k])
+			}
+		}
 		const onresult = (msg: any): void => {
 			const result = msg.data
 			console.log(`received result from worker: `, result)
@@ -366,7 +385,7 @@ async function stop (): Promise<void> {
 	})
 }
 
-async function run (data: Record<string, string | Uint8Array<ArrayBuffer>>): Promise<string> {
+export async function run (data: Record<string, string | Uint8Array<ArrayBuffer>>): Promise<string | Uint8Array<ArrayBuffer>> {
 	try {
 		await start()
 	} catch (err: any) {
@@ -375,13 +394,14 @@ async function run (data: Record<string, string | Uint8Array<ArrayBuffer>>): Pro
 	}
 	try {
 		const result = await dispatch(data)
-		if (!(result instanceof Uint8Array)) {
+		if (typeof result !== 'boolean' && typeof result !== 'string' && !(result instanceof Uint8Array)) {
 			throw new Error(result)
 		}
-		return [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase()
+		return result
 	} catch (err: any) {
 		try {
 			console.error(err)
+			console.error(data)
 			await stop()
 		} catch (e: any) {
 			console.error('failed to stop worker', err?.message ?? err ?? 'unknown reason')
@@ -392,48 +412,20 @@ async function run (data: Record<string, string | Uint8Array<ArrayBuffer>>): Pro
 	}
 }
 
-const NanoNaCl = startNanoNaCl(nacl)
-const NanoNaClWorker = `;(${startNanoNaCl})([${nacl}]);`
-
-/**
- * Nano public key derivation using WebAssembly.
- * @param {Uint8Array<ArrayBuffer>} k - 32-byte private key
- * @returns 32-byte public key
- */
-export function derive (k: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer> {
-	return NanoNaCl.derive(k)
-}
-
-/**
- * Signing using WebAssembly. To sign Nano blocks, the message should be a
- * 32-byte block hash.
- * @param {Uint8Array<ArrayBuffer>} m - Variable-byte-length message up to 32 KiB
- * @param {Uint8Array<ArrayBuffer>} k - 64-byte secret key (prv + pub)
- * @returns 64-byte detached signature
- */
-export function sign (m: Uint8Array<ArrayBuffer>, k: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer> {
-	return NanoNaCl.sign(m, k)
-}
-
 /**
- * Signature verification using WebAssembly. To verify Nano block signatures,
- * the message should be a 64-character block hash.
- * @param {Uint8Array<ArrayBuffer>} s - 64-byte detached signature
- * @param {Uint8Array<ArrayBuffer>} m - Variable-byte-length message up to 32 KiB
- * @param {Uint8Array<ArrayBuffer>} k - 32-byte public key
- * @returns true if signature matches block hash and public key, else false
+ * Asynchronous Nano public key derivation using WebAssembly.
+ * @param {Uint8Array<ArrayBuffer>} k - 64-character private key hex string
+ * @returns Promise for 64-character public key hex string
  */
-export function verify (s: Uint8Array<ArrayBuffer>, m: Uint8Array<ArrayBuffer>, k: Uint8Array<ArrayBuffer>): boolean {
-	return NanoNaCl.verify(s, m, k)[0] === 0
-}
-
+export async function deriveAsync (privateKey: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>
 /**
  * Asynchronous Nano public key derivation using WebAssembly.
- * @param {Uint8Array<ArrayBuffer>} k - 64-character private key hex string
+ * @param {string} k - 64-character private key hex string
  * @returns Promise for 64-character public key hex string
  */
-export async function deriveAsync (privateKey: string): Promise<string> {
-	return await run({ action: 'derive', privateKey })
+export async function deriveAsync (privateKey: string): Promise<string>
+export async function deriveAsync (privateKey: string | Uint8Array<ArrayBuffer>): Promise<string | Uint8Array<ArrayBuffer>> {
+	return run({ action: 'derive', privateKey })
 }
 
 /**
@@ -443,8 +435,17 @@ export async function deriveAsync (privateKey: string): Promise<string> {
  * @param {Uint8Array<ArrayBuffer>} k - 128-character secret key (prv + pub) hex string
  * @returns Promise for 128-character detached signature hex string
  */
-export const signAsync = async function (message: string, secretKey: string): Promise<string> {
-	return await run({ action: 'sign', message, secretKey })
+export async function signAsync (message: Uint8Array<ArrayBuffer>, secretKey: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>
+/**
+ * Asynchronous signing using WebAssembly. To sign Nano blocks, the message
+ * should be a 64-character block hash.
+ * @param {Uint8Array<ArrayBuffer>} m - Variable-length message hex string up to 65536 characters
+ * @param {Uint8Array<ArrayBuffer>} k - 128-character secret key (prv + pub) hex string
+ * @returns Promise for 128-character detached signature hex string
+ */
+export async function signAsync (message: string, secretKey: string): Promise<string>
+export async function signAsync (message: string | Uint8Array<ArrayBuffer>, secretKey: string | Uint8Array<ArrayBuffer>): Promise<string | Uint8Array<ArrayBuffer>> {
+	return run({ action: 'sign', message, secretKey })
 }
 
 /**
@@ -455,6 +456,16 @@ export const signAsync = async function (message: string, secretKey: string): Pr
  * @param {Uint8Array<ArrayBuffer>} k - 64-character public key hex string
  * @returns Promise resolving to true if signature matches block hash and public key, else false
  */
-export const verifyAsync = async function (signature: string, message: string, publicKey: string): Promise<boolean> {
-	return await run({ action: 'verify', signature, message, publicKey }) === '00'
+export async function verifyAsync (signature: Uint8Array<ArrayBuffer>, message: Uint8Array<ArrayBuffer>, publicKey: Uint8Array<ArrayBuffer>): Promise<boolean>
+/**
+ * Asynchronous signature verification using WebAssembly. To verify Nano block
+ * signatures, the message should be a 64-character block hash.
+ * @param {Uint8Array<ArrayBuffer>} s - 128-character detached signature hex string
+ * @param {Uint8Array<ArrayBuffer>} m - Variable-length message hex string to up 65536 characters
+ * @param {Uint8Array<ArrayBuffer>} k - 64-character public key hex string
+ * @returns Promise resolving to true if signature matches block hash and public key, else false
+ */
+export async function verifyAsync (signature: string, message: string, publicKey: string): Promise<boolean>
+export async function verifyAsync (signature: string | Uint8Array<ArrayBuffer>, message: string | Uint8Array<ArrayBuffer>, publicKey: string | Uint8Array<ArrayBuffer>): Promise<boolean> {
+	return !!(await run({ action: 'verify', signature, message, publicKey }))
 }
diff --git a/src/sync.ts b/src/sync.ts
new file mode 100644
index 0000000..1125afb
--- /dev/null
+++ b/src/sync.ts
@@ -0,0 +1,62 @@
+//! SPDX-FileCopyrightText: 2026 Chris Duncan <chris@codecow.com>
+//! SPDX-License-Identifier: GPL-3.0-or-later
+
+import { nano25519 } from "./nano25519"
+
+/**
+ * Nano public key derivation using WebAssembly.
+ * @param {string} k - 64-character hexadecimal private key
+ * @returns 64-character hexadecimal public key
+ */
+export function derive (k: string): string
+/**
+ * Nano public key derivation using WebAssembly.
+ * @param {Uint8Array<ArrayBuffer>} k - 32-byte private key
+ * @returns 32-byte public key
+ */
+export function derive (k: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>
+export function derive (k: string | Uint8Array<ArrayBuffer>): string | Uint8Array<ArrayBuffer> {
+	return nano25519.derive(k)
+}
+
+/**
+ * Signing using WebAssembly. To sign Nano blocks, the message should be a
+ * 64-character hexadecimal block hash.
+ * @param {string} m - Variable-length hexadecimal message up to 32 KiB
+ * @param {string} k - 128-character hexadecimal secret key (prv + pub)
+ * @returns 128-character hexadecimal detached signature
+ */
+export function sign (m: string, k: string): string
+/**
+ * Signing using WebAssembly. To sign Nano blocks, the message should be a
+ * 32-byte block hash.
+ * @param {Uint8Array<ArrayBuffer>} m - Variable-byte-length message up to 32 KiB
+ * @param {Uint8Array<ArrayBuffer>} k - 64-byte secret key (prv + pub)
+ * @returns 64-byte detached signature
+ */
+export function sign (m: Uint8Array<ArrayBuffer>, k: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>
+export function sign (m: string | Uint8Array<ArrayBuffer>, k: string | Uint8Array<ArrayBuffer>): string | Uint8Array<ArrayBuffer> {
+	return nano25519.sign(m, k)
+}
+
+/**
+ * Signature verification using WebAssembly. To verify Nano block signatures,
+ * the message should be a 64-character block hash.
+ * @param {string} s - 128-character hexadecimal detached signature
+ * @param {string} m - Variable-length message up to 32 KiB
+ * @param {string} k - 64-character hexadecimal public key
+ * @returns true if signature matches block hash and public key, else false
+ */
+export function verify (s: string, m: string, k: string): boolean
+/**
+ * Signature verification using WebAssembly. To verify Nano block signatures,
+ * the message should be a 64-character block hash.
+ * @param {Uint8Array<ArrayBuffer>} s - 64-byte detached signature
+ * @param {Uint8Array<ArrayBuffer>} m - Variable-byte-length message up to 32 KiB
+ * @param {Uint8Array<ArrayBuffer>} k - 32-byte public key
+ * @returns true if signature matches block hash and public key, else false
+ */
+export function verify (s: Uint8Array<ArrayBuffer>, m: Uint8Array<ArrayBuffer>, k: Uint8Array<ArrayBuffer>): boolean
+export function verify (s: string | Uint8Array<ArrayBuffer>, m: string | Uint8Array<ArrayBuffer>, k: string | Uint8Array<ArrayBuffer>): boolean {
+	return nano25519.verify(s, m, k)
+}
diff --git a/test.mjs b/test.mjs
index 85af858..2332566 100644
--- a/test.mjs
+++ b/test.mjs
@@ -1,7 +1,9 @@
 //! SPDX-FileCopyrightText: 2026 Chris Duncan <chris@codecow.com>
 //! SPDX-License-Identifier: GPL-3.0-or-later
 
-import { derive, deriveAsync, sign, signAsync, verify, verifyAsync } from 'nano-nacl'
+import * as Nano25519 from 'nano25519'
+import { derive, sign, verify } from 'nano25519/sync'
+import { deriveAsync, signAsync, verifyAsync } from 'nano25519/async'
 import { NANO_ORG_VECTOR, PYTHON_ED25519_BLAKE2B_VECTORS } from './vectors.mjs'
 
 /**
@@ -17,46 +19,143 @@ function check (name, test) {
 
 let result, test, passes = 0, failures = 0
 
-/**
- * @type {any} result
- */
+// Check combined imports
+result = await Nano25519.deriveAsync(NANO_ORG_VECTOR.privateKeyBytes)
+console.log(`RESULT`, result)
+test = [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase() === NANO_ORG_VECTOR.publicKey.toLowerCase()
+check(`async derive from ${NANO_ORG_VECTOR.privateKey}`, test)
+passes += +test
+failures += +!test
+
+result = await Nano25519.signAsync(NANO_ORG_VECTOR.blockHashBytes, NANO_ORG_VECTOR.secretKeyBytes)
+test = [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase() === NANO_ORG_VECTOR.signature.toLowerCase()
+check(`async sign message ${NANO_ORG_VECTOR.blockHash}`, test)
+passes += +test
+failures += +!test
+
+result = await Nano25519.verifyAsync(NANO_ORG_VECTOR.signatureBytes, NANO_ORG_VECTOR.blockHashBytes, NANO_ORG_VECTOR.publicKeyBytes)
+test = result === true
+check(`async verify signature ${NANO_ORG_VECTOR.signature}`, test)
+passes += +test
+failures += +!test
+
+result = Nano25519.derive(NANO_ORG_VECTOR.privateKeyBytes)
+test = [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase() === NANO_ORG_VECTOR.publicKey.toLowerCase()
+check(`derive from ${NANO_ORG_VECTOR.privateKey}`, test)
+passes += +test
+failures += +!test
+
+result = Nano25519.sign(NANO_ORG_VECTOR.blockHashBytes, NANO_ORG_VECTOR.secretKeyBytes)
+test = [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase() === NANO_ORG_VECTOR.signature.toLowerCase()
+check(`sign message ${NANO_ORG_VECTOR.blockHash}`, test)
+passes += +test
+failures += +!test
+
+result = Nano25519.verify(NANO_ORG_VECTOR.signatureBytes, NANO_ORG_VECTOR.blockHashBytes, NANO_ORG_VECTOR.publicKeyBytes)
+test = result === true
+check(`verify signature ${NANO_ORG_VECTOR.signature}`, test)
+passes += +test
+failures += +!test
+
+// Check async imports with string inputs
 result = await deriveAsync(NANO_ORG_VECTOR.privateKey)
 test = result.toLowerCase() === NANO_ORG_VECTOR.publicKey.toLowerCase()
-check(`async derive from ${NANO_ORG_VECTOR.privateKey}`, test)
+console.log(result)
+console.log()
+check(`async derive from private key string ${NANO_ORG_VECTOR.privateKey}`, test)
 passes += +test
 failures += +!test
 
 result = await signAsync(NANO_ORG_VECTOR.blockHash, NANO_ORG_VECTOR.secretKey)
 test = result.toLowerCase() === NANO_ORG_VECTOR.signature.toLowerCase()
-check(`async sign message ${NANO_ORG_VECTOR.blockHash}`, test)
+check(`async sign message string ${NANO_ORG_VECTOR.blockHash}`, test)
 passes += +test
 failures += +!test
 
 result = await verifyAsync(NANO_ORG_VECTOR.signature, NANO_ORG_VECTOR.blockHash, NANO_ORG_VECTOR.publicKey)
 test = result === true
-check(`async verify signature ${NANO_ORG_VECTOR.signature}`, test)
+check(`async verify signature string ${NANO_ORG_VECTOR.signature}`, test)
+passes += +test
+failures += +!test
+
+// Check async imports with byte inputs
+result = await deriveAsync(NANO_ORG_VECTOR.privateKeyBytes)
+console.log(`RESULT`, result)
+test = [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase() === NANO_ORG_VECTOR.publicKey.toLowerCase()
+check(`async derive from private key bytes ${NANO_ORG_VECTOR.privateKey}`, test)
+passes += +test
+failures += +!test
+
+result = await signAsync(NANO_ORG_VECTOR.blockHashBytes, NANO_ORG_VECTOR.secretKeyBytes)
+test = [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase() === NANO_ORG_VECTOR.signature.toLowerCase()
+check(`async sign message bytes ${NANO_ORG_VECTOR.blockHash}`, test)
+passes += +test
+failures += +!test
+
+result = await verifyAsync(NANO_ORG_VECTOR.signatureBytes, NANO_ORG_VECTOR.blockHashBytes, NANO_ORG_VECTOR.publicKeyBytes)
+test = result === true
+check(`async verify signature bytes ${NANO_ORG_VECTOR.signature}`, test)
+passes += +test
+failures += +!test
+
+// Check sync imports with string inputs
+result = derive(NANO_ORG_VECTOR.privateKey)
+test = result.toLowerCase() === NANO_ORG_VECTOR.publicKey.toLowerCase()
+check(`derive from private key string ${NANO_ORG_VECTOR.privateKey}`, test)
+passes += +test
+failures += +!test
+
+result = sign(NANO_ORG_VECTOR.blockHash, NANO_ORG_VECTOR.secretKey)
+test = result.toLowerCase() === NANO_ORG_VECTOR.signature.toLowerCase()
+check(`sign message string ${NANO_ORG_VECTOR.blockHash}`, test)
+passes += +test
+failures += +!test
+
+result = verify(NANO_ORG_VECTOR.signature, NANO_ORG_VECTOR.blockHash, NANO_ORG_VECTOR.publicKey)
+test = result === true
+check(`verify signature string ${NANO_ORG_VECTOR.signature}`, test)
 passes += +test
 failures += +!test
 
+// Check sync imports with byte inputs
 result = derive(NANO_ORG_VECTOR.privateKeyBytes)
 test = [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase() === NANO_ORG_VECTOR.publicKey.toLowerCase()
-check(`derive from ${NANO_ORG_VECTOR.privateKey}`, test)
+check(`derive from private key string ${NANO_ORG_VECTOR.privateKey}`, test)
 passes += +test
 failures += +!test
 
 result = sign(NANO_ORG_VECTOR.blockHashBytes, NANO_ORG_VECTOR.secretKeyBytes)
 test = [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase() === NANO_ORG_VECTOR.signature.toLowerCase()
-check(`sign message ${NANO_ORG_VECTOR.blockHash}`, test)
+check(`sign message string ${NANO_ORG_VECTOR.blockHash}`, test)
 passes += +test
 failures += +!test
 
 result = verify(NANO_ORG_VECTOR.signatureBytes, NANO_ORG_VECTOR.blockHashBytes, NANO_ORG_VECTOR.publicKeyBytes)
 test = result === true
-check(`verify signature ${NANO_ORG_VECTOR.signature}`, test)
+check(`verify signature string ${NANO_ORG_VECTOR.signature}`, test)
 passes += +test
 failures += +!test
 
+// test both string inputs and byte inputs
 for (const { privateKey, publicKey, message, signature } of PYTHON_ED25519_BLAKE2B_VECTORS) {
+	result = derive(privateKey)
+	test = result.toLowerCase() === publicKey
+	check(`derive from private key string ${privateKey}`, test)
+	passes += +test
+	failures += +!test
+
+	result = sign(message, privateKey + publicKey)
+	test = result.toLowerCase() === signature.slice(0, 128)
+	check(`sign message string ${message}`, test)
+	passes += +test
+	failures += +!test
+
+	result = verify(signature.slice(0, 128), message, publicKey)
+	test = result === true
+	check(`verify signature string ${signature.slice(0, 128)}`, test)
+	passes += +test
+	failures += +!test
+
 	const privateKeyBytes = new Uint8Array(privateKey.match(/.{2}/g)?.map(b => parseInt(b, 16)) ?? [])
 	const publicKeyBytes = new Uint8Array(publicKey.match(/.{2}/g)?.map(b => parseInt(b, 16)) ?? [])
 	const secretKeyBytes = new Uint8Array([...privateKeyBytes, ...publicKeyBytes])
@@ -65,19 +164,19 @@ for (const { privateKey, publicKey, message, signature } of PYTHON_ED25519_BLAKE
 
 	result = derive(privateKeyBytes)
 	test = [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase() === publicKey
-	check(`derive from ${privateKey}`, test)
+	check(`derive from private key bytes ${privateKey}`, test)
 	passes += +test
 	failures += +!test
 
 	result = sign(messageBytes, secretKeyBytes)
 	test = [...result].map(b => b.toString(16).padStart(2, '0')).join('').toLowerCase() === signature.slice(0, 128)
-	check(`sign message ${message}`, test)
+	check(`sign message bytes ${message}`, test)
 	passes += +test
 	failures += +!test
 
 	result = verify(signatureBytes, messageBytes, publicKeyBytes)
 	test = result === true
-	check(`verify signature ${signature.slice(0, 128)}`, test)
+	check(`verify signature bytes ${signature.slice(0, 128)}`, test)
 	passes += +test
 	failures += +!test
 }
diff --git a/tsconfig.json b/tsconfig.json
index 1bf8ee1..4513fd8 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -17,6 +17,11 @@
 			"ESNext"
 		]
 	},
+	"include": [
+		"src/index.ts",
+		"src/async.ts",
+		"src/sync.ts"
+	],
 	"exclude": [
 		"assembly",
 		"dist"