Use ken-q org namespace for project Spaces

AGENTS.md

@@ -50,5 +50,5 @@ When the user asks to start or work on a project:
 - Each project lives in its OWN HF Space
 - Use `python3` and the `huggingface_hub` library for all HF API calls
 - If python3 or huggingface_hub is not installed, install with pip
-- Ask the user for the namespace/username to use for project Spaces
+- Default namespace for all project Spaces is `ken-q`
 - One project at a time unless explicitly asked to multitask

README.md

@@ -20,4 +20,4 @@ An AI coding agent running in your browser via Hugging Face Spaces, powered by N
 
 ## Usage
 
-Visit `https://kenqtade-opencode-home.hf.space` and start coding.
+Visit `https://ken-q-opencode-home.hf.space` and start coding.

node_modules/.bin/hfjs

@@ -0,0 +1 @@
+../@huggingface/hub/dist/cli.js

node_modules/.package-lock.json

@@ -0,0 +1,123 @@
+{
+  "name": "opencode-space",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/@huggingface/blake3-jit": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/@huggingface/blake3-jit/-/blake3-jit-0.0.2.tgz",
+      "integrity": "sha512-Bq7B5qabyjrJfhBsl85Jd2QBtf+HzRD7h7A9GfN2lzrrsABhOa5evVPgzoCTxR7Ub0QFj7YDK1YkYRWBU25+2w==",
+      "license": "MIT"
+    },
+    "node_modules/@huggingface/hub": {
+      "version": "2.13.2",
+      "resolved": "https://registry.npmjs.org/@huggingface/hub/-/hub-2.13.2.tgz",
+      "integrity": "sha512-I1Pbn9UcBHCt0M/SbZkKzYr3JVnbJp4YIFv74eVRH2Y22yT9Jpm6DtfM74tcjNLbC7SyFZ433znUw0szdFd4Fg==",
+      "license": "MIT",
+      "dependencies": {
+        "@huggingface/tasks": "^0.21.13",
+        "@huggingface/xetchunk-wasm": "^0.1.0"
+      },
+      "bin": {
+        "hfjs": "dist/cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "cli-progress": "^3.12.0"
+      }
+    },
+    "node_modules/@huggingface/tasks": {
+      "version": "0.21.20",
+      "resolved": "https://registry.npmjs.org/@huggingface/tasks/-/tasks-0.21.20.tgz",
+      "integrity": "sha512-pGw7pQI8TYSbrOVfNRdrYeISDEYOvQzOCEBceYjEKOH2wOmooc6eGfbYRhAALDgNKZCSISPYYFszRxHta3FaNw==",
+      "license": "MIT"
+    },
+    "node_modules/@huggingface/xetchunk-wasm": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/@huggingface/xetchunk-wasm/-/xetchunk-wasm-0.1.0.tgz",
+      "integrity": "sha512-wWpp2qwPgf9kv1KLJjcDUk/OrpDOsFoQ3Qpz0U5LGn20csoymBf8eneOv6wm/GzPBzlWac1OYiR0aa1vT6aM2Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@huggingface/blake3-jit": "0.0.2",
+        "gearhash-jit": "1.0.2"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/cli-progress": {
+      "version": "3.12.0",
+      "resolved": "https://registry.npmjs.org/cli-progress/-/cli-progress-3.12.0.tgz",
+      "integrity": "sha512-tRkV3HJ1ASwm19THiiLIXLO7Im7wlTuKnvkYaTkyoAPefqjNg7W7DHKUlGRxy9vxDvbyCYQkQozvptuMkGCg8A==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "string-width": "^4.2.3"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/gearhash-jit": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/gearhash-jit/-/gearhash-jit-1.0.2.tgz",
+      "integrity": "sha512-UhzJL4KXSdqAKepy/tZwmi2Rcy0YMmtiC4DQS4SURCuIWdh8ECZtnXK2ePRMLigfB61hRKdLK/Vgg2bSw73izQ==",
+      "license": "MIT"
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    }
+  }
+}

node_modules/@huggingface/blake3-jit/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Original work Copyright (c) LongYinan <github@lyn.one> (https://github.com/Brooooooklyn/blake3-jit)
+Modified work Copyright (c) Hugging Face
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@huggingface/blake3-jit/README.md

@@ -0,0 +1,56 @@
+# @huggingface/blake3-jit
+
+Temporary fork of [`blake3-jit`](https://github.com/Brooooooklyn/blake3-jit) by [@Brooooooklyn](https://github.com/Brooooooklyn) with performance enhancements for [Hugging Face Xet](https://huggingface.co/docs/hub/xet) content-defined chunking.
+
+This package will be deprecated once upstream `blake3-jit` exposes these changes.
+
+## Changes from upstream
+
+1. **`Hasher.reset()` method** — resets the hasher to process a new message with the same key/flags, reusing all internal buffers (zero allocations per hash).
+
+2. **Pre-allocated internal buffers** — `parentBlock`, `parentCv`, `chunkCv`, `outWords`, and `finalizeCv` are allocated once in the constructor and reused across `update`/`finalize` calls, significantly reducing GC pressure in hot loops.
+
+3. **`ChunkState.resetTo()` method** — allows reusing `ChunkState` instances instead of allocating new ones per chunk.
+
+4. **Removed `Uint32Array` view fast-path** in `ChunkState.update` — the byte-by-byte `readLittleEndianWordsFull` path was empirically faster and avoids `RangeError` on unaligned offsets.
+
+5. **Dual ESM/CJS output via `tshy`** — the upstream package is ESM-only; this fork uses [`tshy`](https://github.com/isaacs/tshy) to produce both ESM and CommonJS builds, required for compatibility with Node.js CJS consumers.
+
+These changes are also available as a patch file at [`packages/xetchunk-wasm/patches/blake3-jit.patch`](../xetchunk-wasm/patches/blake3-jit.patch) (applicable to the upstream dist bundle).
+
+## Installation
+
+```bash
+npm install @huggingface/blake3-jit
+```
+
+## Usage
+
+```typescript
+import { hash, Hasher } from "@huggingface/blake3-jit";
+
+// One-shot hashing
+const digest = hash(new Uint8Array([1, 2, 3]));
+
+// Incremental hashing with reset (zero-alloc reuse)
+const hasher = new Hasher();
+hasher.update(chunk1);
+const hash1 = hasher.finalize();
+
+hasher.reset();
+hasher.update(chunk2);
+const hash2 = hasher.finalize();
+
+// Keyed hashing (MAC)
+const mac = Hasher.newKeyed(key).update(message).finalize();
+```
+
+## Upstream
+
+This is a fork of [blake3-jit](https://github.com/Brooooooklyn/blake3-jit) — a high-performance BLAKE3 implementation with runtime JIT WASM SIMD, created by [LongYinan (@Brooooooklyn)](https://github.com/Brooooooklyn).
+
+See the upstream repository for full documentation, benchmarks, and architecture details.
+
+## License
+
+MIT — see [LICENSE](./LICENSE)

node_modules/@huggingface/blake3-jit/dist/commonjs/compress.d.ts

@@ -0,0 +1,37 @@
+/**
+ * BLAKE3 Compression Function - Highly Optimized
+ *
+ * Optimization techniques applied (from Fleek Network case study):
+ * 1. Use 16 SMI variables for state instead of TypedArray
+ * 2. Use 16 SMI variables for message words
+ * 3. Fully inlined G function (no function call overhead)
+ * 4. Use `| 0` for integer coercion (forces V8 to use 32-bit ALU)
+ * 5. Hardcoded permutation swaps using only 2 temporary variables
+ * 6. Offset-based access pattern (avoid creating new views)
+ *
+ * The compression function takes:
+ * - cv: 8-word chaining value
+ * - block: 16-word message block (64 bytes)
+ * - counter: 64-bit block counter
+ * - blockLen: number of input bytes in this block
+ * - flags: domain separation flags
+ *
+ * And outputs 8 or 16 words depending on whether this is a root node.
+ */
+/**
+ * Compress a single block.
+ *
+ * This is the hot path - every optimization matters here.
+ *
+ * @param cv - Chaining value array
+ * @param cvOff - Offset into cv
+ * @param block - Message block words
+ * @param blockOff - Offset into block
+ * @param out - Output array (8 or 16 words)
+ * @param outOff - Offset into out
+ * @param full - If true, output all 16 words (for XOF); if false, output 8 words
+ * @param counter - 64-bit block counter
+ * @param blockLen - Number of bytes in this block (0-64)
+ * @param flags - Domain separation flags
+ */
+export declare function compress(cv: Uint32Array, cvOff: number, block: Uint32Array, blockOff: number, out: Uint32Array, outOff: number, full: boolean, counter: number, blockLen: number, flags: number): void;

node_modules/@huggingface/blake3-jit/dist/commonjs/compress.js

@@ -0,0 +1,919 @@
+"use strict";
+/**
+ * BLAKE3 Compression Function - Highly Optimized
+ *
+ * Optimization techniques applied (from Fleek Network case study):
+ * 1. Use 16 SMI variables for state instead of TypedArray
+ * 2. Use 16 SMI variables for message words
+ * 3. Fully inlined G function (no function call overhead)
+ * 4. Use `| 0` for integer coercion (forces V8 to use 32-bit ALU)
+ * 5. Hardcoded permutation swaps using only 2 temporary variables
+ * 6. Offset-based access pattern (avoid creating new views)
+ *
+ * The compression function takes:
+ * - cv: 8-word chaining value
+ * - block: 16-word message block (64 bytes)
+ * - counter: 64-bit block counter
+ * - blockLen: number of input bytes in this block
+ * - flags: domain separation flags
+ *
+ * And outputs 8 or 16 words depending on whether this is a root node.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compress = compress;
+/**
+ * Compress a single block.
+ *
+ * This is the hot path - every optimization matters here.
+ *
+ * @param cv - Chaining value array
+ * @param cvOff - Offset into cv
+ * @param block - Message block words
+ * @param blockOff - Offset into block
+ * @param out - Output array (8 or 16 words)
+ * @param outOff - Offset into out
+ * @param full - If true, output all 16 words (for XOF); if false, output 8 words
+ * @param counter - 64-bit block counter
+ * @param blockLen - Number of bytes in this block (0-64)
+ * @param flags - Domain separation flags
+ */
+function compress(cv, cvOff, block, blockOff, out, outOff, full, counter, blockLen, flags) {
+    // Load message words into SMI variables for maximum performance
+    // V8 optimizes SMI arithmetic directly with the ALU
+    let m0 = block[blockOff] | 0;
+    let m1 = block[blockOff + 1] | 0;
+    let m2 = block[blockOff + 2] | 0;
+    let m3 = block[blockOff + 3] | 0;
+    let m4 = block[blockOff + 4] | 0;
+    let m5 = block[blockOff + 5] | 0;
+    let m6 = block[blockOff + 6] | 0;
+    let m7 = block[blockOff + 7] | 0;
+    let m8 = block[blockOff + 8] | 0;
+    let m9 = block[blockOff + 9] | 0;
+    let m10 = block[blockOff + 10] | 0;
+    let m11 = block[blockOff + 11] | 0;
+    let m12 = block[blockOff + 12] | 0;
+    let m13 = block[blockOff + 13] | 0;
+    let m14 = block[blockOff + 14] | 0;
+    let m15 = block[blockOff + 15] | 0;
+    // Initialize state: first 8 words from chaining value
+    let s0 = cv[cvOff] | 0;
+    let s1 = cv[cvOff + 1] | 0;
+    let s2 = cv[cvOff + 2] | 0;
+    let s3 = cv[cvOff + 3] | 0;
+    let s4 = cv[cvOff + 4] | 0;
+    let s5 = cv[cvOff + 5] | 0;
+    let s6 = cv[cvOff + 6] | 0;
+    let s7 = cv[cvOff + 7] | 0;
+    // Words 8-11: IV constants
+    let s8 = 0x6a09e667;
+    let s9 = 0xbb67ae85;
+    let s10 = 0x3c6ef372;
+    let s11 = 0xa54ff53a;
+    // Words 12-15: counter, blockLen, flags
+    // Note: counter is 64-bit, split into low and high 32-bit words
+    let s12 = counter | 0;
+    let s13 = (counter / 0x100000000) | 0;
+    let s14 = blockLen | 0;
+    let s15 = flags | 0;
+    // ============================================================
+    // 7 rounds of mixing
+    // Each round consists of 4 column G functions and 4 diagonal G functions
+    // followed by a message word permutation (except for round 7)
+    // ============================================================
+    // ROUND 1 (message schedule: 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)
+    // Column G functions
+    // G(0, 4, 8, 12) with m0, m1
+    s0 = (((s0 + s4) | 0) + m0) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s0 = (((s0 + s4) | 0) + m1) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // G(1, 5, 9, 13) with m2, m3
+    s1 = (((s1 + s5) | 0) + m2) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s1 = (((s1 + s5) | 0) + m3) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    // G(2, 6, 10, 14) with m4, m5
+    s2 = (((s2 + s6) | 0) + m4) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s2 = (((s2 + s6) | 0) + m5) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    // G(3, 7, 11, 15) with m6, m7
+    s3 = (((s3 + s7) | 0) + m6) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s3 = (((s3 + s7) | 0) + m7) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    // Diagonal G functions
+    // G(0, 5, 10, 15) with m8, m9
+    s0 = (((s0 + s5) | 0) + m8) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s0 = (((s0 + s5) | 0) + m9) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    // G(1, 6, 11, 12) with m10, m11
+    s1 = (((s1 + s6) | 0) + m10) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s1 = (((s1 + s6) | 0) + m11) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    // G(2, 7, 8, 13) with m12, m13
+    s2 = (((s2 + s7) | 0) + m12) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s2 = (((s2 + s7) | 0) + m13) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    // G(3, 4, 9, 14) with m14, m15
+    s3 = (((s3 + s4) | 0) + m14) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s3 = (((s3 + s4) | 0) + m15) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // Permute message words for round 2
+    // Permutation: [2,6,3,10,7,0,4,13,1,11,12,5,9,14,15,8]
+    // Using 2 temps for the two cycles in the permutation
+    {
+        const t0 = m0, t1 = m1;
+        m0 = m2;
+        m2 = m3;
+        m3 = m10;
+        m10 = m12;
+        m12 = m9;
+        m9 = m11;
+        m11 = m5;
+        m5 = t0;
+        m1 = m6;
+        m6 = m4;
+        m4 = m7;
+        m7 = m13;
+        m13 = m14;
+        m14 = m15;
+        m15 = m8;
+        m8 = t1;
+    }
+    // ROUND 2 (message schedule: 2,6,3,10,7,0,4,13,1,11,12,5,9,14,15,8)
+    s0 = (((s0 + s4) | 0) + m0) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s0 = (((s0 + s4) | 0) + m1) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    s1 = (((s1 + s5) | 0) + m2) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s1 = (((s1 + s5) | 0) + m3) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s2 = (((s2 + s6) | 0) + m4) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s2 = (((s2 + s6) | 0) + m5) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s3 = (((s3 + s7) | 0) + m6) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s3 = (((s3 + s7) | 0) + m7) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s0 = (((s0 + s5) | 0) + m8) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s0 = (((s0 + s5) | 0) + m9) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s1 = (((s1 + s6) | 0) + m10) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s1 = (((s1 + s6) | 0) + m11) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s2 = (((s2 + s7) | 0) + m12) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s2 = (((s2 + s7) | 0) + m13) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s3 = (((s3 + s4) | 0) + m14) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s3 = (((s3 + s4) | 0) + m15) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // Permute for round 3
+    {
+        const t0 = m0, t1 = m1;
+        m0 = m2;
+        m2 = m3;
+        m3 = m10;
+        m10 = m12;
+        m12 = m9;
+        m9 = m11;
+        m11 = m5;
+        m5 = t0;
+        m1 = m6;
+        m6 = m4;
+        m4 = m7;
+        m7 = m13;
+        m13 = m14;
+        m14 = m15;
+        m15 = m8;
+        m8 = t1;
+    }
+    // ROUND 3 (message schedule: 3,4,10,12,13,2,7,14,6,5,9,0,11,15,8,1)
+    s0 = (((s0 + s4) | 0) + m0) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s0 = (((s0 + s4) | 0) + m1) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    s1 = (((s1 + s5) | 0) + m2) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s1 = (((s1 + s5) | 0) + m3) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s2 = (((s2 + s6) | 0) + m4) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s2 = (((s2 + s6) | 0) + m5) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s3 = (((s3 + s7) | 0) + m6) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s3 = (((s3 + s7) | 0) + m7) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s0 = (((s0 + s5) | 0) + m8) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s0 = (((s0 + s5) | 0) + m9) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s1 = (((s1 + s6) | 0) + m10) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s1 = (((s1 + s6) | 0) + m11) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s2 = (((s2 + s7) | 0) + m12) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s2 = (((s2 + s7) | 0) + m13) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s3 = (((s3 + s4) | 0) + m14) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s3 = (((s3 + s4) | 0) + m15) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // Permute for round 4
+    {
+        const t0 = m0, t1 = m1;
+        m0 = m2;
+        m2 = m3;
+        m3 = m10;
+        m10 = m12;
+        m12 = m9;
+        m9 = m11;
+        m11 = m5;
+        m5 = t0;
+        m1 = m6;
+        m6 = m4;
+        m4 = m7;
+        m7 = m13;
+        m13 = m14;
+        m14 = m15;
+        m15 = m8;
+        m8 = t1;
+    }
+    // ROUND 4 (message schedule: 10,7,12,9,14,3,13,15,4,0,11,2,5,8,1,6)
+    s0 = (((s0 + s4) | 0) + m0) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s0 = (((s0 + s4) | 0) + m1) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    s1 = (((s1 + s5) | 0) + m2) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s1 = (((s1 + s5) | 0) + m3) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s2 = (((s2 + s6) | 0) + m4) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s2 = (((s2 + s6) | 0) + m5) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s3 = (((s3 + s7) | 0) + m6) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s3 = (((s3 + s7) | 0) + m7) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s0 = (((s0 + s5) | 0) + m8) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s0 = (((s0 + s5) | 0) + m9) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s1 = (((s1 + s6) | 0) + m10) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s1 = (((s1 + s6) | 0) + m11) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s2 = (((s2 + s7) | 0) + m12) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s2 = (((s2 + s7) | 0) + m13) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s3 = (((s3 + s4) | 0) + m14) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s3 = (((s3 + s4) | 0) + m15) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // Permute for round 5
+    {
+        const t0 = m0, t1 = m1;
+        m0 = m2;
+        m2 = m3;
+        m3 = m10;
+        m10 = m12;
+        m12 = m9;
+        m9 = m11;
+        m11 = m5;
+        m5 = t0;
+        m1 = m6;
+        m6 = m4;
+        m4 = m7;
+        m7 = m13;
+        m13 = m14;
+        m14 = m15;
+        m15 = m8;
+        m8 = t1;
+    }
+    // ROUND 5 (message schedule: 12,13,9,11,15,10,14,8,7,2,5,3,0,1,6,4)
+    s0 = (((s0 + s4) | 0) + m0) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s0 = (((s0 + s4) | 0) + m1) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    s1 = (((s1 + s5) | 0) + m2) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s1 = (((s1 + s5) | 0) + m3) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s2 = (((s2 + s6) | 0) + m4) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s2 = (((s2 + s6) | 0) + m5) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s3 = (((s3 + s7) | 0) + m6) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s3 = (((s3 + s7) | 0) + m7) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s0 = (((s0 + s5) | 0) + m8) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s0 = (((s0 + s5) | 0) + m9) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s1 = (((s1 + s6) | 0) + m10) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s1 = (((s1 + s6) | 0) + m11) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s2 = (((s2 + s7) | 0) + m12) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s2 = (((s2 + s7) | 0) + m13) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s3 = (((s3 + s4) | 0) + m14) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s3 = (((s3 + s4) | 0) + m15) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // Permute for round 6
+    {
+        const t0 = m0, t1 = m1;
+        m0 = m2;
+        m2 = m3;
+        m3 = m10;
+        m10 = m12;
+        m12 = m9;
+        m9 = m11;
+        m11 = m5;
+        m5 = t0;
+        m1 = m6;
+        m6 = m4;
+        m4 = m7;
+        m7 = m13;
+        m13 = m14;
+        m14 = m15;
+        m15 = m8;
+        m8 = t1;
+    }
+    // ROUND 6 (message schedule: 9,14,11,5,8,12,15,1,13,3,0,10,2,6,4,7)
+    s0 = (((s0 + s4) | 0) + m0) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s0 = (((s0 + s4) | 0) + m1) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    s1 = (((s1 + s5) | 0) + m2) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s1 = (((s1 + s5) | 0) + m3) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s2 = (((s2 + s6) | 0) + m4) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s2 = (((s2 + s6) | 0) + m5) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s3 = (((s3 + s7) | 0) + m6) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s3 = (((s3 + s7) | 0) + m7) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s0 = (((s0 + s5) | 0) + m8) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s0 = (((s0 + s5) | 0) + m9) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s1 = (((s1 + s6) | 0) + m10) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s1 = (((s1 + s6) | 0) + m11) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s2 = (((s2 + s7) | 0) + m12) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s2 = (((s2 + s7) | 0) + m13) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s3 = (((s3 + s4) | 0) + m14) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s3 = (((s3 + s4) | 0) + m15) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // Permute for round 7
+    {
+        const t0 = m0, t1 = m1;
+        m0 = m2;
+        m2 = m3;
+        m3 = m10;
+        m10 = m12;
+        m12 = m9;
+        m9 = m11;
+        m11 = m5;
+        m5 = t0;
+        m1 = m6;
+        m6 = m4;
+        m4 = m7;
+        m7 = m13;
+        m13 = m14;
+        m14 = m15;
+        m15 = m8;
+        m8 = t1;
+    }
+    // ROUND 7 (message schedule: 11,15,5,0,1,9,8,6,14,10,2,12,3,4,7,13)
+    s0 = (((s0 + s4) | 0) + m0) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s0 = (((s0 + s4) | 0) + m1) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    s1 = (((s1 + s5) | 0) + m2) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s1 = (((s1 + s5) | 0) + m3) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s2 = (((s2 + s6) | 0) + m4) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s2 = (((s2 + s6) | 0) + m5) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s3 = (((s3 + s7) | 0) + m6) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s3 = (((s3 + s7) | 0) + m7) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s0 = (((s0 + s5) | 0) + m8) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s0 = (((s0 + s5) | 0) + m9) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s1 = (((s1 + s6) | 0) + m10) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s1 = (((s1 + s6) | 0) + m11) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s2 = (((s2 + s7) | 0) + m12) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s2 = (((s2 + s7) | 0) + m13) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s3 = (((s3 + s4) | 0) + m14) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s3 = (((s3 + s4) | 0) + m15) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // ============================================================
+    // Final XOR and output
+    // ============================================================
+    // If full output needed (XOF mode), write words 8-15 first
+    // (written first in case out === cv)
+    if (full) {
+        out[outOff + 8] = s8 ^ cv[cvOff];
+        out[outOff + 9] = s9 ^ cv[cvOff + 1];
+        out[outOff + 10] = s10 ^ cv[cvOff + 2];
+        out[outOff + 11] = s11 ^ cv[cvOff + 3];
+        out[outOff + 12] = s12 ^ cv[cvOff + 4];
+        out[outOff + 13] = s13 ^ cv[cvOff + 5];
+        out[outOff + 14] = s14 ^ cv[cvOff + 6];
+        out[outOff + 15] = s15 ^ cv[cvOff + 7];
+    }
+    // Standard output: XOR state[0..7] with state[8..15]
+    out[outOff] = s0 ^ s8;
+    out[outOff + 1] = s1 ^ s9;
+    out[outOff + 2] = s2 ^ s10;
+    out[outOff + 3] = s3 ^ s11;
+    out[outOff + 4] = s4 ^ s12;
+    out[outOff + 5] = s5 ^ s13;
+    out[outOff + 6] = s6 ^ s14;
+    out[outOff + 7] = s7 ^ s15;
+}

node_modules/@huggingface/blake3-jit/dist/commonjs/constants.d.ts

@@ -0,0 +1,34 @@
+/**
+ * BLAKE3 Constants
+ *
+ * IV values are the same as SHA-256: first 32 bits of the fractional parts
+ * of the square roots of the first 8 primes (2..19)
+ */
+export declare const IV: Uint32Array<ArrayBuffer>;
+export declare const CHUNK_START = 1;
+export declare const CHUNK_END: number;
+export declare const PARENT: number;
+export declare const ROOT: number;
+export declare const KEYED_HASH: number;
+export declare const DERIVE_KEY_CONTEXT: number;
+export declare const DERIVE_KEY_MATERIAL: number;
+export declare const OUT_LEN = 32;
+export declare const KEY_LEN = 32;
+export declare const BLOCK_LEN = 64;
+export declare const CHUNK_LEN = 1024;
+export declare const MAX_DEPTH = 54;
+/**
+ * Precomputed message word permutations for all 7 rounds.
+ *
+ * The base permutation is: [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8]
+ * Each subsequent permutation is the previous one with this permutation applied.
+ *
+ * These are the indices into the message block for each round.
+ * By precomputing these, we avoid runtime permutation overhead.
+ */
+export declare const MSG_SCHEDULE: ReadonlyArray<ReadonlyArray<number>>;
+/**
+ * Flattened permutation table for compress function optimization.
+ * This enables direct indexed access: PERMUTATIONS[round * 16 + index]
+ */
+export declare const PERMUTATIONS: Uint8Array<ArrayBuffer>;

node_modules/@huggingface/blake3-jit/dist/commonjs/constants.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * BLAKE3 Constants
+ *
+ * IV values are the same as SHA-256: first 32 bits of the fractional parts
+ * of the square roots of the first 8 primes (2..19)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PERMUTATIONS = exports.MSG_SCHEDULE = exports.MAX_DEPTH = exports.CHUNK_LEN = exports.BLOCK_LEN = exports.KEY_LEN = exports.OUT_LEN = exports.DERIVE_KEY_MATERIAL = exports.DERIVE_KEY_CONTEXT = exports.KEYED_HASH = exports.ROOT = exports.PARENT = exports.CHUNK_END = exports.CHUNK_START = exports.IV = void 0;
+// Initialization Vector (same as SHA-256)
+exports.IV = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]);
+// Domain separation flags
+exports.CHUNK_START = 1;
+exports.CHUNK_END = 1 << 1;
+exports.PARENT = 1 << 2;
+exports.ROOT = 1 << 3;
+exports.KEYED_HASH = 1 << 4;
+exports.DERIVE_KEY_CONTEXT = 1 << 5;
+exports.DERIVE_KEY_MATERIAL = 1 << 6;
+// Size constants
+exports.OUT_LEN = 32;
+exports.KEY_LEN = 32;
+exports.BLOCK_LEN = 64;
+exports.CHUNK_LEN = 1024;
+// Maximum depth of the CV stack (supports up to 2^54 bytes input)
+exports.MAX_DEPTH = 54;
+/**
+ * Precomputed message word permutations for all 7 rounds.
+ *
+ * The base permutation is: [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8]
+ * Each subsequent permutation is the previous one with this permutation applied.
+ *
+ * These are the indices into the message block for each round.
+ * By precomputing these, we avoid runtime permutation overhead.
+ */
+exports.MSG_SCHEDULE = [
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8],
+    [3, 4, 10, 12, 13, 2, 7, 14, 6, 5, 9, 0, 11, 15, 8, 1],
+    [10, 7, 12, 9, 14, 3, 13, 15, 4, 0, 11, 2, 5, 8, 1, 6],
+    [12, 13, 9, 11, 15, 10, 14, 8, 7, 2, 5, 3, 0, 1, 6, 4],
+    [9, 14, 11, 5, 8, 12, 15, 1, 13, 3, 0, 10, 2, 6, 4, 7],
+    [11, 15, 5, 0, 1, 9, 8, 6, 14, 10, 2, 12, 3, 4, 7, 13],
+];
+/**
+ * Flattened permutation table for compress function optimization.
+ * This enables direct indexed access: PERMUTATIONS[round * 16 + index]
+ */
+exports.PERMUTATIONS = new Uint8Array([
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9,
+    14, 15, 8, 3, 4, 10, 12, 13, 2, 7, 14, 6, 5, 9, 0, 11, 15, 8, 1, 10, 7, 12, 9, 14, 3, 13, 15, 4,
+    0, 11, 2, 5, 8, 1, 6, 12, 13, 9, 11, 15, 10, 14, 8, 7, 2, 5, 3, 0, 1, 6, 4, 9, 14, 11, 5, 8, 12,
+    15, 1, 13, 3, 0, 10, 2, 6, 4, 7, 11, 15, 5, 0, 1, 9, 8, 6, 14, 10, 2, 12, 3, 4, 7, 13,
+]);

node_modules/@huggingface/blake3-jit/dist/commonjs/hash.d.ts

@@ -0,0 +1,28 @@
+/**
+ * BLAKE3 Hash Function - Simple one-shot API
+ *
+ * This provides a simple hash() function optimized for different input sizes.
+ * For small inputs, uses pure JS. For large inputs, uses WASM SIMD.
+ */
+/**
+ * Hash input data and return the result.
+ * Automatically uses WASM SIMD for large inputs when available.
+ *
+ * @param input - Data to hash
+ * @param outputLength - Number of bytes to output (default: 32)
+ * @returns The hash output
+ */
+export declare function hash(input: Uint8Array, outputLength?: number): Uint8Array;
+/**
+ * Pre-warm SIMD initialization (call early to avoid latency later).
+ */
+export declare function warmupSimd(): boolean;
+/**
+ * Hash input data directly into a caller-provided output buffer.
+ * Zero-allocation for the common 32-byte case - ideal for performance-critical code.
+ *
+ * @param input - Data to hash
+ * @param output - Pre-allocated output buffer (must be at least outputLength bytes)
+ * @param outputLength - Number of bytes to output (default: 32, max: output.length)
+ */
+export declare function hashInto(input: Uint8Array, output: Uint8Array, outputLength?: number): void;

node_modules/@huggingface/blake3-jit/dist/commonjs/hash.js

@@ -0,0 +1,1038 @@
+"use strict";
+/**
+ * BLAKE3 Hash Function - Simple one-shot API
+ *
+ * This provides a simple hash() function optimized for different input sizes.
+ * For small inputs, uses pure JS. For large inputs, uses WASM SIMD.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash = hash;
+exports.warmupSimd = warmupSimd;
+exports.hashInto = hashInto;
+const compress_js_1 = require("./compress.js");
+const constants_js_1 = require("./constants.js");
+const utils_js_1 = require("./utils.js");
+const wasm_simd_js_1 = require("./wasm-simd.js");
+// Pre-allocated buffers for reuse (single-threaded optimization)
+let blockWords = null;
+// ===== Contiguous Hyper CV Stack (Optimization #6) =====
+// Maximum tree depth for practical inputs (2^64 chunks = essentially unlimited)
+// Fixed allocation at module load - no runtime allocation
+const CV_STACK_DEPTH = 64;
+const HYPER_CV_STACK = new Uint32Array(CV_STACK_DEPTH * 8); // 64 CVs × 8 words = 512 words
+// Pre-computed offsets for the first few stack levels (hot path optimization)
+// Note: These can be used for further optimization if needed
+// const CV_STACK_OFF_0 = 0;
+// const CV_STACK_OFF_1 = 8;
+// const CV_STACK_OFF_2 = 16;
+// const CV_STACK_OFF_3 = 24;
+// ===== Pre-allocated CV Pool with Views (avoids subarray() in hot paths) =====
+const CV_POOL_SIZE = 64;
+const CV_POOL = new Uint32Array(CV_POOL_SIZE * 8); // 64 CVs × 8 words = 512 words
+const CV_VIEWS = [];
+for (let i = 0; i < CV_POOL_SIZE; i++) {
+    CV_VIEWS.push(CV_POOL.subarray(i * 8, i * 8 + 8));
+}
+// SIMD initialization state
+let simdAvailable = false;
+// Threshold for switching to SIMD (must be > 1 chunk to benefit from parallelism)
+const SIMD_THRESHOLD = 4 * constants_js_1.CHUNK_LEN; // 4KB - need at least 4 chunks for SIMD benefit
+/**
+ * Initialize SIMD synchronously (lazy).
+ */
+function ensureSimdSync() {
+    if (simdAvailable)
+        return true;
+    simdAvailable = (0, wasm_simd_js_1.initSimdSync)();
+    return simdAvailable;
+}
+// Reusable buffer for SIMD chunk CVs (4 chunks × 8 words)
+const simdChunkCvs = new Uint32Array(32);
+// ===== Module-level reusable buffers (single-threaded safe) =====
+// These eliminate heap allocations in hot paths
+// For hashChunkWithWords() and hashChunkRoot()
+const reusableTempCv = new Uint32Array(8);
+// For hashPureJS()
+const reusableChunkCv = new Uint32Array(8);
+const reusablePureParentBlock = new Uint32Array(16);
+const reusablePureParentCv = new Uint32Array(8);
+// For hashSimd() - use flat array for 4 chunk CVs (access via subarray)
+const reusableSimdCvs = new Uint32Array(32); // 4 × 8 words flat
+// For hashSimd() parent compression
+const reusableSimdParentBlock = new Uint32Array(16);
+const reusableSimdParentCv = new Uint32Array(8);
+// For hashSimd() parameters - TypedArrays instead of JS arrays
+const reusableOffsets = new Uint32Array(4);
+const reusableCounters = new Uint32Array(4);
+const reusableBlockLens = new Uint32Array(4);
+const reusableFlags = new Uint32Array(4);
+// Reusable output buffer for common 32-byte hash (eliminates allocations)
+const reusableOut8 = new Uint32Array(8); // Standard 32-byte output
+// Pre-created view to avoid allocation in hot path (Task 1 optimization)
+const reusableOut8View = new Uint8Array(reusableOut8.buffer, 0, 32);
+// ===== Unrolled CV Copy Helper (Task 7 optimization) =====
+// V8 will inline this - avoids loop overhead in hot paths
+function copyCV8(src, srcOff, dst, dstOff) {
+    dst[dstOff] = src[srcOff];
+    dst[dstOff + 1] = src[srcOff + 1];
+    dst[dstOff + 2] = src[srcOff + 2];
+    dst[dstOff + 3] = src[srcOff + 3];
+    dst[dstOff + 4] = src[srcOff + 4];
+    dst[dstOff + 5] = src[srcOff + 5];
+    dst[dstOff + 6] = src[srcOff + 6];
+    dst[dstOff + 7] = src[srcOff + 7];
+}
+/**
+ * Transpose 4 blocks (64 bytes each) into SIMD memory layout.
+ * The SIMD compress4x expects: [m0_0,m0_1,m0_2,m0_3, m1_0,m1_1,m1_2,m1_3, ...]
+ * where m{i}_{j} is message word i from block j.
+ *
+ * OPTIMIZED: Processes all 4 blocks together for each word position,
+ * writing 4 consecutive u32s at once for better cache locality.
+ *
+ * @param inputWords - Pre-created Uint32Array view of input (null if unaligned/non-LE).
+ *                     Created once per hash call to avoid allocation in hot loop.
+ */
+function transposeBlocksToSimd(input, offsets, // Starting offsets for each of 4 blocks
+blockLens, // Length of each block (0-64 bytes)
+mem32, blockCount, // 1-4 blocks
+inputWords) {
+    // Fast path: all blocks are full 64-byte blocks with aligned LE input
+    const allFull = blockCount === 4 &&
+        blockLens[0] === 64 &&
+        blockLens[1] === 64 &&
+        blockLens[2] === 64 &&
+        blockLens[3] === 64;
+    if (allFull &&
+        inputWords &&
+        offsets[0] % 4 === 0 &&
+        offsets[1] % 4 === 0 &&
+        offsets[2] % 4 === 0 &&
+        offsets[3] % 4 === 0) {
+        // Ultra-fast path: process all 4 blocks together, write 4 consecutive u32s per word
+        const wordOff0 = offsets[0] >>> 2;
+        const wordOff1 = offsets[1] >>> 2;
+        const wordOff2 = offsets[2] >>> 2;
+        const wordOff3 = offsets[3] >>> 2;
+        for (let w = 0; w < 16; w++) {
+            const dstBase = w * 4;
+            mem32[dstBase] = inputWords[wordOff0 + w];
+            mem32[dstBase + 1] = inputWords[wordOff1 + w];
+            mem32[dstBase + 2] = inputWords[wordOff2 + w];
+            mem32[dstBase + 3] = inputWords[wordOff3 + w];
+        }
+        return;
+    }
+    // Standard path: process each block independently (handles partial blocks)
+    for (let b = 0; b < blockCount; b++) {
+        const len = blockLens[b];
+        const off = offsets[b];
+        if (len === 64) {
+            // Full block
+            if (inputWords && off % 4 === 0) {
+                // Direct Uint32Array access for aligned LE blocks
+                const wordOff = off >>> 2;
+                for (let w = 0; w < 16; w++) {
+                    mem32[w * 4 + b] = inputWords[wordOff + w];
+                }
+            }
+            else {
+                // Byte-by-byte reconstruction
+                for (let w = 0; w < 16; w++) {
+                    const srcOff = off + w * 4;
+                    mem32[w * 4 + b] =
+                        input[srcOff] |
+                            (input[srcOff + 1] << 8) |
+                            (input[srcOff + 2] << 16) |
+                            (input[srcOff + 3] << 24);
+                }
+            }
+        }
+        else if (len === 0) {
+            // Zero block
+            for (let w = 0; w < 16; w++) {
+                mem32[w * 4 + b] = 0;
+            }
+        }
+        else {
+            // Partial block - handle word by word
+            for (let w = 0; w < 16; w++) {
+                const wordOff = w * 4;
+                if (wordOff >= len) {
+                    mem32[w * 4 + b] = 0;
+                }
+                else if (wordOff + 4 <= len) {
+                    const srcOff = off + wordOff;
+                    mem32[w * 4 + b] =
+                        input[srcOff] |
+                            (input[srcOff + 1] << 8) |
+                            (input[srcOff + 2] << 16) |
+                            (input[srcOff + 3] << 24);
+                }
+                else {
+                    // Partial word at end of block
+                    let word = 0;
+                    for (let i = 0; i < len - wordOff; i++) {
+                        word |= input[off + wordOff + i] << (i * 8);
+                    }
+                    mem32[w * 4 + b] = word;
+                }
+            }
+        }
+    }
+    // Zero unused block slots
+    for (let b = blockCount; b < 4; b++) {
+        for (let w = 0; w < 16; w++) {
+            mem32[w * 4 + b] = 0;
+        }
+    }
+}
+/**
+ * Transpose 4 full chunks (4 × 16 blocks = 64 blocks) into batch SIMD memory.
+ * This is used for the batched compressChunks4x function that processes
+ * all 16 blocks in a single WASM call.
+ *
+ * Memory layout: BATCH_BLOCK_WORDS has 16 positions, each with 16 v128 values.
+ * Position p, word w: mem32[(p * 64) + (w * 4) + lane]
+ *
+ * OPTIMIZED: Processes all 4 chunks together for each (pos, word) pair,
+ * writing 4 consecutive u32s at once for better cache locality.
+ *
+ * @param input - Input data (must have at least 4 full chunks = 4096 bytes)
+ * @param chunkOffsets - Starting offsets for each of 4 chunks
+ * @param mem32 - WASM memory view
+ * @param inputWords - Pre-created Uint32Array view (null if unaligned)
+ */
+function transposeBatchToSimd(input, chunkOffsets, mem32, inputWords) {
+    const BATCH_BASE = wasm_simd_js_1.SIMD_MEMORY.BATCH_BLOCK_WORDS / 4;
+    // Get base word offsets for each chunk (pre-computed for fast path)
+    const chunk0WordBase = chunkOffsets[0] >>> 2;
+    const chunk1WordBase = chunkOffsets[1] >>> 2;
+    const chunk2WordBase = chunkOffsets[2] >>> 2;
+    const chunk3WordBase = chunkOffsets[3] >>> 2;
+    // Fast path: all chunks aligned and LE - process 4 consecutive u32s at once
+    if (inputWords && chunkOffsets[0] % 4 === 0) {
+        for (let pos = 0; pos < 16; pos++) {
+            const posBase = BATCH_BASE + pos * 64; // 16 words × 4 lanes = 64
+            const blockWordOff = pos * 16; // 16 words per block (64 bytes / 4)
+            // Process all 16 words, writing 4 chunks at a time (cache-friendly: 16 bytes per write group)
+            for (let w = 0; w < 16; w++) {
+                const dstBase = posBase + w * 4;
+                // Read word w from all 4 chunks at positions that become consecutive in output
+                mem32[dstBase] = inputWords[chunk0WordBase + blockWordOff + w];
+                mem32[dstBase + 1] = inputWords[chunk1WordBase + blockWordOff + w];
+                mem32[dstBase + 2] = inputWords[chunk2WordBase + blockWordOff + w];
+                mem32[dstBase + 3] = inputWords[chunk3WordBase + blockWordOff + w];
+            }
+        }
+    }
+    else {
+        // Slow path: byte-by-byte reconstruction, still cache-friendly write pattern
+        for (let pos = 0; pos < 16; pos++) {
+            const posBase = BATCH_BASE + pos * 64;
+            const blockByteOff = pos * 64; // 64 bytes per block
+            for (let w = 0; w < 16; w++) {
+                const dstBase = posBase + w * 4;
+                const wordByteOff = w * 4;
+                // Chunk 0
+                const off0 = chunkOffsets[0] + blockByteOff + wordByteOff;
+                mem32[dstBase] =
+                    input[off0] | (input[off0 + 1] << 8) | (input[off0 + 2] << 16) | (input[off0 + 3] << 24);
+                // Chunk 1
+                const off1 = chunkOffsets[1] + blockByteOff + wordByteOff;
+                mem32[dstBase + 1] =
+                    input[off1] | (input[off1 + 1] << 8) | (input[off1 + 2] << 16) | (input[off1 + 3] << 24);
+                // Chunk 2
+                const off2 = chunkOffsets[2] + blockByteOff + wordByteOff;
+                mem32[dstBase + 2] =
+                    input[off2] | (input[off2 + 1] << 8) | (input[off2 + 2] << 16) | (input[off2 + 3] << 24);
+                // Chunk 3
+                const off3 = chunkOffsets[3] + blockByteOff + wordByteOff;
+                mem32[dstBase + 3] =
+                    input[off3] | (input[off3 + 1] << 8) | (input[off3 + 2] << 16) | (input[off3 + 3] << 24);
+            }
+        }
+    }
+}
+// Pre-computed memory offsets for SIMD operations (single-block mode)
+const SIMD_CV_BASE = wasm_simd_js_1.SIMD_MEMORY.CHAINING_VALUES / 4;
+const SIMD_OUT_BASE = wasm_simd_js_1.SIMD_MEMORY.OUTPUT / 4;
+const SIMD_COUNTER_LOW_BASE = wasm_simd_js_1.SIMD_MEMORY.COUNTER_LOW / 4;
+const SIMD_COUNTER_HIGH_BASE = wasm_simd_js_1.SIMD_MEMORY.COUNTER_HIGH / 4;
+const SIMD_BLOCK_LEN_BASE = wasm_simd_js_1.SIMD_MEMORY.BLOCK_LEN / 4;
+// Pre-computed memory offsets for batch SIMD operations (16-block mode)
+const BATCH_CV_BASE = wasm_simd_js_1.SIMD_MEMORY.BATCH_CV / 4;
+const BATCH_COUNTER_LOW_BASE = wasm_simd_js_1.SIMD_MEMORY.BATCH_COUNTER_LOW / 4;
+const BATCH_FLAGS_BASE_OFFSET = wasm_simd_js_1.SIMD_MEMORY.BATCH_FLAGS_BASE / 4;
+const BATCH_OUTPUT_BASE = wasm_simd_js_1.SIMD_MEMORY.BATCH_OUTPUT / 4;
+// Reusable arrays for batch processing
+const batchChunkOffsets = new Uint32Array(4);
+const SIMD_FLAGS_BASE = wasm_simd_js_1.SIMD_MEMORY.FLAGS / 4;
+/**
+ * Set up chaining values in SIMD memory (transposed layout).
+ * Optimized: unrolled loops for common case of 4 chunks.
+ * cvs is flat: [cv0_word0..cv0_word7, cv1_word0..cv1_word7, ...]
+ */
+function setupSimdCvs(cvs, // Flat array: 4 × 8 words
+mem32, count) {
+    // Unrolled for 4 chunks (common case)
+    if (count === 4) {
+        for (let w = 0; w < 8; w++) {
+            const base = SIMD_CV_BASE + w * 4;
+            mem32[base] = cvs[w]; // cv0[w]
+            mem32[base + 1] = cvs[8 + w]; // cv1[w]
+            mem32[base + 2] = cvs[16 + w]; // cv2[w]
+            mem32[base + 3] = cvs[24 + w]; // cv3[w]
+        }
+    }
+    else {
+        for (let w = 0; w < 8; w++) {
+            const base = SIMD_CV_BASE + w * 4;
+            for (let c = 0; c < count; c++) {
+                mem32[base + c] = cvs[c * 8 + w];
+            }
+            for (let c = count; c < 4; c++) {
+                mem32[base + c] = 0;
+            }
+        }
+    }
+}
+/**
+ * Set up SIMD parameters (counters, flags, block lengths).
+ */
+function setupSimdParams(mem32, counters, blockLens, flagsArr, count) {
+    // Most chunk counters fit in 32 bits, so counter high is usually 0
+    for (let i = 0; i < count; i++) {
+        mem32[SIMD_COUNTER_LOW_BASE + i] = counters[i];
+        mem32[SIMD_COUNTER_HIGH_BASE + i] = 0; // Assume counters fit in 32 bits
+        mem32[SIMD_BLOCK_LEN_BASE + i] = blockLens[i];
+        mem32[SIMD_FLAGS_BASE + i] = flagsArr[i];
+    }
+    // Zero unused slots
+    for (let i = count; i < 4; i++) {
+        mem32[SIMD_COUNTER_LOW_BASE + i] = 0;
+        mem32[SIMD_COUNTER_HIGH_BASE + i] = 0;
+        mem32[SIMD_BLOCK_LEN_BASE + i] = 0;
+        mem32[SIMD_FLAGS_BASE + i] = 0;
+    }
+}
+/**
+ * Read output CVs from SIMD memory (untranspose).
+ */
+function readSimdOutputCvs(mem32, outputCvs, // Flat array: 4 × 8 words
+count) {
+    // Unrolled for 4 chunks (common case)
+    if (count === 4) {
+        for (let w = 0; w < 8; w++) {
+            const base = SIMD_OUT_BASE + w * 4;
+            outputCvs[w] = mem32[base];
+            outputCvs[8 + w] = mem32[base + 1];
+            outputCvs[16 + w] = mem32[base + 2];
+            outputCvs[24 + w] = mem32[base + 3];
+        }
+    }
+    else {
+        for (let w = 0; w < 8; w++) {
+            const base = SIMD_OUT_BASE + w * 4;
+            for (let c = 0; c < count; c++) {
+                outputCvs[c * 8 + w] = mem32[base + c];
+            }
+        }
+    }
+}
+function getBlockWords() {
+    if (!blockWords) {
+        blockWords = new Uint32Array(16);
+    }
+    return blockWords;
+}
+/**
+ * Hash a single chunk (up to 1024 bytes) with pre-created inputWords view.
+ * This is the optimized version that avoids creating Uint32Array views per chunk.
+ * (Fleek optimization Step 8)
+ */
+function hashChunkWithWords(input, inputWords, // Pre-created view of entire input
+inputOffset, inputLen, chunkCounter, flags, cv, cvOffset) {
+    // Use reusable temporary CV for intermediate blocks (single-threaded safe)
+    reusableTempCv.set(constants_js_1.IV);
+    // Process full blocks
+    const fullBlocks = inputLen >>> 6; // inputLen / 64
+    const remainder = inputLen & 63; // inputLen % 64
+    // Calculate word offset for this chunk within the pre-created view
+    const chunkWordOffset = inputOffset >>> 2;
+    // Fast path for full chunks with aligned little-endian input
+    if (inputWords && remainder === 0 && inputLen === constants_js_1.CHUNK_LEN) {
+        // All 16 blocks are full, use fast path exclusively
+        let wordOff = chunkWordOffset;
+        // Block 0 (CHUNK_START)
+        (0, compress_js_1.compress)(reusableTempCv, 0, inputWords, wordOff, reusableTempCv, 0, false, chunkCounter, constants_js_1.BLOCK_LEN, flags | constants_js_1.CHUNK_START);
+        wordOff += 16;
+        // Blocks 1-14 (no special flags)
+        for (let i = 1; i < 15; i++) {
+            (0, compress_js_1.compress)(reusableTempCv, 0, inputWords, wordOff, reusableTempCv, 0, false, chunkCounter, constants_js_1.BLOCK_LEN, flags);
+            wordOff += 16;
+        }
+        // Block 15 (CHUNK_END)
+        (0, compress_js_1.compress)(reusableTempCv, 0, inputWords, wordOff, reusableTempCv, 0, false, chunkCounter, constants_js_1.BLOCK_LEN, flags | constants_js_1.CHUNK_END);
+        cv.set(reusableTempCv, cvOffset);
+        return;
+    }
+    // Slower path for partial chunks or non-aligned input
+    const totalBlocks = fullBlocks + (remainder > 0 ? 1 : 0);
+    const block = getBlockWords();
+    for (let blockIdx = 0; blockIdx < totalBlocks; blockIdx++) {
+        const isFirst = blockIdx === 0;
+        const isLast = blockIdx === totalBlocks - 1;
+        const blockStart = blockIdx << 6;
+        const blockLen = isLast && remainder > 0 ? remainder : constants_js_1.BLOCK_LEN;
+        // Determine flags for this block
+        let blockFlags = flags;
+        if (isFirst)
+            blockFlags |= constants_js_1.CHUNK_START;
+        if (isLast)
+            blockFlags |= constants_js_1.CHUNK_END;
+        // Load block words
+        if (isLast && remainder > 0) {
+            // Partial final block - need zero padding
+            (0, utils_js_1.readLittleEndianWordsPartial)(input, inputOffset + blockStart, blockLen, block);
+        }
+        else if (inputWords && chunkWordOffset + (blockStart >>> 2) + 16 <= inputWords.length) {
+            // Fast path: use pre-created view directly
+            (0, compress_js_1.compress)(reusableTempCv, 0, inputWords, chunkWordOffset + (blockStart >>> 2), reusableTempCv, 0, false, chunkCounter, blockLen, blockFlags);
+            continue;
+        }
+        else {
+            (0, utils_js_1.readLittleEndianWordsFull)(input, inputOffset + blockStart, block);
+        }
+        (0, compress_js_1.compress)(reusableTempCv, 0, block, 0, reusableTempCv, 0, false, chunkCounter, blockLen, blockFlags);
+    }
+    // Copy result to output
+    cv.set(reusableTempCv, cvOffset);
+}
+/**
+ * Hash input using pure JavaScript.
+ * Handles the full Merkle tree construction.
+ */
+function hashPureJS(input, outputLen) {
+    const inputLen = input.length;
+    // Special case: empty input
+    if (inputLen === 0) {
+        const block = getBlockWords();
+        block.fill(0);
+        // Use reusable output buffer for common 32-byte case
+        const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+        (0, compress_js_1.compress)(constants_js_1.IV, 0, block, 0, out, 0, outputLen > 32, 0, 0, constants_js_1.CHUNK_START | constants_js_1.CHUNK_END | constants_js_1.ROOT);
+        // Return result - use pre-created view for common 32-byte case
+        if (outputLen === 32 && utils_js_1.IS_LITTLE_ENDIAN) {
+            return reusableOut8View.slice();
+        }
+        const result = new Uint8Array(outputLen);
+        if (utils_js_1.IS_LITTLE_ENDIAN) {
+            result.set(new Uint8Array(out.buffer, 0, outputLen));
+        }
+        else {
+            (0, utils_js_1.writeLittleEndianBytesPartial)(out, 0, result, 0, outputLen);
+        }
+        return result;
+    }
+    // Calculate number of chunks
+    const numChunks = Math.ceil(inputLen / constants_js_1.CHUNK_LEN);
+    // Single chunk optimization
+    if (numChunks === 1) {
+        // Use reusable output buffer for common 32-byte case
+        const cv = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+        hashChunkRoot(input, 0, inputLen, 0, 0, cv, outputLen > 32);
+        // Return result - use pre-created view for common 32-byte case
+        if (outputLen === 32 && utils_js_1.IS_LITTLE_ENDIAN) {
+            return reusableOut8View.slice();
+        }
+        const result = new Uint8Array(outputLen);
+        if (utils_js_1.IS_LITTLE_ENDIAN) {
+            result.set(new Uint8Array(cv.buffer, 0, outputLen));
+        }
+        else {
+            (0, utils_js_1.writeLittleEndianBytesPartial)(cv, 0, result, 0, outputLen);
+        }
+        return result;
+    }
+    // Multiple chunks - need Merkle tree
+    // Use the global contiguous CV stack (no allocation)
+    const stack = HYPER_CV_STACK;
+    let stackLen = 0;
+    // Use reusable buffers (single-threaded safe)
+    const chunkCv = reusableChunkCv;
+    const parentBlock = reusablePureParentBlock;
+    const parentCv = reusablePureParentCv;
+    // Create Uint32Array view ONCE for entire input (Fleek optimization Step 8)
+    // This avoids creating views inside each chunk/block processing
+    let inputWords = null;
+    const canUseFastPath = utils_js_1.IS_LITTLE_ENDIAN && input.byteOffset % 4 === 0;
+    if (canUseFastPath) {
+        inputWords = new Uint32Array(input.buffer, input.byteOffset, inputLen >>> 2);
+    }
+    // Determine how many full chunks we have
+    const fullChunks = inputLen >>> 10; // inputLen / 1024
+    const lastChunkLen = inputLen & 1023; // inputLen % 1024
+    // Process all full chunks with fast path (inlined for performance)
+    if (canUseFastPath && inputWords) {
+        for (let chunkIdx = 0; chunkIdx < fullChunks; chunkIdx++) {
+            // Inline chunk processing for full chunks
+            chunkCv.set(constants_js_1.IV);
+            let wordOff = chunkIdx << 8; // chunkIdx * 256 (CHUNK_LEN/4)
+            // Block 0 (CHUNK_START)
+            (0, compress_js_1.compress)(chunkCv, 0, inputWords, wordOff, chunkCv, 0, false, chunkIdx, constants_js_1.BLOCK_LEN, constants_js_1.CHUNK_START);
+            wordOff += 16;
+            // Blocks 1-14 (no special flags)
+            for (let b = 1; b < 15; b++) {
+                (0, compress_js_1.compress)(chunkCv, 0, inputWords, wordOff, chunkCv, 0, false, chunkIdx, constants_js_1.BLOCK_LEN, 0);
+                wordOff += 16;
+            }
+            // Block 15 (CHUNK_END)
+            (0, compress_js_1.compress)(chunkCv, 0, inputWords, wordOff, chunkCv, 0, false, chunkIdx, constants_js_1.BLOCK_LEN, constants_js_1.CHUNK_END);
+            // Merge completed subtrees (avoid subarray by using index math)
+            let totalChunks = chunkIdx + 1;
+            let cvSrcOff = 0;
+            let cvSrc = chunkCv;
+            // Check if this is the last chunk overall
+            const isLastChunk = chunkIdx === fullChunks - 1 && lastChunkLen === 0;
+            while ((totalChunks & 1) === 0 && stackLen > 0) {
+                // Skip final merge if it would produce the root; let finalization handle it with ROOT flag
+                if (stackLen === 1 && isLastChunk) {
+                    break;
+                }
+                stackLen--;
+                const stackOff = stackLen * 8;
+                // Copy left CV from stack to parentBlock[0..7] (unrolled)
+                copyCV8(stack, stackOff, parentBlock, 0);
+                // Copy current CV to parentBlock[8..15] (unrolled)
+                copyCV8(cvSrc, cvSrcOff, parentBlock, 8);
+                (0, compress_js_1.compress)(constants_js_1.IV, 0, parentBlock, 0, parentCv, 0, false, 0, constants_js_1.BLOCK_LEN, constants_js_1.PARENT);
+                cvSrc = parentCv;
+                cvSrcOff = 0;
+                totalChunks >>>= 1;
+            }
+            // Push CV to stack (unrolled)
+            const stackOff = stackLen * 8;
+            copyCV8(cvSrc, cvSrcOff, stack, stackOff);
+            stackLen++;
+        }
+        // Process last partial chunk if any
+        if (lastChunkLen > 0) {
+            hashChunkWithWords(input, inputWords, fullChunks * constants_js_1.CHUNK_LEN, lastChunkLen, fullChunks, 0, chunkCv, 0);
+            let totalChunks = fullChunks + 1;
+            let newCv = chunkCv;
+            let newCvOffset = 0;
+            while ((totalChunks & 1) === 0 && stackLen > 0) {
+                // Skip final merge; this IS the last chunk, let finalization handle ROOT flag
+                if (stackLen === 1) {
+                    break;
+                }
+                stackLen--;
+                const stackOff = stackLen * 8;
+                // Copy from stack to parentBlock[0..7] (unrolled)
+                copyCV8(stack, stackOff, parentBlock, 0);
+                // Copy from newCv to parentBlock[8..15] (unrolled)
+                copyCV8(newCv, newCvOffset, parentBlock, 8);
+                (0, compress_js_1.compress)(constants_js_1.IV, 0, parentBlock, 0, parentCv, 0, false, 0, constants_js_1.BLOCK_LEN, constants_js_1.PARENT);
+                newCv = parentCv;
+                newCvOffset = 0;
+                totalChunks >>>= 1;
+            }
+            // Push CV to stack (unrolled)
+            const pushOff = stackLen * 8;
+            copyCV8(newCv, newCvOffset, stack, pushOff);
+            stackLen++;
+        }
+    }
+    else {
+        // Slow path for unaligned or big-endian
+        for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
+            const chunkStart = chunkIdx * constants_js_1.CHUNK_LEN;
+            const chunkLen = Math.min(constants_js_1.CHUNK_LEN, inputLen - chunkStart);
+            hashChunkWithWords(input, inputWords, chunkStart, chunkLen, chunkIdx, 0, chunkCv, 0);
+            // Merge completed subtrees
+            let totalChunks = chunkIdx + 1;
+            let newCv = chunkCv;
+            let newCvOffset = 0;
+            // Check if this is the last chunk
+            const isLastChunk = chunkIdx === numChunks - 1;
+            while ((totalChunks & 1) === 0 && stackLen > 0) {
+                // Skip final merge if it would produce the root; let finalization handle it with ROOT flag
+                if (stackLen === 1 && isLastChunk) {
+                    break;
+                }
+                stackLen--;
+                const stackOff = stackLen * 8;
+                // Copy from stack to parentBlock[0..7] (unrolled)
+                copyCV8(stack, stackOff, parentBlock, 0);
+                // Copy from newCv to parentBlock[8..15] (unrolled)
+                copyCV8(newCv, newCvOffset, parentBlock, 8);
+                (0, compress_js_1.compress)(constants_js_1.IV, 0, parentBlock, 0, parentCv, 0, false, 0, constants_js_1.BLOCK_LEN, constants_js_1.PARENT);
+                newCv = parentCv;
+                newCvOffset = 0;
+                totalChunks >>>= 1;
+            }
+            // Push CV to stack (unrolled)
+            const pushOff = stackLen * 8;
+            copyCV8(newCv, newCvOffset, stack, pushOff);
+            stackLen++;
+        }
+    }
+    // Finalize: merge remaining stack entries
+    while (stackLen > 1) {
+        stackLen--;
+        const rightOff = stackLen * 8;
+        stackLen--;
+        const leftOff = stackLen * 8;
+        // Copy left CV to parentBlock[0..7] and right CV to parentBlock[8..15] (unrolled)
+        copyCV8(stack, leftOff, parentBlock, 0);
+        copyCV8(stack, rightOff, parentBlock, 8);
+        if (stackLen === 0) {
+            // This is the root - use reusable output buffer for common 32-byte case
+            const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+            (0, compress_js_1.compress)(constants_js_1.IV, 0, parentBlock, 0, out, 0, outputLen > 32, 0, constants_js_1.BLOCK_LEN, constants_js_1.PARENT | constants_js_1.ROOT);
+            // Return result - use pre-created view for common 32-byte case
+            if (outputLen === 32 && utils_js_1.IS_LITTLE_ENDIAN) {
+                return reusableOut8View.slice();
+            }
+            const result = new Uint8Array(outputLen);
+            if (utils_js_1.IS_LITTLE_ENDIAN) {
+                result.set(new Uint8Array(out.buffer, 0, outputLen));
+            }
+            else {
+                (0, utils_js_1.writeLittleEndianBytesPartial)(out, 0, result, 0, outputLen);
+            }
+            return result;
+        }
+        (0, compress_js_1.compress)(constants_js_1.IV, 0, parentBlock, 0, parentCv, 0, false, 0, constants_js_1.BLOCK_LEN, constants_js_1.PARENT);
+        // Push to stack (unrolled)
+        copyCV8(parentCv, 0, stack, stackLen * 8);
+        stackLen++;
+    }
+    // Single entry in stack - this is the root
+    const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+    const lastBlock = getBlockWords();
+    lastBlock.fill(0);
+    // Copy first 8 words from stack (unrolled)
+    copyCV8(stack, 0, lastBlock, 0);
+    (0, compress_js_1.compress)(constants_js_1.IV, 0, lastBlock, 0, out, 0, outputLen > 32, 0, constants_js_1.BLOCK_LEN, constants_js_1.ROOT);
+    // Return result - use pre-created view for common 32-byte case
+    if (outputLen === 32 && utils_js_1.IS_LITTLE_ENDIAN) {
+        return reusableOut8View.slice();
+    }
+    const result = new Uint8Array(outputLen);
+    if (utils_js_1.IS_LITTLE_ENDIAN) {
+        result.set(new Uint8Array(out.buffer, 0, outputLen));
+    }
+    else {
+        (0, utils_js_1.writeLittleEndianBytesPartial)(out, 0, result, 0, outputLen);
+    }
+    return result;
+}
+/**
+ * Hash a single chunk that is also the root (single chunk input).
+ */
+function hashChunkRoot(input, inputOffset, inputLen, chunkCounter, flags, out, fullOutput) {
+    // Use reusable tempCv (single-threaded safe)
+    reusableTempCv.set(constants_js_1.IV);
+    const block = getBlockWords();
+    // Process full blocks
+    const fullBlocks = inputLen >>> 6;
+    const remainder = inputLen & 63;
+    const totalBlocks = fullBlocks + (remainder > 0 ? 1 : 0) || 1; // At least 1 block
+    // Create a Uint32Array view if possible
+    let inputWords = null;
+    if (utils_js_1.IS_LITTLE_ENDIAN && (input.byteOffset + inputOffset) % 4 === 0 && inputLen >= 4) {
+        inputWords = new Uint32Array(input.buffer, input.byteOffset + inputOffset, inputLen >>> 2);
+    }
+    for (let blockIdx = 0; blockIdx < totalBlocks; blockIdx++) {
+        const isFirst = blockIdx === 0;
+        const isLast = blockIdx === totalBlocks - 1;
+        const blockStart = blockIdx << 6;
+        const blockLen = isLast ? remainder || (inputLen > 0 ? constants_js_1.BLOCK_LEN : 0) : constants_js_1.BLOCK_LEN;
+        // Determine flags
+        let blockFlags = flags;
+        if (isFirst)
+            blockFlags |= constants_js_1.CHUNK_START;
+        if (isLast)
+            blockFlags |= constants_js_1.CHUNK_END | constants_js_1.ROOT;
+        // Load block
+        if (isLast && remainder > 0) {
+            (0, utils_js_1.readLittleEndianWordsPartial)(input, inputOffset + blockStart, blockLen, block);
+        }
+        else if (inputLen === 0) {
+            block.fill(0);
+        }
+        else if (inputWords && (blockStart >>> 2) + 16 <= inputWords.length) {
+            // Fast path
+            (0, compress_js_1.compress)(reusableTempCv, 0, inputWords, blockStart >>> 2, isLast ? out : reusableTempCv, 0, isLast && fullOutput, chunkCounter, blockLen, blockFlags);
+            continue;
+        }
+        else {
+            (0, utils_js_1.readLittleEndianWordsFull)(input, inputOffset + blockStart, block);
+        }
+        (0, compress_js_1.compress)(reusableTempCv, 0, block, 0, isLast ? out : reusableTempCv, 0, isLast && fullOutput, chunkCounter, blockLen, blockFlags);
+    }
+}
+/**
+ * Hash using WASM SIMD - processes 4 chunks in parallel.
+ * Falls back to pure JS if SIMD fails.
+ */
+function hashSimd(input, outputLen) {
+    const mem = (0, wasm_simd_js_1.getSimdMemory)();
+    if (!mem) {
+        return hashPureJS(input, outputLen);
+    }
+    const { view32 } = mem;
+    const inputLen = input.length;
+    const numChunks = Math.ceil(inputLen / constants_js_1.CHUNK_LEN);
+    // For small inputs, pure JS is faster (no transpose overhead)
+    if (numChunks < 4) {
+        return hashPureJS(input, outputLen);
+    }
+    // Try to use WASM arena buffers (zero JS heap allocation)
+    // Falls back to JS buffers if arena not available
+    const arena = (0, wasm_simd_js_1.getArenaBuffers)();
+    const useWasmParent = arena !== null; // Use WASM parent compress when arena available
+    let stack;
+    let tempCvs;
+    let parentBlock;
+    let parentCv;
+    if (arena) {
+        // Use WASM-backed arena buffers
+        stack = arena.cvStack;
+        tempCvs = arena.tempCvs;
+        parentBlock = arena.parentBlock;
+        parentCv = arena.chunkCv;
+    }
+    else {
+        // Fallback to JS heap buffers - use global contiguous stack (no allocation)
+        stack = HYPER_CV_STACK;
+        tempCvs = reusableSimdCvs;
+        parentBlock = reusableSimdParentBlock;
+        parentCv = reusableSimdParentCv;
+    }
+    let stackLen = 0;
+    // Use TypedArrays instead of JS arrays for block parameters
+    const offsets = reusableOffsets;
+    const counters = reusableCounters;
+    const blockLens = reusableBlockLens;
+    const flagsArr = reusableFlags;
+    // Create Uint32Array view once for entire hash call (optimization: avoid allocation in hot loop)
+    const inputWords = utils_js_1.IS_LITTLE_ENDIAN && input.byteOffset % 4 === 0
+        ? new Uint32Array(input.buffer, input.byteOffset, input.byteLength >>> 2)
+        : null;
+    // Calculate number of full chunks (1024 bytes each)
+    const numFullChunks = inputLen >>> 10; // inputLen / 1024
+    // Process chunks in groups of 4
+    let chunkIdx = 0;
+    while (chunkIdx < numChunks) {
+        const groupSize = Math.min(4, numChunks - chunkIdx);
+        // === BATCH FAST PATH: 4 full chunks ===
+        // Use compressChunks4x for groups of exactly 4 full chunks
+        // This reduces 16 WASM calls to 1 per group
+        const canUseBatchPath = groupSize === 4 && chunkIdx + 4 <= numFullChunks;
+        if (canUseBatchPath) {
+            // Set up chunk offsets for batch transpose
+            batchChunkOffsets[0] = chunkIdx * constants_js_1.CHUNK_LEN;
+            batchChunkOffsets[1] = (chunkIdx + 1) * constants_js_1.CHUNK_LEN;
+            batchChunkOffsets[2] = (chunkIdx + 2) * constants_js_1.CHUNK_LEN;
+            batchChunkOffsets[3] = (chunkIdx + 3) * constants_js_1.CHUNK_LEN;
+            // Transpose all 64 blocks (4 chunks × 16 blocks) at once
+            transposeBatchToSimd(input, batchChunkOffsets, view32, inputWords);
+            // Set up initial CVs (IV) in batch memory - transposed layout
+            for (let w = 0; w < 8; w++) {
+                const ivWord = constants_js_1.IV[w];
+                const base = BATCH_CV_BASE + w * 4;
+                view32[base] = ivWord;
+                view32[base + 1] = ivWord;
+                view32[base + 2] = ivWord;
+                view32[base + 3] = ivWord;
+            }
+            // Set up counters in batch memory
+            view32[BATCH_COUNTER_LOW_BASE] = chunkIdx;
+            view32[BATCH_COUNTER_LOW_BASE + 1] = chunkIdx + 1;
+            view32[BATCH_COUNTER_LOW_BASE + 2] = chunkIdx + 2;
+            view32[BATCH_COUNTER_LOW_BASE + 3] = chunkIdx + 3;
+            // Set up base flags (0 - no keyed hashing)
+            view32[BATCH_FLAGS_BASE_OFFSET] = 0;
+            view32[BATCH_FLAGS_BASE_OFFSET + 1] = 0;
+            view32[BATCH_FLAGS_BASE_OFFSET + 2] = 0;
+            view32[BATCH_FLAGS_BASE_OFFSET + 3] = 0;
+            // Run batched compress (16 blocks × 4 chunks in one call!)
+            (0, wasm_simd_js_1.runCompressChunks4x)();
+            // Read output CVs from batch output - untranspose to tempCvs
+            for (let w = 0; w < 8; w++) {
+                const base = BATCH_OUTPUT_BASE + w * 4;
+                tempCvs[w] = view32[base]; // chunk 0
+                tempCvs[8 + w] = view32[base + 1]; // chunk 1
+                tempCvs[16 + w] = view32[base + 2]; // chunk 2
+                tempCvs[24 + w] = view32[base + 3]; // chunk 3
+            }
+        }
+        else {
+            // === STANDARD PATH: block-by-block processing ===
+            // Used for partial chunks or groups < 4
+            // Initialize CVs for this group to IV (flat array: 4 × 8 words)
+            for (let g = 0; g < groupSize; g++) {
+                const base = g * 8;
+                tempCvs[base] = constants_js_1.IV[0];
+                tempCvs[base + 1] = constants_js_1.IV[1];
+                tempCvs[base + 2] = constants_js_1.IV[2];
+                tempCvs[base + 3] = constants_js_1.IV[3];
+                tempCvs[base + 4] = constants_js_1.IV[4];
+                tempCvs[base + 5] = constants_js_1.IV[5];
+                tempCvs[base + 6] = constants_js_1.IV[6];
+                tempCvs[base + 7] = constants_js_1.IV[7];
+            }
+            // Process all 16 blocks of each chunk in this group
+            for (let blockIdx = 0; blockIdx < 16; blockIdx++) {
+                // Calculate block offsets and parameters (reuse arrays)
+                for (let g = 0; g < groupSize; g++) {
+                    const thisChunkIdx = chunkIdx + g;
+                    const chunkStart = thisChunkIdx * constants_js_1.CHUNK_LEN;
+                    const chunkLen = Math.min(constants_js_1.CHUNK_LEN, inputLen - chunkStart);
+                    const thisBlockStart = chunkStart + blockIdx * constants_js_1.BLOCK_LEN;
+                    // Determine block length for this specific block
+                    const blockStartInChunk = blockIdx * constants_js_1.BLOCK_LEN;
+                    let thisBlockLen = constants_js_1.BLOCK_LEN;
+                    if (blockStartInChunk >= chunkLen) {
+                        thisBlockLen = 0;
+                    }
+                    else if (blockStartInChunk + constants_js_1.BLOCK_LEN > chunkLen) {
+                        thisBlockLen = chunkLen - blockStartInChunk;
+                    }
+                    offsets[g] = thisBlockStart;
+                    counters[g] = thisChunkIdx;
+                    // Determine flags
+                    let flags = 0;
+                    if (blockIdx === 0)
+                        flags |= constants_js_1.CHUNK_START;
+                    const totalBlocksInChunk = Math.ceil(chunkLen / constants_js_1.BLOCK_LEN) || 1;
+                    if (blockIdx === totalBlocksInChunk - 1)
+                        flags |= constants_js_1.CHUNK_END;
+                    blockLens[g] = thisBlockLen;
+                    flagsArr[g] = flags;
+                }
+                // Check if any blocks need processing
+                if (blockLens[0] === 0 && blockLens[1] === 0 && blockLens[2] === 0 && blockLens[3] === 0)
+                    continue;
+                // Transpose blocks into SIMD memory (pass pre-created view to avoid allocation)
+                transposeBlocksToSimd(input, offsets, blockLens, view32, groupSize, inputWords);
+                // Set up CVs in SIMD memory
+                setupSimdCvs(tempCvs, view32, groupSize);
+                // Set up parameters
+                setupSimdParams(view32, counters, blockLens, flagsArr, groupSize);
+                // Run SIMD compress
+                (0, wasm_simd_js_1.runCompress4x)();
+                // Read output CVs back
+                readSimdOutputCvs(view32, simdChunkCvs, groupSize);
+                // Update tempCvs - copy from simdChunkCvs (both are flat 32-word arrays)
+                // simdChunkCvs layout matches tempCvs: [cv0_w0..cv0_w7, cv1_w0..cv1_w7, ...]
+                // IMPORTANT: Only update CVs for chunks that had data in this block!
+                // Skipping this check would corrupt CVs for partial chunks after their final block.
+                for (let g = 0; g < groupSize; g++) {
+                    if (blockLens[g] === 0)
+                        continue; // Don't update CV for chunks with no data in this block
+                    const base = g * 8;
+                    tempCvs[base] = simdChunkCvs[base];
+                    tempCvs[base + 1] = simdChunkCvs[base + 1];
+                    tempCvs[base + 2] = simdChunkCvs[base + 2];
+                    tempCvs[base + 3] = simdChunkCvs[base + 3];
+                    tempCvs[base + 4] = simdChunkCvs[base + 4];
+                    tempCvs[base + 5] = simdChunkCvs[base + 5];
+                    tempCvs[base + 6] = simdChunkCvs[base + 6];
+                    tempCvs[base + 7] = simdChunkCvs[base + 7];
+                }
+            }
+        }
+        // Merge each chunk's CV into the Merkle tree
+        for (let g = 0; g < groupSize; g++) {
+            const thisChunkIdx = chunkIdx + g;
+            // Merge completed subtrees
+            let totalChunks = thisChunkIdx + 1;
+            // Track newCv source - either from tempCvs or parentCv
+            let newCvBase = g * 8; // Offset into tempCvs
+            let newCvSrc = tempCvs;
+            // Check if this is the last chunk
+            const isLastChunk = thisChunkIdx === numChunks - 1;
+            while ((totalChunks & 1) === 0 && stackLen > 0) {
+                // Skip final merge if it would produce the root; let finalization handle it with ROOT flag
+                if (stackLen === 1 && isLastChunk) {
+                    break;
+                }
+                // Pop left child
+                stackLen--;
+                const stackOff = stackLen * 8;
+                // Copy from stack to parentBlock[0..7] (unrolled)
+                copyCV8(stack, stackOff, parentBlock, 0);
+                // Copy from newCv source to parentBlock[8..15] (unrolled)
+                copyCV8(newCvSrc, newCvBase, parentBlock, 8);
+                if (useWasmParent) {
+                    // WASM parent compress - data already in arena buffers
+                    (0, wasm_simd_js_1.runCompressParent)();
+                }
+                else {
+                    (0, compress_js_1.compress)(constants_js_1.IV, 0, parentBlock, 0, parentCv, 0, false, 0, constants_js_1.BLOCK_LEN, constants_js_1.PARENT);
+                }
+                newCvSrc = parentCv;
+                newCvBase = 0;
+                totalChunks >>>= 1;
+            }
+            // Push to stack (unrolled)
+            const pushOff = stackLen * 8;
+            copyCV8(newCvSrc, newCvBase, stack, pushOff);
+            stackLen++;
+        }
+        chunkIdx += groupSize;
+    }
+    // Finalize: merge remaining stack entries
+    while (stackLen > 1) {
+        stackLen--;
+        const rightOff = stackLen * 8;
+        stackLen--;
+        const leftOff = stackLen * 8;
+        // Copy left CV to parentBlock[0..7] and right CV to parentBlock[8..15] (unrolled)
+        copyCV8(stack, leftOff, parentBlock, 0);
+        copyCV8(stack, rightOff, parentBlock, 8);
+        if (stackLen === 0) {
+            // This is the root - use reusable output buffer
+            const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+            (0, compress_js_1.compress)(constants_js_1.IV, 0, parentBlock, 0, out, 0, outputLen > 32, 0, constants_js_1.BLOCK_LEN, constants_js_1.PARENT | constants_js_1.ROOT);
+            // Return result - use pre-created view for common 32-byte case
+            if (outputLen === 32 && utils_js_1.IS_LITTLE_ENDIAN) {
+                return reusableOut8View.slice();
+            }
+            const result = new Uint8Array(outputLen);
+            if (utils_js_1.IS_LITTLE_ENDIAN) {
+                result.set(new Uint8Array(out.buffer, 0, outputLen));
+            }
+            else {
+                (0, utils_js_1.writeLittleEndianBytesPartial)(out, 0, result, 0, outputLen);
+            }
+            return result;
+        }
+        if (useWasmParent) {
+            // WASM parent compress - data already in arena buffers
+            (0, wasm_simd_js_1.runCompressParent)();
+        }
+        else {
+            (0, compress_js_1.compress)(constants_js_1.IV, 0, parentBlock, 0, parentCv, 0, false, 0, constants_js_1.BLOCK_LEN, constants_js_1.PARENT);
+        }
+        // Push to stack (unrolled)
+        copyCV8(parentCv, 0, stack, stackLen * 8);
+        stackLen++;
+    }
+    // Single entry in stack - finalize as root
+    if (stackLen === 1) {
+        const block = getBlockWords();
+        block.fill(0);
+        // Copy first 8 words from stack (unrolled)
+        copyCV8(stack, 0, block, 0);
+        // Use reusable output buffer
+        const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+        (0, compress_js_1.compress)(constants_js_1.IV, 0, block, 0, out, 0, outputLen > 32, 0, constants_js_1.BLOCK_LEN, constants_js_1.ROOT);
+        // Return result - use pre-created view for common 32-byte case
+        if (outputLen === 32 && utils_js_1.IS_LITTLE_ENDIAN) {
+            return reusableOut8View.slice();
+        }
+        const result = new Uint8Array(outputLen);
+        if (utils_js_1.IS_LITTLE_ENDIAN) {
+            result.set(new Uint8Array(out.buffer, 0, outputLen));
+        }
+        else {
+            (0, utils_js_1.writeLittleEndianBytesPartial)(out, 0, result, 0, outputLen);
+        }
+        return result;
+    }
+    // Should not reach here
+    return hashPureJS(input, outputLen);
+}
+/**
+ * Hash input data and return the result.
+ * Automatically uses WASM SIMD for large inputs when available.
+ *
+ * @param input - Data to hash
+ * @param outputLength - Number of bytes to output (default: 32)
+ * @returns The hash output
+ */
+function hash(input, outputLength = constants_js_1.OUT_LEN) {
+    // For large inputs, use SIMD for ~1.5x performance improvement
+    if (input.length >= SIMD_THRESHOLD && ensureSimdSync()) {
+        return hashSimd(input, outputLength);
+    }
+    return hashPureJS(input, outputLength);
+}
+/**
+ * Pre-warm SIMD initialization (call early to avoid latency later).
+ */
+function warmupSimd() {
+    return ensureSimdSync();
+}
+/**
+ * Hash input data directly into a caller-provided output buffer.
+ * Zero-allocation for the common 32-byte case - ideal for performance-critical code.
+ *
+ * @param input - Data to hash
+ * @param output - Pre-allocated output buffer (must be at least outputLength bytes)
+ * @param outputLength - Number of bytes to output (default: 32, max: output.length)
+ */
+function hashInto(input, output, outputLength = constants_js_1.OUT_LEN) {
+    // Validate output buffer
+    if (output.length < outputLength) {
+        throw new Error(`Output buffer too small: ${output.length} < ${outputLength}`);
+    }
+    // For large inputs, use SIMD for ~1.5x performance improvement
+    if (input.length >= SIMD_THRESHOLD && ensureSimdSync()) {
+        hashSimdInto(input, output, outputLength);
+        return;
+    }
+    hashPureJSInto(input, output, outputLength);
+}
+/**
+ * Internal: Hash using pure JS, writing directly to output buffer.
+ */
+function hashPureJSInto(input, output, outputLen) {
+    const inputLen = input.length;
+    // Special case: empty input
+    if (inputLen === 0) {
+        const block = getBlockWords();
+        block.fill(0);
+        const out = outputLen <= 32 ? reusableOut8 : new Uint32Array(16);
+        (0, compress_js_1.compress)(constants_js_1.IV, 0, block, 0, out, 0, outputLen > 32, 0, 0, constants_js_1.CHUNK_START | constants_js_1.CHUNK_END | constants_js_1.ROOT);
+        // Copy result to output
+        if (utils_js_1.IS_LITTLE_ENDIAN) {
+            output.set(new Uint8Array(out.buffer, out.byteOffset, outputLen));
+        }
+        else {
+            (0, utils_js_1.writeLittleEndianBytesPartial)(out, 0, output, 0, outputLen);
+        }
+        return;
+    }
+    // Calculate number of chunks
+    const numChunks = Math.ceil(inputLen / constants_js_1.CHUNK_LEN);
+    // Single chunk optimization
+    if (numChunks === 1) {
+        const cv = outputLen <= 32 ? reusableOut8 : new Uint32Array(16);
+        hashChunkRoot(input, 0, inputLen, 0, 0, cv, outputLen > 32);
+        // Copy result to output
+        if (utils_js_1.IS_LITTLE_ENDIAN) {
+            output.set(new Uint8Array(cv.buffer, cv.byteOffset, outputLen));
+        }
+        else {
+            (0, utils_js_1.writeLittleEndianBytesPartial)(cv, 0, output, 0, outputLen);
+        }
+        return;
+    }
+    // Multiple chunks - delegate to hashPureJS and copy result
+    const result = hashPureJS(input, outputLen);
+    output.set(result);
+}
+/**
+ * Internal: Hash using SIMD, writing directly to output buffer.
+ */
+function hashSimdInto(input, output, outputLen) {
+    // Delegate to hashSimd and copy result (SIMD path already optimized)
+    const result = hashSimd(input, outputLen);
+    output.set(result);
+}

node_modules/@huggingface/blake3-jit/dist/commonjs/hasher.d.ts

@@ -0,0 +1,108 @@
+/**
+ * BLAKE3 Hasher - Incremental hashing with support for all modes
+ *
+ * Supports:
+ * - Regular hashing
+ * - Keyed hashing (MAC)
+ * - Key derivation (derive_key)
+ * - XOF (eXtendable Output Function) mode
+ */
+/**
+ * Output state for XOF (eXtendable Output Function) mode.
+ * Allows reading arbitrary amounts of output.
+ */
+export declare class XofReader {
+    private inputCv;
+    private blockWords;
+    private counter;
+    private blockLen;
+    private flags;
+    private outputBlock;
+    private outputBlockOffset;
+    constructor(inputCv: Uint32Array, blockWords: Uint32Array, counter: number, blockLen: number, flags: number);
+    /**
+     * Read the next `length` bytes of output.
+     */
+    read(length: number): Uint8Array;
+}
+/**
+ * Main BLAKE3 Hasher class.
+ *
+ * Usage:
+ *   const hasher = new Hasher();
+ *   hasher.update(data);
+ *   const hash = hasher.finalize();
+ *
+ * Or with chaining:
+ *   const hash = new Hasher().update(data).finalize();
+ */
+export declare class Hasher {
+    private chunkState;
+    private keyWords;
+    private cvStack;
+    private cvStackLen;
+    private flags;
+    private parentBlock;
+    private parentCv;
+    private chunkCv;
+    private outWords;
+    private finalizeCv;
+    /**
+     * Create a new Hasher.
+     *
+     * @param keyWords - Initial key words (IV for regular hashing)
+     * @param flags - Domain separation flags
+     */
+    constructor(keyWords?: Uint32Array, flags?: number);
+    /**
+     * Reset the hasher to process a new message with the same key/flags.
+     * Reuses all internal buffers — zero allocations.
+     */
+    reset(): this;
+    /**
+     * Create a new keyed hasher (MAC).
+     *
+     * @param key - 32-byte key
+     */
+    static newKeyed(key: Uint8Array): Hasher;
+    /**
+     * Create a new key derivation hasher.
+     *
+     * @param context - Context string for domain separation
+     */
+    static newDeriveKey(context: string): Hasher;
+    /**
+     * Push a chaining value onto the stack.
+     */
+    private pushCv;
+    /**
+     * Pop a chaining value from the stack.
+     */
+    private popCv;
+    /**
+     * Add a chunk's chaining value and merge completed subtrees.
+     */
+    private addChunkCv;
+    /**
+     * Update the hasher with input data.
+     *
+     * @param input - Data to hash
+     * @returns this (for chaining)
+     */
+    update(input: Uint8Array): this;
+    /**
+     * Get the output parameters (for XOF mode or finalization).
+     */
+    private finalizeOutput;
+    /**
+     * Finalize the hash and return the result.
+     *
+     * @param outputLength - Number of bytes to output (default: 32)
+     * @returns The hash output
+     */
+    finalize(outputLength?: number): Uint8Array;
+    /**
+     * Finalize and return an XOF reader for arbitrary-length output.
+     */
+    finalizeXof(): XofReader;
+}

node_modules/@huggingface/blake3-jit/dist/commonjs/hasher.js

@@ -0,0 +1,396 @@
+"use strict";
+/**
+ * BLAKE3 Hasher - Incremental hashing with support for all modes
+ *
+ * Supports:
+ * - Regular hashing
+ * - Keyed hashing (MAC)
+ * - Key derivation (derive_key)
+ * - XOF (eXtendable Output Function) mode
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hasher = exports.XofReader = void 0;
+const compress_js_1 = require("./compress.js");
+const constants_js_1 = require("./constants.js");
+const utils_js_1 = require("./utils.js");
+/**
+ * Output state for XOF (eXtendable Output Function) mode.
+ * Allows reading arbitrary amounts of output.
+ */
+class XofReader {
+    inputCv;
+    blockWords;
+    counter;
+    blockLen;
+    flags;
+    outputBlock;
+    outputBlockOffset;
+    constructor(inputCv, blockWords, counter, blockLen, flags) {
+        this.inputCv = inputCv;
+        this.blockWords = blockWords;
+        this.counter = counter;
+        this.blockLen = blockLen;
+        this.flags = flags | constants_js_1.ROOT;
+        this.outputBlock = new Uint32Array(16);
+        this.outputBlockOffset = 64; // Forces generation on first read
+    }
+    /**
+     * Read the next `length` bytes of output.
+     */
+    read(length) {
+        const output = new Uint8Array(length);
+        let outputOffset = 0;
+        while (outputOffset < length) {
+            // Generate new output block if needed
+            if (this.outputBlockOffset >= 64) {
+                (0, compress_js_1.compress)(this.inputCv, 0, this.blockWords, 0, this.outputBlock, 0, true, // full 64-byte output
+                this.counter++, this.blockLen, this.flags);
+                this.outputBlockOffset = 0;
+            }
+            // Copy bytes from output block
+            const available = 64 - this.outputBlockOffset;
+            const toCopy = Math.min(available, length - outputOffset);
+            // Optimized copy using writeLittleEndianBytesPartial
+            const wordOffset = this.outputBlockOffset >>> 2;
+            const byteWithinWord = this.outputBlockOffset & 3;
+            if (byteWithinWord === 0 && toCopy >= 4) {
+                // Aligned copy - can use word-at-a-time
+                const fullWords = toCopy >>> 2;
+                (0, utils_js_1.writeLittleEndianBytesPartial)(this.outputBlock, wordOffset, output, outputOffset, fullWords << 2);
+                const bytesCopied = fullWords << 2;
+                outputOffset += bytesCopied;
+                this.outputBlockOffset += bytesCopied;
+            }
+            else {
+                // Byte-by-byte for unaligned access
+                for (let i = 0; i < toCopy; i++) {
+                    const wordIdx = (this.outputBlockOffset + i) >>> 2;
+                    const byteIdx = (this.outputBlockOffset + i) & 3;
+                    output[outputOffset + i] = (this.outputBlock[wordIdx] >>> (byteIdx << 3)) & 0xff;
+                }
+                outputOffset += toCopy;
+                this.outputBlockOffset += toCopy;
+            }
+        }
+        return output;
+    }
+}
+exports.XofReader = XofReader;
+/**
+ * Chunk state for processing input data.
+ * Each chunk is 1024 bytes and produces an 8-word chaining value.
+ */
+class ChunkState {
+    chainingValue;
+    chunkCounter;
+    blockWords;
+    blockLen;
+    blocksCompressed;
+    flags;
+    constructor(keyWords, chunkCounter, flags) {
+        this.chainingValue = new Uint32Array(keyWords);
+        this.chunkCounter = chunkCounter;
+        this.blockWords = new Uint32Array(16);
+        this.blockLen = 0;
+        this.blocksCompressed = 0;
+        this.flags = flags;
+    }
+    resetTo(keyWords, chunkCounter, flags) {
+        this.chainingValue.set(keyWords);
+        this.chunkCounter = chunkCounter;
+        this.blockLen = 0;
+        this.blocksCompressed = 0;
+        this.flags = flags;
+    }
+    /**
+     * Get the flags for the current block.
+     */
+    startFlag() {
+        return this.blocksCompressed === 0 ? constants_js_1.CHUNK_START : 0;
+    }
+    /**
+     * Update the chunk state with input data.
+     * Returns the number of bytes consumed.
+     */
+    update(input, inputOffset, inputLen) {
+        let consumed = 0;
+        while (inputLen > 0) {
+            // If we have a full block, compress it
+            if (this.blockLen === constants_js_1.BLOCK_LEN) {
+                (0, compress_js_1.compress)(this.chainingValue, 0, this.blockWords, 0, this.chainingValue, 0, false, this.chunkCounter, constants_js_1.BLOCK_LEN, this.flags | this.startFlag());
+                this.blocksCompressed++;
+                this.blockLen = 0;
+            }
+            // Fill the block buffer
+            const want = constants_js_1.BLOCK_LEN - this.blockLen;
+            const take = Math.min(want, inputLen);
+            if (this.blockLen === 0 && take === constants_js_1.BLOCK_LEN) {
+                (0, utils_js_1.readLittleEndianWordsFull)(input, inputOffset, this.blockWords);
+            }
+            else {
+                // Partial block - byte-by-byte into correct position
+                for (let i = 0; i < take; i++) {
+                    const pos = this.blockLen + i;
+                    const wordIdx = pos >>> 2;
+                    const byteIdx = pos & 3;
+                    if (byteIdx === 0) {
+                        this.blockWords[wordIdx] = input[inputOffset + i];
+                    }
+                    else {
+                        this.blockWords[wordIdx] |= input[inputOffset + i] << (byteIdx << 3);
+                    }
+                }
+            }
+            this.blockLen += take;
+            inputOffset += take;
+            inputLen -= take;
+            consumed += take;
+        }
+        return consumed;
+    }
+    /**
+     * Finalize this chunk and return its output.
+     * Returns 8 words (chaining value) or 16 words (if root).
+     */
+    output() {
+        // Zero-pad unused words in blockWords to avoid stale data from previous blocks
+        // This is necessary when a partial block follows a full block within the same chunk
+        const usedWords = (this.blockLen + 3) >>> 2; // ceil(blockLen / 4)
+        for (let i = usedWords; i < 16; i++) {
+            this.blockWords[i] = 0;
+        }
+        return {
+            inputCv: this.chainingValue,
+            blockWords: this.blockWords,
+            blockLen: this.blockLen,
+            counter: this.chunkCounter,
+            flags: this.flags | this.startFlag() | constants_js_1.CHUNK_END,
+        };
+    }
+    /**
+     * Get the number of bytes in this chunk.
+     */
+    len() {
+        return this.blocksCompressed * constants_js_1.BLOCK_LEN + this.blockLen;
+    }
+}
+/**
+ * Main BLAKE3 Hasher class.
+ *
+ * Usage:
+ *   const hasher = new Hasher();
+ *   hasher.update(data);
+ *   const hash = hasher.finalize();
+ *
+ * Or with chaining:
+ *   const hash = new Hasher().update(data).finalize();
+ */
+class Hasher {
+    chunkState;
+    keyWords;
+    cvStack;
+    cvStackLen;
+    flags;
+    parentBlock;
+    parentCv;
+    chunkCv;
+    outWords;
+    finalizeCv;
+    /**
+     * Create a new Hasher.
+     *
+     * @param keyWords - Initial key words (IV for regular hashing)
+     * @param flags - Domain separation flags
+     */
+    constructor(keyWords, flags) {
+        this.keyWords = keyWords ? new Uint32Array(keyWords) : new Uint32Array(constants_js_1.IV);
+        this.flags = flags ?? 0;
+        this.chunkState = new ChunkState(this.keyWords, 0, this.flags);
+        this.cvStack = new Uint32Array(constants_js_1.MAX_DEPTH * 8);
+        this.cvStackLen = 0;
+        this.parentBlock = new Uint32Array(16);
+        this.parentCv = new Uint32Array(8);
+        this.chunkCv = new Uint32Array(8);
+        this.outWords = new Uint32Array(16);
+        this.finalizeCv = new Uint32Array(8);
+    }
+    /**
+     * Reset the hasher to process a new message with the same key/flags.
+     * Reuses all internal buffers — zero allocations.
+     */
+    reset() {
+        this.chunkState.resetTo(this.keyWords, 0, this.flags);
+        this.cvStackLen = 0;
+        return this;
+    }
+    /**
+     * Create a new keyed hasher (MAC).
+     *
+     * @param key - 32-byte key
+     */
+    static newKeyed(key) {
+        if (key.length !== constants_js_1.KEY_LEN) {
+            throw new Error(`Key must be ${constants_js_1.KEY_LEN} bytes, got ${key.length}`);
+        }
+        const keyWords = new Uint32Array(8);
+        if (utils_js_1.IS_LITTLE_ENDIAN) {
+            const view = new Uint32Array(key.buffer, key.byteOffset, 8);
+            keyWords.set(view);
+        }
+        else {
+            for (let i = 0; i < 8; i++) {
+                const off = i * 4;
+                keyWords[i] = key[off] | (key[off + 1] << 8) | (key[off + 2] << 16) | (key[off + 3] << 24);
+            }
+        }
+        return new Hasher(keyWords, constants_js_1.KEYED_HASH);
+    }
+    /**
+     * Create a new key derivation hasher.
+     *
+     * @param context - Context string for domain separation
+     */
+    static newDeriveKey(context) {
+        // First, hash the context string with DERIVE_KEY_CONTEXT flag
+        const contextBytes = (0, utils_js_1.encodeUTF8)(context);
+        const contextHasher = new Hasher(new Uint32Array(constants_js_1.IV), constants_js_1.DERIVE_KEY_CONTEXT);
+        contextHasher.update(contextBytes);
+        // Get the context key
+        const contextKey = new Uint32Array(8);
+        const output = contextHasher.finalizeOutput();
+        (0, compress_js_1.compress)(output.inputCv, 0, output.blockWords, 0, contextKey, 0, false, output.counter, output.blockLen, output.flags | constants_js_1.ROOT);
+        // Return a hasher initialized with the context key
+        return new Hasher(contextKey, constants_js_1.DERIVE_KEY_MATERIAL);
+    }
+    /**
+     * Push a chaining value onto the stack.
+     */
+    pushCv(cv, cvOffset) {
+        this.cvStack.set(cv.subarray(cvOffset, cvOffset + 8), this.cvStackLen * 8);
+        this.cvStackLen++;
+    }
+    /**
+     * Pop a chaining value from the stack.
+     */
+    popCv(out, outOffset) {
+        this.cvStackLen--;
+        out.set(this.cvStack.subarray(this.cvStackLen * 8, (this.cvStackLen + 1) * 8), outOffset);
+    }
+    /**
+     * Add a chunk's chaining value and merge completed subtrees.
+     */
+    addChunkCv(newCv, newCvOffset, totalChunks) {
+        const parentBlock = this.parentBlock;
+        const parentCv = this.parentCv;
+        while ((totalChunks & 1) === 0) {
+            // Pop left child, new CV is right child
+            this.popCv(parentBlock, 0);
+            parentBlock.set(newCv.subarray(newCvOffset, newCvOffset + 8), 8);
+            (0, compress_js_1.compress)(this.keyWords, 0, parentBlock, 0, parentCv, 0, false, 0, constants_js_1.BLOCK_LEN, this.flags | constants_js_1.PARENT);
+            newCv = parentCv;
+            newCvOffset = 0;
+            totalChunks >>>= 1;
+        }
+        this.pushCv(newCv, newCvOffset);
+    }
+    /**
+     * Update the hasher with input data.
+     *
+     * @param input - Data to hash
+     * @returns this (for chaining)
+     */
+    update(input) {
+        let inputOffset = 0;
+        let inputLen = input.length;
+        // Fill the current chunk
+        while (inputLen > 0) {
+            // If current chunk is full, finalize it and start a new one
+            if (this.chunkState.len() === constants_js_1.CHUNK_LEN) {
+                const output = this.chunkState.output();
+                const chunkCv = this.chunkCv;
+                (0, compress_js_1.compress)(output.inputCv, 0, output.blockWords, 0, chunkCv, 0, false, output.counter, output.blockLen, output.flags);
+                const totalChunks = this.chunkState.chunkCounter + 1;
+                this.addChunkCv(chunkCv, 0, totalChunks);
+                this.chunkState.resetTo(this.keyWords, totalChunks, this.flags);
+            }
+            // Fill the current chunk
+            const want = constants_js_1.CHUNK_LEN - this.chunkState.len();
+            const take = Math.min(want, inputLen);
+            this.chunkState.update(input, inputOffset, take);
+            inputOffset += take;
+            inputLen -= take;
+        }
+        return this;
+    }
+    /**
+     * Get the output parameters (for XOF mode or finalization).
+     */
+    finalizeOutput() {
+        let output = this.chunkState.output();
+        let parentBlock = this.parentBlock;
+        let cv = this.finalizeCv;
+        // If there are chunks on the stack, merge them
+        if (this.cvStackLen > 0) {
+            // First compress the current chunk
+            (0, compress_js_1.compress)(output.inputCv, 0, output.blockWords, 0, cv, 0, false, output.counter, output.blockLen, output.flags);
+            // Merge with parent nodes from stack
+            while (this.cvStackLen > 0) {
+                this.cvStackLen--;
+                parentBlock.set(this.cvStack.subarray(this.cvStackLen * 8, (this.cvStackLen + 1) * 8), 0);
+                parentBlock.set(cv, 8);
+                if (this.cvStackLen > 0) {
+                    (0, compress_js_1.compress)(this.keyWords, 0, parentBlock, 0, cv, 0, false, 0, constants_js_1.BLOCK_LEN, this.flags | constants_js_1.PARENT);
+                }
+                else {
+                    // This is the root - return output params
+                    return {
+                        inputCv: this.keyWords,
+                        blockWords: parentBlock,
+                        blockLen: constants_js_1.BLOCK_LEN,
+                        counter: 0,
+                        flags: this.flags | constants_js_1.PARENT,
+                    };
+                }
+            }
+        }
+        // Single chunk case
+        return output;
+    }
+    /**
+     * Finalize the hash and return the result.
+     *
+     * @param outputLength - Number of bytes to output (default: 32)
+     * @returns The hash output
+     */
+    finalize(outputLength = constants_js_1.OUT_LEN) {
+        const output = this.finalizeOutput();
+        const result = new Uint8Array(outputLength);
+        if (outputLength <= 64) {
+            const outWords = this.outWords;
+            (0, compress_js_1.compress)(output.inputCv, 0, output.blockWords, 0, outWords, 0, outputLength > 32, // full output if > 32 bytes
+            output.counter, output.blockLen, output.flags | constants_js_1.ROOT);
+            if (utils_js_1.IS_LITTLE_ENDIAN) {
+                const outBytes = new Uint8Array(outWords.buffer);
+                result.set(outBytes.subarray(0, outputLength));
+            }
+            else {
+                (0, utils_js_1.writeLittleEndianBytesPartial)(outWords, 0, result, 0, outputLength);
+            }
+        }
+        else {
+            // Multiple blocks - use XOF
+            const xof = this.finalizeXof();
+            const full = xof.read(outputLength);
+            result.set(full);
+        }
+        return result;
+    }
+    /**
+     * Finalize and return an XOF reader for arbitrary-length output.
+     */
+    finalizeXof() {
+        const output = this.finalizeOutput();
+        return new XofReader(new Uint32Array(output.inputCv), new Uint32Array(output.blockWords), output.counter, output.blockLen, output.flags);
+    }
+}
+exports.Hasher = Hasher;

node_modules/@huggingface/blake3-jit/dist/commonjs/index.d.ts

@@ -0,0 +1,82 @@
+/**
+ * BLAKE3 - The fastest pure JavaScript implementation
+ *
+ * Features:
+ * - All 3 modes: hash, keyed (MAC), derive_key
+ * - XOF (eXtendable Output Function) support
+ * - Automatic WASM SIMD acceleration for large inputs
+ * - Zero dependencies
+ * - Tree-shakeable exports
+ *
+ * @example
+ * ```typescript
+ * import { hash, createKeyed, createDeriveKey } from 'blake3-jit';
+ *
+ * // Simple hashing
+ * const digest = hash(new Uint8Array([1, 2, 3]));
+ *
+ * // Keyed hashing (MAC)
+ * const mac = createKeyed(key).update(data).finalize();
+ *
+ * // Key derivation
+ * const derived = createDeriveKey("my context").update(material).finalize(64);
+ * ```
+ */
+export { Hasher, XofReader } from "./hasher.js";
+export { hash, hashInto, warmupSimd } from "./hash.js";
+import { Hasher } from "./hasher.js";
+/**
+ * Create a new keyed hasher (MAC).
+ *
+ * @param key - 32-byte key
+ * @returns A new Hasher configured for keyed hashing
+ *
+ * @example
+ * ```typescript
+ * const key = new Uint8Array(32); // Your 32-byte key
+ * crypto.getRandomValues(key);
+ *
+ * const mac = createKeyed(key)
+ *   .update(message)
+ *   .finalize();
+ * ```
+ */
+export declare function createKeyed(key: Uint8Array): Hasher;
+/**
+ * Create a new key derivation hasher.
+ *
+ * @param context - Context string for domain separation
+ * @returns A new Hasher configured for key derivation
+ *
+ * @example
+ * ```typescript
+ * const derivedKey = createDeriveKey("my-app encryption key v1")
+ *   .update(inputKeyMaterial)
+ *   .finalize(32);
+ * ```
+ */
+export declare function createDeriveKey(context: string): Hasher;
+/**
+ * Create a new regular hasher for incremental hashing.
+ *
+ * @returns A new Hasher
+ *
+ * @example
+ * ```typescript
+ * const hasher = createHasher();
+ * hasher.update(chunk1);
+ * hasher.update(chunk2);
+ * const digest = hasher.finalize();
+ * ```
+ */
+export declare function createHasher(): Hasher;
+import { hash, hashInto } from "./hash.js";
+declare const _default: {
+    hash: typeof hash;
+    hashInto: typeof hashInto;
+    Hasher: typeof Hasher;
+    createHasher: typeof createHasher;
+    createKeyed: typeof createKeyed;
+    createDeriveKey: typeof createDeriveKey;
+};
+export default _default;

node_modules/@huggingface/blake3-jit/dist/commonjs/index.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * BLAKE3 - The fastest pure JavaScript implementation
+ *
+ * Features:
+ * - All 3 modes: hash, keyed (MAC), derive_key
+ * - XOF (eXtendable Output Function) support
+ * - Automatic WASM SIMD acceleration for large inputs
+ * - Zero dependencies
+ * - Tree-shakeable exports
+ *
+ * @example
+ * ```typescript
+ * import { hash, createKeyed, createDeriveKey } from 'blake3-jit';
+ *
+ * // Simple hashing
+ * const digest = hash(new Uint8Array([1, 2, 3]));
+ *
+ * // Keyed hashing (MAC)
+ * const mac = createKeyed(key).update(data).finalize();
+ *
+ * // Key derivation
+ * const derived = createDeriveKey("my context").update(material).finalize(64);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warmupSimd = exports.hashInto = exports.hash = exports.XofReader = exports.Hasher = void 0;
+exports.createKeyed = createKeyed;
+exports.createDeriveKey = createDeriveKey;
+exports.createHasher = createHasher;
+// Core exports
+var hasher_js_1 = require("./hasher.js");
+Object.defineProperty(exports, "Hasher", { enumerable: true, get: function () { return hasher_js_1.Hasher; } });
+Object.defineProperty(exports, "XofReader", { enumerable: true, get: function () { return hasher_js_1.XofReader; } });
+var hash_js_1 = require("./hash.js");
+Object.defineProperty(exports, "hash", { enumerable: true, get: function () { return hash_js_1.hash; } });
+Object.defineProperty(exports, "hashInto", { enumerable: true, get: function () { return hash_js_1.hashInto; } });
+Object.defineProperty(exports, "warmupSimd", { enumerable: true, get: function () { return hash_js_1.warmupSimd; } });
+// Convenience imports
+const hasher_js_2 = require("./hasher.js");
+/**
+ * Create a new keyed hasher (MAC).
+ *
+ * @param key - 32-byte key
+ * @returns A new Hasher configured for keyed hashing
+ *
+ * @example
+ * ```typescript
+ * const key = new Uint8Array(32); // Your 32-byte key
+ * crypto.getRandomValues(key);
+ *
+ * const mac = createKeyed(key)
+ *   .update(message)
+ *   .finalize();
+ * ```
+ */
+function createKeyed(key) {
+    return hasher_js_2.Hasher.newKeyed(key);
+}
+/**
+ * Create a new key derivation hasher.
+ *
+ * @param context - Context string for domain separation
+ * @returns A new Hasher configured for key derivation
+ *
+ * @example
+ * ```typescript
+ * const derivedKey = createDeriveKey("my-app encryption key v1")
+ *   .update(inputKeyMaterial)
+ *   .finalize(32);
+ * ```
+ */
+function createDeriveKey(context) {
+    return hasher_js_2.Hasher.newDeriveKey(context);
+}
+/**
+ * Create a new regular hasher for incremental hashing.
+ *
+ * @returns A new Hasher
+ *
+ * @example
+ * ```typescript
+ * const hasher = createHasher();
+ * hasher.update(chunk1);
+ * hasher.update(chunk2);
+ * const digest = hasher.finalize();
+ * ```
+ */
+function createHasher() {
+    return new hasher_js_2.Hasher();
+}
+// Import for default export
+const hash_js_2 = require("./hash.js");
+// Pre-warm SIMD in browser environments (non-blocking)
+// This avoids initialization latency on first large hash
+if (typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined") {
+    queueMicrotask(() => {
+        (0, hash_js_2.warmupSimd)();
+    });
+}
+// Default export for convenience
+exports.default = {
+    hash: hash_js_2.hash,
+    hashInto: hash_js_2.hashInto,
+    Hasher: hasher_js_2.Hasher,
+    createHasher,
+    createKeyed,
+    createDeriveKey,
+};

node_modules/@huggingface/blake3-jit/dist/commonjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

node_modules/@huggingface/blake3-jit/dist/commonjs/utils.d.ts

@@ -0,0 +1,90 @@
+/**
+ * BLAKE3 Utility Functions
+ *
+ * Optimized for little-endian systems (most user-facing systems).
+ * BLAKE3 is little-endian friendly - on little-endian systems we can
+ * create Uint32Array views directly over input buffers.
+ */
+/**
+ * Detect system endianness at module load time.
+ * On little-endian systems, the byte 0x01 will be at index 0.
+ */
+export declare const IS_LITTLE_ENDIAN: boolean;
+/**
+ * Read 16 little-endian 32-bit words from a byte array into a Uint32Array.
+ * This is only needed on big-endian systems.
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset in input
+ * @param words - Destination Uint32Array (must have at least 16 elements)
+ */
+export declare function readLittleEndianWordsFull(input: Uint8Array, offset: number, words: Uint32Array): void;
+/**
+ * Read N little-endian 32-bit words from a byte array.
+ * Handles partial reads (for final blocks).
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset
+ * @param words - Destination Uint32Array
+ * @param wordCount - Number of words to read
+ */
+export declare function readLittleEndianWords(input: Uint8Array, offset: number, words: Uint32Array, wordCount: number): void;
+/**
+ * Read a partial block with zero padding.
+ * Used for the final block when input length is not a multiple of 64.
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset
+ * @param length - Number of bytes to read (< 64)
+ * @param words - Destination Uint32Array (must have 16 elements)
+ */
+export declare function readLittleEndianWordsPartial(input: Uint8Array, offset: number, length: number, words: Uint32Array): void;
+/**
+ * Write 8 little-endian 32-bit words to a byte array.
+ *
+ * @param words - Source Uint32Array
+ * @param wordOffset - Starting word offset in source
+ * @param output - Destination byte array
+ * @param byteOffset - Starting byte offset in destination
+ */
+export declare function writeLittleEndianWords(words: Uint32Array, wordOffset: number, output: Uint8Array, byteOffset: number): void;
+/**
+ * Write N bytes from 32-bit words to output.
+ * Used for variable-length output (XOF mode).
+ *
+ * @param words - Source Uint32Array
+ * @param wordOffset - Starting word offset
+ * @param output - Destination byte array
+ * @param byteOffset - Starting byte offset in destination
+ * @param byteCount - Number of bytes to write
+ */
+export declare function writeLittleEndianBytesPartial(words: Uint32Array, wordOffset: number, output: Uint8Array, byteOffset: number, byteCount: number): void;
+/**
+ * Encode a UTF-8 string to Uint8Array.
+ * Used for derive_key context strings.
+ */
+export declare function encodeUTF8(str: string): Uint8Array;
+/**
+ * Count trailing zero bits in a 32-bit number using De Bruijn multiplication.
+ * This is O(1) and branchless for non-zero inputs.
+ *
+ * For Merkle tree merge: ctz32(chunkCounter) tells us how many merges to do.
+ */
+export declare function ctz32(n: number): number;
+/**
+ * Count trailing zero bits in a 64-bit number.
+ * Used to determine how many parent nodes to compute after adding a chunk.
+ *
+ * Note: JavaScript bitwise ops work on 32-bit signed integers,
+ * so we need to handle 64-bit numbers carefully.
+ */
+export declare function countTrailingZeros(n: number): number;
+/**
+ * Create a Uint32Array view of a Uint8Array.
+ * Only works correctly on little-endian systems when the offset is 4-byte aligned.
+ *
+ * @param arr - Source byte array
+ * @param byteOffset - Starting byte offset (must be 4-byte aligned)
+ * @param wordLength - Number of 32-bit words
+ */
+export declare function uint32View(arr: Uint8Array, byteOffset: number, wordLength: number): Uint32Array;

node_modules/@huggingface/blake3-jit/dist/commonjs/utils.js

@@ -0,0 +1,226 @@
+"use strict";
+/**
+ * BLAKE3 Utility Functions
+ *
+ * Optimized for little-endian systems (most user-facing systems).
+ * BLAKE3 is little-endian friendly - on little-endian systems we can
+ * create Uint32Array views directly over input buffers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IS_LITTLE_ENDIAN = void 0;
+exports.readLittleEndianWordsFull = readLittleEndianWordsFull;
+exports.readLittleEndianWords = readLittleEndianWords;
+exports.readLittleEndianWordsPartial = readLittleEndianWordsPartial;
+exports.writeLittleEndianWords = writeLittleEndianWords;
+exports.writeLittleEndianBytesPartial = writeLittleEndianBytesPartial;
+exports.encodeUTF8 = encodeUTF8;
+exports.ctz32 = ctz32;
+exports.countTrailingZeros = countTrailingZeros;
+exports.uint32View = uint32View;
+/**
+ * Detect system endianness at module load time.
+ * On little-endian systems, the byte 0x01 will be at index 0.
+ */
+exports.IS_LITTLE_ENDIAN = new Uint8Array(new Uint32Array([0x01020304]).buffer)[0] === 0x04;
+/**
+ * Read 16 little-endian 32-bit words from a byte array into a Uint32Array.
+ * This is only needed on big-endian systems.
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset in input
+ * @param words - Destination Uint32Array (must have at least 16 elements)
+ */
+function readLittleEndianWordsFull(input, offset, words) {
+    for (let i = 0; i < 16; ++i, offset += 4) {
+        words[i] =
+            input[offset] |
+                (input[offset + 1] << 8) |
+                (input[offset + 2] << 16) |
+                (input[offset + 3] << 24);
+    }
+}
+/**
+ * Read N little-endian 32-bit words from a byte array.
+ * Handles partial reads (for final blocks).
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset
+ * @param words - Destination Uint32Array
+ * @param wordCount - Number of words to read
+ */
+function readLittleEndianWords(input, offset, words, wordCount) {
+    for (let i = 0; i < wordCount; ++i, offset += 4) {
+        words[i] =
+            input[offset] |
+                (input[offset + 1] << 8) |
+                (input[offset + 2] << 16) |
+                (input[offset + 3] << 24);
+    }
+}
+/**
+ * Read a partial block with zero padding.
+ * Used for the final block when input length is not a multiple of 64.
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset
+ * @param length - Number of bytes to read (< 64)
+ * @param words - Destination Uint32Array (must have 16 elements)
+ */
+function readLittleEndianWordsPartial(input, offset, length, words) {
+    // Zero out all words first
+    words.fill(0);
+    // Read full words
+    const fullWords = length >>> 2;
+    let i = 0;
+    for (; i < fullWords; ++i, offset += 4) {
+        words[i] =
+            input[offset] |
+                (input[offset + 1] << 8) |
+                (input[offset + 2] << 16) |
+                (input[offset + 3] << 24);
+    }
+    // Handle remaining bytes (0-3)
+    const remaining = length & 3;
+    if (remaining > 0) {
+        let word = input[offset];
+        if (remaining > 1)
+            word |= input[offset + 1] << 8;
+        if (remaining > 2)
+            word |= input[offset + 2] << 16;
+        words[i] = word;
+    }
+}
+/**
+ * Write 8 little-endian 32-bit words to a byte array.
+ *
+ * @param words - Source Uint32Array
+ * @param wordOffset - Starting word offset in source
+ * @param output - Destination byte array
+ * @param byteOffset - Starting byte offset in destination
+ */
+function writeLittleEndianWords(words, wordOffset, output, byteOffset) {
+    for (let i = 0; i < 8; ++i, byteOffset += 4) {
+        const w = words[wordOffset + i];
+        output[byteOffset] = w & 0xff;
+        output[byteOffset + 1] = (w >>> 8) & 0xff;
+        output[byteOffset + 2] = (w >>> 16) & 0xff;
+        output[byteOffset + 3] = (w >>> 24) & 0xff;
+    }
+}
+/**
+ * Write N bytes from 32-bit words to output.
+ * Used for variable-length output (XOF mode).
+ *
+ * @param words - Source Uint32Array
+ * @param wordOffset - Starting word offset
+ * @param output - Destination byte array
+ * @param byteOffset - Starting byte offset in destination
+ * @param byteCount - Number of bytes to write
+ */
+function writeLittleEndianBytesPartial(words, wordOffset, output, byteOffset, byteCount) {
+    const fullWords = byteCount >>> 2;
+    let i = 0;
+    // Write full words
+    for (; i < fullWords; ++i, byteOffset += 4) {
+        const w = words[wordOffset + i];
+        output[byteOffset] = w & 0xff;
+        output[byteOffset + 1] = (w >>> 8) & 0xff;
+        output[byteOffset + 2] = (w >>> 16) & 0xff;
+        output[byteOffset + 3] = (w >>> 24) & 0xff;
+    }
+    // Write remaining bytes
+    const remaining = byteCount & 3;
+    if (remaining > 0) {
+        const w = words[wordOffset + i];
+        output[byteOffset] = w & 0xff;
+        if (remaining > 1)
+            output[byteOffset + 1] = (w >>> 8) & 0xff;
+        if (remaining > 2)
+            output[byteOffset + 2] = (w >>> 16) & 0xff;
+    }
+}
+/**
+ * Encode a UTF-8 string to Uint8Array.
+ * Used for derive_key context strings.
+ */
+function encodeUTF8(str) {
+    if (typeof TextEncoder !== "undefined") {
+        return new TextEncoder().encode(str);
+    }
+    // Fallback for older environments
+    const bytes = [];
+    for (let i = 0; i < str.length; i++) {
+        let c = str.charCodeAt(i);
+        if (c < 0x80) {
+            bytes.push(c);
+        }
+        else if (c < 0x800) {
+            bytes.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
+        }
+        else if (c < 0xd800 || c >= 0xe000) {
+            bytes.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+        }
+        else {
+            // Surrogate pair
+            i++;
+            c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
+            bytes.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 0x3f), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+        }
+    }
+    return new Uint8Array(bytes);
+}
+/**
+ * De Bruijn lookup table for O(1) trailing zero count.
+ * The expression (n & -n) isolates the lowest set bit.
+ * Multiplying by the De Bruijn constant maps each power of 2 to a unique 5-bit index.
+ */
+const CTZ32_TABLE = new Uint8Array([
+    0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 31, 27, 13, 23, 21, 19, 16, 7, 26, 12,
+    18, 6, 11, 5, 10, 9,
+]);
+/**
+ * Count trailing zero bits in a 32-bit number using De Bruijn multiplication.
+ * This is O(1) and branchless for non-zero inputs.
+ *
+ * For Merkle tree merge: ctz32(chunkCounter) tells us how many merges to do.
+ */
+function ctz32(n) {
+    if (n === 0)
+        return 32;
+    // Use unsigned right shift to handle negative numbers correctly
+    return CTZ32_TABLE[(((n & -n) * 0x077cb531) >>> 27) & 31];
+}
+/**
+ * Count trailing zero bits in a 64-bit number.
+ * Used to determine how many parent nodes to compute after adding a chunk.
+ *
+ * Note: JavaScript bitwise ops work on 32-bit signed integers,
+ * so we need to handle 64-bit numbers carefully.
+ */
+function countTrailingZeros(n) {
+    if (n === 0)
+        return 64;
+    // For numbers that fit in 32 bits
+    const low = n | 0;
+    if (low !== 0) {
+        // Use Math.clz32 trick: ctz(x) = 31 - clz32(x & -x) for non-zero x
+        return 31 - Math.clz32(low & -low);
+    }
+    // High 32 bits
+    const high = (n / 0x100000000) | 0;
+    if (high !== 0) {
+        return 32 + (31 - Math.clz32(high & -high));
+    }
+    return 64;
+}
+/**
+ * Create a Uint32Array view of a Uint8Array.
+ * Only works correctly on little-endian systems when the offset is 4-byte aligned.
+ *
+ * @param arr - Source byte array
+ * @param byteOffset - Starting byte offset (must be 4-byte aligned)
+ * @param wordLength - Number of 32-bit words
+ */
+function uint32View(arr, byteOffset, wordLength) {
+    return new Uint32Array(arr.buffer, arr.byteOffset + byteOffset, wordLength);
+}

node_modules/@huggingface/blake3-jit/dist/commonjs/wasm-simd.d.ts

@@ -0,0 +1,97 @@
+/**
+ * BLAKE3 WASM SIMD - Runtime bytecode generation
+ *
+ * Generates WebAssembly SIMD bytecode at runtime to process 4 compress
+ * operations in parallel using 128-bit SIMD vectors (i32x4).
+ *
+ * Key insight: One i32x4.add instruction performs 4 parallel additions,
+ * giving us 4x throughput for the same number of instructions.
+ *
+ * Memory layout (all values are transposed for SIMD access):
+ *   0-511:    4 x 16 message words (m0_0,m0_1,m0_2,m0_3, m1_0,m1_1,m1_2,m1_3, ...)
+ *   512-639:  4 x 8 chaining values
+ *   640-767:  4 x 8 output values
+ *   768-783:  4 x counter low
+ *   784-799:  4 x counter high
+ *   800-815:  4 x block length
+ *   816-831:  4 x flags
+ */
+/**
+ * Check if WASM SIMD is supported.
+ */
+export declare function isSimdSupported(): boolean;
+export declare function initSimdSync(): boolean;
+/**
+ * Memory offsets for SIMD data layout
+ *
+ * WASM Arena Pattern: All working buffers live in WASM memory (64KB page)
+ * This eliminates JS heap allocations during hashing operations.
+ */
+export declare const SIMD_MEMORY: {
+    readonly BLOCK_WORDS: 0;
+    readonly CHAINING_VALUES: 512;
+    readonly OUTPUT: 640;
+    readonly COUNTER_LOW: 768;
+    readonly COUNTER_HIGH: 784;
+    readonly BLOCK_LEN: 800;
+    readonly FLAGS: 816;
+    readonly BATCH_BLOCK_WORDS: 832;
+    readonly BATCH_CV: 4928;
+    readonly BATCH_COUNTER_LOW: 5056;
+    readonly BATCH_FLAGS_BASE: 5072;
+    readonly BATCH_OUTPUT: 5088;
+    readonly CV_STACK: 5216;
+    readonly PARENT_BLOCK: 7264;
+    readonly CHUNK_CV: 7328;
+    readonly TEMP_CVS: 7360;
+};
+/**
+ * Get the WASM memory views for writing input data.
+ */
+export declare function getSimdMemory(): {
+    view: Uint8Array;
+    view32: Uint32Array;
+} | null;
+/**
+ * Get the arena buffers for Merkle tree operations.
+ * These TypedArray views are backed by WASM memory - zero JS heap allocation.
+ */
+export declare function getArenaBuffers(): {
+    cvStack: Uint32Array;
+    parentBlock: Uint32Array;
+    chunkCv: Uint32Array;
+    tempCvs: Uint32Array;
+} | null;
+/**
+ * Get the batch arena buffers for chunk-level batched operations.
+ * These TypedArray views are backed by WASM memory - zero JS heap allocation.
+ */
+export declare function getBatchArenaBuffers(): {
+    blockWords: Uint32Array;
+    cv: Uint32Array;
+    counterLow: Uint32Array;
+    flagsBase: Uint32Array;
+    output: Uint32Array;
+} | null;
+/**
+ * Run the compress4x function.
+ * Data must already be set up in WASM memory.
+ */
+export declare function runCompress4x(): void;
+/**
+ * Run the compressChunks4x function.
+ * Processes 4 full chunks (16 blocks each) in a single WASM call.
+ * Data must already be set up in batch arena buffers.
+ */
+export declare function runCompressChunks4x(): void;
+/**
+ * Run the compressParent function.
+ * Compresses a parent node: reads 16 words from PARENT_BLOCK, writes 8 words to CHUNK_CV.
+ * Data must already be set up in arena buffers (PARENT_BLOCK at offset 7264).
+ * Output is written to CHUNK_CV at offset 7328.
+ */
+export declare function runCompressParent(): void;
+/**
+ * Check if SIMD is initialized and ready.
+ */
+export declare function isSimdReady(): boolean;

node_modules/@huggingface/blake3-jit/dist/commonjs/wasm-simd.js

@@ -0,0 +1,948 @@
+"use strict";
+/**
+ * BLAKE3 WASM SIMD - Runtime bytecode generation
+ *
+ * Generates WebAssembly SIMD bytecode at runtime to process 4 compress
+ * operations in parallel using 128-bit SIMD vectors (i32x4).
+ *
+ * Key insight: One i32x4.add instruction performs 4 parallel additions,
+ * giving us 4x throughput for the same number of instructions.
+ *
+ * Memory layout (all values are transposed for SIMD access):
+ *   0-511:    4 x 16 message words (m0_0,m0_1,m0_2,m0_3, m1_0,m1_1,m1_2,m1_3, ...)
+ *   512-639:  4 x 8 chaining values
+ *   640-767:  4 x 8 output values
+ *   768-783:  4 x counter low
+ *   784-799:  4 x counter high
+ *   800-815:  4 x block length
+ *   816-831:  4 x flags
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIMD_MEMORY = void 0;
+exports.isSimdSupported = isSimdSupported;
+exports.initSimdSync = initSimdSync;
+exports.getSimdMemory = getSimdMemory;
+exports.getArenaBuffers = getArenaBuffers;
+exports.getBatchArenaBuffers = getBatchArenaBuffers;
+exports.runCompress4x = runCompress4x;
+exports.runCompressChunks4x = runCompressChunks4x;
+exports.runCompressParent = runCompressParent;
+exports.isSimdReady = isSimdReady;
+// LEB128 encoding with minimum 2 bytes
+// This fixes a V8 quirk where single-byte values 64-127 cause issues
+// when followed by certain SIMD instructions
+function toLebU32Min2(n) {
+    // Always use at least 2 bytes
+    return [(n & 0x7f) | 0x80, (n >>> 7) & 0x7f];
+}
+// LEB128 encoding padded to exactly 5 bytes (for backpatching)
+// Uses continuation bits for all but the last byte
+function toLebU32Padded5(n) {
+    return [
+        (n & 0x7f) | 0x80,
+        ((n >>> 7) & 0x7f) | 0x80,
+        ((n >>> 14) & 0x7f) | 0x80,
+        ((n >>> 21) & 0x7f) | 0x80,
+        (n >>> 28) & 0x0f, // Last byte has no continuation bit
+    ];
+}
+// Signed LEB128 encoding for i32 constants (handles full 32-bit range)
+// WASM i32.const uses signed LEB128 immediate
+function toSignedLeb128_i32(n) {
+    const bytes = [];
+    // Treat as signed 32-bit integer
+    let value = n | 0;
+    let more = true;
+    while (more) {
+        let byte = value & 0x7f;
+        // Arithmetic right shift preserves sign
+        value >>= 7;
+        // Check if we're done:
+        // - If value is 0 and sign bit of byte is clear, we're done
+        // - If value is -1 and sign bit of byte is set, we're done
+        if ((value === 0 && (byte & 0x40) === 0) || (value === -1 && (byte & 0x40) !== 0)) {
+            more = false;
+        }
+        else {
+            byte |= 0x80;
+        }
+        bytes.push(byte);
+    }
+    return bytes;
+}
+// Precomputed message access order for all 7 rounds
+const MSG_ACCESS_ORDER = [
+    // Round 1: 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    // Round 2: 2,6,3,10,7,0,4,13,1,11,12,5,9,14,15,8
+    2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8,
+    // Round 3: 3,4,10,12,13,2,7,14,6,5,9,0,11,15,8,1
+    3, 4, 10, 12, 13, 2, 7, 14, 6, 5, 9, 0, 11, 15, 8, 1,
+    // Round 4: 10,7,12,9,14,3,13,15,4,0,11,2,5,8,1,6
+    10, 7, 12, 9, 14, 3, 13, 15, 4, 0, 11, 2, 5, 8, 1, 6,
+    // Round 5: 12,13,9,11,15,10,14,8,7,2,5,3,0,1,6,4
+    12, 13, 9, 11, 15, 10, 14, 8, 7, 2, 5, 3, 0, 1, 6, 4,
+    // Round 6: 9,14,11,5,8,12,15,1,13,3,0,10,2,6,4,7
+    9, 14, 11, 5, 8, 12, 15, 1, 13, 3, 0, 10, 2, 6, 4, 7,
+    // Round 7: 11,15,5,0,1,9,8,6,14,10,2,12,3,4,7,13
+    11, 15, 5, 0, 1, 9, 8, 6, 14, 10, 2, 12, 3, 4, 7, 13,
+];
+// BLAKE3 Constants (used in generated WASM code)
+// CHUNK_START = 1, CHUNK_END = 2 are embedded directly in WASM bytecode
+/**
+ * Generate the WASM module bytecode with compress4x, compressChunks4x, and compressParent functions.
+ */
+function generateWasmBytes() {
+    const code = [];
+    // Helper to append bytes
+    function put(bytes) {
+        code.push(...bytes);
+    }
+    // WASM module header
+    put([0x00, 0x61, 0x73, 0x6d]); // Magic
+    put([0x01, 0x00, 0x00, 0x00]); // Version
+    // Section 1: Types
+    put([0x01]); // Section ID
+    put([0x04]); // Section size
+    put([0x01]); // 1 type
+    put([0x60, 0x00, 0x00]); // func () -> ()
+    // Section 2: Imports (memory from JS)
+    put([0x02]); // Section ID
+    put([0x0b]); // Section size
+    put([0x01]); // 1 import
+    put([0x02, 0x6a, 0x73]); // "js"
+    put([0x03, 0x6d, 0x65, 0x6d]); // "mem"
+    put([0x02, 0x00, 0x01]); // memory min=1, no max
+    // Section 3: Functions
+    put([0x03]); // Section ID
+    put([0x04]); // Section size (3 functions = 4 bytes)
+    put([0x03]); // 3 functions
+    put([0x00]); // Function 0: type index 0
+    put([0x00]); // Function 1: type index 0
+    put([0x00]); // Function 2: type index 0
+    // Section 7: Exports
+    // Size calculation: 1 (count) + (1+10+1+1) + (1+16+1+1) + (1+14+1+1) = 1 + 13 + 19 + 17 = 50 bytes
+    put([0x07]); // Section ID
+    put([0x32]); // Section size (50 bytes)
+    put([0x03]); // 3 exports
+    // "compress4x" -> func 0
+    put([0x0a]); // name length
+    put([0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x34, 0x78]); // "compress4x"
+    put([0x00, 0x00]); // func index 0
+    // "compressChunks4x" -> func 1
+    put([0x10]); // name length (16)
+    put([
+        0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x73, 0x34, 0x78,
+    ]); // "compressChunks4x"
+    put([0x00, 0x01]); // func index 1
+    // "compressParent" -> func 2
+    put([0x0e]); // name length (14)
+    put([0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74]); // "compressParent"
+    put([0x00, 0x02]); // func index 2
+    // Section 10: Code
+    put([0x0a]); // Section ID
+    // Reserve 5 bytes for section size (LEB128 u32)
+    const sectionSizeOffset = code.length;
+    put([0x00, 0x00, 0x00, 0x00, 0x00]);
+    put([0x03]); // 3 functions
+    // === Function 0: compress4x ===
+    // Reserve 5 bytes for function size
+    const funcSizeOffset = code.length;
+    put([0x00, 0x00, 0x00, 0x00, 0x00]);
+    const funcBodyStart = code.length;
+    // Local declarations: 32 v128 locals
+    // Variables $0-$15: message words (m0-m15)
+    // Variables $16-$31: state words (s0-s15)
+    put([0x01]); // 1 local declaration
+    put([0x20, 0x7b]); // 32 x v128
+    // ===== Function body =====
+    // Load message words from memory (offset 0-255)
+    // Each v128 is 16 bytes, so m[i] is at offset i*16
+    // Note: we use toLebU32Min2 to avoid V8 quirk with single-byte values 64-127
+    for (let i = 0; i < 16; i++) {
+        put([0x41, ...toLebU32Min2(i * 16)]); // i32.const offset (2+ byte LEB128)
+        put([0xfd, 0x00, 0x02, 0x00]); // v128.load align=4 offset=0
+        put([0x21, i]); // local.set $i
+    }
+    // Load chaining values (offset 512-639)
+    // cv[i] at offset 512 + i*16
+    for (let i = 0; i < 8; i++) {
+        put([0x41, ...toLebU32Min2(512 + i * 16)]); // i32.const offset
+        put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+        put([0x21, 16 + i]); // local.set $(16+i)
+    }
+    // Initialize state[8-15] from IV and parameters
+    // s8-s11 = IV[0-3]
+    const IV = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
+    for (let i = 0; i < 4; i++) {
+        // Create v128 constant with all lanes set to IV[i]
+        const ivBytes = [];
+        for (let j = 0; j < 4; j++) {
+            ivBytes.push(IV[i] & 0xff);
+            ivBytes.push((IV[i] >>> 8) & 0xff);
+            ivBytes.push((IV[i] >>> 16) & 0xff);
+            ivBytes.push((IV[i] >>> 24) & 0xff);
+        }
+        put([0xfd, 0x0c, ...ivBytes]); // v128.const
+        put([0x21, 24 + i]); // local.set $(24+i) -> s8-s11
+    }
+    // s12 = counter_low (offset 768)
+    put([0x41, ...toLebU32Min2(768)]); // i32.const
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+    put([0x21, 28]); // local.set $28 -> s12
+    // s13 = counter_high (offset 784)
+    put([0x41, ...toLebU32Min2(784)]); // i32.const
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+    put([0x21, 29]); // local.set $29 -> s13
+    // s14 = block_len (offset 800)
+    put([0x41, ...toLebU32Min2(800)]); // i32.const
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+    put([0x21, 30]); // local.set $30 -> s14
+    // s15 = flags (offset 816)
+    put([0x41, ...toLebU32Min2(816)]); // i32.const
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+    put([0x21, 31]); // local.set $31 -> s15
+    // ===== 7 rounds of mixing =====
+    let msgIdx = 0; // Index into MSG_ACCESS_ORDER
+    // Helper to generate G function (inlined)
+    // G(a, b, c, d) with two message words
+    function g(a, b, c, d) {
+        const mx = MSG_ACCESS_ORDER[msgIdx++];
+        const my = MSG_ACCESS_ORDER[msgIdx++];
+        // Variables: a,b,c,d are state indices (16-31), mx,my are message indices (0-15)
+        // First half of G
+        // s[a] = s[a] + s[b] + m[mx]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x20, mx]); // local.get m[mx]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + a]); // local.set s[a]
+        // s[d] = rotr(s[d] ^ s[a], 16) - using i8x16.shuffle (single instruction vs shift+or)
+        // ROTR16 pattern: [2,3,0,1, 6,7,4,5, 10,11,8,9, 14,15,12,13]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + d]); // local.tee s[d]
+        put([0x20, 16 + d]); // local.get s[d] (second operand for shuffle)
+        put([0xfd, 0x0d, 2, 3, 0, 1, 6, 7, 4, 5, 10, 11, 8, 9, 14, 15, 12, 13]); // i8x16.shuffle ROTR16
+        put([0x21, 16 + d]); // local.set s[d]
+        // s[c] = s[c] + s[d]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + c]); // local.set s[c]
+        // s[b] = (s[b] ^ s[c]) >>> 12
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + b]); // local.tee s[b]
+        put([0x41, 0x0c]); // i32.const 12
+        put([0xfd, 0xad, 0x01]); // i32x4.shr_u (opcode 173 = 0xAD)
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x41, 0x14]); // i32.const 20
+        put([0xfd, 0xab, 0x01]); // i32x4.shl
+        put([0xfd, 0x50]); // v128.or
+        put([0x21, 16 + b]); // local.set s[b]
+        // Second half of G
+        // s[a] = s[a] + s[b] + m[my]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x20, my]); // local.get m[my]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + a]); // local.set s[a]
+        // s[d] = rotr(s[d] ^ s[a], 8) - using i8x16.shuffle (single instruction vs shift+or)
+        // ROTR8 pattern: [1,2,3,0, 5,6,7,4, 9,10,11,8, 13,14,15,12]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + d]); // local.tee s[d]
+        put([0x20, 16 + d]); // local.get s[d] (second operand for shuffle)
+        put([0xfd, 0x0d, 1, 2, 3, 0, 5, 6, 7, 4, 9, 10, 11, 8, 13, 14, 15, 12]); // i8x16.shuffle ROTR8
+        put([0x21, 16 + d]); // local.set s[d]
+        // s[c] = s[c] + s[d]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + c]); // local.set s[c]
+        // s[b] = (s[b] ^ s[c]) >>> 7
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + b]); // local.tee s[b]
+        put([0x41, 0x07]); // i32.const 7
+        put([0xfd, 0xad, 0x01]); // i32x4.shr_u (opcode 173 = 0xAD)
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x41, 0x19]); // i32.const 25
+        put([0xfd, 0xab, 0x01]); // i32x4.shl
+        put([0xfd, 0x50]); // v128.or
+        put([0x21, 16 + b]); // local.set s[b]
+    }
+    // Generate all 7 rounds
+    for (let round = 0; round < 7; round++) {
+        // Column mixing
+        g(0, 4, 8, 12);
+        g(1, 5, 9, 13);
+        g(2, 6, 10, 14);
+        g(3, 7, 11, 15);
+        // Diagonal mixing
+        g(0, 5, 10, 15);
+        g(1, 6, 11, 12);
+        g(2, 7, 8, 13);
+        g(3, 4, 9, 14);
+    }
+    // ===== Final XOR and store output =====
+    // out[i] = s[i] ^ s[i+8] for i in 0..7
+    // Store at offset 640-767
+    for (let i = 0; i < 8; i++) {
+        put([0x41, ...toLebU32Min2(640 + i * 16)]); // i32.const offset
+        put([0x20, 16 + i]); // local.get s[i]
+        put([0x20, 24 + i]); // local.get s[i+8]
+        put([0xfd, 0x51]); // v128.xor
+        put([0xfd, 0x0b, 0x02, 0x00]); // v128.store align=4
+    }
+    // End of function
+    put([0x0b]); // end
+    // Fill in function 0 size using padded LEB128
+    const funcBodySize = code.length - funcBodyStart;
+    const funcSizeBytes = toLebU32Padded5(funcBodySize);
+    for (let i = 0; i < 5; i++) {
+        code[funcSizeOffset + i] = funcSizeBytes[i];
+    }
+    // === Function 1: compressChunks4x ===
+    // Reserve 5 bytes for function size
+    const func1SizeOffset = code.length;
+    put([0x00, 0x00, 0x00, 0x00, 0x00]);
+    const func1BodyStart = code.length;
+    // Generate the compressChunks4x function body
+    const compressChunksBody = generateCompressChunks4xBody();
+    put(compressChunksBody);
+    // Fill in function 1 size using padded LEB128
+    const func1BodySize = code.length - func1BodyStart;
+    const func1SizeBytes = toLebU32Padded5(func1BodySize);
+    for (let i = 0; i < 5; i++) {
+        code[func1SizeOffset + i] = func1SizeBytes[i];
+    }
+    // === Function 2: compressParent ===
+    // Reserve 5 bytes for function size
+    const func2SizeOffset = code.length;
+    put([0x00, 0x00, 0x00, 0x00, 0x00]);
+    const func2BodyStart = code.length;
+    // Generate the compressParent function body
+    const compressParentBody = generateCompressParentBody();
+    put(compressParentBody);
+    // Fill in function 2 size using padded LEB128
+    const func2BodySize = code.length - func2BodyStart;
+    const func2SizeBytes = toLebU32Padded5(func2BodySize);
+    for (let i = 0; i < 5; i++) {
+        code[func2SizeOffset + i] = func2SizeBytes[i];
+    }
+    // Fill in section size using padded LEB128
+    const sectionSize = code.length - sectionSizeOffset - 5;
+    const sectionSizeBytes = toLebU32Padded5(sectionSize);
+    for (let i = 0; i < 5; i++) {
+        code[sectionSizeOffset + i] = sectionSizeBytes[i];
+    }
+    return new Uint8Array(code);
+}
+/**
+ * Generate compressChunks4x WASM function body.
+ * Processes all 16 blocks of 4 chunks in a single call.
+ */
+function generateCompressChunks4xBody() {
+    const code = [];
+    function put(bytes) {
+        code.push(...bytes);
+    }
+    // Local declarations: 32 v128 locals + 1 i32 for position
+    // Locals $0-$15: message words (reloaded each iteration)
+    // Locals $16-$31: state words (s0-s15)
+    // Local $32: position counter (i32)
+    put([0x02]); // 2 local declarations
+    put([0x20, 0x7b]); // 32 x v128
+    put([0x01, 0x7f]); // 1 x i32
+    const BATCH_BLOCK_WORDS = exports.SIMD_MEMORY.BATCH_BLOCK_WORDS;
+    const BATCH_CV = exports.SIMD_MEMORY.BATCH_CV;
+    const BATCH_COUNTER_LOW = exports.SIMD_MEMORY.BATCH_COUNTER_LOW;
+    const BATCH_FLAGS_BASE = exports.SIMD_MEMORY.BATCH_FLAGS_BASE;
+    const BATCH_OUTPUT = exports.SIMD_MEMORY.BATCH_OUTPUT;
+    // IV constants (same as compress4x)
+    const IV = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
+    // Load initial CVs from BATCH_CV into locals $16-$23
+    for (let i = 0; i < 8; i++) {
+        put([0x41, ...toLebU32Min2(BATCH_CV + i * 16)]); // i32.const offset
+        put([0xfd, 0x00, 0x02, 0x00]); // v128.load align=4 offset=0
+        put([0x21, 16 + i]); // local.set $(16+i) -> s0-s7
+    }
+    // Initialize $32 (pos) = 0
+    put([0x41, 0x00]); // i32.const 0
+    put([0x21, 0x20]); // local.set $32
+    // block $done
+    put([0x02, 0x40]); // block void
+    // loop $continue
+    put([0x03, 0x40]); // loop void
+    // === Load message words for position $pos ===
+    // offset = BATCH_BLOCK_WORDS + pos * 256 + word * 16
+    for (let w = 0; w < 16; w++) {
+        put([0x20, 0x20]); // local.get $32 (pos)
+        put([0x41, ...toLebU32Min2(256)]); // i32.const 256
+        put([0x6c]); // i32.mul
+        put([0x41, ...toLebU32Min2(BATCH_BLOCK_WORDS + w * 16)]); // i32.const base + word*16
+        put([0x6a]); // i32.add
+        put([0xfd, 0x00, 0x02, 0x00]); // v128.load align=4 offset=0
+        put([0x21, w]); // local.set $w
+    }
+    // === Initialize state[8-15] ===
+    // s8-s11 = IV[0-3]
+    for (let i = 0; i < 4; i++) {
+        const ivBytes = [];
+        for (let j = 0; j < 4; j++) {
+            ivBytes.push(IV[i] & 0xff);
+            ivBytes.push((IV[i] >>> 8) & 0xff);
+            ivBytes.push((IV[i] >>> 16) & 0xff);
+            ivBytes.push((IV[i] >>> 24) & 0xff);
+        }
+        put([0xfd, 0x0c, ...ivBytes]); // v128.const
+        put([0x21, 24 + i]); // local.set $(24+i) -> s8-s11
+    }
+    // s12 = counter_low (from BATCH_COUNTER_LOW)
+    put([0x41, ...toLebU32Min2(BATCH_COUNTER_LOW)]); // i32.const
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+    put([0x21, 28]); // local.set $28 -> s12
+    // s13 = 0 (counter high - assume fits in 32 bits)
+    put([0xfd, 0x0c, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); // v128.const 0
+    put([0x21, 29]); // local.set $29 -> s13
+    // s14 = 64 (block_len = 64 for full blocks)
+    const blockLen64 = [];
+    for (let j = 0; j < 4; j++) {
+        blockLen64.push(64, 0, 0, 0); // 64 in little-endian
+    }
+    put([0xfd, 0x0c, ...blockLen64]); // v128.const [64,64,64,64]
+    put([0x21, 30]); // local.set $30 -> s14
+    // s15 = flags = base_flags | (pos == 0 ? 1 : 0) | (pos == 15 ? 2 : 0)
+    // First load base flags
+    put([0x41, ...toLebU32Min2(BATCH_FLAGS_BASE)]); // i32.const
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load base flags
+    // Compute position-dependent bits
+    // CHUNK_START (1) if pos == 0
+    put([0x20, 0x20]); // local.get $32 (pos)
+    put([0x45]); // i32.eqz -> 1 if pos==0, 0 otherwise
+    // CHUNK_END (2) if pos == 15
+    put([0x20, 0x20]); // local.get $32 (pos)
+    put([0x41, 0x0f]); // i32.const 15
+    put([0x46]); // i32.eq -> 1 if pos==15, 0 otherwise
+    put([0x41, 0x01]); // i32.const 1 (shift amount)
+    put([0x74]); // i32.shl -> 2 if pos==15, 0 otherwise
+    // OR the two bits together
+    put([0x72]); // i32.or -> combined position bits
+    // Splat to v128 and OR with base flags (stack: base_flags, bits)
+    put([0xfd, 0x11]); // i32x4.splat
+    put([0xfd, 0x50]); // v128.or
+    put([0x21, 31]); // local.set $31 -> s15
+    // === 7 rounds of mixing ===
+    let msgIdx = 0;
+    function g(a, b, c, d) {
+        const mx = MSG_ACCESS_ORDER[msgIdx++];
+        const my = MSG_ACCESS_ORDER[msgIdx++];
+        // First half of G: s[a] = s[a] + s[b] + m[mx]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x20, mx]); // local.get m[mx]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + a]); // local.set s[a]
+        // s[d] = rotr(s[d] ^ s[a], 16) - byte shuffle
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + d]); // local.tee s[d]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0xfd, 0x0d, 2, 3, 0, 1, 6, 7, 4, 5, 10, 11, 8, 9, 14, 15, 12, 13]); // i8x16.shuffle ROTR16
+        put([0x21, 16 + d]); // local.set s[d]
+        // s[c] = s[c] + s[d]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + c]); // local.set s[c]
+        // s[b] = rotr(s[b] ^ s[c], 12)
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + b]); // local.tee s[b]
+        put([0x41, 0x0c]); // i32.const 12
+        put([0xfd, 0xad, 0x01]); // i32x4.shr_u (opcode 173 = 0xAD)
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x41, 0x14]); // i32.const 20
+        put([0xfd, 0xab, 0x01]); // i32x4.shl
+        put([0xfd, 0x50]); // v128.or
+        put([0x21, 16 + b]); // local.set s[b]
+        // Second half: s[a] = s[a] + s[b] + m[my]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x20, my]); // local.get m[my]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + a]); // local.set s[a]
+        // s[d] = rotr(s[d] ^ s[a], 8) - byte shuffle
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + d]); // local.tee s[d]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0xfd, 0x0d, 1, 2, 3, 0, 5, 6, 7, 4, 9, 10, 11, 8, 13, 14, 15, 12]); // i8x16.shuffle ROTR8
+        put([0x21, 16 + d]); // local.set s[d]
+        // s[c] = s[c] + s[d]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + c]); // local.set s[c]
+        // s[b] = rotr(s[b] ^ s[c], 7)
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + b]); // local.tee s[b]
+        put([0x41, 0x07]); // i32.const 7
+        put([0xfd, 0xad, 0x01]); // i32x4.shr_u (opcode 173 = 0xAD)
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x41, 0x19]); // i32.const 25
+        put([0xfd, 0xab, 0x01]); // i32x4.shl
+        put([0xfd, 0x50]); // v128.or
+        put([0x21, 16 + b]); // local.set s[b]
+    }
+    // Generate all 7 rounds
+    for (let round = 0; round < 7; round++) {
+        // Column mixing
+        g(0, 4, 8, 12);
+        g(1, 5, 9, 13);
+        g(2, 6, 10, 14);
+        g(3, 7, 11, 15);
+        // Diagonal mixing
+        g(0, 5, 10, 15);
+        g(1, 6, 11, 12);
+        g(2, 7, 8, 13);
+        g(3, 4, 9, 14);
+    }
+    // === Update CVs: cv[i] = s[i] ^ s[i+8] ===
+    // Store back to state locals $16-$23 (the CV positions)
+    for (let i = 0; i < 8; i++) {
+        put([0x20, 16 + i]); // local.get s[i]
+        put([0x20, 24 + i]); // local.get s[i+8]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x21, 16 + i]); // local.set $(16+i) - update CV
+    }
+    // === Loop control: pos++, continue if pos < 16 ===
+    put([0x20, 0x20]); // local.get $32 (pos)
+    put([0x41, 0x01]); // i32.const 1
+    put([0x6a]); // i32.add
+    put([0x22, 0x20]); // local.tee $32 (pos)
+    put([0x41, 0x10]); // i32.const 16
+    put([0x49]); // i32.lt_u
+    put([0x0d, 0x00]); // br_if 0 (continue loop)
+    // end loop
+    put([0x0b]); // end
+    // end block
+    put([0x0b]); // end
+    // === Store final CVs to BATCH_OUTPUT ===
+    for (let i = 0; i < 8; i++) {
+        put([0x41, ...toLebU32Min2(BATCH_OUTPUT + i * 16)]); // i32.const offset
+        put([0x20, 16 + i]); // local.get $(16+i) - CV word
+        put([0xfd, 0x0b, 0x02, 0x00]); // v128.store align=4
+    }
+    // end function
+    put([0x0b]); // end
+    return code;
+}
+/**
+ * Generate compressParent WASM function body.
+ * Performs a single parent node compression using scalar i32 operations.
+ * Reads 16 words from PARENT_BLOCK, writes 8 words to CHUNK_CV.
+ * Uses IV, counter=0, blockLen=64, flags=PARENT(4).
+ */
+function generateCompressParentBody() {
+    const code = [];
+    function put(bytes) {
+        code.push(...bytes);
+    }
+    // Local declarations: 32 i32 locals for state (s0-s15) and message (m0-m15)
+    put([0x01]); // 1 local declaration
+    put([0x20, 0x7f]); // 32 x i32
+    // Message word indices: 0-15, State indices: 16-31
+    // Locals $0-$15: message words (m0-m15)
+    // Locals $16-$31: state words (s0-s15)
+    const PARENT_BLOCK_OFFSET = exports.SIMD_MEMORY.PARENT_BLOCK;
+    const CHUNK_CV_OFFSET = exports.SIMD_MEMORY.CHUNK_CV;
+    // BLAKE3 IV
+    const IV = [
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ];
+    // Load message words from PARENT_BLOCK (16 words at offset 7264)
+    for (let i = 0; i < 16; i++) {
+        put([0x41, ...toLebU32Min2(PARENT_BLOCK_OFFSET + i * 4)]); // i32.const offset
+        put([0x28, 0x02, 0x00]); // i32.load align=4 offset=0
+        put([0x21, i]); // local.set $i (m0-m15)
+    }
+    // Initialize state s0-s7 = IV[0-7]
+    for (let i = 0; i < 8; i++) {
+        put([0x41, ...toSignedLeb128_i32(IV[i])]); // i32.const IV[i]
+        put([0x21, 16 + i]); // local.set $(16+i) -> s0-s7
+    }
+    // Initialize state s8-s11 = IV[0-3]
+    for (let i = 0; i < 4; i++) {
+        put([0x41, ...toSignedLeb128_i32(IV[i])]); // i32.const IV[i]
+        put([0x21, 24 + i]); // local.set $(24+i) -> s8-s11
+    }
+    // s12 = counter_low = 0
+    put([0x41, 0x00]); // i32.const 0
+    put([0x21, 28]); // local.set $28 -> s12
+    // s13 = counter_high = 0
+    put([0x41, 0x00]); // i32.const 0
+    put([0x21, 29]); // local.set $29 -> s13
+    // s14 = block_len = 64
+    // Note: 0x40 alone is -64 in signed LEB128 (bit 6 is sign bit)
+    // For 64, we need [0xC0, 0x00] to avoid sign extension
+    put([0x41, 0xc0, 0x00]); // i32.const 64
+    put([0x21, 30]); // local.set $30 -> s14
+    // s15 = flags = PARENT = 4
+    put([0x41, 0x04]); // i32.const 4
+    put([0x21, 31]); // local.set $31 -> s15
+    // Helper to generate scalar G function (inlined)
+    // G(a, b, c, d, mx, my) where a,b,c,d are state indices 0-15, mx,my are message indices 0-15
+    function g(a, b, c, d, mx, my) {
+        const sa = 16 + a, sb = 16 + b, sc = 16 + c, sd = 16 + d;
+        // s[a] = (s[a] + s[b] + m[mx]) >>> 0
+        put([0x20, sa]); // local.get s[a]
+        put([0x20, sb]); // local.get s[b]
+        put([0x6a]); // i32.add
+        put([0x20, mx]); // local.get m[mx]
+        put([0x6a]); // i32.add
+        put([0x21, sa]); // local.set s[a]
+        // s[d] = rotr(s[d] ^ s[a], 16)
+        put([0x20, sd]); // local.get s[d]
+        put([0x20, sa]); // local.get s[a]
+        put([0x73]); // i32.xor
+        put([0x41, 0x10]); // i32.const 16
+        put([0x78]); // i32.rotr
+        put([0x21, sd]); // local.set s[d]
+        // s[c] = (s[c] + s[d]) >>> 0
+        put([0x20, sc]); // local.get s[c]
+        put([0x20, sd]); // local.get s[d]
+        put([0x6a]); // i32.add
+        put([0x21, sc]); // local.set s[c]
+        // s[b] = rotr(s[b] ^ s[c], 12)
+        put([0x20, sb]); // local.get s[b]
+        put([0x20, sc]); // local.get s[c]
+        put([0x73]); // i32.xor
+        put([0x41, 0x0c]); // i32.const 12
+        put([0x78]); // i32.rotr
+        put([0x21, sb]); // local.set s[b]
+        // s[a] = (s[a] + s[b] + m[my]) >>> 0
+        put([0x20, sa]); // local.get s[a]
+        put([0x20, sb]); // local.get s[b]
+        put([0x6a]); // i32.add
+        put([0x20, my]); // local.get m[my]
+        put([0x6a]); // i32.add
+        put([0x21, sa]); // local.set s[a]
+        // s[d] = rotr(s[d] ^ s[a], 8)
+        put([0x20, sd]); // local.get s[d]
+        put([0x20, sa]); // local.get s[a]
+        put([0x73]); // i32.xor
+        put([0x41, 0x08]); // i32.const 8
+        put([0x78]); // i32.rotr
+        put([0x21, sd]); // local.set s[d]
+        // s[c] = (s[c] + s[d]) >>> 0
+        put([0x20, sc]); // local.get s[c]
+        put([0x20, sd]); // local.get s[d]
+        put([0x6a]); // i32.add
+        put([0x21, sc]); // local.set s[c]
+        // s[b] = rotr(s[b] ^ s[c], 7)
+        put([0x20, sb]); // local.get s[b]
+        put([0x20, sc]); // local.get s[c]
+        put([0x73]); // i32.xor
+        put([0x41, 0x07]); // i32.const 7
+        put([0x78]); // i32.rotr
+        put([0x21, sb]); // local.set s[b]
+    }
+    // 7 rounds of mixing with permuted message schedule
+    let msgIdx = 0;
+    for (let round = 0; round < 7; round++) {
+        // Column mixing
+        g(0, 4, 8, 12, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+        g(1, 5, 9, 13, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+        g(2, 6, 10, 14, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+        g(3, 7, 11, 15, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+        // Diagonal mixing
+        g(0, 5, 10, 15, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+        g(1, 6, 11, 12, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+        g(2, 7, 8, 13, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+        g(3, 4, 9, 14, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+    }
+    // Store output: out[i] = s[i] ^ s[i+8] for i in 0..7
+    for (let i = 0; i < 8; i++) {
+        put([0x41, ...toLebU32Min2(CHUNK_CV_OFFSET + i * 4)]); // i32.const offset
+        put([0x20, 16 + i]); // local.get s[i]
+        put([0x20, 24 + i]); // local.get s[i+8]
+        put([0x73]); // i32.xor
+        put([0x36, 0x02, 0x00]); // i32.store align=4 offset=0
+    }
+    // end function
+    put([0x0b]); // end
+    return code;
+}
+// Cached WASM instance
+let wasmInstance = null;
+let wasmMemory = null;
+let wasmCompress4x = null;
+let wasmCompressChunks4x = null;
+let wasmCompressParent = null;
+let wasmMemoryView = null;
+let wasmMemoryView32 = null;
+/**
+ * Check if WASM SIMD is supported.
+ */
+function isSimdSupported() {
+    try {
+        // Minimal WASM module with v128.const instruction to test SIMD support
+        const simdTest = new Uint8Array([
+            0x00,
+            0x61,
+            0x73,
+            0x6d, // magic: \0asm
+            0x01,
+            0x00,
+            0x00,
+            0x00, // version: 1
+            // Type section (id=1): () -> v128
+            0x01, // section id = 1 (type)
+            0x05, // section length = 5
+            0x01, // 1 type
+            0x60,
+            0x00,
+            0x01,
+            0x7b, // func () -> v128
+            // Function section (id=3)
+            0x03, // section id = 3 (function)
+            0x02, // section length = 2
+            0x01, // 1 function
+            0x00, // type index 0
+            // Code section (id=10) with v128.const
+            0x0a, // section id = 10 (code)
+            0x16, // section length = 22
+            0x01, // 1 function body
+            0x14, // body length = 20
+            0x00, // 0 locals
+            0xfd,
+            0x0c, // v128.const opcode
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x0b, // end
+        ]);
+        return WebAssembly.validate(simdTest);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Set up arena views over WASM memory.
+ * Called after WASM memory is allocated.
+ */
+function setupArenaViews() {
+    if (!wasmMemory)
+        return;
+    const buffer = wasmMemory.buffer;
+    // Create TypedArray views over WASM memory for arena buffers
+    // These views are backed by WASM memory, eliminating JS heap allocation
+    arenaCvStack = new Uint32Array(buffer, exports.SIMD_MEMORY.CV_STACK, 64 * 8); // 64 levels × 8 words
+    arenaParentBlock = new Uint32Array(buffer, exports.SIMD_MEMORY.PARENT_BLOCK, 16); // 16 words
+    arenaChunkCv = new Uint32Array(buffer, exports.SIMD_MEMORY.CHUNK_CV, 8); // 8 words
+    arenaTempCvs = new Uint32Array(buffer, exports.SIMD_MEMORY.TEMP_CVS, 32); // 4 × 8 words
+    // Batch mode views
+    // 16 positions × 16 v128 words = 16 × 64 u32 words = 1024 words per position? No...
+    // In u32 terms: 16 positions × 16 words × 4 lanes = 1024 u32 values total
+    arenaBatchBlockWords = new Uint32Array(buffer, exports.SIMD_MEMORY.BATCH_BLOCK_WORDS, 16 * 16 * 4); // 16 pos × 16 words × 4 lanes
+    arenaBatchCv = new Uint32Array(buffer, exports.SIMD_MEMORY.BATCH_CV, 32); // 4 × 8 words
+    arenaBatchCounterLow = new Uint32Array(buffer, exports.SIMD_MEMORY.BATCH_COUNTER_LOW, 4); // 4 words
+    arenaBatchFlagsBase = new Uint32Array(buffer, exports.SIMD_MEMORY.BATCH_FLAGS_BASE, 4); // 4 words
+    arenaBatchOutput = new Uint32Array(buffer, exports.SIMD_MEMORY.BATCH_OUTPUT, 32); // 4 × 8 words
+}
+/**
+ * Initialize the WASM SIMD module synchronously.
+ * Call this once before using compress4x.
+ */
+// Cache generated WASM bytes to avoid regenerating on each init
+let cachedWasmBytes = null;
+function initSimdSync() {
+    if (wasmInstance)
+        return true;
+    if (!isSimdSupported()) {
+        return false;
+    }
+    try {
+        const wasmBytes = cachedWasmBytes || generateWasmBytes();
+        cachedWasmBytes = wasmBytes;
+        wasmMemory = new WebAssembly.Memory({ initial: 1 });
+        const importObject = {
+            js: { mem: wasmMemory },
+        };
+        const module = new WebAssembly.Module(wasmBytes.buffer);
+        wasmInstance = new WebAssembly.Instance(module, importObject);
+        wasmCompress4x = wasmInstance.exports.compress4x;
+        wasmCompressChunks4x = wasmInstance.exports.compressChunks4x;
+        wasmCompressParent = wasmInstance.exports.compressParent;
+        wasmMemoryView = new Uint8Array(wasmMemory.buffer);
+        wasmMemoryView32 = new Uint32Array(wasmMemory.buffer);
+        // Set up arena views for Merkle tree operations
+        setupArenaViews();
+        return true;
+    }
+    catch (e) {
+        console.warn("Failed to initialize WASM SIMD:", e);
+        return false;
+    }
+}
+/**
+ * Memory offsets for SIMD data layout
+ *
+ * WASM Arena Pattern: All working buffers live in WASM memory (64KB page)
+ * This eliminates JS heap allocations during hashing operations.
+ */
+exports.SIMD_MEMORY = {
+    // SIMD compress4x working area (used by WASM code) - single block
+    BLOCK_WORDS: 0, // 4 x 16 words = 512 bytes (transposed layout)
+    CHAINING_VALUES: 512, // 4 x 8 words = 128 bytes
+    OUTPUT: 640, // 4 x 8 words = 128 bytes
+    COUNTER_LOW: 768, // 4 words = 16 bytes
+    COUNTER_HIGH: 784, // 4 words = 16 bytes
+    BLOCK_LEN: 800, // 4 words = 16 bytes
+    FLAGS: 816, // 4 words = 16 bytes
+    // End of single-block SIMD working area: 832 bytes
+    // SIMD compressChunks4x working area - 16 blocks batched
+    // Each block position has 16 v128 values (one per message word) = 256 bytes
+    // 16 block positions = 16 × 256 = 4096 bytes
+    BATCH_BLOCK_WORDS: 832, // 16 positions × 256 bytes = 4096 bytes (transposed), ends at 4928
+    BATCH_CV: 4928, // 4 × 8 words × 4 bytes = 128 bytes (working CVs), ends at 5056
+    BATCH_COUNTER_LOW: 5056, // 4 words × 4 bytes = 16 bytes (per-chunk counters), ends at 5072
+    BATCH_FLAGS_BASE: 5072, // 4 words × 4 bytes = 16 bytes (base flags, no START/END), ends at 5088
+    BATCH_OUTPUT: 5088, // 4 × 8 words × 4 bytes = 128 bytes (final output), ends at 5216
+    // End of batch working area: 5216 bytes
+    // WASM Arena: JS working buffers (accessed via TypedArray views)
+    CV_STACK: 5216, // 64 levels × 8 words × 4 bytes = 2048 bytes, ends at 7264
+    PARENT_BLOCK: 7264, // 16 words × 4 bytes = 64 bytes, ends at 7328
+    CHUNK_CV: 7328, // 8 words × 4 bytes = 32 bytes, ends at 7360
+    TEMP_CVS: 7360, // 4 × 8 words × 4 bytes = 128 bytes, ends at 7488
+    // Total arena usage: ~7488 bytes (fits comfortably in 64KB page)
+};
+// Arena views - created once when SIMD initializes
+let arenaCvStack = null;
+let arenaParentBlock = null;
+let arenaChunkCv = null;
+let arenaTempCvs = null;
+// Batch mode arena views
+let arenaBatchBlockWords = null;
+let arenaBatchCv = null;
+let arenaBatchCounterLow = null;
+let arenaBatchFlagsBase = null;
+let arenaBatchOutput = null;
+/**
+ * Get the WASM memory views for writing input data.
+ */
+function getSimdMemory() {
+    if (!wasmMemoryView || !wasmMemoryView32)
+        return null;
+    return { view: wasmMemoryView, view32: wasmMemoryView32 };
+}
+/**
+ * Get the arena buffers for Merkle tree operations.
+ * These TypedArray views are backed by WASM memory - zero JS heap allocation.
+ */
+function getArenaBuffers() {
+    if (!arenaCvStack || !arenaParentBlock || !arenaChunkCv || !arenaTempCvs)
+        return null;
+    return {
+        cvStack: arenaCvStack,
+        parentBlock: arenaParentBlock,
+        chunkCv: arenaChunkCv,
+        tempCvs: arenaTempCvs,
+    };
+}
+/**
+ * Get the batch arena buffers for chunk-level batched operations.
+ * These TypedArray views are backed by WASM memory - zero JS heap allocation.
+ */
+function getBatchArenaBuffers() {
+    if (!arenaBatchBlockWords ||
+        !arenaBatchCv ||
+        !arenaBatchCounterLow ||
+        !arenaBatchFlagsBase ||
+        !arenaBatchOutput)
+        return null;
+    return {
+        blockWords: arenaBatchBlockWords,
+        cv: arenaBatchCv,
+        counterLow: arenaBatchCounterLow,
+        flagsBase: arenaBatchFlagsBase,
+        output: arenaBatchOutput,
+    };
+}
+/**
+ * Run the compress4x function.
+ * Data must already be set up in WASM memory.
+ */
+function runCompress4x() {
+    if (!wasmCompress4x) {
+        throw new Error("WASM SIMD not initialized. Call initSimdSync() first.");
+    }
+    wasmCompress4x();
+}
+/**
+ * Run the compressChunks4x function.
+ * Processes 4 full chunks (16 blocks each) in a single WASM call.
+ * Data must already be set up in batch arena buffers.
+ */
+function runCompressChunks4x() {
+    if (!wasmCompressChunks4x) {
+        throw new Error("WASM SIMD not initialized. Call initSimdSync() first.");
+    }
+    wasmCompressChunks4x();
+}
+/**
+ * Run the compressParent function.
+ * Compresses a parent node: reads 16 words from PARENT_BLOCK, writes 8 words to CHUNK_CV.
+ * Data must already be set up in arena buffers (PARENT_BLOCK at offset 7264).
+ * Output is written to CHUNK_CV at offset 7328.
+ */
+function runCompressParent() {
+    if (!wasmCompressParent) {
+        throw new Error("WASM SIMD not initialized. Call initSimdSync() first.");
+    }
+    wasmCompressParent();
+}
+/**
+ * Check if SIMD is initialized and ready.
+ */
+function isSimdReady() {
+    return wasmCompress4x !== null;
+}

node_modules/@huggingface/blake3-jit/dist/esm/compress.d.ts

@@ -0,0 +1,37 @@
+/**
+ * BLAKE3 Compression Function - Highly Optimized
+ *
+ * Optimization techniques applied (from Fleek Network case study):
+ * 1. Use 16 SMI variables for state instead of TypedArray
+ * 2. Use 16 SMI variables for message words
+ * 3. Fully inlined G function (no function call overhead)
+ * 4. Use `| 0` for integer coercion (forces V8 to use 32-bit ALU)
+ * 5. Hardcoded permutation swaps using only 2 temporary variables
+ * 6. Offset-based access pattern (avoid creating new views)
+ *
+ * The compression function takes:
+ * - cv: 8-word chaining value
+ * - block: 16-word message block (64 bytes)
+ * - counter: 64-bit block counter
+ * - blockLen: number of input bytes in this block
+ * - flags: domain separation flags
+ *
+ * And outputs 8 or 16 words depending on whether this is a root node.
+ */
+/**
+ * Compress a single block.
+ *
+ * This is the hot path - every optimization matters here.
+ *
+ * @param cv - Chaining value array
+ * @param cvOff - Offset into cv
+ * @param block - Message block words
+ * @param blockOff - Offset into block
+ * @param out - Output array (8 or 16 words)
+ * @param outOff - Offset into out
+ * @param full - If true, output all 16 words (for XOF); if false, output 8 words
+ * @param counter - 64-bit block counter
+ * @param blockLen - Number of bytes in this block (0-64)
+ * @param flags - Domain separation flags
+ */
+export declare function compress(cv: Uint32Array, cvOff: number, block: Uint32Array, blockOff: number, out: Uint32Array, outOff: number, full: boolean, counter: number, blockLen: number, flags: number): void;

node_modules/@huggingface/blake3-jit/dist/esm/compress.js

@@ -0,0 +1,916 @@
+/**
+ * BLAKE3 Compression Function - Highly Optimized
+ *
+ * Optimization techniques applied (from Fleek Network case study):
+ * 1. Use 16 SMI variables for state instead of TypedArray
+ * 2. Use 16 SMI variables for message words
+ * 3. Fully inlined G function (no function call overhead)
+ * 4. Use `| 0` for integer coercion (forces V8 to use 32-bit ALU)
+ * 5. Hardcoded permutation swaps using only 2 temporary variables
+ * 6. Offset-based access pattern (avoid creating new views)
+ *
+ * The compression function takes:
+ * - cv: 8-word chaining value
+ * - block: 16-word message block (64 bytes)
+ * - counter: 64-bit block counter
+ * - blockLen: number of input bytes in this block
+ * - flags: domain separation flags
+ *
+ * And outputs 8 or 16 words depending on whether this is a root node.
+ */
+/**
+ * Compress a single block.
+ *
+ * This is the hot path - every optimization matters here.
+ *
+ * @param cv - Chaining value array
+ * @param cvOff - Offset into cv
+ * @param block - Message block words
+ * @param blockOff - Offset into block
+ * @param out - Output array (8 or 16 words)
+ * @param outOff - Offset into out
+ * @param full - If true, output all 16 words (for XOF); if false, output 8 words
+ * @param counter - 64-bit block counter
+ * @param blockLen - Number of bytes in this block (0-64)
+ * @param flags - Domain separation flags
+ */
+export function compress(cv, cvOff, block, blockOff, out, outOff, full, counter, blockLen, flags) {
+    // Load message words into SMI variables for maximum performance
+    // V8 optimizes SMI arithmetic directly with the ALU
+    let m0 = block[blockOff] | 0;
+    let m1 = block[blockOff + 1] | 0;
+    let m2 = block[blockOff + 2] | 0;
+    let m3 = block[blockOff + 3] | 0;
+    let m4 = block[blockOff + 4] | 0;
+    let m5 = block[blockOff + 5] | 0;
+    let m6 = block[blockOff + 6] | 0;
+    let m7 = block[blockOff + 7] | 0;
+    let m8 = block[blockOff + 8] | 0;
+    let m9 = block[blockOff + 9] | 0;
+    let m10 = block[blockOff + 10] | 0;
+    let m11 = block[blockOff + 11] | 0;
+    let m12 = block[blockOff + 12] | 0;
+    let m13 = block[blockOff + 13] | 0;
+    let m14 = block[blockOff + 14] | 0;
+    let m15 = block[blockOff + 15] | 0;
+    // Initialize state: first 8 words from chaining value
+    let s0 = cv[cvOff] | 0;
+    let s1 = cv[cvOff + 1] | 0;
+    let s2 = cv[cvOff + 2] | 0;
+    let s3 = cv[cvOff + 3] | 0;
+    let s4 = cv[cvOff + 4] | 0;
+    let s5 = cv[cvOff + 5] | 0;
+    let s6 = cv[cvOff + 6] | 0;
+    let s7 = cv[cvOff + 7] | 0;
+    // Words 8-11: IV constants
+    let s8 = 0x6a09e667;
+    let s9 = 0xbb67ae85;
+    let s10 = 0x3c6ef372;
+    let s11 = 0xa54ff53a;
+    // Words 12-15: counter, blockLen, flags
+    // Note: counter is 64-bit, split into low and high 32-bit words
+    let s12 = counter | 0;
+    let s13 = (counter / 0x100000000) | 0;
+    let s14 = blockLen | 0;
+    let s15 = flags | 0;
+    // ============================================================
+    // 7 rounds of mixing
+    // Each round consists of 4 column G functions and 4 diagonal G functions
+    // followed by a message word permutation (except for round 7)
+    // ============================================================
+    // ROUND 1 (message schedule: 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)
+    // Column G functions
+    // G(0, 4, 8, 12) with m0, m1
+    s0 = (((s0 + s4) | 0) + m0) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s0 = (((s0 + s4) | 0) + m1) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // G(1, 5, 9, 13) with m2, m3
+    s1 = (((s1 + s5) | 0) + m2) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s1 = (((s1 + s5) | 0) + m3) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    // G(2, 6, 10, 14) with m4, m5
+    s2 = (((s2 + s6) | 0) + m4) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s2 = (((s2 + s6) | 0) + m5) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    // G(3, 7, 11, 15) with m6, m7
+    s3 = (((s3 + s7) | 0) + m6) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s3 = (((s3 + s7) | 0) + m7) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    // Diagonal G functions
+    // G(0, 5, 10, 15) with m8, m9
+    s0 = (((s0 + s5) | 0) + m8) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s0 = (((s0 + s5) | 0) + m9) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    // G(1, 6, 11, 12) with m10, m11
+    s1 = (((s1 + s6) | 0) + m10) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s1 = (((s1 + s6) | 0) + m11) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    // G(2, 7, 8, 13) with m12, m13
+    s2 = (((s2 + s7) | 0) + m12) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s2 = (((s2 + s7) | 0) + m13) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    // G(3, 4, 9, 14) with m14, m15
+    s3 = (((s3 + s4) | 0) + m14) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s3 = (((s3 + s4) | 0) + m15) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // Permute message words for round 2
+    // Permutation: [2,6,3,10,7,0,4,13,1,11,12,5,9,14,15,8]
+    // Using 2 temps for the two cycles in the permutation
+    {
+        const t0 = m0, t1 = m1;
+        m0 = m2;
+        m2 = m3;
+        m3 = m10;
+        m10 = m12;
+        m12 = m9;
+        m9 = m11;
+        m11 = m5;
+        m5 = t0;
+        m1 = m6;
+        m6 = m4;
+        m4 = m7;
+        m7 = m13;
+        m13 = m14;
+        m14 = m15;
+        m15 = m8;
+        m8 = t1;
+    }
+    // ROUND 2 (message schedule: 2,6,3,10,7,0,4,13,1,11,12,5,9,14,15,8)
+    s0 = (((s0 + s4) | 0) + m0) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s0 = (((s0 + s4) | 0) + m1) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    s1 = (((s1 + s5) | 0) + m2) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s1 = (((s1 + s5) | 0) + m3) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s2 = (((s2 + s6) | 0) + m4) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s2 = (((s2 + s6) | 0) + m5) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s3 = (((s3 + s7) | 0) + m6) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s3 = (((s3 + s7) | 0) + m7) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s0 = (((s0 + s5) | 0) + m8) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s0 = (((s0 + s5) | 0) + m9) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s1 = (((s1 + s6) | 0) + m10) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s1 = (((s1 + s6) | 0) + m11) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s2 = (((s2 + s7) | 0) + m12) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s2 = (((s2 + s7) | 0) + m13) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s3 = (((s3 + s4) | 0) + m14) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s3 = (((s3 + s4) | 0) + m15) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // Permute for round 3
+    {
+        const t0 = m0, t1 = m1;
+        m0 = m2;
+        m2 = m3;
+        m3 = m10;
+        m10 = m12;
+        m12 = m9;
+        m9 = m11;
+        m11 = m5;
+        m5 = t0;
+        m1 = m6;
+        m6 = m4;
+        m4 = m7;
+        m7 = m13;
+        m13 = m14;
+        m14 = m15;
+        m15 = m8;
+        m8 = t1;
+    }
+    // ROUND 3 (message schedule: 3,4,10,12,13,2,7,14,6,5,9,0,11,15,8,1)
+    s0 = (((s0 + s4) | 0) + m0) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s0 = (((s0 + s4) | 0) + m1) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    s1 = (((s1 + s5) | 0) + m2) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s1 = (((s1 + s5) | 0) + m3) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s2 = (((s2 + s6) | 0) + m4) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s2 = (((s2 + s6) | 0) + m5) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s3 = (((s3 + s7) | 0) + m6) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s3 = (((s3 + s7) | 0) + m7) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s0 = (((s0 + s5) | 0) + m8) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s0 = (((s0 + s5) | 0) + m9) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s1 = (((s1 + s6) | 0) + m10) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s1 = (((s1 + s6) | 0) + m11) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s2 = (((s2 + s7) | 0) + m12) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s2 = (((s2 + s7) | 0) + m13) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s3 = (((s3 + s4) | 0) + m14) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s3 = (((s3 + s4) | 0) + m15) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // Permute for round 4
+    {
+        const t0 = m0, t1 = m1;
+        m0 = m2;
+        m2 = m3;
+        m3 = m10;
+        m10 = m12;
+        m12 = m9;
+        m9 = m11;
+        m11 = m5;
+        m5 = t0;
+        m1 = m6;
+        m6 = m4;
+        m4 = m7;
+        m7 = m13;
+        m13 = m14;
+        m14 = m15;
+        m15 = m8;
+        m8 = t1;
+    }
+    // ROUND 4 (message schedule: 10,7,12,9,14,3,13,15,4,0,11,2,5,8,1,6)
+    s0 = (((s0 + s4) | 0) + m0) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s0 = (((s0 + s4) | 0) + m1) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    s1 = (((s1 + s5) | 0) + m2) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s1 = (((s1 + s5) | 0) + m3) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s2 = (((s2 + s6) | 0) + m4) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s2 = (((s2 + s6) | 0) + m5) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s3 = (((s3 + s7) | 0) + m6) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s3 = (((s3 + s7) | 0) + m7) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s0 = (((s0 + s5) | 0) + m8) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s0 = (((s0 + s5) | 0) + m9) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s1 = (((s1 + s6) | 0) + m10) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s1 = (((s1 + s6) | 0) + m11) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s2 = (((s2 + s7) | 0) + m12) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s2 = (((s2 + s7) | 0) + m13) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s3 = (((s3 + s4) | 0) + m14) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s3 = (((s3 + s4) | 0) + m15) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // Permute for round 5
+    {
+        const t0 = m0, t1 = m1;
+        m0 = m2;
+        m2 = m3;
+        m3 = m10;
+        m10 = m12;
+        m12 = m9;
+        m9 = m11;
+        m11 = m5;
+        m5 = t0;
+        m1 = m6;
+        m6 = m4;
+        m4 = m7;
+        m7 = m13;
+        m13 = m14;
+        m14 = m15;
+        m15 = m8;
+        m8 = t1;
+    }
+    // ROUND 5 (message schedule: 12,13,9,11,15,10,14,8,7,2,5,3,0,1,6,4)
+    s0 = (((s0 + s4) | 0) + m0) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s0 = (((s0 + s4) | 0) + m1) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    s1 = (((s1 + s5) | 0) + m2) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s1 = (((s1 + s5) | 0) + m3) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s2 = (((s2 + s6) | 0) + m4) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s2 = (((s2 + s6) | 0) + m5) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s3 = (((s3 + s7) | 0) + m6) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s3 = (((s3 + s7) | 0) + m7) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s0 = (((s0 + s5) | 0) + m8) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s0 = (((s0 + s5) | 0) + m9) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s1 = (((s1 + s6) | 0) + m10) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s1 = (((s1 + s6) | 0) + m11) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s2 = (((s2 + s7) | 0) + m12) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s2 = (((s2 + s7) | 0) + m13) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s3 = (((s3 + s4) | 0) + m14) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s3 = (((s3 + s4) | 0) + m15) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // Permute for round 6
+    {
+        const t0 = m0, t1 = m1;
+        m0 = m2;
+        m2 = m3;
+        m3 = m10;
+        m10 = m12;
+        m12 = m9;
+        m9 = m11;
+        m11 = m5;
+        m5 = t0;
+        m1 = m6;
+        m6 = m4;
+        m4 = m7;
+        m7 = m13;
+        m13 = m14;
+        m14 = m15;
+        m15 = m8;
+        m8 = t1;
+    }
+    // ROUND 6 (message schedule: 9,14,11,5,8,12,15,1,13,3,0,10,2,6,4,7)
+    s0 = (((s0 + s4) | 0) + m0) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s0 = (((s0 + s4) | 0) + m1) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    s1 = (((s1 + s5) | 0) + m2) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s1 = (((s1 + s5) | 0) + m3) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s2 = (((s2 + s6) | 0) + m4) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s2 = (((s2 + s6) | 0) + m5) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s3 = (((s3 + s7) | 0) + m6) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s3 = (((s3 + s7) | 0) + m7) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s0 = (((s0 + s5) | 0) + m8) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s0 = (((s0 + s5) | 0) + m9) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s1 = (((s1 + s6) | 0) + m10) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s1 = (((s1 + s6) | 0) + m11) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s2 = (((s2 + s7) | 0) + m12) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s2 = (((s2 + s7) | 0) + m13) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s3 = (((s3 + s4) | 0) + m14) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s3 = (((s3 + s4) | 0) + m15) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // Permute for round 7
+    {
+        const t0 = m0, t1 = m1;
+        m0 = m2;
+        m2 = m3;
+        m3 = m10;
+        m10 = m12;
+        m12 = m9;
+        m9 = m11;
+        m11 = m5;
+        m5 = t0;
+        m1 = m6;
+        m6 = m4;
+        m4 = m7;
+        m7 = m13;
+        m13 = m14;
+        m14 = m15;
+        m15 = m8;
+        m8 = t1;
+    }
+    // ROUND 7 (message schedule: 11,15,5,0,1,9,8,6,14,10,2,12,3,4,7,13)
+    s0 = (((s0 + s4) | 0) + m0) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s0 = (((s0 + s4) | 0) + m1) | 0;
+    s12 ^= s0;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s8 = (s8 + s12) | 0;
+    s4 ^= s8;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    s1 = (((s1 + s5) | 0) + m2) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s1 = (((s1 + s5) | 0) + m3) | 0;
+    s13 ^= s1;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s9 = (s9 + s13) | 0;
+    s5 ^= s9;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s2 = (((s2 + s6) | 0) + m4) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s2 = (((s2 + s6) | 0) + m5) | 0;
+    s14 ^= s2;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s10 = (s10 + s14) | 0;
+    s6 ^= s10;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s3 = (((s3 + s7) | 0) + m6) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s3 = (((s3 + s7) | 0) + m7) | 0;
+    s15 ^= s3;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s11 = (s11 + s15) | 0;
+    s7 ^= s11;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s0 = (((s0 + s5) | 0) + m8) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 16) | (s15 << 16);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 12) | (s5 << 20);
+    s0 = (((s0 + s5) | 0) + m9) | 0;
+    s15 ^= s0;
+    s15 = (s15 >>> 8) | (s15 << 24);
+    s10 = (s10 + s15) | 0;
+    s5 ^= s10;
+    s5 = (s5 >>> 7) | (s5 << 25);
+    s1 = (((s1 + s6) | 0) + m10) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 16) | (s12 << 16);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 12) | (s6 << 20);
+    s1 = (((s1 + s6) | 0) + m11) | 0;
+    s12 ^= s1;
+    s12 = (s12 >>> 8) | (s12 << 24);
+    s11 = (s11 + s12) | 0;
+    s6 ^= s11;
+    s6 = (s6 >>> 7) | (s6 << 25);
+    s2 = (((s2 + s7) | 0) + m12) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 16) | (s13 << 16);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 12) | (s7 << 20);
+    s2 = (((s2 + s7) | 0) + m13) | 0;
+    s13 ^= s2;
+    s13 = (s13 >>> 8) | (s13 << 24);
+    s8 = (s8 + s13) | 0;
+    s7 ^= s8;
+    s7 = (s7 >>> 7) | (s7 << 25);
+    s3 = (((s3 + s4) | 0) + m14) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 16) | (s14 << 16);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 12) | (s4 << 20);
+    s3 = (((s3 + s4) | 0) + m15) | 0;
+    s14 ^= s3;
+    s14 = (s14 >>> 8) | (s14 << 24);
+    s9 = (s9 + s14) | 0;
+    s4 ^= s9;
+    s4 = (s4 >>> 7) | (s4 << 25);
+    // ============================================================
+    // Final XOR and output
+    // ============================================================
+    // If full output needed (XOF mode), write words 8-15 first
+    // (written first in case out === cv)
+    if (full) {
+        out[outOff + 8] = s8 ^ cv[cvOff];
+        out[outOff + 9] = s9 ^ cv[cvOff + 1];
+        out[outOff + 10] = s10 ^ cv[cvOff + 2];
+        out[outOff + 11] = s11 ^ cv[cvOff + 3];
+        out[outOff + 12] = s12 ^ cv[cvOff + 4];
+        out[outOff + 13] = s13 ^ cv[cvOff + 5];
+        out[outOff + 14] = s14 ^ cv[cvOff + 6];
+        out[outOff + 15] = s15 ^ cv[cvOff + 7];
+    }
+    // Standard output: XOR state[0..7] with state[8..15]
+    out[outOff] = s0 ^ s8;
+    out[outOff + 1] = s1 ^ s9;
+    out[outOff + 2] = s2 ^ s10;
+    out[outOff + 3] = s3 ^ s11;
+    out[outOff + 4] = s4 ^ s12;
+    out[outOff + 5] = s5 ^ s13;
+    out[outOff + 6] = s6 ^ s14;
+    out[outOff + 7] = s7 ^ s15;
+}

node_modules/@huggingface/blake3-jit/dist/esm/constants.d.ts

@@ -0,0 +1,34 @@
+/**
+ * BLAKE3 Constants
+ *
+ * IV values are the same as SHA-256: first 32 bits of the fractional parts
+ * of the square roots of the first 8 primes (2..19)
+ */
+export declare const IV: Uint32Array<ArrayBuffer>;
+export declare const CHUNK_START = 1;
+export declare const CHUNK_END: number;
+export declare const PARENT: number;
+export declare const ROOT: number;
+export declare const KEYED_HASH: number;
+export declare const DERIVE_KEY_CONTEXT: number;
+export declare const DERIVE_KEY_MATERIAL: number;
+export declare const OUT_LEN = 32;
+export declare const KEY_LEN = 32;
+export declare const BLOCK_LEN = 64;
+export declare const CHUNK_LEN = 1024;
+export declare const MAX_DEPTH = 54;
+/**
+ * Precomputed message word permutations for all 7 rounds.
+ *
+ * The base permutation is: [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8]
+ * Each subsequent permutation is the previous one with this permutation applied.
+ *
+ * These are the indices into the message block for each round.
+ * By precomputing these, we avoid runtime permutation overhead.
+ */
+export declare const MSG_SCHEDULE: ReadonlyArray<ReadonlyArray<number>>;
+/**
+ * Flattened permutation table for compress function optimization.
+ * This enables direct indexed access: PERMUTATIONS[round * 16 + index]
+ */
+export declare const PERMUTATIONS: Uint8Array<ArrayBuffer>;

node_modules/@huggingface/blake3-jit/dist/esm/constants.js

@@ -0,0 +1,53 @@
+/**
+ * BLAKE3 Constants
+ *
+ * IV values are the same as SHA-256: first 32 bits of the fractional parts
+ * of the square roots of the first 8 primes (2..19)
+ */
+// Initialization Vector (same as SHA-256)
+export const IV = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]);
+// Domain separation flags
+export const CHUNK_START = 1;
+export const CHUNK_END = 1 << 1;
+export const PARENT = 1 << 2;
+export const ROOT = 1 << 3;
+export const KEYED_HASH = 1 << 4;
+export const DERIVE_KEY_CONTEXT = 1 << 5;
+export const DERIVE_KEY_MATERIAL = 1 << 6;
+// Size constants
+export const OUT_LEN = 32;
+export const KEY_LEN = 32;
+export const BLOCK_LEN = 64;
+export const CHUNK_LEN = 1024;
+// Maximum depth of the CV stack (supports up to 2^54 bytes input)
+export const MAX_DEPTH = 54;
+/**
+ * Precomputed message word permutations for all 7 rounds.
+ *
+ * The base permutation is: [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8]
+ * Each subsequent permutation is the previous one with this permutation applied.
+ *
+ * These are the indices into the message block for each round.
+ * By precomputing these, we avoid runtime permutation overhead.
+ */
+export const MSG_SCHEDULE = [
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8],
+    [3, 4, 10, 12, 13, 2, 7, 14, 6, 5, 9, 0, 11, 15, 8, 1],
+    [10, 7, 12, 9, 14, 3, 13, 15, 4, 0, 11, 2, 5, 8, 1, 6],
+    [12, 13, 9, 11, 15, 10, 14, 8, 7, 2, 5, 3, 0, 1, 6, 4],
+    [9, 14, 11, 5, 8, 12, 15, 1, 13, 3, 0, 10, 2, 6, 4, 7],
+    [11, 15, 5, 0, 1, 9, 8, 6, 14, 10, 2, 12, 3, 4, 7, 13],
+];
+/**
+ * Flattened permutation table for compress function optimization.
+ * This enables direct indexed access: PERMUTATIONS[round * 16 + index]
+ */
+export const PERMUTATIONS = new Uint8Array([
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9,
+    14, 15, 8, 3, 4, 10, 12, 13, 2, 7, 14, 6, 5, 9, 0, 11, 15, 8, 1, 10, 7, 12, 9, 14, 3, 13, 15, 4,
+    0, 11, 2, 5, 8, 1, 6, 12, 13, 9, 11, 15, 10, 14, 8, 7, 2, 5, 3, 0, 1, 6, 4, 9, 14, 11, 5, 8, 12,
+    15, 1, 13, 3, 0, 10, 2, 6, 4, 7, 11, 15, 5, 0, 1, 9, 8, 6, 14, 10, 2, 12, 3, 4, 7, 13,
+]);

node_modules/@huggingface/blake3-jit/dist/esm/hash.d.ts

@@ -0,0 +1,28 @@
+/**
+ * BLAKE3 Hash Function - Simple one-shot API
+ *
+ * This provides a simple hash() function optimized for different input sizes.
+ * For small inputs, uses pure JS. For large inputs, uses WASM SIMD.
+ */
+/**
+ * Hash input data and return the result.
+ * Automatically uses WASM SIMD for large inputs when available.
+ *
+ * @param input - Data to hash
+ * @param outputLength - Number of bytes to output (default: 32)
+ * @returns The hash output
+ */
+export declare function hash(input: Uint8Array, outputLength?: number): Uint8Array;
+/**
+ * Pre-warm SIMD initialization (call early to avoid latency later).
+ */
+export declare function warmupSimd(): boolean;
+/**
+ * Hash input data directly into a caller-provided output buffer.
+ * Zero-allocation for the common 32-byte case - ideal for performance-critical code.
+ *
+ * @param input - Data to hash
+ * @param output - Pre-allocated output buffer (must be at least outputLength bytes)
+ * @param outputLength - Number of bytes to output (default: 32, max: output.length)
+ */
+export declare function hashInto(input: Uint8Array, output: Uint8Array, outputLength?: number): void;

node_modules/@huggingface/blake3-jit/dist/esm/hash.js

@@ -0,0 +1,1033 @@
+/**
+ * BLAKE3 Hash Function - Simple one-shot API
+ *
+ * This provides a simple hash() function optimized for different input sizes.
+ * For small inputs, uses pure JS. For large inputs, uses WASM SIMD.
+ */
+import { compress } from "./compress.js";
+import { IV, CHUNK_START, CHUNK_END, PARENT, ROOT, BLOCK_LEN, CHUNK_LEN, OUT_LEN, } from "./constants.js";
+import { IS_LITTLE_ENDIAN, readLittleEndianWordsFull, readLittleEndianWordsPartial, writeLittleEndianBytesPartial, } from "./utils.js";
+import { initSimdSync, getSimdMemory, getArenaBuffers, runCompress4x, runCompressChunks4x, runCompressParent, SIMD_MEMORY, } from "./wasm-simd.js";
+// Pre-allocated buffers for reuse (single-threaded optimization)
+let blockWords = null;
+// ===== Contiguous Hyper CV Stack (Optimization #6) =====
+// Maximum tree depth for practical inputs (2^64 chunks = essentially unlimited)
+// Fixed allocation at module load - no runtime allocation
+const CV_STACK_DEPTH = 64;
+const HYPER_CV_STACK = new Uint32Array(CV_STACK_DEPTH * 8); // 64 CVs × 8 words = 512 words
+// Pre-computed offsets for the first few stack levels (hot path optimization)
+// Note: These can be used for further optimization if needed
+// const CV_STACK_OFF_0 = 0;
+// const CV_STACK_OFF_1 = 8;
+// const CV_STACK_OFF_2 = 16;
+// const CV_STACK_OFF_3 = 24;
+// ===== Pre-allocated CV Pool with Views (avoids subarray() in hot paths) =====
+const CV_POOL_SIZE = 64;
+const CV_POOL = new Uint32Array(CV_POOL_SIZE * 8); // 64 CVs × 8 words = 512 words
+const CV_VIEWS = [];
+for (let i = 0; i < CV_POOL_SIZE; i++) {
+    CV_VIEWS.push(CV_POOL.subarray(i * 8, i * 8 + 8));
+}
+// SIMD initialization state
+let simdAvailable = false;
+// Threshold for switching to SIMD (must be > 1 chunk to benefit from parallelism)
+const SIMD_THRESHOLD = 4 * CHUNK_LEN; // 4KB - need at least 4 chunks for SIMD benefit
+/**
+ * Initialize SIMD synchronously (lazy).
+ */
+function ensureSimdSync() {
+    if (simdAvailable)
+        return true;
+    simdAvailable = initSimdSync();
+    return simdAvailable;
+}
+// Reusable buffer for SIMD chunk CVs (4 chunks × 8 words)
+const simdChunkCvs = new Uint32Array(32);
+// ===== Module-level reusable buffers (single-threaded safe) =====
+// These eliminate heap allocations in hot paths
+// For hashChunkWithWords() and hashChunkRoot()
+const reusableTempCv = new Uint32Array(8);
+// For hashPureJS()
+const reusableChunkCv = new Uint32Array(8);
+const reusablePureParentBlock = new Uint32Array(16);
+const reusablePureParentCv = new Uint32Array(8);
+// For hashSimd() - use flat array for 4 chunk CVs (access via subarray)
+const reusableSimdCvs = new Uint32Array(32); // 4 × 8 words flat
+// For hashSimd() parent compression
+const reusableSimdParentBlock = new Uint32Array(16);
+const reusableSimdParentCv = new Uint32Array(8);
+// For hashSimd() parameters - TypedArrays instead of JS arrays
+const reusableOffsets = new Uint32Array(4);
+const reusableCounters = new Uint32Array(4);
+const reusableBlockLens = new Uint32Array(4);
+const reusableFlags = new Uint32Array(4);
+// Reusable output buffer for common 32-byte hash (eliminates allocations)
+const reusableOut8 = new Uint32Array(8); // Standard 32-byte output
+// Pre-created view to avoid allocation in hot path (Task 1 optimization)
+const reusableOut8View = new Uint8Array(reusableOut8.buffer, 0, 32);
+// ===== Unrolled CV Copy Helper (Task 7 optimization) =====
+// V8 will inline this - avoids loop overhead in hot paths
+function copyCV8(src, srcOff, dst, dstOff) {
+    dst[dstOff] = src[srcOff];
+    dst[dstOff + 1] = src[srcOff + 1];
+    dst[dstOff + 2] = src[srcOff + 2];
+    dst[dstOff + 3] = src[srcOff + 3];
+    dst[dstOff + 4] = src[srcOff + 4];
+    dst[dstOff + 5] = src[srcOff + 5];
+    dst[dstOff + 6] = src[srcOff + 6];
+    dst[dstOff + 7] = src[srcOff + 7];
+}
+/**
+ * Transpose 4 blocks (64 bytes each) into SIMD memory layout.
+ * The SIMD compress4x expects: [m0_0,m0_1,m0_2,m0_3, m1_0,m1_1,m1_2,m1_3, ...]
+ * where m{i}_{j} is message word i from block j.
+ *
+ * OPTIMIZED: Processes all 4 blocks together for each word position,
+ * writing 4 consecutive u32s at once for better cache locality.
+ *
+ * @param inputWords - Pre-created Uint32Array view of input (null if unaligned/non-LE).
+ *                     Created once per hash call to avoid allocation in hot loop.
+ */
+function transposeBlocksToSimd(input, offsets, // Starting offsets for each of 4 blocks
+blockLens, // Length of each block (0-64 bytes)
+mem32, blockCount, // 1-4 blocks
+inputWords) {
+    // Fast path: all blocks are full 64-byte blocks with aligned LE input
+    const allFull = blockCount === 4 &&
+        blockLens[0] === 64 &&
+        blockLens[1] === 64 &&
+        blockLens[2] === 64 &&
+        blockLens[3] === 64;
+    if (allFull &&
+        inputWords &&
+        offsets[0] % 4 === 0 &&
+        offsets[1] % 4 === 0 &&
+        offsets[2] % 4 === 0 &&
+        offsets[3] % 4 === 0) {
+        // Ultra-fast path: process all 4 blocks together, write 4 consecutive u32s per word
+        const wordOff0 = offsets[0] >>> 2;
+        const wordOff1 = offsets[1] >>> 2;
+        const wordOff2 = offsets[2] >>> 2;
+        const wordOff3 = offsets[3] >>> 2;
+        for (let w = 0; w < 16; w++) {
+            const dstBase = w * 4;
+            mem32[dstBase] = inputWords[wordOff0 + w];
+            mem32[dstBase + 1] = inputWords[wordOff1 + w];
+            mem32[dstBase + 2] = inputWords[wordOff2 + w];
+            mem32[dstBase + 3] = inputWords[wordOff3 + w];
+        }
+        return;
+    }
+    // Standard path: process each block independently (handles partial blocks)
+    for (let b = 0; b < blockCount; b++) {
+        const len = blockLens[b];
+        const off = offsets[b];
+        if (len === 64) {
+            // Full block
+            if (inputWords && off % 4 === 0) {
+                // Direct Uint32Array access for aligned LE blocks
+                const wordOff = off >>> 2;
+                for (let w = 0; w < 16; w++) {
+                    mem32[w * 4 + b] = inputWords[wordOff + w];
+                }
+            }
+            else {
+                // Byte-by-byte reconstruction
+                for (let w = 0; w < 16; w++) {
+                    const srcOff = off + w * 4;
+                    mem32[w * 4 + b] =
+                        input[srcOff] |
+                            (input[srcOff + 1] << 8) |
+                            (input[srcOff + 2] << 16) |
+                            (input[srcOff + 3] << 24);
+                }
+            }
+        }
+        else if (len === 0) {
+            // Zero block
+            for (let w = 0; w < 16; w++) {
+                mem32[w * 4 + b] = 0;
+            }
+        }
+        else {
+            // Partial block - handle word by word
+            for (let w = 0; w < 16; w++) {
+                const wordOff = w * 4;
+                if (wordOff >= len) {
+                    mem32[w * 4 + b] = 0;
+                }
+                else if (wordOff + 4 <= len) {
+                    const srcOff = off + wordOff;
+                    mem32[w * 4 + b] =
+                        input[srcOff] |
+                            (input[srcOff + 1] << 8) |
+                            (input[srcOff + 2] << 16) |
+                            (input[srcOff + 3] << 24);
+                }
+                else {
+                    // Partial word at end of block
+                    let word = 0;
+                    for (let i = 0; i < len - wordOff; i++) {
+                        word |= input[off + wordOff + i] << (i * 8);
+                    }
+                    mem32[w * 4 + b] = word;
+                }
+            }
+        }
+    }
+    // Zero unused block slots
+    for (let b = blockCount; b < 4; b++) {
+        for (let w = 0; w < 16; w++) {
+            mem32[w * 4 + b] = 0;
+        }
+    }
+}
+/**
+ * Transpose 4 full chunks (4 × 16 blocks = 64 blocks) into batch SIMD memory.
+ * This is used for the batched compressChunks4x function that processes
+ * all 16 blocks in a single WASM call.
+ *
+ * Memory layout: BATCH_BLOCK_WORDS has 16 positions, each with 16 v128 values.
+ * Position p, word w: mem32[(p * 64) + (w * 4) + lane]
+ *
+ * OPTIMIZED: Processes all 4 chunks together for each (pos, word) pair,
+ * writing 4 consecutive u32s at once for better cache locality.
+ *
+ * @param input - Input data (must have at least 4 full chunks = 4096 bytes)
+ * @param chunkOffsets - Starting offsets for each of 4 chunks
+ * @param mem32 - WASM memory view
+ * @param inputWords - Pre-created Uint32Array view (null if unaligned)
+ */
+function transposeBatchToSimd(input, chunkOffsets, mem32, inputWords) {
+    const BATCH_BASE = SIMD_MEMORY.BATCH_BLOCK_WORDS / 4;
+    // Get base word offsets for each chunk (pre-computed for fast path)
+    const chunk0WordBase = chunkOffsets[0] >>> 2;
+    const chunk1WordBase = chunkOffsets[1] >>> 2;
+    const chunk2WordBase = chunkOffsets[2] >>> 2;
+    const chunk3WordBase = chunkOffsets[3] >>> 2;
+    // Fast path: all chunks aligned and LE - process 4 consecutive u32s at once
+    if (inputWords && chunkOffsets[0] % 4 === 0) {
+        for (let pos = 0; pos < 16; pos++) {
+            const posBase = BATCH_BASE + pos * 64; // 16 words × 4 lanes = 64
+            const blockWordOff = pos * 16; // 16 words per block (64 bytes / 4)
+            // Process all 16 words, writing 4 chunks at a time (cache-friendly: 16 bytes per write group)
+            for (let w = 0; w < 16; w++) {
+                const dstBase = posBase + w * 4;
+                // Read word w from all 4 chunks at positions that become consecutive in output
+                mem32[dstBase] = inputWords[chunk0WordBase + blockWordOff + w];
+                mem32[dstBase + 1] = inputWords[chunk1WordBase + blockWordOff + w];
+                mem32[dstBase + 2] = inputWords[chunk2WordBase + blockWordOff + w];
+                mem32[dstBase + 3] = inputWords[chunk3WordBase + blockWordOff + w];
+            }
+        }
+    }
+    else {
+        // Slow path: byte-by-byte reconstruction, still cache-friendly write pattern
+        for (let pos = 0; pos < 16; pos++) {
+            const posBase = BATCH_BASE + pos * 64;
+            const blockByteOff = pos * 64; // 64 bytes per block
+            for (let w = 0; w < 16; w++) {
+                const dstBase = posBase + w * 4;
+                const wordByteOff = w * 4;
+                // Chunk 0
+                const off0 = chunkOffsets[0] + blockByteOff + wordByteOff;
+                mem32[dstBase] =
+                    input[off0] | (input[off0 + 1] << 8) | (input[off0 + 2] << 16) | (input[off0 + 3] << 24);
+                // Chunk 1
+                const off1 = chunkOffsets[1] + blockByteOff + wordByteOff;
+                mem32[dstBase + 1] =
+                    input[off1] | (input[off1 + 1] << 8) | (input[off1 + 2] << 16) | (input[off1 + 3] << 24);
+                // Chunk 2
+                const off2 = chunkOffsets[2] + blockByteOff + wordByteOff;
+                mem32[dstBase + 2] =
+                    input[off2] | (input[off2 + 1] << 8) | (input[off2 + 2] << 16) | (input[off2 + 3] << 24);
+                // Chunk 3
+                const off3 = chunkOffsets[3] + blockByteOff + wordByteOff;
+                mem32[dstBase + 3] =
+                    input[off3] | (input[off3 + 1] << 8) | (input[off3 + 2] << 16) | (input[off3 + 3] << 24);
+            }
+        }
+    }
+}
+// Pre-computed memory offsets for SIMD operations (single-block mode)
+const SIMD_CV_BASE = SIMD_MEMORY.CHAINING_VALUES / 4;
+const SIMD_OUT_BASE = SIMD_MEMORY.OUTPUT / 4;
+const SIMD_COUNTER_LOW_BASE = SIMD_MEMORY.COUNTER_LOW / 4;
+const SIMD_COUNTER_HIGH_BASE = SIMD_MEMORY.COUNTER_HIGH / 4;
+const SIMD_BLOCK_LEN_BASE = SIMD_MEMORY.BLOCK_LEN / 4;
+// Pre-computed memory offsets for batch SIMD operations (16-block mode)
+const BATCH_CV_BASE = SIMD_MEMORY.BATCH_CV / 4;
+const BATCH_COUNTER_LOW_BASE = SIMD_MEMORY.BATCH_COUNTER_LOW / 4;
+const BATCH_FLAGS_BASE_OFFSET = SIMD_MEMORY.BATCH_FLAGS_BASE / 4;
+const BATCH_OUTPUT_BASE = SIMD_MEMORY.BATCH_OUTPUT / 4;
+// Reusable arrays for batch processing
+const batchChunkOffsets = new Uint32Array(4);
+const SIMD_FLAGS_BASE = SIMD_MEMORY.FLAGS / 4;
+/**
+ * Set up chaining values in SIMD memory (transposed layout).
+ * Optimized: unrolled loops for common case of 4 chunks.
+ * cvs is flat: [cv0_word0..cv0_word7, cv1_word0..cv1_word7, ...]
+ */
+function setupSimdCvs(cvs, // Flat array: 4 × 8 words
+mem32, count) {
+    // Unrolled for 4 chunks (common case)
+    if (count === 4) {
+        for (let w = 0; w < 8; w++) {
+            const base = SIMD_CV_BASE + w * 4;
+            mem32[base] = cvs[w]; // cv0[w]
+            mem32[base + 1] = cvs[8 + w]; // cv1[w]
+            mem32[base + 2] = cvs[16 + w]; // cv2[w]
+            mem32[base + 3] = cvs[24 + w]; // cv3[w]
+        }
+    }
+    else {
+        for (let w = 0; w < 8; w++) {
+            const base = SIMD_CV_BASE + w * 4;
+            for (let c = 0; c < count; c++) {
+                mem32[base + c] = cvs[c * 8 + w];
+            }
+            for (let c = count; c < 4; c++) {
+                mem32[base + c] = 0;
+            }
+        }
+    }
+}
+/**
+ * Set up SIMD parameters (counters, flags, block lengths).
+ */
+function setupSimdParams(mem32, counters, blockLens, flagsArr, count) {
+    // Most chunk counters fit in 32 bits, so counter high is usually 0
+    for (let i = 0; i < count; i++) {
+        mem32[SIMD_COUNTER_LOW_BASE + i] = counters[i];
+        mem32[SIMD_COUNTER_HIGH_BASE + i] = 0; // Assume counters fit in 32 bits
+        mem32[SIMD_BLOCK_LEN_BASE + i] = blockLens[i];
+        mem32[SIMD_FLAGS_BASE + i] = flagsArr[i];
+    }
+    // Zero unused slots
+    for (let i = count; i < 4; i++) {
+        mem32[SIMD_COUNTER_LOW_BASE + i] = 0;
+        mem32[SIMD_COUNTER_HIGH_BASE + i] = 0;
+        mem32[SIMD_BLOCK_LEN_BASE + i] = 0;
+        mem32[SIMD_FLAGS_BASE + i] = 0;
+    }
+}
+/**
+ * Read output CVs from SIMD memory (untranspose).
+ */
+function readSimdOutputCvs(mem32, outputCvs, // Flat array: 4 × 8 words
+count) {
+    // Unrolled for 4 chunks (common case)
+    if (count === 4) {
+        for (let w = 0; w < 8; w++) {
+            const base = SIMD_OUT_BASE + w * 4;
+            outputCvs[w] = mem32[base];
+            outputCvs[8 + w] = mem32[base + 1];
+            outputCvs[16 + w] = mem32[base + 2];
+            outputCvs[24 + w] = mem32[base + 3];
+        }
+    }
+    else {
+        for (let w = 0; w < 8; w++) {
+            const base = SIMD_OUT_BASE + w * 4;
+            for (let c = 0; c < count; c++) {
+                outputCvs[c * 8 + w] = mem32[base + c];
+            }
+        }
+    }
+}
+function getBlockWords() {
+    if (!blockWords) {
+        blockWords = new Uint32Array(16);
+    }
+    return blockWords;
+}
+/**
+ * Hash a single chunk (up to 1024 bytes) with pre-created inputWords view.
+ * This is the optimized version that avoids creating Uint32Array views per chunk.
+ * (Fleek optimization Step 8)
+ */
+function hashChunkWithWords(input, inputWords, // Pre-created view of entire input
+inputOffset, inputLen, chunkCounter, flags, cv, cvOffset) {
+    // Use reusable temporary CV for intermediate blocks (single-threaded safe)
+    reusableTempCv.set(IV);
+    // Process full blocks
+    const fullBlocks = inputLen >>> 6; // inputLen / 64
+    const remainder = inputLen & 63; // inputLen % 64
+    // Calculate word offset for this chunk within the pre-created view
+    const chunkWordOffset = inputOffset >>> 2;
+    // Fast path for full chunks with aligned little-endian input
+    if (inputWords && remainder === 0 && inputLen === CHUNK_LEN) {
+        // All 16 blocks are full, use fast path exclusively
+        let wordOff = chunkWordOffset;
+        // Block 0 (CHUNK_START)
+        compress(reusableTempCv, 0, inputWords, wordOff, reusableTempCv, 0, false, chunkCounter, BLOCK_LEN, flags | CHUNK_START);
+        wordOff += 16;
+        // Blocks 1-14 (no special flags)
+        for (let i = 1; i < 15; i++) {
+            compress(reusableTempCv, 0, inputWords, wordOff, reusableTempCv, 0, false, chunkCounter, BLOCK_LEN, flags);
+            wordOff += 16;
+        }
+        // Block 15 (CHUNK_END)
+        compress(reusableTempCv, 0, inputWords, wordOff, reusableTempCv, 0, false, chunkCounter, BLOCK_LEN, flags | CHUNK_END);
+        cv.set(reusableTempCv, cvOffset);
+        return;
+    }
+    // Slower path for partial chunks or non-aligned input
+    const totalBlocks = fullBlocks + (remainder > 0 ? 1 : 0);
+    const block = getBlockWords();
+    for (let blockIdx = 0; blockIdx < totalBlocks; blockIdx++) {
+        const isFirst = blockIdx === 0;
+        const isLast = blockIdx === totalBlocks - 1;
+        const blockStart = blockIdx << 6;
+        const blockLen = isLast && remainder > 0 ? remainder : BLOCK_LEN;
+        // Determine flags for this block
+        let blockFlags = flags;
+        if (isFirst)
+            blockFlags |= CHUNK_START;
+        if (isLast)
+            blockFlags |= CHUNK_END;
+        // Load block words
+        if (isLast && remainder > 0) {
+            // Partial final block - need zero padding
+            readLittleEndianWordsPartial(input, inputOffset + blockStart, blockLen, block);
+        }
+        else if (inputWords && chunkWordOffset + (blockStart >>> 2) + 16 <= inputWords.length) {
+            // Fast path: use pre-created view directly
+            compress(reusableTempCv, 0, inputWords, chunkWordOffset + (blockStart >>> 2), reusableTempCv, 0, false, chunkCounter, blockLen, blockFlags);
+            continue;
+        }
+        else {
+            readLittleEndianWordsFull(input, inputOffset + blockStart, block);
+        }
+        compress(reusableTempCv, 0, block, 0, reusableTempCv, 0, false, chunkCounter, blockLen, blockFlags);
+    }
+    // Copy result to output
+    cv.set(reusableTempCv, cvOffset);
+}
+/**
+ * Hash input using pure JavaScript.
+ * Handles the full Merkle tree construction.
+ */
+function hashPureJS(input, outputLen) {
+    const inputLen = input.length;
+    // Special case: empty input
+    if (inputLen === 0) {
+        const block = getBlockWords();
+        block.fill(0);
+        // Use reusable output buffer for common 32-byte case
+        const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+        compress(IV, 0, block, 0, out, 0, outputLen > 32, 0, 0, CHUNK_START | CHUNK_END | ROOT);
+        // Return result - use pre-created view for common 32-byte case
+        if (outputLen === 32 && IS_LITTLE_ENDIAN) {
+            return reusableOut8View.slice();
+        }
+        const result = new Uint8Array(outputLen);
+        if (IS_LITTLE_ENDIAN) {
+            result.set(new Uint8Array(out.buffer, 0, outputLen));
+        }
+        else {
+            writeLittleEndianBytesPartial(out, 0, result, 0, outputLen);
+        }
+        return result;
+    }
+    // Calculate number of chunks
+    const numChunks = Math.ceil(inputLen / CHUNK_LEN);
+    // Single chunk optimization
+    if (numChunks === 1) {
+        // Use reusable output buffer for common 32-byte case
+        const cv = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+        hashChunkRoot(input, 0, inputLen, 0, 0, cv, outputLen > 32);
+        // Return result - use pre-created view for common 32-byte case
+        if (outputLen === 32 && IS_LITTLE_ENDIAN) {
+            return reusableOut8View.slice();
+        }
+        const result = new Uint8Array(outputLen);
+        if (IS_LITTLE_ENDIAN) {
+            result.set(new Uint8Array(cv.buffer, 0, outputLen));
+        }
+        else {
+            writeLittleEndianBytesPartial(cv, 0, result, 0, outputLen);
+        }
+        return result;
+    }
+    // Multiple chunks - need Merkle tree
+    // Use the global contiguous CV stack (no allocation)
+    const stack = HYPER_CV_STACK;
+    let stackLen = 0;
+    // Use reusable buffers (single-threaded safe)
+    const chunkCv = reusableChunkCv;
+    const parentBlock = reusablePureParentBlock;
+    const parentCv = reusablePureParentCv;
+    // Create Uint32Array view ONCE for entire input (Fleek optimization Step 8)
+    // This avoids creating views inside each chunk/block processing
+    let inputWords = null;
+    const canUseFastPath = IS_LITTLE_ENDIAN && input.byteOffset % 4 === 0;
+    if (canUseFastPath) {
+        inputWords = new Uint32Array(input.buffer, input.byteOffset, inputLen >>> 2);
+    }
+    // Determine how many full chunks we have
+    const fullChunks = inputLen >>> 10; // inputLen / 1024
+    const lastChunkLen = inputLen & 1023; // inputLen % 1024
+    // Process all full chunks with fast path (inlined for performance)
+    if (canUseFastPath && inputWords) {
+        for (let chunkIdx = 0; chunkIdx < fullChunks; chunkIdx++) {
+            // Inline chunk processing for full chunks
+            chunkCv.set(IV);
+            let wordOff = chunkIdx << 8; // chunkIdx * 256 (CHUNK_LEN/4)
+            // Block 0 (CHUNK_START)
+            compress(chunkCv, 0, inputWords, wordOff, chunkCv, 0, false, chunkIdx, BLOCK_LEN, CHUNK_START);
+            wordOff += 16;
+            // Blocks 1-14 (no special flags)
+            for (let b = 1; b < 15; b++) {
+                compress(chunkCv, 0, inputWords, wordOff, chunkCv, 0, false, chunkIdx, BLOCK_LEN, 0);
+                wordOff += 16;
+            }
+            // Block 15 (CHUNK_END)
+            compress(chunkCv, 0, inputWords, wordOff, chunkCv, 0, false, chunkIdx, BLOCK_LEN, CHUNK_END);
+            // Merge completed subtrees (avoid subarray by using index math)
+            let totalChunks = chunkIdx + 1;
+            let cvSrcOff = 0;
+            let cvSrc = chunkCv;
+            // Check if this is the last chunk overall
+            const isLastChunk = chunkIdx === fullChunks - 1 && lastChunkLen === 0;
+            while ((totalChunks & 1) === 0 && stackLen > 0) {
+                // Skip final merge if it would produce the root; let finalization handle it with ROOT flag
+                if (stackLen === 1 && isLastChunk) {
+                    break;
+                }
+                stackLen--;
+                const stackOff = stackLen * 8;
+                // Copy left CV from stack to parentBlock[0..7] (unrolled)
+                copyCV8(stack, stackOff, parentBlock, 0);
+                // Copy current CV to parentBlock[8..15] (unrolled)
+                copyCV8(cvSrc, cvSrcOff, parentBlock, 8);
+                compress(IV, 0, parentBlock, 0, parentCv, 0, false, 0, BLOCK_LEN, PARENT);
+                cvSrc = parentCv;
+                cvSrcOff = 0;
+                totalChunks >>>= 1;
+            }
+            // Push CV to stack (unrolled)
+            const stackOff = stackLen * 8;
+            copyCV8(cvSrc, cvSrcOff, stack, stackOff);
+            stackLen++;
+        }
+        // Process last partial chunk if any
+        if (lastChunkLen > 0) {
+            hashChunkWithWords(input, inputWords, fullChunks * CHUNK_LEN, lastChunkLen, fullChunks, 0, chunkCv, 0);
+            let totalChunks = fullChunks + 1;
+            let newCv = chunkCv;
+            let newCvOffset = 0;
+            while ((totalChunks & 1) === 0 && stackLen > 0) {
+                // Skip final merge; this IS the last chunk, let finalization handle ROOT flag
+                if (stackLen === 1) {
+                    break;
+                }
+                stackLen--;
+                const stackOff = stackLen * 8;
+                // Copy from stack to parentBlock[0..7] (unrolled)
+                copyCV8(stack, stackOff, parentBlock, 0);
+                // Copy from newCv to parentBlock[8..15] (unrolled)
+                copyCV8(newCv, newCvOffset, parentBlock, 8);
+                compress(IV, 0, parentBlock, 0, parentCv, 0, false, 0, BLOCK_LEN, PARENT);
+                newCv = parentCv;
+                newCvOffset = 0;
+                totalChunks >>>= 1;
+            }
+            // Push CV to stack (unrolled)
+            const pushOff = stackLen * 8;
+            copyCV8(newCv, newCvOffset, stack, pushOff);
+            stackLen++;
+        }
+    }
+    else {
+        // Slow path for unaligned or big-endian
+        for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
+            const chunkStart = chunkIdx * CHUNK_LEN;
+            const chunkLen = Math.min(CHUNK_LEN, inputLen - chunkStart);
+            hashChunkWithWords(input, inputWords, chunkStart, chunkLen, chunkIdx, 0, chunkCv, 0);
+            // Merge completed subtrees
+            let totalChunks = chunkIdx + 1;
+            let newCv = chunkCv;
+            let newCvOffset = 0;
+            // Check if this is the last chunk
+            const isLastChunk = chunkIdx === numChunks - 1;
+            while ((totalChunks & 1) === 0 && stackLen > 0) {
+                // Skip final merge if it would produce the root; let finalization handle it with ROOT flag
+                if (stackLen === 1 && isLastChunk) {
+                    break;
+                }
+                stackLen--;
+                const stackOff = stackLen * 8;
+                // Copy from stack to parentBlock[0..7] (unrolled)
+                copyCV8(stack, stackOff, parentBlock, 0);
+                // Copy from newCv to parentBlock[8..15] (unrolled)
+                copyCV8(newCv, newCvOffset, parentBlock, 8);
+                compress(IV, 0, parentBlock, 0, parentCv, 0, false, 0, BLOCK_LEN, PARENT);
+                newCv = parentCv;
+                newCvOffset = 0;
+                totalChunks >>>= 1;
+            }
+            // Push CV to stack (unrolled)
+            const pushOff = stackLen * 8;
+            copyCV8(newCv, newCvOffset, stack, pushOff);
+            stackLen++;
+        }
+    }
+    // Finalize: merge remaining stack entries
+    while (stackLen > 1) {
+        stackLen--;
+        const rightOff = stackLen * 8;
+        stackLen--;
+        const leftOff = stackLen * 8;
+        // Copy left CV to parentBlock[0..7] and right CV to parentBlock[8..15] (unrolled)
+        copyCV8(stack, leftOff, parentBlock, 0);
+        copyCV8(stack, rightOff, parentBlock, 8);
+        if (stackLen === 0) {
+            // This is the root - use reusable output buffer for common 32-byte case
+            const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+            compress(IV, 0, parentBlock, 0, out, 0, outputLen > 32, 0, BLOCK_LEN, PARENT | ROOT);
+            // Return result - use pre-created view for common 32-byte case
+            if (outputLen === 32 && IS_LITTLE_ENDIAN) {
+                return reusableOut8View.slice();
+            }
+            const result = new Uint8Array(outputLen);
+            if (IS_LITTLE_ENDIAN) {
+                result.set(new Uint8Array(out.buffer, 0, outputLen));
+            }
+            else {
+                writeLittleEndianBytesPartial(out, 0, result, 0, outputLen);
+            }
+            return result;
+        }
+        compress(IV, 0, parentBlock, 0, parentCv, 0, false, 0, BLOCK_LEN, PARENT);
+        // Push to stack (unrolled)
+        copyCV8(parentCv, 0, stack, stackLen * 8);
+        stackLen++;
+    }
+    // Single entry in stack - this is the root
+    const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+    const lastBlock = getBlockWords();
+    lastBlock.fill(0);
+    // Copy first 8 words from stack (unrolled)
+    copyCV8(stack, 0, lastBlock, 0);
+    compress(IV, 0, lastBlock, 0, out, 0, outputLen > 32, 0, BLOCK_LEN, ROOT);
+    // Return result - use pre-created view for common 32-byte case
+    if (outputLen === 32 && IS_LITTLE_ENDIAN) {
+        return reusableOut8View.slice();
+    }
+    const result = new Uint8Array(outputLen);
+    if (IS_LITTLE_ENDIAN) {
+        result.set(new Uint8Array(out.buffer, 0, outputLen));
+    }
+    else {
+        writeLittleEndianBytesPartial(out, 0, result, 0, outputLen);
+    }
+    return result;
+}
+/**
+ * Hash a single chunk that is also the root (single chunk input).
+ */
+function hashChunkRoot(input, inputOffset, inputLen, chunkCounter, flags, out, fullOutput) {
+    // Use reusable tempCv (single-threaded safe)
+    reusableTempCv.set(IV);
+    const block = getBlockWords();
+    // Process full blocks
+    const fullBlocks = inputLen >>> 6;
+    const remainder = inputLen & 63;
+    const totalBlocks = fullBlocks + (remainder > 0 ? 1 : 0) || 1; // At least 1 block
+    // Create a Uint32Array view if possible
+    let inputWords = null;
+    if (IS_LITTLE_ENDIAN && (input.byteOffset + inputOffset) % 4 === 0 && inputLen >= 4) {
+        inputWords = new Uint32Array(input.buffer, input.byteOffset + inputOffset, inputLen >>> 2);
+    }
+    for (let blockIdx = 0; blockIdx < totalBlocks; blockIdx++) {
+        const isFirst = blockIdx === 0;
+        const isLast = blockIdx === totalBlocks - 1;
+        const blockStart = blockIdx << 6;
+        const blockLen = isLast ? remainder || (inputLen > 0 ? BLOCK_LEN : 0) : BLOCK_LEN;
+        // Determine flags
+        let blockFlags = flags;
+        if (isFirst)
+            blockFlags |= CHUNK_START;
+        if (isLast)
+            blockFlags |= CHUNK_END | ROOT;
+        // Load block
+        if (isLast && remainder > 0) {
+            readLittleEndianWordsPartial(input, inputOffset + blockStart, blockLen, block);
+        }
+        else if (inputLen === 0) {
+            block.fill(0);
+        }
+        else if (inputWords && (blockStart >>> 2) + 16 <= inputWords.length) {
+            // Fast path
+            compress(reusableTempCv, 0, inputWords, blockStart >>> 2, isLast ? out : reusableTempCv, 0, isLast && fullOutput, chunkCounter, blockLen, blockFlags);
+            continue;
+        }
+        else {
+            readLittleEndianWordsFull(input, inputOffset + blockStart, block);
+        }
+        compress(reusableTempCv, 0, block, 0, isLast ? out : reusableTempCv, 0, isLast && fullOutput, chunkCounter, blockLen, blockFlags);
+    }
+}
+/**
+ * Hash using WASM SIMD - processes 4 chunks in parallel.
+ * Falls back to pure JS if SIMD fails.
+ */
+function hashSimd(input, outputLen) {
+    const mem = getSimdMemory();
+    if (!mem) {
+        return hashPureJS(input, outputLen);
+    }
+    const { view32 } = mem;
+    const inputLen = input.length;
+    const numChunks = Math.ceil(inputLen / CHUNK_LEN);
+    // For small inputs, pure JS is faster (no transpose overhead)
+    if (numChunks < 4) {
+        return hashPureJS(input, outputLen);
+    }
+    // Try to use WASM arena buffers (zero JS heap allocation)
+    // Falls back to JS buffers if arena not available
+    const arena = getArenaBuffers();
+    const useWasmParent = arena !== null; // Use WASM parent compress when arena available
+    let stack;
+    let tempCvs;
+    let parentBlock;
+    let parentCv;
+    if (arena) {
+        // Use WASM-backed arena buffers
+        stack = arena.cvStack;
+        tempCvs = arena.tempCvs;
+        parentBlock = arena.parentBlock;
+        parentCv = arena.chunkCv;
+    }
+    else {
+        // Fallback to JS heap buffers - use global contiguous stack (no allocation)
+        stack = HYPER_CV_STACK;
+        tempCvs = reusableSimdCvs;
+        parentBlock = reusableSimdParentBlock;
+        parentCv = reusableSimdParentCv;
+    }
+    let stackLen = 0;
+    // Use TypedArrays instead of JS arrays for block parameters
+    const offsets = reusableOffsets;
+    const counters = reusableCounters;
+    const blockLens = reusableBlockLens;
+    const flagsArr = reusableFlags;
+    // Create Uint32Array view once for entire hash call (optimization: avoid allocation in hot loop)
+    const inputWords = IS_LITTLE_ENDIAN && input.byteOffset % 4 === 0
+        ? new Uint32Array(input.buffer, input.byteOffset, input.byteLength >>> 2)
+        : null;
+    // Calculate number of full chunks (1024 bytes each)
+    const numFullChunks = inputLen >>> 10; // inputLen / 1024
+    // Process chunks in groups of 4
+    let chunkIdx = 0;
+    while (chunkIdx < numChunks) {
+        const groupSize = Math.min(4, numChunks - chunkIdx);
+        // === BATCH FAST PATH: 4 full chunks ===
+        // Use compressChunks4x for groups of exactly 4 full chunks
+        // This reduces 16 WASM calls to 1 per group
+        const canUseBatchPath = groupSize === 4 && chunkIdx + 4 <= numFullChunks;
+        if (canUseBatchPath) {
+            // Set up chunk offsets for batch transpose
+            batchChunkOffsets[0] = chunkIdx * CHUNK_LEN;
+            batchChunkOffsets[1] = (chunkIdx + 1) * CHUNK_LEN;
+            batchChunkOffsets[2] = (chunkIdx + 2) * CHUNK_LEN;
+            batchChunkOffsets[3] = (chunkIdx + 3) * CHUNK_LEN;
+            // Transpose all 64 blocks (4 chunks × 16 blocks) at once
+            transposeBatchToSimd(input, batchChunkOffsets, view32, inputWords);
+            // Set up initial CVs (IV) in batch memory - transposed layout
+            for (let w = 0; w < 8; w++) {
+                const ivWord = IV[w];
+                const base = BATCH_CV_BASE + w * 4;
+                view32[base] = ivWord;
+                view32[base + 1] = ivWord;
+                view32[base + 2] = ivWord;
+                view32[base + 3] = ivWord;
+            }
+            // Set up counters in batch memory
+            view32[BATCH_COUNTER_LOW_BASE] = chunkIdx;
+            view32[BATCH_COUNTER_LOW_BASE + 1] = chunkIdx + 1;
+            view32[BATCH_COUNTER_LOW_BASE + 2] = chunkIdx + 2;
+            view32[BATCH_COUNTER_LOW_BASE + 3] = chunkIdx + 3;
+            // Set up base flags (0 - no keyed hashing)
+            view32[BATCH_FLAGS_BASE_OFFSET] = 0;
+            view32[BATCH_FLAGS_BASE_OFFSET + 1] = 0;
+            view32[BATCH_FLAGS_BASE_OFFSET + 2] = 0;
+            view32[BATCH_FLAGS_BASE_OFFSET + 3] = 0;
+            // Run batched compress (16 blocks × 4 chunks in one call!)
+            runCompressChunks4x();
+            // Read output CVs from batch output - untranspose to tempCvs
+            for (let w = 0; w < 8; w++) {
+                const base = BATCH_OUTPUT_BASE + w * 4;
+                tempCvs[w] = view32[base]; // chunk 0
+                tempCvs[8 + w] = view32[base + 1]; // chunk 1
+                tempCvs[16 + w] = view32[base + 2]; // chunk 2
+                tempCvs[24 + w] = view32[base + 3]; // chunk 3
+            }
+        }
+        else {
+            // === STANDARD PATH: block-by-block processing ===
+            // Used for partial chunks or groups < 4
+            // Initialize CVs for this group to IV (flat array: 4 × 8 words)
+            for (let g = 0; g < groupSize; g++) {
+                const base = g * 8;
+                tempCvs[base] = IV[0];
+                tempCvs[base + 1] = IV[1];
+                tempCvs[base + 2] = IV[2];
+                tempCvs[base + 3] = IV[3];
+                tempCvs[base + 4] = IV[4];
+                tempCvs[base + 5] = IV[5];
+                tempCvs[base + 6] = IV[6];
+                tempCvs[base + 7] = IV[7];
+            }
+            // Process all 16 blocks of each chunk in this group
+            for (let blockIdx = 0; blockIdx < 16; blockIdx++) {
+                // Calculate block offsets and parameters (reuse arrays)
+                for (let g = 0; g < groupSize; g++) {
+                    const thisChunkIdx = chunkIdx + g;
+                    const chunkStart = thisChunkIdx * CHUNK_LEN;
+                    const chunkLen = Math.min(CHUNK_LEN, inputLen - chunkStart);
+                    const thisBlockStart = chunkStart + blockIdx * BLOCK_LEN;
+                    // Determine block length for this specific block
+                    const blockStartInChunk = blockIdx * BLOCK_LEN;
+                    let thisBlockLen = BLOCK_LEN;
+                    if (blockStartInChunk >= chunkLen) {
+                        thisBlockLen = 0;
+                    }
+                    else if (blockStartInChunk + BLOCK_LEN > chunkLen) {
+                        thisBlockLen = chunkLen - blockStartInChunk;
+                    }
+                    offsets[g] = thisBlockStart;
+                    counters[g] = thisChunkIdx;
+                    // Determine flags
+                    let flags = 0;
+                    if (blockIdx === 0)
+                        flags |= CHUNK_START;
+                    const totalBlocksInChunk = Math.ceil(chunkLen / BLOCK_LEN) || 1;
+                    if (blockIdx === totalBlocksInChunk - 1)
+                        flags |= CHUNK_END;
+                    blockLens[g] = thisBlockLen;
+                    flagsArr[g] = flags;
+                }
+                // Check if any blocks need processing
+                if (blockLens[0] === 0 && blockLens[1] === 0 && blockLens[2] === 0 && blockLens[3] === 0)
+                    continue;
+                // Transpose blocks into SIMD memory (pass pre-created view to avoid allocation)
+                transposeBlocksToSimd(input, offsets, blockLens, view32, groupSize, inputWords);
+                // Set up CVs in SIMD memory
+                setupSimdCvs(tempCvs, view32, groupSize);
+                // Set up parameters
+                setupSimdParams(view32, counters, blockLens, flagsArr, groupSize);
+                // Run SIMD compress
+                runCompress4x();
+                // Read output CVs back
+                readSimdOutputCvs(view32, simdChunkCvs, groupSize);
+                // Update tempCvs - copy from simdChunkCvs (both are flat 32-word arrays)
+                // simdChunkCvs layout matches tempCvs: [cv0_w0..cv0_w7, cv1_w0..cv1_w7, ...]
+                // IMPORTANT: Only update CVs for chunks that had data in this block!
+                // Skipping this check would corrupt CVs for partial chunks after their final block.
+                for (let g = 0; g < groupSize; g++) {
+                    if (blockLens[g] === 0)
+                        continue; // Don't update CV for chunks with no data in this block
+                    const base = g * 8;
+                    tempCvs[base] = simdChunkCvs[base];
+                    tempCvs[base + 1] = simdChunkCvs[base + 1];
+                    tempCvs[base + 2] = simdChunkCvs[base + 2];
+                    tempCvs[base + 3] = simdChunkCvs[base + 3];
+                    tempCvs[base + 4] = simdChunkCvs[base + 4];
+                    tempCvs[base + 5] = simdChunkCvs[base + 5];
+                    tempCvs[base + 6] = simdChunkCvs[base + 6];
+                    tempCvs[base + 7] = simdChunkCvs[base + 7];
+                }
+            }
+        }
+        // Merge each chunk's CV into the Merkle tree
+        for (let g = 0; g < groupSize; g++) {
+            const thisChunkIdx = chunkIdx + g;
+            // Merge completed subtrees
+            let totalChunks = thisChunkIdx + 1;
+            // Track newCv source - either from tempCvs or parentCv
+            let newCvBase = g * 8; // Offset into tempCvs
+            let newCvSrc = tempCvs;
+            // Check if this is the last chunk
+            const isLastChunk = thisChunkIdx === numChunks - 1;
+            while ((totalChunks & 1) === 0 && stackLen > 0) {
+                // Skip final merge if it would produce the root; let finalization handle it with ROOT flag
+                if (stackLen === 1 && isLastChunk) {
+                    break;
+                }
+                // Pop left child
+                stackLen--;
+                const stackOff = stackLen * 8;
+                // Copy from stack to parentBlock[0..7] (unrolled)
+                copyCV8(stack, stackOff, parentBlock, 0);
+                // Copy from newCv source to parentBlock[8..15] (unrolled)
+                copyCV8(newCvSrc, newCvBase, parentBlock, 8);
+                if (useWasmParent) {
+                    // WASM parent compress - data already in arena buffers
+                    runCompressParent();
+                }
+                else {
+                    compress(IV, 0, parentBlock, 0, parentCv, 0, false, 0, BLOCK_LEN, PARENT);
+                }
+                newCvSrc = parentCv;
+                newCvBase = 0;
+                totalChunks >>>= 1;
+            }
+            // Push to stack (unrolled)
+            const pushOff = stackLen * 8;
+            copyCV8(newCvSrc, newCvBase, stack, pushOff);
+            stackLen++;
+        }
+        chunkIdx += groupSize;
+    }
+    // Finalize: merge remaining stack entries
+    while (stackLen > 1) {
+        stackLen--;
+        const rightOff = stackLen * 8;
+        stackLen--;
+        const leftOff = stackLen * 8;
+        // Copy left CV to parentBlock[0..7] and right CV to parentBlock[8..15] (unrolled)
+        copyCV8(stack, leftOff, parentBlock, 0);
+        copyCV8(stack, rightOff, parentBlock, 8);
+        if (stackLen === 0) {
+            // This is the root - use reusable output buffer
+            const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+            compress(IV, 0, parentBlock, 0, out, 0, outputLen > 32, 0, BLOCK_LEN, PARENT | ROOT);
+            // Return result - use pre-created view for common 32-byte case
+            if (outputLen === 32 && IS_LITTLE_ENDIAN) {
+                return reusableOut8View.slice();
+            }
+            const result = new Uint8Array(outputLen);
+            if (IS_LITTLE_ENDIAN) {
+                result.set(new Uint8Array(out.buffer, 0, outputLen));
+            }
+            else {
+                writeLittleEndianBytesPartial(out, 0, result, 0, outputLen);
+            }
+            return result;
+        }
+        if (useWasmParent) {
+            // WASM parent compress - data already in arena buffers
+            runCompressParent();
+        }
+        else {
+            compress(IV, 0, parentBlock, 0, parentCv, 0, false, 0, BLOCK_LEN, PARENT);
+        }
+        // Push to stack (unrolled)
+        copyCV8(parentCv, 0, stack, stackLen * 8);
+        stackLen++;
+    }
+    // Single entry in stack - finalize as root
+    if (stackLen === 1) {
+        const block = getBlockWords();
+        block.fill(0);
+        // Copy first 8 words from stack (unrolled)
+        copyCV8(stack, 0, block, 0);
+        // Use reusable output buffer
+        const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+        compress(IV, 0, block, 0, out, 0, outputLen > 32, 0, BLOCK_LEN, ROOT);
+        // Return result - use pre-created view for common 32-byte case
+        if (outputLen === 32 && IS_LITTLE_ENDIAN) {
+            return reusableOut8View.slice();
+        }
+        const result = new Uint8Array(outputLen);
+        if (IS_LITTLE_ENDIAN) {
+            result.set(new Uint8Array(out.buffer, 0, outputLen));
+        }
+        else {
+            writeLittleEndianBytesPartial(out, 0, result, 0, outputLen);
+        }
+        return result;
+    }
+    // Should not reach here
+    return hashPureJS(input, outputLen);
+}
+/**
+ * Hash input data and return the result.
+ * Automatically uses WASM SIMD for large inputs when available.
+ *
+ * @param input - Data to hash
+ * @param outputLength - Number of bytes to output (default: 32)
+ * @returns The hash output
+ */
+export function hash(input, outputLength = OUT_LEN) {
+    // For large inputs, use SIMD for ~1.5x performance improvement
+    if (input.length >= SIMD_THRESHOLD && ensureSimdSync()) {
+        return hashSimd(input, outputLength);
+    }
+    return hashPureJS(input, outputLength);
+}
+/**
+ * Pre-warm SIMD initialization (call early to avoid latency later).
+ */
+export function warmupSimd() {
+    return ensureSimdSync();
+}
+/**
+ * Hash input data directly into a caller-provided output buffer.
+ * Zero-allocation for the common 32-byte case - ideal for performance-critical code.
+ *
+ * @param input - Data to hash
+ * @param output - Pre-allocated output buffer (must be at least outputLength bytes)
+ * @param outputLength - Number of bytes to output (default: 32, max: output.length)
+ */
+export function hashInto(input, output, outputLength = OUT_LEN) {
+    // Validate output buffer
+    if (output.length < outputLength) {
+        throw new Error(`Output buffer too small: ${output.length} < ${outputLength}`);
+    }
+    // For large inputs, use SIMD for ~1.5x performance improvement
+    if (input.length >= SIMD_THRESHOLD && ensureSimdSync()) {
+        hashSimdInto(input, output, outputLength);
+        return;
+    }
+    hashPureJSInto(input, output, outputLength);
+}
+/**
+ * Internal: Hash using pure JS, writing directly to output buffer.
+ */
+function hashPureJSInto(input, output, outputLen) {
+    const inputLen = input.length;
+    // Special case: empty input
+    if (inputLen === 0) {
+        const block = getBlockWords();
+        block.fill(0);
+        const out = outputLen <= 32 ? reusableOut8 : new Uint32Array(16);
+        compress(IV, 0, block, 0, out, 0, outputLen > 32, 0, 0, CHUNK_START | CHUNK_END | ROOT);
+        // Copy result to output
+        if (IS_LITTLE_ENDIAN) {
+            output.set(new Uint8Array(out.buffer, out.byteOffset, outputLen));
+        }
+        else {
+            writeLittleEndianBytesPartial(out, 0, output, 0, outputLen);
+        }
+        return;
+    }
+    // Calculate number of chunks
+    const numChunks = Math.ceil(inputLen / CHUNK_LEN);
+    // Single chunk optimization
+    if (numChunks === 1) {
+        const cv = outputLen <= 32 ? reusableOut8 : new Uint32Array(16);
+        hashChunkRoot(input, 0, inputLen, 0, 0, cv, outputLen > 32);
+        // Copy result to output
+        if (IS_LITTLE_ENDIAN) {
+            output.set(new Uint8Array(cv.buffer, cv.byteOffset, outputLen));
+        }
+        else {
+            writeLittleEndianBytesPartial(cv, 0, output, 0, outputLen);
+        }
+        return;
+    }
+    // Multiple chunks - delegate to hashPureJS and copy result
+    const result = hashPureJS(input, outputLen);
+    output.set(result);
+}
+/**
+ * Internal: Hash using SIMD, writing directly to output buffer.
+ */
+function hashSimdInto(input, output, outputLen) {
+    // Delegate to hashSimd and copy result (SIMD path already optimized)
+    const result = hashSimd(input, outputLen);
+    output.set(result);
+}

node_modules/@huggingface/blake3-jit/dist/esm/hasher.d.ts

@@ -0,0 +1,108 @@
+/**
+ * BLAKE3 Hasher - Incremental hashing with support for all modes
+ *
+ * Supports:
+ * - Regular hashing
+ * - Keyed hashing (MAC)
+ * - Key derivation (derive_key)
+ * - XOF (eXtendable Output Function) mode
+ */
+/**
+ * Output state for XOF (eXtendable Output Function) mode.
+ * Allows reading arbitrary amounts of output.
+ */
+export declare class XofReader {
+    private inputCv;
+    private blockWords;
+    private counter;
+    private blockLen;
+    private flags;
+    private outputBlock;
+    private outputBlockOffset;
+    constructor(inputCv: Uint32Array, blockWords: Uint32Array, counter: number, blockLen: number, flags: number);
+    /**
+     * Read the next `length` bytes of output.
+     */
+    read(length: number): Uint8Array;
+}
+/**
+ * Main BLAKE3 Hasher class.
+ *
+ * Usage:
+ *   const hasher = new Hasher();
+ *   hasher.update(data);
+ *   const hash = hasher.finalize();
+ *
+ * Or with chaining:
+ *   const hash = new Hasher().update(data).finalize();
+ */
+export declare class Hasher {
+    private chunkState;
+    private keyWords;
+    private cvStack;
+    private cvStackLen;
+    private flags;
+    private parentBlock;
+    private parentCv;
+    private chunkCv;
+    private outWords;
+    private finalizeCv;
+    /**
+     * Create a new Hasher.
+     *
+     * @param keyWords - Initial key words (IV for regular hashing)
+     * @param flags - Domain separation flags
+     */
+    constructor(keyWords?: Uint32Array, flags?: number);
+    /**
+     * Reset the hasher to process a new message with the same key/flags.
+     * Reuses all internal buffers — zero allocations.
+     */
+    reset(): this;
+    /**
+     * Create a new keyed hasher (MAC).
+     *
+     * @param key - 32-byte key
+     */
+    static newKeyed(key: Uint8Array): Hasher;
+    /**
+     * Create a new key derivation hasher.
+     *
+     * @param context - Context string for domain separation
+     */
+    static newDeriveKey(context: string): Hasher;
+    /**
+     * Push a chaining value onto the stack.
+     */
+    private pushCv;
+    /**
+     * Pop a chaining value from the stack.
+     */
+    private popCv;
+    /**
+     * Add a chunk's chaining value and merge completed subtrees.
+     */
+    private addChunkCv;
+    /**
+     * Update the hasher with input data.
+     *
+     * @param input - Data to hash
+     * @returns this (for chaining)
+     */
+    update(input: Uint8Array): this;
+    /**
+     * Get the output parameters (for XOF mode or finalization).
+     */
+    private finalizeOutput;
+    /**
+     * Finalize the hash and return the result.
+     *
+     * @param outputLength - Number of bytes to output (default: 32)
+     * @returns The hash output
+     */
+    finalize(outputLength?: number): Uint8Array;
+    /**
+     * Finalize and return an XOF reader for arbitrary-length output.
+     */
+    finalizeXof(): XofReader;
+}

node_modules/@huggingface/blake3-jit/dist/esm/hasher.js

@@ -0,0 +1,391 @@
+/**
+ * BLAKE3 Hasher - Incremental hashing with support for all modes
+ *
+ * Supports:
+ * - Regular hashing
+ * - Keyed hashing (MAC)
+ * - Key derivation (derive_key)
+ * - XOF (eXtendable Output Function) mode
+ */
+import { compress } from "./compress.js";
+import { IV, CHUNK_START, CHUNK_END, PARENT, ROOT, KEYED_HASH, DERIVE_KEY_CONTEXT, DERIVE_KEY_MATERIAL, BLOCK_LEN, CHUNK_LEN, OUT_LEN, KEY_LEN, MAX_DEPTH, } from "./constants.js";
+import { IS_LITTLE_ENDIAN, readLittleEndianWordsFull, writeLittleEndianBytesPartial, encodeUTF8, } from "./utils.js";
+/**
+ * Output state for XOF (eXtendable Output Function) mode.
+ * Allows reading arbitrary amounts of output.
+ */
+export class XofReader {
+    inputCv;
+    blockWords;
+    counter;
+    blockLen;
+    flags;
+    outputBlock;
+    outputBlockOffset;
+    constructor(inputCv, blockWords, counter, blockLen, flags) {
+        this.inputCv = inputCv;
+        this.blockWords = blockWords;
+        this.counter = counter;
+        this.blockLen = blockLen;
+        this.flags = flags | ROOT;
+        this.outputBlock = new Uint32Array(16);
+        this.outputBlockOffset = 64; // Forces generation on first read
+    }
+    /**
+     * Read the next `length` bytes of output.
+     */
+    read(length) {
+        const output = new Uint8Array(length);
+        let outputOffset = 0;
+        while (outputOffset < length) {
+            // Generate new output block if needed
+            if (this.outputBlockOffset >= 64) {
+                compress(this.inputCv, 0, this.blockWords, 0, this.outputBlock, 0, true, // full 64-byte output
+                this.counter++, this.blockLen, this.flags);
+                this.outputBlockOffset = 0;
+            }
+            // Copy bytes from output block
+            const available = 64 - this.outputBlockOffset;
+            const toCopy = Math.min(available, length - outputOffset);
+            // Optimized copy using writeLittleEndianBytesPartial
+            const wordOffset = this.outputBlockOffset >>> 2;
+            const byteWithinWord = this.outputBlockOffset & 3;
+            if (byteWithinWord === 0 && toCopy >= 4) {
+                // Aligned copy - can use word-at-a-time
+                const fullWords = toCopy >>> 2;
+                writeLittleEndianBytesPartial(this.outputBlock, wordOffset, output, outputOffset, fullWords << 2);
+                const bytesCopied = fullWords << 2;
+                outputOffset += bytesCopied;
+                this.outputBlockOffset += bytesCopied;
+            }
+            else {
+                // Byte-by-byte for unaligned access
+                for (let i = 0; i < toCopy; i++) {
+                    const wordIdx = (this.outputBlockOffset + i) >>> 2;
+                    const byteIdx = (this.outputBlockOffset + i) & 3;
+                    output[outputOffset + i] = (this.outputBlock[wordIdx] >>> (byteIdx << 3)) & 0xff;
+                }
+                outputOffset += toCopy;
+                this.outputBlockOffset += toCopy;
+            }
+        }
+        return output;
+    }
+}
+/**
+ * Chunk state for processing input data.
+ * Each chunk is 1024 bytes and produces an 8-word chaining value.
+ */
+class ChunkState {
+    chainingValue;
+    chunkCounter;
+    blockWords;
+    blockLen;
+    blocksCompressed;
+    flags;
+    constructor(keyWords, chunkCounter, flags) {
+        this.chainingValue = new Uint32Array(keyWords);
+        this.chunkCounter = chunkCounter;
+        this.blockWords = new Uint32Array(16);
+        this.blockLen = 0;
+        this.blocksCompressed = 0;
+        this.flags = flags;
+    }
+    resetTo(keyWords, chunkCounter, flags) {
+        this.chainingValue.set(keyWords);
+        this.chunkCounter = chunkCounter;
+        this.blockLen = 0;
+        this.blocksCompressed = 0;
+        this.flags = flags;
+    }
+    /**
+     * Get the flags for the current block.
+     */
+    startFlag() {
+        return this.blocksCompressed === 0 ? CHUNK_START : 0;
+    }
+    /**
+     * Update the chunk state with input data.
+     * Returns the number of bytes consumed.
+     */
+    update(input, inputOffset, inputLen) {
+        let consumed = 0;
+        while (inputLen > 0) {
+            // If we have a full block, compress it
+            if (this.blockLen === BLOCK_LEN) {
+                compress(this.chainingValue, 0, this.blockWords, 0, this.chainingValue, 0, false, this.chunkCounter, BLOCK_LEN, this.flags | this.startFlag());
+                this.blocksCompressed++;
+                this.blockLen = 0;
+            }
+            // Fill the block buffer
+            const want = BLOCK_LEN - this.blockLen;
+            const take = Math.min(want, inputLen);
+            if (this.blockLen === 0 && take === BLOCK_LEN) {
+                readLittleEndianWordsFull(input, inputOffset, this.blockWords);
+            }
+            else {
+                // Partial block - byte-by-byte into correct position
+                for (let i = 0; i < take; i++) {
+                    const pos = this.blockLen + i;
+                    const wordIdx = pos >>> 2;
+                    const byteIdx = pos & 3;
+                    if (byteIdx === 0) {
+                        this.blockWords[wordIdx] = input[inputOffset + i];
+                    }
+                    else {
+                        this.blockWords[wordIdx] |= input[inputOffset + i] << (byteIdx << 3);
+                    }
+                }
+            }
+            this.blockLen += take;
+            inputOffset += take;
+            inputLen -= take;
+            consumed += take;
+        }
+        return consumed;
+    }
+    /**
+     * Finalize this chunk and return its output.
+     * Returns 8 words (chaining value) or 16 words (if root).
+     */
+    output() {
+        // Zero-pad unused words in blockWords to avoid stale data from previous blocks
+        // This is necessary when a partial block follows a full block within the same chunk
+        const usedWords = (this.blockLen + 3) >>> 2; // ceil(blockLen / 4)
+        for (let i = usedWords; i < 16; i++) {
+            this.blockWords[i] = 0;
+        }
+        return {
+            inputCv: this.chainingValue,
+            blockWords: this.blockWords,
+            blockLen: this.blockLen,
+            counter: this.chunkCounter,
+            flags: this.flags | this.startFlag() | CHUNK_END,
+        };
+    }
+    /**
+     * Get the number of bytes in this chunk.
+     */
+    len() {
+        return this.blocksCompressed * BLOCK_LEN + this.blockLen;
+    }
+}
+/**
+ * Main BLAKE3 Hasher class.
+ *
+ * Usage:
+ *   const hasher = new Hasher();
+ *   hasher.update(data);
+ *   const hash = hasher.finalize();
+ *
+ * Or with chaining:
+ *   const hash = new Hasher().update(data).finalize();
+ */
+export class Hasher {
+    chunkState;
+    keyWords;
+    cvStack;
+    cvStackLen;
+    flags;
+    parentBlock;
+    parentCv;
+    chunkCv;
+    outWords;
+    finalizeCv;
+    /**
+     * Create a new Hasher.
+     *
+     * @param keyWords - Initial key words (IV for regular hashing)
+     * @param flags - Domain separation flags
+     */
+    constructor(keyWords, flags) {
+        this.keyWords = keyWords ? new Uint32Array(keyWords) : new Uint32Array(IV);
+        this.flags = flags ?? 0;
+        this.chunkState = new ChunkState(this.keyWords, 0, this.flags);
+        this.cvStack = new Uint32Array(MAX_DEPTH * 8);
+        this.cvStackLen = 0;
+        this.parentBlock = new Uint32Array(16);
+        this.parentCv = new Uint32Array(8);
+        this.chunkCv = new Uint32Array(8);
+        this.outWords = new Uint32Array(16);
+        this.finalizeCv = new Uint32Array(8);
+    }
+    /**
+     * Reset the hasher to process a new message with the same key/flags.
+     * Reuses all internal buffers — zero allocations.
+     */
+    reset() {
+        this.chunkState.resetTo(this.keyWords, 0, this.flags);
+        this.cvStackLen = 0;
+        return this;
+    }
+    /**
+     * Create a new keyed hasher (MAC).
+     *
+     * @param key - 32-byte key
+     */
+    static newKeyed(key) {
+        if (key.length !== KEY_LEN) {
+            throw new Error(`Key must be ${KEY_LEN} bytes, got ${key.length}`);
+        }
+        const keyWords = new Uint32Array(8);
+        if (IS_LITTLE_ENDIAN) {
+            const view = new Uint32Array(key.buffer, key.byteOffset, 8);
+            keyWords.set(view);
+        }
+        else {
+            for (let i = 0; i < 8; i++) {
+                const off = i * 4;
+                keyWords[i] = key[off] | (key[off + 1] << 8) | (key[off + 2] << 16) | (key[off + 3] << 24);
+            }
+        }
+        return new Hasher(keyWords, KEYED_HASH);
+    }
+    /**
+     * Create a new key derivation hasher.
+     *
+     * @param context - Context string for domain separation
+     */
+    static newDeriveKey(context) {
+        // First, hash the context string with DERIVE_KEY_CONTEXT flag
+        const contextBytes = encodeUTF8(context);
+        const contextHasher = new Hasher(new Uint32Array(IV), DERIVE_KEY_CONTEXT);
+        contextHasher.update(contextBytes);
+        // Get the context key
+        const contextKey = new Uint32Array(8);
+        const output = contextHasher.finalizeOutput();
+        compress(output.inputCv, 0, output.blockWords, 0, contextKey, 0, false, output.counter, output.blockLen, output.flags | ROOT);
+        // Return a hasher initialized with the context key
+        return new Hasher(contextKey, DERIVE_KEY_MATERIAL);
+    }
+    /**
+     * Push a chaining value onto the stack.
+     */
+    pushCv(cv, cvOffset) {
+        this.cvStack.set(cv.subarray(cvOffset, cvOffset + 8), this.cvStackLen * 8);
+        this.cvStackLen++;
+    }
+    /**
+     * Pop a chaining value from the stack.
+     */
+    popCv(out, outOffset) {
+        this.cvStackLen--;
+        out.set(this.cvStack.subarray(this.cvStackLen * 8, (this.cvStackLen + 1) * 8), outOffset);
+    }
+    /**
+     * Add a chunk's chaining value and merge completed subtrees.
+     */
+    addChunkCv(newCv, newCvOffset, totalChunks) {
+        const parentBlock = this.parentBlock;
+        const parentCv = this.parentCv;
+        while ((totalChunks & 1) === 0) {
+            // Pop left child, new CV is right child
+            this.popCv(parentBlock, 0);
+            parentBlock.set(newCv.subarray(newCvOffset, newCvOffset + 8), 8);
+            compress(this.keyWords, 0, parentBlock, 0, parentCv, 0, false, 0, BLOCK_LEN, this.flags | PARENT);
+            newCv = parentCv;
+            newCvOffset = 0;
+            totalChunks >>>= 1;
+        }
+        this.pushCv(newCv, newCvOffset);
+    }
+    /**
+     * Update the hasher with input data.
+     *
+     * @param input - Data to hash
+     * @returns this (for chaining)
+     */
+    update(input) {
+        let inputOffset = 0;
+        let inputLen = input.length;
+        // Fill the current chunk
+        while (inputLen > 0) {
+            // If current chunk is full, finalize it and start a new one
+            if (this.chunkState.len() === CHUNK_LEN) {
+                const output = this.chunkState.output();
+                const chunkCv = this.chunkCv;
+                compress(output.inputCv, 0, output.blockWords, 0, chunkCv, 0, false, output.counter, output.blockLen, output.flags);
+                const totalChunks = this.chunkState.chunkCounter + 1;
+                this.addChunkCv(chunkCv, 0, totalChunks);
+                this.chunkState.resetTo(this.keyWords, totalChunks, this.flags);
+            }
+            // Fill the current chunk
+            const want = CHUNK_LEN - this.chunkState.len();
+            const take = Math.min(want, inputLen);
+            this.chunkState.update(input, inputOffset, take);
+            inputOffset += take;
+            inputLen -= take;
+        }
+        return this;
+    }
+    /**
+     * Get the output parameters (for XOF mode or finalization).
+     */
+    finalizeOutput() {
+        let output = this.chunkState.output();
+        let parentBlock = this.parentBlock;
+        let cv = this.finalizeCv;
+        // If there are chunks on the stack, merge them
+        if (this.cvStackLen > 0) {
+            // First compress the current chunk
+            compress(output.inputCv, 0, output.blockWords, 0, cv, 0, false, output.counter, output.blockLen, output.flags);
+            // Merge with parent nodes from stack
+            while (this.cvStackLen > 0) {
+                this.cvStackLen--;
+                parentBlock.set(this.cvStack.subarray(this.cvStackLen * 8, (this.cvStackLen + 1) * 8), 0);
+                parentBlock.set(cv, 8);
+                if (this.cvStackLen > 0) {
+                    compress(this.keyWords, 0, parentBlock, 0, cv, 0, false, 0, BLOCK_LEN, this.flags | PARENT);
+                }
+                else {
+                    // This is the root - return output params
+                    return {
+                        inputCv: this.keyWords,
+                        blockWords: parentBlock,
+                        blockLen: BLOCK_LEN,
+                        counter: 0,
+                        flags: this.flags | PARENT,
+                    };
+                }
+            }
+        }
+        // Single chunk case
+        return output;
+    }
+    /**
+     * Finalize the hash and return the result.
+     *
+     * @param outputLength - Number of bytes to output (default: 32)
+     * @returns The hash output
+     */
+    finalize(outputLength = OUT_LEN) {
+        const output = this.finalizeOutput();
+        const result = new Uint8Array(outputLength);
+        if (outputLength <= 64) {
+            const outWords = this.outWords;
+            compress(output.inputCv, 0, output.blockWords, 0, outWords, 0, outputLength > 32, // full output if > 32 bytes
+            output.counter, output.blockLen, output.flags | ROOT);
+            if (IS_LITTLE_ENDIAN) {
+                const outBytes = new Uint8Array(outWords.buffer);
+                result.set(outBytes.subarray(0, outputLength));
+            }
+            else {
+                writeLittleEndianBytesPartial(outWords, 0, result, 0, outputLength);
+            }
+        }
+        else {
+            // Multiple blocks - use XOF
+            const xof = this.finalizeXof();
+            const full = xof.read(outputLength);
+            result.set(full);
+        }
+        return result;
+    }
+    /**
+     * Finalize and return an XOF reader for arbitrary-length output.
+     */
+    finalizeXof() {
+        const output = this.finalizeOutput();
+        return new XofReader(new Uint32Array(output.inputCv), new Uint32Array(output.blockWords), output.counter, output.blockLen, output.flags);
+    }
+}

node_modules/@huggingface/blake3-jit/dist/esm/index.d.ts

@@ -0,0 +1,82 @@
+/**
+ * BLAKE3 - The fastest pure JavaScript implementation
+ *
+ * Features:
+ * - All 3 modes: hash, keyed (MAC), derive_key
+ * - XOF (eXtendable Output Function) support
+ * - Automatic WASM SIMD acceleration for large inputs
+ * - Zero dependencies
+ * - Tree-shakeable exports
+ *
+ * @example
+ * ```typescript
+ * import { hash, createKeyed, createDeriveKey } from 'blake3-jit';
+ *
+ * // Simple hashing
+ * const digest = hash(new Uint8Array([1, 2, 3]));
+ *
+ * // Keyed hashing (MAC)
+ * const mac = createKeyed(key).update(data).finalize();
+ *
+ * // Key derivation
+ * const derived = createDeriveKey("my context").update(material).finalize(64);
+ * ```
+ */
+export { Hasher, XofReader } from "./hasher.js";
+export { hash, hashInto, warmupSimd } from "./hash.js";
+import { Hasher } from "./hasher.js";
+/**
+ * Create a new keyed hasher (MAC).
+ *
+ * @param key - 32-byte key
+ * @returns A new Hasher configured for keyed hashing
+ *
+ * @example
+ * ```typescript
+ * const key = new Uint8Array(32); // Your 32-byte key
+ * crypto.getRandomValues(key);
+ *
+ * const mac = createKeyed(key)
+ *   .update(message)
+ *   .finalize();
+ * ```
+ */
+export declare function createKeyed(key: Uint8Array): Hasher;
+/**
+ * Create a new key derivation hasher.
+ *
+ * @param context - Context string for domain separation
+ * @returns A new Hasher configured for key derivation
+ *
+ * @example
+ * ```typescript
+ * const derivedKey = createDeriveKey("my-app encryption key v1")
+ *   .update(inputKeyMaterial)
+ *   .finalize(32);
+ * ```
+ */
+export declare function createDeriveKey(context: string): Hasher;
+/**
+ * Create a new regular hasher for incremental hashing.
+ *
+ * @returns A new Hasher
+ *
+ * @example
+ * ```typescript
+ * const hasher = createHasher();
+ * hasher.update(chunk1);
+ * hasher.update(chunk2);
+ * const digest = hasher.finalize();
+ * ```
+ */
+export declare function createHasher(): Hasher;
+import { hash, hashInto } from "./hash.js";
+declare const _default: {
+    hash: typeof hash;
+    hashInto: typeof hashInto;
+    Hasher: typeof Hasher;
+    createHasher: typeof createHasher;
+    createKeyed: typeof createKeyed;
+    createDeriveKey: typeof createDeriveKey;
+};
+export default _default;

node_modules/@huggingface/blake3-jit/dist/esm/index.js

@@ -0,0 +1,98 @@
+/**
+ * BLAKE3 - The fastest pure JavaScript implementation
+ *
+ * Features:
+ * - All 3 modes: hash, keyed (MAC), derive_key
+ * - XOF (eXtendable Output Function) support
+ * - Automatic WASM SIMD acceleration for large inputs
+ * - Zero dependencies
+ * - Tree-shakeable exports
+ *
+ * @example
+ * ```typescript
+ * import { hash, createKeyed, createDeriveKey } from 'blake3-jit';
+ *
+ * // Simple hashing
+ * const digest = hash(new Uint8Array([1, 2, 3]));
+ *
+ * // Keyed hashing (MAC)
+ * const mac = createKeyed(key).update(data).finalize();
+ *
+ * // Key derivation
+ * const derived = createDeriveKey("my context").update(material).finalize(64);
+ * ```
+ */
+// Core exports
+export { Hasher, XofReader } from "./hasher.js";
+export { hash, hashInto, warmupSimd } from "./hash.js";
+// Convenience imports
+import { Hasher } from "./hasher.js";
+/**
+ * Create a new keyed hasher (MAC).
+ *
+ * @param key - 32-byte key
+ * @returns A new Hasher configured for keyed hashing
+ *
+ * @example
+ * ```typescript
+ * const key = new Uint8Array(32); // Your 32-byte key
+ * crypto.getRandomValues(key);
+ *
+ * const mac = createKeyed(key)
+ *   .update(message)
+ *   .finalize();
+ * ```
+ */
+export function createKeyed(key) {
+    return Hasher.newKeyed(key);
+}
+/**
+ * Create a new key derivation hasher.
+ *
+ * @param context - Context string for domain separation
+ * @returns A new Hasher configured for key derivation
+ *
+ * @example
+ * ```typescript
+ * const derivedKey = createDeriveKey("my-app encryption key v1")
+ *   .update(inputKeyMaterial)
+ *   .finalize(32);
+ * ```
+ */
+export function createDeriveKey(context) {
+    return Hasher.newDeriveKey(context);
+}
+/**
+ * Create a new regular hasher for incremental hashing.
+ *
+ * @returns A new Hasher
+ *
+ * @example
+ * ```typescript
+ * const hasher = createHasher();
+ * hasher.update(chunk1);
+ * hasher.update(chunk2);
+ * const digest = hasher.finalize();
+ * ```
+ */
+export function createHasher() {
+    return new Hasher();
+}
+// Import for default export
+import { hash, hashInto, warmupSimd } from "./hash.js";
+// Pre-warm SIMD in browser environments (non-blocking)
+// This avoids initialization latency on first large hash
+if (typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined") {
+    queueMicrotask(() => {
+        warmupSimd();
+    });
+}
+// Default export for convenience
+export default {
+    hash,
+    hashInto,
+    Hasher,
+    createHasher,
+    createKeyed,
+    createDeriveKey,
+};

node_modules/@huggingface/blake3-jit/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

node_modules/@huggingface/blake3-jit/dist/esm/utils.d.ts

@@ -0,0 +1,90 @@
+/**
+ * BLAKE3 Utility Functions
+ *
+ * Optimized for little-endian systems (most user-facing systems).
+ * BLAKE3 is little-endian friendly - on little-endian systems we can
+ * create Uint32Array views directly over input buffers.
+ */
+/**
+ * Detect system endianness at module load time.
+ * On little-endian systems, the byte 0x01 will be at index 0.
+ */
+export declare const IS_LITTLE_ENDIAN: boolean;
+/**
+ * Read 16 little-endian 32-bit words from a byte array into a Uint32Array.
+ * This is only needed on big-endian systems.
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset in input
+ * @param words - Destination Uint32Array (must have at least 16 elements)
+ */
+export declare function readLittleEndianWordsFull(input: Uint8Array, offset: number, words: Uint32Array): void;
+/**
+ * Read N little-endian 32-bit words from a byte array.
+ * Handles partial reads (for final blocks).
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset
+ * @param words - Destination Uint32Array
+ * @param wordCount - Number of words to read
+ */
+export declare function readLittleEndianWords(input: Uint8Array, offset: number, words: Uint32Array, wordCount: number): void;
+/**
+ * Read a partial block with zero padding.
+ * Used for the final block when input length is not a multiple of 64.
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset
+ * @param length - Number of bytes to read (< 64)
+ * @param words - Destination Uint32Array (must have 16 elements)
+ */
+export declare function readLittleEndianWordsPartial(input: Uint8Array, offset: number, length: number, words: Uint32Array): void;
+/**
+ * Write 8 little-endian 32-bit words to a byte array.
+ *
+ * @param words - Source Uint32Array
+ * @param wordOffset - Starting word offset in source
+ * @param output - Destination byte array
+ * @param byteOffset - Starting byte offset in destination
+ */
+export declare function writeLittleEndianWords(words: Uint32Array, wordOffset: number, output: Uint8Array, byteOffset: number): void;
+/**
+ * Write N bytes from 32-bit words to output.
+ * Used for variable-length output (XOF mode).
+ *
+ * @param words - Source Uint32Array
+ * @param wordOffset - Starting word offset
+ * @param output - Destination byte array
+ * @param byteOffset - Starting byte offset in destination
+ * @param byteCount - Number of bytes to write
+ */
+export declare function writeLittleEndianBytesPartial(words: Uint32Array, wordOffset: number, output: Uint8Array, byteOffset: number, byteCount: number): void;
+/**
+ * Encode a UTF-8 string to Uint8Array.
+ * Used for derive_key context strings.
+ */
+export declare function encodeUTF8(str: string): Uint8Array;
+/**
+ * Count trailing zero bits in a 32-bit number using De Bruijn multiplication.
+ * This is O(1) and branchless for non-zero inputs.
+ *
+ * For Merkle tree merge: ctz32(chunkCounter) tells us how many merges to do.
+ */
+export declare function ctz32(n: number): number;
+/**
+ * Count trailing zero bits in a 64-bit number.
+ * Used to determine how many parent nodes to compute after adding a chunk.
+ *
+ * Note: JavaScript bitwise ops work on 32-bit signed integers,
+ * so we need to handle 64-bit numbers carefully.
+ */
+export declare function countTrailingZeros(n: number): number;
+/**
+ * Create a Uint32Array view of a Uint8Array.
+ * Only works correctly on little-endian systems when the offset is 4-byte aligned.
+ *
+ * @param arr - Source byte array
+ * @param byteOffset - Starting byte offset (must be 4-byte aligned)
+ * @param wordLength - Number of 32-bit words
+ */
+export declare function uint32View(arr: Uint8Array, byteOffset: number, wordLength: number): Uint32Array;

node_modules/@huggingface/blake3-jit/dist/esm/utils.js

@@ -0,0 +1,214 @@
+/**
+ * BLAKE3 Utility Functions
+ *
+ * Optimized for little-endian systems (most user-facing systems).
+ * BLAKE3 is little-endian friendly - on little-endian systems we can
+ * create Uint32Array views directly over input buffers.
+ */
+/**
+ * Detect system endianness at module load time.
+ * On little-endian systems, the byte 0x01 will be at index 0.
+ */
+export const IS_LITTLE_ENDIAN = new Uint8Array(new Uint32Array([0x01020304]).buffer)[0] === 0x04;
+/**
+ * Read 16 little-endian 32-bit words from a byte array into a Uint32Array.
+ * This is only needed on big-endian systems.
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset in input
+ * @param words - Destination Uint32Array (must have at least 16 elements)
+ */
+export function readLittleEndianWordsFull(input, offset, words) {
+    for (let i = 0; i < 16; ++i, offset += 4) {
+        words[i] =
+            input[offset] |
+                (input[offset + 1] << 8) |
+                (input[offset + 2] << 16) |
+                (input[offset + 3] << 24);
+    }
+}
+/**
+ * Read N little-endian 32-bit words from a byte array.
+ * Handles partial reads (for final blocks).
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset
+ * @param words - Destination Uint32Array
+ * @param wordCount - Number of words to read
+ */
+export function readLittleEndianWords(input, offset, words, wordCount) {
+    for (let i = 0; i < wordCount; ++i, offset += 4) {
+        words[i] =
+            input[offset] |
+                (input[offset + 1] << 8) |
+                (input[offset + 2] << 16) |
+                (input[offset + 3] << 24);
+    }
+}
+/**
+ * Read a partial block with zero padding.
+ * Used for the final block when input length is not a multiple of 64.
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset
+ * @param length - Number of bytes to read (< 64)
+ * @param words - Destination Uint32Array (must have 16 elements)
+ */
+export function readLittleEndianWordsPartial(input, offset, length, words) {
+    // Zero out all words first
+    words.fill(0);
+    // Read full words
+    const fullWords = length >>> 2;
+    let i = 0;
+    for (; i < fullWords; ++i, offset += 4) {
+        words[i] =
+            input[offset] |
+                (input[offset + 1] << 8) |
+                (input[offset + 2] << 16) |
+                (input[offset + 3] << 24);
+    }
+    // Handle remaining bytes (0-3)
+    const remaining = length & 3;
+    if (remaining > 0) {
+        let word = input[offset];
+        if (remaining > 1)
+            word |= input[offset + 1] << 8;
+        if (remaining > 2)
+            word |= input[offset + 2] << 16;
+        words[i] = word;
+    }
+}
+/**
+ * Write 8 little-endian 32-bit words to a byte array.
+ *
+ * @param words - Source Uint32Array
+ * @param wordOffset - Starting word offset in source
+ * @param output - Destination byte array
+ * @param byteOffset - Starting byte offset in destination
+ */
+export function writeLittleEndianWords(words, wordOffset, output, byteOffset) {
+    for (let i = 0; i < 8; ++i, byteOffset += 4) {
+        const w = words[wordOffset + i];
+        output[byteOffset] = w & 0xff;
+        output[byteOffset + 1] = (w >>> 8) & 0xff;
+        output[byteOffset + 2] = (w >>> 16) & 0xff;
+        output[byteOffset + 3] = (w >>> 24) & 0xff;
+    }
+}
+/**
+ * Write N bytes from 32-bit words to output.
+ * Used for variable-length output (XOF mode).
+ *
+ * @param words - Source Uint32Array
+ * @param wordOffset - Starting word offset
+ * @param output - Destination byte array
+ * @param byteOffset - Starting byte offset in destination
+ * @param byteCount - Number of bytes to write
+ */
+export function writeLittleEndianBytesPartial(words, wordOffset, output, byteOffset, byteCount) {
+    const fullWords = byteCount >>> 2;
+    let i = 0;
+    // Write full words
+    for (; i < fullWords; ++i, byteOffset += 4) {
+        const w = words[wordOffset + i];
+        output[byteOffset] = w & 0xff;
+        output[byteOffset + 1] = (w >>> 8) & 0xff;
+        output[byteOffset + 2] = (w >>> 16) & 0xff;
+        output[byteOffset + 3] = (w >>> 24) & 0xff;
+    }
+    // Write remaining bytes
+    const remaining = byteCount & 3;
+    if (remaining > 0) {
+        const w = words[wordOffset + i];
+        output[byteOffset] = w & 0xff;
+        if (remaining > 1)
+            output[byteOffset + 1] = (w >>> 8) & 0xff;
+        if (remaining > 2)
+            output[byteOffset + 2] = (w >>> 16) & 0xff;
+    }
+}
+/**
+ * Encode a UTF-8 string to Uint8Array.
+ * Used for derive_key context strings.
+ */
+export function encodeUTF8(str) {
+    if (typeof TextEncoder !== "undefined") {
+        return new TextEncoder().encode(str);
+    }
+    // Fallback for older environments
+    const bytes = [];
+    for (let i = 0; i < str.length; i++) {
+        let c = str.charCodeAt(i);
+        if (c < 0x80) {
+            bytes.push(c);
+        }
+        else if (c < 0x800) {
+            bytes.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
+        }
+        else if (c < 0xd800 || c >= 0xe000) {
+            bytes.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+        }
+        else {
+            // Surrogate pair
+            i++;
+            c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
+            bytes.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 0x3f), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+        }
+    }
+    return new Uint8Array(bytes);
+}
+/**
+ * De Bruijn lookup table for O(1) trailing zero count.
+ * The expression (n & -n) isolates the lowest set bit.
+ * Multiplying by the De Bruijn constant maps each power of 2 to a unique 5-bit index.
+ */
+const CTZ32_TABLE = new Uint8Array([
+    0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 31, 27, 13, 23, 21, 19, 16, 7, 26, 12,
+    18, 6, 11, 5, 10, 9,
+]);
+/**
+ * Count trailing zero bits in a 32-bit number using De Bruijn multiplication.
+ * This is O(1) and branchless for non-zero inputs.
+ *
+ * For Merkle tree merge: ctz32(chunkCounter) tells us how many merges to do.
+ */
+export function ctz32(n) {
+    if (n === 0)
+        return 32;
+    // Use unsigned right shift to handle negative numbers correctly
+    return CTZ32_TABLE[(((n & -n) * 0x077cb531) >>> 27) & 31];
+}
+/**
+ * Count trailing zero bits in a 64-bit number.
+ * Used to determine how many parent nodes to compute after adding a chunk.
+ *
+ * Note: JavaScript bitwise ops work on 32-bit signed integers,
+ * so we need to handle 64-bit numbers carefully.
+ */
+export function countTrailingZeros(n) {
+    if (n === 0)
+        return 64;
+    // For numbers that fit in 32 bits
+    const low = n | 0;
+    if (low !== 0) {
+        // Use Math.clz32 trick: ctz(x) = 31 - clz32(x & -x) for non-zero x
+        return 31 - Math.clz32(low & -low);
+    }
+    // High 32 bits
+    const high = (n / 0x100000000) | 0;
+    if (high !== 0) {
+        return 32 + (31 - Math.clz32(high & -high));
+    }
+    return 64;
+}
+/**
+ * Create a Uint32Array view of a Uint8Array.
+ * Only works correctly on little-endian systems when the offset is 4-byte aligned.
+ *
+ * @param arr - Source byte array
+ * @param byteOffset - Starting byte offset (must be 4-byte aligned)
+ * @param wordLength - Number of 32-bit words
+ */
+export function uint32View(arr, byteOffset, wordLength) {
+    return new Uint32Array(arr.buffer, arr.byteOffset + byteOffset, wordLength);
+}

node_modules/@huggingface/blake3-jit/dist/esm/wasm-simd.d.ts

@@ -0,0 +1,97 @@
+/**
+ * BLAKE3 WASM SIMD - Runtime bytecode generation
+ *
+ * Generates WebAssembly SIMD bytecode at runtime to process 4 compress
+ * operations in parallel using 128-bit SIMD vectors (i32x4).
+ *
+ * Key insight: One i32x4.add instruction performs 4 parallel additions,
+ * giving us 4x throughput for the same number of instructions.
+ *
+ * Memory layout (all values are transposed for SIMD access):
+ *   0-511:    4 x 16 message words (m0_0,m0_1,m0_2,m0_3, m1_0,m1_1,m1_2,m1_3, ...)
+ *   512-639:  4 x 8 chaining values
+ *   640-767:  4 x 8 output values
+ *   768-783:  4 x counter low
+ *   784-799:  4 x counter high
+ *   800-815:  4 x block length
+ *   816-831:  4 x flags
+ */
+/**
+ * Check if WASM SIMD is supported.
+ */
+export declare function isSimdSupported(): boolean;
+export declare function initSimdSync(): boolean;
+/**
+ * Memory offsets for SIMD data layout
+ *
+ * WASM Arena Pattern: All working buffers live in WASM memory (64KB page)
+ * This eliminates JS heap allocations during hashing operations.
+ */
+export declare const SIMD_MEMORY: {
+    readonly BLOCK_WORDS: 0;
+    readonly CHAINING_VALUES: 512;
+    readonly OUTPUT: 640;
+    readonly COUNTER_LOW: 768;
+    readonly COUNTER_HIGH: 784;
+    readonly BLOCK_LEN: 800;
+    readonly FLAGS: 816;
+    readonly BATCH_BLOCK_WORDS: 832;
+    readonly BATCH_CV: 4928;
+    readonly BATCH_COUNTER_LOW: 5056;
+    readonly BATCH_FLAGS_BASE: 5072;
+    readonly BATCH_OUTPUT: 5088;
+    readonly CV_STACK: 5216;
+    readonly PARENT_BLOCK: 7264;
+    readonly CHUNK_CV: 7328;
+    readonly TEMP_CVS: 7360;
+};
+/**
+ * Get the WASM memory views for writing input data.
+ */
+export declare function getSimdMemory(): {
+    view: Uint8Array;
+    view32: Uint32Array;
+} | null;
+/**
+ * Get the arena buffers for Merkle tree operations.
+ * These TypedArray views are backed by WASM memory - zero JS heap allocation.
+ */
+export declare function getArenaBuffers(): {
+    cvStack: Uint32Array;
+    parentBlock: Uint32Array;
+    chunkCv: Uint32Array;
+    tempCvs: Uint32Array;
+} | null;
+/**
+ * Get the batch arena buffers for chunk-level batched operations.
+ * These TypedArray views are backed by WASM memory - zero JS heap allocation.
+ */
+export declare function getBatchArenaBuffers(): {
+    blockWords: Uint32Array;
+    cv: Uint32Array;
+    counterLow: Uint32Array;
+    flagsBase: Uint32Array;
+    output: Uint32Array;
+} | null;
+/**
+ * Run the compress4x function.
+ * Data must already be set up in WASM memory.
+ */
+export declare function runCompress4x(): void;
+/**
+ * Run the compressChunks4x function.
+ * Processes 4 full chunks (16 blocks each) in a single WASM call.
+ * Data must already be set up in batch arena buffers.
+ */
+export declare function runCompressChunks4x(): void;
+/**
+ * Run the compressParent function.
+ * Compresses a parent node: reads 16 words from PARENT_BLOCK, writes 8 words to CHUNK_CV.
+ * Data must already be set up in arena buffers (PARENT_BLOCK at offset 7264).
+ * Output is written to CHUNK_CV at offset 7328.
+ */
+export declare function runCompressParent(): void;
+/**
+ * Check if SIMD is initialized and ready.
+ */
+export declare function isSimdReady(): boolean;

node_modules/@huggingface/blake3-jit/dist/esm/wasm-simd.js

@@ -0,0 +1,936 @@
+/**
+ * BLAKE3 WASM SIMD - Runtime bytecode generation
+ *
+ * Generates WebAssembly SIMD bytecode at runtime to process 4 compress
+ * operations in parallel using 128-bit SIMD vectors (i32x4).
+ *
+ * Key insight: One i32x4.add instruction performs 4 parallel additions,
+ * giving us 4x throughput for the same number of instructions.
+ *
+ * Memory layout (all values are transposed for SIMD access):
+ *   0-511:    4 x 16 message words (m0_0,m0_1,m0_2,m0_3, m1_0,m1_1,m1_2,m1_3, ...)
+ *   512-639:  4 x 8 chaining values
+ *   640-767:  4 x 8 output values
+ *   768-783:  4 x counter low
+ *   784-799:  4 x counter high
+ *   800-815:  4 x block length
+ *   816-831:  4 x flags
+ */
+// LEB128 encoding with minimum 2 bytes
+// This fixes a V8 quirk where single-byte values 64-127 cause issues
+// when followed by certain SIMD instructions
+function toLebU32Min2(n) {
+    // Always use at least 2 bytes
+    return [(n & 0x7f) | 0x80, (n >>> 7) & 0x7f];
+}
+// LEB128 encoding padded to exactly 5 bytes (for backpatching)
+// Uses continuation bits for all but the last byte
+function toLebU32Padded5(n) {
+    return [
+        (n & 0x7f) | 0x80,
+        ((n >>> 7) & 0x7f) | 0x80,
+        ((n >>> 14) & 0x7f) | 0x80,
+        ((n >>> 21) & 0x7f) | 0x80,
+        (n >>> 28) & 0x0f, // Last byte has no continuation bit
+    ];
+}
+// Signed LEB128 encoding for i32 constants (handles full 32-bit range)
+// WASM i32.const uses signed LEB128 immediate
+function toSignedLeb128_i32(n) {
+    const bytes = [];
+    // Treat as signed 32-bit integer
+    let value = n | 0;
+    let more = true;
+    while (more) {
+        let byte = value & 0x7f;
+        // Arithmetic right shift preserves sign
+        value >>= 7;
+        // Check if we're done:
+        // - If value is 0 and sign bit of byte is clear, we're done
+        // - If value is -1 and sign bit of byte is set, we're done
+        if ((value === 0 && (byte & 0x40) === 0) || (value === -1 && (byte & 0x40) !== 0)) {
+            more = false;
+        }
+        else {
+            byte |= 0x80;
+        }
+        bytes.push(byte);
+    }
+    return bytes;
+}
+// Precomputed message access order for all 7 rounds
+const MSG_ACCESS_ORDER = [
+    // Round 1: 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    // Round 2: 2,6,3,10,7,0,4,13,1,11,12,5,9,14,15,8
+    2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8,
+    // Round 3: 3,4,10,12,13,2,7,14,6,5,9,0,11,15,8,1
+    3, 4, 10, 12, 13, 2, 7, 14, 6, 5, 9, 0, 11, 15, 8, 1,
+    // Round 4: 10,7,12,9,14,3,13,15,4,0,11,2,5,8,1,6
+    10, 7, 12, 9, 14, 3, 13, 15, 4, 0, 11, 2, 5, 8, 1, 6,
+    // Round 5: 12,13,9,11,15,10,14,8,7,2,5,3,0,1,6,4
+    12, 13, 9, 11, 15, 10, 14, 8, 7, 2, 5, 3, 0, 1, 6, 4,
+    // Round 6: 9,14,11,5,8,12,15,1,13,3,0,10,2,6,4,7
+    9, 14, 11, 5, 8, 12, 15, 1, 13, 3, 0, 10, 2, 6, 4, 7,
+    // Round 7: 11,15,5,0,1,9,8,6,14,10,2,12,3,4,7,13
+    11, 15, 5, 0, 1, 9, 8, 6, 14, 10, 2, 12, 3, 4, 7, 13,
+];
+// BLAKE3 Constants (used in generated WASM code)
+// CHUNK_START = 1, CHUNK_END = 2 are embedded directly in WASM bytecode
+/**
+ * Generate the WASM module bytecode with compress4x, compressChunks4x, and compressParent functions.
+ */
+function generateWasmBytes() {
+    const code = [];
+    // Helper to append bytes
+    function put(bytes) {
+        code.push(...bytes);
+    }
+    // WASM module header
+    put([0x00, 0x61, 0x73, 0x6d]); // Magic
+    put([0x01, 0x00, 0x00, 0x00]); // Version
+    // Section 1: Types
+    put([0x01]); // Section ID
+    put([0x04]); // Section size
+    put([0x01]); // 1 type
+    put([0x60, 0x00, 0x00]); // func () -> ()
+    // Section 2: Imports (memory from JS)
+    put([0x02]); // Section ID
+    put([0x0b]); // Section size
+    put([0x01]); // 1 import
+    put([0x02, 0x6a, 0x73]); // "js"
+    put([0x03, 0x6d, 0x65, 0x6d]); // "mem"
+    put([0x02, 0x00, 0x01]); // memory min=1, no max
+    // Section 3: Functions
+    put([0x03]); // Section ID
+    put([0x04]); // Section size (3 functions = 4 bytes)
+    put([0x03]); // 3 functions
+    put([0x00]); // Function 0: type index 0
+    put([0x00]); // Function 1: type index 0
+    put([0x00]); // Function 2: type index 0
+    // Section 7: Exports
+    // Size calculation: 1 (count) + (1+10+1+1) + (1+16+1+1) + (1+14+1+1) = 1 + 13 + 19 + 17 = 50 bytes
+    put([0x07]); // Section ID
+    put([0x32]); // Section size (50 bytes)
+    put([0x03]); // 3 exports
+    // "compress4x" -> func 0
+    put([0x0a]); // name length
+    put([0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x34, 0x78]); // "compress4x"
+    put([0x00, 0x00]); // func index 0
+    // "compressChunks4x" -> func 1
+    put([0x10]); // name length (16)
+    put([
+        0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x73, 0x34, 0x78,
+    ]); // "compressChunks4x"
+    put([0x00, 0x01]); // func index 1
+    // "compressParent" -> func 2
+    put([0x0e]); // name length (14)
+    put([0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74]); // "compressParent"
+    put([0x00, 0x02]); // func index 2
+    // Section 10: Code
+    put([0x0a]); // Section ID
+    // Reserve 5 bytes for section size (LEB128 u32)
+    const sectionSizeOffset = code.length;
+    put([0x00, 0x00, 0x00, 0x00, 0x00]);
+    put([0x03]); // 3 functions
+    // === Function 0: compress4x ===
+    // Reserve 5 bytes for function size
+    const funcSizeOffset = code.length;
+    put([0x00, 0x00, 0x00, 0x00, 0x00]);
+    const funcBodyStart = code.length;
+    // Local declarations: 32 v128 locals
+    // Variables $0-$15: message words (m0-m15)
+    // Variables $16-$31: state words (s0-s15)
+    put([0x01]); // 1 local declaration
+    put([0x20, 0x7b]); // 32 x v128
+    // ===== Function body =====
+    // Load message words from memory (offset 0-255)
+    // Each v128 is 16 bytes, so m[i] is at offset i*16
+    // Note: we use toLebU32Min2 to avoid V8 quirk with single-byte values 64-127
+    for (let i = 0; i < 16; i++) {
+        put([0x41, ...toLebU32Min2(i * 16)]); // i32.const offset (2+ byte LEB128)
+        put([0xfd, 0x00, 0x02, 0x00]); // v128.load align=4 offset=0
+        put([0x21, i]); // local.set $i
+    }
+    // Load chaining values (offset 512-639)
+    // cv[i] at offset 512 + i*16
+    for (let i = 0; i < 8; i++) {
+        put([0x41, ...toLebU32Min2(512 + i * 16)]); // i32.const offset
+        put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+        put([0x21, 16 + i]); // local.set $(16+i)
+    }
+    // Initialize state[8-15] from IV and parameters
+    // s8-s11 = IV[0-3]
+    const IV = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
+    for (let i = 0; i < 4; i++) {
+        // Create v128 constant with all lanes set to IV[i]
+        const ivBytes = [];
+        for (let j = 0; j < 4; j++) {
+            ivBytes.push(IV[i] & 0xff);
+            ivBytes.push((IV[i] >>> 8) & 0xff);
+            ivBytes.push((IV[i] >>> 16) & 0xff);
+            ivBytes.push((IV[i] >>> 24) & 0xff);
+        }
+        put([0xfd, 0x0c, ...ivBytes]); // v128.const
+        put([0x21, 24 + i]); // local.set $(24+i) -> s8-s11
+    }
+    // s12 = counter_low (offset 768)
+    put([0x41, ...toLebU32Min2(768)]); // i32.const
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+    put([0x21, 28]); // local.set $28 -> s12
+    // s13 = counter_high (offset 784)
+    put([0x41, ...toLebU32Min2(784)]); // i32.const
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+    put([0x21, 29]); // local.set $29 -> s13
+    // s14 = block_len (offset 800)
+    put([0x41, ...toLebU32Min2(800)]); // i32.const
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+    put([0x21, 30]); // local.set $30 -> s14
+    // s15 = flags (offset 816)
+    put([0x41, ...toLebU32Min2(816)]); // i32.const
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+    put([0x21, 31]); // local.set $31 -> s15
+    // ===== 7 rounds of mixing =====
+    let msgIdx = 0; // Index into MSG_ACCESS_ORDER
+    // Helper to generate G function (inlined)
+    // G(a, b, c, d) with two message words
+    function g(a, b, c, d) {
+        const mx = MSG_ACCESS_ORDER[msgIdx++];
+        const my = MSG_ACCESS_ORDER[msgIdx++];
+        // Variables: a,b,c,d are state indices (16-31), mx,my are message indices (0-15)
+        // First half of G
+        // s[a] = s[a] + s[b] + m[mx]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x20, mx]); // local.get m[mx]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + a]); // local.set s[a]
+        // s[d] = rotr(s[d] ^ s[a], 16) - using i8x16.shuffle (single instruction vs shift+or)
+        // ROTR16 pattern: [2,3,0,1, 6,7,4,5, 10,11,8,9, 14,15,12,13]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + d]); // local.tee s[d]
+        put([0x20, 16 + d]); // local.get s[d] (second operand for shuffle)
+        put([0xfd, 0x0d, 2, 3, 0, 1, 6, 7, 4, 5, 10, 11, 8, 9, 14, 15, 12, 13]); // i8x16.shuffle ROTR16
+        put([0x21, 16 + d]); // local.set s[d]
+        // s[c] = s[c] + s[d]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + c]); // local.set s[c]
+        // s[b] = (s[b] ^ s[c]) >>> 12
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + b]); // local.tee s[b]
+        put([0x41, 0x0c]); // i32.const 12
+        put([0xfd, 0xad, 0x01]); // i32x4.shr_u (opcode 173 = 0xAD)
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x41, 0x14]); // i32.const 20
+        put([0xfd, 0xab, 0x01]); // i32x4.shl
+        put([0xfd, 0x50]); // v128.or
+        put([0x21, 16 + b]); // local.set s[b]
+        // Second half of G
+        // s[a] = s[a] + s[b] + m[my]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x20, my]); // local.get m[my]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + a]); // local.set s[a]
+        // s[d] = rotr(s[d] ^ s[a], 8) - using i8x16.shuffle (single instruction vs shift+or)
+        // ROTR8 pattern: [1,2,3,0, 5,6,7,4, 9,10,11,8, 13,14,15,12]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + d]); // local.tee s[d]
+        put([0x20, 16 + d]); // local.get s[d] (second operand for shuffle)
+        put([0xfd, 0x0d, 1, 2, 3, 0, 5, 6, 7, 4, 9, 10, 11, 8, 13, 14, 15, 12]); // i8x16.shuffle ROTR8
+        put([0x21, 16 + d]); // local.set s[d]
+        // s[c] = s[c] + s[d]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + c]); // local.set s[c]
+        // s[b] = (s[b] ^ s[c]) >>> 7
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + b]); // local.tee s[b]
+        put([0x41, 0x07]); // i32.const 7
+        put([0xfd, 0xad, 0x01]); // i32x4.shr_u (opcode 173 = 0xAD)
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x41, 0x19]); // i32.const 25
+        put([0xfd, 0xab, 0x01]); // i32x4.shl
+        put([0xfd, 0x50]); // v128.or
+        put([0x21, 16 + b]); // local.set s[b]
+    }
+    // Generate all 7 rounds
+    for (let round = 0; round < 7; round++) {
+        // Column mixing
+        g(0, 4, 8, 12);
+        g(1, 5, 9, 13);
+        g(2, 6, 10, 14);
+        g(3, 7, 11, 15);
+        // Diagonal mixing
+        g(0, 5, 10, 15);
+        g(1, 6, 11, 12);
+        g(2, 7, 8, 13);
+        g(3, 4, 9, 14);
+    }
+    // ===== Final XOR and store output =====
+    // out[i] = s[i] ^ s[i+8] for i in 0..7
+    // Store at offset 640-767
+    for (let i = 0; i < 8; i++) {
+        put([0x41, ...toLebU32Min2(640 + i * 16)]); // i32.const offset
+        put([0x20, 16 + i]); // local.get s[i]
+        put([0x20, 24 + i]); // local.get s[i+8]
+        put([0xfd, 0x51]); // v128.xor
+        put([0xfd, 0x0b, 0x02, 0x00]); // v128.store align=4
+    }
+    // End of function
+    put([0x0b]); // end
+    // Fill in function 0 size using padded LEB128
+    const funcBodySize = code.length - funcBodyStart;
+    const funcSizeBytes = toLebU32Padded5(funcBodySize);
+    for (let i = 0; i < 5; i++) {
+        code[funcSizeOffset + i] = funcSizeBytes[i];
+    }
+    // === Function 1: compressChunks4x ===
+    // Reserve 5 bytes for function size
+    const func1SizeOffset = code.length;
+    put([0x00, 0x00, 0x00, 0x00, 0x00]);
+    const func1BodyStart = code.length;
+    // Generate the compressChunks4x function body
+    const compressChunksBody = generateCompressChunks4xBody();
+    put(compressChunksBody);
+    // Fill in function 1 size using padded LEB128
+    const func1BodySize = code.length - func1BodyStart;
+    const func1SizeBytes = toLebU32Padded5(func1BodySize);
+    for (let i = 0; i < 5; i++) {
+        code[func1SizeOffset + i] = func1SizeBytes[i];
+    }
+    // === Function 2: compressParent ===
+    // Reserve 5 bytes for function size
+    const func2SizeOffset = code.length;
+    put([0x00, 0x00, 0x00, 0x00, 0x00]);
+    const func2BodyStart = code.length;
+    // Generate the compressParent function body
+    const compressParentBody = generateCompressParentBody();
+    put(compressParentBody);
+    // Fill in function 2 size using padded LEB128
+    const func2BodySize = code.length - func2BodyStart;
+    const func2SizeBytes = toLebU32Padded5(func2BodySize);
+    for (let i = 0; i < 5; i++) {
+        code[func2SizeOffset + i] = func2SizeBytes[i];
+    }
+    // Fill in section size using padded LEB128
+    const sectionSize = code.length - sectionSizeOffset - 5;
+    const sectionSizeBytes = toLebU32Padded5(sectionSize);
+    for (let i = 0; i < 5; i++) {
+        code[sectionSizeOffset + i] = sectionSizeBytes[i];
+    }
+    return new Uint8Array(code);
+}
+/**
+ * Generate compressChunks4x WASM function body.
+ * Processes all 16 blocks of 4 chunks in a single call.
+ */
+function generateCompressChunks4xBody() {
+    const code = [];
+    function put(bytes) {
+        code.push(...bytes);
+    }
+    // Local declarations: 32 v128 locals + 1 i32 for position
+    // Locals $0-$15: message words (reloaded each iteration)
+    // Locals $16-$31: state words (s0-s15)
+    // Local $32: position counter (i32)
+    put([0x02]); // 2 local declarations
+    put([0x20, 0x7b]); // 32 x v128
+    put([0x01, 0x7f]); // 1 x i32
+    const BATCH_BLOCK_WORDS = SIMD_MEMORY.BATCH_BLOCK_WORDS;
+    const BATCH_CV = SIMD_MEMORY.BATCH_CV;
+    const BATCH_COUNTER_LOW = SIMD_MEMORY.BATCH_COUNTER_LOW;
+    const BATCH_FLAGS_BASE = SIMD_MEMORY.BATCH_FLAGS_BASE;
+    const BATCH_OUTPUT = SIMD_MEMORY.BATCH_OUTPUT;
+    // IV constants (same as compress4x)
+    const IV = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
+    // Load initial CVs from BATCH_CV into locals $16-$23
+    for (let i = 0; i < 8; i++) {
+        put([0x41, ...toLebU32Min2(BATCH_CV + i * 16)]); // i32.const offset
+        put([0xfd, 0x00, 0x02, 0x00]); // v128.load align=4 offset=0
+        put([0x21, 16 + i]); // local.set $(16+i) -> s0-s7
+    }
+    // Initialize $32 (pos) = 0
+    put([0x41, 0x00]); // i32.const 0
+    put([0x21, 0x20]); // local.set $32
+    // block $done
+    put([0x02, 0x40]); // block void
+    // loop $continue
+    put([0x03, 0x40]); // loop void
+    // === Load message words for position $pos ===
+    // offset = BATCH_BLOCK_WORDS + pos * 256 + word * 16
+    for (let w = 0; w < 16; w++) {
+        put([0x20, 0x20]); // local.get $32 (pos)
+        put([0x41, ...toLebU32Min2(256)]); // i32.const 256
+        put([0x6c]); // i32.mul
+        put([0x41, ...toLebU32Min2(BATCH_BLOCK_WORDS + w * 16)]); // i32.const base + word*16
+        put([0x6a]); // i32.add
+        put([0xfd, 0x00, 0x02, 0x00]); // v128.load align=4 offset=0
+        put([0x21, w]); // local.set $w
+    }
+    // === Initialize state[8-15] ===
+    // s8-s11 = IV[0-3]
+    for (let i = 0; i < 4; i++) {
+        const ivBytes = [];
+        for (let j = 0; j < 4; j++) {
+            ivBytes.push(IV[i] & 0xff);
+            ivBytes.push((IV[i] >>> 8) & 0xff);
+            ivBytes.push((IV[i] >>> 16) & 0xff);
+            ivBytes.push((IV[i] >>> 24) & 0xff);
+        }
+        put([0xfd, 0x0c, ...ivBytes]); // v128.const
+        put([0x21, 24 + i]); // local.set $(24+i) -> s8-s11
+    }
+    // s12 = counter_low (from BATCH_COUNTER_LOW)
+    put([0x41, ...toLebU32Min2(BATCH_COUNTER_LOW)]); // i32.const
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+    put([0x21, 28]); // local.set $28 -> s12
+    // s13 = 0 (counter high - assume fits in 32 bits)
+    put([0xfd, 0x0c, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); // v128.const 0
+    put([0x21, 29]); // local.set $29 -> s13
+    // s14 = 64 (block_len = 64 for full blocks)
+    const blockLen64 = [];
+    for (let j = 0; j < 4; j++) {
+        blockLen64.push(64, 0, 0, 0); // 64 in little-endian
+    }
+    put([0xfd, 0x0c, ...blockLen64]); // v128.const [64,64,64,64]
+    put([0x21, 30]); // local.set $30 -> s14
+    // s15 = flags = base_flags | (pos == 0 ? 1 : 0) | (pos == 15 ? 2 : 0)
+    // First load base flags
+    put([0x41, ...toLebU32Min2(BATCH_FLAGS_BASE)]); // i32.const
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load base flags
+    // Compute position-dependent bits
+    // CHUNK_START (1) if pos == 0
+    put([0x20, 0x20]); // local.get $32 (pos)
+    put([0x45]); // i32.eqz -> 1 if pos==0, 0 otherwise
+    // CHUNK_END (2) if pos == 15
+    put([0x20, 0x20]); // local.get $32 (pos)
+    put([0x41, 0x0f]); // i32.const 15
+    put([0x46]); // i32.eq -> 1 if pos==15, 0 otherwise
+    put([0x41, 0x01]); // i32.const 1 (shift amount)
+    put([0x74]); // i32.shl -> 2 if pos==15, 0 otherwise
+    // OR the two bits together
+    put([0x72]); // i32.or -> combined position bits
+    // Splat to v128 and OR with base flags (stack: base_flags, bits)
+    put([0xfd, 0x11]); // i32x4.splat
+    put([0xfd, 0x50]); // v128.or
+    put([0x21, 31]); // local.set $31 -> s15
+    // === 7 rounds of mixing ===
+    let msgIdx = 0;
+    function g(a, b, c, d) {
+        const mx = MSG_ACCESS_ORDER[msgIdx++];
+        const my = MSG_ACCESS_ORDER[msgIdx++];
+        // First half of G: s[a] = s[a] + s[b] + m[mx]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x20, mx]); // local.get m[mx]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + a]); // local.set s[a]
+        // s[d] = rotr(s[d] ^ s[a], 16) - byte shuffle
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + d]); // local.tee s[d]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0xfd, 0x0d, 2, 3, 0, 1, 6, 7, 4, 5, 10, 11, 8, 9, 14, 15, 12, 13]); // i8x16.shuffle ROTR16
+        put([0x21, 16 + d]); // local.set s[d]
+        // s[c] = s[c] + s[d]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + c]); // local.set s[c]
+        // s[b] = rotr(s[b] ^ s[c], 12)
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + b]); // local.tee s[b]
+        put([0x41, 0x0c]); // i32.const 12
+        put([0xfd, 0xad, 0x01]); // i32x4.shr_u (opcode 173 = 0xAD)
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x41, 0x14]); // i32.const 20
+        put([0xfd, 0xab, 0x01]); // i32x4.shl
+        put([0xfd, 0x50]); // v128.or
+        put([0x21, 16 + b]); // local.set s[b]
+        // Second half: s[a] = s[a] + s[b] + m[my]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x20, my]); // local.get m[my]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + a]); // local.set s[a]
+        // s[d] = rotr(s[d] ^ s[a], 8) - byte shuffle
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0x20, 16 + a]); // local.get s[a]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + d]); // local.tee s[d]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0xfd, 0x0d, 1, 2, 3, 0, 5, 6, 7, 4, 9, 10, 11, 8, 13, 14, 15, 12]); // i8x16.shuffle ROTR8
+        put([0x21, 16 + d]); // local.set s[d]
+        // s[c] = s[c] + s[d]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0x20, 16 + d]); // local.get s[d]
+        put([0xfd, 0xae, 0x01]); // i32x4.add
+        put([0x21, 16 + c]); // local.set s[c]
+        // s[b] = rotr(s[b] ^ s[c], 7)
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x20, 16 + c]); // local.get s[c]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x22, 16 + b]); // local.tee s[b]
+        put([0x41, 0x07]); // i32.const 7
+        put([0xfd, 0xad, 0x01]); // i32x4.shr_u (opcode 173 = 0xAD)
+        put([0x20, 16 + b]); // local.get s[b]
+        put([0x41, 0x19]); // i32.const 25
+        put([0xfd, 0xab, 0x01]); // i32x4.shl
+        put([0xfd, 0x50]); // v128.or
+        put([0x21, 16 + b]); // local.set s[b]
+    }
+    // Generate all 7 rounds
+    for (let round = 0; round < 7; round++) {
+        // Column mixing
+        g(0, 4, 8, 12);
+        g(1, 5, 9, 13);
+        g(2, 6, 10, 14);
+        g(3, 7, 11, 15);
+        // Diagonal mixing
+        g(0, 5, 10, 15);
+        g(1, 6, 11, 12);
+        g(2, 7, 8, 13);
+        g(3, 4, 9, 14);
+    }
+    // === Update CVs: cv[i] = s[i] ^ s[i+8] ===
+    // Store back to state locals $16-$23 (the CV positions)
+    for (let i = 0; i < 8; i++) {
+        put([0x20, 16 + i]); // local.get s[i]
+        put([0x20, 24 + i]); // local.get s[i+8]
+        put([0xfd, 0x51]); // v128.xor
+        put([0x21, 16 + i]); // local.set $(16+i) - update CV
+    }
+    // === Loop control: pos++, continue if pos < 16 ===
+    put([0x20, 0x20]); // local.get $32 (pos)
+    put([0x41, 0x01]); // i32.const 1
+    put([0x6a]); // i32.add
+    put([0x22, 0x20]); // local.tee $32 (pos)
+    put([0x41, 0x10]); // i32.const 16
+    put([0x49]); // i32.lt_u
+    put([0x0d, 0x00]); // br_if 0 (continue loop)
+    // end loop
+    put([0x0b]); // end
+    // end block
+    put([0x0b]); // end
+    // === Store final CVs to BATCH_OUTPUT ===
+    for (let i = 0; i < 8; i++) {
+        put([0x41, ...toLebU32Min2(BATCH_OUTPUT + i * 16)]); // i32.const offset
+        put([0x20, 16 + i]); // local.get $(16+i) - CV word
+        put([0xfd, 0x0b, 0x02, 0x00]); // v128.store align=4
+    }
+    // end function
+    put([0x0b]); // end
+    return code;
+}
+/**
+ * Generate compressParent WASM function body.
+ * Performs a single parent node compression using scalar i32 operations.
+ * Reads 16 words from PARENT_BLOCK, writes 8 words to CHUNK_CV.
+ * Uses IV, counter=0, blockLen=64, flags=PARENT(4).
+ */
+function generateCompressParentBody() {
+    const code = [];
+    function put(bytes) {
+        code.push(...bytes);
+    }
+    // Local declarations: 32 i32 locals for state (s0-s15) and message (m0-m15)
+    put([0x01]); // 1 local declaration
+    put([0x20, 0x7f]); // 32 x i32
+    // Message word indices: 0-15, State indices: 16-31
+    // Locals $0-$15: message words (m0-m15)
+    // Locals $16-$31: state words (s0-s15)
+    const PARENT_BLOCK_OFFSET = SIMD_MEMORY.PARENT_BLOCK;
+    const CHUNK_CV_OFFSET = SIMD_MEMORY.CHUNK_CV;
+    // BLAKE3 IV
+    const IV = [
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ];
+    // Load message words from PARENT_BLOCK (16 words at offset 7264)
+    for (let i = 0; i < 16; i++) {
+        put([0x41, ...toLebU32Min2(PARENT_BLOCK_OFFSET + i * 4)]); // i32.const offset
+        put([0x28, 0x02, 0x00]); // i32.load align=4 offset=0
+        put([0x21, i]); // local.set $i (m0-m15)
+    }
+    // Initialize state s0-s7 = IV[0-7]
+    for (let i = 0; i < 8; i++) {
+        put([0x41, ...toSignedLeb128_i32(IV[i])]); // i32.const IV[i]
+        put([0x21, 16 + i]); // local.set $(16+i) -> s0-s7
+    }
+    // Initialize state s8-s11 = IV[0-3]
+    for (let i = 0; i < 4; i++) {
+        put([0x41, ...toSignedLeb128_i32(IV[i])]); // i32.const IV[i]
+        put([0x21, 24 + i]); // local.set $(24+i) -> s8-s11
+    }
+    // s12 = counter_low = 0
+    put([0x41, 0x00]); // i32.const 0
+    put([0x21, 28]); // local.set $28 -> s12
+    // s13 = counter_high = 0
+    put([0x41, 0x00]); // i32.const 0
+    put([0x21, 29]); // local.set $29 -> s13
+    // s14 = block_len = 64
+    // Note: 0x40 alone is -64 in signed LEB128 (bit 6 is sign bit)
+    // For 64, we need [0xC0, 0x00] to avoid sign extension
+    put([0x41, 0xc0, 0x00]); // i32.const 64
+    put([0x21, 30]); // local.set $30 -> s14
+    // s15 = flags = PARENT = 4
+    put([0x41, 0x04]); // i32.const 4
+    put([0x21, 31]); // local.set $31 -> s15
+    // Helper to generate scalar G function (inlined)
+    // G(a, b, c, d, mx, my) where a,b,c,d are state indices 0-15, mx,my are message indices 0-15
+    function g(a, b, c, d, mx, my) {
+        const sa = 16 + a, sb = 16 + b, sc = 16 + c, sd = 16 + d;
+        // s[a] = (s[a] + s[b] + m[mx]) >>> 0
+        put([0x20, sa]); // local.get s[a]
+        put([0x20, sb]); // local.get s[b]
+        put([0x6a]); // i32.add
+        put([0x20, mx]); // local.get m[mx]
+        put([0x6a]); // i32.add
+        put([0x21, sa]); // local.set s[a]
+        // s[d] = rotr(s[d] ^ s[a], 16)
+        put([0x20, sd]); // local.get s[d]
+        put([0x20, sa]); // local.get s[a]
+        put([0x73]); // i32.xor
+        put([0x41, 0x10]); // i32.const 16
+        put([0x78]); // i32.rotr
+        put([0x21, sd]); // local.set s[d]
+        // s[c] = (s[c] + s[d]) >>> 0
+        put([0x20, sc]); // local.get s[c]
+        put([0x20, sd]); // local.get s[d]
+        put([0x6a]); // i32.add
+        put([0x21, sc]); // local.set s[c]
+        // s[b] = rotr(s[b] ^ s[c], 12)
+        put([0x20, sb]); // local.get s[b]
+        put([0x20, sc]); // local.get s[c]
+        put([0x73]); // i32.xor
+        put([0x41, 0x0c]); // i32.const 12
+        put([0x78]); // i32.rotr
+        put([0x21, sb]); // local.set s[b]
+        // s[a] = (s[a] + s[b] + m[my]) >>> 0
+        put([0x20, sa]); // local.get s[a]
+        put([0x20, sb]); // local.get s[b]
+        put([0x6a]); // i32.add
+        put([0x20, my]); // local.get m[my]
+        put([0x6a]); // i32.add
+        put([0x21, sa]); // local.set s[a]
+        // s[d] = rotr(s[d] ^ s[a], 8)
+        put([0x20, sd]); // local.get s[d]
+        put([0x20, sa]); // local.get s[a]
+        put([0x73]); // i32.xor
+        put([0x41, 0x08]); // i32.const 8
+        put([0x78]); // i32.rotr
+        put([0x21, sd]); // local.set s[d]
+        // s[c] = (s[c] + s[d]) >>> 0
+        put([0x20, sc]); // local.get s[c]
+        put([0x20, sd]); // local.get s[d]
+        put([0x6a]); // i32.add
+        put([0x21, sc]); // local.set s[c]
+        // s[b] = rotr(s[b] ^ s[c], 7)
+        put([0x20, sb]); // local.get s[b]
+        put([0x20, sc]); // local.get s[c]
+        put([0x73]); // i32.xor
+        put([0x41, 0x07]); // i32.const 7
+        put([0x78]); // i32.rotr
+        put([0x21, sb]); // local.set s[b]
+    }
+    // 7 rounds of mixing with permuted message schedule
+    let msgIdx = 0;
+    for (let round = 0; round < 7; round++) {
+        // Column mixing
+        g(0, 4, 8, 12, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+        g(1, 5, 9, 13, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+        g(2, 6, 10, 14, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+        g(3, 7, 11, 15, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+        // Diagonal mixing
+        g(0, 5, 10, 15, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+        g(1, 6, 11, 12, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+        g(2, 7, 8, 13, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+        g(3, 4, 9, 14, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+        msgIdx += 2;
+    }
+    // Store output: out[i] = s[i] ^ s[i+8] for i in 0..7
+    for (let i = 0; i < 8; i++) {
+        put([0x41, ...toLebU32Min2(CHUNK_CV_OFFSET + i * 4)]); // i32.const offset
+        put([0x20, 16 + i]); // local.get s[i]
+        put([0x20, 24 + i]); // local.get s[i+8]
+        put([0x73]); // i32.xor
+        put([0x36, 0x02, 0x00]); // i32.store align=4 offset=0
+    }
+    // end function
+    put([0x0b]); // end
+    return code;
+}
+// Cached WASM instance
+let wasmInstance = null;
+let wasmMemory = null;
+let wasmCompress4x = null;
+let wasmCompressChunks4x = null;
+let wasmCompressParent = null;
+let wasmMemoryView = null;
+let wasmMemoryView32 = null;
+/**
+ * Check if WASM SIMD is supported.
+ */
+export function isSimdSupported() {
+    try {
+        // Minimal WASM module with v128.const instruction to test SIMD support
+        const simdTest = new Uint8Array([
+            0x00,
+            0x61,
+            0x73,
+            0x6d, // magic: \0asm
+            0x01,
+            0x00,
+            0x00,
+            0x00, // version: 1
+            // Type section (id=1): () -> v128
+            0x01, // section id = 1 (type)
+            0x05, // section length = 5
+            0x01, // 1 type
+            0x60,
+            0x00,
+            0x01,
+            0x7b, // func () -> v128
+            // Function section (id=3)
+            0x03, // section id = 3 (function)
+            0x02, // section length = 2
+            0x01, // 1 function
+            0x00, // type index 0
+            // Code section (id=10) with v128.const
+            0x0a, // section id = 10 (code)
+            0x16, // section length = 22
+            0x01, // 1 function body
+            0x14, // body length = 20
+            0x00, // 0 locals
+            0xfd,
+            0x0c, // v128.const opcode
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x0b, // end
+        ]);
+        return WebAssembly.validate(simdTest);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Set up arena views over WASM memory.
+ * Called after WASM memory is allocated.
+ */
+function setupArenaViews() {
+    if (!wasmMemory)
+        return;
+    const buffer = wasmMemory.buffer;
+    // Create TypedArray views over WASM memory for arena buffers
+    // These views are backed by WASM memory, eliminating JS heap allocation
+    arenaCvStack = new Uint32Array(buffer, SIMD_MEMORY.CV_STACK, 64 * 8); // 64 levels × 8 words
+    arenaParentBlock = new Uint32Array(buffer, SIMD_MEMORY.PARENT_BLOCK, 16); // 16 words
+    arenaChunkCv = new Uint32Array(buffer, SIMD_MEMORY.CHUNK_CV, 8); // 8 words
+    arenaTempCvs = new Uint32Array(buffer, SIMD_MEMORY.TEMP_CVS, 32); // 4 × 8 words
+    // Batch mode views
+    // 16 positions × 16 v128 words = 16 × 64 u32 words = 1024 words per position? No...
+    // In u32 terms: 16 positions × 16 words × 4 lanes = 1024 u32 values total
+    arenaBatchBlockWords = new Uint32Array(buffer, SIMD_MEMORY.BATCH_BLOCK_WORDS, 16 * 16 * 4); // 16 pos × 16 words × 4 lanes
+    arenaBatchCv = new Uint32Array(buffer, SIMD_MEMORY.BATCH_CV, 32); // 4 × 8 words
+    arenaBatchCounterLow = new Uint32Array(buffer, SIMD_MEMORY.BATCH_COUNTER_LOW, 4); // 4 words
+    arenaBatchFlagsBase = new Uint32Array(buffer, SIMD_MEMORY.BATCH_FLAGS_BASE, 4); // 4 words
+    arenaBatchOutput = new Uint32Array(buffer, SIMD_MEMORY.BATCH_OUTPUT, 32); // 4 × 8 words
+}
+/**
+ * Initialize the WASM SIMD module synchronously.
+ * Call this once before using compress4x.
+ */
+// Cache generated WASM bytes to avoid regenerating on each init
+let cachedWasmBytes = null;
+export function initSimdSync() {
+    if (wasmInstance)
+        return true;
+    if (!isSimdSupported()) {
+        return false;
+    }
+    try {
+        const wasmBytes = cachedWasmBytes || generateWasmBytes();
+        cachedWasmBytes = wasmBytes;
+        wasmMemory = new WebAssembly.Memory({ initial: 1 });
+        const importObject = {
+            js: { mem: wasmMemory },
+        };
+        const module = new WebAssembly.Module(wasmBytes.buffer);
+        wasmInstance = new WebAssembly.Instance(module, importObject);
+        wasmCompress4x = wasmInstance.exports.compress4x;
+        wasmCompressChunks4x = wasmInstance.exports.compressChunks4x;
+        wasmCompressParent = wasmInstance.exports.compressParent;
+        wasmMemoryView = new Uint8Array(wasmMemory.buffer);
+        wasmMemoryView32 = new Uint32Array(wasmMemory.buffer);
+        // Set up arena views for Merkle tree operations
+        setupArenaViews();
+        return true;
+    }
+    catch (e) {
+        console.warn("Failed to initialize WASM SIMD:", e);
+        return false;
+    }
+}
+/**
+ * Memory offsets for SIMD data layout
+ *
+ * WASM Arena Pattern: All working buffers live in WASM memory (64KB page)
+ * This eliminates JS heap allocations during hashing operations.
+ */
+export const SIMD_MEMORY = {
+    // SIMD compress4x working area (used by WASM code) - single block
+    BLOCK_WORDS: 0, // 4 x 16 words = 512 bytes (transposed layout)
+    CHAINING_VALUES: 512, // 4 x 8 words = 128 bytes
+    OUTPUT: 640, // 4 x 8 words = 128 bytes
+    COUNTER_LOW: 768, // 4 words = 16 bytes
+    COUNTER_HIGH: 784, // 4 words = 16 bytes
+    BLOCK_LEN: 800, // 4 words = 16 bytes
+    FLAGS: 816, // 4 words = 16 bytes
+    // End of single-block SIMD working area: 832 bytes
+    // SIMD compressChunks4x working area - 16 blocks batched
+    // Each block position has 16 v128 values (one per message word) = 256 bytes
+    // 16 block positions = 16 × 256 = 4096 bytes
+    BATCH_BLOCK_WORDS: 832, // 16 positions × 256 bytes = 4096 bytes (transposed), ends at 4928
+    BATCH_CV: 4928, // 4 × 8 words × 4 bytes = 128 bytes (working CVs), ends at 5056
+    BATCH_COUNTER_LOW: 5056, // 4 words × 4 bytes = 16 bytes (per-chunk counters), ends at 5072
+    BATCH_FLAGS_BASE: 5072, // 4 words × 4 bytes = 16 bytes (base flags, no START/END), ends at 5088
+    BATCH_OUTPUT: 5088, // 4 × 8 words × 4 bytes = 128 bytes (final output), ends at 5216
+    // End of batch working area: 5216 bytes
+    // WASM Arena: JS working buffers (accessed via TypedArray views)
+    CV_STACK: 5216, // 64 levels × 8 words × 4 bytes = 2048 bytes, ends at 7264
+    PARENT_BLOCK: 7264, // 16 words × 4 bytes = 64 bytes, ends at 7328
+    CHUNK_CV: 7328, // 8 words × 4 bytes = 32 bytes, ends at 7360
+    TEMP_CVS: 7360, // 4 × 8 words × 4 bytes = 128 bytes, ends at 7488
+    // Total arena usage: ~7488 bytes (fits comfortably in 64KB page)
+};
+// Arena views - created once when SIMD initializes
+let arenaCvStack = null;
+let arenaParentBlock = null;
+let arenaChunkCv = null;
+let arenaTempCvs = null;
+// Batch mode arena views
+let arenaBatchBlockWords = null;
+let arenaBatchCv = null;
+let arenaBatchCounterLow = null;
+let arenaBatchFlagsBase = null;
+let arenaBatchOutput = null;
+/**
+ * Get the WASM memory views for writing input data.
+ */
+export function getSimdMemory() {
+    if (!wasmMemoryView || !wasmMemoryView32)
+        return null;
+    return { view: wasmMemoryView, view32: wasmMemoryView32 };
+}
+/**
+ * Get the arena buffers for Merkle tree operations.
+ * These TypedArray views are backed by WASM memory - zero JS heap allocation.
+ */
+export function getArenaBuffers() {
+    if (!arenaCvStack || !arenaParentBlock || !arenaChunkCv || !arenaTempCvs)
+        return null;
+    return {
+        cvStack: arenaCvStack,
+        parentBlock: arenaParentBlock,
+        chunkCv: arenaChunkCv,
+        tempCvs: arenaTempCvs,
+    };
+}
+/**
+ * Get the batch arena buffers for chunk-level batched operations.
+ * These TypedArray views are backed by WASM memory - zero JS heap allocation.
+ */
+export function getBatchArenaBuffers() {
+    if (!arenaBatchBlockWords ||
+        !arenaBatchCv ||
+        !arenaBatchCounterLow ||
+        !arenaBatchFlagsBase ||
+        !arenaBatchOutput)
+        return null;
+    return {
+        blockWords: arenaBatchBlockWords,
+        cv: arenaBatchCv,
+        counterLow: arenaBatchCounterLow,
+        flagsBase: arenaBatchFlagsBase,
+        output: arenaBatchOutput,
+    };
+}
+/**
+ * Run the compress4x function.
+ * Data must already be set up in WASM memory.
+ */
+export function runCompress4x() {
+    if (!wasmCompress4x) {
+        throw new Error("WASM SIMD not initialized. Call initSimdSync() first.");
+    }
+    wasmCompress4x();
+}
+/**
+ * Run the compressChunks4x function.
+ * Processes 4 full chunks (16 blocks each) in a single WASM call.
+ * Data must already be set up in batch arena buffers.
+ */
+export function runCompressChunks4x() {
+    if (!wasmCompressChunks4x) {
+        throw new Error("WASM SIMD not initialized. Call initSimdSync() first.");
+    }
+    wasmCompressChunks4x();
+}
+/**
+ * Run the compressParent function.
+ * Compresses a parent node: reads 16 words from PARENT_BLOCK, writes 8 words to CHUNK_CV.
+ * Data must already be set up in arena buffers (PARENT_BLOCK at offset 7264).
+ * Output is written to CHUNK_CV at offset 7328.
+ */
+export function runCompressParent() {
+    if (!wasmCompressParent) {
+        throw new Error("WASM SIMD not initialized. Call initSimdSync() first.");
+    }
+    wasmCompressParent();
+}
+/**
+ * Check if SIMD is initialized and ready.
+ */
+export function isSimdReady() {
+    return wasmCompress4x !== null;
+}

node_modules/@huggingface/blake3-jit/package.json

@@ -0,0 +1,49 @@
+{
+	"name": "@huggingface/blake3-jit",
+	"version": "0.0.2",
+	"description": "Temporary fork of blake3-jit with Hasher.reset() and pre-allocated buffers. Will be deprecated once upstream blake3-jit exposes reset().",
+	"keywords": [
+		"blake3",
+		"hash",
+		"fast",
+		"wasm"
+	],
+	"license": "MIT",
+	"author": "Hugging Face",
+	"publishConfig": {
+		"access": "public"
+	},
+	"files": [
+		"dist",
+		"src",
+		"LICENSE",
+		"README.md"
+	],
+	"type": "module",
+	"sideEffects": false,
+	"scripts": {
+		"prepare": "tshy"
+	},
+	"tshy": {
+		"exports": {
+			".": "./src/index.ts",
+			"./package.json": "./package.json"
+		}
+	},
+	"exports": {
+		".": {
+			"import": {
+				"types": "./dist/esm/index.d.ts",
+				"default": "./dist/esm/index.js"
+			},
+			"require": {
+				"types": "./dist/commonjs/index.d.ts",
+				"default": "./dist/commonjs/index.js"
+			}
+		},
+		"./package.json": "./package.json"
+	},
+	"main": "./dist/commonjs/index.js",
+	"types": "./dist/commonjs/index.d.ts",
+	"module": "./dist/esm/index.js"
+}

node_modules/@huggingface/blake3-jit/src/compress.ts

@@ -0,0 +1,954 @@
+/**
+ * BLAKE3 Compression Function - Highly Optimized
+ *
+ * Optimization techniques applied (from Fleek Network case study):
+ * 1. Use 16 SMI variables for state instead of TypedArray
+ * 2. Use 16 SMI variables for message words
+ * 3. Fully inlined G function (no function call overhead)
+ * 4. Use `| 0` for integer coercion (forces V8 to use 32-bit ALU)
+ * 5. Hardcoded permutation swaps using only 2 temporary variables
+ * 6. Offset-based access pattern (avoid creating new views)
+ *
+ * The compression function takes:
+ * - cv: 8-word chaining value
+ * - block: 16-word message block (64 bytes)
+ * - counter: 64-bit block counter
+ * - blockLen: number of input bytes in this block
+ * - flags: domain separation flags
+ *
+ * And outputs 8 or 16 words depending on whether this is a root node.
+ */
+
+/**
+ * Compress a single block.
+ *
+ * This is the hot path - every optimization matters here.
+ *
+ * @param cv - Chaining value array
+ * @param cvOff - Offset into cv
+ * @param block - Message block words
+ * @param blockOff - Offset into block
+ * @param out - Output array (8 or 16 words)
+ * @param outOff - Offset into out
+ * @param full - If true, output all 16 words (for XOF); if false, output 8 words
+ * @param counter - 64-bit block counter
+ * @param blockLen - Number of bytes in this block (0-64)
+ * @param flags - Domain separation flags
+ */
+export function compress(
+  cv: Uint32Array,
+  cvOff: number,
+  block: Uint32Array,
+  blockOff: number,
+  out: Uint32Array,
+  outOff: number,
+  full: boolean,
+  counter: number,
+  blockLen: number,
+  flags: number,
+): void {
+  // Load message words into SMI variables for maximum performance
+  // V8 optimizes SMI arithmetic directly with the ALU
+  let m0 = block[blockOff] | 0;
+  let m1 = block[blockOff + 1] | 0;
+  let m2 = block[blockOff + 2] | 0;
+  let m3 = block[blockOff + 3] | 0;
+  let m4 = block[blockOff + 4] | 0;
+  let m5 = block[blockOff + 5] | 0;
+  let m6 = block[blockOff + 6] | 0;
+  let m7 = block[blockOff + 7] | 0;
+  let m8 = block[blockOff + 8] | 0;
+  let m9 = block[blockOff + 9] | 0;
+  let m10 = block[blockOff + 10] | 0;
+  let m11 = block[blockOff + 11] | 0;
+  let m12 = block[blockOff + 12] | 0;
+  let m13 = block[blockOff + 13] | 0;
+  let m14 = block[blockOff + 14] | 0;
+  let m15 = block[blockOff + 15] | 0;
+
+  // Initialize state: first 8 words from chaining value
+  let s0 = cv[cvOff] | 0;
+  let s1 = cv[cvOff + 1] | 0;
+  let s2 = cv[cvOff + 2] | 0;
+  let s3 = cv[cvOff + 3] | 0;
+  let s4 = cv[cvOff + 4] | 0;
+  let s5 = cv[cvOff + 5] | 0;
+  let s6 = cv[cvOff + 6] | 0;
+  let s7 = cv[cvOff + 7] | 0;
+
+  // Words 8-11: IV constants
+  let s8 = 0x6a09e667;
+  let s9 = 0xbb67ae85;
+  let s10 = 0x3c6ef372;
+  let s11 = 0xa54ff53a;
+
+  // Words 12-15: counter, blockLen, flags
+  // Note: counter is 64-bit, split into low and high 32-bit words
+  let s12 = counter | 0;
+  let s13 = (counter / 0x100000000) | 0;
+  let s14 = blockLen | 0;
+  let s15 = flags | 0;
+
+  // ============================================================
+  // 7 rounds of mixing
+  // Each round consists of 4 column G functions and 4 diagonal G functions
+  // followed by a message word permutation (except for round 7)
+  // ============================================================
+
+  // ROUND 1 (message schedule: 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)
+  // Column G functions
+  // G(0, 4, 8, 12) with m0, m1
+  s0 = (((s0 + s4) | 0) + m0) | 0;
+  s12 ^= s0;
+  s12 = (s12 >>> 16) | (s12 << 16);
+  s8 = (s8 + s12) | 0;
+  s4 ^= s8;
+  s4 = (s4 >>> 12) | (s4 << 20);
+  s0 = (((s0 + s4) | 0) + m1) | 0;
+  s12 ^= s0;
+  s12 = (s12 >>> 8) | (s12 << 24);
+  s8 = (s8 + s12) | 0;
+  s4 ^= s8;
+  s4 = (s4 >>> 7) | (s4 << 25);
+  // G(1, 5, 9, 13) with m2, m3
+  s1 = (((s1 + s5) | 0) + m2) | 0;
+  s13 ^= s1;
+  s13 = (s13 >>> 16) | (s13 << 16);
+  s9 = (s9 + s13) | 0;
+  s5 ^= s9;
+  s5 = (s5 >>> 12) | (s5 << 20);
+  s1 = (((s1 + s5) | 0) + m3) | 0;
+  s13 ^= s1;
+  s13 = (s13 >>> 8) | (s13 << 24);
+  s9 = (s9 + s13) | 0;
+  s5 ^= s9;
+  s5 = (s5 >>> 7) | (s5 << 25);
+  // G(2, 6, 10, 14) with m4, m5
+  s2 = (((s2 + s6) | 0) + m4) | 0;
+  s14 ^= s2;
+  s14 = (s14 >>> 16) | (s14 << 16);
+  s10 = (s10 + s14) | 0;
+  s6 ^= s10;
+  s6 = (s6 >>> 12) | (s6 << 20);
+  s2 = (((s2 + s6) | 0) + m5) | 0;
+  s14 ^= s2;
+  s14 = (s14 >>> 8) | (s14 << 24);
+  s10 = (s10 + s14) | 0;
+  s6 ^= s10;
+  s6 = (s6 >>> 7) | (s6 << 25);
+  // G(3, 7, 11, 15) with m6, m7
+  s3 = (((s3 + s7) | 0) + m6) | 0;
+  s15 ^= s3;
+  s15 = (s15 >>> 16) | (s15 << 16);
+  s11 = (s11 + s15) | 0;
+  s7 ^= s11;
+  s7 = (s7 >>> 12) | (s7 << 20);
+  s3 = (((s3 + s7) | 0) + m7) | 0;
+  s15 ^= s3;
+  s15 = (s15 >>> 8) | (s15 << 24);
+  s11 = (s11 + s15) | 0;
+  s7 ^= s11;
+  s7 = (s7 >>> 7) | (s7 << 25);
+  // Diagonal G functions
+  // G(0, 5, 10, 15) with m8, m9
+  s0 = (((s0 + s5) | 0) + m8) | 0;
+  s15 ^= s0;
+  s15 = (s15 >>> 16) | (s15 << 16);
+  s10 = (s10 + s15) | 0;
+  s5 ^= s10;
+  s5 = (s5 >>> 12) | (s5 << 20);
+  s0 = (((s0 + s5) | 0) + m9) | 0;
+  s15 ^= s0;
+  s15 = (s15 >>> 8) | (s15 << 24);
+  s10 = (s10 + s15) | 0;
+  s5 ^= s10;
+  s5 = (s5 >>> 7) | (s5 << 25);
+  // G(1, 6, 11, 12) with m10, m11
+  s1 = (((s1 + s6) | 0) + m10) | 0;
+  s12 ^= s1;
+  s12 = (s12 >>> 16) | (s12 << 16);
+  s11 = (s11 + s12) | 0;
+  s6 ^= s11;
+  s6 = (s6 >>> 12) | (s6 << 20);
+  s1 = (((s1 + s6) | 0) + m11) | 0;
+  s12 ^= s1;
+  s12 = (s12 >>> 8) | (s12 << 24);
+  s11 = (s11 + s12) | 0;
+  s6 ^= s11;
+  s6 = (s6 >>> 7) | (s6 << 25);
+  // G(2, 7, 8, 13) with m12, m13
+  s2 = (((s2 + s7) | 0) + m12) | 0;
+  s13 ^= s2;
+  s13 = (s13 >>> 16) | (s13 << 16);
+  s8 = (s8 + s13) | 0;
+  s7 ^= s8;
+  s7 = (s7 >>> 12) | (s7 << 20);
+  s2 = (((s2 + s7) | 0) + m13) | 0;
+  s13 ^= s2;
+  s13 = (s13 >>> 8) | (s13 << 24);
+  s8 = (s8 + s13) | 0;
+  s7 ^= s8;
+  s7 = (s7 >>> 7) | (s7 << 25);
+  // G(3, 4, 9, 14) with m14, m15
+  s3 = (((s3 + s4) | 0) + m14) | 0;
+  s14 ^= s3;
+  s14 = (s14 >>> 16) | (s14 << 16);
+  s9 = (s9 + s14) | 0;
+  s4 ^= s9;
+  s4 = (s4 >>> 12) | (s4 << 20);
+  s3 = (((s3 + s4) | 0) + m15) | 0;
+  s14 ^= s3;
+  s14 = (s14 >>> 8) | (s14 << 24);
+  s9 = (s9 + s14) | 0;
+  s4 ^= s9;
+  s4 = (s4 >>> 7) | (s4 << 25);
+
+  // Permute message words for round 2
+  // Permutation: [2,6,3,10,7,0,4,13,1,11,12,5,9,14,15,8]
+  // Using 2 temps for the two cycles in the permutation
+  {
+    const t0 = m0,
+      t1 = m1;
+    m0 = m2;
+    m2 = m3;
+    m3 = m10;
+    m10 = m12;
+    m12 = m9;
+    m9 = m11;
+    m11 = m5;
+    m5 = t0;
+    m1 = m6;
+    m6 = m4;
+    m4 = m7;
+    m7 = m13;
+    m13 = m14;
+    m14 = m15;
+    m15 = m8;
+    m8 = t1;
+  }
+
+  // ROUND 2 (message schedule: 2,6,3,10,7,0,4,13,1,11,12,5,9,14,15,8)
+  s0 = (((s0 + s4) | 0) + m0) | 0;
+  s12 ^= s0;
+  s12 = (s12 >>> 16) | (s12 << 16);
+  s8 = (s8 + s12) | 0;
+  s4 ^= s8;
+  s4 = (s4 >>> 12) | (s4 << 20);
+  s0 = (((s0 + s4) | 0) + m1) | 0;
+  s12 ^= s0;
+  s12 = (s12 >>> 8) | (s12 << 24);
+  s8 = (s8 + s12) | 0;
+  s4 ^= s8;
+  s4 = (s4 >>> 7) | (s4 << 25);
+  s1 = (((s1 + s5) | 0) + m2) | 0;
+  s13 ^= s1;
+  s13 = (s13 >>> 16) | (s13 << 16);
+  s9 = (s9 + s13) | 0;
+  s5 ^= s9;
+  s5 = (s5 >>> 12) | (s5 << 20);
+  s1 = (((s1 + s5) | 0) + m3) | 0;
+  s13 ^= s1;
+  s13 = (s13 >>> 8) | (s13 << 24);
+  s9 = (s9 + s13) | 0;
+  s5 ^= s9;
+  s5 = (s5 >>> 7) | (s5 << 25);
+  s2 = (((s2 + s6) | 0) + m4) | 0;
+  s14 ^= s2;
+  s14 = (s14 >>> 16) | (s14 << 16);
+  s10 = (s10 + s14) | 0;
+  s6 ^= s10;
+  s6 = (s6 >>> 12) | (s6 << 20);
+  s2 = (((s2 + s6) | 0) + m5) | 0;
+  s14 ^= s2;
+  s14 = (s14 >>> 8) | (s14 << 24);
+  s10 = (s10 + s14) | 0;
+  s6 ^= s10;
+  s6 = (s6 >>> 7) | (s6 << 25);
+  s3 = (((s3 + s7) | 0) + m6) | 0;
+  s15 ^= s3;
+  s15 = (s15 >>> 16) | (s15 << 16);
+  s11 = (s11 + s15) | 0;
+  s7 ^= s11;
+  s7 = (s7 >>> 12) | (s7 << 20);
+  s3 = (((s3 + s7) | 0) + m7) | 0;
+  s15 ^= s3;
+  s15 = (s15 >>> 8) | (s15 << 24);
+  s11 = (s11 + s15) | 0;
+  s7 ^= s11;
+  s7 = (s7 >>> 7) | (s7 << 25);
+  s0 = (((s0 + s5) | 0) + m8) | 0;
+  s15 ^= s0;
+  s15 = (s15 >>> 16) | (s15 << 16);
+  s10 = (s10 + s15) | 0;
+  s5 ^= s10;
+  s5 = (s5 >>> 12) | (s5 << 20);
+  s0 = (((s0 + s5) | 0) + m9) | 0;
+  s15 ^= s0;
+  s15 = (s15 >>> 8) | (s15 << 24);
+  s10 = (s10 + s15) | 0;
+  s5 ^= s10;
+  s5 = (s5 >>> 7) | (s5 << 25);
+  s1 = (((s1 + s6) | 0) + m10) | 0;
+  s12 ^= s1;
+  s12 = (s12 >>> 16) | (s12 << 16);
+  s11 = (s11 + s12) | 0;
+  s6 ^= s11;
+  s6 = (s6 >>> 12) | (s6 << 20);
+  s1 = (((s1 + s6) | 0) + m11) | 0;
+  s12 ^= s1;
+  s12 = (s12 >>> 8) | (s12 << 24);
+  s11 = (s11 + s12) | 0;
+  s6 ^= s11;
+  s6 = (s6 >>> 7) | (s6 << 25);
+  s2 = (((s2 + s7) | 0) + m12) | 0;
+  s13 ^= s2;
+  s13 = (s13 >>> 16) | (s13 << 16);
+  s8 = (s8 + s13) | 0;
+  s7 ^= s8;
+  s7 = (s7 >>> 12) | (s7 << 20);
+  s2 = (((s2 + s7) | 0) + m13) | 0;
+  s13 ^= s2;
+  s13 = (s13 >>> 8) | (s13 << 24);
+  s8 = (s8 + s13) | 0;
+  s7 ^= s8;
+  s7 = (s7 >>> 7) | (s7 << 25);
+  s3 = (((s3 + s4) | 0) + m14) | 0;
+  s14 ^= s3;
+  s14 = (s14 >>> 16) | (s14 << 16);
+  s9 = (s9 + s14) | 0;
+  s4 ^= s9;
+  s4 = (s4 >>> 12) | (s4 << 20);
+  s3 = (((s3 + s4) | 0) + m15) | 0;
+  s14 ^= s3;
+  s14 = (s14 >>> 8) | (s14 << 24);
+  s9 = (s9 + s14) | 0;
+  s4 ^= s9;
+  s4 = (s4 >>> 7) | (s4 << 25);
+
+  // Permute for round 3
+  {
+    const t0 = m0,
+      t1 = m1;
+    m0 = m2;
+    m2 = m3;
+    m3 = m10;
+    m10 = m12;
+    m12 = m9;
+    m9 = m11;
+    m11 = m5;
+    m5 = t0;
+    m1 = m6;
+    m6 = m4;
+    m4 = m7;
+    m7 = m13;
+    m13 = m14;
+    m14 = m15;
+    m15 = m8;
+    m8 = t1;
+  }
+
+  // ROUND 3 (message schedule: 3,4,10,12,13,2,7,14,6,5,9,0,11,15,8,1)
+  s0 = (((s0 + s4) | 0) + m0) | 0;
+  s12 ^= s0;
+  s12 = (s12 >>> 16) | (s12 << 16);
+  s8 = (s8 + s12) | 0;
+  s4 ^= s8;
+  s4 = (s4 >>> 12) | (s4 << 20);
+  s0 = (((s0 + s4) | 0) + m1) | 0;
+  s12 ^= s0;
+  s12 = (s12 >>> 8) | (s12 << 24);
+  s8 = (s8 + s12) | 0;
+  s4 ^= s8;
+  s4 = (s4 >>> 7) | (s4 << 25);
+  s1 = (((s1 + s5) | 0) + m2) | 0;
+  s13 ^= s1;
+  s13 = (s13 >>> 16) | (s13 << 16);
+  s9 = (s9 + s13) | 0;
+  s5 ^= s9;
+  s5 = (s5 >>> 12) | (s5 << 20);
+  s1 = (((s1 + s5) | 0) + m3) | 0;
+  s13 ^= s1;
+  s13 = (s13 >>> 8) | (s13 << 24);
+  s9 = (s9 + s13) | 0;
+  s5 ^= s9;
+  s5 = (s5 >>> 7) | (s5 << 25);
+  s2 = (((s2 + s6) | 0) + m4) | 0;
+  s14 ^= s2;
+  s14 = (s14 >>> 16) | (s14 << 16);
+  s10 = (s10 + s14) | 0;
+  s6 ^= s10;
+  s6 = (s6 >>> 12) | (s6 << 20);
+  s2 = (((s2 + s6) | 0) + m5) | 0;
+  s14 ^= s2;
+  s14 = (s14 >>> 8) | (s14 << 24);
+  s10 = (s10 + s14) | 0;
+  s6 ^= s10;
+  s6 = (s6 >>> 7) | (s6 << 25);
+  s3 = (((s3 + s7) | 0) + m6) | 0;
+  s15 ^= s3;
+  s15 = (s15 >>> 16) | (s15 << 16);
+  s11 = (s11 + s15) | 0;
+  s7 ^= s11;
+  s7 = (s7 >>> 12) | (s7 << 20);
+  s3 = (((s3 + s7) | 0) + m7) | 0;
+  s15 ^= s3;
+  s15 = (s15 >>> 8) | (s15 << 24);
+  s11 = (s11 + s15) | 0;
+  s7 ^= s11;
+  s7 = (s7 >>> 7) | (s7 << 25);
+  s0 = (((s0 + s5) | 0) + m8) | 0;
+  s15 ^= s0;
+  s15 = (s15 >>> 16) | (s15 << 16);
+  s10 = (s10 + s15) | 0;
+  s5 ^= s10;
+  s5 = (s5 >>> 12) | (s5 << 20);
+  s0 = (((s0 + s5) | 0) + m9) | 0;
+  s15 ^= s0;
+  s15 = (s15 >>> 8) | (s15 << 24);
+  s10 = (s10 + s15) | 0;
+  s5 ^= s10;
+  s5 = (s5 >>> 7) | (s5 << 25);
+  s1 = (((s1 + s6) | 0) + m10) | 0;
+  s12 ^= s1;
+  s12 = (s12 >>> 16) | (s12 << 16);
+  s11 = (s11 + s12) | 0;
+  s6 ^= s11;
+  s6 = (s6 >>> 12) | (s6 << 20);
+  s1 = (((s1 + s6) | 0) + m11) | 0;
+  s12 ^= s1;
+  s12 = (s12 >>> 8) | (s12 << 24);
+  s11 = (s11 + s12) | 0;
+  s6 ^= s11;
+  s6 = (s6 >>> 7) | (s6 << 25);
+  s2 = (((s2 + s7) | 0) + m12) | 0;
+  s13 ^= s2;
+  s13 = (s13 >>> 16) | (s13 << 16);
+  s8 = (s8 + s13) | 0;
+  s7 ^= s8;
+  s7 = (s7 >>> 12) | (s7 << 20);
+  s2 = (((s2 + s7) | 0) + m13) | 0;
+  s13 ^= s2;
+  s13 = (s13 >>> 8) | (s13 << 24);
+  s8 = (s8 + s13) | 0;
+  s7 ^= s8;
+  s7 = (s7 >>> 7) | (s7 << 25);
+  s3 = (((s3 + s4) | 0) + m14) | 0;
+  s14 ^= s3;
+  s14 = (s14 >>> 16) | (s14 << 16);
+  s9 = (s9 + s14) | 0;
+  s4 ^= s9;
+  s4 = (s4 >>> 12) | (s4 << 20);
+  s3 = (((s3 + s4) | 0) + m15) | 0;
+  s14 ^= s3;
+  s14 = (s14 >>> 8) | (s14 << 24);
+  s9 = (s9 + s14) | 0;
+  s4 ^= s9;
+  s4 = (s4 >>> 7) | (s4 << 25);
+
+  // Permute for round 4
+  {
+    const t0 = m0,
+      t1 = m1;
+    m0 = m2;
+    m2 = m3;
+    m3 = m10;
+    m10 = m12;
+    m12 = m9;
+    m9 = m11;
+    m11 = m5;
+    m5 = t0;
+    m1 = m6;
+    m6 = m4;
+    m4 = m7;
+    m7 = m13;
+    m13 = m14;
+    m14 = m15;
+    m15 = m8;
+    m8 = t1;
+  }
+
+  // ROUND 4 (message schedule: 10,7,12,9,14,3,13,15,4,0,11,2,5,8,1,6)
+  s0 = (((s0 + s4) | 0) + m0) | 0;
+  s12 ^= s0;
+  s12 = (s12 >>> 16) | (s12 << 16);
+  s8 = (s8 + s12) | 0;
+  s4 ^= s8;
+  s4 = (s4 >>> 12) | (s4 << 20);
+  s0 = (((s0 + s4) | 0) + m1) | 0;
+  s12 ^= s0;
+  s12 = (s12 >>> 8) | (s12 << 24);
+  s8 = (s8 + s12) | 0;
+  s4 ^= s8;
+  s4 = (s4 >>> 7) | (s4 << 25);
+  s1 = (((s1 + s5) | 0) + m2) | 0;
+  s13 ^= s1;
+  s13 = (s13 >>> 16) | (s13 << 16);
+  s9 = (s9 + s13) | 0;
+  s5 ^= s9;
+  s5 = (s5 >>> 12) | (s5 << 20);
+  s1 = (((s1 + s5) | 0) + m3) | 0;
+  s13 ^= s1;
+  s13 = (s13 >>> 8) | (s13 << 24);
+  s9 = (s9 + s13) | 0;
+  s5 ^= s9;
+  s5 = (s5 >>> 7) | (s5 << 25);
+  s2 = (((s2 + s6) | 0) + m4) | 0;
+  s14 ^= s2;
+  s14 = (s14 >>> 16) | (s14 << 16);
+  s10 = (s10 + s14) | 0;
+  s6 ^= s10;
+  s6 = (s6 >>> 12) | (s6 << 20);
+  s2 = (((s2 + s6) | 0) + m5) | 0;
+  s14 ^= s2;
+  s14 = (s14 >>> 8) | (s14 << 24);
+  s10 = (s10 + s14) | 0;
+  s6 ^= s10;
+  s6 = (s6 >>> 7) | (s6 << 25);
+  s3 = (((s3 + s7) | 0) + m6) | 0;
+  s15 ^= s3;
+  s15 = (s15 >>> 16) | (s15 << 16);
+  s11 = (s11 + s15) | 0;
+  s7 ^= s11;
+  s7 = (s7 >>> 12) | (s7 << 20);
+  s3 = (((s3 + s7) | 0) + m7) | 0;
+  s15 ^= s3;
+  s15 = (s15 >>> 8) | (s15 << 24);
+  s11 = (s11 + s15) | 0;
+  s7 ^= s11;
+  s7 = (s7 >>> 7) | (s7 << 25);
+  s0 = (((s0 + s5) | 0) + m8) | 0;
+  s15 ^= s0;
+  s15 = (s15 >>> 16) | (s15 << 16);
+  s10 = (s10 + s15) | 0;
+  s5 ^= s10;
+  s5 = (s5 >>> 12) | (s5 << 20);
+  s0 = (((s0 + s5) | 0) + m9) | 0;
+  s15 ^= s0;
+  s15 = (s15 >>> 8) | (s15 << 24);
+  s10 = (s10 + s15) | 0;
+  s5 ^= s10;
+  s5 = (s5 >>> 7) | (s5 << 25);
+  s1 = (((s1 + s6) | 0) + m10) | 0;
+  s12 ^= s1;
+  s12 = (s12 >>> 16) | (s12 << 16);
+  s11 = (s11 + s12) | 0;
+  s6 ^= s11;
+  s6 = (s6 >>> 12) | (s6 << 20);
+  s1 = (((s1 + s6) | 0) + m11) | 0;
+  s12 ^= s1;
+  s12 = (s12 >>> 8) | (s12 << 24);
+  s11 = (s11 + s12) | 0;
+  s6 ^= s11;
+  s6 = (s6 >>> 7) | (s6 << 25);
+  s2 = (((s2 + s7) | 0) + m12) | 0;
+  s13 ^= s2;
+  s13 = (s13 >>> 16) | (s13 << 16);
+  s8 = (s8 + s13) | 0;
+  s7 ^= s8;
+  s7 = (s7 >>> 12) | (s7 << 20);
+  s2 = (((s2 + s7) | 0) + m13) | 0;
+  s13 ^= s2;
+  s13 = (s13 >>> 8) | (s13 << 24);
+  s8 = (s8 + s13) | 0;
+  s7 ^= s8;
+  s7 = (s7 >>> 7) | (s7 << 25);
+  s3 = (((s3 + s4) | 0) + m14) | 0;
+  s14 ^= s3;
+  s14 = (s14 >>> 16) | (s14 << 16);
+  s9 = (s9 + s14) | 0;
+  s4 ^= s9;
+  s4 = (s4 >>> 12) | (s4 << 20);
+  s3 = (((s3 + s4) | 0) + m15) | 0;
+  s14 ^= s3;
+  s14 = (s14 >>> 8) | (s14 << 24);
+  s9 = (s9 + s14) | 0;
+  s4 ^= s9;
+  s4 = (s4 >>> 7) | (s4 << 25);
+
+  // Permute for round 5
+  {
+    const t0 = m0,
+      t1 = m1;
+    m0 = m2;
+    m2 = m3;
+    m3 = m10;
+    m10 = m12;
+    m12 = m9;
+    m9 = m11;
+    m11 = m5;
+    m5 = t0;
+    m1 = m6;
+    m6 = m4;
+    m4 = m7;
+    m7 = m13;
+    m13 = m14;
+    m14 = m15;
+    m15 = m8;
+    m8 = t1;
+  }
+
+  // ROUND 5 (message schedule: 12,13,9,11,15,10,14,8,7,2,5,3,0,1,6,4)
+  s0 = (((s0 + s4) | 0) + m0) | 0;
+  s12 ^= s0;
+  s12 = (s12 >>> 16) | (s12 << 16);
+  s8 = (s8 + s12) | 0;
+  s4 ^= s8;
+  s4 = (s4 >>> 12) | (s4 << 20);
+  s0 = (((s0 + s4) | 0) + m1) | 0;
+  s12 ^= s0;
+  s12 = (s12 >>> 8) | (s12 << 24);
+  s8 = (s8 + s12) | 0;
+  s4 ^= s8;
+  s4 = (s4 >>> 7) | (s4 << 25);
+  s1 = (((s1 + s5) | 0) + m2) | 0;
+  s13 ^= s1;
+  s13 = (s13 >>> 16) | (s13 << 16);
+  s9 = (s9 + s13) | 0;
+  s5 ^= s9;
+  s5 = (s5 >>> 12) | (s5 << 20);
+  s1 = (((s1 + s5) | 0) + m3) | 0;
+  s13 ^= s1;
+  s13 = (s13 >>> 8) | (s13 << 24);
+  s9 = (s9 + s13) | 0;
+  s5 ^= s9;
+  s5 = (s5 >>> 7) | (s5 << 25);
+  s2 = (((s2 + s6) | 0) + m4) | 0;
+  s14 ^= s2;
+  s14 = (s14 >>> 16) | (s14 << 16);
+  s10 = (s10 + s14) | 0;
+  s6 ^= s10;
+  s6 = (s6 >>> 12) | (s6 << 20);
+  s2 = (((s2 + s6) | 0) + m5) | 0;
+  s14 ^= s2;
+  s14 = (s14 >>> 8) | (s14 << 24);
+  s10 = (s10 + s14) | 0;
+  s6 ^= s10;
+  s6 = (s6 >>> 7) | (s6 << 25);
+  s3 = (((s3 + s7) | 0) + m6) | 0;
+  s15 ^= s3;
+  s15 = (s15 >>> 16) | (s15 << 16);
+  s11 = (s11 + s15) | 0;
+  s7 ^= s11;
+  s7 = (s7 >>> 12) | (s7 << 20);
+  s3 = (((s3 + s7) | 0) + m7) | 0;
+  s15 ^= s3;
+  s15 = (s15 >>> 8) | (s15 << 24);
+  s11 = (s11 + s15) | 0;
+  s7 ^= s11;
+  s7 = (s7 >>> 7) | (s7 << 25);
+  s0 = (((s0 + s5) | 0) + m8) | 0;
+  s15 ^= s0;
+  s15 = (s15 >>> 16) | (s15 << 16);
+  s10 = (s10 + s15) | 0;
+  s5 ^= s10;
+  s5 = (s5 >>> 12) | (s5 << 20);
+  s0 = (((s0 + s5) | 0) + m9) | 0;
+  s15 ^= s0;
+  s15 = (s15 >>> 8) | (s15 << 24);
+  s10 = (s10 + s15) | 0;
+  s5 ^= s10;
+  s5 = (s5 >>> 7) | (s5 << 25);
+  s1 = (((s1 + s6) | 0) + m10) | 0;
+  s12 ^= s1;
+  s12 = (s12 >>> 16) | (s12 << 16);
+  s11 = (s11 + s12) | 0;
+  s6 ^= s11;
+  s6 = (s6 >>> 12) | (s6 << 20);
+  s1 = (((s1 + s6) | 0) + m11) | 0;
+  s12 ^= s1;
+  s12 = (s12 >>> 8) | (s12 << 24);
+  s11 = (s11 + s12) | 0;
+  s6 ^= s11;
+  s6 = (s6 >>> 7) | (s6 << 25);
+  s2 = (((s2 + s7) | 0) + m12) | 0;
+  s13 ^= s2;
+  s13 = (s13 >>> 16) | (s13 << 16);
+  s8 = (s8 + s13) | 0;
+  s7 ^= s8;
+  s7 = (s7 >>> 12) | (s7 << 20);
+  s2 = (((s2 + s7) | 0) + m13) | 0;
+  s13 ^= s2;
+  s13 = (s13 >>> 8) | (s13 << 24);
+  s8 = (s8 + s13) | 0;
+  s7 ^= s8;
+  s7 = (s7 >>> 7) | (s7 << 25);
+  s3 = (((s3 + s4) | 0) + m14) | 0;
+  s14 ^= s3;
+  s14 = (s14 >>> 16) | (s14 << 16);
+  s9 = (s9 + s14) | 0;
+  s4 ^= s9;
+  s4 = (s4 >>> 12) | (s4 << 20);
+  s3 = (((s3 + s4) | 0) + m15) | 0;
+  s14 ^= s3;
+  s14 = (s14 >>> 8) | (s14 << 24);
+  s9 = (s9 + s14) | 0;
+  s4 ^= s9;
+  s4 = (s4 >>> 7) | (s4 << 25);
+
+  // Permute for round 6
+  {
+    const t0 = m0,
+      t1 = m1;
+    m0 = m2;
+    m2 = m3;
+    m3 = m10;
+    m10 = m12;
+    m12 = m9;
+    m9 = m11;
+    m11 = m5;
+    m5 = t0;
+    m1 = m6;
+    m6 = m4;
+    m4 = m7;
+    m7 = m13;
+    m13 = m14;
+    m14 = m15;
+    m15 = m8;
+    m8 = t1;
+  }
+
+  // ROUND 6 (message schedule: 9,14,11,5,8,12,15,1,13,3,0,10,2,6,4,7)
+  s0 = (((s0 + s4) | 0) + m0) | 0;
+  s12 ^= s0;
+  s12 = (s12 >>> 16) | (s12 << 16);
+  s8 = (s8 + s12) | 0;
+  s4 ^= s8;
+  s4 = (s4 >>> 12) | (s4 << 20);
+  s0 = (((s0 + s4) | 0) + m1) | 0;
+  s12 ^= s0;
+  s12 = (s12 >>> 8) | (s12 << 24);
+  s8 = (s8 + s12) | 0;
+  s4 ^= s8;
+  s4 = (s4 >>> 7) | (s4 << 25);
+  s1 = (((s1 + s5) | 0) + m2) | 0;
+  s13 ^= s1;
+  s13 = (s13 >>> 16) | (s13 << 16);
+  s9 = (s9 + s13) | 0;
+  s5 ^= s9;
+  s5 = (s5 >>> 12) | (s5 << 20);
+  s1 = (((s1 + s5) | 0) + m3) | 0;
+  s13 ^= s1;
+  s13 = (s13 >>> 8) | (s13 << 24);
+  s9 = (s9 + s13) | 0;
+  s5 ^= s9;
+  s5 = (s5 >>> 7) | (s5 << 25);
+  s2 = (((s2 + s6) | 0) + m4) | 0;
+  s14 ^= s2;
+  s14 = (s14 >>> 16) | (s14 << 16);
+  s10 = (s10 + s14) | 0;
+  s6 ^= s10;
+  s6 = (s6 >>> 12) | (s6 << 20);
+  s2 = (((s2 + s6) | 0) + m5) | 0;
+  s14 ^= s2;
+  s14 = (s14 >>> 8) | (s14 << 24);
+  s10 = (s10 + s14) | 0;
+  s6 ^= s10;
+  s6 = (s6 >>> 7) | (s6 << 25);
+  s3 = (((s3 + s7) | 0) + m6) | 0;
+  s15 ^= s3;
+  s15 = (s15 >>> 16) | (s15 << 16);
+  s11 = (s11 + s15) | 0;
+  s7 ^= s11;
+  s7 = (s7 >>> 12) | (s7 << 20);
+  s3 = (((s3 + s7) | 0) + m7) | 0;
+  s15 ^= s3;
+  s15 = (s15 >>> 8) | (s15 << 24);
+  s11 = (s11 + s15) | 0;
+  s7 ^= s11;
+  s7 = (s7 >>> 7) | (s7 << 25);
+  s0 = (((s0 + s5) | 0) + m8) | 0;
+  s15 ^= s0;
+  s15 = (s15 >>> 16) | (s15 << 16);
+  s10 = (s10 + s15) | 0;
+  s5 ^= s10;
+  s5 = (s5 >>> 12) | (s5 << 20);
+  s0 = (((s0 + s5) | 0) + m9) | 0;
+  s15 ^= s0;
+  s15 = (s15 >>> 8) | (s15 << 24);
+  s10 = (s10 + s15) | 0;
+  s5 ^= s10;
+  s5 = (s5 >>> 7) | (s5 << 25);
+  s1 = (((s1 + s6) | 0) + m10) | 0;
+  s12 ^= s1;
+  s12 = (s12 >>> 16) | (s12 << 16);
+  s11 = (s11 + s12) | 0;
+  s6 ^= s11;
+  s6 = (s6 >>> 12) | (s6 << 20);
+  s1 = (((s1 + s6) | 0) + m11) | 0;
+  s12 ^= s1;
+  s12 = (s12 >>> 8) | (s12 << 24);
+  s11 = (s11 + s12) | 0;
+  s6 ^= s11;
+  s6 = (s6 >>> 7) | (s6 << 25);
+  s2 = (((s2 + s7) | 0) + m12) | 0;
+  s13 ^= s2;
+  s13 = (s13 >>> 16) | (s13 << 16);
+  s8 = (s8 + s13) | 0;
+  s7 ^= s8;
+  s7 = (s7 >>> 12) | (s7 << 20);
+  s2 = (((s2 + s7) | 0) + m13) | 0;
+  s13 ^= s2;
+  s13 = (s13 >>> 8) | (s13 << 24);
+  s8 = (s8 + s13) | 0;
+  s7 ^= s8;
+  s7 = (s7 >>> 7) | (s7 << 25);
+  s3 = (((s3 + s4) | 0) + m14) | 0;
+  s14 ^= s3;
+  s14 = (s14 >>> 16) | (s14 << 16);
+  s9 = (s9 + s14) | 0;
+  s4 ^= s9;
+  s4 = (s4 >>> 12) | (s4 << 20);
+  s3 = (((s3 + s4) | 0) + m15) | 0;
+  s14 ^= s3;
+  s14 = (s14 >>> 8) | (s14 << 24);
+  s9 = (s9 + s14) | 0;
+  s4 ^= s9;
+  s4 = (s4 >>> 7) | (s4 << 25);
+
+  // Permute for round 7
+  {
+    const t0 = m0,
+      t1 = m1;
+    m0 = m2;
+    m2 = m3;
+    m3 = m10;
+    m10 = m12;
+    m12 = m9;
+    m9 = m11;
+    m11 = m5;
+    m5 = t0;
+    m1 = m6;
+    m6 = m4;
+    m4 = m7;
+    m7 = m13;
+    m13 = m14;
+    m14 = m15;
+    m15 = m8;
+    m8 = t1;
+  }
+
+  // ROUND 7 (message schedule: 11,15,5,0,1,9,8,6,14,10,2,12,3,4,7,13)
+  s0 = (((s0 + s4) | 0) + m0) | 0;
+  s12 ^= s0;
+  s12 = (s12 >>> 16) | (s12 << 16);
+  s8 = (s8 + s12) | 0;
+  s4 ^= s8;
+  s4 = (s4 >>> 12) | (s4 << 20);
+  s0 = (((s0 + s4) | 0) + m1) | 0;
+  s12 ^= s0;
+  s12 = (s12 >>> 8) | (s12 << 24);
+  s8 = (s8 + s12) | 0;
+  s4 ^= s8;
+  s4 = (s4 >>> 7) | (s4 << 25);
+  s1 = (((s1 + s5) | 0) + m2) | 0;
+  s13 ^= s1;
+  s13 = (s13 >>> 16) | (s13 << 16);
+  s9 = (s9 + s13) | 0;
+  s5 ^= s9;
+  s5 = (s5 >>> 12) | (s5 << 20);
+  s1 = (((s1 + s5) | 0) + m3) | 0;
+  s13 ^= s1;
+  s13 = (s13 >>> 8) | (s13 << 24);
+  s9 = (s9 + s13) | 0;
+  s5 ^= s9;
+  s5 = (s5 >>> 7) | (s5 << 25);
+  s2 = (((s2 + s6) | 0) + m4) | 0;
+  s14 ^= s2;
+  s14 = (s14 >>> 16) | (s14 << 16);
+  s10 = (s10 + s14) | 0;
+  s6 ^= s10;
+  s6 = (s6 >>> 12) | (s6 << 20);
+  s2 = (((s2 + s6) | 0) + m5) | 0;
+  s14 ^= s2;
+  s14 = (s14 >>> 8) | (s14 << 24);
+  s10 = (s10 + s14) | 0;
+  s6 ^= s10;
+  s6 = (s6 >>> 7) | (s6 << 25);
+  s3 = (((s3 + s7) | 0) + m6) | 0;
+  s15 ^= s3;
+  s15 = (s15 >>> 16) | (s15 << 16);
+  s11 = (s11 + s15) | 0;
+  s7 ^= s11;
+  s7 = (s7 >>> 12) | (s7 << 20);
+  s3 = (((s3 + s7) | 0) + m7) | 0;
+  s15 ^= s3;
+  s15 = (s15 >>> 8) | (s15 << 24);
+  s11 = (s11 + s15) | 0;
+  s7 ^= s11;
+  s7 = (s7 >>> 7) | (s7 << 25);
+  s0 = (((s0 + s5) | 0) + m8) | 0;
+  s15 ^= s0;
+  s15 = (s15 >>> 16) | (s15 << 16);
+  s10 = (s10 + s15) | 0;
+  s5 ^= s10;
+  s5 = (s5 >>> 12) | (s5 << 20);
+  s0 = (((s0 + s5) | 0) + m9) | 0;
+  s15 ^= s0;
+  s15 = (s15 >>> 8) | (s15 << 24);
+  s10 = (s10 + s15) | 0;
+  s5 ^= s10;
+  s5 = (s5 >>> 7) | (s5 << 25);
+  s1 = (((s1 + s6) | 0) + m10) | 0;
+  s12 ^= s1;
+  s12 = (s12 >>> 16) | (s12 << 16);
+  s11 = (s11 + s12) | 0;
+  s6 ^= s11;
+  s6 = (s6 >>> 12) | (s6 << 20);
+  s1 = (((s1 + s6) | 0) + m11) | 0;
+  s12 ^= s1;
+  s12 = (s12 >>> 8) | (s12 << 24);
+  s11 = (s11 + s12) | 0;
+  s6 ^= s11;
+  s6 = (s6 >>> 7) | (s6 << 25);
+  s2 = (((s2 + s7) | 0) + m12) | 0;
+  s13 ^= s2;
+  s13 = (s13 >>> 16) | (s13 << 16);
+  s8 = (s8 + s13) | 0;
+  s7 ^= s8;
+  s7 = (s7 >>> 12) | (s7 << 20);
+  s2 = (((s2 + s7) | 0) + m13) | 0;
+  s13 ^= s2;
+  s13 = (s13 >>> 8) | (s13 << 24);
+  s8 = (s8 + s13) | 0;
+  s7 ^= s8;
+  s7 = (s7 >>> 7) | (s7 << 25);
+  s3 = (((s3 + s4) | 0) + m14) | 0;
+  s14 ^= s3;
+  s14 = (s14 >>> 16) | (s14 << 16);
+  s9 = (s9 + s14) | 0;
+  s4 ^= s9;
+  s4 = (s4 >>> 12) | (s4 << 20);
+  s3 = (((s3 + s4) | 0) + m15) | 0;
+  s14 ^= s3;
+  s14 = (s14 >>> 8) | (s14 << 24);
+  s9 = (s9 + s14) | 0;
+  s4 ^= s9;
+  s4 = (s4 >>> 7) | (s4 << 25);
+
+  // ============================================================
+  // Final XOR and output
+  // ============================================================
+
+  // If full output needed (XOF mode), write words 8-15 first
+  // (written first in case out === cv)
+  if (full) {
+    out[outOff + 8] = s8 ^ cv[cvOff];
+    out[outOff + 9] = s9 ^ cv[cvOff + 1];
+    out[outOff + 10] = s10 ^ cv[cvOff + 2];
+    out[outOff + 11] = s11 ^ cv[cvOff + 3];
+    out[outOff + 12] = s12 ^ cv[cvOff + 4];
+    out[outOff + 13] = s13 ^ cv[cvOff + 5];
+    out[outOff + 14] = s14 ^ cv[cvOff + 6];
+    out[outOff + 15] = s15 ^ cv[cvOff + 7];
+  }
+
+  // Standard output: XOR state[0..7] with state[8..15]
+  out[outOff] = s0 ^ s8;
+  out[outOff + 1] = s1 ^ s9;
+  out[outOff + 2] = s2 ^ s10;
+  out[outOff + 3] = s3 ^ s11;
+  out[outOff + 4] = s4 ^ s12;
+  out[outOff + 5] = s5 ^ s13;
+  out[outOff + 6] = s6 ^ s14;
+  out[outOff + 7] = s7 ^ s15;
+}

node_modules/@huggingface/blake3-jit/src/constants.ts

@@ -0,0 +1,59 @@
+/**
+ * BLAKE3 Constants
+ *
+ * IV values are the same as SHA-256: first 32 bits of the fractional parts
+ * of the square roots of the first 8 primes (2..19)
+ */
+
+// Initialization Vector (same as SHA-256)
+export const IV = new Uint32Array([
+  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]);
+
+// Domain separation flags
+export const CHUNK_START = 1;
+export const CHUNK_END = 1 << 1;
+export const PARENT = 1 << 2;
+export const ROOT = 1 << 3;
+export const KEYED_HASH = 1 << 4;
+export const DERIVE_KEY_CONTEXT = 1 << 5;
+export const DERIVE_KEY_MATERIAL = 1 << 6;
+
+// Size constants
+export const OUT_LEN = 32;
+export const KEY_LEN = 32;
+export const BLOCK_LEN = 64;
+export const CHUNK_LEN = 1024;
+
+// Maximum depth of the CV stack (supports up to 2^54 bytes input)
+export const MAX_DEPTH = 54;
+
+/**
+ * Precomputed message word permutations for all 7 rounds.
+ *
+ * The base permutation is: [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8]
+ * Each subsequent permutation is the previous one with this permutation applied.
+ *
+ * These are the indices into the message block for each round.
+ * By precomputing these, we avoid runtime permutation overhead.
+ */
+export const MSG_SCHEDULE: ReadonlyArray<ReadonlyArray<number>> = [
+  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+  [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8],
+  [3, 4, 10, 12, 13, 2, 7, 14, 6, 5, 9, 0, 11, 15, 8, 1],
+  [10, 7, 12, 9, 14, 3, 13, 15, 4, 0, 11, 2, 5, 8, 1, 6],
+  [12, 13, 9, 11, 15, 10, 14, 8, 7, 2, 5, 3, 0, 1, 6, 4],
+  [9, 14, 11, 5, 8, 12, 15, 1, 13, 3, 0, 10, 2, 6, 4, 7],
+  [11, 15, 5, 0, 1, 9, 8, 6, 14, 10, 2, 12, 3, 4, 7, 13],
+];
+
+/**
+ * Flattened permutation table for compress function optimization.
+ * This enables direct indexed access: PERMUTATIONS[round * 16 + index]
+ */
+export const PERMUTATIONS = new Uint8Array([
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9,
+  14, 15, 8, 3, 4, 10, 12, 13, 2, 7, 14, 6, 5, 9, 0, 11, 15, 8, 1, 10, 7, 12, 9, 14, 3, 13, 15, 4,
+  0, 11, 2, 5, 8, 1, 6, 12, 13, 9, 11, 15, 10, 14, 8, 7, 2, 5, 3, 0, 1, 6, 4, 9, 14, 11, 5, 8, 12,
+  15, 1, 13, 3, 0, 10, 2, 6, 4, 7, 11, 15, 5, 0, 1, 9, 8, 6, 14, 10, 2, 12, 3, 4, 7, 13,
+]);

node_modules/@huggingface/blake3-jit/src/hash.ts

@@ -0,0 +1,1318 @@
+/**
+ * BLAKE3 Hash Function - Simple one-shot API
+ *
+ * This provides a simple hash() function optimized for different input sizes.
+ * For small inputs, uses pure JS. For large inputs, uses WASM SIMD.
+ */
+
+import { compress } from "./compress.js";
+import {
+  IV,
+  CHUNK_START,
+  CHUNK_END,
+  PARENT,
+  ROOT,
+  BLOCK_LEN,
+  CHUNK_LEN,
+  OUT_LEN,
+} from "./constants.js";
+import {
+  IS_LITTLE_ENDIAN,
+  readLittleEndianWordsFull,
+  readLittleEndianWordsPartial,
+  writeLittleEndianBytesPartial,
+} from "./utils.js";
+import {
+  initSimdSync,
+  getSimdMemory,
+  getArenaBuffers,
+  runCompress4x,
+  runCompressChunks4x,
+  runCompressParent,
+  SIMD_MEMORY,
+} from "./wasm-simd.js";
+
+// Pre-allocated buffers for reuse (single-threaded optimization)
+let blockWords: Uint32Array | null = null;
+
+// ===== Contiguous Hyper CV Stack (Optimization #6) =====
+// Maximum tree depth for practical inputs (2^64 chunks = essentially unlimited)
+// Fixed allocation at module load - no runtime allocation
+const CV_STACK_DEPTH = 64;
+const HYPER_CV_STACK = new Uint32Array(CV_STACK_DEPTH * 8); // 64 CVs × 8 words = 512 words
+
+// Pre-computed offsets for the first few stack levels (hot path optimization)
+// Note: These can be used for further optimization if needed
+// const CV_STACK_OFF_0 = 0;
+// const CV_STACK_OFF_1 = 8;
+// const CV_STACK_OFF_2 = 16;
+// const CV_STACK_OFF_3 = 24;
+
+// ===== Pre-allocated CV Pool with Views (avoids subarray() in hot paths) =====
+const CV_POOL_SIZE = 64;
+const CV_POOL = new Uint32Array(CV_POOL_SIZE * 8); // 64 CVs × 8 words = 512 words
+const CV_VIEWS: Uint32Array[] = [];
+for (let i = 0; i < CV_POOL_SIZE; i++) {
+  CV_VIEWS.push(CV_POOL.subarray(i * 8, i * 8 + 8));
+}
+
+// SIMD initialization state
+let simdAvailable = false;
+
+// Threshold for switching to SIMD (must be > 1 chunk to benefit from parallelism)
+const SIMD_THRESHOLD = 4 * CHUNK_LEN; // 4KB - need at least 4 chunks for SIMD benefit
+
+/**
+ * Initialize SIMD synchronously (lazy).
+ */
+function ensureSimdSync(): boolean {
+  if (simdAvailable) return true;
+  simdAvailable = initSimdSync();
+  return simdAvailable;
+}
+
+// Reusable buffer for SIMD chunk CVs (4 chunks × 8 words)
+const simdChunkCvs = new Uint32Array(32);
+
+// ===== Module-level reusable buffers (single-threaded safe) =====
+// These eliminate heap allocations in hot paths
+
+// For hashChunkWithWords() and hashChunkRoot()
+const reusableTempCv = new Uint32Array(8);
+
+// For hashPureJS()
+const reusableChunkCv = new Uint32Array(8);
+const reusablePureParentBlock = new Uint32Array(16);
+const reusablePureParentCv = new Uint32Array(8);
+
+// For hashSimd() - use flat array for 4 chunk CVs (access via subarray)
+const reusableSimdCvs = new Uint32Array(32); // 4 × 8 words flat
+
+// For hashSimd() parent compression
+const reusableSimdParentBlock = new Uint32Array(16);
+const reusableSimdParentCv = new Uint32Array(8);
+
+// For hashSimd() parameters - TypedArrays instead of JS arrays
+const reusableOffsets = new Uint32Array(4);
+const reusableCounters = new Uint32Array(4);
+const reusableBlockLens = new Uint32Array(4);
+const reusableFlags = new Uint32Array(4);
+
+// Reusable output buffer for common 32-byte hash (eliminates allocations)
+const reusableOut8 = new Uint32Array(8); // Standard 32-byte output
+// Pre-created view to avoid allocation in hot path (Task 1 optimization)
+const reusableOut8View = new Uint8Array(reusableOut8.buffer, 0, 32);
+
+// ===== Unrolled CV Copy Helper (Task 7 optimization) =====
+// V8 will inline this - avoids loop overhead in hot paths
+function copyCV8(src: Uint32Array, srcOff: number, dst: Uint32Array, dstOff: number): void {
+  dst[dstOff] = src[srcOff];
+  dst[dstOff + 1] = src[srcOff + 1];
+  dst[dstOff + 2] = src[srcOff + 2];
+  dst[dstOff + 3] = src[srcOff + 3];
+  dst[dstOff + 4] = src[srcOff + 4];
+  dst[dstOff + 5] = src[srcOff + 5];
+  dst[dstOff + 6] = src[srcOff + 6];
+  dst[dstOff + 7] = src[srcOff + 7];
+}
+
+/**
+ * Transpose 4 blocks (64 bytes each) into SIMD memory layout.
+ * The SIMD compress4x expects: [m0_0,m0_1,m0_2,m0_3, m1_0,m1_1,m1_2,m1_3, ...]
+ * where m{i}_{j} is message word i from block j.
+ *
+ * OPTIMIZED: Processes all 4 blocks together for each word position,
+ * writing 4 consecutive u32s at once for better cache locality.
+ *
+ * @param inputWords - Pre-created Uint32Array view of input (null if unaligned/non-LE).
+ *                     Created once per hash call to avoid allocation in hot loop.
+ */
+function transposeBlocksToSimd(
+  input: Uint8Array,
+  offsets: Uint32Array, // Starting offsets for each of 4 blocks
+  blockLens: Uint32Array, // Length of each block (0-64 bytes)
+  mem32: Uint32Array,
+  blockCount: number, // 1-4 blocks
+  inputWords: Uint32Array | null, // Pre-created view passed from caller
+): void {
+  // Fast path: all blocks are full 64-byte blocks with aligned LE input
+  const allFull =
+    blockCount === 4 &&
+    blockLens[0] === 64 &&
+    blockLens[1] === 64 &&
+    blockLens[2] === 64 &&
+    blockLens[3] === 64;
+
+  if (
+    allFull &&
+    inputWords &&
+    offsets[0] % 4 === 0 &&
+    offsets[1] % 4 === 0 &&
+    offsets[2] % 4 === 0 &&
+    offsets[3] % 4 === 0
+  ) {
+    // Ultra-fast path: process all 4 blocks together, write 4 consecutive u32s per word
+    const wordOff0 = offsets[0] >>> 2;
+    const wordOff1 = offsets[1] >>> 2;
+    const wordOff2 = offsets[2] >>> 2;
+    const wordOff3 = offsets[3] >>> 2;
+
+    for (let w = 0; w < 16; w++) {
+      const dstBase = w * 4;
+      mem32[dstBase] = inputWords[wordOff0 + w];
+      mem32[dstBase + 1] = inputWords[wordOff1 + w];
+      mem32[dstBase + 2] = inputWords[wordOff2 + w];
+      mem32[dstBase + 3] = inputWords[wordOff3 + w];
+    }
+    return;
+  }
+
+  // Standard path: process each block independently (handles partial blocks)
+  for (let b = 0; b < blockCount; b++) {
+    const len = blockLens[b];
+    const off = offsets[b];
+
+    if (len === 64) {
+      // Full block
+      if (inputWords && off % 4 === 0) {
+        // Direct Uint32Array access for aligned LE blocks
+        const wordOff = off >>> 2;
+        for (let w = 0; w < 16; w++) {
+          mem32[w * 4 + b] = inputWords[wordOff + w];
+        }
+      } else {
+        // Byte-by-byte reconstruction
+        for (let w = 0; w < 16; w++) {
+          const srcOff = off + w * 4;
+          mem32[w * 4 + b] =
+            input[srcOff] |
+            (input[srcOff + 1] << 8) |
+            (input[srcOff + 2] << 16) |
+            (input[srcOff + 3] << 24);
+        }
+      }
+    } else if (len === 0) {
+      // Zero block
+      for (let w = 0; w < 16; w++) {
+        mem32[w * 4 + b] = 0;
+      }
+    } else {
+      // Partial block - handle word by word
+      for (let w = 0; w < 16; w++) {
+        const wordOff = w * 4;
+        if (wordOff >= len) {
+          mem32[w * 4 + b] = 0;
+        } else if (wordOff + 4 <= len) {
+          const srcOff = off + wordOff;
+          mem32[w * 4 + b] =
+            input[srcOff] |
+            (input[srcOff + 1] << 8) |
+            (input[srcOff + 2] << 16) |
+            (input[srcOff + 3] << 24);
+        } else {
+          // Partial word at end of block
+          let word = 0;
+          for (let i = 0; i < len - wordOff; i++) {
+            word |= input[off + wordOff + i] << (i * 8);
+          }
+          mem32[w * 4 + b] = word;
+        }
+      }
+    }
+  }
+
+  // Zero unused block slots
+  for (let b = blockCount; b < 4; b++) {
+    for (let w = 0; w < 16; w++) {
+      mem32[w * 4 + b] = 0;
+    }
+  }
+}
+
+/**
+ * Transpose 4 full chunks (4 × 16 blocks = 64 blocks) into batch SIMD memory.
+ * This is used for the batched compressChunks4x function that processes
+ * all 16 blocks in a single WASM call.
+ *
+ * Memory layout: BATCH_BLOCK_WORDS has 16 positions, each with 16 v128 values.
+ * Position p, word w: mem32[(p * 64) + (w * 4) + lane]
+ *
+ * OPTIMIZED: Processes all 4 chunks together for each (pos, word) pair,
+ * writing 4 consecutive u32s at once for better cache locality.
+ *
+ * @param input - Input data (must have at least 4 full chunks = 4096 bytes)
+ * @param chunkOffsets - Starting offsets for each of 4 chunks
+ * @param mem32 - WASM memory view
+ * @param inputWords - Pre-created Uint32Array view (null if unaligned)
+ */
+function transposeBatchToSimd(
+  input: Uint8Array,
+  chunkOffsets: Uint32Array,
+  mem32: Uint32Array,
+  inputWords: Uint32Array | null,
+): void {
+  const BATCH_BASE = SIMD_MEMORY.BATCH_BLOCK_WORDS / 4;
+
+  // Get base word offsets for each chunk (pre-computed for fast path)
+  const chunk0WordBase = chunkOffsets[0] >>> 2;
+  const chunk1WordBase = chunkOffsets[1] >>> 2;
+  const chunk2WordBase = chunkOffsets[2] >>> 2;
+  const chunk3WordBase = chunkOffsets[3] >>> 2;
+
+  // Fast path: all chunks aligned and LE - process 4 consecutive u32s at once
+  if (inputWords && chunkOffsets[0] % 4 === 0) {
+    for (let pos = 0; pos < 16; pos++) {
+      const posBase = BATCH_BASE + pos * 64; // 16 words × 4 lanes = 64
+      const blockWordOff = pos * 16; // 16 words per block (64 bytes / 4)
+
+      // Process all 16 words, writing 4 chunks at a time (cache-friendly: 16 bytes per write group)
+      for (let w = 0; w < 16; w++) {
+        const dstBase = posBase + w * 4;
+        // Read word w from all 4 chunks at positions that become consecutive in output
+        mem32[dstBase] = inputWords[chunk0WordBase + blockWordOff + w];
+        mem32[dstBase + 1] = inputWords[chunk1WordBase + blockWordOff + w];
+        mem32[dstBase + 2] = inputWords[chunk2WordBase + blockWordOff + w];
+        mem32[dstBase + 3] = inputWords[chunk3WordBase + blockWordOff + w];
+      }
+    }
+  } else {
+    // Slow path: byte-by-byte reconstruction, still cache-friendly write pattern
+    for (let pos = 0; pos < 16; pos++) {
+      const posBase = BATCH_BASE + pos * 64;
+      const blockByteOff = pos * 64; // 64 bytes per block
+
+      for (let w = 0; w < 16; w++) {
+        const dstBase = posBase + w * 4;
+        const wordByteOff = w * 4;
+
+        // Chunk 0
+        const off0 = chunkOffsets[0] + blockByteOff + wordByteOff;
+        mem32[dstBase] =
+          input[off0] | (input[off0 + 1] << 8) | (input[off0 + 2] << 16) | (input[off0 + 3] << 24);
+
+        // Chunk 1
+        const off1 = chunkOffsets[1] + blockByteOff + wordByteOff;
+        mem32[dstBase + 1] =
+          input[off1] | (input[off1 + 1] << 8) | (input[off1 + 2] << 16) | (input[off1 + 3] << 24);
+
+        // Chunk 2
+        const off2 = chunkOffsets[2] + blockByteOff + wordByteOff;
+        mem32[dstBase + 2] =
+          input[off2] | (input[off2 + 1] << 8) | (input[off2 + 2] << 16) | (input[off2 + 3] << 24);
+
+        // Chunk 3
+        const off3 = chunkOffsets[3] + blockByteOff + wordByteOff;
+        mem32[dstBase + 3] =
+          input[off3] | (input[off3 + 1] << 8) | (input[off3 + 2] << 16) | (input[off3 + 3] << 24);
+      }
+    }
+  }
+}
+
+// Pre-computed memory offsets for SIMD operations (single-block mode)
+const SIMD_CV_BASE = SIMD_MEMORY.CHAINING_VALUES / 4;
+const SIMD_OUT_BASE = SIMD_MEMORY.OUTPUT / 4;
+const SIMD_COUNTER_LOW_BASE = SIMD_MEMORY.COUNTER_LOW / 4;
+const SIMD_COUNTER_HIGH_BASE = SIMD_MEMORY.COUNTER_HIGH / 4;
+const SIMD_BLOCK_LEN_BASE = SIMD_MEMORY.BLOCK_LEN / 4;
+
+// Pre-computed memory offsets for batch SIMD operations (16-block mode)
+const BATCH_CV_BASE = SIMD_MEMORY.BATCH_CV / 4;
+const BATCH_COUNTER_LOW_BASE = SIMD_MEMORY.BATCH_COUNTER_LOW / 4;
+const BATCH_FLAGS_BASE_OFFSET = SIMD_MEMORY.BATCH_FLAGS_BASE / 4;
+const BATCH_OUTPUT_BASE = SIMD_MEMORY.BATCH_OUTPUT / 4;
+
+// Reusable arrays for batch processing
+const batchChunkOffsets = new Uint32Array(4);
+const SIMD_FLAGS_BASE = SIMD_MEMORY.FLAGS / 4;
+
+/**
+ * Set up chaining values in SIMD memory (transposed layout).
+ * Optimized: unrolled loops for common case of 4 chunks.
+ * cvs is flat: [cv0_word0..cv0_word7, cv1_word0..cv1_word7, ...]
+ */
+function setupSimdCvs(
+  cvs: Uint32Array, // Flat array: 4 × 8 words
+  mem32: Uint32Array,
+  count: number,
+): void {
+  // Unrolled for 4 chunks (common case)
+  if (count === 4) {
+    for (let w = 0; w < 8; w++) {
+      const base = SIMD_CV_BASE + w * 4;
+      mem32[base] = cvs[w]; // cv0[w]
+      mem32[base + 1] = cvs[8 + w]; // cv1[w]
+      mem32[base + 2] = cvs[16 + w]; // cv2[w]
+      mem32[base + 3] = cvs[24 + w]; // cv3[w]
+    }
+  } else {
+    for (let w = 0; w < 8; w++) {
+      const base = SIMD_CV_BASE + w * 4;
+      for (let c = 0; c < count; c++) {
+        mem32[base + c] = cvs[c * 8 + w];
+      }
+      for (let c = count; c < 4; c++) {
+        mem32[base + c] = 0;
+      }
+    }
+  }
+}
+
+/**
+ * Set up SIMD parameters (counters, flags, block lengths).
+ */
+function setupSimdParams(
+  mem32: Uint32Array,
+  counters: Uint32Array,
+  blockLens: Uint32Array,
+  flagsArr: Uint32Array,
+  count: number,
+): void {
+  // Most chunk counters fit in 32 bits, so counter high is usually 0
+  for (let i = 0; i < count; i++) {
+    mem32[SIMD_COUNTER_LOW_BASE + i] = counters[i];
+    mem32[SIMD_COUNTER_HIGH_BASE + i] = 0; // Assume counters fit in 32 bits
+    mem32[SIMD_BLOCK_LEN_BASE + i] = blockLens[i];
+    mem32[SIMD_FLAGS_BASE + i] = flagsArr[i];
+  }
+  // Zero unused slots
+  for (let i = count; i < 4; i++) {
+    mem32[SIMD_COUNTER_LOW_BASE + i] = 0;
+    mem32[SIMD_COUNTER_HIGH_BASE + i] = 0;
+    mem32[SIMD_BLOCK_LEN_BASE + i] = 0;
+    mem32[SIMD_FLAGS_BASE + i] = 0;
+  }
+}
+
+/**
+ * Read output CVs from SIMD memory (untranspose).
+ */
+function readSimdOutputCvs(
+  mem32: Uint32Array,
+  outputCvs: Uint32Array, // Flat array: 4 × 8 words
+  count: number,
+): void {
+  // Unrolled for 4 chunks (common case)
+  if (count === 4) {
+    for (let w = 0; w < 8; w++) {
+      const base = SIMD_OUT_BASE + w * 4;
+      outputCvs[w] = mem32[base];
+      outputCvs[8 + w] = mem32[base + 1];
+      outputCvs[16 + w] = mem32[base + 2];
+      outputCvs[24 + w] = mem32[base + 3];
+    }
+  } else {
+    for (let w = 0; w < 8; w++) {
+      const base = SIMD_OUT_BASE + w * 4;
+      for (let c = 0; c < count; c++) {
+        outputCvs[c * 8 + w] = mem32[base + c];
+      }
+    }
+  }
+}
+
+function getBlockWords(): Uint32Array {
+  if (!blockWords) {
+    blockWords = new Uint32Array(16);
+  }
+  return blockWords;
+}
+
+/**
+ * Hash a single chunk (up to 1024 bytes) with pre-created inputWords view.
+ * This is the optimized version that avoids creating Uint32Array views per chunk.
+ * (Fleek optimization Step 8)
+ */
+function hashChunkWithWords(
+  input: Uint8Array,
+  inputWords: Uint32Array | null, // Pre-created view of entire input
+  inputOffset: number,
+  inputLen: number,
+  chunkCounter: number,
+  flags: number,
+  cv: Uint32Array,
+  cvOffset: number,
+): void {
+  // Use reusable temporary CV for intermediate blocks (single-threaded safe)
+  reusableTempCv.set(IV);
+
+  // Process full blocks
+  const fullBlocks = inputLen >>> 6; // inputLen / 64
+  const remainder = inputLen & 63; // inputLen % 64
+
+  // Calculate word offset for this chunk within the pre-created view
+  const chunkWordOffset = inputOffset >>> 2;
+
+  // Fast path for full chunks with aligned little-endian input
+  if (inputWords && remainder === 0 && inputLen === CHUNK_LEN) {
+    // All 16 blocks are full, use fast path exclusively
+    let wordOff = chunkWordOffset;
+    // Block 0 (CHUNK_START)
+    compress(
+      reusableTempCv,
+      0,
+      inputWords,
+      wordOff,
+      reusableTempCv,
+      0,
+      false,
+      chunkCounter,
+      BLOCK_LEN,
+      flags | CHUNK_START,
+    );
+    wordOff += 16;
+    // Blocks 1-14 (no special flags)
+    for (let i = 1; i < 15; i++) {
+      compress(
+        reusableTempCv,
+        0,
+        inputWords,
+        wordOff,
+        reusableTempCv,
+        0,
+        false,
+        chunkCounter,
+        BLOCK_LEN,
+        flags,
+      );
+      wordOff += 16;
+    }
+    // Block 15 (CHUNK_END)
+    compress(
+      reusableTempCv,
+      0,
+      inputWords,
+      wordOff,
+      reusableTempCv,
+      0,
+      false,
+      chunkCounter,
+      BLOCK_LEN,
+      flags | CHUNK_END,
+    );
+
+    cv.set(reusableTempCv, cvOffset);
+    return;
+  }
+
+  // Slower path for partial chunks or non-aligned input
+  const totalBlocks = fullBlocks + (remainder > 0 ? 1 : 0);
+  const block = getBlockWords();
+
+  for (let blockIdx = 0; blockIdx < totalBlocks; blockIdx++) {
+    const isFirst = blockIdx === 0;
+    const isLast = blockIdx === totalBlocks - 1;
+    const blockStart = blockIdx << 6;
+    const blockLen = isLast && remainder > 0 ? remainder : BLOCK_LEN;
+
+    // Determine flags for this block
+    let blockFlags = flags;
+    if (isFirst) blockFlags |= CHUNK_START;
+    if (isLast) blockFlags |= CHUNK_END;
+
+    // Load block words
+    if (isLast && remainder > 0) {
+      // Partial final block - need zero padding
+      readLittleEndianWordsPartial(input, inputOffset + blockStart, blockLen, block);
+    } else if (inputWords && chunkWordOffset + (blockStart >>> 2) + 16 <= inputWords.length) {
+      // Fast path: use pre-created view directly
+      compress(
+        reusableTempCv,
+        0,
+        inputWords,
+        chunkWordOffset + (blockStart >>> 2),
+        reusableTempCv,
+        0,
+        false,
+        chunkCounter,
+        blockLen,
+        blockFlags,
+      );
+      continue;
+    } else {
+      readLittleEndianWordsFull(input, inputOffset + blockStart, block);
+    }
+
+    compress(
+      reusableTempCv,
+      0,
+      block,
+      0,
+      reusableTempCv,
+      0,
+      false,
+      chunkCounter,
+      blockLen,
+      blockFlags,
+    );
+  }
+
+  // Copy result to output
+  cv.set(reusableTempCv, cvOffset);
+}
+
+/**
+ * Hash input using pure JavaScript.
+ * Handles the full Merkle tree construction.
+ */
+function hashPureJS(input: Uint8Array, outputLen: number): Uint8Array {
+  const inputLen = input.length;
+
+  // Special case: empty input
+  if (inputLen === 0) {
+    const block = getBlockWords();
+    block.fill(0);
+    // Use reusable output buffer for common 32-byte case
+    const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+
+    compress(IV, 0, block, 0, out, 0, outputLen > 32, 0, 0, CHUNK_START | CHUNK_END | ROOT);
+
+    // Return result - use pre-created view for common 32-byte case
+    if (outputLen === 32 && IS_LITTLE_ENDIAN) {
+      return reusableOut8View.slice();
+    }
+    const result = new Uint8Array(outputLen);
+    if (IS_LITTLE_ENDIAN) {
+      result.set(new Uint8Array(out.buffer, 0, outputLen));
+    } else {
+      writeLittleEndianBytesPartial(out, 0, result, 0, outputLen);
+    }
+    return result;
+  }
+
+  // Calculate number of chunks
+  const numChunks = Math.ceil(inputLen / CHUNK_LEN);
+
+  // Single chunk optimization
+  if (numChunks === 1) {
+    // Use reusable output buffer for common 32-byte case
+    const cv = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+    hashChunkRoot(input, 0, inputLen, 0, 0, cv, outputLen > 32);
+
+    // Return result - use pre-created view for common 32-byte case
+    if (outputLen === 32 && IS_LITTLE_ENDIAN) {
+      return reusableOut8View.slice();
+    }
+    const result = new Uint8Array(outputLen);
+    if (IS_LITTLE_ENDIAN) {
+      result.set(new Uint8Array(cv.buffer, 0, outputLen));
+    } else {
+      writeLittleEndianBytesPartial(cv, 0, result, 0, outputLen);
+    }
+    return result;
+  }
+
+  // Multiple chunks - need Merkle tree
+  // Use the global contiguous CV stack (no allocation)
+  const stack = HYPER_CV_STACK;
+  let stackLen = 0;
+
+  // Use reusable buffers (single-threaded safe)
+  const chunkCv = reusableChunkCv;
+  const parentBlock = reusablePureParentBlock;
+  const parentCv = reusablePureParentCv;
+
+  // Create Uint32Array view ONCE for entire input (Fleek optimization Step 8)
+  // This avoids creating views inside each chunk/block processing
+  let inputWords: Uint32Array | null = null;
+  const canUseFastPath = IS_LITTLE_ENDIAN && input.byteOffset % 4 === 0;
+  if (canUseFastPath) {
+    inputWords = new Uint32Array(input.buffer, input.byteOffset, inputLen >>> 2);
+  }
+
+  // Determine how many full chunks we have
+  const fullChunks = inputLen >>> 10; // inputLen / 1024
+  const lastChunkLen = inputLen & 1023; // inputLen % 1024
+
+  // Process all full chunks with fast path (inlined for performance)
+  if (canUseFastPath && inputWords) {
+    for (let chunkIdx = 0; chunkIdx < fullChunks; chunkIdx++) {
+      // Inline chunk processing for full chunks
+      chunkCv.set(IV);
+      let wordOff = chunkIdx << 8; // chunkIdx * 256 (CHUNK_LEN/4)
+
+      // Block 0 (CHUNK_START)
+      compress(
+        chunkCv,
+        0,
+        inputWords,
+        wordOff,
+        chunkCv,
+        0,
+        false,
+        chunkIdx,
+        BLOCK_LEN,
+        CHUNK_START,
+      );
+      wordOff += 16;
+      // Blocks 1-14 (no special flags)
+      for (let b = 1; b < 15; b++) {
+        compress(chunkCv, 0, inputWords, wordOff, chunkCv, 0, false, chunkIdx, BLOCK_LEN, 0);
+        wordOff += 16;
+      }
+      // Block 15 (CHUNK_END)
+      compress(chunkCv, 0, inputWords, wordOff, chunkCv, 0, false, chunkIdx, BLOCK_LEN, CHUNK_END);
+
+      // Merge completed subtrees (avoid subarray by using index math)
+      let totalChunks = chunkIdx + 1;
+      let cvSrcOff = 0;
+      let cvSrc = chunkCv;
+
+      // Check if this is the last chunk overall
+      const isLastChunk = chunkIdx === fullChunks - 1 && lastChunkLen === 0;
+
+      while ((totalChunks & 1) === 0 && stackLen > 0) {
+        // Skip final merge if it would produce the root; let finalization handle it with ROOT flag
+        if (stackLen === 1 && isLastChunk) {
+          break;
+        }
+        stackLen--;
+        const stackOff = stackLen * 8;
+        // Copy left CV from stack to parentBlock[0..7] (unrolled)
+        copyCV8(stack, stackOff, parentBlock, 0);
+        // Copy current CV to parentBlock[8..15] (unrolled)
+        copyCV8(cvSrc, cvSrcOff, parentBlock, 8);
+
+        compress(IV, 0, parentBlock, 0, parentCv, 0, false, 0, BLOCK_LEN, PARENT);
+        cvSrc = parentCv;
+        cvSrcOff = 0;
+        totalChunks >>>= 1;
+      }
+
+      // Push CV to stack (unrolled)
+      const stackOff = stackLen * 8;
+      copyCV8(cvSrc, cvSrcOff, stack, stackOff);
+      stackLen++;
+    }
+
+    // Process last partial chunk if any
+    if (lastChunkLen > 0) {
+      hashChunkWithWords(
+        input,
+        inputWords,
+        fullChunks * CHUNK_LEN,
+        lastChunkLen,
+        fullChunks,
+        0,
+        chunkCv,
+        0,
+      );
+
+      let totalChunks = fullChunks + 1;
+      let newCv = chunkCv;
+      let newCvOffset = 0;
+
+      while ((totalChunks & 1) === 0 && stackLen > 0) {
+        // Skip final merge; this IS the last chunk, let finalization handle ROOT flag
+        if (stackLen === 1) {
+          break;
+        }
+        stackLen--;
+        const stackOff = stackLen * 8;
+        // Copy from stack to parentBlock[0..7] (unrolled)
+        copyCV8(stack, stackOff, parentBlock, 0);
+        // Copy from newCv to parentBlock[8..15] (unrolled)
+        copyCV8(newCv, newCvOffset, parentBlock, 8);
+        compress(IV, 0, parentBlock, 0, parentCv, 0, false, 0, BLOCK_LEN, PARENT);
+        newCv = parentCv;
+        newCvOffset = 0;
+        totalChunks >>>= 1;
+      }
+
+      // Push CV to stack (unrolled)
+      const pushOff = stackLen * 8;
+      copyCV8(newCv, newCvOffset, stack, pushOff);
+      stackLen++;
+    }
+  } else {
+    // Slow path for unaligned or big-endian
+    for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
+      const chunkStart = chunkIdx * CHUNK_LEN;
+      const chunkLen = Math.min(CHUNK_LEN, inputLen - chunkStart);
+
+      hashChunkWithWords(input, inputWords, chunkStart, chunkLen, chunkIdx, 0, chunkCv, 0);
+
+      // Merge completed subtrees
+      let totalChunks = chunkIdx + 1;
+      let newCv = chunkCv;
+      let newCvOffset = 0;
+
+      // Check if this is the last chunk
+      const isLastChunk = chunkIdx === numChunks - 1;
+
+      while ((totalChunks & 1) === 0 && stackLen > 0) {
+        // Skip final merge if it would produce the root; let finalization handle it with ROOT flag
+        if (stackLen === 1 && isLastChunk) {
+          break;
+        }
+        stackLen--;
+        const stackOff = stackLen * 8;
+        // Copy from stack to parentBlock[0..7] (unrolled)
+        copyCV8(stack, stackOff, parentBlock, 0);
+        // Copy from newCv to parentBlock[8..15] (unrolled)
+        copyCV8(newCv, newCvOffset, parentBlock, 8);
+        compress(IV, 0, parentBlock, 0, parentCv, 0, false, 0, BLOCK_LEN, PARENT);
+        newCv = parentCv;
+        newCvOffset = 0;
+        totalChunks >>>= 1;
+      }
+
+      // Push CV to stack (unrolled)
+      const pushOff = stackLen * 8;
+      copyCV8(newCv, newCvOffset, stack, pushOff);
+      stackLen++;
+    }
+  }
+
+  // Finalize: merge remaining stack entries
+  while (stackLen > 1) {
+    stackLen--;
+    const rightOff = stackLen * 8;
+    stackLen--;
+    const leftOff = stackLen * 8;
+    // Copy left CV to parentBlock[0..7] and right CV to parentBlock[8..15] (unrolled)
+    copyCV8(stack, leftOff, parentBlock, 0);
+    copyCV8(stack, rightOff, parentBlock, 8);
+
+    if (stackLen === 0) {
+      // This is the root - use reusable output buffer for common 32-byte case
+      const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+      compress(IV, 0, parentBlock, 0, out, 0, outputLen > 32, 0, BLOCK_LEN, PARENT | ROOT);
+
+      // Return result - use pre-created view for common 32-byte case
+      if (outputLen === 32 && IS_LITTLE_ENDIAN) {
+        return reusableOut8View.slice();
+      }
+      const result = new Uint8Array(outputLen);
+      if (IS_LITTLE_ENDIAN) {
+        result.set(new Uint8Array(out.buffer, 0, outputLen));
+      } else {
+        writeLittleEndianBytesPartial(out, 0, result, 0, outputLen);
+      }
+      return result;
+    }
+
+    compress(IV, 0, parentBlock, 0, parentCv, 0, false, 0, BLOCK_LEN, PARENT);
+
+    // Push to stack (unrolled)
+    copyCV8(parentCv, 0, stack, stackLen * 8);
+    stackLen++;
+  }
+
+  // Single entry in stack - this is the root
+  const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+  const lastBlock = getBlockWords();
+  lastBlock.fill(0);
+  // Copy first 8 words from stack (unrolled)
+  copyCV8(stack, 0, lastBlock, 0);
+
+  compress(IV, 0, lastBlock, 0, out, 0, outputLen > 32, 0, BLOCK_LEN, ROOT);
+
+  // Return result - use pre-created view for common 32-byte case
+  if (outputLen === 32 && IS_LITTLE_ENDIAN) {
+    return reusableOut8View.slice();
+  }
+  const result = new Uint8Array(outputLen);
+  if (IS_LITTLE_ENDIAN) {
+    result.set(new Uint8Array(out.buffer, 0, outputLen));
+  } else {
+    writeLittleEndianBytesPartial(out, 0, result, 0, outputLen);
+  }
+  return result;
+}
+
+/**
+ * Hash a single chunk that is also the root (single chunk input).
+ */
+function hashChunkRoot(
+  input: Uint8Array,
+  inputOffset: number,
+  inputLen: number,
+  chunkCounter: number,
+  flags: number,
+  out: Uint32Array,
+  fullOutput: boolean,
+): void {
+  // Use reusable tempCv (single-threaded safe)
+  reusableTempCv.set(IV);
+
+  const block = getBlockWords();
+
+  // Process full blocks
+  const fullBlocks = inputLen >>> 6;
+  const remainder = inputLen & 63;
+  const totalBlocks = fullBlocks + (remainder > 0 ? 1 : 0) || 1; // At least 1 block
+
+  // Create a Uint32Array view if possible
+  let inputWords: Uint32Array | null = null;
+  if (IS_LITTLE_ENDIAN && (input.byteOffset + inputOffset) % 4 === 0 && inputLen >= 4) {
+    inputWords = new Uint32Array(input.buffer, input.byteOffset + inputOffset, inputLen >>> 2);
+  }
+
+  for (let blockIdx = 0; blockIdx < totalBlocks; blockIdx++) {
+    const isFirst = blockIdx === 0;
+    const isLast = blockIdx === totalBlocks - 1;
+    const blockStart = blockIdx << 6;
+    const blockLen = isLast ? remainder || (inputLen > 0 ? BLOCK_LEN : 0) : BLOCK_LEN;
+
+    // Determine flags
+    let blockFlags = flags;
+    if (isFirst) blockFlags |= CHUNK_START;
+    if (isLast) blockFlags |= CHUNK_END | ROOT;
+
+    // Load block
+    if (isLast && remainder > 0) {
+      readLittleEndianWordsPartial(input, inputOffset + blockStart, blockLen, block);
+    } else if (inputLen === 0) {
+      block.fill(0);
+    } else if (inputWords && (blockStart >>> 2) + 16 <= inputWords.length) {
+      // Fast path
+      compress(
+        reusableTempCv,
+        0,
+        inputWords,
+        blockStart >>> 2,
+        isLast ? out : reusableTempCv,
+        0,
+        isLast && fullOutput,
+        chunkCounter,
+        blockLen,
+        blockFlags,
+      );
+      continue;
+    } else {
+      readLittleEndianWordsFull(input, inputOffset + blockStart, block);
+    }
+
+    compress(
+      reusableTempCv,
+      0,
+      block,
+      0,
+      isLast ? out : reusableTempCv,
+      0,
+      isLast && fullOutput,
+      chunkCounter,
+      blockLen,
+      blockFlags,
+    );
+  }
+}
+
+/**
+ * Hash using WASM SIMD - processes 4 chunks in parallel.
+ * Falls back to pure JS if SIMD fails.
+ */
+function hashSimd(input: Uint8Array, outputLen: number): Uint8Array {
+  const mem = getSimdMemory();
+  if (!mem) {
+    return hashPureJS(input, outputLen);
+  }
+
+  const { view32 } = mem;
+  const inputLen = input.length;
+  const numChunks = Math.ceil(inputLen / CHUNK_LEN);
+
+  // For small inputs, pure JS is faster (no transpose overhead)
+  if (numChunks < 4) {
+    return hashPureJS(input, outputLen);
+  }
+
+  // Try to use WASM arena buffers (zero JS heap allocation)
+  // Falls back to JS buffers if arena not available
+  const arena = getArenaBuffers();
+  const useWasmParent = arena !== null; // Use WASM parent compress when arena available
+  let stack: Uint32Array;
+  let tempCvs: Uint32Array;
+  let parentBlock: Uint32Array;
+  let parentCv: Uint32Array;
+
+  if (arena) {
+    // Use WASM-backed arena buffers
+    stack = arena.cvStack;
+    tempCvs = arena.tempCvs;
+    parentBlock = arena.parentBlock;
+    parentCv = arena.chunkCv;
+  } else {
+    // Fallback to JS heap buffers - use global contiguous stack (no allocation)
+    stack = HYPER_CV_STACK;
+    tempCvs = reusableSimdCvs;
+    parentBlock = reusableSimdParentBlock;
+    parentCv = reusableSimdParentCv;
+  }
+
+  let stackLen = 0;
+
+  // Use TypedArrays instead of JS arrays for block parameters
+  const offsets = reusableOffsets;
+  const counters = reusableCounters;
+  const blockLens = reusableBlockLens;
+  const flagsArr = reusableFlags;
+
+  // Create Uint32Array view once for entire hash call (optimization: avoid allocation in hot loop)
+  const inputWords =
+    IS_LITTLE_ENDIAN && input.byteOffset % 4 === 0
+      ? new Uint32Array(input.buffer, input.byteOffset, input.byteLength >>> 2)
+      : null;
+
+  // Calculate number of full chunks (1024 bytes each)
+  const numFullChunks = inputLen >>> 10; // inputLen / 1024
+
+  // Process chunks in groups of 4
+  let chunkIdx = 0;
+  while (chunkIdx < numChunks) {
+    const groupSize = Math.min(4, numChunks - chunkIdx);
+
+    // === BATCH FAST PATH: 4 full chunks ===
+    // Use compressChunks4x for groups of exactly 4 full chunks
+    // This reduces 16 WASM calls to 1 per group
+    const canUseBatchPath = groupSize === 4 && chunkIdx + 4 <= numFullChunks;
+
+    if (canUseBatchPath) {
+      // Set up chunk offsets for batch transpose
+      batchChunkOffsets[0] = chunkIdx * CHUNK_LEN;
+      batchChunkOffsets[1] = (chunkIdx + 1) * CHUNK_LEN;
+      batchChunkOffsets[2] = (chunkIdx + 2) * CHUNK_LEN;
+      batchChunkOffsets[3] = (chunkIdx + 3) * CHUNK_LEN;
+
+      // Transpose all 64 blocks (4 chunks × 16 blocks) at once
+      transposeBatchToSimd(input, batchChunkOffsets, view32, inputWords);
+
+      // Set up initial CVs (IV) in batch memory - transposed layout
+      for (let w = 0; w < 8; w++) {
+        const ivWord = IV[w];
+        const base = BATCH_CV_BASE + w * 4;
+        view32[base] = ivWord;
+        view32[base + 1] = ivWord;
+        view32[base + 2] = ivWord;
+        view32[base + 3] = ivWord;
+      }
+
+      // Set up counters in batch memory
+      view32[BATCH_COUNTER_LOW_BASE] = chunkIdx;
+      view32[BATCH_COUNTER_LOW_BASE + 1] = chunkIdx + 1;
+      view32[BATCH_COUNTER_LOW_BASE + 2] = chunkIdx + 2;
+      view32[BATCH_COUNTER_LOW_BASE + 3] = chunkIdx + 3;
+
+      // Set up base flags (0 - no keyed hashing)
+      view32[BATCH_FLAGS_BASE_OFFSET] = 0;
+      view32[BATCH_FLAGS_BASE_OFFSET + 1] = 0;
+      view32[BATCH_FLAGS_BASE_OFFSET + 2] = 0;
+      view32[BATCH_FLAGS_BASE_OFFSET + 3] = 0;
+
+      // Run batched compress (16 blocks × 4 chunks in one call!)
+      runCompressChunks4x();
+
+      // Read output CVs from batch output - untranspose to tempCvs
+      for (let w = 0; w < 8; w++) {
+        const base = BATCH_OUTPUT_BASE + w * 4;
+        tempCvs[w] = view32[base]; // chunk 0
+        tempCvs[8 + w] = view32[base + 1]; // chunk 1
+        tempCvs[16 + w] = view32[base + 2]; // chunk 2
+        tempCvs[24 + w] = view32[base + 3]; // chunk 3
+      }
+    } else {
+      // === STANDARD PATH: block-by-block processing ===
+      // Used for partial chunks or groups < 4
+
+      // Initialize CVs for this group to IV (flat array: 4 × 8 words)
+      for (let g = 0; g < groupSize; g++) {
+        const base = g * 8;
+        tempCvs[base] = IV[0];
+        tempCvs[base + 1] = IV[1];
+        tempCvs[base + 2] = IV[2];
+        tempCvs[base + 3] = IV[3];
+        tempCvs[base + 4] = IV[4];
+        tempCvs[base + 5] = IV[5];
+        tempCvs[base + 6] = IV[6];
+        tempCvs[base + 7] = IV[7];
+      }
+
+      // Process all 16 blocks of each chunk in this group
+      for (let blockIdx = 0; blockIdx < 16; blockIdx++) {
+        // Calculate block offsets and parameters (reuse arrays)
+
+        for (let g = 0; g < groupSize; g++) {
+          const thisChunkIdx = chunkIdx + g;
+          const chunkStart = thisChunkIdx * CHUNK_LEN;
+          const chunkLen = Math.min(CHUNK_LEN, inputLen - chunkStart);
+          const thisBlockStart = chunkStart + blockIdx * BLOCK_LEN;
+
+          // Determine block length for this specific block
+          const blockStartInChunk = blockIdx * BLOCK_LEN;
+          let thisBlockLen = BLOCK_LEN;
+          if (blockStartInChunk >= chunkLen) {
+            thisBlockLen = 0;
+          } else if (blockStartInChunk + BLOCK_LEN > chunkLen) {
+            thisBlockLen = chunkLen - blockStartInChunk;
+          }
+
+          offsets[g] = thisBlockStart;
+          counters[g] = thisChunkIdx;
+
+          // Determine flags
+          let flags = 0;
+          if (blockIdx === 0) flags |= CHUNK_START;
+          const totalBlocksInChunk = Math.ceil(chunkLen / BLOCK_LEN) || 1;
+          if (blockIdx === totalBlocksInChunk - 1) flags |= CHUNK_END;
+
+          blockLens[g] = thisBlockLen;
+          flagsArr[g] = flags;
+        }
+
+        // Check if any blocks need processing
+        if (blockLens[0] === 0 && blockLens[1] === 0 && blockLens[2] === 0 && blockLens[3] === 0)
+          continue;
+
+        // Transpose blocks into SIMD memory (pass pre-created view to avoid allocation)
+        transposeBlocksToSimd(input, offsets, blockLens, view32, groupSize, inputWords);
+
+        // Set up CVs in SIMD memory
+        setupSimdCvs(tempCvs, view32, groupSize);
+
+        // Set up parameters
+        setupSimdParams(view32, counters, blockLens, flagsArr, groupSize);
+
+        // Run SIMD compress
+        runCompress4x();
+
+        // Read output CVs back
+        readSimdOutputCvs(view32, simdChunkCvs, groupSize);
+
+        // Update tempCvs - copy from simdChunkCvs (both are flat 32-word arrays)
+        // simdChunkCvs layout matches tempCvs: [cv0_w0..cv0_w7, cv1_w0..cv1_w7, ...]
+        // IMPORTANT: Only update CVs for chunks that had data in this block!
+        // Skipping this check would corrupt CVs for partial chunks after their final block.
+        for (let g = 0; g < groupSize; g++) {
+          if (blockLens[g] === 0) continue; // Don't update CV for chunks with no data in this block
+          const base = g * 8;
+          tempCvs[base] = simdChunkCvs[base];
+          tempCvs[base + 1] = simdChunkCvs[base + 1];
+          tempCvs[base + 2] = simdChunkCvs[base + 2];
+          tempCvs[base + 3] = simdChunkCvs[base + 3];
+          tempCvs[base + 4] = simdChunkCvs[base + 4];
+          tempCvs[base + 5] = simdChunkCvs[base + 5];
+          tempCvs[base + 6] = simdChunkCvs[base + 6];
+          tempCvs[base + 7] = simdChunkCvs[base + 7];
+        }
+      }
+    }
+
+    // Merge each chunk's CV into the Merkle tree
+    for (let g = 0; g < groupSize; g++) {
+      const thisChunkIdx = chunkIdx + g;
+
+      // Merge completed subtrees
+      let totalChunks = thisChunkIdx + 1;
+      // Track newCv source - either from tempCvs or parentCv
+      let newCvBase = g * 8; // Offset into tempCvs
+      let newCvSrc = tempCvs;
+
+      // Check if this is the last chunk
+      const isLastChunk = thisChunkIdx === numChunks - 1;
+
+      while ((totalChunks & 1) === 0 && stackLen > 0) {
+        // Skip final merge if it would produce the root; let finalization handle it with ROOT flag
+        if (stackLen === 1 && isLastChunk) {
+          break;
+        }
+        // Pop left child
+        stackLen--;
+        const stackOff = stackLen * 8;
+        // Copy from stack to parentBlock[0..7] (unrolled)
+        copyCV8(stack, stackOff, parentBlock, 0);
+        // Copy from newCv source to parentBlock[8..15] (unrolled)
+        copyCV8(newCvSrc, newCvBase, parentBlock, 8);
+
+        if (useWasmParent) {
+          // WASM parent compress - data already in arena buffers
+          runCompressParent();
+        } else {
+          compress(IV, 0, parentBlock, 0, parentCv, 0, false, 0, BLOCK_LEN, PARENT);
+        }
+
+        newCvSrc = parentCv;
+        newCvBase = 0;
+        totalChunks >>>= 1;
+      }
+
+      // Push to stack (unrolled)
+      const pushOff = stackLen * 8;
+      copyCV8(newCvSrc, newCvBase, stack, pushOff);
+      stackLen++;
+    }
+
+    chunkIdx += groupSize;
+  }
+
+  // Finalize: merge remaining stack entries
+  while (stackLen > 1) {
+    stackLen--;
+    const rightOff = stackLen * 8;
+    stackLen--;
+    const leftOff = stackLen * 8;
+    // Copy left CV to parentBlock[0..7] and right CV to parentBlock[8..15] (unrolled)
+    copyCV8(stack, leftOff, parentBlock, 0);
+    copyCV8(stack, rightOff, parentBlock, 8);
+
+    if (stackLen === 0) {
+      // This is the root - use reusable output buffer
+      const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+      compress(IV, 0, parentBlock, 0, out, 0, outputLen > 32, 0, BLOCK_LEN, PARENT | ROOT);
+
+      // Return result - use pre-created view for common 32-byte case
+      if (outputLen === 32 && IS_LITTLE_ENDIAN) {
+        return reusableOut8View.slice();
+      }
+      const result = new Uint8Array(outputLen);
+      if (IS_LITTLE_ENDIAN) {
+        result.set(new Uint8Array(out.buffer, 0, outputLen));
+      } else {
+        writeLittleEndianBytesPartial(out, 0, result, 0, outputLen);
+      }
+      return result;
+    }
+
+    if (useWasmParent) {
+      // WASM parent compress - data already in arena buffers
+      runCompressParent();
+    } else {
+      compress(IV, 0, parentBlock, 0, parentCv, 0, false, 0, BLOCK_LEN, PARENT);
+    }
+
+    // Push to stack (unrolled)
+    copyCV8(parentCv, 0, stack, stackLen * 8);
+    stackLen++;
+  }
+
+  // Single entry in stack - finalize as root
+  if (stackLen === 1) {
+    const block = getBlockWords();
+    block.fill(0);
+    // Copy first 8 words from stack (unrolled)
+    copyCV8(stack, 0, block, 0);
+
+    // Use reusable output buffer
+    const out = outputLen === 32 ? reusableOut8 : new Uint32Array(outputLen > 32 ? 16 : 8);
+    compress(IV, 0, block, 0, out, 0, outputLen > 32, 0, BLOCK_LEN, ROOT);
+
+    // Return result - use pre-created view for common 32-byte case
+    if (outputLen === 32 && IS_LITTLE_ENDIAN) {
+      return reusableOut8View.slice();
+    }
+    const result = new Uint8Array(outputLen);
+    if (IS_LITTLE_ENDIAN) {
+      result.set(new Uint8Array(out.buffer, 0, outputLen));
+    } else {
+      writeLittleEndianBytesPartial(out, 0, result, 0, outputLen);
+    }
+    return result;
+  }
+
+  // Should not reach here
+  return hashPureJS(input, outputLen);
+}
+
+/**
+ * Hash input data and return the result.
+ * Automatically uses WASM SIMD for large inputs when available.
+ *
+ * @param input - Data to hash
+ * @param outputLength - Number of bytes to output (default: 32)
+ * @returns The hash output
+ */
+export function hash(input: Uint8Array, outputLength: number = OUT_LEN): Uint8Array {
+  // For large inputs, use SIMD for ~1.5x performance improvement
+  if (input.length >= SIMD_THRESHOLD && ensureSimdSync()) {
+    return hashSimd(input, outputLength);
+  }
+  return hashPureJS(input, outputLength);
+}
+
+/**
+ * Pre-warm SIMD initialization (call early to avoid latency later).
+ */
+export function warmupSimd(): boolean {
+  return ensureSimdSync();
+}
+
+/**
+ * Hash input data directly into a caller-provided output buffer.
+ * Zero-allocation for the common 32-byte case - ideal for performance-critical code.
+ *
+ * @param input - Data to hash
+ * @param output - Pre-allocated output buffer (must be at least outputLength bytes)
+ * @param outputLength - Number of bytes to output (default: 32, max: output.length)
+ */
+export function hashInto(
+  input: Uint8Array,
+  output: Uint8Array,
+  outputLength: number = OUT_LEN,
+): void {
+  // Validate output buffer
+  if (output.length < outputLength) {
+    throw new Error(`Output buffer too small: ${output.length} < ${outputLength}`);
+  }
+
+  // For large inputs, use SIMD for ~1.5x performance improvement
+  if (input.length >= SIMD_THRESHOLD && ensureSimdSync()) {
+    hashSimdInto(input, output, outputLength);
+    return;
+  }
+
+  hashPureJSInto(input, output, outputLength);
+}
+
+/**
+ * Internal: Hash using pure JS, writing directly to output buffer.
+ */
+function hashPureJSInto(input: Uint8Array, output: Uint8Array, outputLen: number): void {
+  const inputLen = input.length;
+
+  // Special case: empty input
+  if (inputLen === 0) {
+    const block = getBlockWords();
+    block.fill(0);
+    const out = outputLen <= 32 ? reusableOut8 : new Uint32Array(16);
+
+    compress(IV, 0, block, 0, out, 0, outputLen > 32, 0, 0, CHUNK_START | CHUNK_END | ROOT);
+
+    // Copy result to output
+    if (IS_LITTLE_ENDIAN) {
+      output.set(new Uint8Array(out.buffer, out.byteOffset, outputLen));
+    } else {
+      writeLittleEndianBytesPartial(out, 0, output, 0, outputLen);
+    }
+    return;
+  }
+
+  // Calculate number of chunks
+  const numChunks = Math.ceil(inputLen / CHUNK_LEN);
+
+  // Single chunk optimization
+  if (numChunks === 1) {
+    const cv = outputLen <= 32 ? reusableOut8 : new Uint32Array(16);
+    hashChunkRoot(input, 0, inputLen, 0, 0, cv, outputLen > 32);
+
+    // Copy result to output
+    if (IS_LITTLE_ENDIAN) {
+      output.set(new Uint8Array(cv.buffer, cv.byteOffset, outputLen));
+    } else {
+      writeLittleEndianBytesPartial(cv, 0, output, 0, outputLen);
+    }
+    return;
+  }
+
+  // Multiple chunks - delegate to hashPureJS and copy result
+  const result = hashPureJS(input, outputLen);
+  output.set(result);
+}
+
+/**
+ * Internal: Hash using SIMD, writing directly to output buffer.
+ */
+function hashSimdInto(input: Uint8Array, output: Uint8Array, outputLen: number): void {
+  // Delegate to hashSimd and copy result (SIMD path already optimized)
+  const result = hashSimd(input, outputLen);
+  output.set(result);
+}

node_modules/@huggingface/blake3-jit/src/hasher.ts

@@ -0,0 +1,576 @@
+/**
+ * BLAKE3 Hasher - Incremental hashing with support for all modes
+ *
+ * Supports:
+ * - Regular hashing
+ * - Keyed hashing (MAC)
+ * - Key derivation (derive_key)
+ * - XOF (eXtendable Output Function) mode
+ */
+
+import { compress } from "./compress.js";
+import {
+  IV,
+  CHUNK_START,
+  CHUNK_END,
+  PARENT,
+  ROOT,
+  KEYED_HASH,
+  DERIVE_KEY_CONTEXT,
+  DERIVE_KEY_MATERIAL,
+  BLOCK_LEN,
+  CHUNK_LEN,
+  OUT_LEN,
+  KEY_LEN,
+  MAX_DEPTH,
+} from "./constants.js";
+import {
+  IS_LITTLE_ENDIAN,
+  readLittleEndianWordsFull,
+  writeLittleEndianBytesPartial,
+  encodeUTF8,
+} from "./utils.js";
+
+/**
+ * Output state for XOF (eXtendable Output Function) mode.
+ * Allows reading arbitrary amounts of output.
+ */
+export class XofReader {
+  private inputCv: Uint32Array;
+  private blockWords: Uint32Array;
+  private counter: number;
+  private blockLen: number;
+  private flags: number;
+  private outputBlock: Uint32Array;
+  private outputBlockOffset: number;
+
+  constructor(
+    inputCv: Uint32Array,
+    blockWords: Uint32Array,
+    counter: number,
+    blockLen: number,
+    flags: number,
+  ) {
+    this.inputCv = inputCv;
+    this.blockWords = blockWords;
+    this.counter = counter;
+    this.blockLen = blockLen;
+    this.flags = flags | ROOT;
+    this.outputBlock = new Uint32Array(16);
+    this.outputBlockOffset = 64; // Forces generation on first read
+  }
+
+  /**
+   * Read the next `length` bytes of output.
+   */
+  read(length: number): Uint8Array {
+    const output = new Uint8Array(length);
+    let outputOffset = 0;
+
+    while (outputOffset < length) {
+      // Generate new output block if needed
+      if (this.outputBlockOffset >= 64) {
+        compress(
+          this.inputCv,
+          0,
+          this.blockWords,
+          0,
+          this.outputBlock,
+          0,
+          true, // full 64-byte output
+          this.counter++,
+          this.blockLen,
+          this.flags,
+        );
+        this.outputBlockOffset = 0;
+      }
+
+      // Copy bytes from output block
+      const available = 64 - this.outputBlockOffset;
+      const toCopy = Math.min(available, length - outputOffset);
+
+      // Optimized copy using writeLittleEndianBytesPartial
+      const wordOffset = this.outputBlockOffset >>> 2;
+      const byteWithinWord = this.outputBlockOffset & 3;
+
+      if (byteWithinWord === 0 && toCopy >= 4) {
+        // Aligned copy - can use word-at-a-time
+        const fullWords = toCopy >>> 2;
+        writeLittleEndianBytesPartial(
+          this.outputBlock,
+          wordOffset,
+          output,
+          outputOffset,
+          fullWords << 2,
+        );
+        const bytesCopied = fullWords << 2;
+        outputOffset += bytesCopied;
+        this.outputBlockOffset += bytesCopied;
+      } else {
+        // Byte-by-byte for unaligned access
+        for (let i = 0; i < toCopy; i++) {
+          const wordIdx = (this.outputBlockOffset + i) >>> 2;
+          const byteIdx = (this.outputBlockOffset + i) & 3;
+          output[outputOffset + i] = (this.outputBlock[wordIdx] >>> (byteIdx << 3)) & 0xff;
+        }
+        outputOffset += toCopy;
+        this.outputBlockOffset += toCopy;
+      }
+    }
+
+    return output;
+  }
+}
+
+/**
+ * Chunk state for processing input data.
+ * Each chunk is 1024 bytes and produces an 8-word chaining value.
+ */
+class ChunkState {
+  chainingValue: Uint32Array;
+  chunkCounter: number;
+  blockWords: Uint32Array;
+  blockLen: number;
+  blocksCompressed: number;
+  flags: number;
+
+  constructor(keyWords: Uint32Array, chunkCounter: number, flags: number) {
+    this.chainingValue = new Uint32Array(keyWords);
+    this.chunkCounter = chunkCounter;
+    this.blockWords = new Uint32Array(16);
+    this.blockLen = 0;
+    this.blocksCompressed = 0;
+    this.flags = flags;
+  }
+
+  resetTo(keyWords: Uint32Array, chunkCounter: number, flags: number): void {
+    this.chainingValue.set(keyWords);
+    this.chunkCounter = chunkCounter;
+    this.blockLen = 0;
+    this.blocksCompressed = 0;
+    this.flags = flags;
+  }
+
+  /**
+   * Get the flags for the current block.
+   */
+  private startFlag(): number {
+    return this.blocksCompressed === 0 ? CHUNK_START : 0;
+  }
+
+  /**
+   * Update the chunk state with input data.
+   * Returns the number of bytes consumed.
+   */
+  update(input: Uint8Array, inputOffset: number, inputLen: number): number {
+    let consumed = 0;
+
+    while (inputLen > 0) {
+      // If we have a full block, compress it
+      if (this.blockLen === BLOCK_LEN) {
+        compress(
+          this.chainingValue,
+          0,
+          this.blockWords,
+          0,
+          this.chainingValue,
+          0,
+          false,
+          this.chunkCounter,
+          BLOCK_LEN,
+          this.flags | this.startFlag(),
+        );
+        this.blocksCompressed++;
+        this.blockLen = 0;
+      }
+
+      // Fill the block buffer
+      const want = BLOCK_LEN - this.blockLen;
+      const take = Math.min(want, inputLen);
+
+      if (this.blockLen === 0 && take === BLOCK_LEN) {
+        readLittleEndianWordsFull(input, inputOffset, this.blockWords);
+      } else {
+        // Partial block - byte-by-byte into correct position
+        for (let i = 0; i < take; i++) {
+          const pos = this.blockLen + i;
+          const wordIdx = pos >>> 2;
+          const byteIdx = pos & 3;
+
+          if (byteIdx === 0) {
+            this.blockWords[wordIdx] = input[inputOffset + i];
+          } else {
+            this.blockWords[wordIdx] |= input[inputOffset + i] << (byteIdx << 3);
+          }
+        }
+      }
+
+      this.blockLen += take;
+      inputOffset += take;
+      inputLen -= take;
+      consumed += take;
+    }
+
+    return consumed;
+  }
+
+  /**
+   * Finalize this chunk and return its output.
+   * Returns 8 words (chaining value) or 16 words (if root).
+   */
+  output(): {
+    inputCv: Uint32Array;
+    blockWords: Uint32Array;
+    blockLen: number;
+    counter: number;
+    flags: number;
+  } {
+    // Zero-pad unused words in blockWords to avoid stale data from previous blocks
+    // This is necessary when a partial block follows a full block within the same chunk
+    const usedWords = (this.blockLen + 3) >>> 2; // ceil(blockLen / 4)
+    for (let i = usedWords; i < 16; i++) {
+      this.blockWords[i] = 0;
+    }
+
+    return {
+      inputCv: this.chainingValue,
+      blockWords: this.blockWords,
+      blockLen: this.blockLen,
+      counter: this.chunkCounter,
+      flags: this.flags | this.startFlag() | CHUNK_END,
+    };
+  }
+
+  /**
+   * Get the number of bytes in this chunk.
+   */
+  len(): number {
+    return this.blocksCompressed * BLOCK_LEN + this.blockLen;
+  }
+}
+
+/**
+ * Main BLAKE3 Hasher class.
+ *
+ * Usage:
+ *   const hasher = new Hasher();
+ *   hasher.update(data);
+ *   const hash = hasher.finalize();
+ *
+ * Or with chaining:
+ *   const hash = new Hasher().update(data).finalize();
+ */
+export class Hasher {
+  private chunkState: ChunkState;
+  private keyWords: Uint32Array;
+  private cvStack: Uint32Array;
+  private cvStackLen: number;
+  private flags: number;
+  private parentBlock: Uint32Array;
+  private parentCv: Uint32Array;
+  private chunkCv: Uint32Array;
+  private outWords: Uint32Array;
+  private finalizeCv: Uint32Array;
+
+  /**
+   * Create a new Hasher.
+   *
+   * @param keyWords - Initial key words (IV for regular hashing)
+   * @param flags - Domain separation flags
+   */
+  constructor(keyWords?: Uint32Array, flags?: number) {
+    this.keyWords = keyWords ? new Uint32Array(keyWords) : new Uint32Array(IV);
+    this.flags = flags ?? 0;
+    this.chunkState = new ChunkState(this.keyWords, 0, this.flags);
+    this.cvStack = new Uint32Array(MAX_DEPTH * 8);
+    this.cvStackLen = 0;
+    this.parentBlock = new Uint32Array(16);
+    this.parentCv = new Uint32Array(8);
+    this.chunkCv = new Uint32Array(8);
+    this.outWords = new Uint32Array(16);
+    this.finalizeCv = new Uint32Array(8);
+  }
+
+  /**
+   * Reset the hasher to process a new message with the same key/flags.
+   * Reuses all internal buffers — zero allocations.
+   */
+  reset(): this {
+    this.chunkState.resetTo(this.keyWords, 0, this.flags);
+    this.cvStackLen = 0;
+    return this;
+  }
+
+  /**
+   * Create a new keyed hasher (MAC).
+   *
+   * @param key - 32-byte key
+   */
+  static newKeyed(key: Uint8Array): Hasher {
+    if (key.length !== KEY_LEN) {
+      throw new Error(`Key must be ${KEY_LEN} bytes, got ${key.length}`);
+    }
+
+    const keyWords = new Uint32Array(8);
+    if (IS_LITTLE_ENDIAN) {
+      const view = new Uint32Array(key.buffer, key.byteOffset, 8);
+      keyWords.set(view);
+    } else {
+      for (let i = 0; i < 8; i++) {
+        const off = i * 4;
+        keyWords[i] = key[off] | (key[off + 1] << 8) | (key[off + 2] << 16) | (key[off + 3] << 24);
+      }
+    }
+
+    return new Hasher(keyWords, KEYED_HASH);
+  }
+
+  /**
+   * Create a new key derivation hasher.
+   *
+   * @param context - Context string for domain separation
+   */
+  static newDeriveKey(context: string): Hasher {
+    // First, hash the context string with DERIVE_KEY_CONTEXT flag
+    const contextBytes = encodeUTF8(context);
+    const contextHasher = new Hasher(new Uint32Array(IV), DERIVE_KEY_CONTEXT);
+    contextHasher.update(contextBytes);
+
+    // Get the context key
+    const contextKey = new Uint32Array(8);
+    const output = contextHasher.finalizeOutput();
+    compress(
+      output.inputCv,
+      0,
+      output.blockWords,
+      0,
+      contextKey,
+      0,
+      false,
+      output.counter,
+      output.blockLen,
+      output.flags | ROOT,
+    );
+
+    // Return a hasher initialized with the context key
+    return new Hasher(contextKey, DERIVE_KEY_MATERIAL);
+  }
+
+  /**
+   * Push a chaining value onto the stack.
+   */
+  private pushCv(cv: Uint32Array, cvOffset: number): void {
+    this.cvStack.set(cv.subarray(cvOffset, cvOffset + 8), this.cvStackLen * 8);
+    this.cvStackLen++;
+  }
+
+  /**
+   * Pop a chaining value from the stack.
+   */
+  private popCv(out: Uint32Array, outOffset: number): void {
+    this.cvStackLen--;
+    out.set(this.cvStack.subarray(this.cvStackLen * 8, (this.cvStackLen + 1) * 8), outOffset);
+  }
+
+  /**
+   * Add a chunk's chaining value and merge completed subtrees.
+   */
+  private addChunkCv(newCv: Uint32Array, newCvOffset: number, totalChunks: number): void {
+    const parentBlock = this.parentBlock;
+    const parentCv = this.parentCv;
+
+    while ((totalChunks & 1) === 0) {
+      // Pop left child, new CV is right child
+      this.popCv(parentBlock, 0);
+      parentBlock.set(newCv.subarray(newCvOffset, newCvOffset + 8), 8);
+
+      compress(
+        this.keyWords,
+        0,
+        parentBlock,
+        0,
+        parentCv,
+        0,
+        false,
+        0,
+        BLOCK_LEN,
+        this.flags | PARENT,
+      );
+
+      newCv = parentCv;
+      newCvOffset = 0;
+      totalChunks >>>= 1;
+    }
+
+    this.pushCv(newCv, newCvOffset);
+  }
+
+  /**
+   * Update the hasher with input data.
+   *
+   * @param input - Data to hash
+   * @returns this (for chaining)
+   */
+  update(input: Uint8Array): this {
+    let inputOffset = 0;
+    let inputLen = input.length;
+
+    // Fill the current chunk
+    while (inputLen > 0) {
+      // If current chunk is full, finalize it and start a new one
+      if (this.chunkState.len() === CHUNK_LEN) {
+        const output = this.chunkState.output();
+        const chunkCv = this.chunkCv;
+
+        compress(
+          output.inputCv,
+          0,
+          output.blockWords,
+          0,
+          chunkCv,
+          0,
+          false,
+          output.counter,
+          output.blockLen,
+          output.flags,
+        );
+
+        const totalChunks = this.chunkState.chunkCounter + 1;
+        this.addChunkCv(chunkCv, 0, totalChunks);
+
+        this.chunkState.resetTo(this.keyWords, totalChunks, this.flags);
+      }
+
+      // Fill the current chunk
+      const want = CHUNK_LEN - this.chunkState.len();
+      const take = Math.min(want, inputLen);
+
+      this.chunkState.update(input, inputOffset, take);
+      inputOffset += take;
+      inputLen -= take;
+    }
+
+    return this;
+  }
+
+  /**
+   * Get the output parameters (for XOF mode or finalization).
+   */
+  private finalizeOutput(): {
+    inputCv: Uint32Array;
+    blockWords: Uint32Array;
+    blockLen: number;
+    counter: number;
+    flags: number;
+  } {
+    let output = this.chunkState.output();
+    let parentBlock = this.parentBlock;
+    let cv = this.finalizeCv;
+
+    // If there are chunks on the stack, merge them
+    if (this.cvStackLen > 0) {
+      // First compress the current chunk
+      compress(
+        output.inputCv,
+        0,
+        output.blockWords,
+        0,
+        cv,
+        0,
+        false,
+        output.counter,
+        output.blockLen,
+        output.flags,
+      );
+
+      // Merge with parent nodes from stack
+      while (this.cvStackLen > 0) {
+        this.cvStackLen--;
+        parentBlock.set(this.cvStack.subarray(this.cvStackLen * 8, (this.cvStackLen + 1) * 8), 0);
+        parentBlock.set(cv, 8);
+
+        if (this.cvStackLen > 0) {
+          compress(
+            this.keyWords,
+            0,
+            parentBlock,
+            0,
+            cv,
+            0,
+            false,
+            0,
+            BLOCK_LEN,
+            this.flags | PARENT,
+          );
+        } else {
+          // This is the root - return output params
+          return {
+            inputCv: this.keyWords,
+            blockWords: parentBlock,
+            blockLen: BLOCK_LEN,
+            counter: 0,
+            flags: this.flags | PARENT,
+          };
+        }
+      }
+    }
+
+    // Single chunk case
+    return output;
+  }
+
+  /**
+   * Finalize the hash and return the result.
+   *
+   * @param outputLength - Number of bytes to output (default: 32)
+   * @returns The hash output
+   */
+  finalize(outputLength: number = OUT_LEN): Uint8Array {
+    const output = this.finalizeOutput();
+    const result = new Uint8Array(outputLength);
+
+    if (outputLength <= 64) {
+      const outWords = this.outWords;
+      compress(
+        output.inputCv,
+        0,
+        output.blockWords,
+        0,
+        outWords,
+        0,
+        outputLength > 32, // full output if > 32 bytes
+        output.counter,
+        output.blockLen,
+        output.flags | ROOT,
+      );
+
+      if (IS_LITTLE_ENDIAN) {
+        const outBytes = new Uint8Array(outWords.buffer);
+        result.set(outBytes.subarray(0, outputLength));
+      } else {
+        writeLittleEndianBytesPartial(outWords, 0, result, 0, outputLength);
+      }
+    } else {
+      // Multiple blocks - use XOF
+      const xof = this.finalizeXof();
+      const full = xof.read(outputLength);
+      result.set(full);
+    }
+
+    return result;
+  }
+
+  /**
+   * Finalize and return an XOF reader for arbitrary-length output.
+   */
+  finalizeXof(): XofReader {
+    const output = this.finalizeOutput();
+    return new XofReader(
+      new Uint32Array(output.inputCv),
+      new Uint32Array(output.blockWords),
+      output.counter,
+      output.blockLen,
+      output.flags,
+    );
+  }
+}

node_modules/@huggingface/blake3-jit/src/index.ts

@@ -0,0 +1,106 @@
+/**
+ * BLAKE3 - The fastest pure JavaScript implementation
+ *
+ * Features:
+ * - All 3 modes: hash, keyed (MAC), derive_key
+ * - XOF (eXtendable Output Function) support
+ * - Automatic WASM SIMD acceleration for large inputs
+ * - Zero dependencies
+ * - Tree-shakeable exports
+ *
+ * @example
+ * ```typescript
+ * import { hash, createKeyed, createDeriveKey } from 'blake3-jit';
+ *
+ * // Simple hashing
+ * const digest = hash(new Uint8Array([1, 2, 3]));
+ *
+ * // Keyed hashing (MAC)
+ * const mac = createKeyed(key).update(data).finalize();
+ *
+ * // Key derivation
+ * const derived = createDeriveKey("my context").update(material).finalize(64);
+ * ```
+ */
+
+// Core exports
+export { Hasher, XofReader } from "./hasher.js";
+export { hash, hashInto, warmupSimd } from "./hash.js";
+
+// Convenience imports
+import { Hasher } from "./hasher.js";
+
+/**
+ * Create a new keyed hasher (MAC).
+ *
+ * @param key - 32-byte key
+ * @returns A new Hasher configured for keyed hashing
+ *
+ * @example
+ * ```typescript
+ * const key = new Uint8Array(32); // Your 32-byte key
+ * crypto.getRandomValues(key);
+ *
+ * const mac = createKeyed(key)
+ *   .update(message)
+ *   .finalize();
+ * ```
+ */
+export function createKeyed(key: Uint8Array): Hasher {
+  return Hasher.newKeyed(key);
+}
+
+/**
+ * Create a new key derivation hasher.
+ *
+ * @param context - Context string for domain separation
+ * @returns A new Hasher configured for key derivation
+ *
+ * @example
+ * ```typescript
+ * const derivedKey = createDeriveKey("my-app encryption key v1")
+ *   .update(inputKeyMaterial)
+ *   .finalize(32);
+ * ```
+ */
+export function createDeriveKey(context: string): Hasher {
+  return Hasher.newDeriveKey(context);
+}
+
+/**
+ * Create a new regular hasher for incremental hashing.
+ *
+ * @returns A new Hasher
+ *
+ * @example
+ * ```typescript
+ * const hasher = createHasher();
+ * hasher.update(chunk1);
+ * hasher.update(chunk2);
+ * const digest = hasher.finalize();
+ * ```
+ */
+export function createHasher(): Hasher {
+  return new Hasher();
+}
+
+// Import for default export
+import { hash, hashInto, warmupSimd } from "./hash.js";
+
+// Pre-warm SIMD in browser environments (non-blocking)
+// This avoids initialization latency on first large hash
+if (typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined") {
+  queueMicrotask(() => {
+    warmupSimd();
+  });
+}
+
+// Default export for convenience
+export default {
+  hash,
+  hashInto,
+  Hasher,
+  createHasher,
+  createKeyed,
+  createDeriveKey,
+};

node_modules/@huggingface/blake3-jit/src/utils.ts

@@ -0,0 +1,253 @@
+/**
+ * BLAKE3 Utility Functions
+ *
+ * Optimized for little-endian systems (most user-facing systems).
+ * BLAKE3 is little-endian friendly - on little-endian systems we can
+ * create Uint32Array views directly over input buffers.
+ */
+
+/**
+ * Detect system endianness at module load time.
+ * On little-endian systems, the byte 0x01 will be at index 0.
+ */
+export const IS_LITTLE_ENDIAN = new Uint8Array(new Uint32Array([0x01020304]).buffer)[0] === 0x04;
+
+/**
+ * Read 16 little-endian 32-bit words from a byte array into a Uint32Array.
+ * This is only needed on big-endian systems.
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset in input
+ * @param words - Destination Uint32Array (must have at least 16 elements)
+ */
+export function readLittleEndianWordsFull(
+  input: Uint8Array,
+  offset: number,
+  words: Uint32Array,
+): void {
+  for (let i = 0; i < 16; ++i, offset += 4) {
+    words[i] =
+      input[offset] |
+      (input[offset + 1] << 8) |
+      (input[offset + 2] << 16) |
+      (input[offset + 3] << 24);
+  }
+}
+
+/**
+ * Read N little-endian 32-bit words from a byte array.
+ * Handles partial reads (for final blocks).
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset
+ * @param words - Destination Uint32Array
+ * @param wordCount - Number of words to read
+ */
+export function readLittleEndianWords(
+  input: Uint8Array,
+  offset: number,
+  words: Uint32Array,
+  wordCount: number,
+): void {
+  for (let i = 0; i < wordCount; ++i, offset += 4) {
+    words[i] =
+      input[offset] |
+      (input[offset + 1] << 8) |
+      (input[offset + 2] << 16) |
+      (input[offset + 3] << 24);
+  }
+}
+
+/**
+ * Read a partial block with zero padding.
+ * Used for the final block when input length is not a multiple of 64.
+ *
+ * @param input - Source byte array
+ * @param offset - Starting byte offset
+ * @param length - Number of bytes to read (< 64)
+ * @param words - Destination Uint32Array (must have 16 elements)
+ */
+export function readLittleEndianWordsPartial(
+  input: Uint8Array,
+  offset: number,
+  length: number,
+  words: Uint32Array,
+): void {
+  // Zero out all words first
+  words.fill(0);
+
+  // Read full words
+  const fullWords = length >>> 2;
+  let i = 0;
+  for (; i < fullWords; ++i, offset += 4) {
+    words[i] =
+      input[offset] |
+      (input[offset + 1] << 8) |
+      (input[offset + 2] << 16) |
+      (input[offset + 3] << 24);
+  }
+
+  // Handle remaining bytes (0-3)
+  const remaining = length & 3;
+  if (remaining > 0) {
+    let word = input[offset];
+    if (remaining > 1) word |= input[offset + 1] << 8;
+    if (remaining > 2) word |= input[offset + 2] << 16;
+    words[i] = word;
+  }
+}
+
+/**
+ * Write 8 little-endian 32-bit words to a byte array.
+ *
+ * @param words - Source Uint32Array
+ * @param wordOffset - Starting word offset in source
+ * @param output - Destination byte array
+ * @param byteOffset - Starting byte offset in destination
+ */
+export function writeLittleEndianWords(
+  words: Uint32Array,
+  wordOffset: number,
+  output: Uint8Array,
+  byteOffset: number,
+): void {
+  for (let i = 0; i < 8; ++i, byteOffset += 4) {
+    const w = words[wordOffset + i];
+    output[byteOffset] = w & 0xff;
+    output[byteOffset + 1] = (w >>> 8) & 0xff;
+    output[byteOffset + 2] = (w >>> 16) & 0xff;
+    output[byteOffset + 3] = (w >>> 24) & 0xff;
+  }
+}
+
+/**
+ * Write N bytes from 32-bit words to output.
+ * Used for variable-length output (XOF mode).
+ *
+ * @param words - Source Uint32Array
+ * @param wordOffset - Starting word offset
+ * @param output - Destination byte array
+ * @param byteOffset - Starting byte offset in destination
+ * @param byteCount - Number of bytes to write
+ */
+export function writeLittleEndianBytesPartial(
+  words: Uint32Array,
+  wordOffset: number,
+  output: Uint8Array,
+  byteOffset: number,
+  byteCount: number,
+): void {
+  const fullWords = byteCount >>> 2;
+  let i = 0;
+
+  // Write full words
+  for (; i < fullWords; ++i, byteOffset += 4) {
+    const w = words[wordOffset + i];
+    output[byteOffset] = w & 0xff;
+    output[byteOffset + 1] = (w >>> 8) & 0xff;
+    output[byteOffset + 2] = (w >>> 16) & 0xff;
+    output[byteOffset + 3] = (w >>> 24) & 0xff;
+  }
+
+  // Write remaining bytes
+  const remaining = byteCount & 3;
+  if (remaining > 0) {
+    const w = words[wordOffset + i];
+    output[byteOffset] = w & 0xff;
+    if (remaining > 1) output[byteOffset + 1] = (w >>> 8) & 0xff;
+    if (remaining > 2) output[byteOffset + 2] = (w >>> 16) & 0xff;
+  }
+}
+
+/**
+ * Encode a UTF-8 string to Uint8Array.
+ * Used for derive_key context strings.
+ */
+export function encodeUTF8(str: string): Uint8Array {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(str);
+  }
+  // Fallback for older environments
+  const bytes: number[] = [];
+  for (let i = 0; i < str.length; i++) {
+    let c = str.charCodeAt(i);
+    if (c < 0x80) {
+      bytes.push(c);
+    } else if (c < 0x800) {
+      bytes.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
+    } else if (c < 0xd800 || c >= 0xe000) {
+      bytes.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+    } else {
+      // Surrogate pair
+      i++;
+      c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
+      bytes.push(
+        0xf0 | (c >> 18),
+        0x80 | ((c >> 12) & 0x3f),
+        0x80 | ((c >> 6) & 0x3f),
+        0x80 | (c & 0x3f),
+      );
+    }
+  }
+  return new Uint8Array(bytes);
+}
+
+/**
+ * De Bruijn lookup table for O(1) trailing zero count.
+ * The expression (n & -n) isolates the lowest set bit.
+ * Multiplying by the De Bruijn constant maps each power of 2 to a unique 5-bit index.
+ */
+const CTZ32_TABLE = new Uint8Array([
+  0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 31, 27, 13, 23, 21, 19, 16, 7, 26, 12,
+  18, 6, 11, 5, 10, 9,
+]);
+
+/**
+ * Count trailing zero bits in a 32-bit number using De Bruijn multiplication.
+ * This is O(1) and branchless for non-zero inputs.
+ *
+ * For Merkle tree merge: ctz32(chunkCounter) tells us how many merges to do.
+ */
+export function ctz32(n: number): number {
+  if (n === 0) return 32;
+  // Use unsigned right shift to handle negative numbers correctly
+  return CTZ32_TABLE[(((n & -n) * 0x077cb531) >>> 27) & 31];
+}
+
+/**
+ * Count trailing zero bits in a 64-bit number.
+ * Used to determine how many parent nodes to compute after adding a chunk.
+ *
+ * Note: JavaScript bitwise ops work on 32-bit signed integers,
+ * so we need to handle 64-bit numbers carefully.
+ */
+export function countTrailingZeros(n: number): number {
+  if (n === 0) return 64;
+
+  // For numbers that fit in 32 bits
+  const low = n | 0;
+  if (low !== 0) {
+    // Use Math.clz32 trick: ctz(x) = 31 - clz32(x & -x) for non-zero x
+    return 31 - Math.clz32(low & -low);
+  }
+
+  // High 32 bits
+  const high = (n / 0x100000000) | 0;
+  if (high !== 0) {
+    return 32 + (31 - Math.clz32(high & -high));
+  }
+
+  return 64;
+}
+
+/**
+ * Create a Uint32Array view of a Uint8Array.
+ * Only works correctly on little-endian systems when the offset is 4-byte aligned.
+ *
+ * @param arr - Source byte array
+ * @param byteOffset - Starting byte offset (must be 4-byte aligned)
+ * @param wordLength - Number of 32-bit words
+ */
+export function uint32View(arr: Uint8Array, byteOffset: number, wordLength: number): Uint32Array {
+  return new Uint32Array(arr.buffer, arr.byteOffset + byteOffset, wordLength);
+}

node_modules/@huggingface/blake3-jit/src/wasm-simd.ts

@@ -0,0 +1,1087 @@
+/**
+ * BLAKE3 WASM SIMD - Runtime bytecode generation
+ *
+ * Generates WebAssembly SIMD bytecode at runtime to process 4 compress
+ * operations in parallel using 128-bit SIMD vectors (i32x4).
+ *
+ * Key insight: One i32x4.add instruction performs 4 parallel additions,
+ * giving us 4x throughput for the same number of instructions.
+ *
+ * Memory layout (all values are transposed for SIMD access):
+ *   0-511:    4 x 16 message words (m0_0,m0_1,m0_2,m0_3, m1_0,m1_1,m1_2,m1_3, ...)
+ *   512-639:  4 x 8 chaining values
+ *   640-767:  4 x 8 output values
+ *   768-783:  4 x counter low
+ *   784-799:  4 x counter high
+ *   800-815:  4 x block length
+ *   816-831:  4 x flags
+ */
+
+// LEB128 encoding with minimum 2 bytes
+// This fixes a V8 quirk where single-byte values 64-127 cause issues
+// when followed by certain SIMD instructions
+function toLebU32Min2(n: number): number[] {
+  // Always use at least 2 bytes
+  return [(n & 0x7f) | 0x80, (n >>> 7) & 0x7f];
+}
+
+// LEB128 encoding padded to exactly 5 bytes (for backpatching)
+// Uses continuation bits for all but the last byte
+function toLebU32Padded5(n: number): number[] {
+  return [
+    (n & 0x7f) | 0x80,
+    ((n >>> 7) & 0x7f) | 0x80,
+    ((n >>> 14) & 0x7f) | 0x80,
+    ((n >>> 21) & 0x7f) | 0x80,
+    (n >>> 28) & 0x0f, // Last byte has no continuation bit
+  ];
+}
+
+// Signed LEB128 encoding for i32 constants (handles full 32-bit range)
+// WASM i32.const uses signed LEB128 immediate
+function toSignedLeb128_i32(n: number): number[] {
+  const bytes: number[] = [];
+  // Treat as signed 32-bit integer
+  let value = n | 0;
+  let more = true;
+  while (more) {
+    let byte = value & 0x7f;
+    // Arithmetic right shift preserves sign
+    value >>= 7;
+    // Check if we're done:
+    // - If value is 0 and sign bit of byte is clear, we're done
+    // - If value is -1 and sign bit of byte is set, we're done
+    if ((value === 0 && (byte & 0x40) === 0) || (value === -1 && (byte & 0x40) !== 0)) {
+      more = false;
+    } else {
+      byte |= 0x80;
+    }
+    bytes.push(byte);
+  }
+  return bytes;
+}
+
+// Precomputed message access order for all 7 rounds
+const MSG_ACCESS_ORDER = [
+  // Round 1: 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+  // Round 2: 2,6,3,10,7,0,4,13,1,11,12,5,9,14,15,8
+  2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8,
+  // Round 3: 3,4,10,12,13,2,7,14,6,5,9,0,11,15,8,1
+  3, 4, 10, 12, 13, 2, 7, 14, 6, 5, 9, 0, 11, 15, 8, 1,
+  // Round 4: 10,7,12,9,14,3,13,15,4,0,11,2,5,8,1,6
+  10, 7, 12, 9, 14, 3, 13, 15, 4, 0, 11, 2, 5, 8, 1, 6,
+  // Round 5: 12,13,9,11,15,10,14,8,7,2,5,3,0,1,6,4
+  12, 13, 9, 11, 15, 10, 14, 8, 7, 2, 5, 3, 0, 1, 6, 4,
+  // Round 6: 9,14,11,5,8,12,15,1,13,3,0,10,2,6,4,7
+  9, 14, 11, 5, 8, 12, 15, 1, 13, 3, 0, 10, 2, 6, 4, 7,
+  // Round 7: 11,15,5,0,1,9,8,6,14,10,2,12,3,4,7,13
+  11, 15, 5, 0, 1, 9, 8, 6, 14, 10, 2, 12, 3, 4, 7, 13,
+];
+
+// BLAKE3 Constants (used in generated WASM code)
+// CHUNK_START = 1, CHUNK_END = 2 are embedded directly in WASM bytecode
+
+/**
+ * Generate the WASM module bytecode with compress4x, compressChunks4x, and compressParent functions.
+ */
+function generateWasmBytes(): Uint8Array {
+  const code: number[] = [];
+
+  // Helper to append bytes
+  function put(bytes: number[]): void {
+    code.push(...bytes);
+  }
+
+  // WASM module header
+  put([0x00, 0x61, 0x73, 0x6d]); // Magic
+  put([0x01, 0x00, 0x00, 0x00]); // Version
+
+  // Section 1: Types
+  put([0x01]); // Section ID
+  put([0x04]); // Section size
+  put([0x01]); // 1 type
+  put([0x60, 0x00, 0x00]); // func () -> ()
+
+  // Section 2: Imports (memory from JS)
+  put([0x02]); // Section ID
+  put([0x0b]); // Section size
+  put([0x01]); // 1 import
+  put([0x02, 0x6a, 0x73]); // "js"
+  put([0x03, 0x6d, 0x65, 0x6d]); // "mem"
+  put([0x02, 0x00, 0x01]); // memory min=1, no max
+
+  // Section 3: Functions
+  put([0x03]); // Section ID
+  put([0x04]); // Section size (3 functions = 4 bytes)
+  put([0x03]); // 3 functions
+  put([0x00]); // Function 0: type index 0
+  put([0x00]); // Function 1: type index 0
+  put([0x00]); // Function 2: type index 0
+
+  // Section 7: Exports
+  // Size calculation: 1 (count) + (1+10+1+1) + (1+16+1+1) + (1+14+1+1) = 1 + 13 + 19 + 17 = 50 bytes
+  put([0x07]); // Section ID
+  put([0x32]); // Section size (50 bytes)
+  put([0x03]); // 3 exports
+  // "compress4x" -> func 0
+  put([0x0a]); // name length
+  put([0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x34, 0x78]); // "compress4x"
+  put([0x00, 0x00]); // func index 0
+  // "compressChunks4x" -> func 1
+  put([0x10]); // name length (16)
+  put([
+    0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x73, 0x34, 0x78,
+  ]); // "compressChunks4x"
+  put([0x00, 0x01]); // func index 1
+  // "compressParent" -> func 2
+  put([0x0e]); // name length (14)
+  put([0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74]); // "compressParent"
+  put([0x00, 0x02]); // func index 2
+
+  // Section 10: Code
+  put([0x0a]); // Section ID
+  // Reserve 5 bytes for section size (LEB128 u32)
+  const sectionSizeOffset = code.length;
+  put([0x00, 0x00, 0x00, 0x00, 0x00]);
+
+  put([0x03]); // 3 functions
+
+  // === Function 0: compress4x ===
+  // Reserve 5 bytes for function size
+  const funcSizeOffset = code.length;
+  put([0x00, 0x00, 0x00, 0x00, 0x00]);
+
+  const funcBodyStart = code.length;
+
+  // Local declarations: 32 v128 locals
+  // Variables $0-$15: message words (m0-m15)
+  // Variables $16-$31: state words (s0-s15)
+  put([0x01]); // 1 local declaration
+  put([0x20, 0x7b]); // 32 x v128
+
+  // ===== Function body =====
+
+  // Load message words from memory (offset 0-255)
+  // Each v128 is 16 bytes, so m[i] is at offset i*16
+  // Note: we use toLebU32Min2 to avoid V8 quirk with single-byte values 64-127
+  for (let i = 0; i < 16; i++) {
+    put([0x41, ...toLebU32Min2(i * 16)]); // i32.const offset (2+ byte LEB128)
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load align=4 offset=0
+    put([0x21, i]); // local.set $i
+  }
+
+  // Load chaining values (offset 512-639)
+  // cv[i] at offset 512 + i*16
+  for (let i = 0; i < 8; i++) {
+    put([0x41, ...toLebU32Min2(512 + i * 16)]); // i32.const offset
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+    put([0x21, 16 + i]); // local.set $(16+i)
+  }
+
+  // Initialize state[8-15] from IV and parameters
+  // s8-s11 = IV[0-3]
+  const IV = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
+  for (let i = 0; i < 4; i++) {
+    // Create v128 constant with all lanes set to IV[i]
+    const ivBytes = [];
+    for (let j = 0; j < 4; j++) {
+      ivBytes.push(IV[i] & 0xff);
+      ivBytes.push((IV[i] >>> 8) & 0xff);
+      ivBytes.push((IV[i] >>> 16) & 0xff);
+      ivBytes.push((IV[i] >>> 24) & 0xff);
+    }
+    put([0xfd, 0x0c, ...ivBytes]); // v128.const
+    put([0x21, 24 + i]); // local.set $(24+i) -> s8-s11
+  }
+
+  // s12 = counter_low (offset 768)
+  put([0x41, ...toLebU32Min2(768)]); // i32.const
+  put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+  put([0x21, 28]); // local.set $28 -> s12
+
+  // s13 = counter_high (offset 784)
+  put([0x41, ...toLebU32Min2(784)]); // i32.const
+  put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+  put([0x21, 29]); // local.set $29 -> s13
+
+  // s14 = block_len (offset 800)
+  put([0x41, ...toLebU32Min2(800)]); // i32.const
+  put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+  put([0x21, 30]); // local.set $30 -> s14
+
+  // s15 = flags (offset 816)
+  put([0x41, ...toLebU32Min2(816)]); // i32.const
+  put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+  put([0x21, 31]); // local.set $31 -> s15
+
+  // ===== 7 rounds of mixing =====
+
+  let msgIdx = 0; // Index into MSG_ACCESS_ORDER
+
+  // Helper to generate G function (inlined)
+  // G(a, b, c, d) with two message words
+  function g(a: number, b: number, c: number, d: number): void {
+    const mx = MSG_ACCESS_ORDER[msgIdx++];
+    const my = MSG_ACCESS_ORDER[msgIdx++];
+
+    // Variables: a,b,c,d are state indices (16-31), mx,my are message indices (0-15)
+
+    // First half of G
+    // s[a] = s[a] + s[b] + m[mx]
+    put([0x20, 16 + a]); // local.get s[a]
+    put([0x20, 16 + b]); // local.get s[b]
+    put([0xfd, 0xae, 0x01]); // i32x4.add
+    put([0x20, mx]); // local.get m[mx]
+    put([0xfd, 0xae, 0x01]); // i32x4.add
+    put([0x21, 16 + a]); // local.set s[a]
+
+    // s[d] = rotr(s[d] ^ s[a], 16) - using i8x16.shuffle (single instruction vs shift+or)
+    // ROTR16 pattern: [2,3,0,1, 6,7,4,5, 10,11,8,9, 14,15,12,13]
+    put([0x20, 16 + d]); // local.get s[d]
+    put([0x20, 16 + a]); // local.get s[a]
+    put([0xfd, 0x51]); // v128.xor
+    put([0x22, 16 + d]); // local.tee s[d]
+    put([0x20, 16 + d]); // local.get s[d] (second operand for shuffle)
+    put([0xfd, 0x0d, 2, 3, 0, 1, 6, 7, 4, 5, 10, 11, 8, 9, 14, 15, 12, 13]); // i8x16.shuffle ROTR16
+    put([0x21, 16 + d]); // local.set s[d]
+
+    // s[c] = s[c] + s[d]
+    put([0x20, 16 + c]); // local.get s[c]
+    put([0x20, 16 + d]); // local.get s[d]
+    put([0xfd, 0xae, 0x01]); // i32x4.add
+    put([0x21, 16 + c]); // local.set s[c]
+
+    // s[b] = (s[b] ^ s[c]) >>> 12
+    put([0x20, 16 + b]); // local.get s[b]
+    put([0x20, 16 + c]); // local.get s[c]
+    put([0xfd, 0x51]); // v128.xor
+    put([0x22, 16 + b]); // local.tee s[b]
+    put([0x41, 0x0c]); // i32.const 12
+    put([0xfd, 0xad, 0x01]); // i32x4.shr_u (opcode 173 = 0xAD)
+    put([0x20, 16 + b]); // local.get s[b]
+    put([0x41, 0x14]); // i32.const 20
+    put([0xfd, 0xab, 0x01]); // i32x4.shl
+    put([0xfd, 0x50]); // v128.or
+    put([0x21, 16 + b]); // local.set s[b]
+
+    // Second half of G
+    // s[a] = s[a] + s[b] + m[my]
+    put([0x20, 16 + a]); // local.get s[a]
+    put([0x20, 16 + b]); // local.get s[b]
+    put([0xfd, 0xae, 0x01]); // i32x4.add
+    put([0x20, my]); // local.get m[my]
+    put([0xfd, 0xae, 0x01]); // i32x4.add
+    put([0x21, 16 + a]); // local.set s[a]
+
+    // s[d] = rotr(s[d] ^ s[a], 8) - using i8x16.shuffle (single instruction vs shift+or)
+    // ROTR8 pattern: [1,2,3,0, 5,6,7,4, 9,10,11,8, 13,14,15,12]
+    put([0x20, 16 + d]); // local.get s[d]
+    put([0x20, 16 + a]); // local.get s[a]
+    put([0xfd, 0x51]); // v128.xor
+    put([0x22, 16 + d]); // local.tee s[d]
+    put([0x20, 16 + d]); // local.get s[d] (second operand for shuffle)
+    put([0xfd, 0x0d, 1, 2, 3, 0, 5, 6, 7, 4, 9, 10, 11, 8, 13, 14, 15, 12]); // i8x16.shuffle ROTR8
+    put([0x21, 16 + d]); // local.set s[d]
+
+    // s[c] = s[c] + s[d]
+    put([0x20, 16 + c]); // local.get s[c]
+    put([0x20, 16 + d]); // local.get s[d]
+    put([0xfd, 0xae, 0x01]); // i32x4.add
+    put([0x21, 16 + c]); // local.set s[c]
+
+    // s[b] = (s[b] ^ s[c]) >>> 7
+    put([0x20, 16 + b]); // local.get s[b]
+    put([0x20, 16 + c]); // local.get s[c]
+    put([0xfd, 0x51]); // v128.xor
+    put([0x22, 16 + b]); // local.tee s[b]
+    put([0x41, 0x07]); // i32.const 7
+    put([0xfd, 0xad, 0x01]); // i32x4.shr_u (opcode 173 = 0xAD)
+    put([0x20, 16 + b]); // local.get s[b]
+    put([0x41, 0x19]); // i32.const 25
+    put([0xfd, 0xab, 0x01]); // i32x4.shl
+    put([0xfd, 0x50]); // v128.or
+    put([0x21, 16 + b]); // local.set s[b]
+  }
+
+  // Generate all 7 rounds
+  for (let round = 0; round < 7; round++) {
+    // Column mixing
+    g(0, 4, 8, 12);
+    g(1, 5, 9, 13);
+    g(2, 6, 10, 14);
+    g(3, 7, 11, 15);
+
+    // Diagonal mixing
+    g(0, 5, 10, 15);
+    g(1, 6, 11, 12);
+    g(2, 7, 8, 13);
+    g(3, 4, 9, 14);
+  }
+
+  // ===== Final XOR and store output =====
+
+  // out[i] = s[i] ^ s[i+8] for i in 0..7
+  // Store at offset 640-767
+  for (let i = 0; i < 8; i++) {
+    put([0x41, ...toLebU32Min2(640 + i * 16)]); // i32.const offset
+    put([0x20, 16 + i]); // local.get s[i]
+    put([0x20, 24 + i]); // local.get s[i+8]
+    put([0xfd, 0x51]); // v128.xor
+    put([0xfd, 0x0b, 0x02, 0x00]); // v128.store align=4
+  }
+
+  // End of function
+  put([0x0b]); // end
+
+  // Fill in function 0 size using padded LEB128
+  const funcBodySize = code.length - funcBodyStart;
+  const funcSizeBytes = toLebU32Padded5(funcBodySize);
+  for (let i = 0; i < 5; i++) {
+    code[funcSizeOffset + i] = funcSizeBytes[i];
+  }
+
+  // === Function 1: compressChunks4x ===
+  // Reserve 5 bytes for function size
+  const func1SizeOffset = code.length;
+  put([0x00, 0x00, 0x00, 0x00, 0x00]);
+
+  const func1BodyStart = code.length;
+
+  // Generate the compressChunks4x function body
+  const compressChunksBody = generateCompressChunks4xBody();
+  put(compressChunksBody);
+
+  // Fill in function 1 size using padded LEB128
+  const func1BodySize = code.length - func1BodyStart;
+  const func1SizeBytes = toLebU32Padded5(func1BodySize);
+  for (let i = 0; i < 5; i++) {
+    code[func1SizeOffset + i] = func1SizeBytes[i];
+  }
+
+  // === Function 2: compressParent ===
+  // Reserve 5 bytes for function size
+  const func2SizeOffset = code.length;
+  put([0x00, 0x00, 0x00, 0x00, 0x00]);
+
+  const func2BodyStart = code.length;
+
+  // Generate the compressParent function body
+  const compressParentBody = generateCompressParentBody();
+  put(compressParentBody);
+
+  // Fill in function 2 size using padded LEB128
+  const func2BodySize = code.length - func2BodyStart;
+  const func2SizeBytes = toLebU32Padded5(func2BodySize);
+  for (let i = 0; i < 5; i++) {
+    code[func2SizeOffset + i] = func2SizeBytes[i];
+  }
+
+  // Fill in section size using padded LEB128
+  const sectionSize = code.length - sectionSizeOffset - 5;
+  const sectionSizeBytes = toLebU32Padded5(sectionSize);
+  for (let i = 0; i < 5; i++) {
+    code[sectionSizeOffset + i] = sectionSizeBytes[i];
+  }
+
+  return new Uint8Array(code);
+}
+
+/**
+ * Generate compressChunks4x WASM function body.
+ * Processes all 16 blocks of 4 chunks in a single call.
+ */
+function generateCompressChunks4xBody(): number[] {
+  const code: number[] = [];
+
+  function put(bytes: number[]): void {
+    code.push(...bytes);
+  }
+
+  // Local declarations: 32 v128 locals + 1 i32 for position
+  // Locals $0-$15: message words (reloaded each iteration)
+  // Locals $16-$31: state words (s0-s15)
+  // Local $32: position counter (i32)
+  put([0x02]); // 2 local declarations
+  put([0x20, 0x7b]); // 32 x v128
+  put([0x01, 0x7f]); // 1 x i32
+
+  const BATCH_BLOCK_WORDS = SIMD_MEMORY.BATCH_BLOCK_WORDS;
+  const BATCH_CV = SIMD_MEMORY.BATCH_CV;
+  const BATCH_COUNTER_LOW = SIMD_MEMORY.BATCH_COUNTER_LOW;
+  const BATCH_FLAGS_BASE = SIMD_MEMORY.BATCH_FLAGS_BASE;
+  const BATCH_OUTPUT = SIMD_MEMORY.BATCH_OUTPUT;
+
+  // IV constants (same as compress4x)
+  const IV = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
+
+  // Load initial CVs from BATCH_CV into locals $16-$23
+  for (let i = 0; i < 8; i++) {
+    put([0x41, ...toLebU32Min2(BATCH_CV + i * 16)]); // i32.const offset
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load align=4 offset=0
+    put([0x21, 16 + i]); // local.set $(16+i) -> s0-s7
+  }
+
+  // Initialize $32 (pos) = 0
+  put([0x41, 0x00]); // i32.const 0
+  put([0x21, 0x20]); // local.set $32
+
+  // block $done
+  put([0x02, 0x40]); // block void
+
+  // loop $continue
+  put([0x03, 0x40]); // loop void
+
+  // === Load message words for position $pos ===
+  // offset = BATCH_BLOCK_WORDS + pos * 256 + word * 16
+  for (let w = 0; w < 16; w++) {
+    put([0x20, 0x20]); // local.get $32 (pos)
+    put([0x41, ...toLebU32Min2(256)]); // i32.const 256
+    put([0x6c]); // i32.mul
+    put([0x41, ...toLebU32Min2(BATCH_BLOCK_WORDS + w * 16)]); // i32.const base + word*16
+    put([0x6a]); // i32.add
+    put([0xfd, 0x00, 0x02, 0x00]); // v128.load align=4 offset=0
+    put([0x21, w]); // local.set $w
+  }
+
+  // === Initialize state[8-15] ===
+  // s8-s11 = IV[0-3]
+  for (let i = 0; i < 4; i++) {
+    const ivBytes = [];
+    for (let j = 0; j < 4; j++) {
+      ivBytes.push(IV[i] & 0xff);
+      ivBytes.push((IV[i] >>> 8) & 0xff);
+      ivBytes.push((IV[i] >>> 16) & 0xff);
+      ivBytes.push((IV[i] >>> 24) & 0xff);
+    }
+    put([0xfd, 0x0c, ...ivBytes]); // v128.const
+    put([0x21, 24 + i]); // local.set $(24+i) -> s8-s11
+  }
+
+  // s12 = counter_low (from BATCH_COUNTER_LOW)
+  put([0x41, ...toLebU32Min2(BATCH_COUNTER_LOW)]); // i32.const
+  put([0xfd, 0x00, 0x02, 0x00]); // v128.load
+  put([0x21, 28]); // local.set $28 -> s12
+
+  // s13 = 0 (counter high - assume fits in 32 bits)
+  put([0xfd, 0x0c, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); // v128.const 0
+  put([0x21, 29]); // local.set $29 -> s13
+
+  // s14 = 64 (block_len = 64 for full blocks)
+  const blockLen64 = [];
+  for (let j = 0; j < 4; j++) {
+    blockLen64.push(64, 0, 0, 0); // 64 in little-endian
+  }
+  put([0xfd, 0x0c, ...blockLen64]); // v128.const [64,64,64,64]
+  put([0x21, 30]); // local.set $30 -> s14
+
+  // s15 = flags = base_flags | (pos == 0 ? 1 : 0) | (pos == 15 ? 2 : 0)
+  // First load base flags
+  put([0x41, ...toLebU32Min2(BATCH_FLAGS_BASE)]); // i32.const
+  put([0xfd, 0x00, 0x02, 0x00]); // v128.load base flags
+
+  // Compute position-dependent bits
+  // CHUNK_START (1) if pos == 0
+  put([0x20, 0x20]); // local.get $32 (pos)
+  put([0x45]); // i32.eqz -> 1 if pos==0, 0 otherwise
+  // CHUNK_END (2) if pos == 15
+  put([0x20, 0x20]); // local.get $32 (pos)
+  put([0x41, 0x0f]); // i32.const 15
+  put([0x46]); // i32.eq -> 1 if pos==15, 0 otherwise
+  put([0x41, 0x01]); // i32.const 1 (shift amount)
+  put([0x74]); // i32.shl -> 2 if pos==15, 0 otherwise
+  // OR the two bits together
+  put([0x72]); // i32.or -> combined position bits
+  // Splat to v128 and OR with base flags (stack: base_flags, bits)
+  put([0xfd, 0x11]); // i32x4.splat
+  put([0xfd, 0x50]); // v128.or
+  put([0x21, 31]); // local.set $31 -> s15
+
+  // === 7 rounds of mixing ===
+  let msgIdx = 0;
+
+  function g(a: number, b: number, c: number, d: number): void {
+    const mx = MSG_ACCESS_ORDER[msgIdx++];
+    const my = MSG_ACCESS_ORDER[msgIdx++];
+
+    // First half of G: s[a] = s[a] + s[b] + m[mx]
+    put([0x20, 16 + a]); // local.get s[a]
+    put([0x20, 16 + b]); // local.get s[b]
+    put([0xfd, 0xae, 0x01]); // i32x4.add
+    put([0x20, mx]); // local.get m[mx]
+    put([0xfd, 0xae, 0x01]); // i32x4.add
+    put([0x21, 16 + a]); // local.set s[a]
+
+    // s[d] = rotr(s[d] ^ s[a], 16) - byte shuffle
+    put([0x20, 16 + d]); // local.get s[d]
+    put([0x20, 16 + a]); // local.get s[a]
+    put([0xfd, 0x51]); // v128.xor
+    put([0x22, 16 + d]); // local.tee s[d]
+    put([0x20, 16 + d]); // local.get s[d]
+    put([0xfd, 0x0d, 2, 3, 0, 1, 6, 7, 4, 5, 10, 11, 8, 9, 14, 15, 12, 13]); // i8x16.shuffle ROTR16
+    put([0x21, 16 + d]); // local.set s[d]
+
+    // s[c] = s[c] + s[d]
+    put([0x20, 16 + c]); // local.get s[c]
+    put([0x20, 16 + d]); // local.get s[d]
+    put([0xfd, 0xae, 0x01]); // i32x4.add
+    put([0x21, 16 + c]); // local.set s[c]
+
+    // s[b] = rotr(s[b] ^ s[c], 12)
+    put([0x20, 16 + b]); // local.get s[b]
+    put([0x20, 16 + c]); // local.get s[c]
+    put([0xfd, 0x51]); // v128.xor
+    put([0x22, 16 + b]); // local.tee s[b]
+    put([0x41, 0x0c]); // i32.const 12
+    put([0xfd, 0xad, 0x01]); // i32x4.shr_u (opcode 173 = 0xAD)
+    put([0x20, 16 + b]); // local.get s[b]
+    put([0x41, 0x14]); // i32.const 20
+    put([0xfd, 0xab, 0x01]); // i32x4.shl
+    put([0xfd, 0x50]); // v128.or
+    put([0x21, 16 + b]); // local.set s[b]
+
+    // Second half: s[a] = s[a] + s[b] + m[my]
+    put([0x20, 16 + a]); // local.get s[a]
+    put([0x20, 16 + b]); // local.get s[b]
+    put([0xfd, 0xae, 0x01]); // i32x4.add
+    put([0x20, my]); // local.get m[my]
+    put([0xfd, 0xae, 0x01]); // i32x4.add
+    put([0x21, 16 + a]); // local.set s[a]
+
+    // s[d] = rotr(s[d] ^ s[a], 8) - byte shuffle
+    put([0x20, 16 + d]); // local.get s[d]
+    put([0x20, 16 + a]); // local.get s[a]
+    put([0xfd, 0x51]); // v128.xor
+    put([0x22, 16 + d]); // local.tee s[d]
+    put([0x20, 16 + d]); // local.get s[d]
+    put([0xfd, 0x0d, 1, 2, 3, 0, 5, 6, 7, 4, 9, 10, 11, 8, 13, 14, 15, 12]); // i8x16.shuffle ROTR8
+    put([0x21, 16 + d]); // local.set s[d]
+
+    // s[c] = s[c] + s[d]
+    put([0x20, 16 + c]); // local.get s[c]
+    put([0x20, 16 + d]); // local.get s[d]
+    put([0xfd, 0xae, 0x01]); // i32x4.add
+    put([0x21, 16 + c]); // local.set s[c]
+
+    // s[b] = rotr(s[b] ^ s[c], 7)
+    put([0x20, 16 + b]); // local.get s[b]
+    put([0x20, 16 + c]); // local.get s[c]
+    put([0xfd, 0x51]); // v128.xor
+    put([0x22, 16 + b]); // local.tee s[b]
+    put([0x41, 0x07]); // i32.const 7
+    put([0xfd, 0xad, 0x01]); // i32x4.shr_u (opcode 173 = 0xAD)
+    put([0x20, 16 + b]); // local.get s[b]
+    put([0x41, 0x19]); // i32.const 25
+    put([0xfd, 0xab, 0x01]); // i32x4.shl
+    put([0xfd, 0x50]); // v128.or
+    put([0x21, 16 + b]); // local.set s[b]
+  }
+
+  // Generate all 7 rounds
+  for (let round = 0; round < 7; round++) {
+    // Column mixing
+    g(0, 4, 8, 12);
+    g(1, 5, 9, 13);
+    g(2, 6, 10, 14);
+    g(3, 7, 11, 15);
+    // Diagonal mixing
+    g(0, 5, 10, 15);
+    g(1, 6, 11, 12);
+    g(2, 7, 8, 13);
+    g(3, 4, 9, 14);
+  }
+
+  // === Update CVs: cv[i] = s[i] ^ s[i+8] ===
+  // Store back to state locals $16-$23 (the CV positions)
+  for (let i = 0; i < 8; i++) {
+    put([0x20, 16 + i]); // local.get s[i]
+    put([0x20, 24 + i]); // local.get s[i+8]
+    put([0xfd, 0x51]); // v128.xor
+    put([0x21, 16 + i]); // local.set $(16+i) - update CV
+  }
+
+  // === Loop control: pos++, continue if pos < 16 ===
+  put([0x20, 0x20]); // local.get $32 (pos)
+  put([0x41, 0x01]); // i32.const 1
+  put([0x6a]); // i32.add
+  put([0x22, 0x20]); // local.tee $32 (pos)
+  put([0x41, 0x10]); // i32.const 16
+  put([0x49]); // i32.lt_u
+  put([0x0d, 0x00]); // br_if 0 (continue loop)
+
+  // end loop
+  put([0x0b]); // end
+
+  // end block
+  put([0x0b]); // end
+
+  // === Store final CVs to BATCH_OUTPUT ===
+  for (let i = 0; i < 8; i++) {
+    put([0x41, ...toLebU32Min2(BATCH_OUTPUT + i * 16)]); // i32.const offset
+    put([0x20, 16 + i]); // local.get $(16+i) - CV word
+    put([0xfd, 0x0b, 0x02, 0x00]); // v128.store align=4
+  }
+
+  // end function
+  put([0x0b]); // end
+
+  return code;
+}
+
+/**
+ * Generate compressParent WASM function body.
+ * Performs a single parent node compression using scalar i32 operations.
+ * Reads 16 words from PARENT_BLOCK, writes 8 words to CHUNK_CV.
+ * Uses IV, counter=0, blockLen=64, flags=PARENT(4).
+ */
+function generateCompressParentBody(): number[] {
+  const code: number[] = [];
+
+  function put(bytes: number[]): void {
+    code.push(...bytes);
+  }
+
+  // Local declarations: 32 i32 locals for state (s0-s15) and message (m0-m15)
+  put([0x01]); // 1 local declaration
+  put([0x20, 0x7f]); // 32 x i32
+
+  // Message word indices: 0-15, State indices: 16-31
+  // Locals $0-$15: message words (m0-m15)
+  // Locals $16-$31: state words (s0-s15)
+
+  const PARENT_BLOCK_OFFSET = SIMD_MEMORY.PARENT_BLOCK;
+  const CHUNK_CV_OFFSET = SIMD_MEMORY.CHUNK_CV;
+
+  // BLAKE3 IV
+  const IV = [
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+  ];
+
+  // Load message words from PARENT_BLOCK (16 words at offset 7264)
+  for (let i = 0; i < 16; i++) {
+    put([0x41, ...toLebU32Min2(PARENT_BLOCK_OFFSET + i * 4)]); // i32.const offset
+    put([0x28, 0x02, 0x00]); // i32.load align=4 offset=0
+    put([0x21, i]); // local.set $i (m0-m15)
+  }
+
+  // Initialize state s0-s7 = IV[0-7]
+  for (let i = 0; i < 8; i++) {
+    put([0x41, ...toSignedLeb128_i32(IV[i])]); // i32.const IV[i]
+    put([0x21, 16 + i]); // local.set $(16+i) -> s0-s7
+  }
+
+  // Initialize state s8-s11 = IV[0-3]
+  for (let i = 0; i < 4; i++) {
+    put([0x41, ...toSignedLeb128_i32(IV[i])]); // i32.const IV[i]
+    put([0x21, 24 + i]); // local.set $(24+i) -> s8-s11
+  }
+
+  // s12 = counter_low = 0
+  put([0x41, 0x00]); // i32.const 0
+  put([0x21, 28]); // local.set $28 -> s12
+
+  // s13 = counter_high = 0
+  put([0x41, 0x00]); // i32.const 0
+  put([0x21, 29]); // local.set $29 -> s13
+
+  // s14 = block_len = 64
+  // Note: 0x40 alone is -64 in signed LEB128 (bit 6 is sign bit)
+  // For 64, we need [0xC0, 0x00] to avoid sign extension
+  put([0x41, 0xc0, 0x00]); // i32.const 64
+  put([0x21, 30]); // local.set $30 -> s14
+
+  // s15 = flags = PARENT = 4
+  put([0x41, 0x04]); // i32.const 4
+  put([0x21, 31]); // local.set $31 -> s15
+
+  // Helper to generate scalar G function (inlined)
+  // G(a, b, c, d, mx, my) where a,b,c,d are state indices 0-15, mx,my are message indices 0-15
+  function g(a: number, b: number, c: number, d: number, mx: number, my: number): void {
+    const sa = 16 + a,
+      sb = 16 + b,
+      sc = 16 + c,
+      sd = 16 + d;
+
+    // s[a] = (s[a] + s[b] + m[mx]) >>> 0
+    put([0x20, sa]); // local.get s[a]
+    put([0x20, sb]); // local.get s[b]
+    put([0x6a]); // i32.add
+    put([0x20, mx]); // local.get m[mx]
+    put([0x6a]); // i32.add
+    put([0x21, sa]); // local.set s[a]
+
+    // s[d] = rotr(s[d] ^ s[a], 16)
+    put([0x20, sd]); // local.get s[d]
+    put([0x20, sa]); // local.get s[a]
+    put([0x73]); // i32.xor
+    put([0x41, 0x10]); // i32.const 16
+    put([0x78]); // i32.rotr
+    put([0x21, sd]); // local.set s[d]
+
+    // s[c] = (s[c] + s[d]) >>> 0
+    put([0x20, sc]); // local.get s[c]
+    put([0x20, sd]); // local.get s[d]
+    put([0x6a]); // i32.add
+    put([0x21, sc]); // local.set s[c]
+
+    // s[b] = rotr(s[b] ^ s[c], 12)
+    put([0x20, sb]); // local.get s[b]
+    put([0x20, sc]); // local.get s[c]
+    put([0x73]); // i32.xor
+    put([0x41, 0x0c]); // i32.const 12
+    put([0x78]); // i32.rotr
+    put([0x21, sb]); // local.set s[b]
+
+    // s[a] = (s[a] + s[b] + m[my]) >>> 0
+    put([0x20, sa]); // local.get s[a]
+    put([0x20, sb]); // local.get s[b]
+    put([0x6a]); // i32.add
+    put([0x20, my]); // local.get m[my]
+    put([0x6a]); // i32.add
+    put([0x21, sa]); // local.set s[a]
+
+    // s[d] = rotr(s[d] ^ s[a], 8)
+    put([0x20, sd]); // local.get s[d]
+    put([0x20, sa]); // local.get s[a]
+    put([0x73]); // i32.xor
+    put([0x41, 0x08]); // i32.const 8
+    put([0x78]); // i32.rotr
+    put([0x21, sd]); // local.set s[d]
+
+    // s[c] = (s[c] + s[d]) >>> 0
+    put([0x20, sc]); // local.get s[c]
+    put([0x20, sd]); // local.get s[d]
+    put([0x6a]); // i32.add
+    put([0x21, sc]); // local.set s[c]
+
+    // s[b] = rotr(s[b] ^ s[c], 7)
+    put([0x20, sb]); // local.get s[b]
+    put([0x20, sc]); // local.get s[c]
+    put([0x73]); // i32.xor
+    put([0x41, 0x07]); // i32.const 7
+    put([0x78]); // i32.rotr
+    put([0x21, sb]); // local.set s[b]
+  }
+
+  // 7 rounds of mixing with permuted message schedule
+  let msgIdx = 0;
+  for (let round = 0; round < 7; round++) {
+    // Column mixing
+    g(0, 4, 8, 12, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+    g(1, 5, 9, 13, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+    g(2, 6, 10, 14, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+    g(3, 7, 11, 15, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+
+    // Diagonal mixing
+    g(0, 5, 10, 15, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+    g(1, 6, 11, 12, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+    g(2, 7, 8, 13, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+    g(3, 4, 9, 14, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+  }
+
+  // Store output: out[i] = s[i] ^ s[i+8] for i in 0..7
+  for (let i = 0; i < 8; i++) {
+    put([0x41, ...toLebU32Min2(CHUNK_CV_OFFSET + i * 4)]); // i32.const offset
+    put([0x20, 16 + i]); // local.get s[i]
+    put([0x20, 24 + i]); // local.get s[i+8]
+    put([0x73]); // i32.xor
+    put([0x36, 0x02, 0x00]); // i32.store align=4 offset=0
+  }
+
+  // end function
+  put([0x0b]); // end
+
+  return code;
+}
+
+// Cached WASM instance
+let wasmInstance: WebAssembly.Instance | null = null;
+let wasmMemory: WebAssembly.Memory | null = null;
+let wasmCompress4x: (() => void) | null = null;
+let wasmCompressChunks4x: (() => void) | null = null;
+let wasmCompressParent: (() => void) | null = null;
+let wasmMemoryView: Uint8Array | null = null;
+let wasmMemoryView32: Uint32Array | null = null;
+
+/**
+ * Check if WASM SIMD is supported.
+ */
+export function isSimdSupported(): boolean {
+  try {
+    // Minimal WASM module with v128.const instruction to test SIMD support
+    const simdTest = new Uint8Array([
+      0x00,
+      0x61,
+      0x73,
+      0x6d, // magic: \0asm
+      0x01,
+      0x00,
+      0x00,
+      0x00, // version: 1
+
+      // Type section (id=1): () -> v128
+      0x01, // section id = 1 (type)
+      0x05, // section length = 5
+      0x01, // 1 type
+      0x60,
+      0x00,
+      0x01,
+      0x7b, // func () -> v128
+
+      // Function section (id=3)
+      0x03, // section id = 3 (function)
+      0x02, // section length = 2
+      0x01, // 1 function
+      0x00, // type index 0
+
+      // Code section (id=10) with v128.const
+      0x0a, // section id = 10 (code)
+      0x16, // section length = 22
+      0x01, // 1 function body
+      0x14, // body length = 20
+      0x00, // 0 locals
+      0xfd,
+      0x0c, // v128.const opcode
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x0b, // end
+    ]);
+    return WebAssembly.validate(simdTest);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Set up arena views over WASM memory.
+ * Called after WASM memory is allocated.
+ */
+function setupArenaViews(): void {
+  if (!wasmMemory) return;
+
+  const buffer = wasmMemory.buffer;
+  // Create TypedArray views over WASM memory for arena buffers
+  // These views are backed by WASM memory, eliminating JS heap allocation
+  arenaCvStack = new Uint32Array(buffer, SIMD_MEMORY.CV_STACK, 64 * 8); // 64 levels × 8 words
+  arenaParentBlock = new Uint32Array(buffer, SIMD_MEMORY.PARENT_BLOCK, 16); // 16 words
+  arenaChunkCv = new Uint32Array(buffer, SIMD_MEMORY.CHUNK_CV, 8); // 8 words
+  arenaTempCvs = new Uint32Array(buffer, SIMD_MEMORY.TEMP_CVS, 32); // 4 × 8 words
+
+  // Batch mode views
+  // 16 positions × 16 v128 words = 16 × 64 u32 words = 1024 words per position? No...
+  // In u32 terms: 16 positions × 16 words × 4 lanes = 1024 u32 values total
+  arenaBatchBlockWords = new Uint32Array(buffer, SIMD_MEMORY.BATCH_BLOCK_WORDS, 16 * 16 * 4); // 16 pos × 16 words × 4 lanes
+  arenaBatchCv = new Uint32Array(buffer, SIMD_MEMORY.BATCH_CV, 32); // 4 × 8 words
+  arenaBatchCounterLow = new Uint32Array(buffer, SIMD_MEMORY.BATCH_COUNTER_LOW, 4); // 4 words
+  arenaBatchFlagsBase = new Uint32Array(buffer, SIMD_MEMORY.BATCH_FLAGS_BASE, 4); // 4 words
+  arenaBatchOutput = new Uint32Array(buffer, SIMD_MEMORY.BATCH_OUTPUT, 32); // 4 × 8 words
+}
+
+/**
+ * Initialize the WASM SIMD module synchronously.
+ * Call this once before using compress4x.
+ */
+// Cache generated WASM bytes to avoid regenerating on each init
+let cachedWasmBytes: Uint8Array | null = null;
+
+export function initSimdSync(): boolean {
+  if (wasmInstance) return true;
+
+  if (!isSimdSupported()) {
+    return false;
+  }
+
+  try {
+    const wasmBytes = cachedWasmBytes || generateWasmBytes();
+    cachedWasmBytes = wasmBytes;
+    wasmMemory = new WebAssembly.Memory({ initial: 1 });
+
+    const importObject = {
+      js: { mem: wasmMemory },
+    };
+
+    const module = new WebAssembly.Module(wasmBytes.buffer as ArrayBuffer);
+    wasmInstance = new WebAssembly.Instance(module, importObject);
+    wasmCompress4x = wasmInstance.exports.compress4x as () => void;
+    wasmCompressChunks4x = wasmInstance.exports.compressChunks4x as () => void;
+    wasmCompressParent = wasmInstance.exports.compressParent as () => void;
+    wasmMemoryView = new Uint8Array(wasmMemory.buffer);
+    wasmMemoryView32 = new Uint32Array(wasmMemory.buffer);
+
+    // Set up arena views for Merkle tree operations
+    setupArenaViews();
+
+    return true;
+  } catch (e) {
+    console.warn("Failed to initialize WASM SIMD:", e);
+    return false;
+  }
+}
+
+/**
+ * Memory offsets for SIMD data layout
+ *
+ * WASM Arena Pattern: All working buffers live in WASM memory (64KB page)
+ * This eliminates JS heap allocations during hashing operations.
+ */
+export const SIMD_MEMORY = {
+  // SIMD compress4x working area (used by WASM code) - single block
+  BLOCK_WORDS: 0, // 4 x 16 words = 512 bytes (transposed layout)
+  CHAINING_VALUES: 512, // 4 x 8 words = 128 bytes
+  OUTPUT: 640, // 4 x 8 words = 128 bytes
+  COUNTER_LOW: 768, // 4 words = 16 bytes
+  COUNTER_HIGH: 784, // 4 words = 16 bytes
+  BLOCK_LEN: 800, // 4 words = 16 bytes
+  FLAGS: 816, // 4 words = 16 bytes
+  // End of single-block SIMD working area: 832 bytes
+
+  // SIMD compressChunks4x working area - 16 blocks batched
+  // Each block position has 16 v128 values (one per message word) = 256 bytes
+  // 16 block positions = 16 × 256 = 4096 bytes
+  BATCH_BLOCK_WORDS: 832, // 16 positions × 256 bytes = 4096 bytes (transposed), ends at 4928
+  BATCH_CV: 4928, // 4 × 8 words × 4 bytes = 128 bytes (working CVs), ends at 5056
+  BATCH_COUNTER_LOW: 5056, // 4 words × 4 bytes = 16 bytes (per-chunk counters), ends at 5072
+  BATCH_FLAGS_BASE: 5072, // 4 words × 4 bytes = 16 bytes (base flags, no START/END), ends at 5088
+  BATCH_OUTPUT: 5088, // 4 × 8 words × 4 bytes = 128 bytes (final output), ends at 5216
+  // End of batch working area: 5216 bytes
+
+  // WASM Arena: JS working buffers (accessed via TypedArray views)
+  CV_STACK: 5216, // 64 levels × 8 words × 4 bytes = 2048 bytes, ends at 7264
+  PARENT_BLOCK: 7264, // 16 words × 4 bytes = 64 bytes, ends at 7328
+  CHUNK_CV: 7328, // 8 words × 4 bytes = 32 bytes, ends at 7360
+  TEMP_CVS: 7360, // 4 × 8 words × 4 bytes = 128 bytes, ends at 7488
+  // Total arena usage: ~7488 bytes (fits comfortably in 64KB page)
+} as const;
+
+// Arena views - created once when SIMD initializes
+let arenaCvStack: Uint32Array | null = null;
+let arenaParentBlock: Uint32Array | null = null;
+let arenaChunkCv: Uint32Array | null = null;
+let arenaTempCvs: Uint32Array | null = null;
+
+// Batch mode arena views
+let arenaBatchBlockWords: Uint32Array | null = null;
+let arenaBatchCv: Uint32Array | null = null;
+let arenaBatchCounterLow: Uint32Array | null = null;
+let arenaBatchFlagsBase: Uint32Array | null = null;
+let arenaBatchOutput: Uint32Array | null = null;
+
+/**
+ * Get the WASM memory views for writing input data.
+ */
+export function getSimdMemory(): { view: Uint8Array; view32: Uint32Array } | null {
+  if (!wasmMemoryView || !wasmMemoryView32) return null;
+  return { view: wasmMemoryView, view32: wasmMemoryView32 };
+}
+
+/**
+ * Get the arena buffers for Merkle tree operations.
+ * These TypedArray views are backed by WASM memory - zero JS heap allocation.
+ */
+export function getArenaBuffers(): {
+  cvStack: Uint32Array;
+  parentBlock: Uint32Array;
+  chunkCv: Uint32Array;
+  tempCvs: Uint32Array;
+} | null {
+  if (!arenaCvStack || !arenaParentBlock || !arenaChunkCv || !arenaTempCvs) return null;
+  return {
+    cvStack: arenaCvStack,
+    parentBlock: arenaParentBlock,
+    chunkCv: arenaChunkCv,
+    tempCvs: arenaTempCvs,
+  };
+}
+
+/**
+ * Get the batch arena buffers for chunk-level batched operations.
+ * These TypedArray views are backed by WASM memory - zero JS heap allocation.
+ */
+export function getBatchArenaBuffers(): {
+  blockWords: Uint32Array;
+  cv: Uint32Array;
+  counterLow: Uint32Array;
+  flagsBase: Uint32Array;
+  output: Uint32Array;
+} | null {
+  if (
+    !arenaBatchBlockWords ||
+    !arenaBatchCv ||
+    !arenaBatchCounterLow ||
+    !arenaBatchFlagsBase ||
+    !arenaBatchOutput
+  )
+    return null;
+  return {
+    blockWords: arenaBatchBlockWords,
+    cv: arenaBatchCv,
+    counterLow: arenaBatchCounterLow,
+    flagsBase: arenaBatchFlagsBase,
+    output: arenaBatchOutput,
+  };
+}
+
+/**
+ * Run the compress4x function.
+ * Data must already be set up in WASM memory.
+ */
+export function runCompress4x(): void {
+  if (!wasmCompress4x) {
+    throw new Error("WASM SIMD not initialized. Call initSimdSync() first.");
+  }
+  wasmCompress4x();
+}
+
+/**
+ * Run the compressChunks4x function.
+ * Processes 4 full chunks (16 blocks each) in a single WASM call.
+ * Data must already be set up in batch arena buffers.
+ */
+export function runCompressChunks4x(): void {
+  if (!wasmCompressChunks4x) {
+    throw new Error("WASM SIMD not initialized. Call initSimdSync() first.");
+  }
+  wasmCompressChunks4x();
+}
+
+/**
+ * Run the compressParent function.
+ * Compresses a parent node: reads 16 words from PARENT_BLOCK, writes 8 words to CHUNK_CV.
+ * Data must already be set up in arena buffers (PARENT_BLOCK at offset 7264).
+ * Output is written to CHUNK_CV at offset 7328.
+ */
+export function runCompressParent(): void {
+  if (!wasmCompressParent) {
+    throw new Error("WASM SIMD not initialized. Call initSimdSync() first.");
+  }
+  wasmCompressParent();
+}
+
+/**
+ * Check if SIMD is initialized and ready.
+ */
+export function isSimdReady(): boolean {
+  return wasmCompress4x !== null;
+}

node_modules/@huggingface/hub/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Hugging Face
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@huggingface/hub/README.md

@@ -0,0 +1,228 @@
+# 🤗 Hugging Face Hub API
+
+Official utilities to use the Hugging Face Hub API.
+
+## Install
+
+```console
+pnpm add @huggingface/hub
+
+npm add @huggingface/hub
+
+yarn add @huggingface/hub
+```
+
+### Deno
+
+```ts
+// esm.sh
+import { uploadFiles, listModels } from "https://esm.sh/@huggingface/hub"
+// or npm:
+import { uploadFiles, listModels } from "npm:@huggingface/hub"
+```
+
+Check out the [full documentation](https://huggingface.co/docs/huggingface.js/hub/README).
+
+## Usage
+
+For some of the calls, you need to create an account and generate an [access token](https://huggingface.co/settings/tokens).
+
+Learn how to find free models using the hub package in this [interactive tutorial](https://scrimba.com/scrim/c7BbVPcd?pl=pkVnrP7uP).
+
+```ts
+import * as hub from "@huggingface/hub";
+import type { RepoDesignation } from "@huggingface/hub";
+
+const repo: RepoDesignation = { type: "model", name: "myname/some-model" };
+
+const {name: username} = await hub.whoAmI({accessToken: "hf_..."});
+
+for await (const model of hub.listModels({search: {owner: username}, accessToken: "hf_..."})) {
+  console.log("My model:", model);
+}
+
+const specificModel = await hub.modelInfo({name: "openai-community/gpt2"});
+await hub.checkRepoAccess({repo, accessToken: "hf_..."});
+
+await hub.createRepo({ repo, accessToken: "hf_...", license: "mit" });
+
+await hub.uploadFiles({
+  repo,
+  accessToken: "hf_...",
+  files: [
+    // path + blob content
+    {
+      path: "file.txt",
+      content: new Blob(["Hello World"]),
+    },
+    // Local file URL
+    pathToFileURL("./pytorch-model.bin"),
+    // Local folder URL
+    pathToFileURL("./models"),
+    // Web URL
+    new URL("https://huggingface.co/xlm-roberta-base/resolve/main/tokenizer.json"),
+    // Path + Web URL
+    {
+      path: "myfile.bin",
+      content: new URL("https://huggingface.co/bert-base-uncased/resolve/main/pytorch_model.bin")
+    }
+    // Can also work with native File in browsers
+  ],
+});
+
+// or
+
+for await (const progressEvent of await hub.uploadFilesWithProgress({
+  repo,
+  accessToken: "hf_...",
+  files: [
+    ...
+  ],
+})) {
+  console.log(progressEvent);
+}
+
+// Edit a file by adding prefix & suffix
+await commit({
+  repo,
+  accessToken: "hf_...",
+  operations: [{
+    type: "edit",
+    originalContent: originalFile,
+    edits: [{
+      start: 0,
+      end: 0,
+      content: new Blob(["prefix"])
+    }, {
+      start: originalFile.length,
+      end: originalFile.length,
+      content: new Blob(["suffix"])
+    }]
+  }]
+})
+
+await hub.deleteFile({repo, accessToken: "hf_...", path: "myfile.bin"});
+
+await (await hub.downloadFile({ repo, path: "README.md" })).text();
+
+for await (const fileInfo of hub.listFiles({repo})) {
+  console.log(fileInfo);
+}
+
+await hub.deleteRepo({ repo, accessToken: "hf_..." });
+```
+
+## CLI usage
+
+You can use `@huggingface/hub` in CLI mode to upload files and folders to your repo. 
+
+```console
+npx @huggingface/hub upload coyotte508/test-model .
+npx @huggingface/hub upload datasets/coyotte508/test-dataset .
+# Same thing
+npx @huggingface/hub upload --repo-type dataset coyotte508/test-dataset .
+# Upload new data with 0 history in a separate branch
+npx @huggingface/hub branch create coyotte508/test-model release --empty
+npx @huggingface/hub upload coyotte508/test-model . --revision release
+
+npx @huggingface/hub --help
+npx @huggingface/hub upload --help
+```
+
+You can also install globally with `npm install -g @huggingface/hub`. Then you can do:
+
+```console
+hfjs upload coyotte508/test-model .
+
+hfjs branch create --repo-type dataset coyotte508/test-dataset release --empty
+hfjs upload --repo-type dataset coyotte508/test-dataset . --revision release
+
+hfjs --help
+hfjs  upload --help
+
+hfjs help jobs
+```
+
+## OAuth Login
+
+It's possible to login using OAuth (["Sign in with HF"](https://huggingface.co/docs/hub/oauth)).
+
+This will allow you get an access token to use some of the API, depending on the scopes set inside the Space or the OAuth App.
+
+```ts
+import { oauthLoginUrl, oauthHandleRedirectIfPresent } from "@huggingface/hub";
+
+const oauthResult = await oauthHandleRedirectIfPresent();
+
+if (!oauthResult) {
+  // If the user is not logged in, redirect to the login page
+  window.location.href = await oauthLoginUrl();
+}
+
+// You can use oauthResult.accessToken, oauthResult.accessTokenExpiresAt and oauthResult.userInfo
+console.log(oauthResult);
+```
+
+Checkout the demo: https://huggingface.co/spaces/huggingfacejs/client-side-oauth
+
+## Hugging face cache
+
+The `@huggingface/hub` package provide basic capabilities to scan the cache directory. Learn more about [Manage huggingface_hub cache-system](https://huggingface.co/docs/huggingface_hub/en/guides/manage-cache).
+
+### `scanCacheDir`
+
+You can get the list of cached repositories using the `scanCacheDir` function.
+
+```ts
+import { scanCacheDir } from "@huggingface/hub";
+
+const result = await scanCacheDir();
+
+console.log(result);
+```
+Note: this does not work in the browser
+
+### `downloadFileToCacheDir`
+
+You can cache a file of a repository using the `downloadFileToCacheDir` function.
+
+```ts
+import { downloadFileToCacheDir } from "@huggingface/hub";
+
+const file = await downloadFileToCacheDir({
+  repo: 'foo/bar',
+  path: 'README.md'
+});
+
+console.log(file);
+```
+Note: this does not work in the browser
+
+### `snapshotDownload`
+
+You can download an entire repository at a given revision in the cache directory using the `snapshotDownload` function.
+
+```ts
+import { snapshotDownload } from "@huggingface/hub";
+
+const directory = await snapshotDownload({
+  repo: 'foo/bar',
+});
+
+console.log(directory);
+```
+The code use internally the `downloadFileToCacheDir` function.
+
+Note: this does not work in the browser
+
+## Performance considerations
+
+When uploading large files, you may want to run the `commit` calls inside a worker, to offload the sha256 computations.
+
+Remote resources and local files should be passed as `URL` whenever it's possible so they can be lazy loaded in chunks to reduce RAM usage. Passing a `File` inside the browser's context is fine, because it natively behaves as a `Blob`.
+
+Under the hood, `@huggingface/hub` uses a lazy blob implementation to load the file.
+
+## Dependencies
+
+- `@huggingface/tasks` : Typings only

node_modules/@huggingface/hub/dist/FileBlob-RUOT7DBI.mjs

@@ -0,0 +1,91 @@
+import "./chunk-FFYIGW52.mjs";
+
+// src/utils/FileBlob.ts
+import { createReadStream } from "fs";
+import { open, stat } from "fs/promises";
+import { Readable } from "stream";
+import { fileURLToPath } from "url";
+var FileBlob = class extends Blob {
+  /**
+   * Creates a new FileBlob on the provided file.
+   *
+   * @param path Path to the file to be lazy readed
+   */
+  static async create(path) {
+    path = path instanceof URL ? fileURLToPath(path) : path;
+    const { size } = await stat(path);
+    const fileBlob = new FileBlob(path, 0, size);
+    return fileBlob;
+  }
+  path;
+  start;
+  end;
+  constructor(path, start, end) {
+    super();
+    this.path = path;
+    this.start = start;
+    this.end = end;
+  }
+  /**
+   * Returns the size of the blob.
+   */
+  get size() {
+    return this.end - this.start;
+  }
+  /**
+   * Returns a new instance of FileBlob that is a slice of the current one.
+   *
+   * The slice is inclusive of the start and exclusive of the end.
+   *
+   * The slice method does not supports negative start/end.
+   *
+   * @param start beginning of the slice
+   * @param end end of the slice
+   */
+  slice(start = 0, end = this.size) {
+    if (start < 0 || end < 0) {
+      new TypeError("Unsupported negative start/end on FileBlob.slice");
+    }
+    const slice = new FileBlob(this.path, this.start + start, Math.min(this.start + end, this.end));
+    return slice;
+  }
+  /**
+   * Read the part of the file delimited by the FileBlob and returns it as an ArrayBuffer.
+   */
+  async arrayBuffer() {
+    const slice = await this.execute((file) => file.read(Buffer.alloc(this.size), 0, this.size, this.start));
+    return slice.buffer;
+  }
+  /**
+   * Read the part of the file delimited by the FileBlob and returns it as a string.
+   */
+  async text() {
+    const buffer = await this.arrayBuffer();
+    return buffer.toString("utf8");
+  }
+  /**
+   * Returns a stream around the part of the file delimited by the FileBlob.
+   */
+  stream() {
+    if (this.start === this.end) {
+      return new Blob([]).stream();
+    }
+    return Readable.toWeb(createReadStream(this.path, { start: this.start, end: this.end - 1 }));
+  }
+  /**
+   * We are opening and closing the file for each action to prevent file descriptor leaks.
+   *
+   * It is an intended choice of developer experience over performances.
+   */
+  async execute(action) {
+    const file = await open(this.path, "r");
+    try {
+      return await action(file);
+    } finally {
+      await file.close();
+    }
+  }
+};
+export {
+  FileBlob
+};

node_modules/@huggingface/hub/dist/browser/FileBlob-YC2EPDW4.js

@@ -0,0 +1 @@
+"use strict";