functionalscript 0.39.0 → 0.40.0

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

@@ -42,6 +42,15 @@ const toDjs = state => ast => {
         }
     }
 };
+/**
+ * Evaluates a module body against its imported modules and returns the value
+ * the module yields — the last entry of the body.
+ *
+ * Entries are evaluated left to right, so a `cref` resolves to an already
+ * evaluated entry. A reference is shared, not copied: two properties holding
+ * the same `['cref', i]` deserialize to the same object, which is what lets a
+ * DJS module denote a graph rather than a tree.
+ */
 export const run = body => args => {
     const state = fold(foldOp)({ body, args, consts: null })(body);
     return last(null)(state.consts);

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

@@ -364,7 +364,7 @@ export const tokenizeString = s => {
     }
     const m = descentParser(jsGrammar());
     const cpm = codePointsWithMetadata('')(cp);
-    const [ast, ok, len] = m('', cpm);
+    const { ast, success: ok, idx: len } = m('', cpm);
     if (!ok || len !== cp.length)
         return 'error';
     const flatTokens = toArray(getTokensFromAstRule(ast));
@@ -394,7 +394,7 @@ export const tokenizeJs = input => path => {
         return [{ token: { kind: 'eof' }, metadata: initial }];
     const m = descentParser(jsGrammar());
     const cpm = codePointsWithMetadata(path)(cp);
-    const [ast, ok, len] = m('', cpm);
+    const { ast, success: ok, idx: len } = m('', cpm);
     const finalMetadata = fold(advanceMetadata)(initial)(cp);
     if (!ok || len !== cp.length) {
         const errorMetadata = len < cpm.length ? cpm[len][1] : finalMetadata;

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

@@ -8,6 +8,7 @@ export declare const proof: {
     keywords: (() => void)[];
     comments: (() => void)[];
     metadata: (() => void)[];
+    errorPosition: (() => void)[];
     djsTokenize: (() => void)[];
     largeInputs: (() => void)[];
 };

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

@@ -8,13 +8,21 @@ import { sort } from '../../types/object/module.f.js';
 // DjsTokenWithMetadata carries bigint fields (bf, bigint value) that JSON.stringify can't
 // serialize — reuse the same djs stringifyAsTree serializer tokenizeString uses internally.
 const stringify = stringifyAsTree(sort);
+// 'line:column' of the error token `s` tokenizes to, or 'no error'. Collapsing the
+// position to one string keeps an expectation readable as the caret a reader would
+// draw, instead of two separate assertions per case.
+const errorAt = (s) => {
+    const found = toArray(tokenizeJs(stringToList(s))('a.js'))
+        .find(t => t.token.kind === 'error');
+    return found === undefined ? 'no error' : `${found.metadata.line}:${found.metadata.column}`;
+};
 export const proof = {
     isValid: [() => {
             const m = descentParser(jsGrammar());
             const expect = (s, expected) => {
                 const cp = toArray(stringToCodePointList(s));
                 const mr = descentParserCpOnly(m, '', cp);
-                const success = mr[1] && mr[2] === cp.length;
+                const success = mr.success && mr.idx === cp.length;
                 assertEq(success, expected, JSON.stringify([s, mr]));
             };
             expect('"', false);
@@ -51,7 +59,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList('tr'));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assertEq(seq.tag, 'id', JSON.stringify(mr));
         },
@@ -59,7 +67,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList('"tr"'));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assertEq(seq.tag, 'string', JSON.stringify(mr));
         },
@@ -67,7 +75,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList('56.7e+5'));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assertEq(seq.tag, 'number', JSON.stringify(mr));
         },
@@ -75,7 +83,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList('56n'));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assertEq(seq.tag, 'number', JSON.stringify(mr));
         },
@@ -83,7 +91,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList('*'));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assertEq(seq.tag, '*', JSON.stringify(mr));
         },
@@ -91,7 +99,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList('**'));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assertEq(seq.tag, '**', JSON.stringify(mr));
         },
@@ -99,7 +107,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList('=>'));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assertEq(seq.tag, '=>', JSON.stringify(mr));
         },
@@ -107,7 +115,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList('=='));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assert(!(seq.tag !== '=='), JSON.stringify(mr));
         },
@@ -115,7 +123,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList('==='));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assert(!(seq.tag !== '==='), JSON.stringify(mr));
         },
@@ -123,7 +131,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList('='));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assertEq(seq.tag, '=', JSON.stringify(mr));
         },
@@ -131,7 +139,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList(' '));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assertEq(seq.tag, ' ', JSON.stringify(mr));
         },
@@ -139,7 +147,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList('\n'));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assertEq(seq.tag, '\n', JSON.stringify(mr));
         },
@@ -147,7 +155,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList('/\n'));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assertEq(seq.tag, '/', JSON.stringify(mr));
         },
@@ -155,7 +163,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList('//\n'));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assertEq(seq.tag, 'comment', JSON.stringify(mr));
         },
@@ -163,7 +171,7 @@ export const proof = {
             const m = descentParser(jsGrammar());
             const cp = toArray(stringToCodePointList('/*1*/'));
             const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
+            const seq = mr.ast.sequence[0];
             assert(!(seq instanceof Array), JSON.stringify(mr));
             assertEq(seq.tag, 'comment', JSON.stringify(mr));
         }
@@ -1056,6 +1064,52 @@ export const proof = {
             assertEq(JSON.stringify(result), '[{"token":{"kind":"error","message":"invalid token"},"metadata":{"path":"a.js","line":1,"column":2}}]');
         },
     ],
+    // Where an error token is reported. The `tokenizer` group above checks that
+    // these inputs are rejected at all, through the metadata-free
+    // `tokenizeString`; here the same shapes go through `tokenizeJs` so the
+    // position is pinned too.
+    errorPosition: [
+        () => {
+            // input that tokenizes cleanly produces no error token at all —
+            // without this the helper's own no-error branch never runs
+            assertEq(errorAt('x'), 'no error');
+            assertEq(errorAt('{ "a": 1 }'), 'no error');
+        },
+        () => {
+            // a character no rule accepts: reported where it stands
+            assertEq(errorAt('ᄑ'), '1:1');
+        },
+        () => {
+            // after a good prefix, the position advances past it
+            assertEq(errorAt('x @'), '1:3');
+        },
+        () => {
+            // line as well as column, once newlines have been consumed
+            assertEq(errorAt('a\nb\n@'), '3:1');
+            assertEq(errorAt('x\n\n  @y'), '3:3');
+        },
+        () => {
+            // a number poisoned by a trailing character points at that character
+            assertEq(errorAt('00'), '1:2');
+        },
+        () => {
+            // a number cut short points just past the input
+            assertEq(errorAt('1.'), '1:3');
+        },
+        () => {
+            // Unterminated tokens anchor at the token's *start*, not where the
+            // input ran out: the grammar matches them and tags them
+            // 'unterminated', so this is the structural-error path, not a failed
+            // match. See ./todo/error-position-range.md.
+            assertEq(errorAt('"value'), '1:1');
+            assertEq(errorAt('"a\nb"'), '1:1');
+        },
+        () => {
+            // an unterminated block comment is the exception: its content is
+            // consumed, so the report lands at the end of input
+            assertEq(errorAt('/* c'), '1:5');
+        },
+    ],
     // DJS-level: keyword remapping and '-'-folding on top of tokenizeJs. Doesn't re-test
     // JS-level token shapes already covered above/elsewhere in this file.
     djsTokenize: [

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

@@ -4,9 +4,9 @@ import { type NodeProgram } from './module.f.ts';
  * 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 declare const runEffect: (p: NodeProgram) => Promise<number>;
 /**

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/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;
     };