functionalscript 0.13.0 → 0.14.0

package/{types → fs}/asn.1/module.f.d.ts

@@ -1,4 +1,4 @@
-import { type Vec } from "../bit_vec/module.f.ts";
+import { type Vec } from "../types/bit_vec/module.f.ts";
 /** ASN.1 tag number. */
 type Tag = bigint;
 /** ASN.1 universal BOOLEAN tag. */

package/{types → fs}/asn.1/module.f.js

@@ -1,6 +1,6 @@
-import { bitLength, max } from "../bigint/module.f.js";
-import { empty, isVec, length, listToVec, msb, uint, unpack, vec, vec8 } from "../bit_vec/module.f.js";
-import { identity } from "../function/module.f.js";
+import { bitLength, max } from "../types/bigint/module.f.js";
+import { empty, isVec, length, listToVec, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
+import { identity } from "../types/function/module.f.js";
 import { encode as b128encode, decode as b128decode } from "../base128/module.f.js";
 const pop = msb.popFront;
 const pop8 = pop(8n);

package/{types → fs}/asn.1/test.f.js

@@ -1,5 +1,5 @@
-import { empty, length, listToVec, msb, uint, unpack, vec, vec8 } from "../bit_vec/module.f.js";
-import { asBase } from "../nominal/module.f.js";
+import { empty, length, listToVec, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
+import { asBase } from "../types/nominal/module.f.js";
 import { decodeRaw, decodeInteger, encodeRaw, encodeInteger, integer, encode, decode, constructedSequence, octetString, boolean, constructedSet } from "./module.f.js";
 const { concat, popFront: pop } = msb;
 const cat = listToVec(msb);

package/{types → fs}/base128/module.f.d.ts

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { type Vec } from '../bit_vec/module.f.ts';
+import { type Vec } from '../types/bit_vec/module.f.ts';
 /**
  * Encodes a bigint into an MSB Base128 vector.
  *

package/{types → fs}/base128/module.f.js

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { vec8, msb, empty } from "../bit_vec/module.f.js";
+import { vec8, msb, empty } from "../types/bit_vec/module.f.js";
 const { concat, popFront } = msb;
 const pop8 = popFront(8n);
 /**

package/{types → fs}/base128/test.f.js

@@ -1,5 +1,5 @@
-import { empty, vec, vec8 } from "../bit_vec/module.f.js";
-import { asBase } from "../nominal/module.f.js";
+import { empty, vec, vec8 } from "../types/bit_vec/module.f.js";
+import { asBase } from "../types/nominal/module.f.js";
 import { encode, decode } from "./module.f.js";
 const test = (a, b) => {
     const encoded = encode(a);

package/{bnf → fs/bnf}/data/module.f.d.ts

@@ -82,7 +82,7 @@ export type AstRuleMeta<T> = {
  * Represents a parsed Abstract Syntax Tree (AST) sequence.
  */
 export type AstSequence = readonly (AstRule | CodePoint)[];
-type AstTag = string | true | undefined;
+export type AstTag = string | true | undefined;
 /**
  * Represents a parsed AST rule, consisting of a rule name and its parsed sequence.
  */

package/{cas → fs/cas}/module.f.d.ts

@@ -3,10 +3,10 @@
  *
  * @module
  */
-import { type Sha2 } from "../crypto/sha2/module.f.ts";
-import type { Vec } from "../types/bit_vec/module.f.ts";
-import { type Effect, type Operation } from "../types/effects/module.f.ts";
-import { type Fs, type NodeOp } from "../types/effects/node/module.f.ts";
+import { type Sha2 } from '../crypto/sha2/module.f.ts';
+import type { Vec } from '../types/bit_vec/module.f.ts';
+import { type Effect, type Operation } from '../types/effects/module.f.ts';
+import { type Fs, type NodeOp } from '../types/effects/node/module.f.ts';
 export type KvStore<O extends Operation> = {
     /** Reads a value by key; returns `undefined` when the key does not exist. */
     readonly read: (key: Vec) => Effect<O, Vec | undefined>;

package/{cas → fs/cas}/module.f.js

@@ -5,7 +5,7 @@
  */
 import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
 import { parse } from "../path/module.f.js";
-import { cBase32ToVec, vecToCBase32 } from "../types/cbase32/module.f.js";
+import { cBase32ToVec, vecToCBase32 } from "../cbase32/module.f.js";
 import { begin, pure } from "../types/effects/module.f.js";
 import { error, log, mkdir, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
 import { toOption } from "../types/nullable/module.f.js";

package/{types → fs}/cbase32/module.f.d.ts

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { type Vec } from "../bit_vec/module.f.ts";
-import type { Nullable } from "../nullable/module.f.ts";
+import { type Vec } from "../types/bit_vec/module.f.ts";
+import type { Nullable } from "../types/nullable/module.f.ts";
 export declare const vec5xToCBase32: (v: Vec) => string;
 export declare const vecToCBase32: (v: Vec) => string;
 export declare const cBase32ToVec5x: (s: string) => Nullable<Vec>;

package/{types → fs}/cbase32/module.f.js

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { msb, lsb, length, vec, empty } from "../bit_vec/module.f.js";
+import { msb, lsb, length, vec, empty } from "../types/bit_vec/module.f.js";
 //                         0123456789abcdef
 const m = '0123456789abcdefghjkmnpqrstvwxyz';
 const { popFront, concat } = msb;

package/{types → fs}/cbase32/test.f.js

@@ -1,4 +1,4 @@
-import { empty, vec } from "../bit_vec/module.f.js";
+import { empty, vec } from "../types/bit_vec/module.f.js";
 import { cBase32ToVec, cBase32ToVec5x, vec5xToCBase32, vecToCBase32 } from "./module.f.js";
 const check5x = (s, v) => {
     const sr = vec5xToCBase32(v);

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

@@ -0,0 +1,2 @@
+import { type Architecture, type MetaStep, type Os } from '../common/module.f.ts';
+export declare const bunSteps: (v: Os, a: Architecture) => readonly MetaStep[];

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

@@ -0,0 +1,20 @@
+import { bun } from "../config/module.f.js";
+import { clean, install, test } 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
+        },
+    },
+    name: 'bun',
+    path: 'bun.sh',
+});
+export const bunSteps = (v, a) => clean([
+    installBun(v)(a),
+    test({ run: 'bun test --timeout 20000' }),
+    test({ run: 'bun ./fs/fjs/module.ts t' }),
+]);

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

@@ -0,0 +1,43 @@
+import { images } from '../config/module.f.ts';
+export declare const os: readonly ["ubuntu", "macos", "windows"];
+export type Os = typeof os[number];
+export declare const architecture: readonly ["intel", "arm"];
+export type Architecture = typeof architecture[number];
+export type Image = typeof images[Os][Architecture];
+export type Step = {
+    readonly run?: string;
+    readonly uses?: string;
+    readonly with?: {
+        readonly [k: string]: string;
+    };
+};
+export type Job = {
+    readonly 'runs-on': Image;
+    readonly steps: readonly Step[];
+};
+export type Jobs = {
+    readonly [jobs: string]: Job;
+};
+export type GitHubAction = {
+    readonly name: string;
+    readonly on: {
+        readonly pull_request?: {};
+    };
+    readonly jobs: Jobs;
+};
+export type StepType = 'install' | 'test';
+export type MetaStep = {
+    readonly type: StepType;
+    readonly step: Step;
+} | {
+    readonly type: 'rust';
+    readonly target?: string;
+} | {
+    readonly type: 'apt-get';
+    readonly package: string;
+};
+export declare const install: (step: Step) => MetaStep;
+export declare const test: (step: Step) => MetaStep;
+export declare const clean: (steps: readonly MetaStep[]) => readonly MetaStep[];
+export declare const toSteps: (m: readonly MetaStep[]) => readonly Step[];
+export declare const ubuntu: (ms: readonly MetaStep[]) => Job;

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

@@ -0,0 +1,32 @@
+import { images, rust } from "../config/module.f.js";
+export const os = ['ubuntu', 'macos', 'windows'];
+export const architecture = ['intel', 'arm'];
+export const install = (step) => ({ type: 'install', step });
+export const test = (step) => ({ type: 'test', step });
+export const clean = (steps) => [
+    ...steps,
+    test({ run: 'git reset --hard HEAD && git clean -fdx' })
+];
+export const toSteps = (m) => {
+    const filter = (st) => m.flatMap((mt) => mt.type === st ? [mt.step] : []);
+    const aptGet = m.flatMap(v => v.type === 'apt-get' ? [v.package] : []).join(' ');
+    const needRust = m.find(v => v.type === 'rust') !== undefined;
+    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
+                }
+            }] : []),
+        ...filter('install'),
+        { uses: 'actions/checkout@v5' },
+        ...filter('test'),
+    ];
+};
+export const ubuntu = (ms) => ({
+    'runs-on': images.ubuntu.intel,
+    steps: toSteps(ms)
+});

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

@@ -0,0 +1,25 @@
+export declare const images: {
+    readonly ubuntu: {
+        readonly intel: "ubuntu-24.04";
+        readonly arm: "ubuntu-24.04-arm";
+    };
+    readonly macos: {
+        readonly intel: "macos-26-intel";
+        readonly arm: "macos-26";
+    };
+    readonly windows: {
+        readonly intel: "windows-2025";
+        readonly arm: "windows-11-arm";
+    };
+};
+export declare const bun = "1.3.13";
+export declare const deno = "2.7.14";
+export declare const playwright = "1.59.1";
+export declare const rust = "1.95.0";
+export declare const node: {
+    readonly default: "26.1.0";
+    readonly others: readonly ["20.20.2", "22.22.2", "24.15.0"];
+};
+export declare const wasmtime = "44.0.1";
+export declare const wasmer = "7.1.0";
+export declare const tsgo = "7.0.0-dev.20260508.1";

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

@@ -0,0 +1,34 @@
+// https://docs.github.com/en/actions/reference/runners/github-hosted-runners#standard-github-hosted-runners-for-public-repositories
+export const images = {
+    ubuntu: {
+        intel: 'ubuntu-24.04',
+        arm: 'ubuntu-24.04-arm'
+    },
+    macos: {
+        intel: 'macos-26-intel',
+        arm: 'macos-26'
+    },
+    windows: {
+        intel: 'windows-2025',
+        arm: 'windows-11-arm',
+    }
+};
+// https://bun.sh/
+export const bun = '1.3.13';
+// https://deno.com/
+export const deno = '2.7.14';
+// https://www.npmjs.com/package/playwright
+export const playwright = '1.59.1';
+// https://rust-lang.org/
+export const rust = '1.95.0';
+// https://nodejs.org/en/download
+export const node = {
+    default: '26.1.0',
+    others: ['20.20.2', '22.22.2', '24.15.0'],
+};
+// https://github.com/bytecodealliance/wasmtime/releases
+export const wasmtime = '44.0.1';
+// 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.20260508.1';

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

@@ -0,0 +1,2 @@
+import { type MetaStep } from '../common/module.f.ts';
+export declare const denoSteps: readonly MetaStep[];

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

@@ -0,0 +1,13 @@
+import { deno } from "../config/module.f.js";
+import { clean, install, test } from "../common/module.f.js";
+export const denoSteps = clean([
+    install({
+        uses: 'denoland/setup-deno@v2',
+        with: { 'deno-version': deno },
+    }),
+    test({ run: 'deno install' }),
+    test({ run: 'deno task test' }),
+    test({ run: 'deno task fjs compile issues/demo/data/tree.json _tree.f.js' }),
+    test({ run: 'deno task fjs t' }),
+    test({ run: 'deno publish --dry-run' }),
+]);

package/fs/ci/module.f.js

@@ -0,0 +1,40 @@
+/**
+ * Continuous integration helper commands for repository automation tasks.
+ *
+ * @module
+ */
+import { utf8 } from "../text/module.f.js";
+import { begin, pure } from "../types/effects/module.f.js";
+import { writeFile } from "../types/effects/node/module.f.js";
+import { images } from "./config/module.f.js";
+import { architecture, os, toSteps } from "./common/module.f.js";
+import { rustSteps } from "./rust/module.f.js";
+import { nodeMainSteps, nodeVersions } from "./node/module.f.js";
+import { playwrightJob } from "./playwright/module.f.js";
+import { bunSteps } from "./bun/module.f.js";
+import { denoSteps } from "./deno/module.f.js";
+const job = (v) => (a) => {
+    const id = `${v}-${a}`;
+    const image = images[v][a];
+    const result = [
+        ...rustSteps(a, v),
+        ...nodeMainSteps(v),
+        ...denoSteps,
+        ...bunSteps(v, a),
+    ];
+    return [id, { 'runs-on': image, steps: toSteps(result) }];
+};
+const jobs = {
+    ...Object.fromEntries(os.flatMap(v => architecture.map(job(v)))),
+    ...nodeVersions,
+    playwright: playwrightJob,
+};
+const gha = {
+    name: 'CI',
+    on: { pull_request: {} },
+    jobs,
+};
+export const effect = begin
+    .step(() => writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  '))))
+    .step(() => pure(0));
+export default () => effect;

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

@@ -0,0 +1,6 @@
+import { type Jobs, type MetaStep, type Os } from '../common/module.f.ts';
+export declare const major: (v: string) => string;
+export declare const basicNode: (version: string) => (extra: readonly MetaStep[]) => readonly MetaStep[];
+export declare const nodeTests: (version: string) => (extra: readonly MetaStep[]) => readonly MetaStep[];
+export declare const nodeVersions: Jobs;
+export declare const nodeMainSteps: (v: Os) => readonly MetaStep[];

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

@@ -0,0 +1,36 @@
+import { node, tsgo } from "../config/module.f.js";
+import { clean, install, test, ubuntu } from "../common/module.f.js";
+export const major = (v) => v.split('.')[0];
+const installNode = (version) => ({ uses: 'actions/setup-node@v6', with: { 'node-version': version } });
+export const basicNode = (version) => (extra) => clean([
+    install(installNode(version)),
+    test({ run: 'npm ci' }),
+    ...extra,
+]);
+export const nodeTests = (version) => (extra) => basicNode(version)([
+    test({ run: 'npm test' }),
+    test({ run: 'npm run fst' }),
+    ...extra,
+]);
+const findTgz = (v) => v === 'windows' ? '(Get-ChildItem *.tgz).FullName' : './*.tgz';
+const nodeTest = (v) => major(v) === '20' ? 'run test20' : 'test';
+const nodeSteps = (v) => [
+    install(installNode(v)),
+    test({ run: 'npm ci' }),
+    test({ run: `npm ${nodeTest(v)}` }),
+];
+export const nodeVersions = Object.fromEntries(node.others.map(v => [
+    `node${major(v)}`,
+    ubuntu(nodeSteps(v))
+]));
+export const nodeMainSteps = (v) => nodeTests(node.default)([
+    // TypeScript Preview
+    install({ run: `npm install -g @typescript/native-preview@${tsgo}` }),
+    test({ run: 'tsgo' }),
+    // publishing
+    test({ run: 'npm pack' }),
+    test({ run: `npm install -g ${findTgz(v)}` }),
+    test({ run: 'fjs compile issues/demo/data/tree.json _tree.f.js' }),
+    test({ run: 'fjs t' }),
+    test({ run: 'npm uninstall functionalscript -g' }),
+]);

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

@@ -0,0 +1,2 @@
+import { type Job } from '../common/module.f.ts';
+export declare const playwrightJob: Job;

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

@@ -0,0 +1,23 @@
+import { images, node, playwright } from "../config/module.f.js";
+import { install, test, toSteps } from "../common/module.f.js";
+import { basicNode } from "../node/module.f.js";
+const playwrightImage = images.ubuntu.intel;
+// Playwright installation is stuck on Node 26 (May 7 2026) so we use Node 24.
+export const playwrightJob = {
+    'runs-on': playwrightImage,
+    steps: toSteps(basicNode(node.others.at(-1))([
+        install({
+            uses: 'actions/cache@v4',
+            with: {
+                path: '~/.cache/ms-playwright',
+                key: `${playwrightImage}-playwright-${playwright}`,
+            },
+        }),
+        install({ run: `npm install -g playwright@${playwright}` }),
+        install({ run: 'playwright install-deps' }),
+        install({ run: 'playwright install' }),
+        // we have to use `npx` to make sure that we respect `@playwright/test` version from
+        // the `package.json`.
+        ...['chromium', 'firefox', 'webkit'].map(browser => test({ run: `npx playwright test --browser=${browser}` })),
+    ]))
+};

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

@@ -0,0 +1,2 @@
+import { type Architecture, type MetaStep, type Os } from '../common/module.f.ts';
+export declare const rustSteps: (a: Architecture, v: Os) => readonly MetaStep[];

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

@@ -0,0 +1,49 @@
+import { wasmer, wasmtime } from "../config/module.f.js";
+import { install, test } from "../common/module.f.js";
+const cargoTest = (target, config) => {
+    const to = target ? ` --target ${target}` : '';
+    const co = config ? ` --config ${config}` : '';
+    const main = `cargo test${to}${co}`;
+    return [
+        test({ run: main }),
+        test({ run: `${main} --release` })
+    ];
+};
+const customTarget = (target) => [
+    { type: 'rust', target },
+    ...cargoTest(target)
+];
+const wasmTarget = (target) => [
+    ...customTarget(target),
+    ...cargoTest(target, '.cargo/config.wasmer.toml')
+];
+const i686 = (a, v) => {
+    if (a === 'intel') {
+        switch (v) {
+            case 'windows': return customTarget('i686-pc-windows-msvc');
+            case 'ubuntu': return [
+                { type: 'apt-get', package: 'libc6-dev-i386' },
+                ...customTarget('i686-unknown-linux-gnu'),
+            ];
+        }
+    }
+    return [];
+};
+export const rustSteps = (a, v) => [
+    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}` },
+    }),
+    ...wasmTarget('wasm32-wasip1'),
+    ...wasmTarget('wasm32-wasip2'),
+    ...wasmTarget('wasm32-unknown-unknown'),
+    ...wasmTarget('wasm32-wasip1-threads'),
+    ...i686(a, v),
+];

package/{crypto → fs/crypto}/secp/module.f.d.ts

@@ -3,7 +3,7 @@ import { type PrimeField } from '../../types/prime_field/module.f.ts';
 /**
  * A 2D point represented as a pair of `bigint` values `[x, y]`.
  */
-type Point2D = readonly [bigint, bigint];
+export type Point2D = readonly [bigint, bigint];
 /**
  * A 2D point on an elliptic curve, represented as a pair of `bigint` values.
  * `null` represents the point at infinity (`O`).
@@ -76,4 +76,3 @@ export declare const secp384r1: Curve;
  * https://neuromancer.sk/std/secg/secp521r1
  */
 export declare const secp521r1: Curve;
-export {};

package/{dev → fs/dev}/module.f.d.ts

@@ -7,6 +7,8 @@ import { type Io } from '../io/module.f.ts';
 import { type All, 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 default?: unknown;
 };

package/{dev → fs/dev}/module.f.js

@@ -10,6 +10,11 @@ import { utf8, utf8ToString } from "../text/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 import { begin, pure } from "../types/effects/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]);
 const cmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0;
 export const env = ({ process: { env } }) => a => {
     const r = Object.getOwnPropertyDescriptor(env, a);

package/{dev → fs/dev}/tf/all.test.js

@@ -24,18 +24,20 @@ const scanModule = (x) => async (subTestRunner) => {
         }
         subTests = rest;
         //
-        const [name, value] = first;
-        const set = parse(value);
+        const [name, value, throws] = first;
+        const set = parse(throws)(value);
         if (typeof set === 'function') {
             await subTestRunner(name, () => {
                 const r = set();
-                subTests = [...subTests, [`${name}()`, r]];
+                // The result of a function is walked as a fresh sub-tree;
+                // the parent's `throws` flag does not propagate into it.
+                subTests = [...subTests, [`${name}()`, r, false]];
             });
         }
         else {
             for (const [j, y] of set) {
                 const pr = `${name}/${j}`;
-                subTests = [...subTests, [pr, y]];
+                subTests = [...subTests, [pr, y, throws || j === 'throw']];
             }
         }
     }
@@ -44,7 +46,7 @@ const run = async () => {
     const x = await loadModuleMap(io);
     for (const [i, v] of Object.entries(x)) {
         if (isTest(i)) {
-            framework(i, scanModule(['', v.default]));
+            framework(i, scanModule(['', v.default, false]));
         }
     }
 };

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

@@ -16,7 +16,7 @@ type Input<T> = {
 export declare const isTest: (s: string) => boolean;
 export type Test = () => unknown;
 export type TestSet = Test | readonly (readonly [string, unknown])[];
-export declare const parseTestSet: (t: TryCatch) => (x: unknown) => TestSet;
+export declare const parseTestSet: (t: TryCatch) => (throws: boolean) => (x: unknown) => TestSet;
 export declare const test: <T>(input: Input<T>) => readonly [number, T];
 export declare const anyLog: (f: (s: string) => void) => (s: string) => <T>(state: T) => T;
 export declare const measure: (p: Performance) => <R>(f: () => R) => <T>(state: T) => readonly [R, number, T];

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

@@ -18,16 +18,17 @@ const timeFormat = (a) => {
     const e = x.substring(s);
     return `${b}.${e} ms`;
 };
-export const parseTestSet = (t) => (x) => {
+export const parseTestSet = (t) => (throws) => (x) => {
     switch (typeof x) {
         case 'function': {
             if (x.length === 0) {
                 const xt = x;
-                if (xt.name !== 'throw') {
+                if (!throws && xt.name !== 'throw') {
                     return xt;
                 }
-                // Usual tests throw on error, but if the function name is 'throw',
-                // then the test passes if it throws.
+                // Pass-on-throw: the test passes if it throws. Triggered when the
+                // enclosing tree node is named 'throw' (so any function reference
+                // works, not only inline ones whose inferred name is 'throw').
                 return () => {
                     const [tag, value] = t(xt);
                     if (tag === 'ok') {
@@ -52,9 +53,9 @@ export const test = (input) => {
     const isGitHub = env('GITHUB_ACTION') !== undefined;
     const parse = parseTestSet(tryCatch);
     const f = ([k, v]) => {
-        const test = i => v => ([ts, state]) => {
+        const test = i => throws => v => ([ts, state]) => {
             const next = test(`${i}| `);
-            const set = parse(v);
+            const set = parse(throws)(v);
             if (typeof set === 'function') {
                 const [[s, r], delta, state0] = measure(() => tryCatch(set))(state);
                 state = state0;
@@ -73,13 +74,15 @@ export const test = (input) => {
                 else {
                     ts = addPass(delta)(ts);
                     log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`);
-                    [ts, state] = next(r)([ts, state]);
+                    // The result of a function is walked as a fresh sub-tree;
+                    // the parent's `throws` flag does not propagate into it.
+                    [ts, state] = next(false)(r)([ts, state]);
                 }
             }
             else {
                 const f = ([k, v]) => ([time, state]) => {
                     log(`${i}${k}:`);
-                    [time, state] = next(v)([time, state]);
+                    [time, state] = next(throws || k === 'throw')(v)([time, state]);
                     return [time, state];
                 };
                 [ts, state] = fold(f)([ts, state])(set);
@@ -89,7 +92,7 @@ export const test = (input) => {
         return ([ts, state]) => {
             if (isTest(k)) {
                 log(`testing ${k}`);
-                [ts, state] = test('| ')(v.default)([ts, state]);
+                [ts, state] = test('| ')(false)(v.default)([ts, state]);
             }
             return [ts, state];
         };

package/fs/dev/tf/test.f.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    throw: () => never;
+    throwReference: {
+        throw: () => unknown;
+    };
+    throwGroup: {
+        throw: {
+            inline: () => never;
+            reference: () => unknown;
+            nested: {
+                deep: () => never;
+            };
+        };
+    };
+};
+export default _default;