functionalscript 0.32.4 → 0.34.0

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

@@ -1,15 +1,18 @@
+import { type FileCasOperation } from './module.f.ts';
+import { type Effect } from '../effects/module.f.ts';
+import { type ReadFile, type WriteFile, type Rm, type Mkdir } from '../effects/node/module.f.ts';
+type TestOp = FileCasOperation | WriteFile | ReadFile | Rm | Mkdir;
 export declare const proof: {
-    mainAdd: () => void;
-    mainAddWrongArgs: () => void;
-    mainGetFound: () => void;
-    mainGetNotFound: () => void;
-    mainGetWrongArgs: () => void;
-    mainGetInvalidHash: () => void;
-    mainList: () => void;
-    mainListEmptyStore: () => void;
-    mainListCorruptStore: () => void;
-    mainNoCmd: () => void;
-    mainUnknownCmd: () => void;
-    casWrite: () => void;
-    casReadPassthrough: () => void;
+    addBigFile: () => Effect<TestOp, void>;
+    addAndGetBigFile: () => Effect<TestOp, void>;
+    casWriteRead: () => void;
+    casReadMissingShard: () => void;
+    casWriteMultiChunk: () => void;
+    casWriteDedup: () => void;
+    casWriteErrorItemAborts: () => void;
+    casWriteReadExceedsMaxLength: () => void;
+    casWriteGcReclaimsExpired: () => void;
+    casUploadSuccess: () => void;
+    casUploadFailureKeepsSource: () => void;
 };
+export {};

package/fs/cas/proof.f.js

@@ -1,169 +1,294 @@
-import { cas, commands } from "./module.f.js";
-import { sha256 } from "../crypto/sha2/module.f.js";
-import { empty, length, vec8 } from "../types/bit_vec/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 { fileCas, casAddFile, casUpload } from "./module.f.js";
 import { pure } from "../effects/module.f.js";
-import { run } from "../effects/mock/module.f.js";
+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 { dispatch } from "../cli/module.f.js";
-const makeOptions = (args) => ({
-    args,
-    env: {},
-    home: '.',
-    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
-    testContext: { test: async () => { } },
-    bunTestContext: { test: async () => { } },
-    playwrightTestContext: { test: async () => { } },
-    engine: 'node',
+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));
+            });
+        });
+    });
 });
-const main = dispatch(commands);
 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];
-        }
-        if (finalState.stdout.length === 0) {
-            throw 'expected hash in stdout';
+        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];
         }
-    },
-    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 store = {
-            read: (_key) => pure(undefined),
-            write: (_key, _value) => pure(undefined),
-            list: () => pure([]),
-        };
-        const c = cas(sha256)(store);
-        const [, hash] = run({})(undefined)(c.write(empty));
-        // sha256 of empty input produces a 256-bit hash
-        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 store = {
-            read: (_key) => pure(stored),
-            write: (_key, _value) => pure(undefined),
-            list: () => pure([stored]),
-        };
-        const c = cas(sha256)(store);
-        const [, readResult] = run({})(undefined)(c.read(empty));
-        if (readResult !== stored) {
-            throw ['read should pass through', readResult];
-        }
-        const [, listResult] = run({})(undefined)(c.list());
-        if (listResult.length !== 1) {
-            throw ['list should pass through', listResult];
+    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];
+        }
+        // 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.30.0";
+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.0";
-    readonly node22: "22.22.3";
-    readonly node24: "24.16.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.20260615.1";
+export declare const tsgo = "7.0.0-dev.20260627.2";
 export declare const actions: {
-    readonly 'actions/checkout': "v6";
-    readonly 'actions/setup-node': "v6";
-    readonly 'actions/cache': "v5";
-    readonly 'denoland/setup-deno': "v2";
-    readonly 'oven-sh/setup-bun': "v2";
+    readonly 'actions/checkout': "v7";
+    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,40 +24,40 @@ 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.30.0';
+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.0',
-    node22: '22.22.3',
-    node24: '24.16.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.20260615.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]}` ``.
 // Note: dtolnay/rust-toolchain value is a Rust version, not an action version.
 export const actions = {
     // https://github.com/marketplace/actions/checkout
-    'actions/checkout': 'v6',
+    '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/ci/proof.f.js

@@ -14,18 +14,20 @@ const makeState = (rust, packageJson) => ({
     ...emptyState,
     root: {
         '.github': { workflows: {} },
-        ...(packageJson !== undefined ? { 'package.json': utf8(packageJson) } : {}),
-        ...(rust ? { 'Cargo.toml': emptyVec } : {}),
+        ...(packageJson !== undefined ? { 'package.json': [utf8(packageJson)] } : {}),
+        ...(rust ? { 'Cargo.toml': [emptyVec] } : {}),
     },
 });
 const workflow = (state) => {
     const dotGithub = state.root['.github'];
-    assert(typeof dotGithub === 'object', dotGithub);
+    assert(typeof dotGithub === 'object' && !Array.isArray(dotGithub), dotGithub);
     const workflows = dotGithub['workflows'];
-    assert(typeof workflows === 'object', workflows);
+    assert(typeof workflows === 'object' && !Array.isArray(workflows), workflows);
     const file = workflows['ci.yml'];
-    assert(isVec(file), file);
-    return unwrap(parseGitHubAction(jsonParse(utf8ToString(file))));
+    if (!Array.isArray(file) || file.length === 0) {
+        throw file;
+    }
+    return unwrap(parseGitHubAction(jsonParse(utf8ToString(file[0]))));
 };
 const run = (rust, nodeExtra = () => []) => {
     const [state, result] = virtual(makeState(rust))(ci({ nodeExtra }));

package/fs/cli/proof.f.js

@@ -1,17 +1,7 @@
 import { pure } from "../effects/module.f.js";
-import {} from "../effects/node/module.f.js";
-import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
+import { defaultNodeProgramOptions, emptyState, virtual } from "../effects/node/virtual/module.f.js";
 import { dispatch } from "./module.f.js";
-const makeOptions = (args) => ({
-    args,
-    env: {},
-    home: '.',
-    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
-    testContext: { test: async () => { } },
-    bunTestContext: { test: async () => { } },
-    playwrightTestContext: { test: async () => { } },
-    engine: 'node',
-});
+const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
 const echoCommands = [
     {
         names: ['echo', 'e'],