functionalscript 0.30.0 → 0.31.0

package/fs/effects/node/virtual/module.f.js

@@ -4,17 +4,21 @@
  * @module
  */
 import { todo } from "../../../asserts/module.f.js";
-import { parse } from "../../../path/module.f.js";
+import { join, parse } from "../../../path/module.f.js";
 import { utf8ToString } from "../../../text/module.f.js";
 import { isVec } from "../../../types/bit_vec/module.f.js";
 import { error, ok } from "../../../types/result/module.f.js";
 import { run } from "../../mock/module.f.js";
+import { asBase, asNominal } from "../../memory/module.f.js";
 export const emptyState = {
     stdout: '',
     stderr: '',
+    stdin: [],
     root: {},
     internet: {},
     epochNs: 0,
+    memoryNext: 0,
+    memoryValues: {},
 };
 const operation = (op) => {
     const f = (dir, path) => {
@@ -29,7 +33,7 @@ const operation = (op) => {
         const [newSubDir, r] = f(subDir, rest);
         return [{ ...dir, [first]: newSubDir }, r];
     };
-    return (state, path) => {
+    return (path) => (state) => {
         const [root, result] = f(state.root, parse(path));
         return [{ ...state, root }, result];
     };
@@ -49,15 +53,20 @@ const mkdir = (recursive) => operation((dir, path) => {
     dir = { ...dir, ...d };
     return [dir, okVoid];
 });
-const readFileError = error('no such file');
+/** Absent-path error mirroring Node's `ENOENT`, so `isNotFound` recognizes it. */
+const enoent = error({ code: 'ENOENT' });
 const readFile = readOperation((dir, path) => {
     if (path.length !== 1) {
-        return readFileError;
+        return enoent;
     }
     const file = dir[path[0]];
     if (typeof file === 'function') {
         throw new Error(`'${path[0]}' is a JsModule; readFile not supported`);
     }
+    if (file === undefined) {
+        return enoent;
+    }
+    // exists but is a directory — a real error, not a missing path
     if (!isVec(file)) {
         return error(`'${path[0]}' is not a file`);
     }
@@ -102,7 +111,7 @@ const readdir = (base, recursive) => readOperation((dir, path) => {
             const isFile = typeof content !== 'object';
             result = [...result, { name, parentPath, isFile }];
             if (!isFile && recursive) {
-                result = [...result, ...f(`${parentPath}/${name}`, content)];
+                result = [...result, ...f(join(parentPath, name), content)];
             }
         }
         return result;
@@ -114,9 +123,9 @@ const access = readOperation((dir, path) => {
         return okVoid;
     }
     if (path.length !== 1) {
-        return error('no such file or directory');
+        return enoent;
     }
-    return dir[path[0]] !== undefined ? okVoid : error('no such file or directory');
+    return dir[path[0]] !== undefined ? okVoid : enoent;
 });
 const rm = operation((dir, path) => {
     if (path.length !== 1) {
@@ -134,7 +143,7 @@ const rm = operation((dir, path) => {
     return [rest, okVoid];
 });
 const map = {
-    all: (state, ...a) => {
+    all: (...a) => state => {
         let e = [];
         for (const i of a) {
             const [ns, ei] = virtual(state)(i);
@@ -143,14 +152,31 @@ const map = {
         }
         return [state, e];
     },
-    fetch: (state, url) => {
+    memCreate: value => state => {
+        const id = `mem${state.memoryNext}`;
+        const key = asNominal(id);
+        return [{
+                ...state,
+                memoryNext: state.memoryNext + 1,
+                memoryValues: { ...state.memoryValues, [id]: value },
+            }, key];
+    },
+    memRead: key => state => [state, state.memoryValues[asBase(key)]],
+    memWrite: (key, value) => state => {
+        const id = asBase(key);
+        return [{
+                ...state,
+                memoryValues: { ...state.memoryValues, [id]: value },
+            }, undefined];
+    },
+    fetch: url => state => {
         const result = state.internet[url];
         return result === undefined ? [state, error('not found')] : [state, ok(result)];
     },
-    mkdir: (state, path, p) => mkdir(p !== undefined)(state, path),
+    mkdir: (path, p) => mkdir(p !== undefined)(path),
     readFile,
-    readdir: (state, path, { recursive }) => readdir(path, recursive === true)(state, path),
-    writeFile: (state, path, payload) => writeFile(payload)(state, path),
+    readdir: (path, { recursive }) => readdir(path, recursive === true)(path),
+    writeFile: (path, payload) => writeFile(payload)(path),
     access,
     import: import_,
     rm,
@@ -158,7 +184,7 @@ const map = {
     createServer: todo,
     listen: todo,
     forever: todo,
-    now: (state) => [state, state.epochNs],
+    now: () => state => [state, state.epochNs],
     // Virtual sandbox is a pass-through: the fixture's test function is
     // expected to return a `SandboxResult` directly (encoding pass/fail and a
     // chosen duration), so the handler invokes it without try/catch or clock
@@ -166,12 +192,18 @@ const map = {
     // result instead of the runner measuring real execution. A genuine
     // exception in a fixture propagates loudly as a bug in the fixture.
     // See: issues/156-tf-virtual-tests.md
-    sandbox: (state, f) => [state, f()],
-    await: (state, p) => [state, [p]],
+    sandbox: f => state => [state, f()],
+    await: p => state => [state, [p]],
     test: todo,
-    write: (state, stream, data) => {
+    write: (stream, data) => state => {
         const s = utf8ToString(data);
         return [{ ...state, [stream]: `${state[stream]}${s}` }, undefined];
     },
+    read: () => state => {
+        const [first, ...rest] = state.stdin;
+        return state.stdin.length === 0
+            ? [state, null]
+            : [{ ...state, stdin: rest }, first];
+    },
 };
 export const virtual = run(map);

package/fs/effects/node/virtual/proof.f.d.ts

@@ -0,0 +1,17 @@
+export declare const proof: {
+    rm: {
+        success: () => void;
+        notFound: () => void;
+        isDirectory: () => void;
+    };
+    writeFileOnDirectory: () => void;
+    readdirRecursive: () => void;
+    readFileIntoDir: () => void;
+    awaitNonPromise: () => void;
+    fetchNotFound: () => void;
+    importNestedPath: () => void;
+    importNonModule: () => void;
+    throw: {
+        readFileOnJsModule: () => void;
+    };
+};

package/fs/effects/node/virtual/proof.f.js

@@ -0,0 +1,79 @@
+import { assertEq } from "../../../asserts/module.f.js";
+import { awaitIfPromise, fetch, rm, writeFile, readFile, readdir, import_ } from "../module.f.js";
+import { vec8 } from "../../../types/bit_vec/module.f.js";
+import { emptyState, virtual } from "./module.f.js";
+export const proof = {
+    rm: {
+        success: () => {
+            const root = { 'a.txt': vec8(0x42n) };
+            const [, result] = virtual({ ...emptyState, root })(rm('a.txt'));
+            assertEq(result[0], 'ok');
+        },
+        notFound: () => {
+            const [, result] = virtual(emptyState)(rm('notexist.txt'));
+            assertEq(result[0], 'error');
+        },
+        isDirectory: () => {
+            const inner = {};
+            const root = { 'mydir': inner };
+            const [, result] = virtual({ ...emptyState, root })(rm('mydir'));
+            assertEq(result[0], 'error');
+        },
+    },
+    writeFileOnDirectory: () => {
+        const inner = {};
+        const root = { 'mydir': inner };
+        const [, result] = virtual({ ...emptyState, root })(writeFile('mydir', vec8(0x42n)));
+        assertEq(result[0], 'error');
+    },
+    readdirRecursive: () => {
+        const file = vec8(0x42n);
+        const sub = { 'file.txt': file };
+        const outer = { 'sub': sub };
+        const root = { 'mydir': outer };
+        const [, result] = virtual({ ...emptyState, root })(readdir('mydir', { recursive: true }));
+        assertEq(result[0], 'ok');
+        if (result[0] !== 'ok') {
+            throw result;
+        }
+        assertEq(result[1].length, 2);
+    },
+    readFileIntoDir: () => {
+        // 'a/b' where both 'a' and 'b' are directories
+        // hits path.length === 0 in operation's f and path.length !== 1 in readFile op
+        const inner = {};
+        const outer = { 'b': inner };
+        const root = { 'a': outer };
+        const [, result] = virtual({ ...emptyState, root })(readFile('a/b'));
+        assertEq(result[0], 'error');
+    },
+    awaitNonPromise: () => {
+        // a non-promise value passes through the virtual `await` handler as-is
+        const [, result] = virtual(emptyState)(awaitIfPromise(42));
+        assertEq(result, 42);
+    },
+    fetchNotFound: () => {
+        // covers the `result === undefined` branch of the `fetch` handler
+        const [, result] = virtual(emptyState)(fetch('https://example.com/missing'));
+        assertEq(result[0], 'error');
+    },
+    importNestedPath: () => {
+        // import_ on a path whose parent does not exist covers the
+        // path.length !== 1 branch of the import_ op
+        const [, result] = virtual(emptyState)(import_('a/b'));
+        assertEq(result[0], 'error');
+    },
+    importNonModule: () => {
+        // import_ on a Vec (not a JsModule) covers typeof entry !== 'function' branch
+        const root = { 'module.f.ts': vec8(0x42n) };
+        const [, result] = virtual({ ...emptyState, root })(import_('module.f.ts'));
+        assertEq(result[0], 'error');
+    },
+    throw: {
+        readFileOnJsModule: () => {
+            // readFile on a JsModule path covers typeof file === 'function' branch
+            const root = { 'a.f.ts': (() => ({})) };
+            virtual({ ...emptyState, root })(readFile('a.f.ts'));
+        },
+    },
+};

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

@@ -8,4 +8,9 @@ export declare const proof: {
         empty: () => void;
         runs: () => void;
     };
+    decode: () => void;
+    match: {
+        done: () => void;
+        cont: () => void;
+    };
 };

package/fs/effects/proof.f.js

@@ -1,56 +1,76 @@
-import { foldStep, forEachStep, pure } from "./module.f.js";
+import { decode, do_, foldStep, forEachStep, match, pure } from "./module.f.js";
+const assertPure = (e, expected) => {
+    const d = decode(e);
+    if (!d.done) {
+        throw e.value;
+    }
+    if (d.result !== expected) {
+        throw d.result;
+    }
+};
+const next = match({ add: (a, b) => a + b });
 export const proof = {
     foldStep: {
         empty: () => {
             const e = foldStep((x) => (s) => pure(s + x))(10)([]);
-            const { value } = e;
-            if (value.length !== 1) {
-                throw value;
-            }
-            if (value[0] !== 10) {
-                throw value[0];
-            }
+            assertPure(e, 10);
         },
         threadsState: () => {
             const e = foldStep((x) => (s) => pure(s + x))(0)([1, 2, 3, 4]);
-            const { value } = e;
-            if (value.length !== 1) {
-                throw value;
-            }
-            if (value[0] !== 10) {
-                throw value[0];
-            }
+            assertPure(e, 10);
         },
         order: () => {
             const e = foldStep((x) => (s) => pure(s + x))('')(['a', 'b', 'c']);
-            const { value } = e;
-            if (value.length !== 1) {
-                throw value;
-            }
-            if (value[0] !== 'abc') {
-                throw value[0];
-            }
+            assertPure(e, 'abc');
         },
     },
     forEachStep: {
         empty: () => {
             const e = forEachStep(() => pure(undefined))([]);
-            const { value } = e;
-            if (value.length !== 1) {
-                throw value;
-            }
-            if (value[0] !== undefined) {
-                throw value[0];
-            }
+            assertPure(e, undefined);
         },
         runs: () => {
             const e = forEachStep(() => pure(undefined))([1, 2, 3]);
-            const { value } = e;
-            if (value.length !== 1) {
-                throw value;
+            assertPure(e, undefined);
+        },
+    },
+    decode: () => {
+        const d = decode(do_('add')(2, 3));
+        if (d.done) {
+            throw d;
+        }
+        if (d.command !== 'add') {
+            throw d.command;
+        }
+        if (d.payload[0] !== 2 || d.payload[1] !== 3) {
+            throw d.payload;
+        }
+        assertPure(d.continuation(5), 5);
+    },
+    match: {
+        done: () => {
+            const r = next(pure(7));
+            if (r[0] !== 'done') {
+                throw r;
+            }
+            if (r[1] !== 7) {
+                throw r[1];
+            }
+        },
+        cont: () => {
+            const r = next(do_('add')(2, 3));
+            if (r[0] !== 'cont') {
+                throw r;
+            }
+            if (r[1] !== 5) {
+                throw r[1];
+            }
+            const r2 = next(r[2](r[1]));
+            if (r2[0] !== 'done') {
+                throw r2;
             }
-            if (value[0] !== undefined) {
-                throw value[0];
+            if (r2[1] !== 5) {
+                throw r2[1];
             }
         },
     },

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

@@ -24,7 +24,12 @@ export type TestSet = TestEntry | readonly (readonly [string, unknown])[];
  * Converts an arbitrary JS value into a `TestSet`.
  *
  * - Zero-argument functions become a `TestEntry`; the `throws` flag is set if
- *   `throws` is already `true` or the function's `.name === 'throw'`.
+ *   `throws` is already `true` (i.e. a `throw` key appears in the ancestor path).
+ *   The canonical way to declare a throw-test is structural: nest it under a
+ *   `throw` property key. The secondary `fn.name === 'throw'` check is a legacy
+ *   path that only fires when a function is extracted from a `throw` key and
+ *   placed under a different key; that pattern is engine-dependent (unreliable on
+ *   Bun) and is not a supported authoring style.
  * - Non-null objects become an array of `[key, value]` pairs to recurse into.
  * - All other values (including functions with parameters) produce an empty array.
  */

package/fs/emergent_testing/module.f.js

@@ -15,6 +15,7 @@ import { all, awaitIfPromise, sandbox, test } from "../effects/node/module.f.js"
 import { pure } from "../effects/module.f.js";
 import { loadModuleMap, shouldLoad } from "../dev/module.f.js";
 import { invert } from "../types/result/module.f.js";
+import { definedEntries } from "../types/object/module.f.js";
 const addPass = (delta) => (ts) => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });
 const addFail = (delta) => (ts) => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 });
 const timeFormat = (a) => {
@@ -30,7 +31,12 @@ const timeFormat = (a) => {
  * Converts an arbitrary JS value into a `TestSet`.
  *
  * - Zero-argument functions become a `TestEntry`; the `throws` flag is set if
- *   `throws` is already `true` or the function's `.name === 'throw'`.
+ *   `throws` is already `true` (i.e. a `throw` key appears in the ancestor path).
+ *   The canonical way to declare a throw-test is structural: nest it under a
+ *   `throw` property key. The secondary `fn.name === 'throw'` check is a legacy
+ *   path that only fires when a function is extracted from a `throw` key and
+ *   placed under a different key; that pattern is engine-dependent (unreliable on
+ *   Bun) and is not a supported authoring style.
  * - Non-null objects become an array of `[key, value]` pairs to recurse into.
  * - All other values (including functions with parameters) produce an empty array.
  */
@@ -129,8 +135,7 @@ const runModule = ({ result, test }) => (k, v) => (ts) => {
     return walk([], false, v)
         .step(delta => pure(mergeState(ts, delta)));
 };
-const { entries } = Object;
-const proofEntries = (moduleMap) => entries(moduleMap)
+const proofEntries = (moduleMap) => definedEntries(moduleMap)
     .flatMap(([k, v]) => v.proof !== undefined ? [[k, v.proof]] : []);
 /**
  * Runs all test modules in `moduleMap` whose names pass `isTest`, accumulates

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

@@ -10,6 +10,7 @@ export declare const multipleFiles: () => void;
 export declare const throwByFunctionName: () => void;
 export declare const namedExports: () => void;
 export declare const defaultReporterOutput: () => void;
+export declare const defaultReporterOutputLargeDuration: () => void;
 export declare const defaultReporterFailOutput: () => void;
 export declare const githubReporterOutput: () => void;
 export declare const registerSuffixes: () => void;
@@ -21,6 +22,10 @@ export declare const helpers: {
     fmtPath: () => void;
     fmtTerm: () => void;
     ghEscape: () => void;
+    parseTestSet: {
+        nullReturnsEmpty: () => void;
+        functionWithParamsReturnsEmpty: () => void;
+    };
 };
 export declare const proof: {
     flat: () => void;
@@ -35,9 +40,11 @@ export declare const proof: {
     throwByFunctionName: () => void;
     namedExports: () => void;
     defaultReporterOutput: () => void;
+    defaultReporterOutputLargeDuration: () => void;
     defaultReporterFailOutput: () => void;
     githubReporterOutput: () => void;
     registerSuffixes: () => void;
+    defaultReporterExpectedToThrow: () => void;
     helpers: {
         isInteger: () => void;
         isIdentifier: () => void;
@@ -46,5 +53,9 @@ export declare const proof: {
         fmtPath: () => void;
         fmtTerm: () => void;
         ghEscape: () => void;
+        parseTestSet: {
+            nullReturnsEmpty: () => void;
+            functionWithParamsReturnsEmpty: () => void;
+        };
     };
 };

package/fs/emergent_testing/proof.f.js

@@ -1,23 +1,23 @@
 import { pure } from "../effects/module.f.js";
+import { log } from "../effects/node/module.f.js";
 import { emptyState } from "../effects/node/virtual/module.f.js";
 import { virtual } from "../effects/node/virtual/module.f.js";
 import { assert, assertEq, todo } from "../asserts/module.f.js";
-import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, registerModule, defaultTest, } from "./module.f.js";
+import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, registerModule, parseTestSet, defaultTest, } from "./module.f.js";
 import { run as mockRun } from "../effects/mock/module.f.js";
 import { shouldLoad } from "../dev/module.f.js";
-const makeReporter = () => {
-    const events = [];
-    const reporter = {
-        result: (file, path, r, _throws) => { events.push(['result', file, [...path], r]); return pure(undefined); },
-        summary: (pass, fail, time) => { events.push(['summary', pass, fail, time]); return pure(undefined); },
-        test: defaultTest,
-    };
-    return [reporter, () => events];
-};
+const writeEvent = (event) => log(JSON.stringify(event));
+const parseEvents = (stdout) => stdout === '' ? [] : stdout.trimEnd().split('\n').map(line => JSON.parse(line));
+const makeReporter = () => ({
+    result: (file, path, r, _throws) => writeEvent(['result', file, [...path], r]),
+    summary: (pass, fail, time) => writeEvent(['summary', pass, fail, time]),
+    test: defaultTest,
+});
 const noopTestContext = { test: todo };
 const options = (initCwd, github = false) => ({
     args: [],
     env: { INIT_CWD: initCwd, ...(github ? { GITHUB_ACTIONS: 'true' } : {}) },
+    home: '.',
     std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
     testContext: noopTestContext,
     bunTestContext: noopTestContext,
@@ -28,10 +28,10 @@ const ok0 = () => ({ result: ['ok', undefined], duration: 0 });
 const fail0 = () => ({ result: ['error', 'oops'], duration: 0 });
 const ok1 = () => ({ result: ['ok', undefined], duration: 1 });
 const run = (dir, initCwd = '.') => {
-    const [reporter, getEvents] = makeReporter();
+    const reporter = makeReporter();
     const state = { ...emptyState, root: dir };
-    const [, exitCode] = virtual(state)(testAll(reporter)(options(initCwd)));
-    return [getEvents(), exitCode];
+    const [finalState, exitCode] = virtual(state)(testAll(reporter)(options(initCwd)));
+    return [parseEvents(finalState.stdout), exitCode];
 };
 // Runs the real `defaultReporter` and returns its captured stdout/stderr so the
 // terminal and GitHub output formats can be asserted directly.
@@ -199,6 +199,16 @@ export const defaultReporterOutput = () => {
         + 'Number of tests: pass: 1, fail: 0, total: 1\n'
         + 'Time: 0.0000 ms\n');
 };
+// timeFormat with duration >= 1ms covers the `yl <= 0` branch (no leading zeros needed)
+export const defaultReporterOutputLargeDuration = () => {
+    const [stdout, , exit] = runMain({
+        'a.proof.f.ts': () => ({ proof: { x: ok1 } }),
+    });
+    assertEq(exit, 0);
+    assertEq(stdout, 'import("./a.proof.f.ts").proof.x(): ok, 1.0000 ms\n'
+        + 'Number of tests: pass: 1, fail: 0, total: 1\n'
+        + 'Time: 1.0000 ms\n');
+};
 // a failure on the non-GitHub reporter writes the error to stderr, not stdout
 export const defaultReporterFailOutput = () => {
     const [, stderr, exit] = runMain({
@@ -222,8 +232,8 @@ export const registerSuffixes = () => {
     let runner;
     const noopCtx = { test: (_n, _o, _f) => Promise.resolve() };
     const makeRunner = () => mockRun({
-        test: (s, _ctx, name, _xf, _fn) => [[...s, name], undefined],
-        all: (s, ...effects) => {
+        test: (_ctx, name, _xf, _fn) => (s) => [[...s, name], undefined],
+        all: (...effects) => (s) => {
             let st = s;
             const rs = [];
             for (const e of effects) {
@@ -233,7 +243,7 @@ export const registerSuffixes = () => {
             }
             return [st, rs];
         },
-        await: (s, p) => [s, [p]],
+        await: p => (s) => [s, [p]],
     });
     runner = makeRunner();
     const proof = {
@@ -309,6 +319,8 @@ export const helpers = {
         assertEq(fmtTerm(['math', 'add']), '| | add');
         assertEq(fmtTerm(['a', '0']), '| | 0');
         assertEq(fmtTerm(['x', 'hello world']), '| | "hello world"');
+        // null marks a function-call boundary; fmtTerm filters it out
+        assertEq(fmtTerm(['outer', null, 'inner']), '| | inner');
     },
     ghEscape: () => {
         assertEq(ghEscape('a%b'), 'a%25b');
@@ -317,6 +329,28 @@ export const helpers = {
         assertEq(ghEscape('a\r\nb'), 'a%0D%0Ab');
         assertEq(ghEscape('a%b:c,d'), 'a%25b%3Ac%2Cd');
     },
+    parseTestSet: {
+        nullReturnsEmpty: () => {
+            const result = parseTestSet(false, null);
+            assertEq(Array.isArray(result), true);
+            assertEq(result.length, 0);
+        },
+        functionWithParamsReturnsEmpty: () => {
+            const result = parseTestSet(false, (_x) => _x);
+            assertEq(Array.isArray(result), true);
+            assertEq(result.length, 0);
+        },
+    },
+};
+// a passing throw-test emits '# EXPECTED TO THROW' in its output line
+const defaultReporterExpectedToThrow = () => {
+    // fail0 returns a SandboxResult indicating an error; in a throw context
+    // defaultTest inverts it to ok, so defaultReporter.result sees s==='ok' and throws===true
+    const [stdout, , exit] = runMain({
+        'a.proof.f.ts': () => ({ proof: { throw: { x: fail0 } } }),
+    });
+    assertEq(exit, 0);
+    assert(stdout.includes('# EXPECTED TO THROW'), stdout);
 };
 export const proof = {
     flat,
@@ -331,8 +365,10 @@ export const proof = {
     throwByFunctionName,
     namedExports,
     defaultReporterOutput,
+    defaultReporterOutputLargeDuration,
     defaultReporterFailOutput,
     githubReporterOutput,
     registerSuffixes,
+    defaultReporterExpectedToThrow,
     helpers
 };

package/fs/fjs/module.f.js

@@ -5,7 +5,7 @@
  */
 import { compile } from "../djs/module.f.js";
 import { main as testMain } from "../emergent_testing/module.f.js";
-import { main as casMain } from "../cas/module.f.js";
+import { commands as casCommands } from "../cas/module.f.js";
 import { main as ciMain } from "../ci/module.f.js";
 import { import_ } from "../effects/node/module.f.js";
 import { dispatch } from "../cli/module.f.js";
@@ -23,7 +23,7 @@ const commands = [
     {
         names: ['cas', 's'],
         description: 'Content-addressable storage operations',
-        handler: casMain,
+        handler: casCommands,
     },
     {
         names: ['ci', 'i'],

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

@@ -0,0 +1,8 @@
+export declare const proof: {
+    help: () => void;
+    compileRequiresArgs: () => void;
+    runModule: () => void;
+    throw: {
+        runImportError: () => void;
+    };
+};

package/fs/fjs/proof.f.js

@@ -0,0 +1,39 @@
+import { assert, assertEq } from "../asserts/module.f.js";
+import { pure } from "../effects/module.f.js";
+import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
+import { main } from "./module.f.js";
+const makeOptions = (args) => ({
+    args,
+    env: {},
+    home: '.',
+    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
+    testContext: { test: async () => { } },
+    bunTestContext: { test: async () => { } },
+    playwrightTestContext: { test: async () => { } },
+    engine: 'node',
+});
+const run = (root) => (args) => virtual({ ...emptyState, root })(main(makeOptions(args)));
+const appMain = ({ args }) => pure(args.length);
+export const proof = {
+    help: () => {
+        const [state, code] = run({})(['help']);
+        assertEq(code, 0);
+        assert(state.stdout.includes('compile'), 'expected command list in stdout');
+    },
+    compileRequiresArgs: () => {
+        const [state, code] = run({})(['compile']);
+        assertEq(code, 1);
+        assert(state.stderr.length !== 0, 'expected error in stderr');
+    },
+    runModule: () => {
+        const root = { 'app.f.ts': () => ({ main: appMain }) };
+        const [, code] = run(root)(['run', 'app.f.ts', 'x', 'y']);
+        // `run` strips the command and file name, so `main` sees two arguments
+        assertEq(code, 2);
+    },
+    throw: {
+        runImportError: () => {
+            run({})(['run', 'missing.f.ts']);
+        },
+    },
+};

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

@@ -2,4 +2,9 @@ type Result = readonly [readonly string[], ToResult];
 type ToResult = (codePoint: number) => Result;
 export declare const terminal = -1;
 export declare const init: ToResult;
+export declare const proof: {
+    throw: {
+        unionConflict: () => void;
+    };
+};
 export {};