functionalscript 0.38.0 → 0.40.0

package/fjs/effects/node/proof.f.js

@@ -1,25 +1,46 @@
 import { empty, isVec, uint, vec, vec8 } from "../../types/bit_vec/module.f.js";
 import { utf8, utf8ToString } from "../../text/module.f.js";
-import { decode, pure } from "../module.f.js";
-import { both, fetch, mkdir, now, readdir, readFile, readUtf8File, rm, sandbox, writeFile, writeUtf8File, rename, readBytes, randomInt, writeFromStream } from "./module.f.js";
+import { match, pure, step } from "../module.f.js";
+import { both, fetch, mkdir, now, readdir, readFile, readUtf8File, rm, sandbox, writeFile, writeUtf8File, rename, readBytes, randomInt, writeFromStream, usesInlineTestContext, versionLessThan } from "./module.f.js";
 import { create as memCreate, read as memRead, write as memWrite } from "../memory/module.f.js";
 import { empty as listEmpty, nonEmpty as listNonEmpty } from "../list/module.f.js";
 import { emptyState, virtual } from "./virtual/module.f.js";
 import { assert, assertEq, assertNotNullish } from '../../asserts/module.f.js';
+import { ok } from '../../types/result/module.f.js';
+// Answers the one command the `map` proof below drives. Routing the loop
+// through `match` keeps the `Pure`/`Do` layout out of this module: the map key
+// is the command assertion, and `MatchResult` types the continuation.
+const readHello = match({
+    readFile: path => {
+        assertEq(path, 'hello');
+        return ok(vec8(0x15n));
+    },
+});
 export const proof = {
+    externalTestContext: () => {
+        assert(usesInlineTestContext('node', 'v22.20.0'));
+        assert(usesInlineTestContext('node', '25.99.99'));
+        assert(!usesInlineTestContext('node', '26.0.0'));
+        assert(!usesInlineTestContext('node', '26.1.0'));
+        assert(!usesInlineTestContext('node'));
+        assert(usesInlineTestContext('bun'));
+        assert(!usesInlineTestContext('deno', '22.0.0'));
+        assert(versionLessThan('25.99.99', '26.0.0'));
+        assert(versionLessThan('26.0.0', '26.1.0'));
+        assert(versionLessThan('26.1.0', '26.1.1'));
+        assert(!versionLessThan('26.1.1', '26.1.1'));
+    },
     map: () => {
-        const e = readFile('hello').step(([k, v]) => {
+        const e = step(readFile('hello'), ([k, v]) => {
             assert(k !== 'error', v);
             return pure(uint(v) * 2n);
         });
         //
-        let d = decode(e);
-        while (!d.done) {
-            assertEq(d.command, 'readFile');
-            assert(d.payload[0] === 'hello', d.payload);
-            d = decode(d.continuation(['ok', vec8(0x15n)]));
+        let r = readHello(e);
+        while (r[0] === 'cont') {
+            r = readHello(r[2](r[1]));
         }
-        assertEq(d.result, 0x2an);
+        assertEq(r[1], 0x2an);
     },
     fetch: () => {
         const [_, [t, result]] = virtual({
@@ -282,12 +303,12 @@ export const proof = {
     },
     memory: {
         createAndRead: () => {
-            const effect = memCreate(42).step(key => memRead(key));
+            const effect = step(memCreate(42), key => memRead(key));
             const [_, value] = virtual(emptyState)(effect);
             assertEq(value, 42);
         },
         createAndWrite: () => {
-            const effect = memCreate(1).step(key => memWrite(key, 99).step(() => memRead(key)));
+            const effect = step(memCreate(1), key => step(memWrite(key, 99), () => memRead(key)));
             const [_, value] = virtual(emptyState)(effect);
             assertEq(value, 99);
         },

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

@@ -435,6 +435,6 @@ export const defaultNodeProgramOptions = {
     std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
     testContext,
     bunTestContext: testContext,
-    playwrightTestContext: testContext,
     engine: 'node',
+    inlineTestContext: false,
 };

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

@@ -1,9 +1,14 @@
+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: {
-    lazy: {
-        value: () => void;
-        deferred: () => void;
-        step: () => void;
-    };
     foldStep: {
         empty: () => void;
         threadsState: () => void;
@@ -17,9 +22,30 @@ export declare const proof: {
         ok: () => void;
         error: () => void;
     };
-    decode: () => 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

@@ -1,72 +1,93 @@
-import { decode, do_, foldStep, forEachStep, lazy, match, okStep, pure } from './module.f.js';
+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';
-const assertPure = (e, expected) => {
-    const d = decode(e);
-    assert(d.done, e.value);
-    assertEq(d.result, expected);
+/**
+ * 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 = {
-    lazy: {
-        value: () => {
-            assertPure(lazy(() => 42), 42);
-        },
-        deferred: () => {
-            // The thunk runs only when the effect is decoded, not when `lazy` is called.
-            let evaluated = false;
-            const e = lazy(() => { evaluated = true; return 7; });
-            assert(!(evaluated), 'lazy must not evaluate eagerly');
-            assertPure(e, 7);
-            assert(evaluated, 'decode must force the thunk');
-        },
-        step: () => {
-            const e = lazy(() => 5).step(v => pure(v * 2));
-            assertPure(e, 10);
-        },
-    },
     foldStep: {
         empty: () => {
-            const e = foldStep((x) => (s) => pure(s + x))(10)([]);
+            const e = foldStep(pure([]), 10, x => s => pure(s + x));
             assertPure(e, 10);
         },
         threadsState: () => {
-            const e = foldStep((x) => (s) => pure(s + x))(0)([1, 2, 3, 4]);
+            const e = foldStep(pure([1, 2, 3, 4]), 0, x => s => pure(s + x));
             assertPure(e, 10);
         },
         order: () => {
-            const e = foldStep((x) => (s) => pure(s + x))('')(['a', 'b', 'c']);
+            const e = foldStep(pure(['a', 'b', 'c']), '', x => s => pure(s + x));
             assertPure(e, 'abc');
         },
     },
     forEachStep: {
         empty: () => {
-            const e = forEachStep(() => pure(undefined))([]);
+            const e = forEachStep(pure([]), () => pure(undefined));
             assertPure(e, undefined);
         },
         runs: () => {
-            const e = forEachStep(() => pure(undefined))([1, 2, 3]);
+            const e = forEachStep(pure([1, 2, 3]), () => pure(undefined));
             assertPure(e, undefined);
         },
     },
     okStep: {
         ok: () => {
-            const e = pure(ok(5)).step(okStep((v) => pure(ok(v * 2))));
-            const d = decode(e);
-            assert(!(!d.done || d.result[0] !== 'ok' || d.result[1] !== 10), e.value);
+            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 = pure(error('oops')).step(okStep(v => pure(ok(v * 2))));
-            const d = decode(e);
-            assert(!(!d.done || d.result[0] !== 'error' || d.result[1] !== 'oops'), e.value);
+            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);
         },
     },
-    decode: () => {
-        const d = decode(do_('add')(2, 3));
-        assert(!(d.done), d);
-        assertEq(d.command, 'add');
-        assert(!(d.payload[0] !== 2 || d.payload[1] !== 3), d.payload);
-        assertPure(d.continuation(5), 5);
+    // 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: () => {
@@ -83,4 +104,75 @@ export const proof = {
             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/fjs/emergent_testing/all.test.js

@@ -1,4 +1,5 @@
 import { runEffect } from '../effects/node/module.js';
 import { register } from './module.f.js';
-// we need `await` for Playwright.
+// Top-level `await`: every proof must be registered before the runner starts
+// collecting tests.
 await runEffect(register);

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

@@ -62,8 +62,8 @@ export type Reporter<O extends Operation> = {
  * Unlike `runModule`, which sandboxes only the leaf function, `registerModule`
  * lets the external framework own scheduling: each registered test callback
  * calls `fn`, then recursively registers any sub-trees returned by the function.
- * This is the correct model for Node `--test`, Bun, and Playwright, where tests
- * must be declared upfront and the framework drives execution.
+ * This is the correct model for Node `--test`, Bun, and Deno, where tests must
+ * be declared upfront and the framework drives execution.
  */
 export declare const registerModule: (ctx: TestContext, k: string, v: unknown, star: string) => Effect<Test | All | Await, void>;
 /**
@@ -130,7 +130,7 @@ export declare const defaultReporter: (options: NodeProgramOptions) => Reporter<
 /** The `fjs t` entry point: runs all tests using `defaultReporter`. */
 export declare const main: NodeProgram;
 /**
- * Entry point for external test frameworks (Node `--test`, Bun, Playwright).
+ * Entry point for external test frameworks (Node `--test`, Bun, Deno).
  *
  * Discovers test modules via `loadModuleMap`, then registers each with the
  * framework-appropriate `TestContext` selected from `NodeProgramOptions`

package/fjs/emergent_testing/module.f.js

@@ -5,14 +5,15 @@
  * - `runModule` / `Reporter<O>` — self-hosted Effects runner used by `fjs t`;
  *   sandboxes each leaf call individually and accumulates `TestState`.
  * - `registerModule` / `TestContext` — registers tests with an external
- *   framework (Node `--test`, Bun, Playwright) at import time; the framework
- *   owns scheduling and pass/fail counting.
+ *   framework (Node `--test`, Bun, Deno) at import time; the framework owns
+ *   scheduling and pass/fail counting.
  *
  * @module
  */
 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';
@@ -78,18 +79,18 @@ export const collectTests = (path, throws, v) => {
  * Unlike `runModule`, which sandboxes only the leaf function, `registerModule`
  * lets the external framework own scheduling: each registered test callback
  * calls `fn`, then recursively registers any sub-trees returned by the function.
- * This is the correct model for Node `--test`, Bun, and Playwright, where tests
- * must be declared upfront and the framework drives execution.
+ * This is the correct model for Node `--test`, Bun, and Deno, where tests must
+ * be declared upfront and the framework drives execution.
  */
 export const registerModule = (ctx, k, v, star) => {
     const registerOne = (ctx, [path, { fn, throws }]) => {
-        // ' *' (non-empty only for Bun/Playwright) signals that all sub-tests run
+        // ' *' (non-empty only for Bun) signals that all sub-tests run
         // inline inside this single registration. Not appended to throw-tests since
         // those never produce sub-tests. The path already contains '.throw' when a
         // 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,
     };
@@ -257,19 +273,17 @@ export const defaultReporter = (options) => {
 /** The `fjs t` entry point: runs all tests using `defaultReporter`. */
 export const main = options => testAll(defaultReporter(options))(options);
 /**
- * Entry point for external test frameworks (Node `--test`, Bun, Playwright).
+ * Entry point for external test frameworks (Node `--test`, Bun, Deno).
  *
  * Discovers test modules via `loadModuleMap`, then registers each with the
  * framework-appropriate `TestContext` selected from `NodeProgramOptions`
  * based on the detected `engine`.
  */
 export const register = o => {
-    const star = o.engine === 'bun' || o.engine === 'playwright' ? ' ...' : '';
-    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));
+    const star = o.inlineTestContext ? ' ...' : '';
+    const ctx = o.engine === 'bun' ? o.bunTestContext : o.testContext;
+    return eff(loadModuleMap(o.env))
+        .step(registerModuleMap(ctx, star))
+        .step(() => pure(0))
+        .value;
 };

package/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;