functionalscript 0.24.0 → 0.26.0

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

@@ -0,0 +1,8 @@
+export declare const proof: {
+    assertPassesOnTrue: () => void;
+    assertThrowsDefaultMsg: () => void;
+    assertThrowsCustomMsg: () => void;
+    assertEqPassesOnEqual: () => void;
+    assertEqThrowsOnUnequal: () => void;
+    todoThrows: () => void;
+};

package/fs/asserts/proof.f.js

@@ -0,0 +1,51 @@
+import { assert, assertEq, todo } from "./module.f.js";
+const throws = (f, expected) => {
+    let caught = false;
+    try {
+        f();
+    }
+    catch (e) {
+        caught = true;
+        if (e !== expected) {
+            throw ['unexpected throw value', e];
+        }
+    }
+    if (!caught) {
+        throw 'expected function to throw but it did not';
+    }
+};
+export const proof = {
+    assertPassesOnTrue: () => {
+        assert(true);
+        assert(true, 'with message');
+    },
+    assertThrowsDefaultMsg: () => {
+        throws(() => assert(false), 'assertion failed');
+    },
+    assertThrowsCustomMsg: () => {
+        throws(() => assert(false, 'oops'), 'oops');
+    },
+    assertEqPassesOnEqual: () => {
+        assertEq(1, 1);
+        assertEq('x', 'x');
+    },
+    assertEqThrowsOnUnequal: () => {
+        let caught = false;
+        try {
+            assertEq(1, 2);
+        }
+        catch (e) {
+            caught = true;
+            const arr = e;
+            if (arr[0] !== 1 || arr[1] !== 2) {
+                throw ['wrong throw value', e];
+            }
+        }
+        if (!caught) {
+            throw 'expected assertEq to throw';
+        }
+    },
+    todoThrows: () => {
+        throws(() => todo(), 'not implemented');
+    },
+};

package/fs/bnf/data/proof.f.js

@@ -3,7 +3,7 @@ import { stringToCodePointList } from "../../text/utf16/module.f.js";
 import { identity } from "../../types/function/module.f.js";
 import { map, toArray } from "../../types/list/module.f.js";
 import { sort } from "../../types/object/module.f.js";
-import { join0Plus, oneEncode, option, range, rangeDecode, repeat0Plus, set } from "../module.f.js";
+import { commaJoin0Plus, oneEncode, option, range, rangeDecode, repeat0Plus, set } from "../module.f.js";
 import { classic, deterministic } from "../testlib.f.js";
 import { dispatchMap, parser, parserRuleSet, toData, createEmptyTagMap, descentParser } from "./module.f.js";
 const mapCodePoint = (cp) => [cp, undefined];
@@ -437,15 +437,10 @@ export const proof = {
         },
         () => {
             const ws = repeat0Plus(set(' \n\r\t'));
-            const commaJoin0Plus = ([open, close], a) => [
-                open,
-                ws,
-                join0Plus([a, ws], [',', ws]),
-                close,
-            ];
+            const cj = commaJoin0Plus(ws);
             const value = () => ({
-                object: commaJoin0Plus('{}', 'a'),
-                array: commaJoin0Plus('[]', 'a')
+                object: cj('{}', 'a'),
+                array: cj('[]', 'a')
             });
             value.name; //bun will fail if no usage of name found
             const m = parser(value);
@@ -642,15 +637,10 @@ export const proof = {
         },
         () => {
             const ws = repeat0Plus(set(' \n\r\t'));
-            const commaJoin0Plus = ([open, close], a) => [
-                open,
-                ws,
-                join0Plus([a, ws], [',', ws]),
-                close,
-            ];
+            const cj = commaJoin0Plus(ws);
             const value = () => ({
-                object: commaJoin0Plus('{}', 'a'),
-                array: commaJoin0Plus('[]', 'a')
+                object: cj('{}', 'a'),
+                array: cj('[]', 'a')
             });
             value.name; //bun will fail if no usage of name found
             const m = descentParser(value);

package/fs/bnf/module.f.d.ts

@@ -131,6 +131,16 @@ export type Join0Plus<T, S> = Option<readonly [T, Repeat0Plus<readonly [S, T]>]>
  * Repeats `some` zero or more times separated by `separator`.
  */
 export declare const join0Plus: <T extends Rule, S extends Rule>(some: T, separator: S) => Rule;
+/**
+ * A delimited, comma-separated list with whitespace between tokens:
+ * `open ws (item ws (',' ws item ws)*)? close`.
+ *
+ * `ws` is the per-grammar whitespace rule and is curried so callers can
+ * partially apply it once (`const cj = commaJoin0Plus(ws)`) before reusing
+ * the same combinator at multiple bracket pairs. The two-character string
+ * supplies the bracket pair via destructuring (e.g. `'[]'`, `'{}'`).
+ */
+export declare const commaJoin0Plus: (ws: Rule) => ([open, close]: string, item: Rule) => Sequence;
 export type Repeat<T> = readonly T[];
 /**
  * Repeats a rule a fixed number of times.

package/fs/bnf/module.f.js

@@ -151,6 +151,16 @@ export const join1Plus = (some, separator) => [some, repeat0Plus([separator, som
  * Repeats `some` zero or more times separated by `separator`.
  */
 export const join0Plus = (some, separator) => option(join1Plus(some, separator));
+/**
+ * A delimited, comma-separated list with whitespace between tokens:
+ * `open ws (item ws (',' ws item ws)*)? close`.
+ *
+ * `ws` is the per-grammar whitespace rule and is curried so callers can
+ * partially apply it once (`const cj = commaJoin0Plus(ws)`) before reusing
+ * the same combinator at multiple bracket pairs. The two-character string
+ * supplies the bracket pair via destructuring (e.g. `'[]'`, `'{}'`).
+ */
+export const commaJoin0Plus = (ws) => ([open, close], item) => [open, ws, join0Plus([item, ws], [',', ws]), close];
 /**
  * Repeats a rule a fixed number of times.
  */

package/fs/bnf/testlib.f.js

@@ -1,4 +1,4 @@
-import { join0Plus, max, none, option, range, remove, repeat, repeat0Plus, set } from "./module.f.js";
+import { commaJoin0Plus, max, none, option, range, remove, repeat, repeat0Plus, set } from "./module.f.js";
 export const classic = () => {
     // https://www.json.org/json-en.html
     const json = () => [element];
@@ -123,15 +123,10 @@ export const deterministic = () => {
         option([set('Ee'), option(set('+-')), digits])
     ];
     const ws = repeat0Plus(set(' \n\r\t'));
-    const commaJoin0Plus = ([open, close], a) => [
-        open,
-        ws,
-        join0Plus([a, ws], [',', ws]),
-        close,
-    ];
+    const cj = commaJoin0Plus(ws);
     const value = () => ({
-        array: commaJoin0Plus('[]', value),
-        object: commaJoin0Plus('{}', [string, ws, ':', ws, value]),
+        array: cj('[]', value),
+        object: cj('{}', [string, ws, ':', ws, value]),
         string,
         number,
         true: 'true',

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

@@ -6,7 +6,7 @@
 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 Fs, type NodeOp } from '../effects/node/module.f.ts';
+import { type Fs, type NodeOp, type NodeProgramOptions } from '../effects/node/module.f.ts';
 export type KvStore<O extends Operation> = {
     /** Reads a value by key; returns `undefined` when the key does not exist. */
     readonly read: (key: Vec) => Effect<O, Vec | undefined>;
@@ -33,12 +33,4 @@ export type Cas<O extends Operation> = {
  * Builds a content-addressable storage facade from a SHA-2 implementation.
  */
 export declare const cas: (sha2: Sha2) => <O extends Operation>(_: KvStore<O>) => Cas<O>;
-/**
- * Runs the CAS CLI.
- *
- * Supported subcommands:
- * - `add <path>`: stores file content and prints the hash.
- * - `get <hash> <path>`: restores content by hash into a file.
- * - `list`: prints all known hashes.
- */
-export declare const main: (args: readonly string[]) => Effect<NodeOp, number>;
+export declare const main: (options: NodeProgramOptions) => Effect<NodeOp, number>;

package/fs/cas/module.f.js

@@ -8,6 +8,7 @@ import { parse } from "../path/module.f.js";
 import { cBase32ToVec, vecToCBase32 } from "../cbase32/module.f.js";
 import { begin, forEachStep, pure } from "../effects/module.f.js";
 import { errorExit, log, mkdir, readdir, readFile, writeFile } from "../effects/node/module.f.js";
+import { dispatch } from "../cli/module.f.js";
 import { toOption } from "../types/nullable/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 const o = { withFileTypes: true };
@@ -61,59 +62,54 @@ export const cas = (sha2) => {
         list,
     });
 };
-/**
- * Runs the CAS CLI.
- *
- * Supported subcommands:
- * - `add <path>`: stores file content and prints the hash.
- * - `get <hash> <path>`: restores content by hash into a file.
- * - `list`: prints all known hashes.
- */
-export const main = (args) => {
+export const main = (options) => {
     const c = cas(sha256)(fileKvStore('.'));
-    const [cmd, ...options] = args;
-    switch (cmd) {
-        case 'add': {
-            if (options.length !== 1) {
-                return errorExit("'cas add' expects one parameter");
-            }
-            const [path] = options;
-            return begin
-                .step(() => readFile(path))
-                .step(v => c.write(unwrap(v)))
-                .step(hash => log(vecToCBase32(hash)))
-                .step(() => pure(0));
-        }
-        case 'get': {
-            if (options.length !== 2) {
-                return errorExit("'cas get' expects two parameters");
-            }
-            const [hashCBase32, path] = options;
-            const hash = cBase32ToVec(hashCBase32);
-            if (hash === null) {
-                return errorExit(`invalid hash format: ${hashCBase32}`);
-            }
-            return begin
-                .step(() => c.read(hash))
-                .step(v => {
-                const result = v === undefined
-                    ? errorExit(`no such hash: ${hashCBase32}`)
-                    : begin
-                        .step(() => writeFile(path, v))
-                        .step(() => pure(0));
-                return result;
-            });
-        }
-        case 'list': {
-            return begin
+    const commands = [
+        {
+            names: ['add'],
+            description: 'Store file content and print its hash',
+            handler: ({ args: [path, ...rest] }) => {
+                if (path === undefined || rest.length !== 0) {
+                    return errorExit("'cas add' expects one parameter");
+                }
+                return begin
+                    .step(() => readFile(path))
+                    .step(v => c.write(unwrap(v)))
+                    .step(hash => log(vecToCBase32(hash)))
+                    .step(() => pure(0));
+            },
+        },
+        {
+            names: ['get'],
+            description: 'Restore content by hash into a file',
+            handler: ({ args: [hashCBase32, path, ...rest] }) => {
+                if (hashCBase32 === undefined || path === undefined || rest.length !== 0) {
+                    return errorExit("'cas get' expects two parameters");
+                }
+                const hash = cBase32ToVec(hashCBase32);
+                if (hash === null) {
+                    return errorExit(`invalid hash format: ${hashCBase32}`);
+                }
+                return begin
+                    .step(() => c.read(hash))
+                    .step(v => {
+                    const result = v === undefined
+                        ? errorExit(`no such hash: ${hashCBase32}`)
+                        : begin
+                            .step(() => writeFile(path, v))
+                            .step(() => pure(0));
+                    return result;
+                });
+            },
+        },
+        {
+            names: ['list'],
+            description: 'List all stored content hashes',
+            handler: () => begin
                 .step(() => c.list())
                 .step(forEachStep(j => log(vecToCBase32(j))))
-                .step(() => pure(0));
-        }
-        case undefined: {
-            return errorExit('Error: CAS command requires subcommand');
-        }
-        default:
-            return errorExit(`Error: Unknown CAS subcommand "${args[0]}"`);
-    }
+                .step(() => pure(0)),
+        },
+    ];
+    return dispatch(commands)(options);
 };

package/fs/cas/proof.f.js

@@ -4,11 +4,20 @@ import { empty, length, vec8 } from "../types/bit_vec/module.f.js";
 import { pure } from "../effects/module.f.js";
 import { run } from "../effects/mock/module.f.js";
 import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
+const makeOptions = (args) => ({
+    args,
+    env: {},
+    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
+    testContext: { test: async () => { } },
+    bunTestContext: { test: async () => { } },
+    playwrightTestContext: { test: async () => { } },
+    engine: 'node',
+});
 export const proof = {
     mainAdd: () => {
         const content = vec8(0x2an);
         const state = { ...emptyState, root: { myfile: content } };
-        const [finalState, exitCode] = virtual(state)(main(['add', 'myfile']));
+        const [finalState, exitCode] = virtual(state)(main(makeOptions(['add', 'myfile'])));
         if (exitCode !== 0) {
             throw ['expected exit 0', exitCode];
         }
@@ -17,7 +26,7 @@ export const proof = {
         }
     },
     mainAddWrongArgs: () => {
-        const [finalState, exitCode] = virtual(emptyState)(main(['add']));
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['add'])));
         if (exitCode !== 1) {
             throw ['expected exit 1', exitCode];
         }
@@ -28,12 +37,12 @@ export const proof = {
     mainGetFound: () => {
         const content = vec8(0x2an);
         const state = { ...emptyState, root: { myfile: content } };
-        const [state1, exitCode1] = virtual(state)(main(['add', 'myfile']));
+        const [state1, exitCode1] = virtual(state)(main(makeOptions(['add', 'myfile'])));
         if (exitCode1 !== 0) {
             throw ['expected add exit 0', exitCode1];
         }
         const hashStr = state1.stdout.trim();
-        const [, exitCode2] = virtual(state1)(main(['get', hashStr, 'output']));
+        const [, exitCode2] = virtual(state1)(main(makeOptions(['get', hashStr, 'output'])));
         if (exitCode2 !== 0) {
             throw ['expected get exit 0', exitCode2];
         }
@@ -42,10 +51,10 @@ export const proof = {
         // valid cBase32 hash that has not been stored
         const content = vec8(0x2an);
         const state = { ...emptyState, root: { myfile: content } };
-        const [state1] = virtual(state)(main(['add', 'myfile']));
+        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(['get', hashStr, 'output']));
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get', hashStr, 'output'])));
         if (exitCode !== 1) {
             throw ['expected exit 1', exitCode];
         }
@@ -54,7 +63,7 @@ export const proof = {
         }
     },
     mainGetWrongArgs: () => {
-        const [finalState, exitCode] = virtual(emptyState)(main(['get']));
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get'])));
         if (exitCode !== 1) {
             throw ['expected exit 1', exitCode];
         }
@@ -63,7 +72,7 @@ export const proof = {
         }
     },
     mainGetInvalidHash: () => {
-        const [finalState, exitCode] = virtual(emptyState)(main(['get', 'not-a-valid-hash', 'output']));
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get', 'not-a-valid-hash', 'output'])));
         if (exitCode !== 1) {
             throw ['expected exit 1', exitCode];
         }
@@ -74,14 +83,14 @@ export const proof = {
     mainList: () => {
         const content = vec8(0x2an);
         const state = { ...emptyState, root: { myfile: content } };
-        const [state1] = virtual(state)(main(['add', 'myfile']));
-        const [, exitCode] = virtual(state1)(main(['list']));
+        const [state1] = virtual(state)(main(makeOptions(['add', 'myfile'])));
+        const [, exitCode] = virtual(state1)(main(makeOptions(['list'])));
         if (exitCode !== 0) {
             throw ['expected exit 0', exitCode];
         }
     },
     mainNoCmd: () => {
-        const [finalState, exitCode] = virtual(emptyState)(main([]));
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions([])));
         if (exitCode !== 1) {
             throw ['expected exit 1', exitCode];
         }
@@ -90,7 +99,7 @@ export const proof = {
         }
     },
     mainUnknownCmd: () => {
-        const [finalState, exitCode] = virtual(emptyState)(main(['bogus']));
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['bogus'])));
         if (exitCode !== 1) {
             throw ['expected exit 1', exitCode];
         }

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

@@ -37,6 +37,7 @@ export declare const gitHubActionSchema: {
     readonly name: import("../../types/rtti/module.f.ts").String;
     readonly on: {
         readonly pull_request: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
+        readonly merge_group: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
     };
     readonly jobs: import("../../types/rtti/module.f.ts").Type1<"record", {
         readonly 'runs-on': import("../../types/rtti/module.f.ts").String;
@@ -55,6 +56,7 @@ export declare const parseGitHubAction: import("../../types/rtti/parse/module.f.
     readonly name: import("../../types/rtti/module.f.ts").String;
     readonly on: {
         readonly pull_request: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
+        readonly merge_group: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
     };
     readonly jobs: import("../../types/rtti/module.f.ts").Type1<"record", {
         readonly 'runs-on': import("../../types/rtti/module.f.ts").String;

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

@@ -23,7 +23,10 @@ export const jobSchema = {
 export const jobsSchema = record(jobSchema);
 export const gitHubActionSchema = {
     name: string,
-    on: { pull_request: option({}) },
+    on: {
+        pull_request: option({}),
+        merge_group: option({})
+    },
     jobs: jobsSchema
 };
 export const parseGitHubAction = rttiParse(gitHubActionSchema);

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

@@ -28,7 +28,7 @@ export declare const node: {
 };
 export declare const wasmtime = "45.0.0";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260604.1";
+export declare const tsgo = "7.0.0-dev.20260605.1";
 export declare const actions: {
     readonly 'actions/checkout': "v6";
     readonly 'actions/setup-node': "v6";
@@ -37,5 +37,5 @@ export declare const actions: {
     readonly 'oven-sh/setup-bun': "v2";
     readonly 'bytecodealliance/actions/wasmtime/setup': "v1";
     readonly 'wasmerio/setup-wasmer': "v3.1";
-    readonly 'dtolnay/rust-toolchain': "1.95.0";
+    readonly 'dtolnay/rust-toolchain': "1.96.0";
 };

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

@@ -36,7 +36,7 @@ export const wasmtime = '45.0.0';
 // 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.20260604.1';
+export const tsgo = '7.0.0-dev.20260605.1';
 // 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]}` ``.
@@ -57,5 +57,5 @@ export const actions = {
     // https://github.com/wasmerio/setup-wasmer
     'wasmerio/setup-wasmer': 'v3.1',
     // https://rust-lang.org/ - value is Rust version, not action version
-    'dtolnay/rust-toolchain': '1.95.0',
+    'dtolnay/rust-toolchain': '1.96.0',
 };

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

@@ -2,11 +2,9 @@ import { type Effect } from '../effects/module.f.ts';
 import { type NodeOp } from '../effects/node/module.f.ts';
 import { type MetaStep, type Os } from './common/module.f.ts';
 export type Setup = {
-    readonly rust: boolean;
     readonly nodeExtra: (os: Os) => readonly MetaStep[];
     readonly denoExtra: readonly MetaStep[];
     readonly bunExtra: readonly MetaStep[];
 };
-export declare const ci: ({ rust, nodeExtra, denoExtra, bunExtra }: Setup) => Effect<NodeOp, number>;
-declare const _default: () => Effect<NodeOp, number>;
-export default _default;
+export declare const ci: ({ nodeExtra, denoExtra, bunExtra }: Setup) => Effect<NodeOp, number>;
+export declare const main: () => Effect<NodeOp, number>;

package/fs/ci/module.f.js

@@ -4,8 +4,8 @@
  * @module
  */
 import { utf8 } from "../text/module.f.js";
-import { begin, pure } from "../effects/module.f.js";
-import { writeFile } from "../effects/node/module.f.js";
+import { pure } from "../effects/module.f.js";
+import { access, writeFile } from "../effects/node/module.f.js";
 import { images } from "./config/module.f.js";
 import { architecture, findTgz, os, test, toSteps } from "./common/module.f.js";
 import { rustSteps } from "./rust/module.f.js";
@@ -24,7 +24,8 @@ const job = (rust, nodeExtra, denoExtra, bunExtra) => (o) => (a) => {
     ];
     return [id, { 'runs-on': image, steps: toSteps(result) }];
 };
-export const ci = ({ rust, nodeExtra, denoExtra, bunExtra }) => {
+export const ci = ({ nodeExtra, denoExtra, bunExtra }) => access('Cargo.toml').step(result => {
+    const rust = result[0] === 'ok';
     const jobs = {
         ...Object.fromEntries(os.flatMap(o => architecture.map(job(rust, nodeExtra(o), denoExtra, bunExtra)(o)))),
         ...nodeVersions,
@@ -32,15 +33,16 @@ export const ci = ({ rust, nodeExtra, denoExtra, bunExtra }) => {
     };
     const gha = {
         name: 'CI',
-        on: { pull_request: {} },
+        on: {
+            pull_request: {},
+            merge_group: {},
+        },
         jobs,
     };
-    return begin
-        .step(() => writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  '))))
+    return writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  ')))
         .step(() => pure(0));
-};
+});
 const defaultEffect = ci({
-    rust: true,
     nodeExtra: o => [
         test({ run: 'npm pack' }),
         test({ run: `npm install -g ${findTgz(o)}` }),
@@ -57,4 +59,4 @@ const defaultEffect = ci({
         test({ run: 'bun ./fs/fjs/module.ts t' }),
     ]
 });
-export default () => defaultEffect;
+export const main = () => defaultEffect;

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

@@ -17,8 +17,10 @@ export const basicNode = (version) => (extra) => clean([
     ...extra,
 ]);
 const basicTests = [
-    test({ run: 'npm t' }),
-    test({ run: 'npm run fst' }),
+    test({ run: 'npx tsc' }),
+    test({ run: 'npm test' }),
+    test({ run: 'node --test' }),
+    test({ run: 'npm run cov' }),
 ];
 export const nodeTests = (version) => (extra) => basicNode(version)([
     ...basicTests,

package/fs/ci/proof.f.js

@@ -1,6 +1,6 @@
 import { ci } from "./module.f.js";
 import { utf8ToString } from "../text/module.f.js";
-import { isVec } from "../types/bit_vec/module.f.js";
+import { empty as emptyVec, isVec } from "../types/bit_vec/module.f.js";
 import { test, parseGitHubAction } from "./common/module.f.js";
 import { assert } from "../asserts/module.f.js";
 import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
@@ -8,12 +8,15 @@ import { parse as jsonParse } from "../json/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 const hasRun = (cmd) => (gha) => Object.values(gha.jobs).some(job => job.steps.some(step => step.run?.includes(cmd)));
 const hasRunInJob = (jobId, cmd) => (gha) => gha.jobs[jobId]?.steps.some(step => step.run?.includes(cmd)) ?? false;
-const githubState = {
+const makeState = (rust) => ({
     ...emptyState,
-    root: { '.github': { workflows: {} } },
-};
+    root: {
+        '.github': { workflows: {} },
+        ...(rust ? { 'Cargo.toml': emptyVec } : {}),
+    },
+});
 const run = (rust, nodeExtra = () => []) => {
-    const [state, result] = virtual(githubState)(ci({ rust, nodeExtra, denoExtra: [], bunExtra: [] }));
+    const [state, result] = virtual(makeState(rust))(ci({ nodeExtra, denoExtra: [], bunExtra: [] }));
     assert(result === 0, result);
     const dotGithub = state.root['.github'];
     assert(typeof dotGithub === 'object', dotGithub);

package/fs/cli/module.f.d.ts

@@ -0,0 +1,9 @@
+import { type NodeOp, type NodeProgramOptions, type Write } from '../effects/node/module.f.ts';
+import { type Effect } from '../effects/module.f.ts';
+export type Command<O extends NodeOp> = {
+    readonly names: readonly string[];
+    readonly description: string;
+    readonly handler: (options: NodeProgramOptions) => Effect<O, number>;
+};
+export type Commands<O extends NodeOp> = readonly Command<O>[];
+export declare const dispatch: <O extends NodeOp>(commands: Commands<O>) => (options: NodeProgramOptions) => Effect<O | Write, number>;

package/fs/cli/module.f.js

@@ -0,0 +1,24 @@
+import { errorExit, log } from "../effects/node/module.f.js";
+import { pure } from "../effects/module.f.js";
+const helpMeta = { names: ['help', 'h', '?'], description: 'Print this help message' };
+export const dispatch = (commands) => (options) => {
+    const [cmd, ...rest] = options.args;
+    const rows = [...commands, helpMeta];
+    const nameCol = rows.map(c => c.names.join(', '));
+    const width = Math.max(...nameCol.map(s => s.length));
+    const helpText = ['Available commands:', ...rows.map((c, i) => `  ${nameCol[i].padEnd(width)}  ${c.description}`)].join('\n');
+    const helpCommand = {
+        ...helpMeta,
+        handler: () => log(helpText).step(() => pure(0)),
+    };
+    const allCommands = [...commands, helpCommand];
+    const map = Object.fromEntries(allCommands.flatMap(c => c.names.map(n => [n, c])));
+    if (cmd === undefined) {
+        return errorExit(`Error: command is required.\n${helpText}`);
+    }
+    const found = map[cmd];
+    if (found === undefined) {
+        return errorExit(`Error: unknown command "${cmd}".\n${helpText}`);
+    }
+    return found.handler({ ...options, args: rest });
+};

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

@@ -0,0 +1,9 @@
+export declare const proof: {
+    knownCommand: () => void;
+    alias: () => void;
+    noArgs: () => void;
+    unknownCommand: () => void;
+    help: () => void;
+    errorIncludesAvailable: () => void;
+    handlerReceivesRemainingArgs: () => void;
+};