functionalscript 0.19.0 → 0.20.0

package/fs/asn.1/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     encodeSmall: () => void;
     encode7F: () => void;
     encode80: () => void;
@@ -41,4 +41,3 @@ declare const _default: {
     };
     raw: (() => void)[];
 };
-export default _default;

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

@@ -45,7 +45,7 @@ const ch = (r, v) => {
     ch0(r, v, vec8(0x23n));
     ch0(r, v, vec(16n)(0x2345n));
 };
-export default {
+export const proof = {
     encodeSmall: () => {
         const v = vec8(0x13n);
         const x = encodeRaw([integer, v]);

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

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

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

@@ -14,7 +14,7 @@ const test = (a, b) => {
         throw `rest: ${asBase(rest).toString(16)}, expected: ${asBase(empty).toString(16)}`;
     }
 };
-export default () => {
+export const proof = () => {
     test(0n, vec8(0n));
     test(1n, vec8(1n));
     test(0x7fn, vec8(0x7fn));

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

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     rangeDecode: () => void;
     rangeEncode: () => void;
     toData: (() => void)[];
@@ -12,4 +12,3 @@ declare const _default: {
     repeatParser: (() => void)[];
     example: () => void;
 };
-export default _default;

package/fs/bnf/data/{test.f.js → proof.f.js}

@@ -11,7 +11,7 @@ const descentParserCpOnly = (m, name, cp) => {
     const cpm = toArray(map(mapCodePoint)(cp));
     return m(name, cpm);
 };
-export default {
+export const proof = {
     rangeDecode: () => {
         const decoded1 = stringify(sort)(rangeDecode(0x000079_000087));
         if (decoded1 !== '[121,135]') {

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

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

package/fs/bnf/{test.f.js → proof.f.js}

@@ -1,5 +1,5 @@
 import { classic, deterministic } from "./testlib.f.js";
-export default {
+export const proof = {
     test: () => {
         classic();
         deterministic();

package/fs/cas/module.f.js

@@ -6,7 +6,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, pure } from "../types/effects/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 { toOption } from "../types/nullable/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
@@ -111,17 +111,7 @@ export const main = (args) => {
         case 'list': {
             return begin
                 .step(() => c.list())
-                .step(v => {
-                // TODO: make it lazy.
-                let i = begin;
-                for (const j of v) {
-                    const prev = i;
-                    i = begin
-                        .step(() => prev)
-                        .step(() => log(vecToCBase32(j)));
-                }
-                return i;
-            })
+                .step(forEachStep(j => log(vecToCBase32(j))))
                 .step(() => pure(0));
         }
         case undefined: {

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

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

package/fs/cas/proof.f.js

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

package/fs/cbase32/{test.f.d.ts → proof.f.d.ts}

@@ -1,7 +1,6 @@
-declare const _default: {
+export declare const proof: {
     roundtrip5x: () => void;
     roundtrip: () => void;
     unalignedBits: () => void;
     caseInsensitive: () => void;
 };
-export default _default;

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

@@ -22,7 +22,7 @@ const check = (s, v) => {
         throw [vr, v];
     }
 };
-export default {
+export const proof = {
     roundtrip5x: () => {
         check5x("", empty);
         check5x("0", vec(5n)(0n));

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

@@ -8,20 +8,25 @@ import { node, tsgo } from "../config/module.f.js";
 import { clean, findTgz, 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)),
+const nodeInstall = (v) => [
+    install(installNode(v)),
     test({ run: 'npm ci' }),
+];
+export const basicNode = (version) => (extra) => clean([
+    ...nodeInstall(version),
     ...extra,
 ]);
-export const nodeTests = (version) => (extra) => basicNode(version)([
-    test({ run: 'npm test' }),
+const basicTests = [
+    test({ run: 'npm t' }),
     test({ run: 'npm run fst' }),
+];
+export const nodeTests = (version) => (extra) => basicNode(version)([
+    ...basicTests,
     ...extra,
 ]);
 const nodeSteps = (v) => [
-    install(installNode(v)),
-    test({ run: 'npm ci' }),
-    test({ run: 'npm t' }),
+    ...nodeInstall(v),
+    ...basicTests,
 ];
 export const nodeVersions = Object.fromEntries(node.others.map(v => [
     `node${major(v)}`,

package/fs/ci/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     rust: () => void;
     noRust: () => void;
     extra: {
@@ -6,4 +6,3 @@ declare const _default: {
         osSpecific: () => void;
     };
 };
-export default _default;

package/fs/ci/{test.f.js → proof.f.js}

@@ -23,7 +23,7 @@ const run = (rust, nodeExtra = () => []) => {
     assert(isVec(file), file);
     return unwrap(parseGitHubAction(jsonParse(utf8ToString(file))));
 };
-export default {
+export const proof = {
     rust: () => {
         assert(hasRun('cargo')(run(true)), 'expected Rust steps');
     },

package/fs/crypto/hmac/{test.f.d.ts → proof.f.d.ts}

@@ -1,7 +1,6 @@
-declare const _default: {
+export declare const proof: {
     example: () => void;
     sha256: () => void;
     sha384: () => void;
     sha512: () => void;
 };
-export default _default;

package/fs/crypto/hmac/{test.f.js → proof.f.js}

@@ -2,7 +2,7 @@ import { utf8 } from "../../text/module.f.js";
 import { uint, vec } from "../../types/bit_vec/module.f.js";
 import { sha256, sha384, sha512 } from "../sha2/module.f.js";
 import { hmac } from "./module.f.js";
-export default {
+export const proof = {
     example: () => {
         const r = hmac(sha256)(utf8('key'))(utf8('The quick brown fox jumps over the lazy dog'));
         if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) {

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

@@ -1,8 +1,7 @@
-declare const _default: {
+export declare const proof: {
     example: () => void;
     test: () => void;
     poker: () => {
         [k: string]: () => void;
     };
 };
-export default _default;

package/fs/crypto/secp/{test.f.js → proof.f.js}

@@ -53,7 +53,7 @@ const poker = (param) => () => {
         ++m;
     }
 };
-export default {
+export const proof = {
     example: () => {
         const curveParams = {
             p: 23n,

package/fs/crypto/sha2/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     base: {
         b32: () => {
             s256: () => void;
@@ -28,4 +28,3 @@ declare const _default: {
         overflow: () => void;
     };
 };
-export default _default;

package/fs/crypto/sha2/{test.f.js → proof.f.js}

@@ -12,7 +12,7 @@ const checkEmpty = ({ init, end, hashLength }) => (x) => {
 // https://en.wikipedia.org/wiki/SHA-2#Test_vectors
 //
 // https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing
-export default {
+export const proof = {
     base: {
         b32: () => {
             const { fromV8, compress, chunkLength } = base32;

package/fs/crypto/sign/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     bits2int: () => void;
     int2octets: () => void;
     bit2octets: () => void;
@@ -9,4 +9,3 @@ declare const _default: {
     a2: () => void;
     a2s: () => void;
 };
-export default _default;

package/fs/crypto/sign/{test.f.js → proof.f.js}

@@ -13,7 +13,7 @@ const v256 = vec(256n);
 const v600 = vec(600n);
 const r32 = repeat(32n);
 const hmac256 = hmac(sha256);
-export default {
+export const proof = {
     bits2int: () => {
         if (all(7n).bits2int(vec(5n)(20n)) !== 5n) {
             throw new Error("fail");

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

@@ -10,14 +10,40 @@ 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;
+    readonly proof?: unknown;
     readonly [k: string]: unknown;
 };
 export type ModuleMap = {
     readonly [k in string]: Module;
 };
 export declare const env: (io: Io) => (v: string) => string | undefined;
-export declare const allFiles: (s: string) => Effect<Readdir | All, readonly string[]>;
+/**
+ * Returns `true` if the file should be loaded for proof discovery.
+ *
+ * All FunctionalScript modules (`.f.ts` / `.f.js`) are safe to bulk-load by
+ * construction — they have no import side effects. For vanilla TS/JS the
+ * load gate stays opt-in by filename: any file ending in `proof.ts`,
+ * `proof.js`, `proof.mts`, or `proof.mjs` is included.
+ *
+ * Whether a loaded module actually _contains_ a proof is determined at
+ * runtime by checking for an exported `proof` property.
+ */
+export declare const shouldLoad: (s: string) => boolean;
+/** The effect operations required to discover and load a module map. */
 export type LoadModuleOperations = Access | Import | All | Readdir;
+/**
+ * Discovers all source files under `INIT_CWD` (or `.` if unset) that match
+ * `predicate`, imports them, and returns a map from relative path to module
+ * exports.
+ *
+ * The `predicate` is propagated into `allFiles` so that non-matching files
+ * are excluded before any `import()` is attempted — no wasted I/O.
+ * The default matches all JS/TS source files (`.js`, `.ts`, `.mts`, `.mjs`).
+ * `loadFile`'s own guards (`.f.js`, `.f.ts`, `shouldLoad`) still apply on
+ * top; the predicate only controls which files are discovered.
+ *
+ * The result is sorted by path key using `string.cmp` so the order is
+ * deterministic regardless of filesystem traversal order.
+ */
 export declare const loadModuleMap: (env: Env) => Effect<LoadModuleOperations, ModuleMap>;
 export declare const index4: NodeProgram;

package/fs/dev/module.f.js

@@ -1,5 +1,6 @@
 import { updateVersion } from "./version/module.f.js";
 import { access, all, both, import_, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
+import { cmp as strCmp } from "../types/string/module.f.js";
 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";
@@ -13,14 +14,28 @@ export const assert = (v, msg = 'assertion failed') => {
         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);
     return r === undefined ? undefined :
         typeof r.get === 'function' ? r.get() :
             r.value;
 };
-export const allFiles = (s) => {
+/**
+ * Returns `true` if the file should be loaded for proof discovery.
+ *
+ * All FunctionalScript modules (`.f.ts` / `.f.js`) are safe to bulk-load by
+ * construction — they have no import side effects. For vanilla TS/JS the
+ * load gate stays opt-in by filename: any file ending in `proof.ts`,
+ * `proof.js`, `proof.mts`, or `proof.mjs` is included.
+ *
+ * Whether a loaded module actually _contains_ a proof is determined at
+ * runtime by checking for an exported `proof` property.
+ */
+export const shouldLoad = (s) => s.endsWith('.f.ts') || s.endsWith('.f.js') ||
+    s.endsWith('proof.ts') || s.endsWith('proof.js') ||
+    s.endsWith('proof.mts') || s.endsWith('proof.mjs');
+const isSourceFile = (path) => path.endsWith('.js') || path.endsWith('.ts') || path.endsWith('.mts') || path.endsWith('.mjs');
+const allFiles = (s, predicate) => {
     const load = (p) => begin
         .step(() => readdir(p, {}))
         .step(d => {
@@ -38,7 +53,7 @@ export const allFiles = (s) => {
                 result = [...result, load(file)];
                 continue;
             }
-            if (name.endsWith('.js') || name.endsWith('.ts')) {
+            if (predicate(file)) {
                 result = [...result, pure([file])];
             }
         }
@@ -47,18 +62,22 @@ export const allFiles = (s) => {
         .step(v => pure(v.flat()));
     return load(s);
 };
-const loadFile = (f) => {
-    const doImport = import_(f).step(r => pure([[f, unwrap(r)]]));
-    if (f.endsWith('.f.js')) {
-        return doImport;
-    }
-    if (f.endsWith('.f.ts')) {
-        return access(f.substring(0, f.length - 3) + '.js')
-            .step(r => r[0] === 'ok' ? pure([]) : doImport);
-    }
-    return pure([]);
-};
+const loadFile = (f) => import_(f).step(r => pure([[f, unwrap(r)]]));
 const { fromEntries } = Object;
+/**
+ * Discovers all source files under `INIT_CWD` (or `.` if unset) that match
+ * `predicate`, imports them, and returns a map from relative path to module
+ * exports.
+ *
+ * The `predicate` is propagated into `allFiles` so that non-matching files
+ * are excluded before any `import()` is attempted — no wasted I/O.
+ * The default matches all JS/TS source files (`.js`, `.ts`, `.mts`, `.mjs`).
+ * `loadFile`'s own guards (`.f.js`, `.f.ts`, `shouldLoad`) still apply on
+ * top; the predicate only controls which files are discovered.
+ *
+ * The result is sorted by path key using `string.cmp` so the order is
+ * deterministic regardless of filesystem traversal order.
+ */
 export const loadModuleMap = (env) => {
     const initCwd = env['INIT_CWD'];
     const s = initCwd === undefined ? '.' : `${initCwd.replaceAll('\\', '/')}`;
@@ -67,24 +86,21 @@ export const loadModuleMap = (env) => {
     //       we should consider optimize them by ALIQ technique or something similar.
     //       For example, we should be able to write it like `allFiles(s).flatMap(loadFile)`,
     //       then an effect runner can batch all file loading operations together.
-    return allFiles(s)
+    return allFiles(s, shouldLoad)
         .step(files => all(...files.map(loadFile)))
         .step(entries => pure(fromEntries(entries
         .flat()
         .map(([k, v]) => [relativize(prefix, k), v])
-        .toSorted(cmp))));
+        .toSorted(([a], [b]) => strCmp(a)(b)))));
 };
 const denoJson = './deno.json';
 const parseDenoJson = rttiParse(record(rttiUnknown));
-const index2 = begin
-    .step(() => updateVersion)
+const index2 = updateVersion
     .step(() => readFile(denoJson))
     .step(v => pure(unwrap(parseDenoJson(jsonParse(utf8ToString(unwrap(v)))))));
-const allFiles2aa = begin
-    .step(() => allFiles('.'))
+const allFiles2aa = allFiles('.', v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'))
     .step(files => {
-    const list = files.filter(v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'));
-    const exportsA = list.map(v => [v, `./${v.substring(2)}`]);
+    const exportsA = files.map(v => [v, `./${v.substring(2)}`]);
     return pure(Object.fromEntries(exportsA));
 });
 const index3 = both(index2)(allFiles2aa)

package/fs/dev/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,7 @@
-declare const _default: {
+export declare const proof: {
+    shouldPass: () => {
+        then: () => undefined;
+    };
     ctor: () => void;
     ctorEmpty: () => void;
     ctorUndefined: () => void;
@@ -6,5 +9,5 @@ declare const _default: {
     properties: () => void;
     getOwnPropertyDescriptor: () => void;
     throw: () => void;
+    env: () => void;
 };
-export default _default;

package/fs/dev/{test.f.js → proof.f.js}

@@ -1,5 +1,8 @@
-import { todo } from "./module.f.js";
-export default {
+import { todo, env } from "./module.f.js";
+export const proof = {
+    shouldPass: () => ({
+        then: () => undefined
+    }),
     ctor: () => {
         const c = (() => { })['constructor'];
         const f = c('return 5');
@@ -52,5 +55,25 @@ export default {
     },
     throw: () => {
         todo();
+    },
+    env: () => {
+        const mockIo = { process: { env: { MY_VAR: 'hello' } } };
+        // missing key → undefined
+        const r1 = env(mockIo)('MISSING');
+        if (r1 !== undefined) {
+            throw r1;
+        }
+        // regular value property → returns value
+        const r2 = env(mockIo)('MY_VAR');
+        if (r2 !== 'hello') {
+            throw r2;
+        }
+        // getter property → calls get()
+        const envWithGetter = Object.defineProperty({}, 'GETTER_VAR', { get: () => 'from-getter', enumerable: true, configurable: true });
+        const mockIo2 = { process: { env: envWithGetter } };
+        const r3 = env(mockIo2)('GETTER_VAR');
+        if (r3 !== 'from-getter') {
+            throw r3;
+        }
     }
 };

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

@@ -1,13 +1,33 @@
-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 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';
-export declare const isTest: (s: string) => boolean;
+/** A zero-argument test function whose return value may contain sub-tests. */
 export type TestFn = () => unknown;
+/**
+ * A leaf test bundled with its throw expectation.
+ *
+ * `throws: true` means the test is expected to throw; the runner inverts the
+ * `sandbox` result so a caught error becomes a pass and a clean return becomes
+ * a failure. Using a record instead of a wrapper function avoids a double
+ * `sandbox` call and gives accurate per-test timing.
+ */
 export type TestEntry = {
     readonly fn: TestFn;
     readonly throws: boolean;
 };
+/**
+ * Either a leaf `TestEntry` (function + throw flag) or a named sub-tree of
+ * `[key, value]` pairs to recurse into. Discriminate with `Array.isArray`.
+ */
 export type TestSet = TestEntry | readonly (readonly [string, unknown])[];
+/**
+ * Converts an arbitrary JS value into a `TestSet`.
+ *
+ * - Zero-argument functions become a `TestEntry`; the `throws` flag is set if
+ *   `throws` is already `true` or the function's `.name === 'throw'`.
+ * - Non-null objects become an array of `[key, value]` pairs to recurse into.
+ * - All other values (including functions with parameters) produce an empty array.
+ */
 export declare const parseTestSet: (throws: boolean, x: unknown) => TestSet;
 type TestAndPath = readonly [Path, TestEntry];
 /**
@@ -30,12 +50,38 @@ 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>;
+/**
+ * Registers all tests reachable from module export `v` (keyed by `k`) with
+ * the given `TestContext`.
+ *
+ * Unlike `runModule`, which sandboxes only the leaf function, `registerModule`
+ * lets the external framework own scheduling: each registered test callback
+ * calls `fn`, then recursively registers any sub-trees returned by the function.
+ * This is the correct model for Node `--test`, Bun, and Playwright, where tests
+ * must be declared upfront and the framework drives execution.
+ */
+export declare const registerModule: (ctx: TestContext, k: string, v: unknown) => 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,
+ * 1 = at least one failure).
+ */
 export declare const runModuleMap: <O extends Operation>(reporter: Reporter<O>) => (moduleMap: ModuleMap) => Effect<O | All, number>;
+/**
+ * Discovers all test modules via `loadModuleMap`, then runs them through
+ * `runModuleMap`. The composed effect is a `NodeProgram` entry point for the
+ * `fjs t` test runner.
+ */
 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>;
+/**
+ * A chain of property-access keys leading to a test location. String entries
+ * are object/array keys; `null` marks a function-call boundary (the return
+ * value was walked as a sub-tree).
+ */
 export type Path = readonly (string | null)[];
+/** Returns `true` if `s` is a non-negative decimal integer without a leading zero. */
 export declare const isInteger: (s: string) => boolean;
+/** Returns `true` if `s` is a valid JS identifier (ASCII subset: `[A-Za-z_$][A-Za-z0-9_$]*`). */
 export declare const isIdentifier: (s: string) => boolean;
 /**
  * Renders a key chain as a JS property-access expression: identifier keys use
@@ -46,7 +92,7 @@ export declare const isIdentifier: (s: string) => boolean;
 export declare const fmtPath: (path: Path) => string;
 /**
  * Formats a fully-qualified test identifier as a JS-like expression, e.g.
- * `import("./math.test.f.ts").add()` or `import("./a.test.f.ts").users[3].name()`.
+ * `import("./math.proof.f.ts").add()` or `import("./a.proof.f.ts").users[3].name()`.
  * Self-contained per line — suitable for parallel output and as a CLI filter argument.
  */
 export declare const fmtImport: (file: string, path: Path) => string;
@@ -63,6 +109,10 @@ export declare const fmtTerm: (path: Path) => string;
  * https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
  */
 export declare const ghEscape: (s: string) => string;
+/**
+ * Default `Reporter.test` implementation: sandboxes `fn` once and inverts the
+ * result when `throws` is `true` (caught error → pass, clean return → fail).
+ */
 export declare const defaultTest: (file: string, path: Path, { fn, throws }: TestEntry) => Effect<Sandbox, SandboxResult<unknown>>;
 /**
  * The terminal/GitHub reporter used by `fjs t`. Output goes through
@@ -72,6 +122,14 @@ export declare const defaultTest: (file: string, path: Path, { fn, throws }: Tes
  * GitHub format path can be exercised directly from tests.
  */
 export declare const defaultReporter: (options: NodeProgramOptions) => Reporter<Write | Sandbox>;
+/** The `fjs t` entry point: runs all tests using `defaultReporter`. */
 export declare const main: NodeProgram;
+/**
+ * Entry point for external test frameworks (Node `--test`, Bun, Playwright).
+ *
+ * Discovers test modules via `loadModuleMap`, then registers each with the
+ * framework-appropriate `TestContext` selected from `NodeProgramOptions`
+ * based on the detected `engine`.
+ */
 export declare const register: NodeProgram;
 export {};