functionalscript 0.32.4 → 0.34.0

package/fs/effects/node/virtual/module.f.d.ts

@@ -1,6 +1,6 @@
 import { type Vec } from '../../../types/bit_vec/module.f.ts';
 import { type RunInstance } from '../../mock/module.f.ts';
-import type { Module, NodeOp } from '../module.f.ts';
+import type { Module, NodeOp, NodeProgramOptions } from '../module.f.ts';
 /**
  * In-memory JS module entry. When `import_` is called on the path, the
  * function is invoked and its return value is the module value (with a
@@ -10,7 +10,7 @@ import type { Module, NodeOp } from '../module.f.ts';
  * each import for closures/state.
  */
 export type JsModule = () => Module;
-export type Entity = Vec | Dir | JsModule;
+export type Entity = readonly Vec[] | Dir | JsModule;
 export type Dir = {
     readonly [name in string]?: Entity;
 };
@@ -33,3 +33,17 @@ export type State = {
 };
 export declare const emptyState: State;
 export declare const virtual: RunInstance<NodeOp, State>;
+/**
+ * Safe, inert defaults for every {@link NodeProgramOptions} field, intended for
+ * proof files that need to call a program without owning the full literal.
+ *
+ * Proofs spread-override only what their test cares about:
+ *
+ * ```ts
+ * const opts: NodeProgramOptions = { ...defaultNodeProgramOptions, args }
+ * ```
+ *
+ * Future additions to `NodeProgramOptions` only need a default added here,
+ * keeping unrelated proof files from churning.
+ */
+export declare const defaultNodeProgramOptions: NodeProgramOptions;

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

@@ -6,7 +6,7 @@
 import { todo } from "../../../asserts/module.f.js";
 import { join, parse } from "../../../path/module.f.js";
 import { utf8ToString } from "../../../text/module.f.js";
-import { isVec, length, maxLengthBytes, msb, vec } from "../../../types/bit_vec/module.f.js";
+import { empty, length, maxLengthBytes, msb, vec } from "../../../types/bit_vec/module.f.js";
 import { error, ok } from "../../../types/result/module.f.js";
 import { run } from "../../mock/module.f.js";
 import { asBase, asNominal } from "../../memory/module.f.js";
@@ -28,7 +28,7 @@ const operation = (op) => {
         }
         const [first, ...rest] = path;
         const subDir = dir[first];
-        if (typeof subDir !== 'object') {
+        if (typeof subDir !== 'object' || Array.isArray(subDir)) {
             return op(dir, path);
         }
         const [newSubDir, r] = f(subDir, rest);
@@ -67,11 +67,23 @@ const readFile = readOperation((dir, path) => {
     if (file === undefined) {
         return enoent;
     }
-    // exists but is a directory — a real error, not a missing path
-    if (!isVec(file)) {
+    if (!Array.isArray(file)) {
         return error(`'${path[0]}' is not a file`);
     }
-    return ok(file);
+    const chunks = file;
+    const capBits = maxLengthBytes * 8n;
+    let result = empty;
+    for (const chunk of chunks) {
+        const chunkLen = length(chunk);
+        if (chunkLen === 0n) {
+            continue;
+        }
+        if (length(result) + chunkLen > capBits) {
+            return error(`File size exceeds maximum allowed size of ${maxLengthBytes} bytes`);
+        }
+        result = msb.concat(result)(chunk);
+    }
+    return ok(result);
 });
 const import_ = readOperation((dir, path) => {
     if (path.length !== 1) {
@@ -90,11 +102,10 @@ const writeFile = (payload) => operation((dir, path) => {
     }
     const [name] = path;
     const file = dir[name];
-    // fail if the file is a directory
-    if (file !== undefined && !isVec(file)) {
+    if (file !== undefined && !Array.isArray(file)) {
         return [dir, writeFileError];
     }
-    dir = { ...dir, [name]: payload };
+    dir = { ...dir, [name]: [payload] };
     return [dir, okVoid];
 });
 const invalidPath = error('invalid path');
@@ -109,7 +120,7 @@ const readdir = (base, recursive) => readOperation((dir, path) => {
             if (content === undefined) {
                 continue;
             }
-            const isFile = typeof content !== 'object';
+            const isFile = Array.isArray(content) || typeof content !== 'object';
             result = [...result, { name, parentPath, isFile }];
             if (!isFile && recursive) {
                 result = [...result, ...f(join(parentPath, name), content)];
@@ -137,7 +148,7 @@ const rm = operation((dir, path) => {
     if (entry === undefined) {
         return [dir, error('no such file')];
     }
-    if (typeof entry === 'object') {
+    if (!Array.isArray(entry) && typeof entry === 'object') {
         return [dir, error('is a directory')];
     }
     const { [name]: _, ...rest } = dir;
@@ -158,7 +169,7 @@ const extractEntity = (dir, path) => {
     }
     const [first, ...rest] = path;
     const sub = dir[first];
-    if (sub === undefined || isVec(sub) || typeof sub === 'function') {
+    if (sub === undefined || Array.isArray(sub) || typeof sub === 'function') {
         return [dir, enoent];
     }
     const [newSub, result] = extractEntity(sub, rest);
@@ -175,8 +186,8 @@ const insertEntityAt = (dir, path, entity) => {
         const [name] = path;
         const existing = dir[name];
         if (existing !== undefined) {
-            const entityIsDir = typeof entity === 'object';
-            const existingIsDir = typeof existing === 'object';
+            const entityIsDir = !Array.isArray(entity) && typeof entity === 'object';
+            const existingIsDir = !Array.isArray(existing) && typeof existing === 'object';
             if (entityIsDir && !existingIsDir) {
                 return [dir, error(`cannot overwrite file '${name}' with a directory`)];
             }
@@ -198,7 +209,7 @@ const insertEntityAt = (dir, path, entity) => {
     if (sub === undefined) {
         return [dir, enoent];
     }
-    if (isVec(sub) || typeof sub === 'function') {
+    if (Array.isArray(sub) || typeof sub === 'function') {
         return [dir, error('not a directory')];
     }
     const [newSub, result] = insertEntityAt(sub, rest, entity);
@@ -238,7 +249,7 @@ const readBytesOp = (path, offset, size) => readOperation((dir, p) => {
     if (file === undefined) {
         return enoent;
     }
-    if (!isVec(file)) {
+    if (!Array.isArray(file)) {
         return error(`'${p[0]}' is not a file`);
     }
     if (!Number.isInteger(offset)) {
@@ -256,12 +267,83 @@ const readBytesOp = (path, offset, size) => readOperation((dir, p) => {
     if (BigInt(size) > maxLengthBytes) {
         return error(`Chunk size ${size} exceeds maximum allowed size of ${maxLengthBytes} bytes`);
     }
-    const offsetBits = BigInt(offset) * 8n;
-    const sizeBits = BigInt(size) * 8n;
-    const remaining = msb.removeFront(offsetBits)(file);
-    const actualSizeBits = sizeBits < length(remaining) ? sizeBits : length(remaining);
-    return ok(vec(actualSizeBits)(msb.front(actualSizeBits)(remaining)));
+    const chunks = file;
+    let toSkip = BigInt(offset) * 8n;
+    let toRead = BigInt(size) * 8n;
+    let result = empty;
+    for (const chunk of chunks) {
+        if (toRead === 0n) {
+            break;
+        }
+        const chunkBits = length(chunk);
+        if (toSkip >= chunkBits) {
+            toSkip -= chunkBits;
+            continue;
+        }
+        const skipInChunk = toSkip;
+        const availableBits = chunkBits - skipInChunk;
+        const takeBits = availableBits <= toRead ? availableBits : toRead;
+        const taken = vec(takeBits)(msb.front(takeBits)(msb.removeFront(skipInChunk)(chunk)));
+        result = msb.concat(result)(taken);
+        toSkip = 0n;
+        toRead -= takeBits;
+    }
+    return ok(result);
+})(path);
+/** Total byte size of a chunk-list file (each chunk is byte-aligned). */
+const fileSizeBytes = (chunks) => chunks.reduce((acc, c) => acc + Number(length(c) / 8n), 0);
+/** Absent-path error for an already-existing exclusive create, mirroring `EEXIST`. */
+const eexist = error({ code: 'EEXIST' });
+const createExclusive = operation((dir, path) => {
+    if (path.length !== 1) {
+        return [dir, invalidPath];
+    }
+    const [name] = path;
+    // O_EXCL: fail if the name is already taken; otherwise create an empty file.
+    if (dir[name] !== undefined) {
+        return [dir, eexist];
+    }
+    return [{ ...dir, [name]: [] }, okVoid];
+});
+// The lock-free upload only ever writes sequentially at the current end of the
+// staging file (`offset === size`), so the virtual model implements that append
+// case exactly: it never creates (a missing file is `ENOENT`), never overwrites
+// existing bytes, and never leaves a hole — matching the effect's contract for
+// the one access pattern its callers use.
+const writeBytesOp = (path, offset, data) => operation((dir, p) => {
+    if (p.length !== 1) {
+        return [dir, enoent];
+    }
+    const [name] = p;
+    const file = dir[name];
+    if (file === undefined) {
+        return [dir, enoent];
+    } // writeBytes never creates
+    if (!Array.isArray(file)) {
+        return [dir, error(`'${name}' is not a file`)];
+    }
+    if (!Number.isInteger(offset) || offset < 0) {
+        return [dir, error(`Offset ${offset} is invalid`)];
+    }
+    const chunks = file;
+    if (offset !== fileSizeBytes(chunks)) {
+        return [dir, error(`writeBytes offset ${offset} must equal the file size (append-only)`)];
+    }
+    return [{ ...dir, [name]: [...chunks, data] }, okVoid];
 })(path);
+const statOp = readOperation((dir, path) => {
+    if (path.length !== 1) {
+        return enoent;
+    }
+    const file = dir[path[0]];
+    if (file === undefined) {
+        return enoent;
+    }
+    if (!Array.isArray(file)) {
+        return error(`'${path[0]}' is not a file`);
+    }
+    return ok({ size: fileSizeBytes(file) });
+});
 const map = {
     all: (...a) => state => {
         let e = [];
@@ -302,6 +384,9 @@ const map = {
     rm,
     rename,
     readBytes: readBytesOp,
+    createExclusive,
+    writeBytes: writeBytesOp,
+    stat: statOp,
     randomInt: () => state => [{ ...state, randomNext: state.randomNext + 1 }, state.randomNext],
     exec: todo,
     createServer: todo,
@@ -330,3 +415,27 @@ const map = {
     },
 };
 export const virtual = run(map);
+const testContext = { test: todo };
+/**
+ * Safe, inert defaults for every {@link NodeProgramOptions} field, intended for
+ * proof files that need to call a program without owning the full literal.
+ *
+ * Proofs spread-override only what their test cares about:
+ *
+ * ```ts
+ * const opts: NodeProgramOptions = { ...defaultNodeProgramOptions, args }
+ * ```
+ *
+ * Future additions to `NodeProgramOptions` only need a default added here,
+ * keeping unrelated proof files from churning.
+ */
+export const defaultNodeProgramOptions = {
+    args: [],
+    env: {},
+    home: '.',
+    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
+    testContext,
+    bunTestContext: testContext,
+    playwrightTestContext: testContext,
+    engine: 'node',
+};

package/fs/effects/node/virtual/proof.f.d.ts

@@ -19,9 +19,13 @@ export declare const proof: {
     renameOntoOwnAncestor: () => void;
     renameNonEmptyDirOverEmptyDir: () => void;
     renameEmptyDirOverNonEmptyDir: () => void;
+    renameFileOntoDirectory: () => void;
+    readFileTooLarge: () => void;
     readBytesNegativeSize: () => void;
     readBytesZeroSize: () => void;
     readBytesNegativeOffset: () => void;
     readBytesFractionalSize: () => void;
     readBytesFractionalOffset: () => void;
+    readBytesAcrossChunkBoundary: () => void;
+    largeFileReadBytes: () => void;
 };

package/fs/effects/node/virtual/proof.f.js

@@ -1,11 +1,11 @@
 import { assertEq } from "../../../asserts/module.f.js";
 import { awaitIfPromise, fetch, rm, writeFile, readFile, readdir, import_, rename, readBytes } from "../module.f.js";
-import { vec8 } from "../../../types/bit_vec/module.f.js";
+import { maxLengthBytes, vec, vec8 } from "../../../types/bit_vec/module.f.js";
 import { emptyState, virtual } from "./module.f.js";
 export const proof = {
     rm: {
         success: () => {
-            const root = { 'a.txt': vec8(0x42n) };
+            const root = { 'a.txt': [vec8(0x42n)] };
             const [, result] = virtual({ ...emptyState, root })(rm('a.txt'));
             assertEq(result[0], 'ok');
         },
@@ -27,7 +27,7 @@ export const proof = {
         assertEq(result[0], 'error');
     },
     readdirRecursive: () => {
-        const file = vec8(0x42n);
+        const file = [vec8(0x42n)];
         const sub = { 'file.txt': file };
         const outer = { 'sub': sub };
         const root = { 'mydir': outer };
@@ -65,7 +65,7 @@ export const proof = {
     },
     importNonModule: () => {
         // import_ on a Vec (not a JsModule) covers typeof entry !== 'function' branch
-        const root = { 'module.f.ts': vec8(0x42n) };
+        const root = { 'module.f.ts': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(import_('module.f.ts'));
         assertEq(result[0], 'error');
     },
@@ -78,62 +78,95 @@ export const proof = {
     },
     renameSamePath: () => {
         // rename('a', 'a') should succeed as a no-op, not reject
-        const root = { 'a': vec8(0x42n) };
+        const root = { 'a': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(rename('a', 'a'));
         assertEq(result[0], 'ok');
     },
     renameIntoOwnSubtree: () => {
         // rename('a', 'a/b') should fail (dst inside src's subtree)
-        const root = { 'a': { 'b': vec8(0x42n) } };
+        const root = { 'a': { 'b': [vec8(0x42n)] } };
         const [, result] = virtual({ ...emptyState, root })(rename('a', 'a/b'));
         assertEq(result[0], 'error');
     },
     renameOntoOwnAncestor: () => {
         // rename('a/b', 'a') should fail (src inside dst's subtree)
-        const root = { 'a': { 'b': vec8(0x42n) } };
+        const root = { 'a': { 'b': [vec8(0x42n)] } };
         const [, result] = virtual({ ...emptyState, root })(rename('a/b', 'a'));
         assertEq(result[0], 'error');
     },
     renameNonEmptyDirOverEmptyDir: () => {
         // rename a directory onto an empty directory should succeed
-        const root = { 'src': { 'file': vec8(0x42n) }, 'dst': {} };
+        const root = { 'src': { 'file': [vec8(0x42n)] }, 'dst': {} };
         const [, result] = virtual({ ...emptyState, root })(rename('src', 'dst'));
         assertEq(result[0], 'ok');
     },
     renameEmptyDirOverNonEmptyDir: () => {
         // rename an empty directory onto a non-empty directory should fail
-        const root = { 'src': {}, 'dst': { 'file': vec8(0x42n) } };
+        const root = { 'src': {}, 'dst': { 'file': [vec8(0x42n)] } };
         const [, result] = virtual({ ...emptyState, root })(rename('src', 'dst'));
         assertEq(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');
+    },
+    readFileTooLarge: () => {
+        // a file stored as two max-size chunks exceeds the limit; readFile must return an error
+        const chunk0 = vec(maxLengthBytes * 8n)(0n);
+        const chunk1 = vec(1n)(1n);
+        const root = { 'big': [chunk0, chunk1] };
+        const [, result] = virtual({ ...emptyState, root })(readFile('big'));
+        assertEq(result[0], 'error');
+    },
     readBytesNegativeSize: () => {
         // readBytes with negative size should fail
-        const root = { 'file': vec8(0x42n) };
+        const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0, -1));
         assertEq(result[0], 'error');
     },
     readBytesZeroSize: () => {
         // readBytes with zero size should succeed and return empty vec
-        const root = { 'file': vec8(0x42n) };
+        const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0, 0));
         assertEq(result[0], 'ok');
     },
     readBytesNegativeOffset: () => {
         // readBytes with negative offset should fail
-        const root = { 'file': vec8(0x42n) };
+        const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', -1, 1));
         assertEq(result[0], 'error');
     },
     readBytesFractionalSize: () => {
         // readBytes with fractional size should fail rather than throw RangeError
-        const root = { 'file': vec8(0x42n) };
+        const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0, 1.5));
         assertEq(result[0], 'error');
     },
     readBytesFractionalOffset: () => {
         // readBytes with fractional offset should fail rather than throw RangeError
-        const root = { 'file': vec8(0x42n) };
+        const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0.5, 1));
         assertEq(result[0], 'error');
     },
+    readBytesAcrossChunkBoundary: () => {
+        // Two 128 KiB chunks; read 2 bytes spanning the boundary (last byte of chunk 0, first of chunk 1).
+        const chunkSize = Number(maxLengthBytes);
+        const chunk0 = vec(maxLengthBytes * 8n)(0xaan);
+        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');
+    },
+    largeFileReadBytes: () => {
+        // A file stored as two 128 KiB chunks is larger than maxLengthBytes.
+        // readBytes within the second chunk (offset = 128 KiB, size = 1) should succeed.
+        const chunkSize = Number(maxLengthBytes);
+        const chunk0 = vec(maxLengthBytes * 8n)(0n);
+        const chunk1 = vec(maxLengthBytes * 8n)(0xffn);
+        const root = { 'large': [chunk0, chunk1] };
+        const [, result] = virtual({ ...emptyState, root })(readBytes('large', chunkSize, 1));
+        assertEq(result[0], 'ok');
+    },
 };

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

@@ -1,4 +1,8 @@
 export declare const proof: {
+    lazy: {
+        value: () => void;
+        deferred: () => void;
+    };
     foldStep: {
         empty: () => void;
         threadsState: () => void;

package/fs/effects/proof.f.js

@@ -1,4 +1,4 @@
-import { decode, do_, foldStep, forEachStep, match, pure } from "./module.f.js";
+import { decode, do_, foldStep, forEachStep, lazy, match, pure } from "./module.f.js";
 const assertPure = (e, expected) => {
     const d = decode(e);
     if (!d.done) {
@@ -10,6 +10,23 @@ const assertPure = (e, 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; });
+            if (evaluated) {
+                throw 'lazy must not evaluate eagerly';
+            }
+            assertPure(e, 7);
+            if (!evaluated) {
+                throw 'decode must force the thunk';
+            }
+        },
+    },
     foldStep: {
         empty: () => {
             const e = foldStep((x) => (s) => pure(s + x))(10)([]);

package/fs/emergent_testing/proof.f.js

@@ -1,8 +1,7 @@
-import { pure } from "../effects/module.f.js";
 import { log } from "../effects/node/module.f.js";
-import { emptyState } from "../effects/node/virtual/module.f.js";
+import { defaultNodeProgramOptions, emptyState } from "../effects/node/virtual/module.f.js";
 import { virtual } from "../effects/node/virtual/module.f.js";
-import { assert, assertEq, todo } from "../asserts/module.f.js";
+import { assert, assertEq } from "../asserts/module.f.js";
 import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, registerModule, parseTestSet, defaultTest, } from "./module.f.js";
 import { run as mockRun } from "../effects/mock/module.f.js";
 import { shouldLoad } from "../dev/module.f.js";
@@ -13,16 +12,9 @@ const makeReporter = () => ({
     summary: (pass, fail, time) => writeEvent(['summary', pass, fail, time]),
     test: defaultTest,
 });
-const noopTestContext = { test: todo };
 const options = (initCwd, github = false) => ({
-    args: [],
+    ...defaultNodeProgramOptions,
     env: { INIT_CWD: initCwd, ...(github ? { GITHUB_ACTIONS: 'true' } : {}) },
-    home: '.',
-    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
-    testContext: noopTestContext,
-    bunTestContext: noopTestContext,
-    playwrightTestContext: noopTestContext,
-    engine: 'node',
 });
 const ok0 = () => ({ result: ['ok', undefined], duration: 0 });
 const fail0 = () => ({ result: ['error', 'oops'], duration: 0 });

package/fs/fjs/module.f.js

@@ -5,14 +5,11 @@
  */
 import { compile } from "../djs/module.f.js";
 import { main as testMain } from "../emergent_testing/module.f.js";
-import { commands as casCommands } from "../cas/module.f.js";
+import { commands as casCommands } from "../cas/cli/module.f.js";
 import { main as ciMain } from "../ci/module.f.js";
 import { import_ } from "../effects/node/module.f.js";
 import { dispatch } from "../cli/module.f.js";
 import { casMcpServer } from "../cas/mcp/module.f.js";
-import { cas, fileKvStore, toPath } from "../cas/module.f.js";
-import { sha256 } from "../crypto/sha2/module.f.js";
-import { join } from "../path/module.f.js";
 import { pure } from "../effects/module.f.js";
 const commands = [
     {
@@ -33,10 +30,7 @@ const commands = [
     {
         names: ['mcp', 'm'],
         description: 'Run an MCP server over stdio exposing the CAS as tools',
-        handler: ({ home }) => {
-            const c = cas(sha256)(fileKvStore(home));
-            return casMcpServer(c, home, hash => join(home, toPath(hash))).step(() => pure(0));
-        },
+        handler: ({ home }) => casMcpServer(home).step(() => pure(0)),
     },
     {
         names: ['ci', 'i'],

package/fs/fjs/proof.f.js

@@ -1,17 +1,8 @@
 import { assert, assertEq } from "../asserts/module.f.js";
 import { pure } from "../effects/module.f.js";
-import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
+import { defaultNodeProgramOptions, emptyState, virtual } from "../effects/node/virtual/module.f.js";
 import { main } from "./module.f.js";
-const makeOptions = (args) => ({
-    args,
-    env: {},
-    home: '.',
-    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
-    testContext: { test: async () => { } },
-    bunTestContext: { test: async () => { } },
-    playwrightTestContext: { test: async () => { } },
-    engine: 'node',
-});
+const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
 const run = (root) => (args) => virtual({ ...emptyState, root })(main(makeOptions(args)));
 const appMain = ({ args }) => pure(args.length);
 export const proof = {

package/fs/html/module.f.js

@@ -46,15 +46,13 @@ const rawText = [
 /**
  * https://stackoverflow.com/questions/7381974/which-characters-need-to-be-escaped-in-html
  */
-const escapeCharCode = (code) => {
-    switch (code) {
-        case quotationMark: return '"';
-        case ampersand: return '&';
-        case lessThanSign: return '<';
-        case greaterThanSign: return '>';
-        default: return fromCharCode(code);
-    }
+const escapeTable = {
+    [quotationMark]: '"',
+    [ampersand]: '&',
+    [lessThanSign]: '<',
+    [greaterThanSign]: '>',
 };
+const escapeCharCode = (code) => escapeTable[code] ?? fromCharCode(code);
 const escape = compose(stringToList)(map(escapeCharCode));
 const node = (n) => typeof n === 'string' ? escape(n) : element(n);
 const nodes = flatMap(node);

package/fs/js/tokenizer/module.f.d.ts

@@ -95,4 +95,9 @@ export type JsTokenWithMetadata = {
 type ErrorMessage = '" are missing' | 'unescaped character' | 'invalid hex value' | 'unexpected character' | 'invalid number' | 'invalid token' | '*\/ expected' | 'unterminated string literal' | 'eof';
 export declare const isKeywordToken: (token: JsToken) => boolean;
 export declare const tokenize: (input: List<number>) => (path: string) => List<JsTokenWithMetadata>;
+export declare const proof: {
+    throw: {
+        unionConflict: () => void;
+    };
+};
 export {};

package/fs/js/tokenizer/module.f.js

@@ -27,6 +27,7 @@ leftSquareBracket, reverseSolidus, rightSquareBracket, lowLine,
 latinSmallLetterRange, latinSmallLetterA, latinSmallLetterB, latinSmallLetterE, latinSmallLetterF, latinSmallLetterN, latinSmallLetterR, latinSmallLetterT, latinSmallLetterU, 
 //
 leftCurlyBracket, rightCurlyBracket, dollarSign } from "../../text/ascii/module.f.js";
+import { todo } from "../../asserts/module.f.js";
 const { fromCharCode } = String;
 const rangeOneNine = range('19');
 const rangeSetNewLine = [
@@ -519,3 +520,15 @@ export const tokenize = input => path => {
     const scan = scanTokenize({ state: { kind: 'initial' }, metadata: { path, line: 1, column: 1 } });
     return flat(scan(flat([input /*satisfies List<CharCodeOrEof>*/, [null]])));
 };
+export const proof = {
+    throw: {
+        // union throws when two distinct non-default handlers are merged for the same range;
+        // this path is unreachable through the public API (no overlapping ranges in practice).
+        unionConflict: () => {
+            const def = (_) => todo;
+            const a = (_) => todo;
+            const b = (_) => todo;
+            union(def)(a)(b);
+        }
+    }
+};

package/fs/json/serializer/module.f.js

@@ -4,7 +4,6 @@
  * @module
  */
 import { flat, reduce, empty } from "../../types/list/module.f.js";
-import {} from "../../types/object/module.f.js";
 import {} from "../../types/function/operator/module.f.js";
 const jsonStringify = JSON.stringify;
 /**

package/fs/mcp/module.f.d.ts

@@ -229,4 +229,4 @@ export type McpConfig = {
  * - `tools/list` params (an optional pagination `cursor`) are validated and passed
  *   to the handler; invalid params → -32602.
  */
-export declare const mcpStep: <O extends Operation>({ protocolVersion, capabilities, serverInfo, }: McpConfig) => (handlers: McpHandlers<O>) => (stateKey: Key<McpSessionState>) => (value: Unknown) => Effect<MemOp | O, Response | null>;
+export declare const mcpStep: ({ protocolVersion, capabilities, serverInfo, }: McpConfig) => <O extends Operation>(handlers: McpHandlers<O>) => (stateKey: Key<McpSessionState>) => (value: Unknown) => Effect<MemOp | O, Response | null>;