functionalscript 0.19.0 → 0.21.0

package/fs/{dev/tf/test.f.js → emergent-testing/proof.f.js}

@@ -1,12 +1,14 @@
-import { pure } from "../../types/effects/module.f.js";
-import { emptyState } from "../../types/effects/node/virtual/module.f.js";
-import { virtual } from "../../types/effects/node/virtual/module.f.js";
-import { assert, assertEq, todo } from "../module.f.js";
-import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, defaultTest, } from "./module.f.js";
+import { pure } from "../types/effects/module.f.js";
+import { emptyState } from "../types/effects/node/virtual/module.f.js";
+import { virtual } from "../types/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 { run as mockRun } from "../types/effects/mock/module.f.js";
+import { shouldLoad } from "../dev/module.f.js";
 const makeReporter = () => {
     const events = [];
     const reporter = {
-        result: (file, path, r) => { events.push(['result', file, [...path], r]); return pure(undefined); },
+        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,
     };
@@ -42,7 +44,7 @@ const runMain = (dir, github = false) => {
 // flat object: two passing tests
 export const flat = () => {
     const [events, exit] = run({
-        'a.test.f.ts': () => ({ a: ok0, b: ok1 }),
+        'a.proof.f.ts': () => ({ proof: { a: ok0, b: ok1 } }),
     });
     assertEq(exit, 0);
     const [e0, e1, e2] = events;
@@ -56,7 +58,7 @@ export const flat = () => {
 // nested object: leaf tests carry the full path including the sub-tree key
 export const nested = () => {
     const [events, exit] = run({
-        'n.test.f.ts': () => ({ math: { add: ok0, sub: ok0 } }),
+        'n.proof.f.ts': () => ({ proof: { math: { add: ok0, sub: ok0 } } }),
     });
     assertEq(exit, 0);
     const [e0, e1, e2] = events;
@@ -70,7 +72,7 @@ export const nested = () => {
 // throw key: tests inside 'throw' pass on error result
 export const throwKey = () => {
     const [events, exit] = run({
-        't.test.f.ts': () => ({ throw: { a: fail0 } }),
+        't.proof.f.ts': () => ({ proof: { throw: { a: fail0 } } }),
     });
     assertEq(exit, 0);
     const [e0, e1] = events;
@@ -83,7 +85,7 @@ export const throwKey = () => {
 // throw key fails when test does not throw (returns ok in throw context)
 export const throwKeyFail = () => {
     const [events, exit] = run({
-        't.test.f.ts': () => ({ throw: { a: ok0 } }),
+        't.proof.f.ts': () => ({ proof: { throw: { a: ok0 } } }),
     });
     assertEq(exit, 1);
     const [e0, e1] = events;
@@ -95,7 +97,7 @@ export const throwKeyFail = () => {
 // mixed pass/fail updates summary counts
 export const mixedPassFail = () => {
     const [events, exit] = run({
-        'm.test.f.ts': () => ({ good: ok0, bad: fail0 }),
+        'm.proof.f.ts': () => ({ proof: { good: ok0, bad: fail0 } }),
     });
     assertEq(exit, 1);
     const summary = events[events.length - 1];
@@ -108,11 +110,13 @@ export const mixedPassFail = () => {
 export const returnValueSubTree = () => {
     const inner = () => ({ result: ['ok', undefined], duration: 0 });
     const [events, exit] = run({
-        'r.test.f.ts': () => ({
-            outer: () => ({
-                result: ['ok', { inner }],
-                duration: 0,
-            }),
+        'r.proof.f.ts': () => ({
+            proof: {
+                outer: () => ({
+                    result: ['ok', { inner }],
+                    duration: 0,
+                }),
+            }
         }),
     });
     // outer passes, then inner (from return value) also passes
@@ -126,7 +130,7 @@ export const returnValueSubTree = () => {
 // integer-indexed array keys appear as numeric path segments
 export const arrayKeys = () => {
     const [events, exit] = run({
-        'a.test.f.ts': () => ({ arr: [ok0, ok0] }),
+        'a.proof.f.ts': () => ({ proof: { arr: [ok0, ok0] } }),
     });
     assertEq(exit, 0);
     const passEvents = events.filter(e => e[0] === 'result');
@@ -134,22 +138,24 @@ export const arrayKeys = () => {
     assertEq(passEvents[0][2][1], '0');
     assertEq(passEvents[1][2][1], '1');
 };
-// non-test files are skipped (only files ending in test.f.ts/js are loaded)
+// non-proof files are skipped: plain `.ts` is not loaded; `.f.ts` without
+// a `proof` export is loaded but produces no events
 export const nonTestFilesSkipped = () => {
     const [events, exit] = run({
-        'helper.ts': () => ({ a: ok0 }),
-        'b.test.f.ts': () => ({ x: ok0 }),
+        'helper.ts': () => ({ a: ok0 }), // not loaded (plain .ts)
+        'module.f.ts': () => ({ someExport: ok0 }), // loaded, no proof → skipped
+        'b.proof.f.ts': () => ({ proof: { x: ok0 } }), // loaded, has proof → runs
     });
     assertEq(exit, 0);
     const results = events.filter(e => e[0] === 'result');
     assertEq(results.length, 1);
-    assertEq(results[0][1], './b.test.f.ts');
+    assertEq(results[0][1], './b.proof.f.ts');
 };
 // multiple test files each produce result events
 export const multipleFiles = () => {
     const [events, exit] = run({
-        'a.test.f.ts': () => ({ x: ok0 }),
-        'b.test.f.ts': () => ({ y: ok0 }),
+        'a.proof.f.ts': () => ({ proof: { x: ok0 } }),
+        'b.proof.f.ts': () => ({ proof: { y: ok0 } }),
     });
     assertEq(exit, 0);
     const results = events.filter(e => e[0] === 'result');
@@ -164,51 +170,86 @@ export const throwByFunctionName = () => {
     // const named = ({ throw: () => fail0() }).throw
     const x = { throw: () => fail0() };
     const [events, exit] = run({
-        't.test.f.ts': () => ({ here: x.throw }),
+        't.proof.f.ts': () => ({ proof: { here: x.throw } }),
     });
     assertEq(exit, 0);
     const passEvents = events.filter(e => e[0] === 'result');
     assertEq(passEvents.length, 1);
     assertEq(passEvents[0][2][0], 'here');
 };
-// every module export — `default` and named — becomes a top-level path segment
+// only the `proof` export is used; other module properties are ignored
 export const namedExports = () => {
     const [events, exit] = run({
-        'e.test.f.ts': () => ({ default: ok0, helper: ok0 }),
+        'e.proof.f.ts': () => ({ proof: { a: ok0, b: ok0 }, other: ok0 }),
     });
     assertEq(exit, 0);
     const passEvents = events.filter(e => e[0] === 'result');
-    assertEq(passEvents.length, 2);
-    assertEq(passEvents[0][2][0], 'default');
-    assertEq(passEvents[1][2][0], 'helper');
+    assertEq(passEvents.length, 2); // `other` is ignored
+    assertEq(passEvents[0][2][0], 'a');
+    assertEq(passEvents[1][2][0], 'b');
 };
 // the default (non-GitHub) reporter formats module/pass/summary lines on stdout
 export const defaultReporterOutput = () => {
     const [stdout, stderr, exit] = runMain({
-        'a.test.f.ts': () => ({ x: ok0 }),
+        'a.proof.f.ts': () => ({ proof: { x: ok0 } }),
     });
     assertEq(exit, 0);
     assertEq(stderr, '');
-    assertEq(stdout, 'import("./a.test.f.ts").x(): ok, 0.0000 ms\n'
+    assertEq(stdout, 'import("./a.proof.f.ts").proof.x(): ok, 0.0000 ms\n'
         + 'Number of tests: pass: 1, fail: 0, total: 1\n'
         + 'Time: 0.0000 ms\n');
 };
 // a failure on the non-GitHub reporter writes the error to stderr, not stdout
 export const defaultReporterFailOutput = () => {
     const [, stderr, exit] = runMain({
-        'a.test.f.ts': () => ({ bad: fail0 }),
+        'a.proof.f.ts': () => ({ proof: { bad: fail0 } }),
     });
     assertEq(exit, 1);
-    assertEq(stderr, 'import("./a.test.f.ts").bad(): error, 0.0000 ms\noops\n');
+    assertEq(stderr, 'import("./a.proof.f.ts").proof.bad(): error, 0.0000 ms\noops\n');
 };
 // the GitHub reporter emits an `::error` annotation with a percent-encoded
 // title (the JSON path) and message
 export const githubReporterOutput = () => {
     const [, stderr, exit] = runMain({
-        's.test.f.ts': () => ({ 'a:b,c%d': fail0 }),
+        's.proof.f.ts': () => ({ proof: { 'a:b,c%d': fail0 } }),
     }, true);
     assertEq(exit, 1);
-    assertEq(stderr, '::error file=./s.test.f.ts,line=1,title=import("./s.test.f.ts")["a%3Ab%2Cc%25d"]()::oops\n');
+    assertEq(stderr, '::error file=./s.proof.f.ts,line=1,title=import("./s.proof.f.ts").proof["a%3Ab%2Cc%25d"]()::oops\n');
+};
+// registerModule appends ' ...' for inline runners (Bun/Playwright).
+// Uses a minimal synchronous mock for the Test/All/Await effect operations.
+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) => {
+            let st = s;
+            const rs = [];
+            for (const e of effects) {
+                const [ns, r] = runner(st)(e);
+                st = ns;
+                rs.push(r);
+            }
+            return [st, rs];
+        },
+        await: (s, p) => [s, [p]],
+    });
+    runner = makeRunner();
+    const proof = {
+        ok: () => { },
+        throw: { a: () => { throw 'expected'; } },
+    };
+    // Node (star = ''): no suffixes
+    const [nodeNames] = runner([])(registerModule(noopCtx, './a.f.ts', proof, ''));
+    assertEq(nodeNames.length, 2);
+    assertEq(nodeNames[0], 'import("./a.f.ts").proof.ok()');
+    assertEq(nodeNames[1], 'import("./a.f.ts").proof.throw.a()');
+    // Bun/Playwright (star = ' ...'): ... on normal tests, path shows throw for throw-tests
+    const [inlineNames] = runner([])(registerModule(noopCtx, './a.f.ts', proof, ' ...'));
+    assertEq(inlineNames.length, 2);
+    assertEq(inlineNames[0], 'import("./a.f.ts").proof.ok() ...');
+    assertEq(inlineNames[1], 'import("./a.f.ts").proof.throw.a()');
 };
 // direct unit tests for the pure path-format helpers
 export const helpers = {
@@ -229,12 +270,32 @@ export const helpers = {
         assert(!isIdentifier('1a'));
         assert(!isIdentifier('a-b'));
     },
+    shouldLoad: () => {
+        // all .f.ts / .f.js — FS modules are safe to bulk-load
+        assert(shouldLoad('module.f.ts'));
+        assert(shouldLoad('module.f.js'));
+        assert(shouldLoad('a.proof.f.ts'));
+        assert(shouldLoad('dir/module.f.ts'));
+        // vanilla opt-in by filename
+        assert(shouldLoad('proof.ts'));
+        assert(shouldLoad('proof.js'));
+        assert(shouldLoad('proof.mts'));
+        assert(shouldLoad('proof.mjs'));
+        assert(shouldLoad('math.proof.ts'));
+        assert(shouldLoad('math.proof.js'));
+        assert(shouldLoad('math.proof.mts'));
+        assert(shouldLoad('dir/math.proof.ts'));
+        // non-FS, non-proof vanilla files are not loaded
+        assert(!shouldLoad('helper.ts'));
+        assert(!shouldLoad('module.ts'));
+        assert(!shouldLoad('proof.tsx'));
+    },
     fmtImport: () => {
-        assertEq(fmtImport('./a.test.f.ts', []), 'import("./a.test.f.ts")()');
-        assertEq(fmtImport('./a.test.f.ts', ['math', 'add']), 'import("./a.test.f.ts").math.add()');
-        assertEq(fmtImport('./a.test.f.ts', ['users', '3']), 'import("./a.test.f.ts").users[3]()');
-        assertEq(fmtImport('./a.test.f.ts', ['x', 'hello world']), 'import("./a.test.f.ts").x["hello world"]()');
-        assertEq(fmtImport('./a.test.f.ts', ['outer', null, 'inner']), 'import("./a.test.f.ts").outer().inner()');
+        assertEq(fmtImport('./a.proof.f.ts', []), 'import("./a.proof.f.ts").proof()');
+        assertEq(fmtImport('./a.proof.f.ts', ['math', 'add']), 'import("./a.proof.f.ts").proof.math.add()');
+        assertEq(fmtImport('./a.proof.f.ts', ['users', '3']), 'import("./a.proof.f.ts").proof.users[3]()');
+        assertEq(fmtImport('./a.proof.f.ts', ['x', 'hello world']), 'import("./a.proof.f.ts").proof.x["hello world"]()');
+        assertEq(fmtImport('./a.proof.f.ts', ['outer', null, 'inner']), 'import("./a.proof.f.ts").proof.outer().inner()');
     },
     fmtPath: () => {
         assertEq(fmtPath([]), '');
@@ -257,3 +318,21 @@ export const helpers = {
         assertEq(ghEscape('a%b:c,d'), 'a%25b%3Ac%2Cd');
     },
 };
+export const proof = {
+    flat,
+    nested,
+    throwKey,
+    throwKeyFail,
+    mixedPassFail,
+    returnValueSubTree,
+    arrayKeys,
+    nonTestFilesSkipped,
+    multipleFiles,
+    throwByFunctionName,
+    namedExports,
+    defaultReporterOutput,
+    defaultReporterFailOutput,
+    githubReporterOutput,
+    registerSuffixes,
+    helpers
+};

package/fs/emergent-testing/scenarios/async-subtests.fail.d.ts

@@ -0,0 +1,6 @@
+export declare const proof: {
+    withSubtests: () => Promise<{
+        sub1: () => void;
+        sub2: () => never;
+    }>;
+};

package/fs/emergent-testing/scenarios/async-subtests.fail.js

@@ -0,0 +1,9 @@
+export const proof = {
+    withSubtests: async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        return {
+            sub1: () => { },
+            sub2: () => { throw 'sub-test failure'; },
+        };
+    }
+};

package/fs/emergent-testing/scenarios/async-subtests.pass.d.ts

@@ -0,0 +1,6 @@
+export declare const proof: {
+    withSubtests: () => Promise<{
+        sub1: () => void;
+        sub2: () => void;
+    }>;
+};

package/fs/emergent-testing/scenarios/async-subtests.pass.js

@@ -0,0 +1,9 @@
+export const proof = {
+    withSubtests: async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        return {
+            sub1: () => { },
+            sub2: () => { },
+        };
+    }
+};

package/fs/emergent-testing/scenarios/async.fail.d.ts

@@ -0,0 +1,3 @@
+export declare const proof: {
+    sleep_fail: () => Promise<never>;
+};

package/fs/emergent-testing/scenarios/async.fail.js

@@ -0,0 +1,6 @@
+export const proof = {
+    sleep_fail: async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        throw 'async failure';
+    }
+};

package/fs/emergent-testing/scenarios/async.pass.d.ts

@@ -0,0 +1,3 @@
+export declare const proof: {
+    sleep: () => Promise<void>;
+};

package/fs/emergent-testing/scenarios/async.pass.js

@@ -0,0 +1,5 @@
+export const proof = {
+    sleep: async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+    }
+};

package/fs/emergent-testing/scenarios/fail.fail.d.ts

@@ -0,0 +1,3 @@
+export declare const proof: {
+    failing: () => never;
+};

package/fs/emergent-testing/scenarios/fail.fail.js

@@ -0,0 +1,3 @@
+export const proof = {
+    failing: () => { throw 'intentional failure'; }
+};

package/fs/emergent-testing/scenarios/return-value.pass.d.ts

@@ -0,0 +1,3 @@
+export declare const proof: {
+    outer: () => unknown;
+};

package/fs/emergent-testing/scenarios/return-value.pass.js

@@ -0,0 +1,4 @@
+const inner = () => { };
+export const proof = {
+    outer: () => ({ inner })
+};

package/fs/emergent-testing/scenarios/thenable.pass.d.ts

@@ -0,0 +1,5 @@
+export declare const proof: {
+    thenableResolves: () => {
+        then(resolve: (v: undefined) => void): void;
+    };
+};

package/fs/emergent-testing/scenarios/thenable.pass.js

@@ -0,0 +1,11 @@
+// A test that returns a thenable (Promise-like object, not a real Promise).
+// Per FunctionalScript convention, thenables are treated as plain values —
+// not awaited. Both sandbox (fjs) and registerModule (node/bun/deno/playwright)
+// must exit 0: the thenable object is walked as a sub-tree whose only key
+// `then` is a function with parameters, so no leaf tests are found and the
+// test trivially passes.
+export const proof = {
+    thenableResolves: () => ({
+        then(resolve) { resolve(undefined); }
+    })
+};

package/fs/emergent-testing/scenarios/thenable2.pass.d.ts

@@ -0,0 +1,5 @@
+export declare const proof: {
+    shouldPass: () => {
+        then: () => string;
+    };
+};

package/fs/emergent-testing/scenarios/thenable2.pass.js

@@ -0,0 +1,3 @@
+export const proof = {
+    shouldPass: () => ({ then: () => 'ok' })
+};

package/fs/emergent-testing/scenarios/throw.pass.d.ts

@@ -0,0 +1,5 @@
+export declare const proof: {
+    throw: {
+        a: () => never;
+    };
+};

package/fs/{dev/tf/scenarios/throw.pass.f.js → emergent-testing/scenarios/throw.pass.js}

@@ -1,3 +1,3 @@
-export default {
+export const proof = {
     throw: { a: () => { throw 'expected'; } }
 };

package/fs/fjs/module.f.js

@@ -4,10 +4,9 @@
  * @module
  */
 import { compile } from "../djs/module.f.js";
-import { main as testMain } from "../dev/tf/module.f.js";
+import { main as testMain } from "../emergent-testing/module.f.js";
 import { main as casMain } from "../cas/module.f.js";
-import { import_, error } from "../types/effects/node/module.f.js";
-import { pure } from "../types/effects/module.f.js";
+import { import_, errorExit } from "../types/effects/node/module.f.js";
 export const main = options => {
     const [command, ...rest] = options.args;
     switch (command) {
@@ -31,8 +30,8 @@ export const main = options => {
             });
         }
         case undefined:
-            return error('Error: command is required').step(() => pure(1));
+            return errorExit('Error: command is required');
         default:
-            return error(`Error: Unknown command "${command}"`).step(() => pure(1));
+            return errorExit(`Error: Unknown command "${command}"`);
     }
 };

package/fs/fsc/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     a: () => void;
     fn: () => void;
     f1: () => void;
@@ -6,4 +6,3 @@ declare const _default: {
     f3: () => void;
     f4: () => void;
 };
-export default _default;

package/fs/fsc/{test.f.js → proof.f.js}

@@ -11,7 +11,7 @@ const fn = (f, name) => ({ [name]: f }[name]);
 const withName = (name) => 
 // translated into one command: define a `function [name]() { return undefined }`
 Object.getOwnPropertyDescriptor({ [name]: () => undefined }, name).value;
-export default {
+export const proof = {
     a: () => {
         const x = f('1');
         if (x !== '["1"]') {

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

@@ -0,0 +1,4 @@
+export declare const proof: {
+    dfa: () => void;
+    run: (() => void)[];
+};

package/fs/fsm/{test.f.js → proof.f.js}

@@ -28,7 +28,7 @@ const buildDfa = () => {
     ];
     return dfa(grammar);
 };
-export default {
+export const proof = {
     dfa: () => {
         const dfa = buildDfa();
         const entries = Object.entries(dfa);

package/fs/html/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     empty: () => void;
     empty2: () => void;
     void: () => void;
@@ -13,4 +13,3 @@ declare const _default: {
         noRaw: () => void;
     };
 };
-export default _default;

package/fs/html/{test.f.js → proof.f.js}

@@ -1,5 +1,5 @@
 import { htmlToString } from "./module.f.js";
-export default {
+export const proof = {
     empty: () => {
         const r = htmlToString(['html']);
         if (r !== '<!DOCTYPE html><html></html>') {

package/fs/io/module.d.ts

@@ -4,6 +4,6 @@ import { type Result } from '../types/result/module.f.ts';
 export declare const asyncImport: (v: string) => Promise<Module>;
 export declare const tryCatch: <T>(f: () => T) => Result<T, unknown>;
 export declare const io: Io;
-export type NodeRun = (p: NodeProgram) => Promise<number>;
+export type NodeRun = (p: NodeProgram) => Promise<never>;
 declare const effectRun: NodeRun;
 export default effectRun;

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

@@ -74,7 +74,7 @@ export type Process = {
     readonly stderr: Writable;
 };
 export type TryCatch = <T>(f: () => T) => Result<T, unknown>;
-export type Sandbox = <T>(f: () => T) => SandboxResult<T>;
+export type Sandbox = <T>(f: () => T) => Promise<SandboxResult<T>>;
 export type Server = {
     readonly listen: (port: number) => void;
 };
@@ -120,6 +120,7 @@ export type Io = {
     readonly bunTestContext: TestContext;
     readonly playwrightTestContext: TestContext;
     readonly engine: Engine;
+    readonly await: (p: unknown) => Promise<readonly [unknown]>;
 };
 export type App = (io: Io) => Promise<number>;
 export type Run = (f: App) => Promise<never>;
@@ -129,5 +130,5 @@ export type Run = (f: App) => Promise<never>;
  */
 export declare const run: (io: Io) => Run;
 export type EffectToPromise = <T>(effect: Effect<NodeOp, T>) => Promise<T>;
-export declare const fromIo: ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox: ioSandbox, write: ioWrite, }: Io) => EffectToPromise;
+export declare const fromIo: ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox, write, await: awaitPromise, }: Io) => EffectToPromise;
 export declare const runProgram: (io: Io) => (args: readonly string[]) => (program: NodeProgram) => Promise<number>;

package/fs/io/module.f.js

@@ -45,7 +45,7 @@ const collect = async (v) => {
     }
     return result;
 };
-export const fromIo = ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox: ioSandbox, write: ioWrite, }) => {
+export const fromIo = ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox, write, await: awaitPromise, }) => {
     const result = asyncRun({
         all: async (...effects) => await Promise.all(effects.map(result)),
         fetch: async (url) => tc(async () => {
@@ -95,8 +95,9 @@ export const fromIo = ({ fs: { promises: { mkdir, readFile, readdir, writeFile,
         },
         forever: () => new Promise(() => { }),
         now: async () => ioNow(),
-        sandbox: async (f) => ioSandbox(f),
-        write: ioWrite,
+        sandbox,
+        await: awaitPromise,
+        write,
         test: async (ctx, name, expectFailure, test) => ctx.test(name, { expectFailure }, async (t) => result(test(t))),
     });
     return result;

package/fs/io/module.js

@@ -12,7 +12,7 @@ import fs from 'node:fs';
 import process from 'node:process';
 import { concat } from "../path/module.f.js";
 import { once } from 'node:events';
-import { fromIo, runProgram } from "./module.f.js";
+import { runProgram } from "./module.f.js";
 import { error, ok } from "../types/result/module.f.js";
 import { fromVec } from "../types/uint8array/module.f.js";
 import * as testContext from 'node:test';
@@ -35,12 +35,11 @@ const inlineTest = async (name, { expectFailure }, fn) => {
     }
 };
 const inlineContext = { test: inlineTest };
-const bunTestContext = {
-    test: (name, opts, fn) => testContext.test(name, () => inlineTest(name, opts, fn))
-};
-const playwrightTestContext = {
-    test: (name, opts, fn) => pwTest(name, () => inlineTest(name, opts, fn))
-};
+const wrapInlineTest = (register) => ({
+    test: (name, opts, fn) => register(name, () => inlineTest(name, opts, fn))
+});
+const bunTestContext = wrapInlineTest(testContext.test);
+const playwrightTestContext = wrapInlineTest(pwTest);
 const prefix = 'file:///';
 const { now } = Date;
 /** Maps `WriteConsoles` names to the corresponding Node.js writable streams. */
@@ -76,6 +75,7 @@ export const tryCatch = f => {
         return error(e);
     }
 };
+const awaitPromise = async (p) => [p instanceof Promise ? await p : p];
 export const io = {
     console,
     fs,
@@ -99,14 +99,18 @@ export const io = {
     http,
     childProcess,
     now,
-    sandbox: (f) => {
+    sandbox: async (f) => {
         let result;
         let after;
         const before = performance.now();
         try {
-            const value = f();
+            let p = f();
             after = performance.now();
-            result = ok(value);
+            if (p instanceof Promise) {
+                p = await p;
+                after = performance.now();
+            }
+            result = ok(p);
         }
         catch (e) {
             after = performance.now();
@@ -115,10 +119,14 @@ export const io = {
         return { result, duration: after - before };
     },
     write: (stream, data) => writeAll(streams[stream], fromVec(data)),
+    await: awaitPromise,
     testContext,
     bunTestContext,
     playwrightTestContext,
     engine: isPlaywright ? 'playwright' : 'Bun' in globalThis ? 'bun' : 'node',
 };
-const effectRun = runProgram(io)(io.process.argv.slice(2));
+const effectRun = async (p) => {
+    const code = await runProgram(io)(io.process.argv.slice(2))(p);
+    return process.exit(code);
+};
 export default effectRun;

package/fs/js/tokenizer/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     djs: (() => void)[];
     operators: (() => void)[];
     ws: (() => void)[];
@@ -7,4 +7,3 @@ declare const _default: {
     comments: (() => void)[];
     metadata: (() => void)[];
 };
-export default _default;

package/fs/js/tokenizer/{test.f.js → proof.f.js}

@@ -7,7 +7,7 @@ const tokenizeString = s => toArray(map(withoutMetada)(tokenize(stringToList(s))
 const tokenizeStringWithMetadata = s => toArray(tokenize(stringToList(s))(''));
 const stringify = stringifyAsTree(sort);
 const withoutMetada = tokenWithMetada => tokenWithMetada.token;
-export default {
+export const proof = {
     djs: [
         () => {
             const result = stringify(tokenizeString(''));