functionalscript 0.39.0 → 0.41.0

package/fjs/effects/node/module.f.d.ts

@@ -224,8 +224,7 @@ export type Await = readonly ['await', (p: unknown) => readonly [unknown]];
 export declare const awaitIfPromise: (p: unknown) => Effect<Await, unknown>;
 /**
  * Signature of a framework test-registration function (e.g. `nodeTest.test`,
- * `bunTest.test`, `pwTest`). Returns `Promise<void>` so async sub-tests can
- * be awaited.
+ * `bunTest.test`). Returns `Promise<void>` so async sub-tests can be awaited.
  */
 export type TestFn = (name: string, options: {
     readonly expectFailure: boolean;
@@ -233,8 +232,8 @@ export type TestFn = (name: string, options: {
 /**
  * A thin wrapper around a framework's `test` function. Passed through
  * `registerModule` so nested test registration uses the appropriate context
- * (e.g. `inlineContext` on Bun and Playwright, which do not support nested
- * `test()` calls inside a callback).
+ * (e.g. `inlineContext` on Bun, which does not support nested `test()` calls
+ * inside a callback).
  */
 export type TestContext = {
     readonly test: TestFn;
@@ -258,7 +257,16 @@ export type Env = {
     readonly [k: string]: string | undefined;
 };
 /** Identifies the JavaScript runtime detected at startup. */
-export type Engine = 'node' | 'bun' | 'playwright';
+export type Engine = 'node' | 'bun' | 'deno';
+/** Compares semantic versions numerically by major, minor, then patch. */
+export declare const versionLessThan: (version: string, minimum: string) => boolean;
+/**
+ * Reports whether an external runner needs FunctionalScript's flattened test
+ * registration strategy. Node uses the native `expectFailure` option only
+ * from the Node 26 baseline; Deno is deliberately exempt from this Node-only
+ * version check.
+ */
+export declare const usesInlineTestContext: (engine: Engine, nodeVersion?: string) => boolean;
 /**
  * Runtime options passed to every `NodeProgram`.
  *
@@ -269,8 +277,9 @@ export type Engine = 'node' | 'bun' | 'playwright';
  * - `testContext`: Node `--test` context; used by `register` on Node.
  * - `bunTestContext`: Bun-compatible context that flattens nested tests inline,
  *   working around Bun's lack of nested `test()` support.
- * - `playwrightTestContext`: Playwright context using the same inline strategy.
  * - `engine`: runtime detected at startup; controls which context `register` selects.
+ * - `nodeVersion`: detected Node version; absent for other and virtual runtimes.
+ * - `inlineTestContext`: whether the selected context flattens nested tests.
  */
 export type NodeProgramOptions = {
     readonly args: readonly string[];
@@ -283,8 +292,9 @@ export type NodeProgramOptions = {
     };
     readonly testContext: TestContext;
     readonly bunTestContext: TestContext;
-    readonly playwrightTestContext: TestContext;
     readonly engine: Engine;
+    readonly nodeVersion?: string;
+    readonly inlineTestContext: boolean;
 };
 export type Program<O extends Operation> = (options: NodeProgramOptions) => Effect<O, number>;
 export type NodeProgram = Program<NodeOp>;

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

@@ -147,3 +147,25 @@ export const test = do_('test');
  * compose `mapStep(error(s), () => n)` directly.
  */
 export const errorExit = (s) => mapStep(error(s), () => 1);
+const versionParts = (version) => version.replace(/^v/, '').split('.').map(Number);
+/** Compares semantic versions numerically by major, minor, then patch. */
+export const versionLessThan = (version, minimum) => {
+    const [major = 0, minor = 0, patch = 0] = versionParts(version);
+    const [minMajor = 0, minMinor = 0, minPatch = 0] = versionParts(minimum);
+    return major < minMajor || major === minMajor && (minor < minMinor || minor === minMinor && patch < minPatch);
+};
+/**
+ * Reports whether an external runner needs FunctionalScript's flattened test
+ * registration strategy. Node uses the native `expectFailure` option only
+ * from the Node 26 baseline; Deno is deliberately exempt from this Node-only
+ * version check.
+ */
+export const usesInlineTestContext = (engine, nodeVersion) => {
+    if (engine === 'bun') {
+        return true;
+    }
+    if (engine !== 'node' || nodeVersion === undefined) {
+        return false;
+    }
+    return versionLessThan(nodeVersion, '26.0.0');
+};

package/fjs/effects/node/module.js

@@ -32,7 +32,7 @@ import { concat, normalize, toPosix } from '../../path/module.f.js';
 import {} from '../module.f.js';
 import { asyncRun } from '../module.js';
 import { memoryOperationMap } from './memory/module.js';
-import {} from './module.f.js';
+import { usesInlineTestContext, } from './module.f.js';
 import { asBase, asNominal } from '../../types/nominal/module.f.js';
 import { error, ok } from '../../types/result/module.f.js';
 import { asyncTryCatch } from '../../types/result/module.js';
@@ -250,10 +250,6 @@ const runNodeEffect = asyncRun({
     read: readStdinByte,
     test: async (ctx, name, expectFailure, test) => ctx.test(name, { expectFailure }, async (t) => runNodeEffect(test(t))),
 });
-const isPlaywright = 'PLAYWRIGHT_TEST' in (process?.env ?? {});
-const pwTest = isPlaywright
-    ? (await import('@playwright/test')).test
-    : undefined;
 const inlineTest = async (name, { expectFailure }, fn) => {
     if (expectFailure) {
         try {
@@ -273,25 +269,29 @@ const wrapInlineTest = (register) => ({
     test: (name, opts, fn) => register(name, () => inlineTest(name, opts, fn))
 });
 const bunTestContext = wrapInlineTest(testContext.test);
-const playwrightTestContext = wrapInlineTest(pwTest);
+const engine = 'Bun' in globalThis ? 'bun' :
+    'Deno' in globalThis ? 'deno' : 'node';
+const nodeVersion = engine === 'node' ? process.version : undefined;
+const inlineTestContext = usesInlineTestContext(engine, nodeVersion);
 const options = {
     args: process.argv.slice(2),
     env: process.env,
     home: toPosix(os.homedir()),
     std: { stdout: process.stdout, stderr: process.stderr },
-    testContext,
+    testContext: inlineTestContext ? wrapInlineTest(testContext.test) : testContext,
     bunTestContext,
-    playwrightTestContext,
-    engine: isPlaywright ? 'playwright' : 'Bun' in globalThis ? 'bun' : 'node',
+    engine,
+    ...(nodeVersion === undefined ? {} : { nodeVersion }),
+    inlineTestContext,
 };
 /**
  * Runs a `NodeProgram` against the real Node globals and process arguments,
  * resolving to its exit code **without** terminating the process.
  *
  * Use this when the caller must stay alive afterwards — e.g. when proofs are
- * registered under an external test runner (Node `--test`, Bun, Playwright)
- * that owns the process lifecycle. For a standalone CLI entry point that should
- * exit with the program's code, use {@link run} instead.
+ * registered under an external test runner (Node `--test`, Bun, Deno) that owns
+ * the process lifecycle. For a standalone CLI entry point that should exit with
+ * the program's code, use {@link run} instead.
  */
 export const runEffect = program => runNodeEffect(program(options));
 /**

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

@@ -1,4 +1,5 @@
 export declare const proof: {
+    externalTestContext: () => void;
     map: () => void;
     fetch: () => void;
     mkdir: {

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

@@ -1,7 +1,7 @@
 import { empty, isVec, uint, vec, vec8 } from "../../types/bit_vec/module.f.js";
 import { utf8, utf8ToString } from "../../text/module.f.js";
 import { match, pure, step } from "../module.f.js";
-import { both, fetch, mkdir, now, readdir, readFile, readUtf8File, rm, sandbox, writeFile, writeUtf8File, rename, readBytes, randomInt, writeFromStream } from "./module.f.js";
+import { both, fetch, mkdir, now, readdir, readFile, readUtf8File, rm, sandbox, writeFile, writeUtf8File, rename, readBytes, randomInt, writeFromStream, usesInlineTestContext, versionLessThan } from "./module.f.js";
 import { create as memCreate, read as memRead, write as memWrite } from "../memory/module.f.js";
 import { empty as listEmpty, nonEmpty as listNonEmpty } from "../list/module.f.js";
 import { emptyState, virtual } from "./virtual/module.f.js";
@@ -17,6 +17,19 @@ const readHello = match({
     },
 });
 export const proof = {
+    externalTestContext: () => {
+        assert(usesInlineTestContext('node', 'v22.20.0'));
+        assert(usesInlineTestContext('node', '25.99.99'));
+        assert(!usesInlineTestContext('node', '26.0.0'));
+        assert(!usesInlineTestContext('node', '26.1.0'));
+        assert(!usesInlineTestContext('node'));
+        assert(usesInlineTestContext('bun'));
+        assert(!usesInlineTestContext('deno', '22.0.0'));
+        assert(versionLessThan('25.99.99', '26.0.0'));
+        assert(versionLessThan('26.0.0', '26.1.0'));
+        assert(versionLessThan('26.1.0', '26.1.1'));
+        assert(!versionLessThan('26.1.1', '26.1.1'));
+    },
     map: () => {
         const e = step(readFile('hello'), ([k, v]) => {
             assert(k !== 'error', v);

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

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

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

@@ -31,6 +31,11 @@ export declare const proof: {
     match: {
         done: () => void;
         cont: () => void;
+        ownCommand: () => void;
+        throw: {
+            constructorCommand: () => void;
+            toStringCommand: () => void;
+        };
     };
     step: {
         pure: () => void;

package/fjs/effects/proof.f.js

@@ -15,6 +15,7 @@ export const assertPure = (e, expected) => {
     assertEq(o[0], expected);
 };
 const next = match({ add: (a, b) => a + b });
+const anyNext = match({ add: a => a + 1 });
 export const proof = {
     foldStep: {
         empty: () => {
@@ -103,6 +104,27 @@ export const proof = {
             assert(r2[0] === 'done', r2);
             assertEq(r2[1], 5);
         },
+        ownCommand: () => {
+            // The same map the two cases below dispatch against: an own
+            // property still resolves, so what they prove is refusal of
+            // inherited names, not a map that dispatches nothing.
+            const r = anyNext(do_('add')(41));
+            assert(r[0] === 'cont', r);
+            assertEq(r[1], 42);
+        },
+        // A `command` naming an `Object.prototype` member must not dispatch to
+        // the inherited value. `map['constructor']` is `Object` and
+        // `map['toString']` is `Function.prototype.toString` — both callable,
+        // neither a handler — so a plain index read would call one of them with
+        // the node's payload instead of throwing.
+        throw: {
+            constructorCommand: () => {
+                anyNext(do_('constructor')(1));
+            },
+            toStringCommand: () => {
+                anyNext(do_('toString')(1));
+            },
+        },
     },
     step: {
         pure: () => {

package/fjs/emergent_testing/all.test.js

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

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

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

package/fjs/emergent_testing/module.f.js

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

package/fjs/emergent_testing/proof.f.js

@@ -236,7 +236,7 @@ const makeRegisterRunner = (testOp) => {
     });
     return runner;
 };
-// registerModule appends ' ...' for inline runners (Bun/Playwright).
+// registerModule appends ' ...' for inline runners (Bun).
 // 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]);
@@ -249,7 +249,7 @@ export const registerSuffixes = () => {
     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
+    // Bun (star = ' ...'): ... on normal tests, path shows throw for throw-tests
     const [inlineNames] = runner([])(registerModule(registerNoopCtx, './a.f.ts', proof, ' ...'));
     assertEq(inlineNames.length, 2);
     assert(inlineNames[0] === 'import("./a.f.ts").proof.ok() ...');

package/fjs/emergent_testing/scenarios/thenable.pass.js

@@ -1,6 +1,6 @@
 // A test that returns a thenable (Promise-like object, not a real Promise).
 // Per FunctionalScript convention, thenables are treated as plain values —
-// not awaited. Both sandbox (fjs) and registerModule (node/bun/deno/playwright)
+// not awaited. Both sandbox (fjs) and registerModule (node/bun/deno)
 // must exit 0: the thenable object is walked as a sub-tree whose only key
 // `then` is a function with parameters, so no leaf tests are found and the
 // test trivially passes.

package/fjs/fsc/module.f.js

@@ -7,7 +7,7 @@ import { strictEqual } from '../types/function/operator/module.f.js';
 import { merge as rangeMapMerge, fromRange, get, } from '../types/range_map/module.f.js';
 import { reduce as listReduce, toArray, map } from '../types/list/module.f.js';
 import { range as asciiRange } from '../text/ascii/module.f.js';
-import { fn } from '../types/function/module.f.js';
+import { flip, fn } from '../types/function/module.f.js';
 import { one } from '../types/range/module.f.js';
 import { assertEq } from '../asserts/module.f.js';
 const fromCharCode = String.fromCharCode;
@@ -31,17 +31,17 @@ const reduce = (a) => {
     });
     return toArray(listReduce(merge)(empty)(a));
 };
-const codePointRange = fromRange(def);
+const codePointRange = flip(fromRange(def));
 const range = fn(asciiRange).map(codePointRange).result;
 const rangeSet = (l) => (f) => {
-    const codePointRange = fromRange(def);
+    const codePointRange = flip(fromRange(def));
     const g = r => codePointRange(asciiRange(r))(f);
     return reduce(map(g)(l));
 };
 const create = (a) => {
     const i = reduce(a);
     const x = get(def);
-    return v => c => x(c)(i)(v)(c);
+    return v => c => x(i)(c)(v)(c);
 };
 export const terminal = -1;
 const toInit = () => () => [[], init];

package/fjs/fsm/module.f.js

@@ -51,5 +51,5 @@ const initialState = [''];
 const initialStateStringify = stringifyIdentity(initialState);
 export const dfa = grammar => addEntry(grammar)(initialState)({});
 const get = rangeMapGet(emptyStateStringify);
-const runOp = dfa => input => s => get(input)(dfa[s] ?? []);
+const runOp = dfa => input => s => get(dfa[s] ?? [])(input);
 export const run = (dfa) => (input) => foldScan(runOp(dfa))(initialStateStringify)(input);

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

@@ -96,6 +96,7 @@ type ErrorMessage = '" are missing' | 'unescaped character' | 'invalid hex value
 export declare const isKeywordToken: (token: JsToken) => boolean;
 export declare const tokenize: (input: List<number>) => (path: string) => List<JsTokenWithMetadata>;
 export declare const proof: {
+    getOperatorTokenInvalid: () => void;
     throw: {
         unionConflict: () => void;
     };

package/fjs/js/tokenizer/module.f.js

@@ -27,7 +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';
+import { todo, assertEq } from '../../asserts/module.f.js';
 const { fromCharCode } = String;
 const rangeOneNine = range('19');
 const rangeSetNewLine = [
@@ -111,21 +111,20 @@ const rangeMapMerge = def => merge({
     equal: strictEqual,
     def,
 });
-const rangeFunc = r => f => def => fromRange(def)(r)(f);
+const rangeFunc = r => f => def => fromRange(def)(f)(r);
 const scanRangeOp = def => f => [f(def), scanRangeOp(def)];
 const reduceRangeMap = def => a => {
     const rm = scan(scanRangeOp(def))(a);
     return toArray(listReduce(rangeMapMerge(def))(empty)(rm));
 };
-const scanRangeSetOp = def => f => r => [fromRange(def)(r)(f), scanRangeSetOp(def)(f)];
+const scanRangeSetOp = def => f => r => [fromRange(def)(f)(r), scanRangeSetOp(def)(f)];
 const rangeSetFunc = rs => f => def => {
     const rm = scan(scanRangeSetOp(def)(f))(rs);
     return toArray(listReduce(rangeMapMerge(def))(empty)(rm));
 };
 const create = (def) => (a) => {
-    const i = reduceRangeMap(def)(a);
-    const x = get(def);
-    return v => c => x(c)(i)(v)(c);
+    const x = get(def)(reduceRangeMap(def)(a));
+    return v => c => x(c)(v)(c);
 };
 const digitToBigInt = d => BigInt(d - digit0);
 const startNumber = digit => ({ s: 1n, m: digitToBigInt(digit), f: 0, es: 1, e: 0 });
@@ -527,6 +526,14 @@ export const tokenize = input => path => {
     return flat(scan(flat([input /*satisfies List<CharCodeOrEof>*/, [null]])));
 };
 export const proof = {
+    // `getOperatorToken` is only ever called with a value already confirmed to be
+    // a known operator (`hasOperatorToken`, or a single char from `rangeOpStart`),
+    // so its `??` fallback is unreachable through `tokenize`. Call it directly
+    // with a non-operator string to cover that branch.
+    getOperatorTokenInvalid: () => {
+        const result = getOperatorToken('@');
+        assertEq(result.kind, 'error');
+    },
     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).

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

@@ -1,9 +1,7 @@
-import { type Effect } from '../../effects/module.f.ts';
 import { type MemOp } from '../../effects/memory/module.f.ts';
-import { type Read, type Write } from '../../effects/node/module.f.ts';
-import { type McpConfig, type McpHandlers, type ToolEntry } from '../../mcp/module.f.ts';
-import { type FileCasOperation } from '../module.f.ts';
-import { type Cache } from '../evo/module.f.ts';
+import { type ToolEntry } from '../../protocol/mcp/module.f.ts';
+import { type FileCasOperation } from '../../cas/module.f.ts';
+import { type Cache } from '../../cas/evo/module.f.ts';
 import type { Key } from '../../effects/memory/module.f.ts';
 /** Arguments for `cas_add`: content to store, with optional encoding type. */
 export declare const casAddArgs: {
@@ -27,23 +25,3 @@ export declare const casListArgs: {};
  * rescan.
  */
 export declare const casToolRegistry: (home: string) => (cacheKey: Key<Cache>) => readonly ToolEntry<FileCasOperation | MemOp>[];
-/**
- * MCP handlers for `FileCas` plus the Evo API (`fjs/cas/evo`) layered on it,
- * bound to `home` and an already-built Evo cache slot (see `initEvo`).
- */
-export declare const casMcpHandlers: (home: string) => (cacheKey: Key<Cache>) => McpHandlers<FileCasOperation | MemOp>;
-/**
- * Static MCP configuration for the CAS server: advertises the `tools`
- * capability, identifies the server, and pins the protocol version.
- */
-export declare const casConfig: McpConfig;
-/**
- * Runs the combined CAS + Evo MCP server over stdio: scans `~/.cas/` once to
- * build the Evo subject/head cache (`initEvo`), allocates the session-state
- * slot, builds the `mcpStep` for the merged tool registry, and drives the
- * read → parse → dispatch → write loop until stdin EOF.
- */
-export declare const casMcpServer: (home: string) => Effect<Read | Write | MemOp | FileCasOperation, void>;
-export declare const proof: {
-    casMcpServer: () => void;
-};

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

@@ -1,28 +1,21 @@
 /**
- * MCP adapter for the content-addressable store and the Evo API layered on
- * top of it.
- *
- * Maps `Cas<O>` operations onto MCP tools, so an agent that speaks MCP can
- * store a blob and get back its hash, fetch a blob by hash, and enumerate
- * what is stored — without shelling out to the `cas` CLI. The store itself
+ * The `cas_add` / `cas_get` / `cas_list` tool registry: maps `Cas<O>`
+ * operations onto MCP tools, so an agent that speaks MCP can store a blob and
+ * get back its hash, fetch a blob by hash, and enumerate what is stored —
+ * without shelling out to the `cas` CLI. The store itself
  * (`fjs/cas/module.f.ts`) stays transport-agnostic; this is an additional
- * front end alongside the CLI `main`. The same server also exposes
- * `fjs/cas/evo`'s subject/head API
- * (`evo_list`/`evo_head`/`evo_revision`/`evo_add`, `fjs/cas/evo/mcp`) — one
- * process, one `~/.cas/` store, one in-memory Evo cache scanned once at
- * startup (`initEvo`).
+ * front end alongside the CLI `main`. This registry is one of the tool sets
+ * `fjs/mcp/module.f.ts` composes into the FJS MCP server — see that module
+ * for the full tool table (including `fjs/mcp/evo`'s `evo_*` tools) and the
+ * server entry point.
  *
  * ## Tools
  *
- * | Tool           | args                                         | action           | result                              |
- * |----------------|----------------------------------------------|------------------|--------------------------------------|
- * | `cas_add`      | `{ content, type? }`                         | `c.write(...)`   | hash (cBase32)                      |
- * | `cas_get`      | `{ hash, content?: boolean }`                | `c.read(key)`    | JSON `{length,mimeType,type[,uri][,text\|blob]}` |
- * | `cas_list`     | `{}`                                         | `c.list()`       | hashes, one per line                |
- * | `evo_list`     | `{}`                                         | `e.list()`       | subjects, one per line              |
- * | `evo_head`     | `{ subject }`                                | `e.head(...)`    | head hashes, one per line           |
- * | `evo_revision` | `{ hash }`                                   | `e.revision(...)`| the revision, as JSON               |
- * | `evo_add`      | `{ parents, snapshot?, subject?, archived? }` | `e.add(...)`     | hash (cBase32)                      |
+ * | Tool           | args                          | action           | result                              |
+ * |----------------|--------------------------------|------------------|--------------------------------------|
+ * | `cas_add`      | `{ content, type? }`          | `c.write(...)`   | hash (cBase32)                      |
+ * | `cas_get`      | `{ hash, content?: boolean }` | `c.read(key)`    | JSON `{length,mimeType,type[,uri][,text\|blob]}` |
+ * | `cas_list`     | `{}`                          | `c.list()`       | hashes, one per line                |
  *
  * ## `cas_add` input encoding
  *
@@ -35,7 +28,7 @@
  *
  * Inline content (either encoding) is capped at 128 KiB (`maxLength`). There is
  * no MCP route for larger content — the server never opens a local path named by
- * the client (see the invariant in `fjs/cas/mcp/README.md`); large files go
+ * the client (see the invariant in `fjs/mcp/README.md`); large files go
  * through the `cas` CLI (`cas add <path>`) instead, run directly by the user.
  *
  * ## `cas_get` output
@@ -111,7 +104,7 @@
 import { string, option, or, boolean } from '../../types/rtti/module.f.js';
 import { stringify } from '../../media/json/module.f.js';
 import { pure, step } from '../../effects/module.f.js';
-import { create } from '../../effects/memory/module.f.js';
+import {} from '../../effects/memory/module.f.js';
 import { cBase32ToVec, vecToCBase32 } from '../../basen/cbase32/module.f.js';
 import { decode as base64Decode, encode as base64Encode } from '../../basen/base64/module.f.js';
 import { tryUtf8 } from '../../text/module.f.js';
@@ -119,16 +112,13 @@ import { detectStream } from '../../media/type/module.f.js';
 import { detect as detectDialect } from '../../media/module.f.js';
 import { maxLengthBytes } from '../../types/bit_vec/module.f.js';
 import { ok } from '../../types/result/module.f.js';
-import {} from '../../effects/node/module.f.js';
-import { stdioTransport } from '../../mcp/stdio/module.f.js';
-import { mcpStep, uninitializedState, toolEntry, fromRegistry, errorResult, okResult, } from '../../mcp/module.f.js';
-import { collectRead, fileCas } from '../module.f.js';
+import { toolEntry, errorResult, okResult, } from '../../protocol/mcp/module.f.js';
+import { collectRead, fileCas } from '../../cas/module.f.js';
 import { fromVec } from '../../text/utf8/module.f.js';
 import { identity } from '../../types/function/module.f.js';
 import { sha256 } from '../../crypto/sha2/module.f.js';
 import { nonEmpty, empty as elEmpty } from '../../effects/list/module.f.js';
-import { initEvo, evo, syncRevision } from '../evo/module.f.js';
-import { evoToolRegistry } from '../evo/mcp/module.f.js';
+import { syncRevision } from '../../cas/evo/module.f.js';
 // ── Argument schemas (declared once, used for both inputSchema and validate) ─────
 /** Arguments for `cas_add`: content to store, with optional encoding type. */
 export const casAddArgs = {
@@ -237,33 +227,3 @@ export const casToolRegistry = (home) => (cacheKey) => {
         toolEntry('cas_list', 'List all stored content hashes (cBase32), one per line.', casListArgs, () => step(c.list(), hashes => pure(okResult(hashes.map(vecToCBase32).join('\n'))))),
     ];
 };
-// ── Handlers ────────────────────────────────────────────────────────────────────
-/**
- * MCP handlers for `FileCas` plus the Evo API (`fjs/cas/evo`) layered on it,
- * bound to `home` and an already-built Evo cache slot (see `initEvo`).
- */
-export const casMcpHandlers = (home) => (cacheKey) => fromRegistry([...casToolRegistry(home)(cacheKey), ...evoToolRegistry(evo(fileCas(sha256)(home))(cacheKey))]);
-// ── Session configuration ───────────────────────────────────────────────────────
-/**
- * Static MCP configuration for the CAS server: advertises the `tools`
- * capability, identifies the server, and pins the protocol version.
- */
-export const casConfig = {
-    serverInfo: { name: 'functionalscript-cas', version: '0.30.0' },
-    capabilities: { tools: {} },
-    protocolVersion: '2024-11-05',
-};
-// ── Server ──────────────────────────────────────────────────────────────────────
-/**
- * Runs the combined CAS + Evo MCP server over stdio: scans `~/.cas/` once to
- * build the Evo subject/head cache (`initEvo`), allocates the session-state
- * slot, builds the `mcpStep` for the merged tool registry, and drives the
- * read → parse → dispatch → write loop until stdin EOF.
- */
-export const casMcpServer = (home) => step(initEvo(fileCas(sha256)(home)), cacheKey => step(create(uninitializedState), sessionKey => stdioTransport(mcpStep(casConfig)(casMcpHandlers(home)(cacheKey))(sessionKey))));
-// ── Tests ────────────────────────────────────────────────────────────────────
-export const proof = {
-    // casMcpServer is never called in integration tests because it drives a
-    // real stdio server; call it here to cover its Effect-building body.
-    casMcpServer: () => { casMcpServer('/'); },
-};

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

@@ -0,0 +1,32 @@
+import { type Operation } from '../../effects/module.f.ts';
+import { type MemOp } from '../../effects/memory/module.f.ts';
+import { type ToolEntry } from '../../protocol/mcp/module.f.ts';
+import { type Evo } from '../../cas/evo/module.f.ts';
+/**
+ * Arguments for `evo_list`: an optional status filter, forwarded unchanged to
+ * `Evo.list` — omitted lists the active subjects, `true` the archived ones.
+ */
+export declare const evoListArgs: {
+    readonly archived: import("../../types/rtti/module.f.ts").Or<readonly [true, undefined]>;
+};
+/** Arguments for `evo_head`: the subject whose current heads are requested. */
+export declare const evoHeadArgs: {
+    readonly subject: import("../../types/rtti/module.f.ts").String;
+};
+/** Arguments for `evo_revision`: the hash of the revision to read. */
+export declare const evoRevisionArgs: {
+    readonly hash: import("../../types/rtti/module.f.ts").String;
+};
+/**
+ * Arguments for `evo_add`: a new revision, per `fjs/cas/evo`'s
+ * `RevisionData` — every field of it the caller supplies, i.e. all but
+ * `generation`, which the server computes.
+ */
+export declare const evoAddArgs: {
+    readonly parents: import("../../types/rtti/module.f.ts").Type1<"array", import("../../types/rtti/module.f.ts").String>;
+    readonly snapshot: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+    readonly subject: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+    readonly archived: import("../../types/rtti/module.f.ts").Or<readonly [true, undefined]>;
+};
+/** Registry of all Evo tools, bound to an `Evo<O>`. */
+export declare const evoToolRegistry: <O extends Operation>(e: Evo<O>) => readonly ToolEntry<O | MemOp>[];