functionalscript 0.37.0 → 0.39.0

package/{fs → fjs}/cas/module.f.js

@@ -5,9 +5,10 @@
  */
 import { sha256 } from '../crypto/sha2/module.f.js';
 import { join, normalize, parse } from '../path/module.f.js';
-import { empty, length, maxLengthBytes, msb, vec } from '../types/bit_vec/module.f.js';
+import { empty, length, maxLength, maxLengthBytes, msb, vec } from '../types/bit_vec/module.f.js';
 import { cBase32ToVec, vecToCBase32 } from '../basen/cbase32/module.f.js';
-import { foldStep, forEachStep, okStep, pure } from '../effects/module.f.js';
+import { foldStep, forEachStep, history, historyStep, okStep, pure, step } from '../effects/module.f.js';
+import { eff } from '../effects/eff/module.f.js';
 import { access, createExclusive, isNotFound, mkdir, now, randomInt, readBytes, readdir, rename, rm, stat, writeBytes, } from '../effects/node/module.f.js';
 import { toOption } from '../types/nullable/module.f.js';
 import { error, ok, unwrap } from '../types/result/module.f.js';
@@ -22,6 +23,34 @@ export const toPath = (key) => {
     const [b, c] = split2(bc);
     return join(prefix, a, b, c);
 };
+/**
+ * Drains a `Cas<O>.read` chunk stream into a single `Vec`. Used by any caller
+ * that needs the whole blob at once (an MCP `content: true` fetch, an Evo
+ * revision decode): the chunk stream is concatenated and an error item is
+ * surfaced as the result. A single `Vec` cannot exceed `maxLength` bits;
+ * concatenating past it would overflow the runtime's `bigint` constraint, so
+ * that case is surfaced as an error item too, rather than crashing the
+ * process.
+ */
+export const collectRead = (stream) => {
+    const loop = (acc) => (s) => eff(s)
+        .step((node) => {
+        if (node === undefined) {
+            return pure(ok(acc));
+        }
+        const { first, tail } = node;
+        const [t, v] = first;
+        if (t === 'error') {
+            return pure(first);
+        }
+        if (length(acc) + length(v) > maxLength) {
+            return pure(error(`cas blob exceeds maximum vector length of ${maxLength} bits`));
+        }
+        return loop(msb.concat(acc)(v))(tail);
+    })
+        .value;
+    return loop(empty)(stream);
+};
 /** Maximum chunk size for streaming reads: the largest `Vec` the runtime allows. */
 const chunkBytes = Number(maxLengthBytes);
 /** Staging directory under the store root; GC and every uploader share it. */
@@ -49,13 +78,18 @@ const deadlineOf = (name) => Number(name.slice(0, name.indexOf('-')));
  * still-live lease is left alone; the fencing rename keeps even a misjudged
  * reclaim fail-safe (worst case: that upload restarts).
  */
-const gcStage = (stageDir) => now().step(t => readdir(stageDir, {}).step(([k, v]) => {
+const gcStage = (stageDir) => eff(now())
+    .step(() => readdir(stageDir, {}))
+    .step(([k, v], t) => {
     if (k === 'error') {
         return pure(undefined);
     }
     const expired = v.flatMap(d => d.isFile && deadlineOf(d.name) < t ? [d.name] : []);
-    return forEachStep((name) => rm(join(stageDir, name)).step(() => pure(undefined)))(expired);
-}));
+    return forEachStep(pure(expired), name => eff(rm(join(stageDir, name)))
+        .step(() => pure(undefined))
+        .value);
+})
+    .value;
 /**
  * Builds a content-addressable storage facade from a SHA-2 implementation.
  */
@@ -66,7 +100,7 @@ export const fileCas = (sha2) => (path) => {
     return {
         read: (hash) => {
             const p = join(path, toPath(hash));
-            const loop = (offset) => readBytes(p, offset, chunkBytes)
+            const loop = (offset) => eff(readBytes(p, offset, chunkBytes))
                 .step((result) => {
                 const [t, v] = result;
                 // A missing shard or read error is an explicit error item, never EOF.
@@ -78,7 +112,8 @@ export const fileCas = (sha2) => (path) => {
                 return length(v) === 0n
                     ? elEmpty()
                     : nonEmpty(ok(v), loop(offset + chunkBytes));
-            });
+            })
+                .value;
             return loop(0);
         },
         // Lock-free staging upload (issues/cas/staging-lease.md): stream each chunk straight
@@ -99,17 +134,20 @@ export const fileCas = (sha2) => (path) => {
                 const rel = toPath(hash);
                 const dst = join(path, rel);
                 const dstDir = join(path, ...parse(rel).slice(0, -1));
-                return mkdir(dstDir, { recursive: true })
+                return eff(mkdir(dstDir, { recursive: true }))
                     .step(() => rename(curPath, dst))
                     .step(() => rm(curPath))
                     .step(() => stat(dst))
-                    .step(st => pure(st[0] === 'ok' && st[1].size === offset ? ok(hash) : error('publish size mismatch')));
+                    .step(st => pure(st[0] === 'ok' && st[1].size === offset ? ok(hash) : error('publish size mismatch')))
+                    .value;
             };
             // Any streaming error fails closed: delete the partial file, return the error.
-            const fail = (curPath, e) => rm(curPath).step(() => pure(error(e)));
-            return gcStage(stageDir).step(() => random256.step(rnd => {
+            const fail = (curPath, e) => eff(rm(curPath))
+                .step(() => pure(error(e)))
+                .value;
+            return eff(gcStage(stageDir)).step(() => eff(random256).step(rnd => {
                 const rndStr = vecToCBase32(rnd);
-                const loop = (state, offset, curPath) => (stream) => stream
+                const loop = (state, offset, curPath) => (stream) => eff(stream)
                     .step((node) => {
                     if (node === undefined) {
                         return publish(state, offset, curPath);
@@ -119,7 +157,7 @@ export const fileCas = (sha2) => (path) => {
                         return fail(curPath, first[1]);
                     }
                     const chunk = first[1];
-                    return writeBytes(curPath, offset, chunk)
+                    return eff(writeBytes(curPath, offset, chunk))
                         .step(wb => {
                         if (wb[0] === 'error') {
                             return fail(curPath, wb[1]);
@@ -127,49 +165,59 @@ export const fileCas = (sha2) => (path) => {
                         const newState = sha2.append(chunk)(state);
                         const newOffset = offset + Number(length(chunk) / 8n);
                         // Renew the lease: rename to a fresh deadline (keeps `delta` constant).
-                        return now()
-                            .step(t => {
-                            const next = join(stageDir, stageName(t + leaseDelta, rndStr));
-                            return rename(curPath, next).step(([t, v]) => t === 'error'
-                                ? fail(curPath, v)
-                                : loop(newState, newOffset, next)(tail));
-                        });
-                    });
-                });
-                return mkdir(stageDir, { recursive: true })
-                    .step(() => now()
+                        // The new path is still needed after the rename, to recurse with,
+                        // so the rename captures it rather than closing over it.
+                        const nextPath = step(now(), t => pure(join(stageDir, stageName(t + leaseDelta, rndStr))));
+                        const renamed = historyStep(history(nextPath), next => rename(curPath, next));
+                        return step(renamed, ([[rt, v], next]) => rt === 'error'
+                            ? fail(curPath, v)
+                            : loop(newState, newOffset, next)(tail));
+                    })
+                        .value;
+                })
+                    .value;
+                return eff(mkdir(stageDir, { recursive: true }))
+                    .step(() => now())
                     .step(t0 => {
                     const path0 = join(stageDir, stageName(t0 + leaseDelta, rndStr));
-                    return createExclusive(path0)
-                        .step(okStep(() => loop(sha2.init, 0, path0)(payload)));
-                }));
-            }));
+                    return eff(createExclusive(path0))
+                        .step(okStep(() => loop(sha2.init, 0, path0)(payload)))
+                        .value;
+                })
+                    .value;
+            }).value).value;
         },
         list: () => 
         // A fresh store has no `.cas` directory yet. Treat *only* that case as an
         // empty store, mirroring how `read` maps a missing shard to an error item.
         // A `.cas` that exists but cannot be read (permissions, corruption) is a
         // genuine storage error and is surfaced, not masked as "no hashes".
-        access(storePrefix).step(a => {
+        eff(access(storePrefix))
+            .step(a => {
             if (a[0] === 'error') {
                 if (isNotFound(a[1])) {
                     return pure([]);
                 }
                 throw a[1];
             }
-            return readdir(storePrefix, { recursive: true })
+            return eff(readdir(storePrefix, { recursive: true }))
                 .step(r => pure(unwrap(r).flatMap(({ name, parentPath, isFile }) => toOption(isFile
                 ? cBase32ToVec(normalize(parentPath).substring(normalizedStorePrefix.length).replaceAll('/', '') + name)
-                : null))));
-        }),
+                : null))))
+                .value;
+        })
+            .value,
         url: (hash) => join(path, toPath(hash))
     };
 };
 /** 256-bit random `Vec` built from 8 sequential `randomInt` (32-bit) calls. */
-const random256 = foldStep((_) => (acc) => randomInt().step(r => pure(msb.concat(acc)(vec(32n)(BigInt(r))))))(empty)([0, 1, 2, 3, 4, 5, 6, 7]);
+const random256 = foldStep(pure([0, 1, 2, 3, 4, 5, 6, 7]), empty, () => (acc) => eff(randomInt())
+    .step(r => pure(msb.concat(acc)(vec(32n)(BigInt(r)))))
+    .value);
 /** Streams any file at `filePath` in `<=128 KiB` chunks as a `ListEffect` of `ok` items. */
 const streamFile = (filePath) => {
-    const loop = (offset) => readBytes(filePath, offset, chunkBytes).step((result) => {
+    const loop = (offset) => eff(readBytes(filePath, offset, chunkBytes))
+        .step((result) => {
         if (result[0] === 'error') {
             return nonEmpty(result, elEmpty());
         }
@@ -177,7 +225,8 @@ const streamFile = (filePath) => {
         return length(chunk) === 0n
             ? elEmpty()
             : nonEmpty(ok(chunk), loop(offset + chunkBytes));
-    });
+    })
+        .value;
     return loop(0);
 };
 /**
@@ -198,5 +247,9 @@ cas.write(streamFile(path));
 export const casUpload = (home) => (fileName) => {
     const src = join(home, 'cas_upload', fileName);
     const c = fileCas(sha256)(home);
-    return casAddFile(c)(src).step(okStep(v => rm(src).step(() => pure(ok(v)))));
+    return eff(casAddFile(c)(src))
+        .step(okStep(v => eff(rm(src))
+        .step(() => pure(ok(v)))
+        .value))
+        .value;
 };

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

@@ -0,0 +1,18 @@
+export declare const proof: {
+    addBigFile: () => void;
+    addAndGetBigFile: () => void;
+    casWriteRead: () => void;
+    casReadMissingShard: () => void;
+    casWriteMultiChunk: () => void;
+    casWriteDedup: () => void;
+    casWriteErrorItemAborts: () => void;
+    casWriteReadExceedsMaxLength: () => void;
+    casWriteGcReclaimsExpired: () => void;
+    casWriteGcSkipsLiveLease: () => void;
+    casUploadSuccess: () => void;
+    casUploadFailureKeepsSource: () => void;
+    collectReadDrainsChunks: () => void;
+    collectReadPropagatesErrorItem: () => void;
+    collectReadOverflow: () => void;
+    casListPropagatesNonNotFoundAccessError: () => void;
+};

package/fjs/cas/proof.f.js

@@ -0,0 +1,305 @@
+import { length, maxLength, msb, vec, vec8 } from '../types/bit_vec/module.f.js';
+import { cBase32ToVec, vecToCBase32 } from '../basen/cbase32/module.f.js';
+import { computeSync, sha256 } from '../crypto/sha2/module.f.js';
+import { fileCas, casAddFile, collectRead, casUpload } from './module.f.js';
+import { match, pure, runPure, step } from '../effects/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 { join } from '../path/module.f.js';
+import { nonEmpty, empty } from '../effects/list/module.f.js';
+import { assert, assertEq, assertNotNullish } from '../asserts/module.f.js';
+const testDir = './test-cas-cli';
+// Names the command a `FileCasOperation` effect stops at, so a proof can assert
+// on it and resume the continuation without reading the `Do` layout. The map
+// has to list every operation the CAS can perform — that is what makes it total,
+// and what makes a new operation a compile error here rather than a silent gap.
+const casCommand = match({
+    access: () => 'access',
+    createExclusive: () => 'createExclusive',
+    mkdir: () => 'mkdir',
+    now: () => 'now',
+    randomInt: () => 'randomInt',
+    readBytes: () => 'readBytes',
+    readdir: () => 'readdir',
+    rename: () => 'rename',
+    rm: () => 'rm',
+    stat: () => 'stat',
+    writeBytes: () => 'writeBytes',
+});
+// 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 = () => {
+    const bigFilePath = `${testDir}/big-file.bin`;
+    const cas = fileCas(sha256)(testDir);
+    const x0 = step(mkdir(testDir, { recursive: true }), () => writeFile(bigFilePath, createBigFileContent()));
+    const x1 = step(x0, writeRes => {
+        assert(writeRes[0] === 'ok', ['failed to write test file', writeRes]);
+        return casAddFile(cas)(bigFilePath);
+    });
+    const x2 = step(x1, addRes => {
+        assert(addRes[0] === 'ok', ['failed to add file to CAS', addRes]);
+        const hash = addRes[1];
+        // Verify hash is 256 bits (SHA-256)
+        assertEq(length(hash), 256n, ['expected 256-bit hash', length(hash)]);
+        // Verify hash can be encoded/decoded
+        assertNotNullish(cBase32ToVec(vecToCBase32(hash)), 'failed to decode hash from cBase32');
+        return rm(testDir);
+    });
+    return step(x2, () => pure(undefined));
+};
+// Test adding and retrieving a big file
+const testAddAndGetBigFile = () => {
+    const bigContent = createBigFileContent();
+    const bigFilePath = `${testDir}/big-file.bin`;
+    const cas = fileCas(sha256)(testDir);
+    const x0 = step(mkdir(testDir, { recursive: true }), () => writeFile(bigFilePath, bigContent));
+    const x1 = step(x0, writeRes => {
+        assert(writeRes[0] === 'ok', ['failed to write test file', writeRes]);
+        return casAddFile(cas)(bigFilePath);
+    });
+    // Verify the file is stored at the expected location
+    const x2 = step(x1, addRes => {
+        assert(addRes[0] === 'ok', ['failed to add file to CAS', addRes]);
+        return readFile(cas.url(addRes[1]));
+    });
+    const x3 = step(x2, readRes => {
+        assert(readRes[0] === 'ok', ['failed to read stored file', readRes]);
+        // Verify content is the same size as original
+        assertEq(length(readRes[1]), length(bigContent), 'stored content size mismatch');
+        return rm(testDir);
+    });
+    return step(x3, () => pure(undefined));
+};
+export const proof = {
+    // Both effects must be interpreted, not merely built: an `Effect` is inert
+    // data, so returning one from a proof runs none of its continuations and
+    // asserts nothing.
+    addBigFile: () => { virtual(emptyState)(testAddBigFile()); },
+    addAndGetBigFile: () => { virtual(emptyState)(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 c = fileCas(sha256)('.');
+        const payload = nonEmpty(ok(content), empty());
+        const [state1, writeResult] = virtual(emptyState)(c.write(payload));
+        assert(writeResult[0] === 'ok', ['expected write ok', writeResult]);
+        const hash = writeResult[1];
+        assertEq(length(hash), 256n, ['expected 256-bit hash', length(hash)]);
+        assertEq(msb.cmp(hash)(computeSync(sha256)([content])), 0, 'write hash mismatch');
+        const drain = (acc) => (stream) => step(stream, (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)));
+        assert(readResult[0] === 'ok', ['expected read ok', readResult]);
+        assertEq(msb.cmp(msb.listToVec(readResult[1]))(content), 0, 'read content mismatch');
+    },
+    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];
+        assert(node !== undefined, 'missing shard must not be EOF');
+        assert(node.first[0] === 'error', ['expected error item', node.tail]);
+    },
+    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));
+        assert(writeResult[0] === 'ok', ['expected write ok', writeResult]);
+        const hash = writeResult[1];
+        assertEq(msb.cmp(hash)(computeSync(sha256)(chunks)), 0, 'multi-chunk write hash mismatch');
+        const drain = (acc) => (stream) => step(stream, (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)));
+        assert(readResult[0] === 'ok', ['expected read ok', readResult]);
+        const expected = msb.concat(msb.concat(chunks[0])(chunks[1]))(chunks[2]);
+        assertEq(msb.cmp(msb.listToVec(readResult[1]))(expected), 0, 'multi-chunk read content mismatch');
+    },
+    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 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()));
+        assert(!(w1[0] !== 'ok' || w2[0] !== 'ok'), ['expected both writes ok', w1, w2]);
+        assertEq(msb.cmp(w1[1])(w2[1]), 0, 'dedup hash mismatch');
+        const [, hashes] = virtual(state2)(c.list());
+        assertEq(hashes.length, 1, ['expected one shard after dedup', hashes.length]);
+    },
+    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));
+        assert(result[0] === 'error', ['expected write error', result]);
+        const [, hashes] = virtual(state1)(c.list());
+        assertEq(hashes.length, 0, ['expected nothing published on abort', hashes]);
+    },
+    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));
+        assert(w[0] === 'ok', ['expected write ok', w]);
+        const hash = w[1];
+        assertEq(msb.cmp(hash)(computeSync(sha256)(chunks)), 0, 'oversized write hash mismatch');
+        // Fold the read stream straight into a fresh SHA-2 state — never one `Vec`.
+        const rehash = (state) => (stream) => step(stream, (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)));
+        assert(readBack[0] === 'ok', ['expected read ok', readBack]);
+        assertEq(msb.cmp(readBack[1])(hash), 0, 'oversized read-back hash mismatch');
+    },
+    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);
+        assert(w[0] === 'ok', ['expected write ok', w]);
+        const [, present] = virtual(state1)(access(stalePath));
+        assert(present[0] === 'error', 'expected GC to reclaim the expired staging file');
+    },
+    casWriteGcSkipsLiveLease: () => {
+        // A staging file whose deadline is still in the future is left alone by the GC
+        // that `write` runs before staging its own file.
+        const livePath = join('.', '.cas', '_stage', '0000000000002000000-live');
+        const state0 = {
+            ...emptyState,
+            epochNs: 1_000_000,
+            root: { '.cas': { '_stage': { '0000000000002000000-live': [vec8(0x99n)] } } },
+        };
+        const content = vec8(0x2an);
+        const c = fileCas(sha256)('.');
+        const x = c.write(nonEmpty(ok(content), empty()));
+        const [state1, w] = virtual(state0)(x);
+        assert(w[0] === 'ok', ['expected write ok', w]);
+        const [, present] = virtual(state1)(access(livePath));
+        assert(present[0] === 'ok', 'expected GC to leave the live staging file alone');
+    },
+    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'));
+        assert(result[0] === 'ok', ['expected casUpload ok', result]);
+        assertEq(length(result[1]), 256n, ['expected 256-bit hash', length(result[1])]);
+        // Source must be deleted after successful publish.
+        const srcPath = join('.', 'cas_upload', 'myfile');
+        const [, srcAccess] = virtual(state1)(access(srcPath));
+        assert(srcAccess[0] === 'error', 'expected source to be deleted after successful upload');
+    },
+    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'));
+        assert(result[0] === 'error', ['expected casUpload to fail on missing source', result]);
+        // Nothing published to the store.
+        const c = fileCas(sha256)('.');
+        const [, hashes] = virtual(state1)(c.list());
+        assertEq(hashes.length, 0, ['expected nothing published on failed upload', hashes]);
+    },
+    collectReadDrainsChunks: () => {
+        // The common path: every chunk is `ok`, so collectRead concatenates them all
+        // and returns the whole blob as one `Vec`.
+        const stream = nonEmpty(ok(vec8(0x11n)), nonEmpty(ok(vec8(0x22n)), empty()));
+        const o = runPure(collectRead(stream));
+        assert(o.length === 1, 'expected collectRead to finish without issuing a command');
+        assertEq(o[0][0], 'ok');
+    },
+    collectReadPropagatesErrorItem: () => {
+        // An error item mid-stream short-circuits collectRead with that same error.
+        const boom = error('boom');
+        const stream = nonEmpty(ok(vec8(0x11n)), nonEmpty(boom, empty()));
+        const o = runPure(collectRead(stream));
+        assert(o.length === 1, 'expected collectRead to finish without issuing a command');
+        const [r] = o;
+        assertEq(r[0], 'error');
+        assertEq(r[1], 'boom');
+    },
+    // A single `Vec` cannot exceed `maxLength` bits — feed a pure stream whose second
+    // chunk pushes the running total just over the limit so the overflow guard fires
+    // without any real I/O.
+    collectReadOverflow: () => {
+        const half = maxLength / 2n;
+        const v1 = vec(half)(0n);
+        const v2 = vec(half + 1n)(0n);
+        const stream = nonEmpty(ok(v1), nonEmpty(ok(v2), empty()));
+        const o = runPure(collectRead(stream));
+        assert(o.length === 1, 'expected collectRead to finish without issuing a command');
+        assertEq(o[0][0], 'error');
+    },
+    casListPropagatesNonNotFoundAccessError: () => {
+        // A non-ENOENT `access` failure (permissions, corruption) is a genuine storage
+        // error and must propagate out of `list`, not be swallowed as an empty store.
+        const c = fileCas(sha256)('.');
+        const boom = { code: 'EACCES' };
+        const r = casCommand(c.list());
+        assert(r[0] === 'cont', 'expected list() to issue an access command first');
+        assertEq(r[1], 'access');
+        let threw;
+        try {
+            r[2](error(boom));
+        }
+        catch (e) {
+            threw = e;
+        }
+        assertEq(threw, boom);
+    },
+};

package/{fs → fjs}/ci/bun/module.f.js

@@ -5,11 +5,11 @@
  * @module
  */
 import { bun } from '../config/module.f.js';
-import { clean, install, test, uses } from '../common/module.f.js';
-export const bunSteps = (version) => clean([
+import { install, test, uses } from '../common/module.f.js';
+export const bunSteps = (version) => [
     install(uses('oven-sh/setup-bun', { 'bun-version': bun })),
     install({ run: `bun install -g functionalscript@${version}` }),
     test({ run: 'bun install --frozen-lockfile' }),
     test({ run: `bunx functionalscript@${version} t` }),
     test({ run: 'bun test --coverage' }),
-]);
+];

package/{fs → fjs}/ci/common/module.f.d.ts

@@ -1,7 +1,7 @@
 /**
  * Shared CI types and helpers: GitHub Actions step/job RTTI schemas, the
  * `MetaStep` representation used by tool-specific modules, and assemblers like
- * `install`, `test`, `clean`, `ubuntu`, and `toSteps`.
+ * `install`, `test`, `ubuntu`, and `toSteps`.
  *
  * @module
  */
@@ -83,7 +83,6 @@ export type MetaStep = {
 export declare const uses: (name: keyof typeof actions, w?: Record<string, string>) => Step;
 export declare const install: (step: Step) => MetaStep;
 export declare const test: (step: Step) => MetaStep;
-export declare const clean: (steps: readonly MetaStep[]) => readonly MetaStep[];
 export declare const toSteps: (m: readonly MetaStep[]) => readonly Step[];
 export declare const ubuntu: (ms: readonly MetaStep[]) => Job;
 export declare const ubuntuArm: (ms: readonly MetaStep[]) => Job;

package/{fs → fjs}/ci/common/module.f.js

@@ -1,7 +1,7 @@
 /**
  * Shared CI types and helpers: GitHub Actions step/job RTTI schemas, the
  * `MetaStep` representation used by tool-specific modules, and assemblers like
- * `install`, `test`, `clean`, `ubuntu`, and `toSteps`.
+ * `install`, `test`, `ubuntu`, and `toSteps`.
  *
  * @module
  */
@@ -37,10 +37,6 @@ export const uses = (name, w) => ({
 });
 export const install = (step) => ({ type: 'install', step });
 export const test = (step) => ({ type: 'test', step });
-export const clean = (steps) => [
-    ...steps,
-    test({ run: 'git reset --hard HEAD && git clean -fdx' })
-];
 export const toSteps = (m) => {
     const filter = (st) => m.flatMap((mt) => mt.type === st ? [mt.step] : []);
     const aptGet = m.flatMap(v => v.type === 'apt-get' ? [v.package] : []).join(' ');

package/{fs → fjs}/ci/config/module.f.d.ts

@@ -19,24 +19,24 @@ export declare const images: {
         readonly arm: 'windows-11-arm';
     };
 };
-export declare const functionalscript: '0.36.0';
+export declare const functionalscript: '0.38.0';
 export declare const bun = "1.3.14";
-export declare const deno = "2.9.2";
-export declare const playwright = "1.61.1";
+export declare const deno = "2.9.4";
+export declare const playwright = "1.62.0";
 export declare const node: {
     readonly default: '26.5.0';
     readonly node22: '22.23.1';
     readonly node24: '24.18.0';
 };
-export declare const wasmtime = "46.0.1";
-export declare const wasmer = "7.2.0";
+export declare const wasmtime = "47.0.2";
+export declare const wasmer = "7.2.1";
 export declare const actions: {
-    readonly 'actions/checkout': 'v7';
-    readonly 'actions/setup-node': 'v6.4.0';
+    readonly 'actions/checkout': 'v7.0.1';
+    readonly 'actions/setup-node': 'v7.0.0';
     readonly 'actions/cache': 'v6.1.0';
     readonly 'denoland/setup-deno': 'v2.0.5';
     readonly 'oven-sh/setup-bun': 'v2.2.0';
     readonly 'bytecodealliance/actions/wasmtime/setup': 'v1.1.3';
     readonly 'wasmerio/setup-wasmer': 'v3.1';
-    readonly 'dtolnay/rust-toolchain': '1.96.1';
+    readonly 'dtolnay/rust-toolchain': '1.97.1';
 };