functionalscript 0.33.0 → 0.34.0

package/fs/cas/proof.f.js

@@ -1,160 +1,294 @@
-import { commands } from "./module.f.js";
+import { length, maxLength, msb, vec, vec8 } from "../types/bit_vec/module.f.js";
+import { cBase32ToVec, vecToCBase32 } from "../cbase32/module.f.js";
 import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
-import { empty, length, vec8 } from "../types/bit_vec/module.f.js";
+import { fileCas, casAddFile, casUpload } from "./module.f.js";
 import { pure } from "../effects/module.f.js";
-import { run } from "../effects/mock/module.f.js";
-import { defaultNodeProgramOptions, emptyState, virtual } from "../effects/node/virtual/module.f.js";
-import { dispatch } from "../cli/module.f.js";
-import { assert } from "../asserts/module.f.js";
-const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
-const main = dispatch(commands);
+import { mkdir, writeFile, rm, readFile, access } from "../effects/node/module.f.js";
+import { error, ok } from "../types/result/module.f.js";
+import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
+import { join } from "../path/module.f.js";
+import { nonEmpty, empty } from "../effects/list/module.f.js";
+const testDir = './test-cas-cli';
+// Create a 128 KiB big file content (at the max Vec size limit)
+// This tests the boundary where files are at the chunk size limit
+const createBigFileContent = () => {
+    const byteCount = 128n * 1024n; // 128 KiB
+    // Create a repeating pattern: 0x42 repeated across the file
+    return vec(byteCount * 8n)(0x42424242n);
+};
+// Test adding a big file and verifying the hash
+const testAddBigFile = () => mkdir(testDir, { recursive: true }).step(() => {
+    const bigContent = createBigFileContent();
+    const bigFilePath = `${testDir}/big-file.bin`;
+    return writeFile(bigFilePath, bigContent).step(writeRes => {
+        if (writeRes[0] === 'error') {
+            throw new Error(`Failed to write test file: ${writeRes[1]}`);
+        }
+        const cas = fileCas(sha256)(testDir);
+        return casAddFile(cas)(bigFilePath).step(addRes => {
+            if (addRes[0] === 'error') {
+                throw new Error(`Failed to add file to CAS: ${addRes[1]}`);
+            }
+            const hash = addRes[1];
+            // Verify hash is 256 bits (SHA-256)
+            if (length(hash) !== 256n) {
+                throw new Error(`Expected hash length 256 bits, got ${length(hash)}`);
+            }
+            // Verify hash can be encoded/decoded
+            const hashCBase32 = vecToCBase32(hash);
+            const decodedHash = cBase32ToVec(hashCBase32);
+            if (decodedHash === null) {
+                throw new Error('Failed to decode hash from base32');
+            }
+            return rm(testDir).step(() => pure(undefined));
+        });
+    });
+});
+// Test adding and retrieving a big file
+const testAddAndGetBigFile = () => mkdir(testDir, { recursive: true })
+    .step(() => {
+    const bigContent = createBigFileContent();
+    const bigFilePath = `${testDir}/big-file.bin`;
+    return writeFile(bigFilePath, bigContent)
+        .step(writeRes => {
+        if (writeRes[0] === 'error') {
+            throw new Error(`Failed to write test file: ${writeRes[1]}`);
+        }
+        const cas = fileCas(sha256)(testDir);
+        return casAddFile(cas)(bigFilePath)
+            .step(addRes => {
+            if (addRes[0] === 'error') {
+                throw new Error(`Failed to add file to CAS: ${addRes[1]}`);
+            }
+            const hash = addRes[1];
+            const storedPath = cas.url(hash);
+            // Verify file is stored at the expected location
+            return readFile(storedPath).step(readRes => {
+                if (readRes[0] === 'error') {
+                    throw new Error(`Failed to read stored file: ${readRes[1]}`);
+                }
+                const storedContent = readRes[1];
+                // Verify content is the same size as original
+                const storedLen = length(storedContent);
+                const originalLen = length(bigContent);
+                if (storedLen !== originalLen) {
+                    throw new Error(`Content size mismatch: stored ${storedLen} bits, expected ${originalLen} bits`);
+                }
+                return rm(testDir).step(() => pure(undefined));
+            });
+        });
+    });
+});
 export const proof = {
-    mainAdd: () => {
+    addBigFile: testAddBigFile,
+    addAndGetBigFile: testAddAndGetBigFile,
+    //
+    casWriteRead: () => {
+        // Round-trip a single-chunk payload through the real streaming CAS: `write` returns
+        // the content hash, and `read` streams the same bytes back as `ok` chunk items.
         const content = vec8(0x2an);
-        const state = { ...emptyState, root: { myfile: [content] } };
-        const [finalState, exitCode] = virtual(state)(main(makeOptions(['add', 'myfile'])));
-        if (exitCode !== 0) {
-            throw ['expected exit 0', exitCode];
+        const c = fileCas(sha256)('.');
+        const payload = nonEmpty(ok(content), empty());
+        const [state1, writeResult] = virtual(emptyState)(c.write(payload));
+        if (writeResult[0] !== 'ok') {
+            throw ['expected write ok', writeResult];
         }
-        if (finalState.stdout.length === 0) {
-            throw 'expected hash in stdout';
-        }
-    },
-    mainAddWrongArgs: () => {
-        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['add'])));
-        if (exitCode !== 1) {
-            throw ['expected exit 1', exitCode];
+        const hash = writeResult[1];
+        if (length(hash) !== 256n) {
+            throw ['expected 256-bit hash', length(hash)];
         }
-        if (finalState.stderr.length === 0) {
-            throw 'expected error in stderr';
+        if (msb.cmp(hash)(computeSync(sha256)([content])) !== 0) {
+            throw 'write hash mismatch';
         }
-    },
-    mainGetFound: () => {
-        const content = vec8(0x2an);
-        const state = { ...emptyState, root: { myfile: [content] } };
-        const [state1, exitCode1] = virtual(state)(main(makeOptions(['add', 'myfile'])));
-        if (exitCode1 !== 0) {
-            throw ['expected add exit 0', exitCode1];
+        const drain = (acc) => (stream) => stream.step((node) => {
+            if (node === undefined) {
+                return pure(ok(acc));
+            }
+            const { first, tail } = node;
+            if (first[0] === 'error') {
+                return pure(first);
+            }
+            return drain([...acc, first[1]])(tail);
+        });
+        const [, readResult] = virtual(state1)(drain([])(c.read(hash)));
+        if (readResult[0] !== 'ok') {
+            throw ['expected read ok', readResult];
         }
-        const hashStr = state1.stdout.trim();
-        const [, exitCode2] = virtual(state1)(main(makeOptions(['get', hashStr, 'output'])));
-        if (exitCode2 !== 0) {
-            throw ['expected get exit 0', exitCode2];
+        if (msb.cmp(msb.listToVec(readResult[1]))(content) !== 0) {
+            throw 'read content mismatch';
         }
     },
-    mainGetNotFound: () => {
-        // valid cBase32 hash that has not been stored
-        const content = vec8(0x2an);
-        const state = { ...emptyState, root: { myfile: [content] } };
-        const [state1] = virtual(state)(main(makeOptions(['add', 'myfile'])));
-        const hashStr = state1.stdout.trim();
-        // use an empty store so the hash is not found
-        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get', hashStr, 'output'])));
-        if (exitCode !== 1) {
-            throw ['expected exit 1', exitCode];
+    casReadMissingShard: () => {
+        // A missing shard surfaces as an explicit error *item*, never as end-of-stream.
+        const c = fileCas(sha256)('.');
+        const hash = computeSync(sha256)([vec8(0x2an)]);
+        const node = virtual(emptyState)(c.read(hash))[1];
+        if (node === undefined) {
+            throw 'missing shard must not be EOF';
         }
-        if (finalState.stderr.length === 0) {
-            throw 'expected error in stderr';
+        if (node.first[0] !== 'error') {
+            throw ['expected error item', node.tail];
         }
     },
-    mainGetWrongArgs: () => {
-        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get'])));
-        if (exitCode !== 1) {
-            throw ['expected exit 1', exitCode];
+    casWriteMultiChunk: () => {
+        // A multi-chunk payload streams through `writeBytes` chunk-by-chunk (the lease is
+        // renewed between chunks); the hash equals the SHA-256 of the concatenated bytes,
+        // and read streams the same content back.
+        const chunks = [vec8(0x11n), vec8(0x22n), vec8(0x33n)];
+        const c = fileCas(sha256)('.');
+        const payload = chunks.reduceRight((tail, chunk) => nonEmpty(ok(chunk), tail), empty());
+        const [state1, writeResult] = virtual(emptyState)(c.write(payload));
+        if (writeResult[0] !== 'ok') {
+            throw ['expected write ok', writeResult];
         }
-        if (finalState.stderr.length === 0) {
-            throw 'expected error in stderr';
+        const hash = writeResult[1];
+        if (msb.cmp(hash)(computeSync(sha256)(chunks)) !== 0) {
+            throw 'multi-chunk write hash mismatch';
         }
-    },
-    mainGetInvalidHash: () => {
-        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get', 'not-a-valid-hash', 'output'])));
-        if (exitCode !== 1) {
-            throw ['expected exit 1', exitCode];
+        const drain = (acc) => (stream) => stream.step((node) => {
+            if (node === undefined) {
+                return pure(ok(acc));
+            }
+            const { first, tail } = node;
+            if (first[0] === 'error') {
+                return pure(first);
+            }
+            return drain([...acc, first[1]])(tail);
+        });
+        const [, readResult] = virtual(state1)(drain([])(c.read(hash)));
+        if (readResult[0] !== 'ok') {
+            throw ['expected read ok', readResult];
         }
-        if (finalState.stderr.length === 0) {
-            throw 'expected error in stderr';
+        const expected = msb.concat(msb.concat(chunks[0])(chunks[1]))(chunks[2]);
+        if (msb.cmp(msb.listToVec(readResult[1]))(expected) !== 0) {
+            throw 'multi-chunk read content mismatch';
         }
     },
-    mainList: () => {
+    casWriteDedup: () => {
+        // Same content ⇒ same hash; the second upload's replace-`rename` publishes over the
+        // first, leaving exactly one shard in the store.
         const content = vec8(0x2an);
-        const state = { ...emptyState, root: { myfile: [content] } };
-        const [state1] = virtual(state)(main(makeOptions(['add', 'myfile'])));
-        const [, exitCode] = virtual(state1)(main(makeOptions(['list'])));
-        if (exitCode !== 0) {
-            throw ['expected exit 0', exitCode];
+        const c = fileCas(sha256)('.');
+        const payload = () => nonEmpty(ok(content), empty());
+        const [state1, w1] = virtual(emptyState)(c.write(payload()));
+        const [state2, w2] = virtual(state1)(c.write(payload()));
+        if (w1[0] !== 'ok' || w2[0] !== 'ok') {
+            throw ['expected both writes ok', w1, w2];
+        }
+        if (msb.cmp(w1[1])(w2[1]) !== 0) {
+            throw 'dedup hash mismatch';
+        }
+        const [, hashes] = virtual(state2)(c.list());
+        if (hashes.length !== 1) {
+            throw ['expected one shard after dedup', hashes.length];
         }
     },
-    mainListEmptyStore: () => {
-        // A fresh directory has no `.cas` yet; listing must succeed (empty),
-        // not crash unwrapping a readdir ENOENT.
-        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['list'])));
-        if (exitCode !== 0) {
-            throw ['expected exit 0', exitCode];
+    casWriteErrorItemAborts: () => {
+        // An error item mid-stream deletes the partial staging file and fails; nothing is
+        // published, so the store stays empty.
+        const c = fileCas(sha256)('.');
+        const okItem = ok(vec8(0x11n));
+        const errItem = error({ code: 'BOOM' });
+        const payload = nonEmpty(okItem, nonEmpty(errItem, empty()));
+        const [state1, result] = virtual(emptyState)(c.write(payload));
+        if (result[0] !== 'error') {
+            throw ['expected write error', result];
         }
-        if (finalState.stdout !== '') {
-            throw ['expected empty stdout', finalState.stdout];
+        const [, hashes] = virtual(state1)(c.list());
+        if (hashes.length !== 0) {
+            throw ['expected nothing published on abort', hashes];
         }
     },
-    mainListCorruptStore: () => {
-        // `.cas` exists but is a file, not a directory: a real storage error
-        // that must surface, not be masked as an empty list.
-        const state = { ...emptyState, root: { '.cas': [vec8(0x2an)] } };
-        let threw = false;
-        try {
-            virtual(state)(main(makeOptions(['list'])));
+    casWriteReadExceedsMaxLength: () => {
+        // The point of streaming: a payload larger than a single `Vec`'s `maxLength`
+        // (128 KiB) must round-trip. `write` lands the chunks on disk without ever
+        // holding them as one `Vec`, and `read` streams them back the same way — so the
+        // round-trip is verified by hashing the read stream incrementally rather than
+        // concatenating it (which would itself overflow `maxLength`).
+        const big = vec(maxLength)(0xabn); // one full-size chunk: exactly maxLength bits
+        const tail = vec8(0x2an); // one more byte ⇒ total > maxLength
+        const chunks = [big, tail];
+        const c = fileCas(sha256)('.');
+        const payload = chunks.reduceRight((tl, chunk) => nonEmpty(ok(chunk), tl), empty());
+        const [state1, w] = virtual(emptyState)(c.write(payload));
+        if (w[0] !== 'ok') {
+            throw ['expected write ok', w];
+        }
+        const hash = w[1];
+        if (msb.cmp(hash)(computeSync(sha256)(chunks)) !== 0) {
+            throw 'oversized write hash mismatch';
         }
-        catch {
-            threw = true;
+        // Fold the read stream straight into a fresh SHA-2 state — never one `Vec`.
+        const rehash = (state) => (stream) => stream.step((node) => {
+            if (node === undefined) {
+                return pure(ok(sha256.end(state)));
+            }
+            const { first, tail } = node;
+            if (first[0] === 'error') {
+                return pure(first);
+            }
+            return rehash(sha256.append(first[1])(state))(tail);
+        });
+        const [, readBack] = virtual(state1)(rehash(sha256.init)(c.read(hash)));
+        if (readBack[0] !== 'ok') {
+            throw ['expected read ok', readBack];
         }
-        if (!threw) {
-            throw 'expected list to surface the storage error';
+        if (msb.cmp(readBack[1])(hash) !== 0) {
+            throw 'oversized read-back hash mismatch';
         }
     },
-    mainNoCmd: () => {
-        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions([])));
-        if (exitCode !== 1) {
-            throw ['expected exit 1', exitCode];
+    casWriteGcReclaimsExpired: () => {
+        // A staging file whose deadline is in the past is reclaimed by the GC that `write`
+        // runs before staging its own file.
+        const stalePath = join('.', '.cas', '_stage', '0000000000000000000-stale');
+        const state0 = {
+            ...emptyState,
+            epochNs: 1_000_000,
+            root: { '.cas': { '_stage': { '0000000000000000000-stale': [vec8(0x99n)] } } },
+        };
+        const content = vec8(0x2an);
+        const c = fileCas(sha256)('.');
+        const x = c.write(nonEmpty(ok(content), empty()));
+        const [state1, w] = virtual(state0)(x);
+        if (w[0] !== 'ok') {
+            throw ['expected write ok', w];
         }
-        if (finalState.stderr.length === 0) {
-            throw 'expected error in stderr';
+        const [, present] = virtual(state1)(access(stalePath));
+        if (present[0] !== 'error') {
+            throw 'expected GC to reclaim the expired staging file';
         }
     },
-    mainUnknownCmd: () => {
-        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['bogus'])));
-        if (exitCode !== 1) {
-            throw ['expected exit 1', exitCode];
+    casUploadSuccess: () => {
+        // A successful upload returns the hash and deletes the source file from cas_upload/.
+        const content = vec8(0x2an);
+        const state0 = { ...emptyState, root: { 'cas_upload': { 'myfile': [content] } } };
+        const [state1, result] = virtual(state0)(casUpload('.')('myfile'));
+        if (result[0] !== 'ok') {
+            throw ['expected casUpload ok', result];
         }
-        if (finalState.stderr.length === 0) {
-            throw 'expected error in stderr';
+        if (length(result[1]) !== 256n) {
+            throw ['expected 256-bit hash', length(result[1])];
         }
-    },
-    casWrite: () => {
-        const c = {
-            read: (_key) => pure(undefined),
-            write: (value) => pure(computeSync(sha256)([value])),
-            list: () => pure([]),
-        };
-        const [, hash] = run({})(undefined)(c.write(empty));
-        // sha256 of empty input produces a 256-bit hash
-        assert(hash !== undefined);
-        if (length(hash) !== 256n) {
-            throw ['expected 256-bit hash', length(hash)];
+        // Source must be deleted after successful publish.
+        const srcPath = join('.', 'cas_upload', 'myfile');
+        const [, srcAccess] = virtual(state1)(access(srcPath));
+        if (srcAccess[0] !== 'error') {
+            throw 'expected source to be deleted after successful upload';
         }
     },
-    casReadPassthrough: () => {
-        const stored = empty;
-        const c = {
-            read: (_key) => pure(stored),
-            write: (value) => pure(computeSync(sha256)([value])),
-            list: () => pure([stored]),
-        };
-        const [, readResult] = run({})(undefined)(c.read(empty));
-        if (readResult !== stored) {
-            throw ['read should pass through', readResult];
+    casUploadFailureKeepsSource: () => {
+        // A missing source file causes write to fail; casUpload returns error and the
+        // source is left in place (trivially: it was never there, but the upload is not published).
+        const state0 = { ...emptyState, root: {} };
+        const [state1, result] = virtual(state0)(casUpload('.')('nonexistent'));
+        if (result[0] !== 'error') {
+            throw ['expected casUpload to fail on missing source', result];
         }
-        const [, listResult] = run({})(undefined)(c.list());
-        if (listResult.length !== 1) {
-            throw ['list should pass through', listResult];
+        // Nothing published to the store.
+        const c = fileCas(sha256)('.');
+        const [, hashes] = virtual(state1)(c.list());
+        if (hashes.length !== 0) {
+            throw ['expected nothing published on failed upload', hashes];
         }
     },
 };

package/fs/ci/config/module.f.d.ts

@@ -7,8 +7,8 @@
  */
 export declare const images: {
     readonly ubuntu: {
-        readonly intel: "ubuntu-24.04";
-        readonly arm: "ubuntu-24.04-arm";
+        readonly intel: "ubuntu-26.04";
+        readonly arm: "ubuntu-26.04-arm";
     };
     readonly macos: {
         readonly intel: "macos-26-intel";
@@ -19,24 +19,24 @@ export declare const images: {
         readonly arm: "windows-11-arm";
     };
 };
-export declare const functionalscript: "0.32.4";
+export declare const functionalscript: "0.33.0";
 export declare const bun = "1.3.14";
-export declare const deno = "2.8.3";
-export declare const playwright = "1.61.0";
+export declare const deno = "2.9.0";
+export declare const playwright = "1.61.1";
 export declare const node: {
-    readonly default: "26.3.1";
-    readonly node22: "22.23.0";
-    readonly node24: "24.17.0";
+    readonly default: "26.4.0";
+    readonly node22: "22.23.1";
+    readonly node24: "24.18.0";
 };
-export declare const wasmtime = "45.0.2";
+export declare const wasmtime = "46.0.1";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260620.1";
+export declare const tsgo = "7.0.0-dev.20260627.2";
 export declare const actions: {
     readonly 'actions/checkout': "v7";
-    readonly 'actions/setup-node': "v6";
-    readonly 'actions/cache': "v5";
-    readonly 'denoland/setup-deno': "v2";
-    readonly 'oven-sh/setup-bun': "v2";
+    readonly 'actions/setup-node': "v6.4.0";
+    readonly 'actions/cache': "v6.1.0";
+    readonly 'denoland/setup-deno': "v2.0.4";
+    readonly 'oven-sh/setup-bun': "v2.2.0";
     readonly 'bytecodealliance/actions/wasmtime/setup': "v1";
     readonly 'wasmerio/setup-wasmer': "v3.1";
     readonly 'dtolnay/rust-toolchain': "1.96.0";

package/fs/ci/config/module.f.js

@@ -8,8 +8,8 @@
 // https://docs.github.com/en/actions/reference/runners/github-hosted-runners#standard-github-hosted-runners-for-public-repositories
 export const images = {
     ubuntu: {
-        intel: 'ubuntu-24.04',
-        arm: 'ubuntu-24.04-arm'
+        intel: 'ubuntu-26.04',
+        arm: 'ubuntu-26.04-arm'
     },
     macos: {
         intel: 'macos-26-intel',
@@ -24,25 +24,25 @@ export const images = {
 // published FunctionalScript release; do not tie it to package.json's current
 // in-repo version. A separate maintenance job advances this pin.
 // https://www.npmjs.com/package/functionalscript
-export const functionalscript = '0.32.4';
+export const functionalscript = '0.33.0';
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
-export const deno = '2.8.3';
+export const deno = '2.9.0';
 // https://www.npmjs.com/package/playwright
-export const playwright = '1.61.0';
+export const playwright = '1.61.1';
 // https://nodejs.org/en/download
 export const node = {
-    default: '26.3.1',
-    node22: '22.23.0',
-    node24: '24.17.0',
+    default: '26.4.0',
+    node22: '22.23.1',
+    node24: '24.18.0',
 };
 // https://github.com/bytecodealliance/wasmtime/releases
-export const wasmtime = '45.0.2';
+export const wasmtime = '46.0.1';
 // https://github.com/wasmerio/wasmer/releases
 export const wasmer = '7.1.0';
 // https://www.npmjs.com/package/@typescript/native-preview?activeTab=versions
-export const tsgo = '7.0.0-dev.20260620.1';
+export const tsgo = '7.0.0-dev.20260627.2';
 // GitHub Action versions used by CI step builders. The key is the action
 // `owner/name`; call sites compose the full ref as
 // `` `${name}@${actions[name]}` ``.
@@ -51,13 +51,13 @@ export const actions = {
     // https://github.com/marketplace/actions/checkout
     'actions/checkout': 'v7',
     // https://github.com/marketplace/actions/setup-node-js-environment
-    'actions/setup-node': 'v6',
+    'actions/setup-node': 'v6.4.0',
     // https://github.com/marketplace/actions/cache
-    'actions/cache': 'v5',
+    'actions/cache': 'v6.1.0',
     // https://github.com/marketplace/actions/setup-deno
-    'denoland/setup-deno': 'v2',
+    'denoland/setup-deno': 'v2.0.4',
     // https://github.com/marketplace/actions/setup-bun
-    'oven-sh/setup-bun': 'v2',
+    'oven-sh/setup-bun': 'v2.2.0',
     // https://github.com/bytecodealliance/actions
     'bytecodealliance/actions/wasmtime/setup': 'v1',
     // https://github.com/wasmerio/setup-wasmer

package/fs/djs/tokenizer-new/module.f.js

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { descentParser } from "../../bnf/data/module.f.js";
+import { descentParser } from "../../bnf/descent/module.f.js";
 import { eof, join0Plus, max, none, not, notSet, oneEncode, option, range, remove, repeat, repeat0Plus, repeat1Plus, set, unicodeRange } from "../../bnf/module.f.js";
 import { todo } from "../../asserts/module.f.js";
 export const parse = (input) => {

package/fs/djs/tokenizer-new/proof.f.d.ts

@@ -4,6 +4,8 @@ export declare const proof: {
     djs: (() => void)[];
     operators: (() => void)[];
     ws: (() => void)[];
+    id: (() => void)[];
+    keywords: (() => void)[];
     throw: {
         parse: () => void;
     };