functionalscript 0.37.0 → 0.39.0

package/{fs → fjs}/effects/node/virtual/proof.f.js

@@ -1,5 +1,5 @@
-import { assertEq } from '../../../asserts/module.f.js';
-import { awaitIfPromise, fetch, rm, writeFile, readFile, readdir, import_, rename, readBytes, writeBytes } from '../module.f.js';
+import { assert, assertEq } from '../../../asserts/module.f.js';
+import { access, awaitIfPromise, fetch, rm, writeFile, readFile, readdir, import_, rename, readBytes, writeBytes } from '../module.f.js';
 import { maxLengthBytes, vec, vec8 } from '../../../types/bit_vec/module.f.js';
 import { emptyState, virtual } from './module.f.js';
 export const proof = {
@@ -7,24 +7,24 @@ export const proof = {
         success: () => {
             const root = { 'a.txt': [vec8(0x42n)] };
             const [, result] = virtual({ ...emptyState, root })(rm('a.txt'));
-            assertEq(result[0], 'ok');
+            assert(result[0] === 'ok');
         },
         notFound: () => {
             const [, result] = virtual(emptyState)(rm('notexist.txt'));
-            assertEq(result[0], 'error');
+            assert(result[0] === 'error');
         },
         isDirectory: () => {
             const inner = {};
             const root = { 'mydir': inner };
             const [, result] = virtual({ ...emptyState, root })(rm('mydir'));
-            assertEq(result[0], 'error');
+            assert(result[0] === 'error');
         },
     },
     writeFileOnDirectory: () => {
         const inner = {};
         const root = { 'mydir': inner };
         const [, result] = virtual({ ...emptyState, root })(writeFile('mydir', vec8(0x42n)));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     readdirRecursive: () => {
         const file = [vec8(0x42n)];
@@ -32,12 +32,19 @@ export const proof = {
         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;
-        }
+        assert(result[0] === 'ok');
+        assert(result[0] === 'ok', result);
         assertEq(result[1].length, 2);
     },
+    accessNestedPathThroughFile: () => {
+        // 'a/b/c' where 'a' is a file: the operation wrapper's "not a directory"
+        // fallback passes the full remaining path through unchanged, covering the
+        // path.length !== 1 branch of the access op (only path.length === 0 was
+        // otherwise exercised).
+        const root = { 'a': [vec8(0x42n)] };
+        const [, result] = virtual({ ...emptyState, root })(access('a/b/c'));
+        assert(result[0] === 'error');
+    },
     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
@@ -45,7 +52,7 @@ export const proof = {
         const outer = { 'b': inner };
         const root = { 'a': outer };
         const [, result] = virtual({ ...emptyState, root })(readFile('a/b'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     awaitNonPromise: () => {
         // a non-promise value passes through the virtual `await` handler as-is
@@ -55,19 +62,19 @@ export const proof = {
     fetchNotFound: () => {
         // covers the `result === undefined` branch of the `fetch` handler
         const [, result] = virtual(emptyState)(fetch('https://example.com/missing'));
-        assertEq(result[0], 'error');
+        assert(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');
+        assert(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');
+        assert(result[0] === 'error');
     },
     throw: {
         readFileOnJsModule: () => {
@@ -80,37 +87,37 @@ export const proof = {
         // rename('a', 'a') should succeed as a no-op, not reject
         const root = { 'a': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(rename('a', 'a'));
-        assertEq(result[0], 'ok');
+        assert(result[0] === 'ok');
     },
     renameIntoOwnSubtree: () => {
         // rename('a', 'a/b') should fail (dst inside src's subtree)
         const root = { 'a': { 'b': [vec8(0x42n)] } };
         const [, result] = virtual({ ...emptyState, root })(rename('a', 'a/b'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     renameOntoOwnAncestor: () => {
         // rename('a/b', 'a') should fail (src inside dst's subtree)
         const root = { 'a': { 'b': [vec8(0x42n)] } };
         const [, result] = virtual({ ...emptyState, root })(rename('a/b', 'a'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     renameNonEmptyDirOverEmptyDir: () => {
         // rename a directory onto an empty directory should succeed
         const root = { 'src': { 'file': [vec8(0x42n)] }, 'dst': {} };
         const [, result] = virtual({ ...emptyState, root })(rename('src', 'dst'));
-        assertEq(result[0], 'ok');
+        assert(result[0] === 'ok');
     },
     renameEmptyDirOverNonEmptyDir: () => {
         // rename an empty directory onto a non-empty directory should fail
         const root = { 'src': {}, 'dst': { 'file': [vec8(0x42n)] } };
         const [, result] = virtual({ ...emptyState, root })(rename('src', 'dst'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     renameFileOntoDirectory: () => {
         // rename a file to a path that is already an existing directory should fail
         const root = { 'myfile': [vec8(0x42n)], 'mydir': {} };
         const [, result] = virtual({ ...emptyState, root })(rename('myfile', 'mydir'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     readFileTooLarge: () => {
         // a file stored as two max-size chunks exceeds the limit; readFile must return an error
@@ -118,37 +125,37 @@ export const proof = {
         const chunk1 = vec(1n)(1n);
         const root = { 'big': [chunk0, chunk1] };
         const [, result] = virtual({ ...emptyState, root })(readFile('big'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     readBytesNegativeSize: () => {
         // readBytes with negative size should fail
         const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0, -1));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     readBytesZeroSize: () => {
         // readBytes with zero size should succeed and return empty vec
         const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0, 0));
-        assertEq(result[0], 'ok');
+        assert(result[0] === 'ok');
     },
     readBytesNegativeOffset: () => {
         // readBytes with negative offset should fail
         const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', -1, 1));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     readBytesFractionalSize: () => {
         // readBytes with fractional size should fail rather than throw RangeError
         const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0, 1.5));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     readBytesFractionalOffset: () => {
         // readBytes with fractional offset should fail rather than throw RangeError
         const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0.5, 1));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     readBytesAcrossChunkBoundary: () => {
         // Two 128 KiB chunks; read 2 bytes spanning the boundary (last byte of chunk 0, first of chunk 1).
@@ -157,14 +164,14 @@ export const proof = {
         const chunk1 = vec(maxLengthBytes * 8n)(0xbbn);
         const root = { 'big': [chunk0, chunk1] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('big', chunkSize - 1, 2));
-        assertEq(result[0], 'ok');
+        assert(result[0] === 'ok');
     },
     writeBytesWrongOffset: () => {
         // writeBytes is append-only; an offset that doesn't match the current
         // file size must fail rather than silently create a hole.
         const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(writeBytes('file', 5, vec8(0x43n)));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     largeFileReadBytes: () => {
         // A file stored as two 128 KiB chunks is larger than maxLengthBytes.
@@ -174,6 +181,6 @@ export const proof = {
         const chunk1 = vec(maxLengthBytes * 8n)(0xffn);
         const root = { 'large': [chunk0, chunk1] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('large', chunkSize, 1));
-        assertEq(result[0], 'ok');
+        assert(result[0] === 'ok');
     },
 };

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

@@ -0,0 +1,51 @@
+import { type Effect, type Operation } from './module.f.ts';
+/**
+ * Asserts that `e` yields `expected` without performing a command. Exported so
+ * `eff/proof.f.ts` shares this definition instead of repeating it.
+ *
+ * Not `assertEq(runPure(e), [expected])`: `assertEq` compares with `===`, so a
+ * freshly allocated `[expected]` is never equal to the returned option. Assert
+ * the option's shape first, then compare the value inside it.
+ */
+export declare const assertPure: <O extends Operation, T>(e: Effect<O, T>, expected: T) => void;
+export declare const proof: {
+    foldStep: {
+        empty: () => void;
+        threadsState: () => void;
+        order: () => void;
+    };
+    forEachStep: {
+        empty: () => void;
+        runs: () => void;
+    };
+    okStep: {
+        ok: () => void;
+        error: () => void;
+    };
+    runPure: {
+        pure: () => void;
+        pureNull: () => void;
+        do_: () => void;
+    };
+    doNode: () => void;
+    match: {
+        done: () => void;
+        cont: () => void;
+    };
+    step: {
+        pure: () => void;
+        chain: () => void;
+        overDo: () => void;
+    };
+    mapStep: {
+        pure: () => void;
+        constant: () => void;
+        overDo: () => void;
+    };
+    historyStep: {
+        pure: () => void;
+        overDo: () => void;
+        chain: () => void;
+        fReceivesWholeHistory: () => void;
+    };
+};

package/fjs/effects/proof.f.js

@@ -0,0 +1,178 @@
+import { step, do_, foldStep, forEachStep, mapStep, match, okStep, history, pure, runPure, historyStep } from './module.f.js';
+import { error, ok } from '../types/result/module.f.js';
+import { assert, assertEq } from '../asserts/module.f.js';
+/**
+ * Asserts that `e` yields `expected` without performing a command. Exported so
+ * `eff/proof.f.ts` shares this definition instead of repeating it.
+ *
+ * Not `assertEq(runPure(e), [expected])`: `assertEq` compares with `===`, so a
+ * freshly allocated `[expected]` is never equal to the returned option. Assert
+ * the option's shape first, then compare the value inside it.
+ */
+export const assertPure = (e, expected) => {
+    const o = runPure(e);
+    assert(o.length === 1, e);
+    assertEq(o[0], expected);
+};
+const next = match({ add: (a, b) => a + b });
+export const proof = {
+    foldStep: {
+        empty: () => {
+            const e = foldStep(pure([]), 10, x => s => pure(s + x));
+            assertPure(e, 10);
+        },
+        threadsState: () => {
+            const e = foldStep(pure([1, 2, 3, 4]), 0, x => s => pure(s + x));
+            assertPure(e, 10);
+        },
+        order: () => {
+            const e = foldStep(pure(['a', 'b', 'c']), '', x => s => pure(s + x));
+            assertPure(e, 'abc');
+        },
+    },
+    forEachStep: {
+        empty: () => {
+            const e = forEachStep(pure([]), () => pure(undefined));
+            assertPure(e, undefined);
+        },
+        runs: () => {
+            const e = forEachStep(pure([1, 2, 3]), () => pure(undefined));
+            assertPure(e, undefined);
+        },
+    },
+    okStep: {
+        ok: () => {
+            const e = step(pure(ok(5)), okStep((v) => pure(ok(v * 2))));
+            const o = runPure(e);
+            assert(o.length === 1, e);
+            const [r] = o;
+            assert(r[0] === 'ok', r);
+            assertEq(r[1], 10);
+        },
+        error: () => {
+            const e = step(pure(error('oops')), okStep(v => pure(ok(v * 2))));
+            const o = runPure(e);
+            assert(o.length === 1, e);
+            const [r] = o;
+            assert(r[0] === 'error', r);
+            assertEq(r[1], 'oops');
+        },
+    },
+    runPure: {
+        pure: () => {
+            const o = runPure(pure(5));
+            assert(o.length === 1, o);
+            assertEq(o[0], 5);
+        },
+        // A pure `null` is `[null]`, never `[]`. Collapsing the two is what a
+        // `T | null` result would do, and why the option is tagged.
+        pureNull: () => {
+            const o = runPure(pure(null));
+            assertEq(o.length, 1, o);
+            assertEq(o[0], null);
+        },
+        do_: () => {
+            assertEq(runPure(do_('add')(2, 3)).length, 0);
+        },
+    },
+    // The one place a `Do` node is opened on purpose: `do_` builds the command,
+    // the payload it was called with, and a continuation that resumes with the
+    // command's output. Everything else goes through `step`, `match`, or
+    // `runPure`.
+    doNode: () => {
+        const e = do_('add')(2, 3);
+        assert(typeof e !== 'function', e);
+        const { command, payload, continuation } = e;
+        assertEq(command, 'add');
+        const [a, b] = payload;
+        assertEq(a, 2, payload);
+        assertEq(b, 3, payload);
+        assertPure(continuation(5), 5);
+    },
+    match: {
+        done: () => {
+            const r = next(pure(7));
+            assert(r[0] === 'done', r);
+            assertEq(r[1], 7);
+        },
+        cont: () => {
+            const r = next(do_('add')(2, 3));
+            assert(r[0] === 'cont', r);
+            assertEq(r[1], 5);
+            const r2 = next(r[2](r[1]));
+            assert(r2[0] === 'done', r2);
+            assertEq(r2[1], 5);
+        },
+    },
+    step: {
+        pure: () => {
+            assertPure(step(pure(3), v => pure(v + 1)), 4);
+        },
+        chain: () => {
+            // Chains as step(step(e, f), g), raw effect in and out.
+            assertPure(step(step(pure(3), v => pure(v + 1)), v => pure(v * 2)), 8);
+        },
+        overDo: () => {
+            // Stepping a Do node preserves the command and threads the result
+            // through the rebuilt continuation.
+            const e = step(do_('add')(2, 3), r => pure(r * 10));
+            const r = next(e);
+            assert(r[0] === 'cont', r);
+            assertEq(r[1], 5);
+            assertPure(r[2](r[1]), 50);
+        },
+    },
+    mapStep: {
+        pure: () => {
+            assertPure(mapStep(pure(3), v => v + 1), 4);
+        },
+        constant: () => {
+            // The `() => v` shape a `constStep` would have covered.
+            assertPure(mapStep(pure('ignored'), () => 1), 1);
+        },
+        overDo: () => {
+            // A projection over a `Do` node keeps the command intact and is
+            // applied to the command's output when the continuation resumes.
+            const r = next(mapStep(do_('add')(2, 3), v => v * 10));
+            assert(r[0] === 'cont', r);
+            assertEq(r[1], 5);
+            assertPure(r[2](r[1]), 50);
+        },
+    },
+    historyStep: {
+        pure: () => {
+            const o = runPure(historyStep(history(pure(3)), v => pure(v * 2)));
+            assert(o.length === 1, o);
+            const [[result, param]] = o;
+            assertEq(param, 3);
+            assertEq(result, 6);
+        },
+        overDo: () => {
+            // The captured value survives a command boundary: the history is
+            // rebuilt inside the continuation rather than lost when `e` is a Do.
+            const c = next(historyStep(history(do_('add')(2, 3)), r => pure(r * 10)));
+            assert(c[0] === 'cont', c);
+            assertEq(c[1], 5);
+            const o = runPure(c[2](c[1]));
+            assert(o.length === 1, o);
+            const [[result, param]] = o;
+            assertEq(param, 5);
+            assertEq(result, 50);
+        },
+        chain: () => {
+            // `historyStep` takes a history and returns one, so link two is
+            // spelled exactly like link one. The tuple is newest first, so a
+            // destructuring reads reverse-chronologically.
+            const a = historyStep(history(pure(1)), x => pure(x + 1));
+            const b = historyStep(a, (result, param) => pure(result + param));
+            assertPure(step(b, ([z, y, x]) => pure(`${x}${y}${z}`)), '123');
+        },
+        fReceivesWholeHistory: () => {
+            // `f` is handed the whole history spread as arguments, not just the
+            // most recent value - which is what lets a later link reach back.
+            const a = historyStep(history(pure(1)), x => pure(x + 1));
+            const b = historyStep(a, (...p) => pure(p[1] * 100 + p[0]));
+            assertPure(step(b, ([result]) => pure(result)), 102);
+        },
+    },
+};

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

@@ -12,7 +12,8 @@
  */
 import { reset, fgGreen, fgRed, bold, csiWrite } from '../text/sgr/module.f.js';
 import { all, awaitIfPromise, sandbox, test } from '../effects/node/module.f.js';
-import { pure } from '../effects/module.f.js';
+import { history, historyStep, pure, step } from '../effects/module.f.js';
+import { eff } from '../effects/eff/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';
@@ -89,7 +90,7 @@ export const registerModule = (ctx, k, v, star) => {
         // test is expected to throw, so no extra suffix is needed.
         const base = fmtImport(k, path);
         const name = throws ? base : `${base}${star}`;
-        return test(ctx, name, throws, (t) => awaitIfPromise(fn())
+        return test(ctx, name, throws, (t) => eff(awaitIfPromise(fn()))
             .step(resolved => {
             if (throws) {
                 return pure(undefined);
@@ -98,42 +99,49 @@ export const registerModule = (ctx, k, v, star) => {
             if (sub.length === 0) {
                 return pure(undefined);
             }
-            return all(...sub.map(e => registerOne(t, e))).step(() => pure(undefined));
-        }));
+            return eff(all(...sub.map(e => registerOne(t, e))))
+                .step(() => pure(undefined))
+                .value;
+        })
+            .value);
     };
     const tests = collectTests([], false, v);
     if (tests.length === 0) {
         return pure(undefined);
     }
-    return all(...tests.map(e => registerOne(ctx, e))).step(() => pure(undefined));
+    return eff(all(...tests.map(e => registerOne(ctx, e))))
+        .step(() => pure(undefined))
+        .value;
 };
 const mergeState = (a, b) => ({ time: a.time + b.time, pass: a.pass + b.pass, fail: a.fail + b.fail });
 const zero = { time: 0, pass: 0, fail: 0 };
 const runModule = ({ result, test }) => (k, v) => (ts) => {
-    const one = ([testPath, set]) => test(k, testPath, set)
-        .step(sr => {
-        const { result: [s, r], duration } = sr;
-        return result(k, testPath, sr, set.throws)
-            .step(() => {
-            if (s === 'ok') {
-                if (set.throws) {
-                    return pure(addPass(duration)(zero));
-                }
-                // Walk return-value sub-tree; null marks the call boundary so
-                // paths render as e.g. `outer().inner`. throws resets to false.
-                return walk([...testPath, null], false, r)
-                    .step(sub => pure(mergeState(addPass(duration)(zero), sub)));
+    const one = ([testPath, set]) => {
+        // The sandbox result is still needed after it has been reported, so the
+        // reporting call is captured rather than nested inside its own step.
+        const reported = historyStep(history(test(k, testPath, set)), sr => result(k, testPath, sr, set.throws));
+        return step(reported, ([, sr]) => {
+            const { result: [s, r], duration } = sr;
+            if (s !== 'ok') {
+                return pure(addFail(duration)(zero));
             }
-            return pure(addFail(duration)(zero));
+            if (set.throws) {
+                return pure(addPass(duration)(zero));
+            }
+            // Walk return-value sub-tree; null marks the call boundary so
+            // paths render as e.g. `outer().inner`. throws resets to false.
+            return step(walk([...testPath, null], false, r), sub => pure(mergeState(addPass(duration)(zero), sub)));
         });
-    });
+    };
     const walk = (path, throws, v) => {
         const effects = collectTests(path, throws, v).map(one);
-        return all(...effects)
-            .step(states => pure(states.reduce(mergeState, zero)));
+        return eff(all(...effects))
+            .step(states => pure(states.reduce(mergeState, zero)))
+            .value;
     };
-    return walk([], false, v)
-        .step(delta => pure(mergeState(ts, delta)));
+    return eff(walk([], false, v))
+        .step(delta => pure(mergeState(ts, delta)))
+        .value;
 };
 const proofEntries = (moduleMap) => definedEntries(moduleMap)
     .flatMap(([k, v]) => v.proof !== undefined ? [[k, v.proof]] : []);
@@ -145,17 +153,20 @@ const proofEntries = (moduleMap) => definedEntries(moduleMap)
 export const runModuleMap = (reporter) => (moduleMap) => {
     const { summary } = reporter;
     const modules = proofEntries(moduleMap);
-    return all(...modules.map(([k, v]) => runModule(reporter)(k, v)(zero)))
+    return eff(all(...modules.map(([k, v]) => runModule(reporter)(k, v)(zero))))
         .step(m => pure(m.reduce(mergeState, zero)))
-        .step(ts => summary(ts.pass, ts.fail, ts.time)
-        .step(() => pure(ts.fail !== 0 ? 1 : 0)));
+        .step(ts => summary(ts.pass, ts.fail, ts.time))
+        .step((_, ts) => pure(ts.fail !== 0 ? 1 : 0))
+        .value;
 };
 /**
  * Discovers all test modules via `loadModuleMap`, then runs them through
  * `runModuleMap`. The composed effect is a `NodeProgram` entry point for the
  * `fjs t` test runner.
  */
-export const testAll = (reporter) => options => loadModuleMap(options.env).step(runModuleMap(reporter));
+export const testAll = (reporter) => options => eff(loadModuleMap(options.env))
+    .step(runModuleMap(reporter))
+    .value;
 /**
  * Registers all modules in `moduleMap` that export a `proof` property with
  * `ctx`. Delegates to `registerModule` for each matching entry.
@@ -165,7 +176,9 @@ const registerModuleMap = (ctx, star) => (moduleMap) => {
     if (modules.length === 0) {
         return pure(undefined);
     }
-    return all(...modules.map(([k, v]) => registerModule(ctx, k, v, star))).step(() => pure(undefined));
+    return eff(all(...modules.map(([k, v]) => registerModule(ctx, k, v, star))))
+        .step(() => pure(undefined))
+        .value;
 };
 const isAlpha = (c) => (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c === '_' || c === '$';
 const isDigit = (c) => c >= '0' && c <= '9';
@@ -219,8 +232,9 @@ export const ghEscape = (s) => s.replaceAll('%', '%25')
  * Default `Reporter.test` implementation: sandboxes `fn` once and inverts the
  * result when `throws` is `true` (caught error → pass, clean return → fail).
  */
-export const defaultTest = (file, path, { fn, throws }) => sandbox(fn)
-    .step(r => pure(throws ? { ...r, result: invert(r.result) } : r));
+export const defaultTest = (file, path, { fn, throws }) => eff(sandbox(fn))
+    .step(r => pure(throws ? { ...r, result: invert(r.result) } : r))
+    .value;
 const fmtResultLine = (file, path, color, label, duration) => `${fmtImport(file, path)}: ${color}${label}${reset}, ${timeFormat(duration)}`;
 /**
  * The terminal/GitHub reporter used by `fjs t`. Output goes through
@@ -244,12 +258,14 @@ export const defaultReporter = (options) => {
             ? csiLog(fmtResultLine(file, path, fgGreen, 'ok', duration) + (throws ? ' # EXPECTED TO THROW' : ''))
             : isGitHub
                 ? csiError(`::error file=${file},line=1,title=${ghEscape(fmtImport(file, path))}::${ghEscape(String(v))}`)
-                : csiError(fmtResultLine(file, path, fgRed, 'error', duration))
-                    .step(() => csiError(`${fgRed}${v}${reset}`)),
+                : eff(csiError(fmtResultLine(file, path, fgRed, 'error', duration)))
+                    .step(() => csiError(`${fgRed}${v}${reset}`))
+                    .value,
         summary: (pass, fail, time) => {
             const fgFail = fail === 0 ? fgGreen : fgRed;
-            return csiLog(`${bold}Number of tests: pass: ${fgGreen}${pass}${reset}${bold}, fail: ${fgFail}${fail}${reset}${bold}, total: ${pass + fail}${reset}`)
-                .step(() => csiLog(`${bold}Time: ${timeFormat(time)}${reset}`));
+            return eff(csiLog(`${bold}Number of tests: pass: ${fgGreen}${pass}${reset}${bold}, fail: ${fgFail}${fail}${reset}${bold}, total: ${pass + fail}${reset}`))
+                .step(() => csiLog(`${bold}Time: ${timeFormat(time)}${reset}`))
+                .value;
         },
         test: defaultTest,
     };
@@ -268,8 +284,8 @@ export const register = o => {
     const ctx = o.engine === 'bun' ? o.bunTestContext :
         o.engine === 'playwright' ? o.playwrightTestContext :
             o.testContext;
-    const r = registerModuleMap(ctx, star);
-    return loadModuleMap(o.env)
-        .step(r)
-        .step(() => pure(0));
+    return eff(loadModuleMap(o.env))
+        .step(registerModuleMap(ctx, star))
+        .step(() => pure(0))
+        .value;
 };

package/{fs → fjs}/emergent_testing/proof.f.d.ts

@@ -14,6 +14,8 @@ export declare const defaultReporterOutputLargeDuration: () => void;
 export declare const defaultReporterFailOutput: () => void;
 export declare const githubReporterOutput: () => void;
 export declare const registerSuffixes: () => void;
+export declare const registerThrowsWithoutThrowing: () => void;
+export declare const registerEmptyProof: () => void;
 export declare const helpers: {
     isInteger: () => void;
     isIdentifier: () => void;
@@ -45,6 +47,8 @@ export declare const proof: {
     defaultReporterFailOutput: typeof defaultReporterFailOutput;
     githubReporterOutput: typeof githubReporterOutput;
     registerSuffixes: typeof registerSuffixes;
+    registerThrowsWithoutThrowing: typeof registerThrowsWithoutThrowing;
+    registerEmptyProof: typeof registerEmptyProof;
     defaultReporterExpectedToThrow: typeof defaultReporterExpectedToThrow;
     helpers: {
         isInteger: () => void;