functionalscript 0.38.0 → 0.39.0

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

package/fjs/emergent_testing/proof.f.js

@@ -218,41 +218,72 @@ export const githubReporterOutput = () => {
     assertEq(exit, 1);
     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 = () => {
+const registerNoopCtx = { test: (_n, _o, _f) => Promise.resolve() };
+/**
+ * Builds a synchronous mock runner for `registerModule`'s `Test`/`All`/`Await`
+ * effect operations. Only the `test` op varies between call sites (whether it
+ * invokes the registered callback), so `all`/`await` are shared here.
+ */
+const makeRegisterRunner = (testOp) => {
     let runner;
-    const noopCtx = { test: (_n, _o, _f) => Promise.resolve() };
-    const makeRunner = () => mockRun({
-        test: (_ctx, name, _xf, _fn) => (s) => [[...s, name], undefined],
-        all: (...effects) => (s) => {
-            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: p => (s) => [s, [p]],
+    runner = mockRun({
+        test: (ctx, name, xf, fn) => testOp(runner, ctx, name, xf, fn),
+        all: (...effects) => (s) => effects.reduce(([st, rs], e) => {
+            const [ns, r] = runner(st)(e);
+            return [ns, [...rs, r]];
+        }, [s, []]),
+        await: (p) => (s) => [s, [p]],
     });
-    runner = makeRunner();
+    return runner;
+};
+// registerModule appends ' ...' for inline runners (Bun/Playwright).
+// This mock never invokes the registered callback; it only records names.
+export const registerSuffixes = () => {
+    const runner = makeRegisterRunner((_runner, _ctx, name, _xf, _fn) => (s) => [[...s, name], undefined]);
     const proof = {
         ok: () => { },
         throw: { a: () => { throw 'expected'; } },
     };
     // Node (star = ''): no suffixes
-    const [nodeNames] = runner([])(registerModule(noopCtx, './a.f.ts', proof, ''));
+    const [nodeNames] = runner([])(registerModule(registerNoopCtx, './a.f.ts', proof, ''));
     assertEq(nodeNames.length, 2);
     assert(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, ' ...'));
+    const [inlineNames] = runner([])(registerModule(registerNoopCtx, './a.f.ts', proof, ' ...'));
     assertEq(inlineNames.length, 2);
     assert(inlineNames[0] === 'import("./a.f.ts").proof.ok() ...');
     assertEq(inlineNames[1], 'import("./a.f.ts").proof.throw.a()');
 };
+// A `throw`-tagged test whose function completes without throwing (the
+// external framework, not this module, is responsible for turning that into
+// a failure via `expectFailure`). registerModule's own callback must still
+// short-circuit before walking the returned value for sub-tests: it invokes
+// the callback and returns without recursing, rather than treating the
+// returned object as a sub-tree.
+export const registerThrowsWithoutThrowing = () => {
+    // Unlike registerSuffixes' mock, this one actually invokes the registered
+    // callback so registerOne's inner `.step` body runs, and asserts the
+    // callback is registered with `expectFailure: true`.
+    const runner = makeRegisterRunner((runner, ctx, name, xf, fn) => (s) => {
+        assert(xf);
+        const [ns] = runner(s)(fn(ctx));
+        return [[...ns, name], undefined];
+    });
+    // Returns a sub-tree that would register more tests if it were walked.
+    const proof = { throw: { a: () => ({ sub: () => { } }) } };
+    const [names] = runner([])(registerModule(registerNoopCtx, './a.f.ts', proof, ''));
+    // Only the throw-test itself is registered; `sub` is never reached.
+    assertEq(names.length, 1);
+    assertEq(names[0], 'import("./a.f.ts").proof.throw.a()');
+};
+// registerModule with an empty proof object registers zero tests and
+// returns without invoking the mock's `test` op at all.
+export const registerEmptyProof = () => {
+    const runner = makeRegisterRunner((_runner, _ctx, name, _xf, _fn) => (s) => [[...s, name], undefined]);
+    const [names] = runner([])(registerModule(registerNoopCtx, './a.f.ts', {}, ''));
+    assertEq(names.length, 0);
+};
 // direct unit tests for the pure path-format helpers
 export const helpers = {
     isInteger: () => {
@@ -361,6 +392,8 @@ export const proof = {
     defaultReporterFailOutput,
     githubReporterOutput,
     registerSuffixes,
+    registerThrowsWithoutThrowing,
+    registerEmptyProof,
     defaultReporterExpectedToThrow,
     helpers
 };

package/fjs/mcp/module.f.js

@@ -15,7 +15,7 @@
  */
 import { boolean, string, option, array, record, or } from '../types/rtti/module.f.js';
 import { unknown } from '../media/json/module.f.js';
-import { pure } from '../effects/module.f.js';
+import { pure, step } from '../effects/module.f.js';
 import { read, write } from '../effects/memory/module.f.js';
 import { decodeRequest, rpcError, invalidRequest, invalidParams, methodNotFound, jsonrpc, } from '../media/json/rpc/module.f.js';
 import { validate } from '../types/rtti/validate/module.f.js';
@@ -211,8 +211,8 @@ export const mcpStep = ({ protocolVersion, capabilities, serverInfo, }) => (hand
                 // Malformed handshake — ignore it; the session stays gated.
                 return pure(null);
             }
-            return read(stateKey).step(([t]) => t === 'initializing'
-                ? write(stateKey, ['initialized', true]).step(() => pure(null))
+            return step(read(stateKey), ([t]) => t === 'initializing'
+                ? step(write(stateKey, ['initialized', true]), () => pure(null))
                 : pure(null));
         }
         return pure(null);
@@ -227,7 +227,7 @@ export const mcpStep = ({ protocolVersion, capabilities, serverInfo, }) => (hand
     }
     // `initialize` transitions uninitialized → initializing; reject if already done.
     if (method === 'initialize') {
-        return read(stateKey).step(([t]) => {
+        return step(read(stateKey), ([t]) => {
             if (t !== 'uninitialized') {
                 return pure(_errResponse(id)(invalidRequest));
             }
@@ -240,11 +240,11 @@ export const mcpStep = ({ protocolVersion, capabilities, serverInfo, }) => (hand
                 capabilities,
                 serverInfo,
             };
-            return write(stateKey, ['initializing']).step(() => pure(_okResponse(id)(result)));
+            return step(write(stateKey, ['initializing']), () => pure(_okResponse(id)(result)));
         });
     }
     // All other methods require fully initialized state — read it first.
-    return read(stateKey).step(([t]) => {
+    return step(read(stateKey), ([t]) => {
         if (t !== 'initialized') {
             return pure(_errResponse(id)(notInitialized));
         }
@@ -256,7 +256,7 @@ export const mcpStep = ({ protocolVersion, capabilities, serverInfo, }) => (hand
             const [t, pr] = validate(toolsListParams)(params === undefined ? {} : params);
             return t === 'error'
                 ? pure(_errResponse(id)(invalidParams))
-                : handlers.toolsList(pr).step(r => pure(_okResponse(id)(r)));
+                : step(handlers.toolsList(pr), r => pure(_okResponse(id)(r)));
         }
         if (method === 'tools/call') {
             if (capabilities.tools === undefined) {
@@ -265,7 +265,7 @@ export const mcpStep = ({ protocolVersion, capabilities, serverInfo, }) => (hand
             const [t, pr] = validate(toolsCallParams)(params);
             return t === 'error'
                 ? pure(_errResponse(id)(invalidParams))
-                : handlers.toolsCall(pr).step(r => pure(_okResponse(id)(r)));
+                : step(handlers.toolsCall(pr), r => pure(_okResponse(id)(r)));
         }
         return pure(_errResponse(id)(methodNotFound));
     });

package/fjs/mcp/proof.f.js

@@ -1,5 +1,6 @@
 import { assert, assertEq } from '../asserts/module.f.js';
-import { pure } from '../effects/module.f.js';
+import { pure, step } from '../effects/module.f.js';
+import { eff } from '../effects/eff/module.f.js';
 import { run } from '../effects/mock/module.f.js';
 import { asBase, asNominal, create, read } from '../effects/memory/module.f.js';
 import { uninitializedState, mcpStep, notInitialized, } from './module.f.js';
@@ -36,11 +37,11 @@ const runMem = (effect) => run(mock)(initial)(effect)[1];
 // O flows through McpHandlers<never>, so we cast the widened type down to MemOp.
 const asMemEffect = (e) => e;
 // Run one step from uninitializedState, return [response, newState].
-const step1 = (cfg) => (msg) => runMem(asMemEffect(create(uninitializedState).step(key => mcpStep(cfg)(handlers)(key)(msg).step(resp => read(key).step(state => pure([resp, state]))))));
+const step1 = (cfg) => (msg) => runMem(asMemEffect(step(create(uninitializedState), key => step(mcpStep(cfg)(handlers)(key)(msg), resp => step(read(key), state => pure([resp, state]))))));
 // Run initialize then a second step, return [response, newState] of the second.
-const step2 = (cfg) => (msg1) => (msg2) => runMem(asMemEffect(create(uninitializedState).step(key => mcpStep(cfg)(handlers)(key)(msg1).step(() => mcpStep(cfg)(handlers)(key)(msg2).step(resp => read(key).step(state => pure([resp, state])))))));
+const step2 = (cfg) => (msg1) => (msg2) => runMem(asMemEffect(eff(create(uninitializedState)).step(key => eff(mcpStep(cfg)(handlers)(key)(msg1)).step(() => eff(mcpStep(cfg)(handlers)(key)(msg2)).step(resp => step(read(key), state => pure([resp, state]))).value).value).value));
 // Run initialize, notifications/initialized, then a third step; return [response, newState] of the third.
-const step3 = (cfg) => (msg1) => (msg2) => (msg3) => runMem(asMemEffect(create(uninitializedState).step(key => mcpStep(cfg)(handlers)(key)(msg1).step(() => mcpStep(cfg)(handlers)(key)(msg2).step(() => mcpStep(cfg)(handlers)(key)(msg3).step(resp => read(key).step(state => pure([resp, state]))))))));
+const step3 = (cfg) => (msg1) => (msg2) => (msg3) => runMem(asMemEffect(eff(create(uninitializedState)).step(key => eff(mcpStep(cfg)(handlers)(key)(msg1)).step(() => eff(mcpStep(cfg)(handlers)(key)(msg2)).step(() => eff(mcpStep(cfg)(handlers)(key)(msg3)).step(resp => eff(read(key)).step(state => pure([resp, state])).value).value).value).value).value));
 // ── Test messages ─────────────────────────────────────────────────────────────
 const initMsg = { jsonrpc: '2.0', method: 'initialize', id: 1,
     params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'client', version: '0.0.1' } } };

package/fjs/mcp/stdio/module.f.d.ts

@@ -39,9 +39,9 @@ import { type Response } from '../../media/json/rpc/module.f.ts';
  */
 export type Step<O extends Operation> = (value: Unknown) => Effect<O, Response | null>;
 /**
- * Drives the read-parse-dispatch-write loop for `step` over stdin/stdout.
+ * Drives the read-parse-dispatch-write loop for `handler` over stdin/stdout.
  *
  * Recurses after each handled line; terminates (resolving to `void`) when
  * `readLine` reports EOF.
  */
-export declare const stdioTransport: <O extends Operation>(step: Step<O>) => Effect<Read | Write | O, void>;
+export declare const stdioTransport: <O extends Operation>(handler: Step<O>) => Effect<Read | Write | O, void>;