functionalscript 0.20.0 → 0.21.0

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

@@ -0,0 +1,4 @@
+export declare const todo: () => never;
+export declare const assert: (v: boolean, msg?: unknown) => asserts v;
+export declare const assertEq: <T>(a: T, b: T) => void;
+export type Assert<T extends true> = T;

package/fs/asserts/module.f.js

@@ -0,0 +1,6 @@
+export const todo = () => { throw 'not implemented'; };
+export const assert = (v, msg = 'assertion failed') => {
+    if (!v)
+        throw msg;
+};
+export const assertEq = (a, b) => assert(a === b, [a, b]);

package/fs/cas/module.f.js

@@ -7,7 +7,7 @@ import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
 import { parse } from "../path/module.f.js";
 import { cBase32ToVec, vecToCBase32 } from "../cbase32/module.f.js";
 import { begin, forEachStep, pure } from "../types/effects/module.f.js";
-import { error, log, mkdir, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
+import { errorExit, log, mkdir, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
 import { toOption } from "../types/nullable/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 const o = { withFileTypes: true };
@@ -61,10 +61,6 @@ export const cas = (sha2) => {
         list,
     });
 };
-/** Prints an error message and returns exit code `1`. */
-const e = (s) => begin
-    .step(() => error(s))
-    .step(() => pure(1));
 /**
  * Runs the CAS CLI.
  *
@@ -79,7 +75,7 @@ export const main = (args) => {
     switch (cmd) {
         case 'add': {
             if (options.length !== 1) {
-                return e("'cas add' expects one parameter");
+                return errorExit("'cas add' expects one parameter");
             }
             const [path] = options;
             return begin
@@ -90,18 +86,18 @@ export const main = (args) => {
         }
         case 'get': {
             if (options.length !== 2) {
-                return e("'cas get' expects two parameters");
+                return errorExit("'cas get' expects two parameters");
             }
             const [hashCBase32, path] = options;
             const hash = cBase32ToVec(hashCBase32);
             if (hash === null) {
-                return e(`invalid hash format: ${hashCBase32}`);
+                return errorExit(`invalid hash format: ${hashCBase32}`);
             }
             return begin
                 .step(() => c.read(hash))
                 .step(v => {
                 const result = v === undefined
-                    ? e(`no such hash: ${hashCBase32}`)
+                    ? errorExit(`no such hash: ${hashCBase32}`)
                     : begin
                         .step(() => writeFile(path, v))
                         .step(() => pure(0));
@@ -115,9 +111,9 @@ export const main = (args) => {
                 .step(() => pure(0));
         }
         case undefined: {
-            return e('Error: CAS command requires subcommand');
+            return errorExit('Error: CAS command requires subcommand');
         }
         default:
-            return e(`Error: Unknown CAS subcommand "${args[0]}"`);
+            return errorExit(`Error: Unknown CAS subcommand "${args[0]}"`);
     }
 };

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

@@ -1 +1,4 @@
-export declare const proof: () => void;
+export declare const proof: {
+    casWrite: () => void;
+    casReadPassthrough: () => void;
+};

package/fs/cas/proof.f.js

@@ -1 +1,37 @@
-export const proof = () => { };
+import { cas } from "./module.f.js";
+import { sha256 } from "../crypto/sha2/module.f.js";
+import { empty, length } from "../types/bit_vec/module.f.js";
+import { pure } from "../types/effects/module.f.js";
+import { run } from "../types/effects/mock/module.f.js";
+export const proof = {
+    casWrite: () => {
+        const store = {
+            read: (_key) => pure(undefined),
+            write: (_key, _value) => pure(undefined),
+            list: () => pure([]),
+        };
+        const c = cas(sha256)(store);
+        const [, hash] = run({})(undefined)(c.write(empty));
+        // sha256 of empty input produces a 256-bit hash
+        if (length(hash) !== 256n) {
+            throw ['expected 256-bit hash', length(hash)];
+        }
+    },
+    casReadPassthrough: () => {
+        const stored = empty;
+        const store = {
+            read: (_key) => pure(stored),
+            write: (_key, _value) => pure(undefined),
+            list: () => pure([stored]),
+        };
+        const c = cas(sha256)(store);
+        const [, readResult] = run({})(undefined)(c.read(empty));
+        if (readResult !== stored) {
+            throw ['read should pass through', readResult];
+        }
+        const [, listResult] = run({})(undefined)(c.list());
+        if (listResult.length !== 1) {
+            throw ['list should pass through', listResult];
+        }
+    },
+};

package/fs/ci/bun/module.f.js

@@ -5,17 +5,12 @@
  * @module
  */
 import { bun } from "../config/module.f.js";
-import { clean, install, test } from "../common/module.f.js";
+import { clean, install, test, uses } from "../common/module.f.js";
 const installOnWindowsArm = ({ def, name, path }) => (v) => (a) => install(v === 'windows' && a === 'arm'
     ? { run: `irm ${path}/install.ps1 | iex; "$env:USERPROFILE\\.${name}\\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append` }
     : def);
 const installBun = installOnWindowsArm({
-    def: {
-        uses: 'oven-sh/setup-bun@v2',
-        with: {
-            'bun-version': bun
-        },
-    },
+    def: uses('oven-sh/setup-bun', { 'bun-version': bun }),
     name: 'bun',
     path: 'bun.sh',
 });

package/fs/ci/common/module.f.d.ts

@@ -5,7 +5,7 @@
  *
  * @module
  */
-import { images } from '../config/module.f.ts';
+import { actions, images } from '../config/module.f.ts';
 import { type Ts } from '../../types/rtti/ts/module.f.ts';
 export declare const os: readonly ["ubuntu", "macos", "windows"];
 export type Os = typeof os[number];
@@ -76,6 +76,7 @@ export type MetaStep = {
     readonly type: 'apt-get';
     readonly package: string;
 };
+export declare const uses: (name: keyof typeof actions, w?: Record<string, string>) => Step;
 export declare const install: (step: Step) => MetaStep;
 export declare const test: (step: Step) => MetaStep;
 export declare const clean: (steps: readonly MetaStep[]) => readonly MetaStep[];

package/fs/ci/common/module.f.js

@@ -5,7 +5,7 @@
  *
  * @module
  */
-import { images, rust } from "../config/module.f.js";
+import { actions, images } from "../config/module.f.js";
 import { option, array, record, string } from "../../types/rtti/module.f.js";
 import {} from "../../types/rtti/ts/module.f.js";
 import { parse as rttiParse } from "../../types/rtti/parse/module.f.js";
@@ -27,6 +27,10 @@ export const gitHubActionSchema = {
     jobs: jobsSchema
 };
 export const parseGitHubAction = rttiParse(gitHubActionSchema);
+export const uses = (name, w) => ({
+    uses: `${name}@${actions[name]}`,
+    ...(w === undefined ? {} : { with: w })
+});
 export const install = (step) => ({ type: 'install', step });
 export const test = (step) => ({ type: 'test', step });
 export const clean = (steps) => [
@@ -40,15 +44,9 @@ export const toSteps = (m) => {
     const targets = m.flatMap(v => v.type === 'rust' && v.target !== undefined ? [v.target] : []).join(',');
     return [
         ...(aptGet !== '' ? [{ run: `sudo apt-get update && sudo apt-get install -y ${aptGet}` }] : []),
-        ...(needRust ? [{
-                uses: `dtolnay/rust-toolchain@${rust}`,
-                with: {
-                    components: 'rustfmt,clippy',
-                    targets
-                }
-            }] : []),
+        ...(needRust ? [uses('dtolnay/rust-toolchain', { components: 'rustfmt,clippy', targets })] : []),
         ...filter('install'),
-        { uses: 'actions/checkout@v5' },
+        uses('actions/checkout'),
         ...filter('test'),
     ];
 };

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

@@ -22,11 +22,20 @@ export declare const images: {
 export declare const bun = "1.3.14";
 export declare const deno = "2.8.1";
 export declare const playwright = "1.60.0";
-export declare const rust = "1.95.0";
 export declare const node: {
-    readonly default: "26.2.0";
+    readonly default: "26.3.0";
     readonly others: readonly ["24.16.0"];
 };
 export declare const wasmtime = "45.0.0";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260527.1";
+export declare const tsgo = "7.0.0-dev.20260601.1";
+export declare const actions: {
+    readonly 'actions/checkout': "v6";
+    readonly 'actions/setup-node': "v6";
+    readonly 'actions/cache': "v5";
+    readonly 'denoland/setup-deno': "v2";
+    readonly 'oven-sh/setup-bun': "v2";
+    readonly 'bytecodealliance/actions/wasmtime/setup': "v1";
+    readonly 'wasmerio/setup-wasmer': "v3.1";
+    readonly 'dtolnay/rust-toolchain': "1.95.0";
+};

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

@@ -26,11 +26,9 @@ export const bun = '1.3.14';
 export const deno = '2.8.1';
 // https://www.npmjs.com/package/playwright
 export const playwright = '1.60.0';
-// https://rust-lang.org/
-export const rust = '1.95.0';
 // https://nodejs.org/en/download
 export const node = {
-    default: '26.2.0',
+    default: '26.3.0',
     others: ['24.16.0'],
 };
 // https://github.com/bytecodealliance/wasmtime/releases
@@ -38,4 +36,26 @@ export const wasmtime = '45.0.0';
 // https://github.com/wasmerio/wasmer/releases
 export const wasmer = '7.1.0';
 // https://www.npmjs.com/package/@typescript/native-preview?activeTab=versions
-export const tsgo = '7.0.0-dev.20260527.1';
+export const tsgo = '7.0.0-dev.20260601.1';
+// GitHub Action versions used by CI step builders. The key is the action
+// `owner/name`; call sites compose the full ref as
+// `` `${name}@${actions[name]}` ``.
+// Note: dtolnay/rust-toolchain value is a Rust version, not an action version.
+export const actions = {
+    // https://github.com/marketplace/actions/checkout
+    'actions/checkout': 'v6',
+    // https://github.com/marketplace/actions/setup-node-js-environment
+    'actions/setup-node': 'v6',
+    // https://github.com/marketplace/actions/cache
+    'actions/cache': 'v5',
+    // https://github.com/marketplace/actions/setup-deno
+    'denoland/setup-deno': 'v2',
+    // https://github.com/marketplace/actions/setup-bun
+    'oven-sh/setup-bun': 'v2',
+    // https://github.com/bytecodealliance/actions
+    'bytecodealliance/actions/wasmtime/setup': 'v1',
+    // https://github.com/wasmerio/setup-wasmer
+    'wasmerio/setup-wasmer': 'v3.1',
+    // https://rust-lang.org/ - value is Rust version, not action version
+    'dtolnay/rust-toolchain': '1.95.0',
+};

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

@@ -5,12 +5,9 @@
  * @module
  */
 import { deno } from "../config/module.f.js";
-import { clean, install, test } from "../common/module.f.js";
+import { clean, install, test, uses } from "../common/module.f.js";
 export const denoSteps = (extra) => clean([
-    install({
-        uses: 'denoland/setup-deno@v2',
-        with: { 'deno-version': deno },
-    }),
+    install(uses('denoland/setup-deno', { 'deno-version': deno })),
     test({ run: 'deno install' }),
     test({ run: 'deno task test' }),
     ...extra,

package/fs/ci/node/module.f.js

@@ -5,9 +5,9 @@
  * @module
  */
 import { node, tsgo } from "../config/module.f.js";
-import { clean, findTgz, install, test, ubuntu } from "../common/module.f.js";
+import { clean, findTgz, install, test, ubuntu, uses } from "../common/module.f.js";
 export const major = (v) => v.split('.')[0];
-const installNode = (version) => ({ uses: 'actions/setup-node@v6', with: { 'node-version': version } });
+const installNode = (version) => uses('actions/setup-node', { 'node-version': version });
 const nodeInstall = (v) => [
     install(installNode(v)),
     test({ run: 'npm ci' }),

package/fs/ci/playwright/module.f.js

@@ -5,19 +5,16 @@
  * @module
  */
 import { images, node, playwright } from "../config/module.f.js";
-import { install, test, toSteps } from "../common/module.f.js";
+import { install, test, toSteps, uses } from "../common/module.f.js";
 import { basicNode } from "../node/module.f.js";
 const playwrightImage = images.ubuntu.intel;
 export const playwrightJob = {
     'runs-on': playwrightImage,
     steps: toSteps(basicNode(node.default)([
-        install({
-            uses: 'actions/cache@v4',
-            with: {
-                path: '~/.cache/ms-playwright',
-                key: `${playwrightImage}-playwright-${playwright}`,
-            },
-        }),
+        install(uses('actions/cache', {
+            path: '~/.cache/ms-playwright',
+            key: `${playwrightImage}-playwright-${playwright}`,
+        })),
         install({ run: `npm install -g playwright@${playwright}` }),
         install({ run: 'playwright install-deps' }),
         install({ run: 'playwright install' }),

package/fs/ci/proof.f.js

@@ -2,7 +2,7 @@ import { ci } from "./module.f.js";
 import { utf8ToString } from "../text/module.f.js";
 import { isVec } from "../types/bit_vec/module.f.js";
 import { test, parseGitHubAction } from "./common/module.f.js";
-import { assert } from "../dev/module.f.js";
+import { assert } from "../asserts/module.f.js";
 import { emptyState, virtual } from "../types/effects/node/virtual/module.f.js";
 import { parse as jsonParse } from "../json/module.f.js";
 import { unwrap } from "../types/result/module.f.js";

package/fs/ci/rust/module.f.js

@@ -6,7 +6,7 @@
  * @module
  */
 import { wasmer, wasmtime } from "../config/module.f.js";
-import { install, test } from "../common/module.f.js";
+import { install, test, uses } from "../common/module.f.js";
 const cargoTest = (target, config) => {
     const to = target ? ` --target ${target}` : '';
     const co = config ? ` --config ${config}` : '';
@@ -40,14 +40,8 @@ export const rustSteps = (v, a) => [
     test({ run: 'cargo fmt -- --check' }),
     test({ run: 'cargo clippy -- -D warnings' }),
     ...cargoTest(),
-    install({
-        uses: 'bytecodealliance/actions/wasmtime/setup@v1',
-        with: { version: wasmtime }
-    }),
-    install({
-        uses: 'wasmerio/setup-wasmer@v3.1',
-        with: { version: `v${wasmer}` },
-    }),
+    install(uses('bytecodealliance/actions/wasmtime/setup', { version: wasmtime })),
+    install(uses('wasmerio/setup-wasmer', { version: `v${wasmer}` })),
     ...wasmTarget('wasm32-wasip1'),
     ...wasmTarget('wasm32-wasip2'),
     ...wasmTarget('wasm32-unknown-unknown'),

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

@@ -6,9 +6,6 @@
 import type { Io } from '../io/module.f.ts';
 import { type Access, type All, type Env, type Import, type NodeProgram, type Readdir } from '../types/effects/node/module.f.ts';
 import { type Effect } from '../types/effects/module.f.ts';
-export declare const todo: () => never;
-export declare const assert: (v: boolean, msg?: unknown) => asserts v;
-export declare const assertEq: <T>(a: T, b: T) => void;
 export type Module = {
     readonly proof?: unknown;
     readonly [k: string]: unknown;

package/fs/dev/module.f.js

@@ -8,12 +8,6 @@ import { parse as jsonParse } from "../json/module.f.js";
 import { record, unknown as rttiUnknown } from "../types/rtti/module.f.js";
 import { parse as rttiParse } from "../types/rtti/parse/module.f.js";
 import { relativize } from "../path/module.f.js";
-export const todo = () => { throw 'not implemented'; };
-export const assert = (v, msg = 'assertion failed') => {
-    if (!v)
-        throw msg;
-};
-export const assertEq = (a, b) => assert(a === b, [a, b]);
 export const env = ({ process: { env } }) => a => {
     const r = Object.getOwnPropertyDescriptor(env, a);
     return r === undefined ? undefined :

package/fs/dev/proof.f.js

@@ -1,4 +1,5 @@
-import { todo, env } from "./module.f.js";
+import { todo } from "../asserts/module.f.js";
+import { env } from "./module.f.js";
 export const proof = {
     shouldPass: () => ({
         then: () => undefined

package/fs/djs/tokenizer-new/module.f.js

@@ -5,7 +5,7 @@
  */
 import { descentParser } from "../../bnf/data/module.f.js";
 import { eof, join0Plus, max, none, not, notSet, oneEncode, option, range, remove, repeat, repeat0Plus, repeat1Plus, set, unicodeRange } from "../../bnf/module.f.js";
-import { todo } from "../../dev/module.f.js";
+import { todo } from "../../asserts/module.f.js";
 export const parse = (input) => {
     const m = descentParser(jsGrammar());
     return todo();

package/fs/{dev/tf → emergent-testing}/module.f.d.ts

@@ -1,6 +1,6 @@
-import { type All, type Await, type NodeProgram, type NodeProgramOptions, type Program, type Sandbox, type SandboxResult, type Test, type TestContext, type Write } from '../../types/effects/node/module.f.ts';
-import { type Effect, type Operation } from '../../types/effects/module.f.ts';
-import { type LoadModuleOperations, type ModuleMap } from '../module.f.ts';
+import { type All, type Await, type NodeProgram, type NodeProgramOptions, type Program, type Sandbox, type SandboxResult, type Test, type TestContext, type Write } from '../types/effects/node/module.f.ts';
+import { type Effect, type Operation } from '../types/effects/module.f.ts';
+import { type LoadModuleOperations, type ModuleMap } from '../dev/module.f.ts';
 /** A zero-argument test function whose return value may contain sub-tests. */
 export type TestFn = () => unknown;
 /**
@@ -46,7 +46,7 @@ export declare const collectTests: (path: Path, throws: boolean, v: unknown) =>
  * contained `inner`.
  */
 export type Reporter<O extends Operation> = {
-    readonly result: (file: string, path: Path, r: SandboxResult<unknown>) => Effect<O, void>;
+    readonly result: (file: string, path: Path, r: SandboxResult<unknown>, throws: boolean) => Effect<O, void>;
     readonly summary: (pass: number, fail: number, time: number) => Effect<O, void>;
     readonly test: (file: string, path: Path, set: TestEntry) => Effect<O, SandboxResult<unknown>>;
 };
@@ -60,7 +60,7 @@ export type Reporter<O extends Operation> = {
  * This is the correct model for Node `--test`, Bun, and Playwright, where tests
  * must be declared upfront and the framework drives execution.
  */
-export declare const registerModule: (ctx: TestContext, k: string, v: unknown) => Effect<Test | All | Await, void>;
+export declare const registerModule: (ctx: TestContext, k: string, v: unknown, star: string) => Effect<Test | All | Await, void>;
 /**
  * Runs all test modules in `moduleMap` whose names pass `isTest`, accumulates
  * pass/fail/time via `reporter`, and returns an exit code (0 = all passed,

package/fs/{dev/tf → emergent-testing}/module.f.js

@@ -10,11 +10,11 @@
  *
  * @module
  */
-import { reset, fgGreen, fgRed, bold, csiWrite } from "../../text/sgr/module.f.js";
-import { all, awaitIfPromise, sandbox, test } from "../../types/effects/node/module.f.js";
-import { pure } from "../../types/effects/module.f.js";
-import { loadModuleMap, shouldLoad } from "../module.f.js";
-import { invert } from "../../types/result/module.f.js";
+import { reset, fgGreen, fgRed, bold, csiWrite } from "../text/sgr/module.f.js";
+import { all, awaitIfPromise, sandbox, test } from "../types/effects/node/module.f.js";
+import { pure } from "../types/effects/module.f.js";
+import { loadModuleMap, shouldLoad } from "../dev/module.f.js";
+import { invert } from "../types/result/module.f.js";
 const addPass = (delta) => (ts) => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });
 const addFail = (delta) => (ts) => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 });
 const timeFormat = (a) => {
@@ -75,18 +75,26 @@ export const collectTests = (path, throws, v) => {
  * This is the correct model for Node `--test`, Bun, and Playwright, where tests
  * must be declared upfront and the framework drives execution.
  */
-export const registerModule = (ctx, k, v) => {
-    const registerOne = (ctx, [path, { fn, throws }]) => test(ctx, fmtImport(k, path), throws, (t) => awaitIfPromise(fn())
-        .step(resolved => {
-        if (throws) {
-            return pure(undefined);
-        }
-        const sub = collectTests([...path, null], false, resolved);
-        if (sub.length === 0) {
-            return pure(undefined);
-        }
-        return all(...sub.map(e => registerOne(t, e))).step(() => pure(undefined));
-    }));
+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
+        // 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.
+        const base = fmtImport(k, path);
+        const name = throws ? base : `${base}${star}`;
+        return test(ctx, name, throws, (t) => awaitIfPromise(fn())
+            .step(resolved => {
+            if (throws) {
+                return pure(undefined);
+            }
+            const sub = collectTests([...path, null], false, resolved);
+            if (sub.length === 0) {
+                return pure(undefined);
+            }
+            return all(...sub.map(e => registerOne(t, e))).step(() => pure(undefined));
+        }));
+    };
     const tests = collectTests([], false, v);
     if (tests.length === 0) {
         return pure(undefined);
@@ -99,7 +107,7 @@ const runModule = ({ result, test }) => (k, v) => (ts) => {
     const one = ([testPath, set]) => test(k, testPath, set)
         .step(sr => {
         const { result: [s, r], duration } = sr;
-        return result(k, testPath, sr)
+        return result(k, testPath, sr, set.throws)
             .step(() => {
             if (s === 'ok') {
                 if (set.throws) {
@@ -146,13 +154,13 @@ export const testAll = (reporter) => options => loadModuleMap(options.env).step(
  * Registers all modules in `moduleMap` that export a `proof` property with
  * `ctx`. Delegates to `registerModule` for each matching entry.
  */
-const registerModuleMap = (ctx) => (moduleMap) => {
+const registerModuleMap = (ctx, star) => (moduleMap) => {
     const modules = entries(moduleMap)
         .flatMap(([k, v]) => v.proof !== undefined ? [[k, v.proof]] : []);
     if (modules.length === 0) {
         return pure(undefined);
     }
-    return all(...modules.map(([k, v]) => registerModule(ctx, k, v))).step(() => pure(undefined));
+    return all(...modules.map(([k, v]) => registerModule(ctx, k, v, star))).step(() => pure(undefined));
 };
 const isAlpha = (c) => (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c === '_' || c === '$';
 const isDigit = (c) => c >= '0' && c <= '9';
@@ -227,8 +235,8 @@ export const defaultReporter = (options) => {
     const isGitHub = options.env['GITHUB_ACTION'] !== undefined;
     return {
         // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
-        result: (file, path, { result: [s, v], duration }) => s === 'ok'
-            ? csiLog(fmtResultLine(file, path, fgGreen, 'ok', duration))
+        result: (file, path, { result: [s, v], duration }, throws) => s === 'ok'
+            ? csiLog(fmtResultLine(file, path, fgGreen, 'ok', duration) + (throws ? ' # EXPECTED TO THROW' : ''))
             : isGitHub
                 ? csiError(`::error file=${file},line=1,title=${ghEscape(fmtImport(file, path))}::${ghEscape(String(v))}`)
                 : csiError(fmtResultLine(file, path, fgRed, 'error', duration))
@@ -251,9 +259,11 @@ export const main = options => testAll(defaultReporter(options))(options);
  * based on the detected `engine`.
  */
 export const register = o => {
-    const r = registerModuleMap(o.engine === 'bun' ? o.bunTestContext :
+    const star = o.engine === 'bun' || o.engine === 'playwright' ? ' ...' : '';
+    const ctx = o.engine === 'bun' ? o.bunTestContext :
         o.engine === 'playwright' ? o.playwrightTestContext :
-            o.testContext);
+            o.testContext;
+    const r = registerModuleMap(ctx, star);
     return loadModuleMap(o.env)
         .step(r)
         .step(() => pure(0));

package/fs/{dev/tf → emergent-testing}/module.js

@@ -1,4 +1,4 @@
-import { io } from "../../io/module.js";
+import { io } from "../io/module.js";
 import { register } from "./module.f.js";
-import { runProgram } from "../../io/module.f.js";
+import { runProgram } from "../io/module.f.js";
 export const run = () => runProgram(io)([])(register);

package/fs/{dev/tf → emergent-testing}/proof.f.d.ts

@@ -12,6 +12,7 @@ export declare const namedExports: () => void;
 export declare const defaultReporterOutput: () => void;
 export declare const defaultReporterFailOutput: () => void;
 export declare const githubReporterOutput: () => void;
+export declare const registerSuffixes: () => void;
 export declare const helpers: {
     isInteger: () => void;
     isIdentifier: () => void;
@@ -36,6 +37,7 @@ export declare const proof: {
     defaultReporterOutput: () => void;
     defaultReporterFailOutput: () => void;
     githubReporterOutput: () => void;
+    registerSuffixes: () => void;
     helpers: {
         isInteger: () => void;
         isIdentifier: () => void;

package/fs/{dev/tf → emergent-testing}/proof.f.js

@@ -1,13 +1,14 @@
-import { pure } from "../../types/effects/module.f.js";
-import { emptyState } from "../../types/effects/node/virtual/module.f.js";
-import { virtual } from "../../types/effects/node/virtual/module.f.js";
-import { assert, assertEq, todo } from "../module.f.js";
-import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, defaultTest, } from "./module.f.js";
-import { shouldLoad } from "../module.f.js";
+import { pure } from "../types/effects/module.f.js";
+import { emptyState } from "../types/effects/node/virtual/module.f.js";
+import { virtual } from "../types/effects/node/virtual/module.f.js";
+import { assert, assertEq, todo } from "../asserts/module.f.js";
+import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, registerModule, defaultTest, } from "./module.f.js";
+import { run as mockRun } from "../types/effects/mock/module.f.js";
+import { shouldLoad } from "../dev/module.f.js";
 const makeReporter = () => {
     const events = [];
     const reporter = {
-        result: (file, path, r) => { events.push(['result', file, [...path], r]); return pure(undefined); },
+        result: (file, path, r, _throws) => { events.push(['result', file, [...path], r]); return pure(undefined); },
         summary: (pass, fail, time) => { events.push(['summary', pass, fail, time]); return pure(undefined); },
         test: defaultTest,
     };
@@ -215,6 +216,41 @@ export const githubReporterOutput = () => {
     assertEq(exit, 1);
     assertEq(stderr, '::error file=./s.proof.f.ts,line=1,title=import("./s.proof.f.ts").proof["a%3Ab%2Cc%25d"]()::oops\n');
 };
+// registerModule appends ' ...' for inline runners (Bun/Playwright).
+// Uses a minimal synchronous mock for the Test/All/Await effect operations.
+export const registerSuffixes = () => {
+    let runner;
+    const noopCtx = { test: (_n, _o, _f) => Promise.resolve() };
+    const makeRunner = () => mockRun({
+        test: (s, _ctx, name, _xf, _fn) => [[...s, name], undefined],
+        all: (s, ...effects) => {
+            let st = s;
+            const rs = [];
+            for (const e of effects) {
+                const [ns, r] = runner(st)(e);
+                st = ns;
+                rs.push(r);
+            }
+            return [st, rs];
+        },
+        await: (s, p) => [s, [p]],
+    });
+    runner = makeRunner();
+    const proof = {
+        ok: () => { },
+        throw: { a: () => { throw 'expected'; } },
+    };
+    // Node (star = ''): no suffixes
+    const [nodeNames] = runner([])(registerModule(noopCtx, './a.f.ts', proof, ''));
+    assertEq(nodeNames.length, 2);
+    assertEq(nodeNames[0], 'import("./a.f.ts").proof.ok()');
+    assertEq(nodeNames[1], 'import("./a.f.ts").proof.throw.a()');
+    // Bun/Playwright (star = ' ...'): ... on normal tests, path shows throw for throw-tests
+    const [inlineNames] = runner([])(registerModule(noopCtx, './a.f.ts', proof, ' ...'));
+    assertEq(inlineNames.length, 2);
+    assertEq(inlineNames[0], 'import("./a.f.ts").proof.ok() ...');
+    assertEq(inlineNames[1], 'import("./a.f.ts").proof.throw.a()');
+};
 // direct unit tests for the pure path-format helpers
 export const helpers = {
     isInteger: () => {
@@ -297,5 +333,6 @@ export const proof = {
     defaultReporterOutput,
     defaultReporterFailOutput,
     githubReporterOutput,
+    registerSuffixes,
     helpers
 };

package/fs/emergent-testing/scenarios/async-subtests.fail.d.ts

@@ -0,0 +1,6 @@
+export declare const proof: {
+    withSubtests: () => Promise<{
+        sub1: () => void;
+        sub2: () => never;
+    }>;
+};

package/fs/emergent-testing/scenarios/async-subtests.fail.js

@@ -0,0 +1,9 @@
+export const proof = {
+    withSubtests: async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        return {
+            sub1: () => { },
+            sub2: () => { throw 'sub-test failure'; },
+        };
+    }
+};

package/fs/emergent-testing/scenarios/async-subtests.pass.d.ts

@@ -0,0 +1,6 @@
+export declare const proof: {
+    withSubtests: () => Promise<{
+        sub1: () => void;
+        sub2: () => void;
+    }>;
+};

package/fs/emergent-testing/scenarios/async-subtests.pass.js

@@ -0,0 +1,9 @@
+export const proof = {
+    withSubtests: async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        return {
+            sub1: () => { },
+            sub2: () => { },
+        };
+    }
+};

package/fs/emergent-testing/scenarios/async.fail.d.ts

@@ -0,0 +1,3 @@
+export declare const proof: {
+    sleep_fail: () => Promise<never>;
+};

package/fs/emergent-testing/scenarios/async.fail.js

@@ -0,0 +1,6 @@
+export const proof = {
+    sleep_fail: async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        throw 'async failure';
+    }
+};

package/fs/emergent-testing/scenarios/async.pass.d.ts

@@ -0,0 +1,3 @@
+export declare const proof: {
+    sleep: () => Promise<void>;
+};

package/fs/emergent-testing/scenarios/async.pass.js

@@ -0,0 +1,5 @@
+export const proof = {
+    sleep: async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+    }
+};

package/fs/emergent-testing/scenarios/fail.fail.d.ts

@@ -0,0 +1,3 @@
+export declare const proof: {
+    failing: () => never;
+};

package/fs/emergent-testing/scenarios/fail.fail.js

@@ -0,0 +1,3 @@
+export const proof = {
+    failing: () => { throw 'intentional failure'; }
+};

package/fs/emergent-testing/scenarios/return-value.pass.d.ts

@@ -0,0 +1,3 @@
+export declare const proof: {
+    outer: () => unknown;
+};

package/fs/emergent-testing/scenarios/return-value.pass.js

@@ -0,0 +1,4 @@
+const inner = () => { };
+export const proof = {
+    outer: () => ({ inner })
+};

package/fs/emergent-testing/scenarios/thenable.pass.d.ts

@@ -0,0 +1,5 @@
+export declare const proof: {
+    thenableResolves: () => {
+        then(resolve: (v: undefined) => void): void;
+    };
+};

package/fs/{dev/tf → emergent-testing}/scenarios/thenable.pass.js

@@ -4,6 +4,8 @@
 // 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.
-export const thenableResolves = () => ({
-    then(resolve) { resolve(undefined); }
-});
+export const proof = {
+    thenableResolves: () => ({
+        then(resolve) { resolve(undefined); }
+    })
+};

package/fs/emergent-testing/scenarios/thenable2.pass.d.ts

@@ -0,0 +1,5 @@
+export declare const proof: {
+    shouldPass: () => {
+        then: () => string;
+    };
+};

package/fs/emergent-testing/scenarios/thenable2.pass.js

@@ -0,0 +1,3 @@
+export const proof = {
+    shouldPass: () => ({ then: () => 'ok' })
+};

package/fs/emergent-testing/scenarios/throw.pass.d.ts

@@ -0,0 +1,5 @@
+export declare const proof: {
+    throw: {
+        a: () => never;
+    };
+};

package/fs/{dev/tf/scenarios/throw.pass.f.js → emergent-testing/scenarios/throw.pass.js}

@@ -1,3 +1,3 @@
-export default {
+export const proof = {
     throw: { a: () => { throw 'expected'; } }
 };

package/fs/fjs/module.f.js

@@ -4,10 +4,9 @@
  * @module
  */
 import { compile } from "../djs/module.f.js";
-import { main as testMain } from "../dev/tf/module.f.js";
+import { main as testMain } from "../emergent-testing/module.f.js";
 import { main as casMain } from "../cas/module.f.js";
-import { import_, error } from "../types/effects/node/module.f.js";
-import { pure } from "../types/effects/module.f.js";
+import { import_, errorExit } from "../types/effects/node/module.f.js";
 export const main = options => {
     const [command, ...rest] = options.args;
     switch (command) {
@@ -31,8 +30,8 @@ export const main = options => {
             });
         }
         case undefined:
-            return error('Error: command is required').step(() => pure(1));
+            return errorExit('Error: command is required');
         default:
-            return error(`Error: Unknown command "${command}"`).step(() => pure(1));
+            return errorExit(`Error: Unknown command "${command}"`);
     }
 };

package/fs/sul/id/module.f.js

@@ -7,7 +7,7 @@
  */
 import { toArray } from "../../types/list/module.f.js";
 import { length, msb, uint, uintChunkList, unpack, vec } from "../../types/bit_vec/module.f.js";
-import { assertEq } from "../../dev/module.f.js";
+import { assertEq } from "../../asserts/module.f.js";
 import { utf8 } from "../../text/module.f.js";
 import { secp256r1 } from "../../crypto/secp/module.f.js";
 import { base32 } from "../../crypto/sha2/module.f.js";

package/fs/sul/id/proof.f.js

@@ -1,4 +1,4 @@
-import { assert, assertEq } from "../../dev/module.f.js";
+import { assert, assertEq } from "../../asserts/module.f.js";
 import { mask } from "../../types/bigint/module.f.js";
 import { vec } from "../../types/bit_vec/module.f.js";
 import { compress, hashId, isHash, isRaw, level3Id, rawId } from "./module.f.js";

package/fs/sul/level/hash/proof.f.js

@@ -1,4 +1,4 @@
-import { assert, assertEq } from "../../../dev/module.f.js";
+import { assert, assertEq } from "../../../asserts/module.f.js";
 import { compress, level3Id } from "../../id/module.f.js";
 import { emptyEncodeState, encode } from "./module.f.js";
 const add = (l, r, m, isSymbol, s) => [...s, [l, r, m, isSymbol]];

package/fs/sul/proof.f.js

@@ -1,4 +1,4 @@
-import { assert, assertEq } from "../dev/module.f.js";
+import { assert, assertEq } from "../asserts/module.f.js";
 import { compress } from "./id/module.f.js";
 import { encode, emptyEncodeState } from "./module.f.js";
 const run = (bits) => {

package/fs/types/array/module.f.js

@@ -3,15 +3,12 @@
  *
  * @module
  */
-import { map } from "../nullable/module.f.js";
+import { fromUndefined, map } from "../nullable/module.f.js";
 export const isArray = (value) => value instanceof Array;
 export const isArray2 = (a) => a.length === 2;
 const uncheckTail = (a) => a.slice(1);
 const uncheckHead = (a) => a.slice(0, -1);
-export const at = (i) => (a) => {
-    const r = a[i];
-    return r === undefined ? null : r;
-};
+export const at = (i) => (a) => fromUndefined(a[i]);
 export const first = at(0);
 export const last = (a) => at(a.length - 1)(a);
 export const tail = (a) => a.length === 0 ? null : uncheckTail(a);

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

@@ -161,6 +161,12 @@ export type Test = readonly ['test', (ctx: TestContext, name: string, expectFail
 export declare const test: Func<Test>;
 export type NodeOp = All | Await | Fetch | Fs | Http | Forever | Import | Now | Sandbox | Write | Test;
 export type NodeEffect<T> = Effect<NodeOp, T>;
+/**
+ * Writes an error line to `stderr` and yields exit code `1`. The canonical
+ * "fail with a message" program for a `NodeProgram`. For non-`1` exit codes,
+ * compose `error(s).step(() => pure(n))` directly.
+ */
+export declare const errorExit: (s: string) => Effect<NodeOp, number>;
 export type NodeOperationMap = ToAsyncOperationMap<NodeOp>;
 /**
  * The environment variables.

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

@@ -8,7 +8,7 @@
  * @module
  */
 import { utf8 } from "../../../text/module.f.js";
-import { do_, pure } from "../module.f.js";
+import { begin, do_, pure } from "../module.f.js";
 const doAll = do_('all');
 /**
  * To run the operation `O` should be known by the runner/engine.
@@ -65,3 +65,11 @@ export const sandbox = do_('sandbox');
 const awaitPromise = do_('await');
 export const awaitIfPromise = (p) => awaitPromise(p).step(([x]) => pure(x));
 export const test = do_('test');
+/**
+ * Writes an error line to `stderr` and yields exit code `1`. The canonical
+ * "fail with a message" program for a `NodeProgram`. For non-`1` exit codes,
+ * compose `error(s).step(() => pure(n))` directly.
+ */
+export const errorExit = (s) => begin
+    .step(() => error(s))
+    .step(() => pure(1));

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

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { assert, todo } from "../../../../dev/module.f.js";
+import { assert, todo } from "../../../../asserts/module.f.js";
 import { parse } from "../../../../path/module.f.js";
 import { utf8ToString } from "../../../../text/module.f.js";
 import { isVec } from "../../../bit_vec/module.f.js";

package/fs/types/list/proof.f.d.ts

@@ -18,4 +18,5 @@ export declare const proof: {
     strictEqual: (() => void)[];
     isEmpty: (() => void)[];
     length: () => void;
+    filterMap: (() => void)[];
 };

package/fs/types/list/proof.f.js

@@ -389,5 +389,19 @@ export const proof = {
             throw 6;
         }
     },
+    filterMap: [
+        () => {
+            const result = str(filterMap((x) => x % 2 === 0 ? x * 10 : null)([1, 2, 3, 4, 5]));
+            if (result !== '[20,40]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = str(filterMap((x) => x > 3 ? x : null)([1, 2, 3]));
+            if (result !== '[]') {
+                throw result;
+            }
+        },
+    ],
     // stress
 };

package/fs/types/nullable/module.f.d.ts

@@ -8,3 +8,10 @@ export type Nullable<T> = T | null;
 export declare const map: <T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>;
 export declare const match: <T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>;
 export declare const toOption: <T>(value: Nullable<T>) => Option<T>;
+/**
+ * Normalizes a possibly-`undefined` value into the codebase's `null` convention.
+ *
+ * The boundary rule between JavaScript hosts (which return `undefined` from
+ * property/index lookups) and FunctionalScript (which uses `null` for absence).
+ */
+export declare const fromUndefined: <T>(value: T | undefined) => Nullable<T>;

package/fs/types/nullable/module.f.js

@@ -1,3 +1,10 @@
 export const map = f => value => value === null ? null : f(value);
 export const match = f => none => value => value === null ? none() : f(value);
 export const toOption = (value) => value === null ? [] : [value];
+/**
+ * Normalizes a possibly-`undefined` value into the codebase's `null` convention.
+ *
+ * The boundary rule between JavaScript hosts (which return `undefined` from
+ * property/index lookups) and FunctionalScript (which uses `null` for absence).
+ */
+export const fromUndefined = (value) => value === undefined ? null : value;

package/fs/types/nullable/proof.f.js

@@ -1,4 +1,4 @@
-import { map, match, toOption } from "./module.f.js";
+import { fromUndefined, map, match, toOption } from "./module.f.js";
 export const proof = [
     () => {
         const optionSq = map((v) => v * v);
@@ -29,5 +29,22 @@ export const proof = [
         if (double(null) !== -1) {
             throw double(null);
         }
-    }
+    },
+    () => {
+        if (fromUndefined(undefined) !== null) {
+            throw 0;
+        }
+        if (fromUndefined(5) !== 5) {
+            throw 1;
+        }
+        if (fromUndefined(0) !== 0) {
+            throw 2;
+        }
+        if (fromUndefined(null) !== null) {
+            throw 3;
+        }
+        if (fromUndefined('') !== '') {
+            throw 4;
+        }
+    },
 ];

package/fs/types/object/module.f.js

@@ -7,12 +7,10 @@
  */
 import { isArray } from "../array/module.f.js";
 import { iterable } from "../list/module.f.js";
+import { fromUndefined, map } from "../nullable/module.f.js";
 import { entries as mapEntries, fromEntries as mapFromEntries } from "../ordered_map/module.f.js";
 const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object;
-export const at = name => object => {
-    const r = getOwnPropertyDescriptor(object, name);
-    return r === undefined ? null : r.value;
-};
+export const at = name => object => map((d) => d.value)(fromUndefined(getOwnPropertyDescriptor(object, name)));
 export const sort = e => mapEntries(mapFromEntries(e));
 export const fromEntries = e => objectFromEntries(iterable(e));
 export const fromMap = m => fromEntries(mapEntries(m));

package/fs/types/patricia_trie/proof.f.js

@@ -1,4 +1,4 @@
-import { assert } from "../../dev/module.f.js";
+import { assert } from "../../asserts/module.f.js";
 import { emptyState, patriciaTrie } from "./module.f.js";
 const combine = (a, b) => a * 1000n + b;
 const create = (a, b, s) => {

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

@@ -6,7 +6,6 @@
  * @module
  */
 export type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
-export type Assert<T extends true> = T;
 /** Functions for emitting TypeScript type expression strings. */
 export type Printer = {
     /** Emits a tuple type: `readonly[A, B]` or `[A, B]` when mutable. */

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

@@ -0,0 +1,3 @@
+export declare const proof: {
+    default: () => void;
+};

package/fs/website/proof.f.js

@@ -0,0 +1,9 @@
+import defaultExport from "./module.f.js";
+export const proof = {
+    default: () => {
+        const program = defaultExport();
+        if (program === undefined) {
+            throw 'expected a program effect';
+        }
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "type": "module",
   "files": [
     "**/*.js",

package/fs/dev/tf/scenarios/async-subtests.fail.d.ts

@@ -1,4 +0,0 @@
-export declare const withSubtests: () => Promise<{
-    sub1: () => void;
-    sub2: () => never;
-}>;

package/fs/dev/tf/scenarios/async-subtests.fail.js

@@ -1,7 +0,0 @@
-export const withSubtests = async () => {
-    await new Promise(resolve => setTimeout(resolve, 10));
-    return {
-        sub1: () => { },
-        sub2: () => { throw 'sub-test failure'; },
-    };
-};

package/fs/dev/tf/scenarios/async-subtests.pass.d.ts

@@ -1,4 +0,0 @@
-export declare const withSubtests: () => Promise<{
-    sub1: () => void;
-    sub2: () => void;
-}>;

package/fs/dev/tf/scenarios/async-subtests.pass.js

@@ -1,7 +0,0 @@
-export const withSubtests = async () => {
-    await new Promise(resolve => setTimeout(resolve, 10));
-    return {
-        sub1: () => { },
-        sub2: () => { },
-    };
-};

package/fs/dev/tf/scenarios/async.fail.d.ts

@@ -1 +0,0 @@
-export declare const sleep_fail: () => Promise<never>;

package/fs/dev/tf/scenarios/async.fail.js

@@ -1,4 +0,0 @@
-export const sleep_fail = async () => {
-    await new Promise(resolve => setTimeout(resolve, 10));
-    throw 'async failure';
-};

package/fs/dev/tf/scenarios/async.pass.d.ts

@@ -1 +0,0 @@
-export declare const sleep: () => Promise<void>;

package/fs/dev/tf/scenarios/async.pass.js

@@ -1,3 +0,0 @@
-export const sleep = async () => {
-    await new Promise(resolve => setTimeout(resolve, 10));
-};

package/fs/dev/tf/scenarios/fail.fail.f.d.ts

@@ -1 +0,0 @@
-export declare const failing: () => never;

package/fs/dev/tf/scenarios/fail.fail.f.js

@@ -1 +0,0 @@
-export const failing = () => { throw 'intentional failure'; };

package/fs/dev/tf/scenarios/return-value.pass.f.d.ts

@@ -1 +0,0 @@
-export declare const outer: () => unknown;

package/fs/dev/tf/scenarios/return-value.pass.f.js

@@ -1,2 +0,0 @@
-const inner = () => { };
-export const outer = () => ({ inner });

package/fs/dev/tf/scenarios/thenable.pass.d.ts

@@ -1,3 +0,0 @@
-export declare const thenableResolves: () => {
-    then(resolve: (v: undefined) => void): void;
-};

package/fs/dev/tf/scenarios/thenable2.pass.f.d.ts

@@ -1,3 +0,0 @@
-export declare const shouldPass: () => {
-    then: () => string;
-};

package/fs/dev/tf/scenarios/thenable2.pass.f.js

@@ -1,3 +0,0 @@
-export const shouldPass = () => ({
-    then: () => 'ok'
-});

package/fs/dev/tf/scenarios/throw.pass.f.d.ts

@@ -1,6 +0,0 @@
-declare const _default: {
-    throw: {
-        a: () => never;
-    };
-};
-export default _default;