functionalscript 0.19.0 → 0.21.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/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/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,8 +6,8 @@
 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 { error, log, mkdir, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
+import { begin, forEachStep, pure } from "../types/effects/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));
@@ -111,23 +107,13 @@ 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: {
-            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

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

package/fs/cas/proof.f.js

@@ -0,0 +1,37 @@
+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/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/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,23 +5,28 @@
  * @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 } });
-export const basicNode = (version) => (extra) => clean([
-    install(installNode(version)),
+const installNode = (version) => uses('actions/setup-node', { 'node-version': 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/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/{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}

@@ -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";
@@ -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/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/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

@@ -6,18 +6,41 @@
 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 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;