functionalscript 0.35.0 → 0.35.2

package/fs/base64/proof.f.d.ts

@@ -9,4 +9,5 @@ export declare const proof: {
     validPadding: () => void;
     knownVectors: () => void;
     decodeOverflow: () => void;
+    encodeLargeVecIsSlow: () => void;
 };

package/fs/base64/proof.f.js

@@ -1,5 +1,5 @@
 import { assertEq } from "../asserts/module.f.js";
-import { empty, vec } from "../types/bit_vec/module.f.js";
+import { empty, vec, repeat, vec8 } from "../types/bit_vec/module.f.js";
 import { encode, decode } from "./module.f.js";
 const check = (s, v) => {
     assertEq(encode(v), s);
@@ -83,4 +83,28 @@ export const proof = {
         const oversized = 'A'.repeat(174_764);
         assertEq(decode(oversized), null);
     },
+    // Regression guard: `encode` used to be quadratic in the input size, not
+    // linear. `baseN`'s `vecToString` (`fs/base_n/module.f.ts`) popped one
+    // 6-bit chunk off the front at a time via `popFront`, and each `popFront`
+    // re-masked the entire remaining bigint through `vec()`'s `m & ui` —
+    // O(remaining length) — so encoding a vector of `n` bits cost O(n²). A
+    // 90,000-byte input took ~5.6s on Node and ~18.4s on Bun (Bun's `bigint`
+    // has a much higher per-operation constant, see PR #1190), reliably
+    // blowing `bun test`'s 5s per-test timeout — the same class of failure
+    // that hit `cas_get content:true` on a comparably-sized binary blob in CI
+    // (PR #1201).
+    //
+    // Fixed by rewriting `vecToString` as a balanced recursive split
+    // (`unpackToString`), mirroring the `chunkList`/`unpackChunkList`
+    // divide-and-conquer already used by `u8List` and by concatenation
+    // (`msb.concat` / `unpackListToVec`, PR #1192) — true O(n log n) now,
+    // since each half is masked to its own length before recursing. The same
+    // call now takes ~50ms on Node and ~225ms on Bun. No timing assertion
+    // (duration varies by engine/machine) — this just exercises the call and
+    // relies on the test runner's own per-test timing to catch a regression.
+    encodeLargeVecIsSlow: () => {
+        const big = repeat(90000n)(vec8(0xffn));
+        const result = encode(big);
+        assertEq(result?.length, 120_000);
+    },
 };

package/fs/base_n/module.f.d.ts

@@ -18,9 +18,10 @@ import type { Nullable } from '../types/nullable/module.f.ts';
  */
 export type BaseN = {
     /**
-     * Encodes a bit vector by repeatedly popping `bits`-wide MSB chunks and
-     * indexing them into the alphabet. A trailing partial chunk shorter than
-     * `bits` is left-padded with zeros (the underlying `popFront` semantics).
+     * Encodes a bit vector by splitting it into `bits`-wide MSB chunks
+     * (`chunkList`, a balanced divide-and-conquer split, not a linear scan)
+     * and indexing each into the alphabet. A trailing partial chunk shorter
+     * than `bits` is left-padded with zeros.
      */
     readonly vecToString: (v: Vec) => string;
     /**

package/fs/base_n/module.f.js

@@ -11,10 +11,14 @@
  *
  * @module
  */
-import { msb, lsb, length, vec } from "../types/bit_vec/module.f.js";
-import {} from "../types/list/module.f.js";
-const { popFront } = msb;
+import { msb, lsb, vec, chunkList, unpack } from "../types/bit_vec/module.f.js";
+import { fold } from "../types/list/module.f.js";
+import { compose } from "../types/function/module.f.js";
+const { unpackSplit } = msb;
 const { tryListToVec: reversedListToVec } = lsb;
+// `chunkList(msb)` doesn't depend on `bits` or `v` — shared across every
+// `baseN(...)` codec (base64, cbase32, ...).
+const chunkListMsb = chunkList(msb);
 /**
  * Builds a {@link BaseN} codec for a fixed chunk width and alphabet.
  *
@@ -26,21 +30,29 @@ const { tryListToVec: reversedListToVec } = lsb;
  *   `i`/`l`→`1`, `o`→`0`.
  */
 export const baseN = (bits, alphabet, normalize) => {
-    const popFrontN = popFront(bits);
     const vecN = vec(bits);
     const toIndex = normalize === undefined
         ? (c) => alphabet.indexOf(c)
         : (c) => alphabet.indexOf(normalize(c));
+    const unpackSplitBits = unpackSplit(bits);
+    // Converts one `<= bits`-wide chunk (as yielded by `chunkList`, already
+    // masked to its own length) to its alphabet index. A trailing partial
+    // chunk shorter than `bits` is left-padded with zeros: `unpackSplit`'s
+    // shift amount goes negative, which per spec becomes a left shift.
+    const chunkToIndex = (chunk) => {
+        const u = unpack(chunk);
+        return Number(u.length < bits ? unpackSplitBits(u)[0] : u.uint);
+    };
+    // Folds directly over `chunkList`'s lazy list in one pass — faster than
+    // `map` into a second lazy list before joining, since there's no second
+    // list to allocate/traverse.
+    const chunkToString = (chunk) => (acc) => acc + alphabet[chunkToIndex(chunk)];
     return {
-        vecToString: v => {
-            let result = '';
-            while (length(v) > 0n) {
-                const [r, rest] = popFrontN(v);
-                result += alphabet[Number(r)];
-                v = rest;
-            }
-            return result;
-        },
+        // `chunkListMsb(bits)` then `fold(chunkToString)('')` — neither half
+        // depends on `v`, so `compose` builds (and this closure captures)
+        // the composed function once per `baseN(...)` codec; no need to name
+        // the halves separately just to get that one-time build.
+        vecToString: compose(chunkListMsb(bits))(fold(chunkToString)('')),
         stringToVec: s => {
             // Build a reversed chunk list, bailing out at the first invalid
             // character so malformed input is rejected in O(prefix) time and

package/fs/cas/mcp/proof.f.d.ts

@@ -4,6 +4,8 @@ export declare const proof: {
     getMetaLargeMultiChunkTextThenBinary: () => void;
     getContentLargeBlobTooLargeError: () => void;
     getContentMissingHashIsError: () => void;
+    getContentBase64InflationOverflowWritesInternalError: () => void;
+    getContentBase64NearBoundarySucceeds: () => void;
     getContentDoubleEscapedOverflowWritesInternalError: () => void;
     toolsListAdvertisesThreeTools: () => void;
     addReturnsHash: () => void;

package/fs/cas/mcp/proof.f.js

@@ -142,6 +142,15 @@ const asciiChunk = repeat(maxLengthBytes)(vec8(0x61n));
 const symbolChunk = repeat(maxLengthBytes / 2n)(u8ListToVec(msb)([0xc3, 0xa9]));
 // A full chunk of 0xFF — an invalid UTF-8 lead byte, so binary (no magic match).
 const binaryChunk = repeat(maxLengthBytes)(vec8(0xffn));
+// 100,000 raw bytes of 0xFF: comfortably under `maxLengthBytes` (so `cas_get`'s
+// own `length > maxLengthBytes` guard does not fire), but base64 inflates it to
+// ceil(100_000/3)*4 = 133,336 chars — already past `maxLength` (131,072 bytes)
+// before the JSON-RPC envelope adds anything. Small enough to stay clear of the
+// separate `base64Encode`-near-`maxLength` padding bug (see `base64OfA` above).
+const oversizedBase64Chunk = repeat(100000n)(vec8(0xffn));
+// 90,000 raw bytes: base64 inflates to 120,000 chars, leaving ~11 KiB of margin
+// under `maxLength` once the envelope is added — the paired "still succeeds" case.
+const boundaryBase64Chunk = repeat(90000n)(vec8(0xffn));
 // 33,000 `"` bytes (0x22): valid UTF-8, so `cas_get` classifies it as text and
 // takes the double-JSON-escaping path (`toJson` builds the inner CAS JSON, then
 // the outer `stringifyJson` embeds that as the `text` field). Each quote costs
@@ -185,6 +194,51 @@ export const proof = {
         assertEq(resultOf(resp).isError, true);
         assert(textOf(resp).includes('no such hash'));
     },
+    // A blob at exactly `maxLengthBytes` passes cas_get's own raw-length guard
+    // (it checks the *stored* size, not the encoded response), but base64
+    // inflation of a 100,000-byte blob alone already exceeds `maxLength` before
+    // the JSON-RPC envelope is even added. The transport's `writeResponse`
+    // (`tryUtf8`) must catch this and write a JSON-RPC internal-error response —
+    // carrying the *original request's* `id` — instead of crashing the process.
+    // See `fs/mcp/stdio/module.f.ts` `writeResponse`.
+    //
+    // This test originally timed out under `bun test`'s native 5s per-test
+    // limit (12-14s observed in CI on PR #1201) — the cost was in
+    // `base64Encode`, quadratic before the `baseN.vecToString` fix (see
+    // `fs/base64/proof.f.ts` `encodeLargeVecIsSlow`). Now well under budget on
+    // both engines.
+    getContentBase64InflationOverflowWritesInternalError: () => {
+        const root = { 'home': { 'user': { 'cas_upload': { 'big': [oversizedBase64Chunk] } } } };
+        const [addResp] = runStdio(root)([
+            call(2, 'cas_add', { content: '/home/user/cas_upload/big', type: 'url' }),
+        ]);
+        const hash = textOf(addResp);
+        const [, getResp] = runStdio(root)([
+            call(2, 'cas_add', { content: '/home/user/cas_upload/big', type: 'url' }),
+            call(3, 'cas_get', { hash, content: true }),
+        ]);
+        const err = getResp;
+        assertEq(err.error?.code, -32603);
+        assertEq(err.id, 3);
+    },
+    // The paired boundary case: a blob whose base64 inflation leaves enough
+    // margin under `maxLength` for the envelope — confirms the fallback above
+    // only triggers on genuine overflow, not on every `content:true` binary read.
+    getContentBase64NearBoundarySucceeds: () => {
+        const root = { 'home': { 'user': { 'cas_upload': { 'big': [boundaryBase64Chunk] } } } };
+        const [addResp] = runStdio(root)([
+            call(2, 'cas_add', { content: '/home/user/cas_upload/big', type: 'url' }),
+        ]);
+        const hash = textOf(addResp);
+        const [, getResp] = runStdio(root)([
+            call(2, 'cas_add', { content: '/home/user/cas_upload/big', type: 'url' }),
+            call(3, 'cas_get', { hash, content: true }),
+        ]);
+        assert(!resultOf(getResp).isError);
+        const result = JSON.parse(textOf(getResp));
+        assertEq(result.type, 'base64');
+        assertEq(result.length, 90_000);
+    },
     // A text blob made entirely of `"` characters keeps the *raw* content
     // (33,000 bytes) well under `maxLengthBytes`, but each quote costs 2 bytes on
     // the inner CAS-JSON escape and 4 bytes once the outer JSON-RPC envelope

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.0",
+  "version": "0.35.2",
   "type": "module",
   "files": [
     "**/*.js",