functionalscript 0.35.0 → 0.35.1

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/package.json

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