functionalscript 0.46.0 → 0.47.0

package/fjs/basen/cbase32/module.f.mjs

@@ -7,7 +7,7 @@
  * @import { Nullable } from '../../types/nullable/types.ts'
  */
 
-import { msb, lsb, length, vec, empty } from '../../types/bit_vec/module.f.mjs'
+import { msb, lsb, length, maxLength, vec, empty } from '../../types/bit_vec/module.f.mjs'
 import { baseN } from '../module.f.mjs'
 
 //                         0123456789abcdef
@@ -47,15 +47,23 @@ export const vecToCBase32 = v => {
 
 /** @type {(s: string) => Nullable<Vec>} */
 export const cBase32ToVec = s => {
-    let v = cBase32ToVec5x(s)
-    if (v === null) { return null }
-    // Strip the padding: trailing zeros up to and including the sentinel `1` bit.
-    // A string with no sentinel — only zero symbols (`0`/`o`), or empty — exhausts
-    // to `empty` and is rejected as `null` rather than looping forever.
-    while (v !== empty) {
-        const [last, rest] = popBack1(v)
-        v = rest
-        if (last === 1n) { return v }
+    // Locate the sentinel from the end one character at a time. This preserves
+    // accepted non-canonical spellings with trailing zero characters without
+    // ever materialising their padded body as one oversized vector.
+    for (let i = s.length - 1; i >= 0; i--) {
+        let tail = cBase32ToVec5x(s[i])
+        if (tail === null) { return null }
+        while (tail !== empty) {
+            const [last, rest] = popBack1(tail)
+            tail = rest
+            if (last === 1n) {
+                const head = cBase32ToVec5x(s.slice(0, i))
+                if (head === null || length(head) + length(rest) > maxLength) {
+                    return null
+                }
+                return concat(head)(rest)
+            }
+        }
     }
     return null
 }

package/fjs/basen/cbase32/proof.f.d.mts

@@ -7,4 +7,7 @@ export declare const proof: {
     unalignedBits: () => void;
     caseInsensitive: () => void;
     unterminated: () => void;
+    trailingZeroSymbols: () => void;
+    decodeAtMaxLengthSucceeds: () => void;
+    decodeOverflow: () => void;
 };

package/fjs/basen/cbase32/proof.f.mjs

@@ -2,7 +2,7 @@
  * @import { Vec } from '../../types/bit_vec/types.ts'
  */
 
-import { empty, vec } from '../../types/bit_vec/module.f.mjs'
+import { empty, maxLength, vec } from '../../types/bit_vec/module.f.mjs'
 import { cBase32ToVec, cBase32ToVec5x, vec5xToCBase32, vecToCBase32 } from './module.f.mjs'
 import { assertEq } from '../../asserts/module.f.mjs'
 
@@ -75,5 +75,27 @@ export const proof = {
         assertEq(cBase32ToVec("0"), null, 'single zero symbol must be null')
         assertEq(cBase32ToVec("00"), null, 'all-zero symbols must be null')
         assertEq(cBase32ToVec("o"), null, 'o (maps to 0) must be null')
-    }
+        assertEq(cBase32ToVec('u'), null, 'invalid trailing symbol must be null')
+        assertEq(cBase32ToVec('u8'), null, 'invalid symbol before sentinel must be null')
+        assertEq(cBase32ToVec('8u'), null, 'invalid symbol after sentinel must be null')
+    },
+    trailingZeroSymbols: () => {
+        assertEq(cBase32ToVec('g0'), empty)
+        assertEq(cBase32ToVec('80'), vec(1n)(0n))
+    },
+    decodeAtMaxLengthSucceeds: () => {
+        const value = vec(maxLength)(0n)
+        // Construct the boundary encoding directly. Encoding a `maxLength`
+        // vector exceeds Bun's own BigInt size limit while adding the stop
+        // bit, independently of this decoder regression.
+        const encoded = '0'.repeat(209_715) + '8'
+        assertEq(cBase32ToVec(encoded), value)
+    },
+    decodeOverflow: () => {
+        // Reject both an independently oversized head and a valid head whose
+        // retained tail would push the combined result over `maxLength`.
+        assertEq(cBase32ToVec('0'.repeat(209_717) + 'g'), null)
+        assertEq(cBase32ToVec('0'.repeat(209_715) + '4'), null)
+        assertEq(cBase32ToVec('0'.repeat(209_715) + '1'), null)
+    },
 }

package/fjs/basen/proof.f.mjs

@@ -4,15 +4,10 @@ import { baseN } from './module.f.mjs'
 
 const hex = baseN(4n, '0123456789abcdef')
 
-const cb32 = baseN(5n, '0123456789abcdefghjkmnpqrstvwxyz', c => {
-    const lower = c.toLowerCase()
-    switch (lower) {
-        case 'i': { return '1' }
-        case 'l': { return '1' }
-        case 'o': { return '0' }
-        default: { return lower }
-    }
-})
+// A synthetic normalizer keeps this proof focused on `baseN`'s mechanism
+// rather than duplicating the rules owned by a concrete codec.
+const normalizedHex = baseN(4n, '0123456789abcdef', c =>
+    c === 'x' ? 'a' : c === 'y' ? 'z' : c.toLowerCase())
 
 // Sample input for the `big` proof below: 262 144 `f` characters decode into a
 // 1 Mibit (`maxLength`) vector.
@@ -48,16 +43,13 @@ export const proof = {
     },
     normalizeHit: () => {
         // 'A' lowercases to 'a' — same vector as the lowercase input.
-        const a = cb32.stringToVec('A')
-        const b = cb32.stringToVec('a')
+        const a = normalizedHex.stringToVec('A')
+        const b = normalizedHex.stringToVec('a')
         assertEq(a, b, [a, b])
-        // Crockford folds: i,l → 1 and o → 0.
-        assertEq(cb32.stringToVec('I'), cb32.stringToVec('1'), 'I→1')
-        assertEq(cb32.stringToVec('l'), cb32.stringToVec('1'), 'l→1')
-        assertEq(cb32.stringToVec('o'), cb32.stringToVec('0'), 'o→0')
+        assertEq(normalizedHex.stringToVec('x'), a, 'x→a')
     },
     normalizeMiss: () => {
-        assertEq(cb32.stringToVec('u'), null, 'unknown char should return null')
+        assertEq(normalizedHex.stringToVec('y'), null, 'normalizing to an unknown char should return null')
     },
     // Decodes a 1 Mibit hex string. With the O(n log n) `listToVec` builder this
     // runs in well under a second (was ~13 s node / ~43 s bun under the old

package/fjs/bnf/ll1/proof.f.d.mts

@@ -3,6 +3,7 @@
  * @import { RuleSet } from '../data/types.ts'
  * @import { CodePointMeta } from '../descent/types.ts'
  * @import { Rule as FRule } from '../types.ts'
+ * @import { Match } from './types.ts'
  * @import { MatchResult } from './types.ts'
  */
 export declare const proof: {
@@ -28,4 +29,5 @@ export declare const proof: {
         leftRecursiveVariant: () => void;
     };
     cyclicNullability: () => void;
+    ssn: () => void;
 };

package/fjs/bnf/ll1/proof.f.mjs

@@ -3,12 +3,13 @@
  * @import { RuleSet } from '../data/types.ts'
  * @import { CodePointMeta } from '../descent/types.ts'
  * @import { Rule as FRule } from '../types.ts'
+ * @import { Match } from './types.ts'
  * @import { MatchResult } from './types.ts'
  */
 
 import { stringToCodePointList } from '../../text/utf16/module.f.mjs'
 import { map, toArray } from '../../types/list/module.f.mjs'
-import { commaJoin0Plus, eof, option, range, repeat0Plus, set } from '../module.f.mjs'
+import { commaJoin0Plus, eof, option, range, repeat, repeat0Plus, set } from '../module.f.mjs'
 import { toData } from '../data/module.f.mjs'
 import { descentParser } from '../descent/module.f.mjs'
 import { dispatchMap, parser, parserRuleSet } from './module.f.mjs'
@@ -18,6 +19,15 @@ import { deterministic, showAst } from '../testlib.f.mjs'
 /** @type {(cp: CodePoint) => CodePointMeta<unknown>} */
 const mapCodePoint = cp => [cp, undefined]
 
+/** @type {(mr: MatchResult) => boolean} */
+const isMatchSuccess = ([, success, remainder]) => success && remainder?.length === 0
+
+/** @type {(m: Match) => (s: string, success: boolean) => void} */
+const expectMatch = m => (s, success) => {
+    const mr = m('', toArray(stringToCodePointList(s)))
+    assertEq(isMatchSuccess(mr), success, mr)
+}
+
 /**
  * One grammar matched by both backends, which must build the same AST for it:
  * the shape is pinned once and asserted against each backend, so neither can
@@ -241,13 +251,7 @@ export const proof = {
         },
         () => {
             const m = parser(option('a'))
-
-            const isSuccess = (/** @type {MatchResult} */mr) => mr[1] && mr[2]?.length === 0
-            /** @type {(s: string, success: boolean) => void} */
-            const expect = (s, success) => {
-                const mr = m('', toArray(stringToCodePointList(s)))
-                assertEq(isSuccess(mr), success, mr)
-            }
+            const expect = expectMatch(m)
 
             expect('a', true)
             expect('', true)
@@ -268,12 +272,10 @@ export const proof = {
 
             const m = parser(value)
 
-            /** @type {(mr: MatchResult) => boolean} */
-            const isSuccess = mr => mr[1] && mr[2]?.length === 0
             /** @type {(s: string, success: boolean) => void} */
             const expect = (s, success) => {
                 const mr = m('value', toArray(stringToCodePointList(s)))
-                assertEq(isSuccess(mr), success, mr)
+                assertEq(isMatchSuccess(mr), success, mr)
             }
 
             expect('', false)
@@ -305,7 +307,7 @@ export const proof = {
             /** @type {(s: string) => void} */
             const expectNoMatch = s => {
                 const mr = ml(entry, toArray(stringToCodePointList(s)))
-                assertEq(mr[1] && mr[2]?.length === 0, false, s)
+                assertEq(isMatchSuccess(mr), false, s)
             }
 
             expectSameAst('   true   ')
@@ -570,12 +572,7 @@ export const proof = {
         const ws = option(' ')
         const value = () => ({ array: ['[', value, ']'], leaf: 'a' })
         const m = parser([ws, value, ws]) // must not throw 'can not merge'
-
-        /** @type {(s: string, success: boolean) => void} */
-        const expect = (s, success) => {
-            const mr = m('', toArray(stringToCodePointList(s)))
-            assertEq(mr[1] && mr[2]?.length === 0, success, mr)
-        }
+        const expect = expectMatch(m)
 
         expect('a', true)
         expect(' a ', true)
@@ -584,4 +581,22 @@ export const proof = {
         expect(' [[a]] ', true)
         expect('b', false)
     },
+    // A Social Security Number, `ddd-dd-dddd`.
+    ssn: () => {
+        const ws = repeat0Plus(' ')
+        const d = range('09')
+        const ssn = /** @type {const} */([
+            ws, repeat(3)(d), ws, '-', ws, repeat(2)(d), ws, '-', ws, repeat(4)(d), ws])
+
+        const m = parser(ssn) // must not throw 'can not merge'
+        const expect = expectMatch(m)
+
+        expect('123-45-6789', true)
+        expect('  123  - 45 - 6789 ', true)
+        expect('22', false) // too short
+        expect('123456789', false) // no dashes
+        expect('123-3456-78', false) // wrong grouping
+        expect('123-345-6789', false) // wrong grouping
+        expect('12a-34-5678', false) // a letter where a digit is required
+    }
 }

package/fjs/bnf/module.f.d.mts

@@ -106,9 +106,9 @@ export declare const none: None;
 /**
  * Creates an option value from a required branch.
  */
-export declare const option: <S extends Rule>(
+export declare const option: <const S extends Rule>(
 /**
- * @template {Rule} S
+ * @template {Rule} const S
  * @param {S} some
  * @returns {Option<S>}
  */

package/fjs/bnf/module.f.mjs

@@ -236,7 +236,7 @@ export const none = []
  */
 export const option =
     /**
-     * @template {Rule} S
+     * @template {Rule} const S
      * @param {S} some
      * @returns {Option<S>}
      */
@@ -261,7 +261,7 @@ export const repeat0Plus =
      * @returns {Repeat0Plus<T>}
      */
     some => {
-        const r = () => option(/** @type {const} */ ([some, r]))
+        const r = () => option([some, r])
         return r
     }
 

package/fjs/cas/proof.f.mjs

@@ -215,20 +215,9 @@ export const proof = {
         const hash = writeResult[1]
         assertEq(length(hash), 256n, ['expected 256-bit hash', length(hash)])
         assertEq(msb.cmp(hash)(computeSync(sha256)([content])), 0, 'write hash mismatch')
-        /** @type {(acc: readonly Vec[]) => (stream: List<FileCasOperation, Vec, IoChannel>) => Effect<FileCasOperation, readonly Vec[], IoChannel>} */
-        const drain = acc =>
-            stream =>
-                ioStep(
-                    stream,
-                    (node) => {
-                        if (node === undefined) { return pureOk(acc) }
-                        const { first, tail } = node
-                        return drain([...acc, first])(tail)
-                    },
-                )
-        const [, readResult] = virtual(state1)(drain([])(c.read(hash)))
+        const [, readResult] = virtual(state1)(collectRead(c.read(hash)))
         assert(readResult[0] === 'ok', ['expected read ok', readResult])
-        assertEq(msb.cmp(msb.listToVec(readResult[1]))(content), 0, 'read content mismatch')
+        assertEq(msb.cmp(readResult[1])(content), 0, 'read content mismatch')
     },
     casReadMissingShard: () => {
         // A missing shard fails the stream; it is never the `ok(undefined)` that
@@ -252,21 +241,10 @@ export const proof = {
         assert(writeResult[0] === 'ok', ['expected write ok', writeResult])
         const hash = writeResult[1]
         assertEq(msb.cmp(hash)(computeSync(sha256)(chunks)), 0, 'multi-chunk write hash mismatch')
-        /** @type {(acc: readonly Vec[]) => (stream: List<FileCasOperation, Vec, IoChannel>) => Effect<FileCasOperation, readonly Vec[], IoChannel>} */
-        const drain = acc =>
-            stream =>
-                ioStep(
-                    stream,
-                    (node) => {
-                        if (node === undefined) { return pureOk(acc) }
-                        const { first, tail } = node
-                        return drain([...acc, first])(tail)
-                    },
-                )
-        const [, readResult] = virtual(state1)(drain([])(c.read(hash)))
+        const [, readResult] = virtual(state1)(collectRead(c.read(hash)))
         assert(readResult[0] === 'ok', ['expected read ok', readResult])
         const expected = msb.concat(msb.concat(chunks[0])(chunks[1]))(chunks[2])
-        assertEq(msb.cmp(msb.listToVec(readResult[1]))(expected), 0, 'multi-chunk read content mismatch')
+        assertEq(msb.cmp(readResult[1])(expected), 0, 'multi-chunk read content mismatch')
     },
     casWriteDedup: () => {
         // Same content ⇒ same hash; the second upload's replace-`rename` publishes over the

package/fjs/ci/common/module.f.mjs

@@ -18,6 +18,12 @@ export const os = /** @type {const} */ (['ubuntu', 'macos', 'windows'])
 
 export const architecture = /** @type {const} */ (['intel', 'arm'])
 
+// These three are **closed**, which is the bare form's meaning and the right
+// one here: `parseGitHubAction` reads back a workflow this repo generates, so
+// a key the schema does not name is generator drift rather than a field a
+// third party added. Reading a hand-written workflow — which carries `name`,
+// `if`, `env` and much else — would need `open`.
+
 export const stepSchema = /** @type {const} */ ({
     run: option(string),
     uses: option(string),

package/fjs/ci/config/module.f.d.mts

@@ -18,20 +18,20 @@ export declare const images: {
         readonly arm: 'windows-11-arm';
     };
 };
-export declare const functionalscript = /** @type {const} */ "0.45.0";
-export declare const bun = "1.3.14";
+export declare const functionalscript = /** @type {const} */ "0.46.1";
+export declare const bun = "1.4.0";
 export declare const deno = "2.9.5";
 export declare const node: {
     readonly default: '26.7.0';
     readonly node22: '22.23.2';
-    readonly node24: '24.18.1';
+    readonly node24: '24.19.0';
 };
 export declare const nixpkgs: {
     readonly ref: 'nixos-26.05';
-    readonly commit: '02e08985a27c65ffd33d434eeb2e660a2e4dc84d';
+    readonly commit: 'f4f698677b11021a8f84f452e23ae9ef2427bec3';
 };
-export declare const wasmtime = "47.0.3";
-export declare const wasmer = "7.2.1";
+export declare const wasmtime = "48.0.1";
+export declare const wasmer = "7.3.0";
 export declare const actions: {
     readonly 'actions/checkout': 'v7.0.1';
     readonly 'actions/setup-node': 'v7.0.0';
@@ -41,5 +41,5 @@ export declare const actions: {
     readonly 'bytecodealliance/actions/wasmtime/setup': 'v1.1.3';
     readonly 'wasmerio/setup-wasmer': 'v3.1';
     readonly 'cachix/install-nix-action': 'v31.11.1';
-    readonly 'dtolnay/rust-toolchain': '1.97.1';
+    readonly 'dtolnay/rust-toolchain': '1.98.0';
 };

package/fjs/ci/config/module.f.mjs

@@ -25,10 +25,10 @@ export const images = /** @type {const} */({
 // published FunctionalScript release; do not tie it to package.json's current
 // in-repo version.
 // https://www.npmjs.com/package/functionalscript
-export const functionalscript = /** @type {const} */ '0.45.0'
+export const functionalscript = /** @type {const} */ '0.46.1'
 
 // https://bun.sh/
-export const bun = '1.3.14'
+export const bun = '1.4.0'
 
 // https://deno.com/
 export const deno = '2.9.5'
@@ -43,7 +43,7 @@ export const deno = '2.9.5'
 export const node = /** @type {const} */({
     default: '26.7.0',
     node22: '22.23.2',
-    node24: '24.18.1',
+    node24: '24.19.0',
 })
 
 // Official Nixpkgs snapshot used by the generated CI flakes. `ref` is the
@@ -53,14 +53,14 @@ export const node = /** @type {const} */({
 // https://channels.nixos.org/nixos-26.05/git-revision
 export const nixpkgs = /** @type {const} */({
     ref: 'nixos-26.05',
-    commit: '02e08985a27c65ffd33d434eeb2e660a2e4dc84d',
+    commit: 'f4f698677b11021a8f84f452e23ae9ef2427bec3',
 })
 
 // https://github.com/bytecodealliance/wasmtime/releases
-export const wasmtime = '47.0.3'
+export const wasmtime = '48.0.1'
 
 // https://github.com/wasmerio/wasmer/releases
-export const wasmer = '7.2.1'
+export const wasmer = '7.3.0'
 
 // GitHub Action versions used by CI step builders. The key is the action
 // `owner/name`; call sites compose the full ref as
@@ -85,5 +85,5 @@ export const actions = /** @type {const} */({
     // Enables the `nix-command` and `flakes` experimental features by default.
     'cachix/install-nix-action': 'v31.11.1',
     // https://rust-lang.org/ - value is Rust version, not action version
-    'dtolnay/rust-toolchain': '1.97.1',
+    'dtolnay/rust-toolchain': '1.98.0',
 })

package/fjs/cli/module.f.mjs

@@ -14,19 +14,23 @@ import { at, fromEntries } from '../types/object/module.f.mjs'
 
 const helpMeta = { names: ['help', 'h', '?'], description: 'Print this help message' }
 
-/** @type {<O extends NodeOp>(commands: Commands<O>) => Program<O | Write>} */
-export const dispatch = commands => options => {
-    const [cmd, ...rest] = options.args
+/** @type {<O extends NodeOp>(commands: Commands<O>) => string} */
+const renderHelp = commands => {
     const rows = [...commands, helpMeta]
-    const nameCol = rows.map(({names}) => names.join(', '))
-    const width = Math.max(...nameCol.map(({length}) => length))
-    const helpText = [
+    const nameCol = rows.map(({ names }) => names.join(', '))
+    const width = Math.max(...nameCol.map(({ length }) => length))
+    return [
         'Available commands:',
-        ...rows.map(({description}, i) => `  ${nameCol[i].padEnd(width)}  ${description}`)
+        ...rows.map(({ description }, i) => `  ${nameCol[i].padEnd(width)}  ${description}`)
     ].join('\n')
+}
+
+/** @type {<O extends NodeOp>(commands: Commands<O>) => Program<O | Write>} */
+export const dispatch = commands => options => {
+    const [cmd, ...rest] = options.args
     const map = fromEntries(commands.flatMap(c => c.names.map(n => /** @type {const} */ ([n, c]))))
     if (cmd === undefined) {
-        return errorExit(`Error: command is required.\n${helpText}`)
+        return errorExit(`Error: command is required.\n${renderHelp(commands)}`)
     }
     if (helpMeta.names.includes(cmd)) {
         const [target] = rest
@@ -36,11 +40,11 @@ export const dispatch = commands => options => {
                 return dispatch(targetCmd.handler)({ ...options, args: ['help'] })
             }
         }
-        return exitStep(log(helpText))
+        return exitStep(log(renderHelp(commands)))
     }
     const found = at(cmd)(map)
     if (found === null) {
-        return errorExit(`Error: unknown command "${cmd}".\n${helpText}`)
+        return errorExit(`Error: unknown command "${cmd}".\n${renderHelp(commands)}`)
     }
     const { handler } = found
     return (typeof handler === 'function' ? handler : dispatch(handler))({ ...options, args: rest })

package/fjs/crypto/vdf/module.f.d.mts

@@ -18,7 +18,6 @@
  *
  * @import { PrimeField } from '../../types/prime_field/types.ts'
  * @import { Nullable } from '../../types/nullable/types.ts'
- * @import { Unary } from '../../types/bigint/types.ts'
  * @import { Sloth } from './types.ts'
  */
 import type { Sloth } from './types.ts';

package/fjs/crypto/vdf/module.f.mjs

@@ -18,27 +18,16 @@
  *
  * @import { PrimeField } from '../../types/prime_field/types.ts'
  * @import { Nullable } from '../../types/nullable/types.ts'
- * @import { Unary } from '../../types/bigint/types.ts'
  * @import { Sloth } from './types.ts'
  */
 
+import { iterate } from '../../types/function/module.f.mjs'
 import { modSqrt, prime_field } from '../../types/prime_field/module.f.mjs'
 
 /** Sloth VDF modulus (3072-bit safe prime, same as reference implementations). */
 export const p =
     0xf2346eae06a23388_2814ff16f6a076d3_b8f2161c5c92171c_0b7b84eed4e9475b_cce0c13bde34512a_fdf90f41ab9b86dc_f834f85e04b27fad_ee712eed23a1d4e5_8cd1b09d9bfb1069_6d614f119179a40c_49dc8762edc29e81_15263913237e1471_8cbcd4dc6b35bace_13f8cdb1b5156c50_c47b4aaee0820c87_4e2864cb854367c3n
 
-/** @type {(steps: bigint) => (f: Unary) => (value: bigint) => bigint} */
-const repeatSeq = steps => f => value => {
-    let v = value
-    let i = 0n
-    while (i < steps) {
-        v = f(v)
-        i = i + 1n
-    }
-    return v
-}
-
 /**
  * Builds Sloth VDF operations over `modulus`.
  *
@@ -52,11 +41,11 @@ export const sloth_vdf = modulus => {
 
     /** @type {(steps: bigint) => (value: bigint) => bigint} */
     const squareLoop = steps => value =>
-        repeatSeq(steps)(pow2)(reduce(value))
+        iterate(steps)(reduce(value))(pow2)
 
     /** @type {(steps: bigint) => (value: bigint) => bigint} */
     const modSqrtLoop = steps => value =>
-        repeatSeq(steps)(root)(reduce(value))
+        iterate(steps)(reduce(value))(root)
 
     /** @type {(steps: bigint) => (x: bigint) => Nullable<bigint>} */
     const evalSteps = steps => x =>

package/fjs/dev/module.f.mjs

@@ -11,6 +11,7 @@
 
 import { allOk, import_, readdir } from '../effects/node/module.f.mjs'
 import { cmp as strCmp } from '../types/string/module.f.mjs'
+import { fromEntries } from '../types/object/module.f.mjs'
 import { unwrap } from '../types/result/module.f.mjs'
 import { mapStep, pureOk, step } from '../effects/module.f.mjs'
 import { join, relativize, toPosix } from '../path/module.f.mjs'
@@ -55,24 +56,14 @@ const allFiles = (s, predicate) => {
     const load = p => {
         const listed = step(
             readdir(p, {}),
-            d => {
-                /** @type {readonly Effect<Readdir | All, readonly string[], IoChannel>[]} */
-                let result = []
-                for (const i of d) {
-                    const { name } = i
-                    if (name.startsWith('.')) { continue }
-                    const file = join(p, name)
-                    if (!i.isFile) {
-                        if (name === 'node_modules') { continue }
-                        result = [...result, load(file)]
-                        continue
-                    }
-                    if (predicate(file)) {
-                        result = [...result, pureOk([file])]
-                    }
-                }
-                return allOk(...result)
-            })
+            d => allOk(...d.flatMap(i => {
+                const { name } = i
+                if (name.startsWith('.')) { return [] }
+                const file = join(p, name)
+                return i.isFile
+                    ? (predicate(file) ? [pureOk([file])] : [])
+                    : (name === 'node_modules' ? [] : [load(file)])
+            })))
         return mapStep(listed, v => v.flat())
     }
     return load(s)
@@ -82,8 +73,6 @@ const allFiles = (s, predicate) => {
 const loadFile = f =>
     mapStep(import_(f), m => [/** @type {const} */ ([f, m])])
 
-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
@@ -142,6 +131,7 @@ export const proof = {
         // still skipped.
         /** @type {Dir} */
         const root = {
+            '.hidden.f.ts': [],
             'a.f.ts': [],
             'b.f.mjs': [],
             'c.f.mts': [],