@qntx/wallet-worker 0.4.0 → 0.5.1

package/dist/node.mjs

@@ -1,6 +1,9 @@
 import { WalletError } from "@qntx/wallet";
 import { PASSKEY_PURPOSE_VAULT, PASSKEY_PURPOSE_WALLET, connectKernel } from "@qntx/wallet/host";
 import { MessageChannel, Worker } from "node:worker_threads";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, concatBytes, utf8ToBytes } from "@noble/hashes/utils.js";
+import { hmac } from "@noble/hashes/hmac.js";
 //#region ../wallet-kernel/src/errors.ts
 /**
 * The only error type kernel code throws. Its code is the public `WalletErrorCode`: the kernel
@@ -24,765 +27,6 @@ var KernelError = class extends Error {
 	}
 };
 //#endregion
-//#region ../../node_modules/.bun/@noble+hashes@2.4.0/node_modules/@noble/hashes/utils.js
-/**
-* Checks if something is Uint8Array. Be careful: nodejs Buffer will return true.
-* @param a - value to test
-* @returns `true` when the value is a Uint8Array-compatible view.
-* @example
-* Check whether a value is a Uint8Array-compatible view.
-* ```ts
-* isBytes(new Uint8Array([1, 2, 3]));
-* ```
-*/
-function isBytes(a) {
-	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
-}
-const atitle = (title) => title ? `"${title}" ` : "";
-/**
-* Asserts something is a non-negative integer.
-* @param n - number to validate
-* @param title - label included in thrown errors
-* @returns The validated number.
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Validate a non-negative integer option.
-* ```ts
-* anumber(32, 'length');
-* ```
-*/
-function anumber(n, title = "") {
-	if (typeof n !== "number") throw new TypeError(atitle(title) + "expected number, got " + typeof n);
-	if (!Number.isSafeInteger(n) || n < 0) throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
-	return n;
-}
-/**
-* Asserts something is Uint8Array.
-* @param value - value to validate
-* @param length - optional exact length constraint
-* @param title - label included in thrown errors
-* @returns The validated byte array.
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Validate that a value is a byte array.
-* ```ts
-* abytes(new Uint8Array([1, 2, 3]));
-* ```
-*/
-function abytes(value, length, title = "") {
-	if (isBytes(value) && (length === void 0 || value.length === length)) return value;
-	if (length !== void 0) anumber(length, "length");
-	const bytes = isBytes(value);
-	const ofLen = length !== void 0 ? ` of length ${length}` : "";
-	const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
-	const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
-	if (!bytes) throw new TypeError(message);
-	throw new RangeError(message);
-}
-/**
-* Asserts something is a wrapped hash constructor.
-* @param h - hash constructor to validate
-* @throws On wrong argument types or invalid hash wrapper shape. {@link TypeError}
-* @throws On invalid hash metadata ranges or values. {@link RangeError}
-* @throws If the hash metadata allows empty outputs or block sizes. {@link Error}
-* @example
-* Validate a callable hash wrapper.
-* ```ts
-* import { ahash } from '@noble/hashes/utils.js';
-* import { sha256 } from '@noble/hashes/sha2.js';
-* ahash(sha256);
-* ```
-*/
-function ahash(h) {
-	if (typeof h !== "function" || typeof h.create !== "function") throw new TypeError("expected hash wrapped by utils.createHasher");
-	anumber(h.outputLen);
-	anumber(h.blockLen);
-	if (h.outputLen < 1 || h.blockLen < 1) throw new Error("hash blockLen / outputLen must be >= 1");
-}
-const aobject = (value, label) => {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError((label === "object" ? "" : `"${label}" `) + "expected object, got type=" + typeof value);
-};
-const aopts = (value, label) => {
-	aobject(value, label);
-	const proto = Object.getPrototypeOf(value);
-	if (proto !== Object.prototype && proto !== null) throw new TypeError(`"${label}" expected plain object`);
-	if (Object.hasOwn(value, "__proto__")) throw new TypeError(`"${label}.__proto__" is not allowed`);
-};
-/**
-* Asserts a hash instance has not been destroyed or finished.
-* @param instance - hash instance to validate
-* @param checkFinished - whether to reject finalized instances
-* @throws If the hash instance has already been destroyed or finalized. {@link Error}
-* @example
-* Validate that a hash instance is still usable.
-* ```ts
-* import { aexists } from '@noble/hashes/utils.js';
-* import { sha256 } from '@noble/hashes/sha2.js';
-* const hash = sha256.create();
-* aexists(hash);
-* ```
-*/
-function aexists(instance, checkFinished = true) {
-	if (instance.destroyed) throw new Error("hash was destroyed");
-	if (checkFinished && instance.finished) throw new Error("digest() was already called");
-}
-/**
-* Asserts output is a sufficiently-sized byte array.
-* @param out - destination buffer
-* @param instance - hash instance providing output length
-* Oversized buffers are allowed; downstream code only promises to fill the first `outputLen` bytes.
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Validate a caller-provided digest buffer.
-* ```ts
-* import { aoutput } from '@noble/hashes/utils.js';
-* import { sha256 } from '@noble/hashes/sha2.js';
-* const hash = sha256.create();
-* aoutput(new Uint8Array(hash.outputLen), hash);
-* ```
-*/
-function aoutput(out, instance) {
-	abytes(out, void 0, "output");
-	const min = instance.outputLen;
-	if (!(out.length >= min)) throw new RangeError("\"output\" expected length >= " + min);
-}
-/**
-* Zeroizes typed arrays in place. Warning: JS provides no guarantees.
-* @param arrays - arrays to overwrite with zeros
-* @example
-* Zeroize sensitive buffers in place.
-* ```ts
-* clean(new Uint8Array([1, 2, 3]));
-* ```
-*/
-function clean(...arrays) {
-	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
-}
-/**
-* Creates a DataView for byte-level manipulation.
-* @param arr - source typed array
-* @returns DataView over the same buffer region.
-* @example
-* Create a DataView over an existing buffer.
-* ```ts
-* createView(new Uint8Array(4));
-* ```
-*/
-function createView(arr) {
-	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-/**
-* Rotate-right operation for uint32 values.
-* @param word - source word
-* @param shift - shift amount in bits
-* @returns Rotated word.
-* @example
-* Rotate a 32-bit word to the right.
-* ```ts
-* rotr(0x12345678, 8);
-* ```
-*/
-function rotr(word, shift) {
-	return word << 32 - shift | word >>> shift;
-}
-const hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
-const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-/**
-* Convert byte array to hex string.
-* Uses the built-in function when available and assumes it matches the tested
-* fallback semantics.
-* @param bytes - bytes to encode
-* @returns Lowercase hexadecimal string.
-* @throws On wrong argument types. {@link TypeError}
-* @example
-* Convert bytes to lowercase hexadecimal.
-* ```ts
-* bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])); // 'cafe0123'
-* ```
-*/
-function bytesToHex(bytes) {
-	abytes(bytes);
-	if (hasHexBuiltin) return bytes.toHex();
-	let hex = "";
-	for (let i = 0; i < bytes.length; i++) hex += hexes[bytes[i]];
-	return hex;
-}
-/**
-* Converts string to bytes using UTF8 encoding.
-* Built-in doesn't validate input to be string: we do the check.
-* Non-ASCII details are delegated to the platform `TextEncoder`.
-* @param str - string to encode
-* @returns UTF-8 encoded bytes.
-* @throws On wrong argument types. {@link TypeError}
-* @example
-* Encode a string as UTF-8 bytes.
-* ```ts
-* utf8ToBytes('abc'); // Uint8Array.from([97, 98, 99])
-* ```
-*/
-function utf8ToBytes(str) {
-	if (typeof str !== "string") throw new TypeError("string expected");
-	const encoded = new TextEncoder().encode(str);
-	try {
-		return new Uint8Array(encoded);
-	} finally {
-		clean(encoded);
-	}
-}
-/**
-* Copies several Uint8Arrays into one.
-* @param arrays - arrays to concatenate
-* @returns Concatenated byte array.
-* @throws On wrong argument types. {@link TypeError}
-* @example
-* Concatenate multiple byte arrays.
-* ```ts
-* concatBytes(new Uint8Array([1]), new Uint8Array([2]));
-* ```
-*/
-function concatBytes(...arrays) {
-	let sum = 0;
-	for (let i = 0; i < arrays.length; i++) {
-		const a = arrays[i];
-		abytes(a);
-		sum += a.length;
-	}
-	const res = new Uint8Array(sum);
-	for (let i = 0, pad = 0; i < arrays.length; i++) {
-		const a = arrays[i];
-		res.set(a, pad);
-		pad += a.length;
-	}
-	return res;
-}
-/**
-* Merges default options and passed options.
-* @param defaults - base option object
-* @param opts - user overrides
-* @param title - label included in thrown override errors
-* @returns Fresh merged option object with a null prototype.
-* @throws On wrong argument types. {@link TypeError}
-* @example
-* Merge user overrides onto default options.
-* ```ts
-* checkOpts({ dkLen: 32 }, { asyncTick: 10 });
-* ```
-*/
-function checkOpts(defaults, opts, title = "opts") {
-	aopts(defaults, "defaults");
-	if (opts !== void 0) aopts(opts, title);
-	return Object.assign(Object.create(null), defaults, opts);
-}
-/**
-* Creates a callable hash function from a stateful class constructor.
-* @param hashCons - hash constructor or factory
-* @param info - optional metadata such as DER OID
-* @returns Frozen callable hash wrapper with `.create()`.
-*   Wrapper construction eagerly calls `hashCons(undefined)` once to read
-*   `outputLen` / `blockLen`, so constructor side effects happen at module
-*   init time.
-* @throws On wrong argument types. {@link TypeError}
-* @example
-* Wrap a stateful hash constructor into a callable helper.
-* ```ts
-* import { createHasher } from '@noble/hashes/utils.js';
-* import { sha256 } from '@noble/hashes/sha2.js';
-* const wrapped = createHasher(sha256.create, { oid: sha256.oid });
-* wrapped(new Uint8Array([1]));
-* ```
-*/
-function createHasher(hashCons, info = {}) {
-	if (typeof hashCons !== "function") throw new TypeError("\"hashCons\" expected function, got type=" + typeof hashCons);
-	info = checkOpts({}, info, "info");
-	const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
-	const tmp = hashCons(void 0);
-	hashC.outputLen = tmp.outputLen;
-	hashC.blockLen = tmp.blockLen;
-	hashC.canXOF = tmp.canXOF;
-	hashC.create = (opts) => hashCons(opts);
-	Object.assign(hashC, info);
-	return Object.freeze(hashC);
-}
-/**
-* Creates OID metadata for NIST hashes with prefix `06 09 60 86 48 01 65 03 04 02`.
-* @param suffix - final OID byte for the selected hash.
-*   The helper accepts any byte even though only the documented NIST hash
-*   suffixes are meaningful downstream.
-* @returns Object containing the DER-encoded OID.
-* @example
-* Build OID metadata for a NIST hash.
-* ```ts
-* oidNist(0x01);
-* ```
-*/
-const oidNist = (suffix) => ({ oid: Uint8Array.from([
-	6,
-	9,
-	96,
-	134,
-	72,
-	1,
-	101,
-	3,
-	4,
-	2,
-	suffix
-]) });
-//#endregion
-//#region ../../node_modules/.bun/@noble+hashes@2.4.0/node_modules/@noble/hashes/hmac.js
-/**
-* HMAC: RFC2104 message authentication code.
-* @module
-*/
-/**
-* Internal class for HMAC.
-* Accepts any byte key, although RFC 2104 §3 recommends keys at least
-* `HashLen` bytes long.
-*/
-var _HMAC = class {
-	oHash;
-	iHash;
-	blockLen;
-	outputLen;
-	canXOF = false;
-	finished = false;
-	destroyed = false;
-	constructor(hash, key) {
-		ahash(hash);
-		abytes(key, void 0, "key");
-		this.iHash = hash.create();
-		if (typeof this.iHash.update !== "function") throw new Error("expected Hash instance");
-		this.blockLen = this.iHash.blockLen;
-		this.outputLen = this.iHash.outputLen;
-		const blockLen = this.blockLen;
-		const pad = new Uint8Array(blockLen);
-		pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
-		for (let i = 0; i < pad.length; i++) pad[i] ^= 54;
-		this.iHash.update(pad);
-		this.oHash = hash.create();
-		for (let i = 0; i < pad.length; i++) pad[i] ^= 106;
-		this.oHash.update(pad);
-		clean(pad);
-	}
-	update(buf) {
-		aexists(this);
-		this.iHash.update(buf);
-		return this;
-	}
-	digestInto(out) {
-		aexists(this);
-		aoutput(out, this);
-		this.finished = true;
-		const buf = out.subarray(0, this.outputLen);
-		this.iHash.digestInto(buf);
-		this.oHash.update(buf);
-		this.oHash.digestInto(buf);
-		this.destroy();
-	}
-	digest() {
-		const out = new Uint8Array(this.oHash.outputLen);
-		this.digestInto(out);
-		return out;
-	}
-	_cloneInto(to) {
-		to ||= Object.create(Object.getPrototypeOf(this), {});
-		const { oHash, iHash, finished, destroyed, blockLen, outputLen, canXOF } = this;
-		to = to;
-		to.finished = finished;
-		to.destroyed = destroyed;
-		to.blockLen = blockLen;
-		to.outputLen = outputLen;
-		to.canXOF = canXOF;
-		to.oHash = oHash._cloneInto(to.oHash);
-		to.iHash = iHash._cloneInto(to.iHash);
-		return to;
-	}
-	clone() {
-		return this._cloneInto();
-	}
-	destroy() {
-		this.destroyed = true;
-		this.oHash.destroy();
-		this.iHash.destroy();
-	}
-};
-const hmac = /* @__PURE__ */ (() => {
-	const hmac_ = ((hash, key, message) => new _HMAC(hash, key).update(message).digest());
-	hmac_.create = (hash, key) => new _HMAC(hash, key);
-	return hmac_;
-})();
-//#endregion
-//#region ../../node_modules/.bun/@noble+hashes@2.4.0/node_modules/@noble/hashes/_u64.js
-const fromNumH = (n) => n / 2 ** 32 | 0;
-const fromNumL = (n) => n >>> 0;
-function setU64FromNum(view, byteOffset, n, isLE) {
-	const h = fromNumH(n);
-	const l = fromNumL(n);
-	view.setUint32(byteOffset, isLE ? l : h, isLE);
-	view.setUint32(byteOffset + 4, isLE ? h : l, isLE);
-}
-//#endregion
-//#region ../../node_modules/.bun/@noble+hashes@2.4.0/node_modules/@noble/hashes/_md.js
-/**
-* Internal Merkle-Damgard hash utils.
-* @module
-*/
-/**
-* Shared 32-bit conditional boolean primitive reused by SHA-256, SHA-1, and MD5 `F`.
-* Returns bits from `b` when `a` is set, otherwise from `c`.
-* The XOR form is equivalent to MD5's `F(X,Y,Z) = XY v not(X)Z` because the masked terms never
-* set the same bit.
-* @param a - selector word
-* @param b - word chosen when selector bit is set
-* @param c - word chosen when selector bit is clear
-* @returns Mixed 32-bit word.
-* @example
-* Combine three words with the shared 32-bit choice primitive.
-* ```ts
-* Chi(0xffffffff, 0x12345678, 0x87654321);
-* ```
-*/
-function Chi(a, b, c) {
-	return a & b ^ ~a & c;
-}
-/**
-* Shared 32-bit majority primitive reused by SHA-256 and SHA-1.
-* Returns bits shared by at least two inputs.
-* @param a - first input word
-* @param b - second input word
-* @param c - third input word
-* @returns Mixed 32-bit word.
-* @example
-* Combine three words with the shared 32-bit majority primitive.
-* ```ts
-* Maj(0xffffffff, 0x12345678, 0x87654321);
-* ```
-*/
-function Maj(a, b, c) {
-	return a & b ^ a & c ^ b & c;
-}
-/**
-* Merkle-Damgard hash construction base class.
-* Could be used to create MD5, RIPEMD, SHA1, SHA2.
-* Accepts only byte-aligned `Uint8Array` input, even when the underlying spec describes bit
-* strings with partial-byte tails.
-* @param blockLen - internal block size in bytes
-* @param outputLen - digest size in bytes
-* @param padOffset - trailing length field size in bytes
-* @param isLE - whether length and state words are encoded in little-endian
-* @example
-* Use a concrete subclass to get the shared Merkle-Damgard update/digest flow.
-* ```ts
-* import { _SHA1 } from '@noble/hashes/legacy.js';
-* const hash = new _SHA1();
-* hash.update(new Uint8Array([97, 98, 99]));
-* hash.digest();
-* ```
-*/
-var HashMD = class {
-	blockLen;
-	outputLen;
-	canXOF = false;
-	padOffset;
-	isLE;
-	buffer;
-	view;
-	finished = false;
-	length = 0;
-	pos = 0;
-	destroyed = false;
-	constructor(blockLen, outputLen, padOffset, isLE) {
-		this.blockLen = blockLen;
-		this.outputLen = outputLen;
-		this.padOffset = padOffset;
-		this.isLE = isLE;
-		this.buffer = new Uint8Array(blockLen);
-		this.view = createView(this.buffer);
-	}
-	update(data) {
-		aexists(this);
-		abytes(data);
-		const { view, buffer, blockLen } = this;
-		const len = data.length;
-		let processed = false;
-		for (let pos = 0; pos < len;) {
-			const take = Math.min(blockLen - this.pos, len - pos);
-			if (take === blockLen) {
-				const dataView = createView(data);
-				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
-				processed = true;
-				continue;
-			}
-			buffer.set(pos === 0 && take === len ? data : data.subarray(pos, pos + take), this.pos);
-			this.pos += take;
-			pos += take;
-			if (this.pos === blockLen) {
-				this.process(view, 0);
-				this.pos = 0;
-				processed = true;
-			}
-		}
-		this.length += data.length;
-		if (processed) this.roundClean();
-		return this;
-	}
-	digestInto(out) {
-		aexists(this);
-		aoutput(out, this);
-		this.finished = true;
-		const { buffer, view, blockLen, isLE } = this;
-		let { pos } = this;
-		buffer[pos++] = 128;
-		buffer.fill(0, pos);
-		if (this.padOffset > blockLen - pos) {
-			this.process(view, 0);
-			buffer.fill(0);
-		}
-		setU64FromNum(view, blockLen - 8, this.length * 8, isLE);
-		this.process(view, 0);
-		this.roundClean();
-		const oview = out === buffer ? view : createView(out);
-		const len = this.outputLen;
-		const outLen = len / 4;
-		const state = this.get();
-		if (len % 4 || outLen > state.length) throw new Error("invalid outputLen");
-		for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
-	}
-	digest() {
-		const { buffer, outputLen } = this;
-		this.digestInto(buffer);
-		const res = buffer.slice(0, outputLen);
-		this.destroy();
-		return res;
-	}
-	_cloneIntoMeta(to) {
-		const { buffer, length, finished, destroyed, pos } = this;
-		to.destroyed = destroyed;
-		to.finished = finished;
-		to.length = length;
-		to.pos = pos;
-		if (pos) to.buffer.set(buffer);
-		return to;
-	}
-	clone() {
-		return this._cloneInto();
-	}
-};
-/**
-* Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
-* Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
-*/
-/** Initial SHA256 state from RFC 6234 §6.1: the first 32 bits of the fractional parts of the
-* square roots of the first eight prime numbers. Exported as a shared table; callers must treat
-* it as read-only because constructors copy words from it by index. */
-const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
-	1779033703,
-	3144134277,
-	1013904242,
-	2773480762,
-	1359893119,
-	2600822924,
-	528734635,
-	1541459225
-]);
-//#endregion
-//#region ../../node_modules/.bun/@noble+hashes@2.4.0/node_modules/@noble/hashes/sha2.js
-/**
-* SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
-* SHA256 is the fastest hash implementable in JS, even faster than Blake3.
-* Check out {@link https://www.rfc-editor.org/rfc/rfc4634 | RFC 4634} and
-* {@link https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf | FIPS 180-4}.
-* @module
-*/
-/**
-* SHA-224 / SHA-256 round constants from RFC 6234 §5.1: the first 32 bits
-* of the cube roots of the first 64 primes (2..311).
-*/
-const SHA256_K = /* @__PURE__ */ Uint32Array.from([
-	1116352408,
-	1899447441,
-	3049323471,
-	3921009573,
-	961987163,
-	1508970993,
-	2453635748,
-	2870763221,
-	3624381080,
-	310598401,
-	607225278,
-	1426881987,
-	1925078388,
-	2162078206,
-	2614888103,
-	3248222580,
-	3835390401,
-	4022224774,
-	264347078,
-	604807628,
-	770255983,
-	1249150122,
-	1555081692,
-	1996064986,
-	2554220882,
-	2821834349,
-	2952996808,
-	3210313671,
-	3336571891,
-	3584528711,
-	113926993,
-	338241895,
-	666307205,
-	773529912,
-	1294757372,
-	1396182291,
-	1695183700,
-	1986661051,
-	2177026350,
-	2456956037,
-	2730485921,
-	2820302411,
-	3259730800,
-	3345764771,
-	3516065817,
-	3600352804,
-	4094571909,
-	275423344,
-	430227734,
-	506948616,
-	659060556,
-	883997877,
-	958139571,
-	1322822218,
-	1537002063,
-	1747873779,
-	1955562222,
-	2024104815,
-	2227730452,
-	2361852424,
-	2428436474,
-	2756734187,
-	3204031479,
-	3329325298
-]);
-/** Reusable SHA-224 / SHA-256 message schedule buffer `W_t` from RFC 6234 §6.2 step 1. */
-const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-/** Internal SHA-224 / SHA-256 compression engine from RFC 6234 §6.2. */
-var SHA2_32B = class extends HashMD {
-	A = 0;
-	B = 0;
-	C = 0;
-	D = 0;
-	E = 0;
-	F = 0;
-	G = 0;
-	H = 0;
-	constructor(outputLen, IV) {
-		super(64, outputLen, 8, false);
-		this.A = IV[0] | 0;
-		this.B = IV[1] | 0;
-		this.C = IV[2] | 0;
-		this.D = IV[3] | 0;
-		this.E = IV[4] | 0;
-		this.F = IV[5] | 0;
-		this.G = IV[6] | 0;
-		this.H = IV[7] | 0;
-	}
-	get() {
-		const { A, B, C, D, E, F, G, H } = this;
-		return [
-			A,
-			B,
-			C,
-			D,
-			E,
-			F,
-			G,
-			H
-		];
-	}
-	set(A, B, C, D, E, F, G, H) {
-		this.A = A | 0;
-		this.B = B | 0;
-		this.C = C | 0;
-		this.D = D | 0;
-		this.E = E | 0;
-		this.F = F | 0;
-		this.G = G | 0;
-		this.H = H | 0;
-	}
-	_cloneInto(to) {
-		(to ||= new this.constructor()).set(...this.get());
-		return this._cloneIntoMeta(to);
-	}
-	process(view, offset) {
-		for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
-		for (let i = 16; i < 64; i++) {
-			const W15 = SHA256_W[i - 15];
-			const W2 = SHA256_W[i - 2];
-			const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-			const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
-			SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
-		}
-		let { A, B, C, D, E, F, G, H } = this;
-		for (let i = 0; i < 64; i++) {
-			const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-			const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-			const T2 = (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Maj(A, B, C) | 0;
-			H = G;
-			G = F;
-			F = E;
-			E = D + T1 | 0;
-			D = C;
-			C = B;
-			B = A;
-			A = T1 + T2 | 0;
-		}
-		A = A + this.A | 0;
-		B = B + this.B | 0;
-		C = C + this.C | 0;
-		D = D + this.D | 0;
-		E = E + this.E | 0;
-		F = F + this.F | 0;
-		G = G + this.G | 0;
-		H = H + this.H | 0;
-		this.set(A, B, C, D, E, F, G, H);
-	}
-	roundClean() {
-		clean(SHA256_W);
-	}
-	destroy() {
-		this.destroyed = true;
-		this.set(0, 0, 0, 0, 0, 0, 0, 0);
-		clean(this.buffer);
-	}
-};
-/** Internal SHA-256 hash class grounded in RFC 6234 §6.2. */
-var _SHA256 = class extends SHA2_32B {
-	constructor() {
-		super(32, SHA256_IV);
-	}
-};
-/**
-* SHA2-256 hash function from RFC 4634. In JS it's the fastest: even faster than Blake3. Some info:
-*
-* - Trying 2^128 hashes would get 50% chance of collision, using birthday attack.
-* - BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
-* - Each sha256 hash is executing 2^18 bit operations.
-* - Good 2024 ASICs can do 200Th/sec with 3500 watts of power, corresponding to 2^36 hashes/joule.
-* @param msg - message bytes to hash
-* @param opts - Reserved hash options.
-* @returns Digest bytes.
-* @example
-* Hash a message with SHA2-256.
-* ```ts
-* sha256(new Uint8Array([97, 98, 99]));
-* ```
-*/
-const sha256 = /* @__PURE__ */ createHasher(() => new _SHA256(), /* @__PURE__ */ oidNist(1));
-//#endregion
 //#region ../wallet-kernel/src/vault/memory.ts
 function cloneRecord(record) {
 	return {
@@ -820,6 +64,81 @@ function requireMeta(meta) {
 * leaves the store untouched. Content ops bump `meta.revision` once per commit; an `init` commit
 * writes its meta verbatim (revision stays as the initializer set it).
 */
+/**
+* Applies a commit's ops to a vault image and returns the next image — the single implementation of
+* record/factor op semantics shared by the memory store and the file-backed store in
+*
+* @qntx/wallet-native.
+*/
+function applyStoreOps(image, ops) {
+	let { meta } = image;
+	let { records } = image;
+	let { factors } = image;
+	let bump = false;
+	let initialized = false;
+	for (const op of ops) switch (op.op) {
+		case "init":
+			if (meta !== void 0 || records.length > 0 || factors.length > 0) throw conflict("vault already initialized");
+			meta = cloneMeta(op.meta);
+			initialized = true;
+			break;
+		case "expect-revision":
+			if (meta === void 0 || meta.revision !== op.revision) throw conflict("vault changed underneath");
+			break;
+		case "set-key-id":
+			meta = {
+				...requireMeta(meta),
+				keyId: op.keyId
+			};
+			bump = true;
+			break;
+		case "record-failure": {
+			const current = requireMeta(meta);
+			meta = {
+				...current,
+				failedAttempts: current.failedAttempts + 1,
+				lastFailureAt: op.at
+			};
+			break;
+		}
+		case "reset-failures":
+			meta = {
+				...requireMeta(meta),
+				failedAttempts: 0,
+				lastFailureAt: 0
+			};
+			break;
+		case "put-record":
+			records = [...records.filter((record) => !(record.kind === op.record.kind && record.id === op.record.id)), cloneRecord(op.record)];
+			bump = true;
+			break;
+		case "delete-record":
+			records = records.filter((record) => !(record.kind === op.kind && record.id === op.id));
+			bump = true;
+			break;
+		case "put-factor":
+			factors = [...factors.filter((factor) => factor.id !== op.factor.id), cloneFactor(op.factor)];
+			bump = true;
+			break;
+		case "delete-factor":
+			factors = factors.filter((factor) => factor.id !== op.id);
+			bump = true;
+			break;
+		case "clear":
+			meta = void 0;
+			records = [];
+			factors = [];
+	}
+	if (bump && !initialized && meta !== void 0) meta = {
+		...meta,
+		revision: meta.revision + 1
+	};
+	return {
+		meta,
+		records,
+		factors
+	};
+}
 function createMemoryStore() {
 	let image = {
 		meta: void 0,
@@ -827,81 +146,12 @@ function createMemoryStore() {
 		factors: []
 	};
 	const listeners = /* @__PURE__ */ new Set();
-	function apply(ops) {
-		let { meta } = image;
-		let { records } = image;
-		let { factors } = image;
-		let bump = false;
-		let initialized = false;
-		for (const op of ops) switch (op.op) {
-			case "init":
-				if (meta !== void 0 || records.length > 0 || factors.length > 0) throw conflict("vault already initialized");
-				meta = cloneMeta(op.meta);
-				initialized = true;
-				break;
-			case "expect-revision":
-				if (meta === void 0 || meta.revision !== op.revision) throw conflict("vault changed underneath");
-				break;
-			case "set-key-id":
-				meta = {
-					...requireMeta(meta),
-					keyId: op.keyId
-				};
-				bump = true;
-				break;
-			case "record-failure": {
-				const current = requireMeta(meta);
-				meta = {
-					...current,
-					failedAttempts: current.failedAttempts + 1,
-					lastFailureAt: op.at
-				};
-				break;
-			}
-			case "reset-failures":
-				meta = {
-					...requireMeta(meta),
-					failedAttempts: 0,
-					lastFailureAt: 0
-				};
-				break;
-			case "put-record":
-				records = [...records.filter((record) => !(record.kind === op.record.kind && record.id === op.record.id)), cloneRecord(op.record)];
-				bump = true;
-				break;
-			case "delete-record":
-				records = records.filter((record) => !(record.kind === op.kind && record.id === op.id));
-				bump = true;
-				break;
-			case "put-factor":
-				factors = [...factors.filter((factor) => factor.id !== op.factor.id), cloneFactor(op.factor)];
-				bump = true;
-				break;
-			case "delete-factor":
-				factors = factors.filter((factor) => factor.id !== op.id);
-				bump = true;
-				break;
-			case "clear":
-				meta = void 0;
-				records = [];
-				factors = [];
-		}
-		if (bump && !initialized && meta !== void 0) meta = {
-			...meta,
-			revision: meta.revision + 1
-		};
-		return {
-			meta,
-			records,
-			factors
-		};
-	}
 	return {
 		async load() {
 			return cloneImage(image);
 		},
 		async commit(ops) {
-			image = apply(ops);
+			image = applyStoreOps(image, ops);
 			for (const listener of listeners) listener();
 		},
 		watch(listener) {
@@ -1085,7 +335,7 @@ async function createNodeWallet(options) {
 			},
 			onExit: (handler) => {
 				const listener = () => {
-					handler();
+					handler("crashed");
 				};
 				worker.once("exit", listener);
 				return () => {
@@ -1099,6 +349,7 @@ async function createNodeWallet(options) {
 		};
 	};
 	return connectKernel({
+		factors: "software",
 		spawn,
 		passkey: options.passkey,
 		ceremony: options.authenticator,