functionalscript 0.18.0 → 0.20.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.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}

@@ -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]);
@@ -46,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]);
@@ -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/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/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/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/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/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;