functionalscript 0.35.1 → 0.35.2

package/fs/crypto/sha2/module.f.js

@@ -1,7 +1,10 @@
 import { mask } from "../../types/bigint/module.f.js";
-import { vec, length, empty, msb } from "../../types/bit_vec/module.f.js";
+import { vec, length, empty, msb, chunkList, uint } from "../../types/bit_vec/module.f.js";
 import { fold } from "../../types/list/module.f.js";
-const { concat, popFront, front } = msb;
+const { concat, front } = msb;
+// `chunkList(msb)` depends on neither `chunkLength` nor `v`/`state` — shared
+// across every `base(...)` config (32-bit and 64-bit SHA-2 variants).
+const chunkListMsb = chunkList(msb);
 const lastOne = vec(1n)(1n);
 const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
     const bitLength = 1n << logBitLen;
@@ -109,6 +112,20 @@ const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
         ]);
     };
     const chunkLength = bitLength << 4n; // * 16
+    // `chunkListMsb(chunkLength)` depends on `chunkLength` but not `v`/`state`
+    // — computed once per `base(...)` config, not once per `append` call.
+    const chunkListChunkLength = chunkListMsb(chunkLength);
+    // Folds one block (or the final, shorter-than-`chunkLength` leftover) into
+    // `State`. `chunkList` yields chunks of exactly `chunkLength` bits except
+    // possibly the last one, which is why `remainder` only ever holds that
+    // last chunk (`empty` otherwise) — same shape as `State` itself, so no
+    // separate accumulator type is needed.
+    const appendChunk = (chunk) => (state) => length(chunk) === chunkLength
+        ? { hash: compress(state.hash)(uint(chunk)), len: state.len + chunkLength, remainder: empty }
+        : { ...state, remainder: chunk };
+    // `fold(appendChunk)` depends on neither `v` nor `state` — only the
+    // starting accumulator passed to it per `append` call does.
+    const foldChunks = fold(appendChunk);
     const fromV8 = (a) => a.reduce((p, v) => (p << bitLength) | v);
     // See https://www.rfc-editor.org/rfc/rfc6234#section-4
     const lastChunkLength = chunkLength - 1n - (bitLength << 1n);
@@ -117,23 +134,7 @@ const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
         chunkLength,
         compress,
         fromV8,
-        append: (v) => (state) => {
-            let { remainder, hash, len } = state;
-            remainder = concat(remainder)(v);
-            let remainderLen = length(remainder);
-            while (remainderLen >= chunkLength) {
-                const [u, nr] = popFront(chunkLength)(remainder);
-                hash = compress(hash)(u);
-                remainder = nr;
-                remainderLen -= chunkLength;
-                len += chunkLength;
-            }
-            return {
-                hash,
-                len,
-                remainder
-            };
-        },
+        append: (v) => (state) => foldChunks({ ...state, remainder: empty })(chunkListChunkLength(concat(state.remainder)(v))),
         end: (hashLength) => {
             const offset = (bitLength << 3n) - hashLength;
             const result = vec(hashLength);

package/fs/crypto/sha2/proof.f.d.ts

@@ -27,4 +27,5 @@ export declare const proof: {
     padding: {
         overflow: () => void;
     };
+    appendLargeVecIsFast: () => void;
 };

package/fs/crypto/sha2/proof.f.js

@@ -149,4 +149,22 @@ export const proof = {
             }
         },
     },
+    // Regression guard (sha2-append-quadratic): `append` used to be
+    // quadratic in the input size, not linear — a single call on a
+    // 100,000-byte `Vec` used to cost real seconds and scale worse than
+    // O(n²); now near-linear (~40-60ms on Node, well under `bun test`'s 5s
+    // per-test limit on Bun). No timing assertion (duration varies by
+    // engine/machine); relies on the test runner's own per-test timing to
+    // catch a regression, same convention as `fs/base64/proof.f.ts`
+    // `encodeLargeVecIsSlow`.
+    appendLargeVecIsFast: () => {
+        const big = repeat(100000n)(vec(8n)(0xffn));
+        let state = sha256.init;
+        state = sha256.append(big)(state);
+        const h = sha256.end(state);
+        const x = 0xbe87f6dbe42cdf682276fbecab3636fbfcaa008cf454d635dd77872b50d940aan;
+        if (uint(h) !== x) {
+            throw h;
+        }
+    },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.35.1",
+  "version": "0.35.2",
   "type": "module",
   "files": [
     "**/*.js",