functionalscript 0.41.0 → 0.43.0

package/fjs/bnf/data/module.f.d.ts

@@ -11,7 +11,7 @@ export type TerminalRange = number;
  */
 export type Sequence = readonly string[];
 /** A variant of rule names. */
-export type Variant = StringMap<string, string>;
+export type Variant = StringMap<string>;
 /**
  * Grammar rule definition.
  *
@@ -29,7 +29,7 @@ export type RuleSet = Readonly<Record<string, Rule>>;
  * variant branch.
  */
 export type EmptyTag = string | true | undefined;
-type EmptyTagMap = StringMap<string, EmptyTag>;
+type EmptyTagMap = StringMap<EmptyTag>;
 /**
  * Computes, for every rule in the set, whether it can match empty input, by
  * the standard nullable-set fixpoint: a sequence is nullable iff all of its

package/fjs/bnf/ll1/module.f.d.ts

@@ -26,7 +26,7 @@ type DispatchRuleCollection = {
     readonly tag: string | undefined;
     readonly rules: DispatchRuleOrName[];
 };
-type DispatchMap = StringMap<string, DispatchRule>;
+type DispatchMap = StringMap<DispatchRule>;
 /**
  * Represents a parsed AST sequence.
  */

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

@@ -89,7 +89,7 @@ export declare const range: (ab: string) => TerminalRange;
 /**
  * A set of terminal ranges compatible with the `Variant` rule.
  */
-export type RangeVariant = StringMap<string, TerminalRange>;
+export type RangeVariant = StringMap<TerminalRange>;
 export declare const remove: (range: TerminalRange, v: RangeVariant) => RangeVariant;
 /**
  * Returns the complement set of the provided ranges over {@link fullRange}.

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

@@ -119,7 +119,7 @@ export type SubjectState = {
 };
 /** In-memory index: subject → its {@link SubjectState}. */
 export type Cache = {
-    readonly bySubject: StringMap<string, SubjectState>;
+    readonly bySubject: StringMap<SubjectState>;
 };
 /** A cache with no known subjects yet — the starting point for {@link buildCache}. */
 export declare const emptyCache: Cache;

package/fjs/ci/config/module.f.d.ts

@@ -18,17 +18,17 @@ export declare const images: {
         readonly arm: 'windows-11-arm';
     };
 };
-export declare const functionalscript: '0.39.0';
+export declare const functionalscript: '0.41.0';
 export declare const bun = "1.3.14";
 export declare const deno = "2.9.4";
 export declare const node: {
-    readonly default: '26.5.1';
+    readonly default: '26.6.0';
     readonly node22: '22.23.2';
     readonly node24: '24.18.0';
 };
 export declare const nixpkgs: {
     readonly ref: 'nixos-26.05';
-    readonly commit: '6d65bfc1bcef2ef39a239d38e577e92a89fb0f07';
+    readonly commit: '04607e1165ac22c5fde6dcc54c9e0b3c0487c555';
 };
 export declare const wasmtime = "47.0.3";
 export declare const wasmer = "7.2.1";

package/fjs/ci/config/module.f.js

@@ -23,7 +23,7 @@ export const images = {
 // published FunctionalScript release; do not tie it to package.json's current
 // in-repo version.
 // https://www.npmjs.com/package/functionalscript
-export const functionalscript = '0.39.0';
+export const functionalscript = '0.41.0';
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
@@ -36,7 +36,7 @@ export const deno = '2.9.4';
 // it offers rather than the latest release.
 // https://nodejs.org/en/download
 export const node = {
-    default: '26.5.1',
+    default: '26.6.0',
     node22: '22.23.2',
     node24: '24.18.0',
 };
@@ -47,7 +47,7 @@ export const node = {
 // https://channels.nixos.org/nixos-26.05/git-revision
 export const nixpkgs = {
     ref: 'nixos-26.05',
-    commit: '6d65bfc1bcef2ef39a239d38e577e92a89fb0f07',
+    commit: '04607e1165ac22c5fde6dcc54c9e0b3c0487c555',
 };
 // https://github.com/bytecodealliance/wasmtime/releases
 export const wasmtime = '47.0.3';

package/fjs/ci/deno/module.f.d.ts

@@ -1,2 +1,10 @@
 import { type MetaStep } from '../common/module.f.ts';
+/**
+ * The regular expression selecting FunctionalScript implementation modules for
+ * Deno coverage. Both authored extensions are included so a module migrated
+ * from `.f.ts` to `.f.mjs` stays in the report. Keep it semantically equal to
+ * the `--test-coverage-include` list in `package.json` and to the `cov` task in
+ * `deno.json`.
+ */
+export declare const coverageInclude: '.*module\\.f\\.(ts|mjs)';
 export declare const denoSteps: (version: string) => readonly MetaStep[];

package/fjs/ci/deno/module.f.js

@@ -7,6 +7,14 @@
 import { deno } from '../config/module.f.js';
 import { install, test, uses } from '../common/module.f.js';
 const denoTest = 'deno test --allow-read --allow-env --allow-sys';
+/**
+ * The regular expression selecting FunctionalScript implementation modules for
+ * Deno coverage. Both authored extensions are included so a module migrated
+ * from `.f.ts` to `.f.mjs` stays in the report. Keep it semantically equal to
+ * the `--test-coverage-include` list in `package.json` and to the `cov` task in
+ * `deno.json`.
+ */
+export const coverageInclude = '.*module\\.f\\.(ts|mjs)';
 export const denoSteps = (version) => [
     install(uses('denoland/setup-deno', { 'deno-version': deno })),
     // We need --minimum-dependency-age=0 for functionalscript because we would like to use
@@ -16,5 +24,5 @@ export const denoSteps = (version) => [
     install({ run: `deno install -g -A --minimum-dependency-age=0 npm:functionalscript@${version}` }),
     test({ run: `deno run -A --minimum-dependency-age=0 npm:functionalscript@${version} t` }),
     test({ run: 'deno install --frozen' }),
-    test({ run: `${denoTest} --coverage && deno coverage --include='.*module\\.f\\.ts'` }),
+    test({ run: `${denoTest} --coverage && deno coverage --include='${coverageInclude}'` }),
 ];

package/fjs/ci/deno/proof.f.d.ts

@@ -0,0 +1,5 @@
+export declare const proof: {
+    coverageInclude: () => void;
+    coverageStep: () => void;
+    installsPinnedVersion: () => void;
+};

package/fjs/ci/deno/proof.f.js

@@ -0,0 +1,26 @@
+import { coverageInclude, denoSteps } from './module.f.js';
+import { toSteps } from '../common/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
+const coverageRuns = (version) => toSteps(denoSteps(version))
+    .flatMap(s => s.run !== undefined && s.run.includes('deno coverage') ? [s.run] : []);
+export const proof = {
+    // A regression guard: dropping either authored implementation extension
+    // from the Deno coverage filter silently removes those modules from the
+    // CI coverage report while CI still passes.
+    coverageInclude: () => {
+        assertEq(coverageInclude, '.*module\\.f\\.(ts|mjs)');
+    },
+    coverageStep: () => {
+        const runs = coverageRuns('0.0.0');
+        assertEq(runs.length, 1);
+        const [run] = runs;
+        assert(run !== undefined);
+        assert(run.includes(`deno coverage --include='${coverageInclude}'`));
+    },
+    installsPinnedVersion: () => {
+        const runs = toSteps(denoSteps('1.2.3'))
+            .flatMap(s => s.run !== undefined && s.run.includes('npm:functionalscript@') ? [s.run] : []);
+        assertEq(runs.length, 2);
+        assert(runs.every(r => r.includes('npm:functionalscript@1.2.3')));
+    },
+};

package/fjs/ci/proof.f.js

@@ -1,6 +1,7 @@
 import { ci, main } from './module.f.js';
 import { functionalscript, node } from './config/module.f.js';
 import { nodeNixJobs } from './node/module.f.js';
+import { coverageInclude } from './deno/module.f.js';
 import { utf8, utf8ToString } from '../text/module.f.js';
 import { empty as emptyVec, isVec } from '../types/bit_vec/module.f.js';
 import { test, ubuntu, parseGitHubAction } from './common/module.f.js';
@@ -33,7 +34,7 @@ const text = (dir, name) => {
 const path = (dir, names) => names.reduce(subDir, dir);
 const workflow = (state) => {
     const workflows = path(state.root, ['.github', 'workflows']);
-    return unwrap(parseGitHubAction(jsonParse(text(workflows, 'ci.yml'))));
+    return unwrap(parseGitHubAction(unwrap(jsonParse(text(workflows, 'ci.yml')))));
 };
 const flake = (state, id) => text(path(state.root, ['nix', 'generated', id]), 'flake.nix');
 const run = (rust, nodeExtra = () => []) => {
@@ -132,7 +133,7 @@ export const proof = {
             assert(hasRun(`deno install -g -A --minimum-dependency-age=0 npm:functionalscript@${functionalscript}`)(gha), 'expected configured-version deno install cache');
             assert(hasRun('deno install --frozen')(gha), 'expected deno lock install');
             assert(hasRun(`deno run -A --minimum-dependency-age=0 npm:functionalscript@${functionalscript} t`)(gha), 'expected configured-version deno install');
-            assert(hasRun("deno test --allow-read --allow-env --allow-sys --coverage && deno coverage --include='.*module\\.f\\.ts'")(gha), 'expected limited-permission deno coverage');
+            assert(hasRun(`deno test --allow-read --allow-env --allow-sys --coverage && deno coverage --include='${coverageInclude}'`)(gha), 'expected limited-permission deno coverage');
             assert(hasRun(`bun install -g functionalscript@${functionalscript}`)(gha), 'expected configured-version bun cache');
             assert(hasRun('bun install --frozen-lockfile')(gha), 'expected bun lock install');
             assert(hasRun(`bunx functionalscript@${functionalscript} t`)(gha), 'expected configured-version bun install');

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

@@ -10,14 +10,23 @@ export type Module = {
     readonly proof?: unknown;
     readonly [k: string]: unknown;
 };
-export type ModuleMap = StringMap<string, Module>;
+export type ModuleMap = StringMap<Module>;
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *
- * All FunctionalScript modules (`.f.ts` / `.f.js`) are safe to bulk-load by
- * construction — they have no import side effects. For vanilla TS/JS the
- * load gate stays opt-in by filename: any file ending in `proof.ts`,
- * `proof.js`, `proof.mts`, or `proof.mjs` is included.
+ * Two symmetrical rules, each covering all four TS/JS module extensions:
+ *
+ * - **FunctionalScript modules** — anything ending in `.f.ts`, `.f.mts`,
+ *   `.f.js`, or `.f.mjs`. They are safe to bulk-load by construction, since
+ *   they have no import side effects, so the whole module is loaded and its
+ *   internal `proof` export (if any) is discovered. `.f.ts` and `.f.mjs` are
+ *   the authored extensions; `.f.js` is generated from `.f.ts`.
+ * - **Impure JavaScript/TypeScript proofs** — anything ending in `proof.ts`,
+ *   `proof.mts`, `proof.js`, or `proof.mjs`. Outside FunctionalScript a module
+ *   may have import side effects, so the load gate stays opt-in by filename.
+ *
+ * A `proof.f.mts` / `proof.f.mjs` matches the FunctionalScript rule by its
+ * `.f.` infix, not the vanilla proof rule.
  *
  * Whether a loaded module actually _contains_ a proof is determined at
  * runtime by checking for an exported `proof` property.
@@ -42,5 +51,7 @@ export type LoadModuleOperations = Access | Import | All | Readdir;
 export declare const loadModuleMap: (env: Env) => Effect<LoadModuleOperations, ModuleMap>;
 export declare const proof: {
     isSourceFile: () => void;
+    allFilesFindsFunctionalScript: () => void;
     allFilesSkipsNodeModules: () => void;
+    loadModuleMapDefaultsToCwdWhenInitCwdUnset: () => void;
 };

package/fjs/dev/module.f.js

@@ -13,17 +13,27 @@ import { emptyState, virtual } from '../effects/node/virtual/module.f.js';
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *
- * All FunctionalScript modules (`.f.ts` / `.f.js`) are safe to bulk-load by
- * construction — they have no import side effects. For vanilla TS/JS the
- * load gate stays opt-in by filename: any file ending in `proof.ts`,
- * `proof.js`, `proof.mts`, or `proof.mjs` is included.
+ * Two symmetrical rules, each covering all four TS/JS module extensions:
+ *
+ * - **FunctionalScript modules** — anything ending in `.f.ts`, `.f.mts`,
+ *   `.f.js`, or `.f.mjs`. They are safe to bulk-load by construction, since
+ *   they have no import side effects, so the whole module is loaded and its
+ *   internal `proof` export (if any) is discovered. `.f.ts` and `.f.mjs` are
+ *   the authored extensions; `.f.js` is generated from `.f.ts`.
+ * - **Impure JavaScript/TypeScript proofs** — anything ending in `proof.ts`,
+ *   `proof.mts`, `proof.js`, or `proof.mjs`. Outside FunctionalScript a module
+ *   may have import side effects, so the load gate stays opt-in by filename.
+ *
+ * A `proof.f.mts` / `proof.f.mjs` matches the FunctionalScript rule by its
+ * `.f.` infix, not the vanilla proof rule.
  *
  * Whether a loaded module actually _contains_ a proof is determined at
  * runtime by checking for an exported `proof` property.
  */
-export const shouldLoad = (s) => s.endsWith('.f.ts') || s.endsWith('.f.js') ||
-    s.endsWith('proof.ts') || s.endsWith('proof.js') ||
-    s.endsWith('proof.mts') || s.endsWith('proof.mjs');
+export const shouldLoad = (s) => s.endsWith('.f.ts') || s.endsWith('.f.mts') ||
+    s.endsWith('.f.js') || s.endsWith('.f.mjs') ||
+    s.endsWith('proof.ts') || s.endsWith('proof.mts') ||
+    s.endsWith('proof.js') || s.endsWith('proof.mjs');
 const isSourceFile = (path) => path.endsWith('.js') || path.endsWith('.ts') || path.endsWith('.mts') || path.endsWith('.mjs');
 const allFiles = (s, predicate) => {
     const load = (p) => {
@@ -91,6 +101,19 @@ export const proof = {
         assert(!isSourceFile('readme.md'));
         assert(!isSourceFile('module.json'));
     },
+    allFilesFindsFunctionalScript: () => {
+        // Every FunctionalScript extension is discovered, so a module migrated
+        // from `.f.ts` to `.f.mjs` keeps its proofs. An ordinary `.mjs` is
+        // still skipped.
+        const root = {
+            'a.f.ts': [],
+            'b.f.mjs': [],
+            'c.f.mts': [],
+            'd.mjs': [],
+        };
+        const [, result] = virtual({ ...emptyState, root })(allFiles('.', shouldLoad));
+        assertEq(result.join(','), './a.f.ts,./b.f.mjs,./c.f.mts');
+    },
     allFilesSkipsNodeModules: () => {
         // `node_modules` is skipped without descending into it, even though
         // it contains a file that would otherwise match the predicate.
@@ -101,4 +124,12 @@ export const proof = {
         const [, result] = virtual({ ...emptyState, root })(allFiles('.', shouldLoad));
         assertEq(result.join(','), './a.f.ts');
     },
+    loadModuleMapDefaultsToCwdWhenInitCwdUnset: () => {
+        // With no `INIT_CWD` (e.g. `fjs t` invoked outside `npm run`), `env`
+        // lookup returns `undefined` and discovery falls back to `.`, so
+        // every path keeps its own `./`-prefix instead of having one stripped.
+        const root = { 'a.f.ts': () => ({}) };
+        const [, result] = virtual({ ...emptyState, root })(loadModuleMap({}));
+        assertEq(Object.keys(result).join(','), './a.f.ts');
+    },
 };

package/fjs/dev/package_json/module.f.js

@@ -1,6 +1,10 @@
-import { parse as jsonParse } from '../../media/json/parser/module.f.js';
-import { tokenize as jsonTokenize } from '../../media/json/tokenizer/module.f.js';
-import { stringToList } from '../../text/utf16/module.f.js';
+/**
+ * Helpers for reading package.json-style metadata without losing unrelated
+ * fields before write-back.
+ *
+ * @module
+ */
+import { parse as parseJsonText } from '../../media/json/module.f.js';
 import { option, record, string } from '../../types/rtti/module.f.js';
 import { validate as rttiValidate } from '../../types/rtti/validate/module.f.js';
 import { error, ok } from '../../types/result/module.f.js';
@@ -10,7 +14,6 @@ export const packageJsonSchema = {
     scripts: option(record(string)),
 };
 export const validatePackageJson = rttiValidate(packageJsonSchema);
-const parseJsonText = (text) => jsonParse(jsonTokenize(stringToList(text)));
 export const validatePackageJsonText = (text) => {
     const [t, v] = parseJsonText(text);
     if (t === 'error') {

package/fjs/dev/proof.f.js

@@ -2,13 +2,22 @@ import { assert, assertEq, todo } from '../asserts/module.f.js';
 import { shouldLoad } from './module.f.js';
 export const proof = {
     shouldLoad: () => {
+        // Every FunctionalScript extension is loaded whatever the file name.
         assert(shouldLoad('foo.f.ts'));
+        assert(shouldLoad('foo.f.mts'));
         assert(shouldLoad('bar.f.js'));
+        assert(shouldLoad('module.f.mjs'));
+        assert(shouldLoad('proof.f.mts'));
+        assert(shouldLoad('proof.f.mjs'));
+        // Every impure JS/TS extension is loaded only under the `proof` name.
         assert(shouldLoad('proof.ts'));
-        assert(shouldLoad('proof.js'));
         assert(shouldLoad('proof.mts'));
+        assert(shouldLoad('proof.js'));
         assert(shouldLoad('proof.mjs'));
         assert(!shouldLoad('module.ts'));
+        assert(!shouldLoad('module.mts'));
+        assert(!shouldLoad('module.js'));
+        assert(!shouldLoad('module.mjs'));
         assert(!shouldLoad('readme.md'));
     },
     shouldPass: () => ({

package/fjs/djs/parser/module.f.js

@@ -4,7 +4,7 @@
  * @module
  */
 import { error, ok } from '../../types/result/module.f.js';
-import { fold, first, drop, toArray, length, concat } from '../../types/list/module.f.js';
+import { fold, next, toArray, length, concat } from '../../types/list/module.f.js';
 import { setReplace, at } from '../../types/ordered_map/module.f.js';
 import { fromMap } from '../../types/object/module.f.js';
 import { assertEq } from '../../asserts/module.f.js';
@@ -164,9 +164,19 @@ const startArray = state => {
     const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
     return { ...state, valueState: '[', top: ['array', null], stack: newStack };
 };
+// Pops the enclosing container off `stack`. `next` is forced here rather than
+// left as a `drop(1)` thunk: the stack is written only by startArray/startObject,
+// always as a literal cons, and a lazy pop leaves one unforced thunk per closed
+// container — a chain that overflows the call stack when it is finally forced.
+const popStack = state => {
+    const ne = next(state.stack);
+    return ne === null
+        ? { ...state, valueState: '', top: null, stack: null }
+        : { ...state, valueState: '', top: ne.first, stack: ne.tail };
+};
 const endArray = state => {
     const top = state.top;
-    const newState = { ...state, valueState: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
+    const newState = popStack(state);
     if (top !== null && top[0] === 'array') {
         const array = ['array', toArray(top[1])];
         return pushValue(newState)(array);
@@ -179,7 +189,7 @@ const startObject = state => {
 };
 const endObject = state => {
     const obj = state?.top !== null && state?.top[0] === 'object' ? fromMap(state.top[1]) : null;
-    const newState = { ...state, valueState: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
+    const newState = popStack(state);
     return pushValue(newState)(obj);
 };
 const tokenToValue = token => {

package/fjs/djs/parser/proof.f.d.ts

@@ -10,4 +10,5 @@ export declare const proof: {
     validWithArgs: (() => void)[];
     invalidWithArgs: (() => void)[];
     comments: (() => void)[];
+    containerStackCost: (() => void)[];
 };

package/fjs/djs/parser/proof.f.js

@@ -526,5 +526,31 @@ export const proof = {
             const result = stringifyDjsModule(obj[1]);
             assertEq(result, '[[],[null]]');
         },
+    ],
+    // Regression: closing a container popped the parser stack with `drop(1)`,
+    // which is lazy, so every closed container left one unforced thunk wrapping
+    // the stack. The chain was forced only at the end, costing a call-stack
+    // frame per container and overflowing at roughly 5000 of them — whether
+    // nested or flat siblings — while primitives were unbounded. `fjs/media/json`
+    // carried the same defect and was fixed in the same way.
+    containerStackCost: [
+        () => {
+            const [tag, value] = parseFromTokens(tokenizeString(`export default [${Array(20000).fill('{}').join(',')}]`));
+            assert(tag === 'ok', tag);
+            assertEq(value[1].length, 1);
+        },
+        () => {
+            const [tag] = parseFromTokens(tokenizeString(`export default [${Array(20000).fill('[]').join(',')}]`));
+            assert(tag === 'ok', tag);
+        },
+        () => {
+            const [tag] = parseFromTokens(tokenizeString('export default ' + '['.repeat(20000) + ']'.repeat(20000)));
+            assert(tag === 'ok', tag);
+        },
+        () => {
+            // primitives never touched the stack — the baseline that always passed
+            const [tag] = parseFromTokens(tokenizeString(`export default [${Array.from({ length: 20000 }, (_, i) => i).join(',')}]`));
+            assert(tag === 'ok', tag);
+        },
     ]
 };

package/fjs/djs/tokenizer/proof.f.js

@@ -1167,12 +1167,19 @@ export const proof = {
         () => {
             // many distinct short tokens, well past the ~1000-1500 token crash threshold
             // the old whole-file recursive match hit for this shape
-            const src = Array.from({ length: 3000 }, (_, i) => `a${i % 10}`).join(' ');
+            const ids = Array.from({ length: 3000 }, (_, i) => `a${i % 10}`);
+            const src = ids.join(' ');
             const result = tokenizeString(src);
             assert(result !== 'error', result);
-            const parsed = JSON.parse(result);
-            // 3000 ids + 2999 separating ws + a trailing eof token
-            assertEq(parsed.length, 3000 + 2999 + 1);
+            // `tokenizeString` runs its own pipeline (`getTokensFromAstRule` +
+            // filter/scan + `stringify`), not `tokenizeJs`'s, so only its dump
+            // covers it. Compared whole rather than counted: at this size the
+            // count was the only thing the old JSON round-trip could check,
+            // while the reconstructed literal also pins every token's content.
+            assertEq(result, `[${ids.map(v => `{"kind":"id","value":"${v}"}`).join(',{"kind":"ws"},')},{"kind":"eof"}]`);
+            // The token list must agree with the dump: 3000 ids + 2999
+            // separating ws + a trailing eof token.
+            assertEq(toArray(tokenizeJs(stringToList(src))('a.js')).length, 3000 + 2999 + 1);
         },
         () => {
             // same many-short-tokens shape through the metadata-aware entry point

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

@@ -109,7 +109,7 @@ export type Stat = readonly ['stat', (path: string) => IoResult<FileStat>];
 export declare const stat: Func<Stat>;
 export type Fs = Mkdir | ReadFile | ReadBytes | Readdir | WriteFile | Rm | Rename | Exec | Access | CreateExclusive | WriteBytes | Stat;
 export type Server = Nominal<'server', `160855c4f69310fece3273c1853ac32de43dee1eb41bf59d821917f8eebe9272`, unknown>;
-export type Headers = StringMap<string, string>;
+export type Headers = StringMap<string>;
 export type IncomingMessage = {
     readonly method: string;
     readonly url: string;
@@ -129,7 +129,7 @@ export declare const listen: Func<Listen>;
 export type Http = CreateServer | Listen;
 export type Forever = ['forever', () => never];
 export declare const forever: Func<Forever>;
-export type Module = StringMap<string, unknown>;
+export type Module = StringMap<unknown>;
 export type Import = ['import', (path: string) => IoResult<Module>];
 export declare const import_: Func<Import>;
 /** Named output streams accepted by the `Write` effect. */

package/fjs/emergent_testing/proof.f.js

@@ -5,10 +5,27 @@ 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';
-const writeEvent = (event) => log(JSON.stringify(event));
-const parseEvents = (stdout) => stdout === '' ? [] : stdout.trimEnd().split('\n').map(line => JSON.parse(line));
+import { parse as parseJson } from '../media/json/module.f.js';
+import { array, number as rttiNumber, or, string as rttiString } from '../types/rtti/module.f.js';
+import { parse as rttiParse } from '../types/rtti/parse/module.f.js';
+import { unwrap } from '../types/result/module.f.js';
+/**
+ * The mock reporter's stdout lines. A schema rather than a hand-written type:
+ * the events round-trip through JSON, and this is what turns a line back into
+ * a typed value without an `as` cast — a shape change fails at the parse
+ * instead of silently at an assertion.
+ *
+ * `Reporter.result` also receives the test's `SandboxResult`, which is not
+ * written: no assertion here reads it, and its `undefined` payloads have no
+ * JSON representation to round-trip through anyway.
+ */
+const event = or(['result', rttiString, array(or(rttiString, null))], ['summary', rttiNumber, rttiNumber, rttiNumber]);
+const parseEvent = rttiParse(event);
+const writeEvent = (e) => log(JSON.stringify(e));
+const parseEvents = (stdout) => stdout === '' ? [] : stdout.trimEnd().split('\n')
+    .map(line => unwrap(parseEvent(unwrap(parseJson(line)))));
 const makeReporter = () => ({
-    result: (file, path, r, _throws) => writeEvent(['result', file, [...path], r]),
+    result: (file, path, _r, _throws) => writeEvent(['result', file, [...path]]),
     summary: (pass, fail, time) => writeEvent(['summary', pass, fail, time]),
     test: defaultTest,
 });

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

@@ -9,7 +9,7 @@ import { type ByteSet } from '../types/byte_set/module.f.ts';
 import { type RangeMapArray } from '../types/range_map/module.f.ts';
 type Rule = readonly [string, ByteSet, string];
 export type Grammar = List<Rule>;
-type Dfa = StringMap<string, RangeMapArray<string>>;
+type Dfa = StringMap<RangeMapArray<string>>;
 export declare const toRange: (s: string) => ByteSet;
 export declare const toUnion: (s: string) => ByteSet;
 export declare const dfa: (grammar: Grammar) => Dfa;

package/fjs/js/tokenizer/proof.f.js

@@ -357,6 +357,13 @@ export const proof = {
                 throw result;
             }
         },
+        () => {
+            // a second "." after the fraction has started (covers fullStopToToken's default branch)
+            const result = stringify(tokenizeString('1..'));
+            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
         () => {
             const result = stringify(tokenizeString('0e1'));
             if (result !== '[{"bf":[0n,1],"kind":"number","value":"0e1"},{"kind":"eof"}]') {

package/fjs/mcp/cas/module.f.js

@@ -109,7 +109,8 @@ 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';
 import { detectStream } from '../../media/type/module.f.js';
-import { detect as detectDialect } from '../../media/module.f.js';
+import { detect } from '../../media/module.f.js';
+import { revisionDialect } from '../../media/revision/module.f.js';
 import { maxLengthBytes } from '../../types/bit_vec/module.f.js';
 import { ok } from '../../types/result/module.f.js';
 import { toolEntry, errorResult, okResult, } from '../../protocol/mcp/module.f.js';
@@ -134,6 +135,8 @@ export const casGetArgs = {
 export const casListArgs = {};
 // ── Tool registry ──────────────────────────────────────────────────────────────
 const toJson = stringify(identity);
+/** The dialect-aware classifier, bound to the dialects this server recognizes. */
+const detectDialect = detect([revisionDialect]);
 /**
  * Registry of all CAS tools, bound to `home` and the Evo cache at
  * `cacheKey`. `cas_add` is the only tool that writes, so it is the only one

package/fjs/mcp/evo/proof.f.js

@@ -6,7 +6,12 @@ import { vec8 } from '../../types/bit_vec/module.f.js';
 import { vecToCBase32 } from '../../basen/cbase32/module.f.js';
 import { initEvo, evo } from '../../cas/evo/module.f.js';
 import { evoToolRegistry } from './module.f.js';
+import { parse as parseJson } from '../../media/json/module.f.js';
+import { array, string as rttiString } from '../../types/rtti/module.f.js';
+import { parse as rttiParse } from '../../types/rtti/parse/module.f.js';
+import { unwrap } from '../../types/result/module.f.js';
 const home = '/home/user';
+const parseSubjects = rttiParse(array(rttiString));
 const findEntry = (registry, name) => {
     const entry = registry.find(e => e.name === name);
     assert(entry !== undefined, ['missing tool entry', name]);
@@ -52,7 +57,7 @@ export const proof = {
         const entry = findEntry(evoToolRegistry(e), 'evo_list');
         const [, result] = virtual(state2)(entry.handle({}));
         assert(!result.isError);
-        const subjects = JSON.parse(textOf(result));
+        const subjects = unwrap(parseSubjects(unwrap(parseJson(textOf(result)))));
         assertEq(subjects.length, 2);
         assert(subjects.includes('line one\nline two'), ['unexpected subjects', subjects]);
         assert(subjects.includes(''), ['unexpected subjects', subjects]);