functionalscript 0.37.0 → 0.38.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/{fs → fjs}/effects/proof.f.js

@@ -1,13 +1,10 @@
 import { decode, do_, foldStep, forEachStep, lazy, match, okStep, pure } 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);
-    if (!d.done) {
-        throw e.value;
-    }
-    if (d.result !== expected) {
-        throw d.result;
-    }
+    assert(d.done, e.value);
+    assertEq(d.result, expected);
 };
 const next = match({ add: (a, b) => a + b });
 export const proof = {
@@ -19,13 +16,9 @@ export const proof = {
             // The thunk runs only when the effect is decoded, not when `lazy` is called.
             let evaluated = false;
             const e = lazy(() => { evaluated = true; return 7; });
-            if (evaluated) {
-                throw 'lazy must not evaluate eagerly';
-            }
+            assert(!(evaluated), 'lazy must not evaluate eagerly');
             assertPure(e, 7);
-            if (!evaluated) {
-                throw 'decode must force the thunk';
-            }
+            assert(evaluated, 'decode must force the thunk');
         },
         step: () => {
             const e = lazy(() => 5).step(v => pure(v * 2));
@@ -60,56 +53,34 @@ export const proof = {
         ok: () => {
             const e = pure(ok(5)).step(okStep((v) => pure(ok(v * 2))));
             const d = decode(e);
-            if (!d.done || d.result[0] !== 'ok' || d.result[1] !== 10) {
-                throw e.value;
-            }
+            assert(!(!d.done || d.result[0] !== 'ok' || d.result[1] !== 10), e.value);
         },
         error: () => {
             const e = pure(error('oops')).step(okStep(v => pure(ok(v * 2))));
             const d = decode(e);
-            if (!d.done || d.result[0] !== 'error' || d.result[1] !== 'oops') {
-                throw e.value;
-            }
+            assert(!(!d.done || d.result[0] !== 'error' || d.result[1] !== 'oops'), e.value);
         },
     },
     decode: () => {
         const d = decode(do_('add')(2, 3));
-        if (d.done) {
-            throw d;
-        }
-        if (d.command !== 'add') {
-            throw d.command;
-        }
-        if (d.payload[0] !== 2 || d.payload[1] !== 3) {
-            throw d.payload;
-        }
+        assert(!(d.done), d);
+        assertEq(d.command, 'add');
+        assert(!(d.payload[0] !== 2 || d.payload[1] !== 3), d.payload);
         assertPure(d.continuation(5), 5);
     },
     match: {
         done: () => {
             const r = next(pure(7));
-            if (r[0] !== 'done') {
-                throw r;
-            }
-            if (r[1] !== 7) {
-                throw r[1];
-            }
+            assert(r[0] === 'done', r);
+            assertEq(r[1], 7);
         },
         cont: () => {
             const r = next(do_('add')(2, 3));
-            if (r[0] !== 'cont') {
-                throw r;
-            }
-            if (r[1] !== 5) {
-                throw r[1];
-            }
+            assert(r[0] === 'cont', r);
+            assertEq(r[1], 5);
             const r2 = next(r[2](r[1]));
-            if (r2[0] !== 'done') {
-                throw r2;
-            }
-            if (r2[1] !== 5) {
-                throw r2[1];
-            }
+            assert(r2[0] === 'done', r2);
+            assertEq(r2[1], 5);
         },
     },
 };

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);
@@ -245,12 +245,12 @@ export const registerSuffixes = () => {
     // Node (star = ''): no suffixes
     const [nodeNames] = runner([])(registerModule(noopCtx, './a.f.ts', proof, ''));
     assertEq(nodeNames.length, 2);
-    assertEq(nodeNames[0], 'import("./a.f.ts").proof.ok()');
+    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, ' ...'));
     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()');
 };
 // direct unit tests for the pure path-format 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,7 +9,7 @@
  *
  * 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
  */
@@ -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.
  *

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

@@ -49,16 +49,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 +69,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 +84,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 +118,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