functionalscript 0.43.0 → 0.44.0

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

@@ -1,64 +0,0 @@
-/**
- * Content-addressable storage utilities for hashing, addressing, and path parsing.
- *
- * @module
- */
-import { type Sha2 } from '../crypto/sha2/module.f.ts';
-import { type Vec } from '../types/bit_vec/module.f.ts';
-import { type Effect, type Operation } from '../effects/module.f.ts';
-import { type Access, type CreateExclusive, type IoResult, type Mkdir, type Now, type RandomInt, type ReadBytes, type Readdir, type Rename, type Rm, type Stat, type WriteBytes } from '../effects/node/module.f.ts';
-import { type List } from '../effects/list/module.f.ts';
-/** Converts a content key to its sharded relative CAS file path. */
-export declare const toPath: (key: Vec) => string;
-/**
- * The filesystem effects the streaming CAS performs: `read` pulls shards
- * (`ReadBytes`); `list` walks the store (`Access`/`Readdir`); `write` runs the
- * lock-free staging upload (`Mkdir`/`CreateExclusive`/`WriteBytes`/`Rename`/`Rm`/
- * `Stat`, lease deadlines from `Now`, staging names from `RandomInt`) and GC's
- * expired staging files (`Readdir`/`Rm`).
- */
-export type FileCasOperation = ReadBytes | Mkdir | Readdir | Access | Rename | Rm | RandomInt | Now | CreateExclusive | WriteBytes | Stat | Now | Readdir | Rm;
-export type Cas<O extends Operation> = {
-    /**
-     * Streams the content for `hash` out in `<=128 KiB` chunks. Every pull yields an
-     * explicit `ok(chunk)` or `error` item, so a missing shard or I/O error is a distinct
-     * error *item* in the stream, never collapsed into end-of-stream (`undefined`).
-     */
-    readonly read: (hash: Vec) => List<O, IoResult<Vec>>;
-    /**
-     * Consumes a chunk stream — each item `ok(chunk)` or `error` — hashing incrementally,
-     * and returns the content address. An error item aborts the upload.
-     */
-    readonly write: <O1 extends Operation>(payload: List<O1, IoResult<Vec>>) => Effect<O | O1, IoResult<Vec>>;
-    /** Lists all stored content hashes. */
-    readonly list: () => Effect<O, readonly Vec[]>;
-};
-/**
- * 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 declare const collectRead: <O extends Operation>(stream: List<O, IoResult<Vec>>) => Effect<O, IoResult<Vec>>;
-export type FileCas = Cas<FileCasOperation> & {
-    url: (v: Vec) => string;
-};
-/**
- * Builds a content-addressable storage facade from a SHA-2 implementation.
- */
-export declare const fileCas: (sha2: Sha2) => (path: string) => FileCas;
-/**
- * Streams the file at `path` through `cas.write`, returning the content hash.
- * Both the CLI `cas add` and the MCP `add` delegate to this; the MCP layer
- * additionally deletes the source file on success.
- */
-export declare const casAddFile: <O extends Operation>(cas: Cas<O>) => (path: string) => Effect<O | ReadBytes, IoResult<Vec>>;
-/**
- * Upload pipeline: streams `fileName` from `~/cas_upload/` through `casAddFile`,
- * then deletes the source on success. On failure the source is left in place so
- * the upload can be retried; `write` already cleans up its own partial staging file.
- */
-export declare const casUpload: (home: string) => (fileName: string) => Effect<FileCasOperation, IoResult<Vec>>;

package/fjs/cas/module.f.js

@@ -1,255 +0,0 @@
-/**
- * Content-addressable storage utilities for hashing, addressing, and path parsing.
- *
- * @module
- */
-import { sha256 } from '../crypto/sha2/module.f.js';
-import { join, normalize, parse } from '../path/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, 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';
-import { splitAt } from '../types/string/module.f.js';
-import { nonEmpty, empty as elEmpty } from '../effects/list/module.f.js';
-const split2 = splitAt(2);
-const prefix = '.cas';
-/** Converts a content key to its sharded relative CAS file path. */
-export const toPath = (key) => {
-    const s = vecToCBase32(key);
-    const [a, bc] = split2(s);
-    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. */
-const stageRel = '_stage';
-/**
- * Lease duration in ms: a staging file's deadline is `now() + leaseDelta`.
- * Renewed after every chunk, so it only has to cover the gap between two
- * consecutive chunks (see [staging-lease.md](../../issues/cas/staging-lease.md)).
- */
-const leaseDelta = 30_000;
-/**
- * Fixed width for the zero-padded epoch-ms deadline embedded in a staging name,
- * so names sort lexically exactly as they sort chronologically. 19 digits keeps
- * epoch-ms (13 digits today) padded with headroom well past year 2286.
- */
-const deadlineWidth = 19;
-/** Builds a `<deadline>-<random256>` staging file name. */
-const stageName = (deadline, rnd) => `${String(deadline).padStart(deadlineWidth, '0')}-${rnd}`;
-/** Recovers the deadline (epoch ms) from a `<deadline>-<random256>` name. */
-const deadlineOf = (name) => Number(name.slice(0, name.indexOf('-')));
-/**
- * Reclaims expired staging files: any `_stage/<deadline>-<rand>` whose deadline
- * is already in the past. Lazy and piggy-backed on `write`. Best-effort — a
- * missing `_stage/` (fresh store) or any `readdir`/`rm` error is ignored, and a
- * still-live lease is left alone; the fencing rename keeps even a misjudged
- * reclaim fail-safe (worst case: that upload restarts).
- */
-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(pure(expired), name => eff(rm(join(stageDir, name)))
-        .step(() => pure(undefined))
-        .value);
-})
-    .value;
-/**
- * Builds a content-addressable storage facade from a SHA-2 implementation.
- */
-export const fileCas = (sha2) => (path) => {
-    const storePrefix = join(path, prefix);
-    const normalizedStorePrefix = normalize(storePrefix);
-    const stageDir = join(storePrefix, stageRel);
-    return {
-        read: (hash) => {
-            const p = join(path, toPath(hash));
-            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.
-                if (t === 'error') {
-                    return nonEmpty(result, elEmpty());
-                }
-                // End the stream only on an empty read; every non-empty read — including a
-                // final short (`< CHUNK_BYTES`) chunk — is emitted as an `ok` item.
-                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
-        // to a `_stage/<deadline>-<rand>` file via `writeBytes` while folding it into the
-        // running SHA-2 state — the payload never lives in memory as a whole. The lease is
-        // renewed (rename to a fresh deadline) after every chunk; any error deletes the
-        // partial file and fails. On end-of-stream the file is published to its hash-derived
-        // shard path by a replace-`rename` (which also dedups/repairs a same-content shard),
-        // and success is confirmed by a `stat` size check. GC of expired staging files is
-        // piggy-backed at the start.
-        write: (payload) => {
-            // Publish the finished staging file to its content-addressed shard. The three
-            // filesystem steps run best-effort with their results ignored; success is decided
-            // afterward by observing the target's size (see staging-lease.md "Publish ignores
-            // results and checks the end state").
-            const publish = (state, offset, curPath) => {
-                const hash = sha2.end(state);
-                const rel = toPath(hash);
-                const dst = join(path, rel);
-                const dstDir = join(path, ...parse(rel).slice(0, -1));
-                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')))
-                    .value;
-            };
-            // Any streaming error fails closed: delete the partial file, return the error.
-            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) => eff(stream)
-                    .step((node) => {
-                    if (node === undefined) {
-                        return publish(state, offset, curPath);
-                    }
-                    const { first, tail } = node;
-                    if (first[0] === 'error') {
-                        return fail(curPath, first[1]);
-                    }
-                    const chunk = first[1];
-                    return eff(writeBytes(curPath, offset, chunk))
-                        .step(wb => {
-                        if (wb[0] === 'error') {
-                            return fail(curPath, wb[1]);
-                        }
-                        const newState = sha2.append(chunk)(state);
-                        const newOffset = offset + Number(length(chunk) / 8n);
-                        // Renew the lease: rename to a fresh deadline (keeps `delta` constant).
-                        // 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 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".
-        eff(access(storePrefix))
-            .step(a => {
-            if (a[0] === 'error') {
-                if (isNotFound(a[1])) {
-                    return pure([]);
-                }
-                throw a[1];
-            }
-            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))))
-                .value;
-        })
-            .value,
-        url: (hash) => join(path, toPath(hash))
-    };
-};
-/** 256-bit random `Vec` built from 8 sequential `randomInt` (32-bit) calls. */
-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) => eff(readBytes(filePath, offset, chunkBytes))
-        .step((result) => {
-        if (result[0] === 'error') {
-            return nonEmpty(result, elEmpty());
-        }
-        const chunk = result[1];
-        return length(chunk) === 0n
-            ? elEmpty()
-            : nonEmpty(ok(chunk), loop(offset + chunkBytes));
-    })
-        .value;
-    return loop(0);
-};
-/**
- * Streams the file at `path` through `cas.write`, returning the content hash.
- * Both the CLI `cas add` and the MCP `add` delegate to this; the MCP layer
- * additionally deletes the source file on success.
- */
-export const casAddFile = (cas) => (path) => 
-// streamFile produces only ReadBytes effects. TypeScript can't prove ListEffect<ReadBytes,T>
-// ≤ ListEffect<O,T> for generic O (recursive type), but the cast is sound: every concrete
-// caller passes a Cas<O> where ReadBytes ⊆ O (e.g. FileCasOperation).
-cas.write(streamFile(path));
-/**
- * Upload pipeline: streams `fileName` from `~/cas_upload/` through `casAddFile`,
- * then deletes the source on success. On failure the source is left in place so
- * the upload can be retried; `write` already cleans up its own partial staging file.
- */
-export const casUpload = (home) => (fileName) => {
-    const src = join(home, 'cas_upload', fileName);
-    const c = fileCas(sha256)(home);
-    return eff(casAddFile(c)(src))
-        .step(okStep(v => eff(rm(src))
-        .step(() => pure(ok(v)))
-        .value))
-        .value;
-};

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

@@ -1,18 +0,0 @@
-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

@@ -1,305 +0,0 @@
-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/fjs/ci/bun/module.f.d.ts

@@ -1,2 +0,0 @@
-import { type MetaStep } from '../common/module.f.ts';
-export declare const bunSteps: (version: string) => readonly MetaStep[];

package/fjs/ci/bun/module.f.js

@@ -1,15 +0,0 @@
-/**
- * CI step builder for Bun: installs the pinned Bun version and runs the
- * FunctionalScript package smoke test plus Bun coverage in one canonical job.
- *
- * @module
- */
-import { bun } from '../config/module.f.js';
-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' }),
-];