functionalscript 0.18.0 → 0.19.0

package/fs/asn.1/module.f.js

@@ -5,19 +5,18 @@
  * @module
  */
 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 { empty, isVec, length, 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 { popFront: pop, listToVec } = msb;
 const pop8 = pop(8n);
-const concat = listToVec(msb);
 const classPcMask = 224n;
 const tagNumberMask = 31n;
 const parsedTagEncode = ([classPc, number]) => {
     const [firstByteNumber, rest] = number < tagNumberMask
         ? [number, empty]
         : [tagNumberMask, b128encode(number)];
-    return concat([vec8(classPc | firstByteNumber), rest]);
+    return listToVec([vec8(classPc | firstByteNumber), rest]);
 };
 const parsedTagDecode = (v) => {
     const [firstByte, rest] = pop8(v);
@@ -86,7 +85,7 @@ const lenEncode = (uint) => {
         return vec8(uint);
     }
     const { byteLen, v } = round8({ length: bitLength(uint), uint });
-    return concat([vec8(0x80n | byteLen), v]);
+    return listToVec([vec8(0x80n | byteLen), v]);
 };
 /**
  * Decodes the length field of an ASN.1 TLV and returns the length in bits and the remaining input.
@@ -104,7 +103,7 @@ const lenDecode = (v) => {
 export const encodeRaw = ([tag, value]) => {
     const tagVec = tagEncode(tag);
     const { byteLen, v } = round8(unpack(value));
-    return concat([tagVec, lenEncode(byteLen), v]);
+    return listToVec([tagVec, lenEncode(byteLen), v]);
 };
 /** Decodes a raw ASN.1 TLV tuple and returns the remaining input. */
 export const decodeRaw = (v) => {
@@ -139,7 +138,7 @@ export const decodeOctetString = (v) => v;
 export const encodeObjectIdentifier = (oid) => {
     const [first, second, ...rest] = oid;
     const firstByte = first * 40n + second;
-    return concat([vec8(firstByte), ...rest.map(b128encode)]);
+    return listToVec([vec8(firstByte), ...rest.map(b128encode)]);
 };
 /** Decodes an OBJECT IDENTIFIER value. */
 export const decodeObjectIdentifier = (v) => {
@@ -155,7 +154,7 @@ export const decodeObjectIdentifier = (v) => {
     }
     return result;
 };
-const genericEncodeSequence = (map) => (...records) => concat(map(records.map(encode)));
+const genericEncodeSequence = (map) => (...records) => listToVec(map(records.map(encode)));
 /** Encodes a SEQUENCE payload from ordered records. */
 export const encodeSequence = genericEncodeSequence(identity);
 /** Decodes a SEQUENCE payload into records. */

package/fs/asn.1/test.f.js

@@ -1,8 +1,7 @@
-import { empty, length, listToVec, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
+import { empty, length, 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);
+const { concat, popFront: pop, listToVec } = msb;
 const pop8 = pop(8n);
 const check = (tag, v, rest) => {
     const s = encodeRaw([tag, v]);
@@ -244,19 +243,19 @@ export default {
     },
     encodeDecode: {
         integer: () => {
-            ch([integer, 0n], cat([vec8(BigInt(integer)), vec8(1n), vec8(0n)]));
-            ch([integer, 1n], cat([vec8(BigInt(integer)), vec8(1n), vec8(1n)]));
+            ch([integer, 0n], listToVec([vec8(BigInt(integer)), vec8(1n), vec8(0n)]));
+            ch([integer, 1n], listToVec([vec8(BigInt(integer)), vec8(1n), vec8(1n)]));
         },
         sequence: () => {
-            ch([constructedSequence, []], cat([vec8(BigInt(constructedSequence)), vec8(0n)]));
-            ch([constructedSequence, [[integer, 0n]]], cat([vec8(BigInt(constructedSequence)), vec8(3n), encode([integer, 0n])]));
-            ch([constructedSequence, [[integer, 1n], [integer, 2n]]], cat([
+            ch([constructedSequence, []], listToVec([vec8(BigInt(constructedSequence)), vec8(0n)]));
+            ch([constructedSequence, [[integer, 0n]]], listToVec([vec8(BigInt(constructedSequence)), vec8(3n), encode([integer, 0n])]));
+            ch([constructedSequence, [[integer, 1n], [integer, 2n]]], listToVec([
                 vec8(BigInt(constructedSequence)),
                 vec8(6n),
                 encode([integer, 1n]),
                 encode([integer, 2n])
             ]));
-            ch([constructedSequence, [[octetString, vec8(0x23n)], [boolean, true], [boolean, false]]], cat([
+            ch([constructedSequence, [[octetString, vec8(0x23n)], [boolean, true], [boolean, false]]], listToVec([
                 vec8(BigInt(constructedSequence)),
                 vec8(9n),
                 encode([octetString, vec8(0x23n)]),
@@ -265,7 +264,7 @@ export default {
             ]));
         },
         set: () => {
-            ch([constructedSet, [[integer, 2n], [integer, 1n]]], cat([
+            ch([constructedSet, [[integer, 2n], [integer, 1n]]], listToVec([
                 vec8(BigInt(constructedSet)),
                 vec8(6n),
                 encode([integer, 1n]),
@@ -276,7 +275,7 @@ export default {
     raw: [
         () => {
             const e = encodeRaw([0x00n, vec8(0x23n)]);
-            if (e !== cat([vec8(0x00n), vec8(1n), vec8(0x23n)])) {
+            if (e !== listToVec([vec8(0x00n), vec8(1n), vec8(0x23n)])) {
                 throw `encode: ${length(e)}: ${uint(e).toString(2)}`;
             }
             const [[tag, value], rest] = decodeRaw(e);
@@ -292,7 +291,7 @@ export default {
         },
         () => {
             const e = encodeRaw([0x1f20n, vec(16n)(0x1234n)]);
-            if (e !== cat([vec8(0x1fn), vec8(0x20n), vec8(2n), vec(16n)(0x1234n)])) {
+            if (e !== listToVec([vec8(0x1fn), vec8(0x20n), vec8(2n), vec(16n)(0x1234n)])) {
                 const l = length(e);
                 const u = uint(e);
                 throw `encode: ${l}: ${u.toString(16)}`;

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

@@ -20,13 +20,13 @@ export declare const images: {
     };
 };
 export declare const bun = "1.3.14";
-export declare const deno = "2.8.0";
+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 others: readonly ["22.22.3", "24.16.0"];
+    readonly others: readonly ["24.16.0"];
 };
-export declare const wasmtime = "44.0.1";
+export declare const wasmtime = "45.0.0";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260526.1";
+export declare const tsgo = "7.0.0-dev.20260527.1";

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

@@ -23,7 +23,7 @@ export const images = {
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
-export const deno = '2.8.0';
+export const deno = '2.8.1';
 // https://www.npmjs.com/package/playwright
 export const playwright = '1.60.0';
 // https://rust-lang.org/
@@ -31,11 +31,11 @@ export const rust = '1.95.0';
 // https://nodejs.org/en/download
 export const node = {
     default: '26.2.0',
-    others: ['22.22.3', '24.16.0'],
+    others: ['24.16.0'],
 };
 // https://github.com/bytecodealliance/wasmtime/releases
-export const wasmtime = '44.0.1';
+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.20260526.1';
+export const tsgo = '7.0.0-dev.20260527.1';

package/fs/crypto/sign/module.f.js

@@ -1,5 +1,5 @@
 import { bitLength, divUp, roundUp } from "../../types/bigint/module.f.js";
-import { empty, length, listToVec, msb, repeat, unpack, vec, vec8 } from "../../types/bit_vec/module.f.js";
+import { empty, length, msb, repeat, unpack, vec, vec8 } from "../../types/bit_vec/module.f.js";
 import { hmac } from "../hmac/module.f.js";
 import { computeSync } from "../sha2/module.f.js";
 // qlen to rlen
@@ -34,8 +34,8 @@ export const all = (q) => {
 export const fromCurve = (c) => all(c.nf.p);
 const x01 = vec8(0x01n);
 const x00 = vec8(0x00n);
-const ltov = listToVec(msb);
-export const concat = (...x) => ltov(x);
+const { listToVec } = msb;
+export const concat = (...x) => listToVec(x);
 /**
  * Computes deterministic ECDSA nonce `k` as described by RFC6979.
  */

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

@@ -1,2 +1 @@
-export declare const run3: () => Promise<void>;
-export declare const run: () => Promise<void>;
+export declare const run: () => Promise<number>;

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

@@ -1,21 +1,22 @@
-import { type All, type NodeProgram, type NodeProgramOptions, type Program, type Sandbox, type SandboxResult, type Write } from '../../types/effects/node/module.f.ts';
+import { type All, 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';
 export declare const isTest: (s: string) => boolean;
-export type Test = () => unknown;
+export type TestFn = () => unknown;
 export type TestEntry = {
-    readonly fn: Test;
+    readonly fn: TestFn;
     readonly throws: boolean;
 };
 export type TestSet = TestEntry | readonly (readonly [string, unknown])[];
 export declare const parseTestSet: (throws: boolean, x: unknown) => TestSet;
+type TestAndPath = readonly [Path, TestEntry];
 /**
  * Recursively collects all leaf tests reachable from `v` as `[path, entry]`
  * pairs, without running anything. Return-value sub-trees are not walked
  * (that requires execution); only the static object/array/function structure
  * is traversed.
  */
-export declare const collectTests: (path: Path, throws: boolean, v: unknown) => readonly (readonly [Path, TestEntry])[];
+export declare const collectTests: (path: Path, throws: boolean, v: unknown) => readonly TestAndPath[];
 /**
  * Receives semantic test-run events. Each method is the runner's notification
  * of an event; the reporter decides how to render it (terminal, GitHub
@@ -29,8 +30,10 @@ export type Reporter<O extends Operation> = {
     readonly summary: (pass: number, fail: number, time: number) => Effect<O, void>;
     readonly test: (file: string, path: Path, set: TestEntry) => Effect<O, SandboxResult<unknown>>;
 };
+export declare const registerModule: (ctx: TestContext, k: string, v: unknown) => Effect<Test | All, void>;
 export declare const runModuleMap: <O extends Operation>(reporter: Reporter<O>) => (moduleMap: ModuleMap) => Effect<O | All, number>;
-export declare const test: <O extends Operation>(reporter: Reporter<O>) => Program<O | All | LoadModuleOperations>;
+export declare const testAll: <O extends Operation>(reporter: Reporter<O>) => Program<O | All | LoadModuleOperations>;
+export declare const registerModuleMap: (ctx: TestContext, moduleMap: ModuleMap) => Effect<Test | All, void>;
 export type Path = readonly (string | null)[];
 export declare const isInteger: (s: string) => boolean;
 export declare const isIdentifier: (s: string) => boolean;
@@ -70,3 +73,5 @@ export declare const defaultTest: (file: string, path: Path, { fn, throws }: Tes
  */
 export declare const defaultReporter: (options: NodeProgramOptions) => Reporter<Write | Sandbox>;
 export declare const main: NodeProgram;
+export declare const register: NodeProgram;
+export {};

package/fs/dev/tf/module.f.js

@@ -4,8 +4,8 @@
  * @module
  */
 import { reset, fgGreen, fgRed, bold, csiWrite } from "../../text/sgr/module.f.js";
-import { all, sandbox } from "../../types/effects/node/module.f.js";
-import { pure } from "../../types/effects/module.f.js";
+import { all, sandbox, test } from "../../types/effects/node/module.f.js";
+import { pure, do_ } from "../../types/effects/module.f.js";
 import { loadModuleMap } from "../module.f.js";
 import { invert } from "../../types/result/module.f.js";
 export const isTest = (s) => s.endsWith('test.f.js') || s.endsWith('test.f.ts');
@@ -51,28 +51,47 @@ export const collectTests = (path, throws, v) => {
     }
     return [[path, set]];
 };
+export const registerModule = (ctx, k, v) => {
+    const registerOne = (ctx, [path, { fn, throws }]) => test(ctx, fmtImport(k, path), throws, (t) => {
+        if (throws) {
+            fn();
+            return pure(undefined);
+        }
+        const r = fn();
+        const sub = collectTests([...path, null], false, r);
+        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);
+    }
+    return all(...tests.map(e => registerOne(ctx, e))).step(() => pure(undefined));
+};
 const mergeState = (a, b) => ({ time: a.time + b.time, pass: a.pass + b.pass, fail: a.fail + b.fail });
 const zero = { time: 0, pass: 0, fail: 0 };
 const runModule = ({ result, test }) => (k, v) => (ts) => {
-    const walk = (path, throws, v) => {
-        const effects = collectTests(path, throws, v)
-            .map(([testPath, set]) => test(k, testPath, set)
-            .step(sr => {
-            const { result: [s, r], duration } = sr;
-            return result(k, testPath, sr)
-                .step(() => {
-                if (s === 'ok') {
-                    if (set.throws) {
-                        return pure(addPass(duration)(zero));
-                    }
-                    // Walk return-value sub-tree; null marks the call boundary so
-                    // paths render as e.g. `outer().inner`. throws resets to false.
-                    return walk([...testPath, null], false, r)
-                        .step(sub => pure(mergeState(addPass(duration)(zero), sub)));
+    const one = ([testPath, set]) => test(k, testPath, set)
+        .step(sr => {
+        const { result: [s, r], duration } = sr;
+        return result(k, testPath, sr)
+            .step(() => {
+            if (s === 'ok') {
+                if (set.throws) {
+                    return pure(addPass(duration)(zero));
                 }
-                return pure(addFail(duration)(zero));
-            });
-        }));
+                // Walk return-value sub-tree; null marks the call boundary so
+                // paths render as e.g. `outer().inner`. throws resets to false.
+                return walk([...testPath, null], false, r)
+                    .step(sub => pure(mergeState(addPass(duration)(zero), sub)));
+            }
+            return pure(addFail(duration)(zero));
+        });
+    });
+    const walk = (path, throws, v) => {
+        const effects = collectTests(path, throws, v).map(one);
         return all(...effects)
             .step(states => pure(states.reduce(mergeState, zero)));
     };
@@ -87,7 +106,14 @@ export const runModuleMap = (reporter) => (moduleMap) => {
         .step(ts => summary(ts.pass, ts.fail, ts.time)
         .step(() => pure(ts.fail !== 0 ? 1 : 0)));
 };
-export const test = (reporter) => options => loadModuleMap(options.env).step(runModuleMap(reporter));
+export const testAll = (reporter) => options => loadModuleMap(options.env).step(runModuleMap(reporter));
+export const registerModuleMap = (ctx, moduleMap) => {
+    const modules = entries(moduleMap).filter(([k]) => isTest(k));
+    if (modules.length === 0) {
+        return pure(undefined);
+    }
+    return all(...modules.map(([k, v]) => registerModule(ctx, k, v))).step(() => pure(undefined));
+};
 const isAlpha = (c) => (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c === '_' || c === '$';
 const isDigit = (c) => c >= '0' && c <= '9';
 export const isInteger = (s) => s.length > 0 && [...s].every(isDigit) && (s === '0' || s[0] !== '0');
@@ -169,4 +195,9 @@ export const defaultReporter = (options) => {
         test: defaultTest,
     };
 };
-export const main = options => test(defaultReporter(options))(options);
+export const main = options => testAll(defaultReporter(options))(options);
+export const register = o => loadModuleMap(o.env)
+    .step(m => registerModuleMap(o.engine === 'bun' ? o.bunTestContext :
+    o.engine === 'playwright' ? o.playwrightTestContext :
+        o.testContext, m))
+    .step(() => pure(0));

package/fs/dev/tf/module.js

@@ -1,103 +1,4 @@
-import { io, tryCatch } from "../../io/module.js";
-import { loadModuleMap } from "../module.f.js";
-import { fmtImport, isTest, parseTestSet, runModuleMap } from "./module.f.js";
-import * as nodeTest from 'node:test';
-import { asyncImport } from "../../io/module.js";
-import { fromIo } from "../../io/module.f.js";
-import { pure } from "../../types/effects/module.f.js";
-import { asyncRun } from "../../types/effects/module.js";
-import {} from "../../types/effects/node/module.f.js";
-const isBun = typeof Bun !== 'undefined';
-const isPlaywright = typeof process !== 'undefined' && process?.env?.PLAYWRIGHT_TEST !== undefined;
-const createFramework = (fw) => (prefix, f) => fw.test(prefix, t => f((name, v) => t.test(name, v)));
-// Bun doesn't support nested tests yet.
-const createBunFramework = (fw) => (prefix, f) => f((name, v) => fw.test(`${prefix}: ${name}`, v));
-const createPlaywrightFramework = async () => {
-    const pwTest = (await asyncImport('@playwright/test')).test;
-    return (prefix, f) => f((name, v) => pwTest(`${prefix}: ${name}`, v));
-};
-const framework = isPlaywright ? await createPlaywrightFramework() :
-    isBun ? createBunFramework(nodeTest) :
-        createFramework(nodeTest);
-const scanModule = (x) => async (subTestRunner) => {
-    let subTests = [x];
-    while (true) {
-        const [first, ...rest] = subTests;
-        if (first === undefined) {
-            break;
-        }
-        subTests = rest;
-        //
-        const [name, value, throws] = first;
-        const set = parseTestSet(throws, value);
-        if (set instanceof Array) {
-            for (const [j, y] of set) {
-                const pr = `${name}/${j}`;
-                subTests = [...subTests, [pr, y, throws || j === 'throw']];
-            }
-        }
-        else {
-            await subTestRunner(name, () => {
-                if (set.throws) {
-                    let threw = false;
-                    try {
-                        set.fn();
-                    }
-                    catch (_) {
-                        threw = true;
-                    }
-                    if (!threw) {
-                        throw new Error(`${name}() expected to throw`);
-                    }
-                }
-                else {
-                    const r = set.fn();
-                    // 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]];
-                }
-            });
-        }
-    }
-};
-const noOp = () => pure(undefined);
-const reporter = {
-    result: noOp,
-    summary: noOp,
-    test: (file, path, { throws, fn }) => {
-        nodeTest.test(fmtImport(file, path), async (_t) => {
-            const [s, r] = tryCatch(fn);
-            if (throws === (s === 'ok')) {
-                throw r;
-            }
-            if (!throws) {
-                // TODO: add subtests
-            }
-        });
-        return pure({
-            result: ['ok', undefined],
-            duration: 0,
-        });
-    }
-};
-const map = {
-    // TODO: we use the same algorithm twice. Refactor by creating a `createAll(map)`
-    // helper that takes a `map` and returns an `all` function that runs effects
-    // according to the map. There could be a problem with circular dependencies,
-    // but we can use a lazy function `() => ToAsyncOperationMap<All>` instead od `map`.
-    all: async (...effects) => Promise.all(effects.map(asyncRun(map))),
-};
-export const run3 = async () => {
-    const fio = fromIo(io);
-    const moduleMap = await fio(loadModuleMap(io.process.env));
-    const runner = runModuleMap(reporter)(moduleMap);
-    await asyncRun(map)(runner);
-};
-export const run = async () => {
-    const moduleMap = await fromIo(io)(loadModuleMap(io.process.env));
-    for (const [i, v] of Object.entries(moduleMap)) {
-        if (isTest(i)) {
-            framework(i, scanModule(['', v, false]));
-        }
-    }
-};
+import { io } from "../../io/module.js";
+import { register } from "./module.f.js";
+import { runProgram } from "../../io/module.f.js";
+export const run = () => runProgram(io)([])(register);

package/fs/dev/tf/scenarios/all.d.ts

@@ -0,0 +1 @@
+export {};

package/fs/dev/tf/scenarios/all.js

@@ -0,0 +1,3 @@
+import { run } from "../module.js";
+// we need `await` for Playwright.
+await run();

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

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

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

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

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

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

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

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

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

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

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

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

package/fs/dev/tf/test.f.js

@@ -1,8 +1,8 @@
 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 } from "../module.f.js";
-import { test, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, defaultTest, } from "./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";
 const makeReporter = () => {
     const events = [];
     const reporter = {
@@ -12,10 +12,15 @@ const makeReporter = () => {
     };
     return [reporter, () => events];
 };
+const noopTestContext = { test: todo };
 const options = (initCwd, github = false) => ({
     args: [],
     env: { INIT_CWD: initCwd, ...(github ? { GITHUB_ACTION: 'true' } : {}) },
     std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
+    testContext: noopTestContext,
+    bunTestContext: noopTestContext,
+    playwrightTestContext: noopTestContext,
+    engine: 'node',
 });
 const ok0 = () => ({ result: ['ok', undefined], duration: 0 });
 const fail0 = () => ({ result: ['error', 'oops'], duration: 0 });
@@ -23,7 +28,7 @@ const ok1 = () => ({ result: ['ok', undefined], duration: 1 });
 const run = (dir, initCwd = '.') => {
     const [reporter, getEvents] = makeReporter();
     const state = { ...emptyState, root: dir };
-    const [, exitCode] = virtual(state)(test(reporter)(options(initCwd)));
+    const [, exitCode] = virtual(state)(testAll(reporter)(options(initCwd)));
     return [getEvents(), exitCode];
 };
 // Runs the real `defaultReporter` and returns its captured stdout/stderr so the
@@ -31,7 +36,7 @@ const run = (dir, initCwd = '.') => {
 const runMain = (dir, github = false) => {
     const state = { ...emptyState, root: dir };
     const opts = options('.', github);
-    const [finalState, exitCode] = virtual(state)(test(defaultReporter(opts))(opts));
+    const [finalState, exitCode] = virtual(state)(testAll(defaultReporter(opts))(opts));
     return [finalState.stdout, finalState.stderr, exitCode];
 };
 // flat object: two passing tests

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

@@ -1,5 +1,5 @@
 import { type Effect } from '../types/effects/module.f.ts';
-import type { Headers, Module, NodeOp, Env, SandboxResult, NodeProgram, WriteConsoles } from '../types/effects/node/module.f.ts';
+import { type Headers, type Module, type NodeOp, type Env, type SandboxResult, type NodeProgram, type WriteConsoles, type TestContext, type Engine } from '../types/effects/node/module.f.ts';
 import type { Vec } from '../types/bit_vec/module.f.ts';
 import { type Result } from '../types/result/module.f.ts';
 /**
@@ -116,6 +116,10 @@ export type Io = {
     readonly now: () => number;
     readonly sandbox: Sandbox;
     readonly write: (stream: WriteConsoles, data: Vec) => Promise<void>;
+    readonly testContext: TestContext;
+    readonly bunTestContext: TestContext;
+    readonly playwrightTestContext: TestContext;
+    readonly engine: Engine;
 };
 export type App = (io: Io) => Promise<number>;
 export type Run = (f: App) => Promise<never>;

package/fs/io/module.f.js

@@ -10,6 +10,7 @@
 import { normalize } from "../path/module.f.js";
 import {} from "../types/effects/module.f.js";
 import { asyncRun } from "../types/effects/module.js";
+import {} from "../types/effects/node/module.f.js";
 import { asBase, asNominal } from "../types/nominal/module.f.js";
 import { error, ok } from "../types/result/module.f.js";
 import { fromVec, listToVec, toVec } from "../types/uint8array/module.f.js";
@@ -96,18 +97,16 @@ export const fromIo = ({ fs: { promises: { mkdir, readFile, readdir, writeFile,
         now: async () => ioNow(),
         sandbox: async (f) => ioSandbox(f),
         write: ioWrite,
+        test: async (ctx, name, expectFailure, test) => ctx.test(name, { expectFailure }, async (t) => result(test(t))),
     });
     return result;
 };
 export const runProgram = (io) => {
-    const { process: { env, stdout, stderr } } = io;
+    const { process: { env, stdout, stderr }, testContext, bunTestContext, playwrightTestContext, engine } = io;
+    const std = { stdout, stderr };
     const f = fromIo(io);
-    return (args) => (program) => f(program({
-        args,
-        env,
-        std: {
-            stdout: { isTTY: stdout.isTTY },
-            stderr: { isTTY: stderr.isTTY },
-        },
-    }));
+    return args => {
+        const options = { args, env, std, testContext, bunTestContext, playwrightTestContext, engine };
+        return program => f(program(options));
+    };
 };

package/fs/io/module.js

@@ -15,6 +15,32 @@ import { once } from 'node:events';
 import { fromIo, runProgram } from "./module.f.js";
 import { error, ok } from "../types/result/module.f.js";
 import { fromVec } from "../types/uint8array/module.f.js";
+import * as testContext from 'node:test';
+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 {
+            await fn(inlineContext);
+        }
+        catch {
+            return;
+        }
+        throw new Error(`expected to throw: ${name}`);
+    }
+    else {
+        await fn(inlineContext);
+    }
+};
+const inlineContext = { test: inlineTest };
+const bunTestContext = {
+    test: (name, opts, fn) => testContext.test(name, () => inlineTest(name, opts, fn))
+};
+const playwrightTestContext = {
+    test: (name, opts, fn) => pwTest(name, () => inlineTest(name, opts, fn))
+};
 const prefix = 'file:///';
 const { now } = Date;
 /** Maps `WriteConsoles` names to the corresponding Node.js writable streams. */
@@ -89,6 +115,10 @@ export const io = {
         return { result, duration: after - before };
     },
     write: (stream, data) => writeAll(streams[stream], fromVec(data)),
+    testContext,
+    bunTestContext,
+    playwrightTestContext,
+    engine: isPlaywright ? 'playwright' : 'Bun' in globalThis ? 'bun' : 'node',
 };
 const effectRun = runProgram(io)(io.process.argv.slice(2));
 export default effectRun;

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

@@ -6,7 +6,7 @@
  * @module
  */
 import { toArray } from "../../types/list/module.f.js";
-import { length, listToVec, msb, uint, uintChunkList, unpack, vec } from "../../types/bit_vec/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 { utf8 } from "../../text/module.f.js";
 import { secp256r1 } from "../../crypto/secp/module.f.js";
@@ -77,9 +77,8 @@ export const isHash = (v) => asBase(v) >> hashPrefixOffset === 1n;
 export const hashId = (hash) => asNominal(hashPrefix | hash);
 const hash2 = base32.compress(iv);
 const vecX20 = vec(0x20n);
-const ltv = listToVec(msb);
-const hashMerge = (a, b) => hashId(uint(ltv(hash2((asBase(a) << 0x100n) | asBase(b)).map(vecX20))));
-const { concat } = msb;
+const { concat, listToVec } = msb;
+const hashMerge = (a, b) => hashId(uint(listToVec(hash2((asBase(a) << 0x100n) | asBase(b)).map(vecX20))));
 export const compress = (a, b) => {
     if (isHash(a) || isHash(b)) {
         return hashMerge(a, b);

package/fs/sul/level/literal/module.f.js

@@ -5,7 +5,7 @@
  * @module
  */
 import { log2 } from "../../../types/bigint/module.f.js";
-import { listToVec, msb, vec } from "../../../types/bit_vec/module.f.js";
+import { msb, vec } from "../../../types/bit_vec/module.f.js";
 import { strictEqual } from "../../../types/function/operator/module.f.js";
 import { equal, map } from "../../../types/list/module.f.js";
 import { join } from "../../../types/string/module.f.js";
@@ -73,12 +73,12 @@ export const pipelineStep = (bit, [l1s, l2s, l3s]) => {
     const [l3Out, newL3s] = l3.encode(l2Out, l3s);
     return [l3Out, [newL1s, newL2s, newL3s]];
 };
-const concat = listToVec(msb);
 const vec1 = vec(1n);
+const { listToVec } = msb;
 const literalToVec = (prior, e) => {
     const m = map(prior);
     const { decode } = level(e);
-    return literal => concat(m(decode(literal)));
+    return literal => listToVec(m(decode(literal)));
 };
 /** Decodes a level-1 symbol to its canonical MSB bit vector. */
 export const literal1ToVec = literalToVec(vec1, 0n);

package/fs/text/sgr/test.f.js

@@ -1,8 +1,23 @@
-import { fgRed } from "./module.f.js";
+import { fgRed, createConsoleText, backspace } from "./module.f.js";
 export default [
     () => {
         if (fgRed !== '\x1b[31m') {
             throw new Error('Test failed: sgr(0)');
         }
+    },
+    () => {
+        const output = [];
+        const stdout = { write: (s) => { output.push(s); } };
+        const writer1 = createConsoleText(stdout);
+        const writer2 = writer1('hello');
+        if (output[0] !== 'hello') {
+            throw output[0];
+        }
+        // replacing 'hello' (len=5) with 'hi' (len=2): suffixLength=3
+        writer2('hi');
+        const expected = backspace.repeat(5) + 'hi' + ' '.repeat(3) + backspace.repeat(3);
+        if (output[1] !== expected) {
+            throw output[1];
+        }
     }
 ];

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

@@ -146,6 +146,15 @@ export type BitOrder = {
      * ```
      */
     readonly concat: Reduce;
+    /**
+     * Folds a list of vectors into a single vector in this bit order.
+     *
+     * Unlike `concat`, which joins exactly two vectors, this joins a whole list.
+     *
+     * @returns The concatenation of every vector in the list, or `empty` when the
+     * list is empty.
+     */
+    readonly listToVec: (list: List<Vec>) => Vec;
     /**
      * Computes the bitwise exclusive OR of two vectors after normalizing their lengths.
      *
@@ -219,10 +228,6 @@ export declare const chunkList: (bo: BitOrder) => (n: bigint) => (v: Vec) => Thu
  * @returns A thunk that produces a list of unsigned 8-bit integers.
  */
 export declare const u8List: (bo: BitOrder) => (v: Vec) => Thunk<number>;
-/**
- * Concatenates a list of vectors using the provided bit order.
- */
-export declare const listToVec: ({ concat }: BitOrder) => (list: List<Vec>) => Vec;
 /**
  * Repeats a vector to create a padded block of the desired length.
  */

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

@@ -127,14 +127,16 @@ const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }
             return [uint, pack(u)];
         };
     };
+    const concat = a => b => {
+        const au = unpack(a);
+        const bu = unpack(b);
+        return pack(unpackConcat(au)(bu));
+    };
     return {
         front,
         removeFront,
-        concat: a => b => {
-            const au = unpack(a);
-            const bu = unpack(b);
-            return pack(unpackConcat(au)(bu));
-        },
+        concat,
+        listToVec: fold(flip(concat))(empty),
         xor: op(norm)(xor),
         unpackPopFront,
         popFront,
@@ -301,10 +303,6 @@ const vecToU8 = ({ unpackSplit }) => {
  * @returns A thunk that produces a list of unsigned 8-bit integers.
  */
 export const u8List = (bo) => (v) => map(vecToU8(bo))(chunkList(bo)(8n)(v));
-/**
- * Concatenates a list of vectors using the provided bit order.
- */
-export const listToVec = ({ concat }) => fold(flip(concat))(empty);
 /**
  * Repeats a vector to create a padded block of the desired length.
  */

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

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import type { TNode, Tree } from '../types/module.f.ts';
+import { type TNode, type Tree } from '../types/module.f.ts';
 import type { Compare } from '../../function/compare/module.f.ts';
 export declare const nodeRemove: <T>(c: Compare<T>) => (node: TNode<T>) => Tree<T>;
 export declare const remove: <T>(c: Compare<T>) => (tree: Tree<T>) => Tree<T>;

package/fs/types/btree/remove/module.f.js

@@ -1,3 +1,9 @@
+/**
+ * Removal operations for persistent B-tree structures.
+ *
+ * @module
+ */
+import { collapseRoot } from "../types/module.f.js";
 import { find } from "../find/module.f.js";
 import { fold, concat, next } from "../../list/module.f.js";
 import { map } from "../../nullable/module.f.js";
@@ -163,7 +169,6 @@ export const nodeRemove = (c) => (node) => {
         return first;
     }
     const { first: tf, tail: tt } = tailR;
-    const result = reduce(initReduce(tf)(first))(tt);
-    return result.length === 1 ? result[0] : result;
+    return collapseRoot(reduce(initReduce(tf)(first))(tt));
 };
 export const remove = c => map(nodeRemove(c));

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

@@ -3,6 +3,6 @@
  *
  * @module
  */
-import type { TNode, Tree } from '../types/module.f.ts';
+import { type TNode, type Tree } from '../types/module.f.ts';
 import type { Compare } from '../../function/compare/module.f.ts';
 export declare const set: <T>(c: Compare<T>) => (f: (value: T | null) => T) => (tree: Tree<T>) => TNode<T>;

package/fs/types/btree/set/module.f.js

@@ -1,3 +1,9 @@
+/**
+ * Insertion and update operations for persistent B-tree structures.
+ *
+ * @module
+ */
+import { collapseRoot } from "../types/module.f.js";
 import { find } from "../find/module.f.js";
 import { fold } from "../../list/module.f.js";
 const b57 = b => b.length === 5 ? [b] : [[b[0], b[1], b[2]], b[3], [b[4], b[5], b[6]]];
@@ -114,7 +120,6 @@ const nodeSet = (c) => (g) => (node) => {
             }
         }
     };
-    const r = reduceBranch(f())(tail);
-    return r.length === 1 ? r[0] : r;
+    return collapseRoot(reduceBranch(f())(tail));
 };
 export const set = c => f => tree => tree === null ? [f(null)] : nodeSet(c)(f)(tree);

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

@@ -12,3 +12,4 @@ export type TNode<T> = Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>;
 export type Tree<T> = TNode<T> | null;
 export type Branch1<T> = readonly [TNode<T>];
 export type Branch7<T> = readonly [...Branch5<T>, T, TNode<T>];
+export declare const collapseRoot: <T>(b: Branch1<T> | Branch3<T> | Branch5<T>) => TNode<T>;

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

@@ -1 +1 @@
-export {};
+export const collapseRoot = b => b.length === 1 ? b[0] : b;

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

@@ -116,7 +116,15 @@ export type Sandbox = readonly ['sandbox', <T>(f: () => T) => SandboxResult<T>];
  * @see {@link SandboxResult}
  */
 export declare const sandbox: Func<Sandbox>;
-export type NodeOp = All | Fetch | Fs | Http | Forever | Import | Now | Sandbox | Write;
+export type TestFn = (name: string, options: {
+    readonly expectFailure: boolean;
+}, fn: (t: TestContext) => Promise<void>) => Promise<void>;
+export type TestContext = {
+    readonly test: TestFn;
+};
+export type Test = readonly ['test', (ctx: TestContext, name: string, expectFailure: boolean, test: (t: TestContext) => Effect<Test | All, void>) => void];
+export declare const test: Func<Test>;
+export type NodeOp = All | Fetch | Fs | Http | Forever | Import | Now | Sandbox | Write | Test;
 export type NodeEffect<T> = Effect<NodeOp, T>;
 export type NodeOperationMap = ToAsyncOperationMap<NodeOp>;
 /**
@@ -125,6 +133,7 @@ export type NodeOperationMap = ToAsyncOperationMap<NodeOp>;
 export type Env = {
     readonly [k: string]: string | undefined;
 };
+export type Engine = 'node' | 'bun' | 'playwright';
 export type NodeProgramOptions = {
     readonly args: readonly string[];
     readonly env: Env;
@@ -133,6 +142,10 @@ export type NodeProgramOptions = {
             readonly isTTY: boolean;
         };
     };
+    readonly testContext: TestContext;
+    readonly bunTestContext: TestContext;
+    readonly playwrightTestContext: TestContext;
+    readonly engine: Engine;
 };
 export type Program<O extends Operation> = (options: NodeProgramOptions) => Effect<O, number>;
 export type NodeProgram = Program<NodeOp>;

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

@@ -61,3 +61,4 @@ export const now = do_('now');
  * @see {@link SandboxResult}
  */
 export const sandbox = do_('sandbox');
+export const test = do_('test');

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

@@ -10,8 +10,9 @@ import type { Module, NodeOp } from '../module.f.ts';
  * each import for closures/state.
  */
 export type JsModule = () => Module;
+export type Entity = Vec | Dir | JsModule;
 export type Dir = {
-    readonly [name in string]?: Dir | Vec | JsModule;
+    readonly [name in string]?: Entity;
 };
 export type State = {
     stdout: string;

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

@@ -167,6 +167,7 @@ const map = {
     // exception in a fixture propagates loudly as a bug in the fixture.
     // See: issues/156-tf-virtual-tests.md
     sandbox: (state, f) => [state, f()],
+    test: todo,
     write: (state, stream, data) => {
         const s = utf8ToString(data);
         return [{ ...state, [stream]: `${state[stream]}${s}` }, undefined];

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

@@ -1,4 +1,4 @@
-import { map, toOption } from "./module.f.js";
+import { map, match, toOption } from "./module.f.js";
 export default [
     () => {
         const optionSq = map((v) => v * v);
@@ -20,5 +20,14 @@ export default [
         if (opt2.length !== 0) {
             throw opt2;
         }
+    },
+    () => {
+        const double = match((v) => v * 2)(() => -1);
+        if (double(3) !== 6) {
+            throw double(3);
+        }
+        if (double(null) !== -1) {
+            throw double(null);
+        }
     }
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -9,17 +9,17 @@
   "description": "FunctionalScript is a purely functional subset of JavaScript",
   "scripts": {
     "prepack": "tsc --NoEmit false",
-    "test": "tsc && node --test --experimental-strip-types --experimental-test-coverage --test-coverage-include=**/module.f.ts",
+    "test": "tsc && node --test --experimental-test-coverage --test-coverage-include=**/module.f.ts",
     "index": "node ./fs/fjs/module.ts r ./fs/dev/index/module.f.ts",
     "fst": "node ./fs/fjs/module.ts t",
     "start": "node ./fs/fjs/module.ts",
     "ci-update": "node ./fs/fjs/module.ts r ./fs/ci/module.f.ts",
     "update": "npm install && npm run index && npm run ci-update",
-    "index-html": "node --experimental-strip-types ./fs/fjs/module.ts r ./fs/website/module.f.ts",
+    "index-html": "node ./fs/fjs/module.ts r ./fs/website/module.f.ts",
     "website": "npm run prepack &&npm run index-html"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "bin": {
     "fjs": "fs/fjs/module.js"