functionalscript 0.37.0 → 0.39.0

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

@@ -42,7 +42,7 @@ export const flat = () => {
     const [e0, e1, e2] = events;
     assert(e0[0] === 'result' && e0[2][0] === 'a');
     assert(e1[0] === 'result' && e1[2][0] === 'b');
-    assertEq(e2[0], 'summary');
+    assert(e2[0] === 'summary');
     const [, pass, fail] = e2;
     assertEq(pass, 2);
     assertEq(fail, 0);
@@ -56,7 +56,7 @@ export const nested = () => {
     const [e0, e1, e2] = events;
     assert(e0[0] === 'result' && e0[2][1] === 'add');
     assert(e1[0] === 'result' && e1[2][1] === 'sub');
-    assertEq(e2[0], 'summary');
+    assert(e2[0] === 'summary');
     const [, pass, fail] = e2;
     assertEq(pass, 2);
     assertEq(fail, 0);
@@ -69,7 +69,7 @@ export const throwKey = () => {
     assertEq(exit, 0);
     const [e0, e1] = events;
     assert(e0[0] === 'result' && e0[2][0] === 'throw' && e0[2][1] === 'a');
-    assertEq(e1[0], 'summary');
+    assert(e1[0] === 'summary');
     const [, pass, fail] = e1;
     assertEq(pass, 1);
     assertEq(fail, 0);
@@ -81,7 +81,7 @@ export const throwKeyFail = () => {
     });
     assertEq(exit, 1);
     const [e0, e1] = events;
-    assertEq(e0[0], 'result');
+    assert(e0[0] === 'result');
     const [, pass, fail] = e1;
     assertEq(pass, 0);
     assertEq(fail, 1);
@@ -93,7 +93,7 @@ export const mixedPassFail = () => {
     });
     assertEq(exit, 1);
     const summary = events[events.length - 1];
-    assertEq(summary[0], 'summary');
+    assert(summary[0] === 'summary');
     const [, pass, fail] = summary;
     assertEq(pass, 1);
     assertEq(fail, 1);
@@ -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);
-    assertEq(nodeNames[0], 'import("./a.f.ts").proof.ok()');
+    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);
-    assertEq(inlineNames[0], 'import("./a.f.ts").proof.ok() ...');
+    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/{fs → fjs}/fsc/proof.f.js

@@ -15,24 +15,18 @@ Object.getOwnPropertyDescriptor({ [name]: () => undefined }, name).value;
 export const proof = {
     a: () => {
         const x = f('1');
-        if (x !== '["1"]') {
-            throw x;
-        }
+        assertEq(x, '["1"]');
     },
     b: () => {
         // exercises toInit: terminal returns empty output and loops back to init
         const result = init(terminal);
-        if (result[0].length !== 0) {
-            throw result[0];
-        }
+        assertEq(result[0].length, 0, result[0]);
     },
     c: () => {
         // exercises unexpectedSymbol: next state after a token returns an error message
         const next = init(one('1'))[1];
         const result = next(42);
-        if (result[0][0] !== 'unexpected symbol 42') {
-            throw result[0][0];
-        }
+        assertEq(result[0][0], 'unexpected symbol 42');
     },
     fn: () => {
         const o = {
@@ -40,58 +34,42 @@ export const proof = {
         };
         const f = o["hello world!"];
         const { name } = f;
-        if (name !== "hello world!") {
-            throw name;
-        }
+        assertEq(name, "hello world!");
         //
         const f1 = { ["boring"]: () => undefined }["boring"];
-        if (f1.name !== "boring") {
-            throw f1.name;
-        }
+        assertEq(f1.name, "boring");
         //
         const x = fn(() => undefined, "hello").name;
-        if (x !== "") {
-            throw x;
-        }
+        assertEq(x, "");
         //
         const m = withName("boring2").name;
-        if (m !== "boring2") {
-            throw m;
-        }
+        assertEq(m, "boring2");
         //
         const a = function x() { return undefined; };
-        if (a.name !== "x") {
-            throw a.name;
-        }
+        assertEq(a.name, "x");
     },
     //
     f1: () => {
         const m1 = () => undefined;
-        if (m1.name !== "m1") {
-            throw m1.name;
-        }
+        assertEq(m1.name, "m1");
     },
     //
     f2: () => {
         const m11 = (() => undefined);
-        if (m11.name !== "m11") {
-            throw m11.name;
-        }
+        assertEq(m11.name, "m11");
     },
     //
     f3: () => {
         const m2 = true ? () => undefined : () => undefined;
         // for `bun` it is `m2`:
-        // if (m2.name !== "") { throw m2.name }
+        // assertEq(m2.name, "")
         // see also https://github.com/oven-sh/bun/issues/20398
     },
     f4: () => {
         const id = (i) => i;
         const f = id(() => undefined);
         // for `bun` it is `m2`:
-        if (f.name !== "") {
-            throw f.name;
-        }
+        assertEq(f.name, "");
     },
     chars: {
         whitespace: () => {

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

@@ -5,6 +5,7 @@ import { stringify } from '../media/json/module.f.js';
 import { identity } from '../types/function/module.f.js';
 import { toArray } from '../types/list/module.f.js';
 import { stringToList } from '../text/utf16/module.f.js';
+import { assertEq } from '../asserts/module.f.js';
 const stringifyIdentity = stringify(identity);
 const buildDfa = () => {
     const lowercaseAlpha = toRange('az');
@@ -85,9 +86,7 @@ export const proof = {
                 '["id"]'
             ];
             const expectedResult = stringifyIdentity(expectedOutput);
-            if (result !== expectedResult) {
-                throw result;
-            }
+            assertEq(result, expectedResult);
         },
         () => {
             const dfa = buildDfa();
@@ -99,9 +98,7 @@ export const proof = {
                 '["float"]'
             ];
             const expectedResult = stringifyIdentity(expectedOutput);
-            if (result !== expectedResult) {
-                throw result;
-            }
+            assertEq(result, expectedResult);
         },
         () => {
             const dfa = buildDfa();
@@ -112,9 +109,7 @@ export const proof = {
                 '[]'
             ];
             const expectedResult = stringifyIdentity(expectedOutput);
-            if (result !== expectedResult) {
-                throw result;
-            }
+            assertEq(result, expectedResult);
         },
         () => {
             const dfa = buildDfa();
@@ -125,9 +120,7 @@ export const proof = {
                 '[]'
             ];
             const expectedResult = stringifyIdentity(expectedOutput);
-            if (result !== expectedResult) {
-                throw result;
-            }
+            assertEq(result, expectedResult);
         }
     ]
 };

package/{fs → fjs}/mcp/module.f.d.ts

@@ -166,6 +166,13 @@ export type ToolEntry<O extends Operation> = {
  * @returns A `ToolEntry` ready to be added to a registry
  */
 export declare const toolEntry: <T extends Type, O extends Operation>(name: string, description: string, inputRtti: T, handle: (args: Ts<T>) => Effect<O, ToolsCallResult>) => ToolEntry<O>;
+/**
+ * Helper to create a successful single-text-block tool result.
+ *
+ * @param text - The text to return to the client
+ * @returns A `ToolsCallResult` with the text content
+ */
+export declare const okResult: (text: string) => ToolsCallResult;
 /**
  * Helper to create a tool-level error result with plain text explanation.
  *

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

@@ -9,13 +9,13 @@
  *
  * Each schema is both a runtime decoder (`validate(schema)`) and a static
  * TypeScript type (`Ts<typeof schema>`). Transport framing (stdio) and the
- * JSON-RPC dispatcher are in `fs/media/json/rpc/module.f.ts`.
+ * JSON-RPC dispatcher are in `fjs/media/json/rpc/module.f.ts`.
  *
  * @module
  */
 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';
@@ -125,13 +125,20 @@ export const toolEntry = (name, description, inputRtti, handle) => ({
             : handle(r);
     }
 });
+/**
+ * Helper to create a successful single-text-block tool result.
+ *
+ * @param text - The text to return to the client
+ * @returns A `ToolsCallResult` with the text content
+ */
+export const okResult = (text) => ({ content: [{ type: 'text', text }] });
 /**
  * Helper to create a tool-level error result with plain text explanation.
  *
  * @param text - The error message to return to the client
  * @returns A `ToolsCallResult` with `isError: true` and the text explanation
  */
-export const errorResult = (text) => ({ content: [{ type: 'text', text }], isError: true });
+export const errorResult = (text) => ({ ...okResult(text), isError: true });
 /**
  * Builds `McpHandlers` from a registry of tool entries.
  *
@@ -204,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);
@@ -220,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));
             }
@@ -233,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));
         }
@@ -249,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) {
@@ -258,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/{fs → 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' } } };
@@ -49,16 +50,16 @@ const initNotif = { jsonrpc: '2.0', method: 'notifications/initialized' };
 export const proof = {
     lifecycle: {
         initialStateIsUninitialized: () => {
-            assertEq(uninitializedState[0], 'uninitialized');
+            assert(uninitializedState[0] === 'uninitialized');
         },
         initializeTransitionsToInitializing: () => {
             const [, newState] = step1(config)(initMsg);
-            assertEq(newState[0], 'initializing');
+            assert(newState[0] === 'initializing');
         },
         initializedNotificationTransitionsToInitialized: () => {
             const [resp, newState] = step2(config)(initMsg)(initNotif);
             assertEq(resp, null);
-            assertEq(newState[0], 'initialized');
+            assert(newState[0] === 'initialized');
         },
         initializeReturnsResult: () => {
             const [resp] = step1(config)(initMsg);
@@ -69,12 +70,12 @@ export const proof = {
         initializeWithBadParamsReturnsInvalidParams: () => {
             const bad = { jsonrpc: '2.0', method: 'initialize', id: 2, params: { wrong: true } };
             const [resp, newState] = step1(config)(bad);
-            assertEq(newState[0], 'uninitialized');
+            assert(newState[0] === 'uninitialized');
             assertEq(resp.error.code, -32602);
         },
         notificationBeforeInitReturnNull: () => {
             const [resp, newState] = step1(config)(initNotif);
-            assertEq(newState[0], 'uninitialized');
+            assert(newState[0] === 'uninitialized');
             assertEq(resp, null);
         },
         unknownNotificationReturnNull: () => {
@@ -84,19 +85,19 @@ export const proof = {
         },
         doubleInitializeReturnsInvalidRequest: () => {
             const [resp, newState] = step2(config)(initMsg)(initMsg);
-            assertEq(newState[0], 'initializing');
+            assert(newState[0] === 'initializing');
             assertEq(resp.error.code, -32600);
         },
         pingBeforeInitSucceeds: () => {
             const msg = { jsonrpc: '2.0', method: 'ping', id: 11 };
             const [resp, newState] = step1(config)(msg);
-            assertEq(newState[0], 'uninitialized');
+            assert(newState[0] === 'uninitialized');
             assert(!('error' in resp));
         },
         pingDuringInitializingSucceeds: () => {
             const msg = { jsonrpc: '2.0', method: 'ping', id: 12 };
             const [resp, newState] = step2(config)(initMsg)(msg);
-            assertEq(newState[0], 'initializing');
+            assert(newState[0] === 'initializing');
             assert(!('error' in resp));
         },
         pingAfterInitSucceeds: () => {
@@ -118,24 +119,24 @@ export const proof = {
             const notif = { jsonrpc: '2.0', method: 'notifications/initialized', params: {} };
             const [resp, newState] = step2(config)(initMsg)(notif);
             assertEq(resp, null);
-            assertEq(newState[0], 'initialized');
+            assert(newState[0] === 'initialized');
         },
         initializedNotificationBadParamsIgnored: () => {
             const notif = { jsonrpc: '2.0', method: 'notifications/initialized', params: 1 };
             const [resp, newState] = step2(config)(initMsg)(notif);
             assertEq(resp, null);
-            assertEq(newState[0], 'initializing');
+            assert(newState[0] === 'initializing');
         },
         methodBeforeInitReturnsNotInitialized: () => {
             const msg = { jsonrpc: '2.0', method: 'tools/list', id: 3 };
             const [resp, newState] = step1(config)(msg);
-            assertEq(newState[0], 'uninitialized');
+            assert(newState[0] === 'uninitialized');
             assertEq(resp.error.code, notInitialized.code);
         },
         methodDuringInitializingReturnsNotInitialized: () => {
             const msg = { jsonrpc: '2.0', method: 'tools/list', id: 16 };
             const [resp, newState] = step2(config)(initMsg)(msg);
-            assertEq(newState[0], 'initializing');
+            assert(newState[0] === 'initializing');
             assertEq(resp.error.code, notInitialized.code);
         },
         invalidEnvelopeReturnsInvalidRequest: () => {

package/{fs → fjs}/mcp/stdio/module.f.d.ts

@@ -2,10 +2,10 @@
  * stdio transport for JSON-RPC / MCP servers.
  *
  * `stdioTransport` wraps a step function — the `mcpStep`-shaped
- * `(value) => Effect<O, Response | null>` from `fs/mcp/module.f.ts` — in the
+ * `(value) => Effect<O, Response | null>` from `fjs/mcp/module.f.ts` — in the
  * canonical read → parse → dispatch → write loop, expressed as a recursive
  * effect so it stays in the pure effect model and is fully testable against a
- * mock stdin / stdout (see `fs/effects/node/virtual`) with no real process.
+ * mock stdin / stdout (see `fjs/effects/node/virtual`) with no real process.
  *
  * The loop only consumes `Read` (stdin, one byte at a time, via the pure
  * `readLine` combinator) and emits `Write` (stdout) on top of whatever `O` the
@@ -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>;

package/{fs → fjs}/mcp/stdio/module.f.js

@@ -2,10 +2,10 @@
  * stdio transport for JSON-RPC / MCP servers.
  *
  * `stdioTransport` wraps a step function — the `mcpStep`-shaped
- * `(value) => Effect<O, Response | null>` from `fs/mcp/module.f.ts` — in the
+ * `(value) => Effect<O, Response | null>` from `fjs/mcp/module.f.ts` — in the
  * canonical read → parse → dispatch → write loop, expressed as a recursive
  * effect so it stays in the pure effect model and is fully testable against a
- * mock stdin / stdout (see `fs/effects/node/virtual`) with no real process.
+ * mock stdin / stdout (see `fjs/effects/node/virtual`) with no real process.
  *
  * The loop only consumes `Read` (stdin, one byte at a time, via the pure
  * `readLine` combinator) and emits `Write` (stdout) on top of whatever `O` the
@@ -29,7 +29,7 @@
  *
  * @module
  */
-import { pure } from '../../effects/module.f.js';
+import { pure, step } from '../../effects/module.f.js';
 import { readLine, write } from '../../effects/node/module.f.js';
 import { tryUtf8 } from '../../text/module.f.js';
 import { stringToList } from '../../text/utf16/module.f.js';
@@ -49,24 +49,24 @@ const writeResponse = (resp) => {
     const v = tryUtf8(stringifyJson(resp) + '\n');
     return v === null
         ? pure(error(undefined))
-        : write('stdout', v).step(() => pure(ok(undefined)));
+        : step(write('stdout', v), () => pure(ok(undefined)));
 };
 /**
- * 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 const stdioTransport = (step) => readLine('stdin').step(line => line === null
+export const stdioTransport = (handler) => step(readLine('stdin'), line => line === null
     ? pure(undefined)
-    : handleLine(step)(line));
-const handleLine = (step) => (line) => {
+    : handleLine(handler)(line));
+const handleLine = (handler) => (line) => {
     const [t, value] = parse(tokenize(stringToList(line)));
-    return (t === 'error'
+    return step(t === 'error'
         ? writeResponse(parseErrorResponse)
-        : step(value).step(resp => resp === null
+        : step(handler(value), resp => resp === null
             ? pure(undefined)
-            : writeResponse(resp).step(([t2]) => t2 === 'error'
+            : step(writeResponse(resp), ([t2]) => t2 === 'error'
                 // The real response didn't fit. Retry with a fixed, small
                 // internal-error body carrying `resp.id` — but a
                 // caller-controlled `id` (e.g. a very large string) can
@@ -74,8 +74,8 @@ const handleLine = (step) => (line) => {
                 // that retry is bounded by one more: an `id: null`
                 // internal-error, whose fully-constant shape is the only
                 // line in this transport guaranteed to always encode.
-                ? writeResponse(internalErrorResponse(resp.id)).step(([t3]) => t3 === 'error'
-                    ? writeResponse(internalErrorResponse(null)).step(() => pure(undefined))
+                ? step(writeResponse(internalErrorResponse(resp.id)), ([t3]) => t3 === 'error'
+                    ? step(writeResponse(internalErrorResponse(null)), () => pure(undefined))
                     : pure(undefined))
-                : pure(undefined)))).step(() => stdioTransport(step));
+                : pure(undefined))), () => stdioTransport(handler));
 };