functionalscript 0.45.0 → 0.46.1

package/fjs/emergent_testing/proof.f.mjs

@@ -1,26 +1,28 @@
 /**
- * @import { Effect } from '../effects/types.ts'
- * @import { NodeProgramOptions, Sandbox, Write } from '../effects/node/types.ts'
+ * @import { RunInstance } from '../effects/mock/types.ts'
+ * @import { Effect, NotImplemented } from '../effects/types.ts'
+ * @import { NodeProgramOptions, OpResult, Sandbox, Write } from '../effects/node/types.ts'
  * @import { JsModule } from '../effects/node/virtual/types.ts'
  * @import { Reporter } from './types.ts'
- * @import { All, Await, Test, TestContext } from '../effects/node/types.ts'
+ * @import { All, Await, Import, Readdir, Test, TestContext } from '../effects/node/types.ts'
  * @import { Ts } from '../types/rtti/ts/types.ts'
  */
 
+import { exitCode } from '../effects/node/module.f.mjs'
 import { log } from '../effects/node/module.f.mjs'
 import { defaultNodeProgramOptions, emptyState, virtual } from '../effects/node/virtual/module.f.mjs'
-import { assert, assertEq } from '../asserts/module.f.mjs'
+import { assert, assertEq, todo } from '../asserts/module.f.mjs'
 import {
     testAll, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier,
     registerModule, parseTestSet,
-    defaultTest, main,
+    defaultTest, main, register,
 } from './module.f.mjs'
 import { run as mockRun } from '../effects/mock/module.f.mjs'
 import { shouldLoad } from '../dev/module.f.mjs'
 import { parse as parseJson } from '../media/json/module.f.mjs'
 import { array, number as rttiNumber, or, string as rttiString } from '../types/rtti/module.f.mjs'
 import { parse as rttiParse } from '../types/rtti/parse/module.f.mjs'
-import { unwrap } from '../types/result/module.f.mjs'
+import { error, ok, unwrap } from '../types/result/module.f.mjs'
 
 /**
  * The mock reporter's stdout lines. A schema rather than a hand-written type:
@@ -43,7 +45,7 @@ const parseEvent = rttiParse(event)
 
 /** @typedef {Reporter<Sandbox | Write>} _TestReporter */
 
-/** @type {(e: _Event) => ReturnType<typeof log>} */
+/** @type {(e: _Event) => Effect<Write, void, NotImplemented>} */
 const writeEvent = e => log(JSON.stringify(e))
 
 /** @type {(stdout: string) => readonly _Event[]} */
@@ -75,8 +77,8 @@ const ok1 = () => ({ result: /** @type {const} */ (['ok', undefined]), duration:
 const run = (dir, initCwd = '.') => {
     const reporter = makeReporter()
     const state = { ...emptyState, root: dir }
-    const [finalState, exitCode] = virtual(state)(testAll(reporter)(options(initCwd)))
-    return [parseEvents(finalState.stdout), exitCode]
+    const [finalState, code] = virtual(state)(testAll(reporter)(options(initCwd)))
+    return [parseEvents(finalState.stdout), exitCode(code)]
 }
 
 // Runs the `fjs t` entry point (`main`) and returns its captured stdout/stderr
@@ -85,8 +87,8 @@ const run = (dir, initCwd = '.') => {
 const runMain = (dir, github = false) => {
     const state = { ...emptyState, root: dir }
     const opts = options('.', github)
-    const [finalState, exitCode] = virtual(state)(main(opts))
-    return [finalState.stdout, finalState.stderr, exitCode]
+    const [finalState, code] = virtual(state)(main(opts))
+    return [finalState.stdout, finalState.stderr, exitCode(code)]
 }
 
 // flat object: two passing tests
@@ -166,10 +168,10 @@ export const returnValueSubTree = () => {
     const [events, exit] = run({
         'r.proof.f.ts': () => ({
             proof: {
-                outer: /** @type {() => unknown} */ (() => ({
+                outer: () => ({
                     result: /** @type {const} */ (['ok', { inner }]),
                     duration: 0,
-                })),
+                }),
             }
         }),
     })
@@ -299,13 +301,45 @@ export const githubReporterOutput = () => {
     )
 }
 
+/** @typedef {All | Import | Readdir | Sandbox | Write} _FailOps */
+
+// A reporter that cannot write neither panics nor reports success. The failed
+// `result` line short-circuits its own test, leaves `allOk` as the first error,
+// skips the summary, and reaches the program tail — which answers exit `1`.
+//
+// `write` fails for every stream here, including the one `errorExit` reports
+// the failure on, so the exit code rather than a message is what is observable:
+// a run that cannot say anything at all still says it failed.
+export const reporterWriteFailure = () => {
+    /** @type {RunInstance<_FailOps, undefined>} */
+    let runner
+    runner = mockRun(/** @type {Parameters<typeof mockRun<_FailOps, undefined>>[0]} */ ({
+        readdir: (_path, _o) => s => [s, ok([{ name: 'a.proof.f.ts', parentPath: '.', isFile: true }])],
+        import: _path => s => [s, ok({ proof: { x: () => { } } })],
+        all: (...effects) => s => {
+            const [st, rs] = effects.reduce(
+                ([st1, rs1], e) => {
+                    const [ns, r] = runner(st1)(e)
+                    return [ns, [...rs1, r]]
+                },
+                /** @type {readonly [undefined, readonly unknown[]]} */([s, []]),
+            )
+            return [st, ok(rs)]
+        },
+        sandbox: (/** @type {() => unknown} */ f) => (/** @type {undefined} */ s) =>
+            [s, ok({ result: ok(f()), duration: 0 })],
+        write: (_stream, _data) => s => [s, error(/** @type {const} */(['notImplemented', 'write']))],
+    }))
+    const [, code] = runner(undefined)(
+        /** @type {Effect<_FailOps, 0, number>} */(main(options('.'))))
+    assertEq(exitCode(code), 1)
+}
+
 /** @typedef {readonly string[]} _RegisterMockState */
 
 /** @typedef {Test | All | Await} _RegisterMockOps */
 
-/**
- * @typedef {(s: _RegisterMockState) => <T>(e: Effect<_RegisterMockOps, T>) => readonly [_RegisterMockState, T]} _RegisterRunner
- */
+/** @typedef {RunInstance<_RegisterMockOps, _RegisterMockState>} _RegisterRunner */
 
 /**
  * The `test` op body for a `registerModule` mock; `runner` is threaded in explicitly (rather than closed over) so it can recurse into sub-effects returned by `fn`.
@@ -314,8 +348,8 @@ export const githubReporterOutput = () => {
  *     ctx: TestContext,
  *     name: string,
  *     expectFailure: boolean,
- *     fn: (t: TestContext) => Effect<_RegisterMockOps, void>,
- * ) => (s: _RegisterMockState) => readonly [_RegisterMockState, void]} _RegisterTestOp
+ *     fn: (t: TestContext) => Effect<_RegisterMockOps, void, never>,
+ * ) => (s: _RegisterMockState) => readonly [_RegisterMockState, OpResult<void>]} _RegisterTestOp
  */
 
 /** @type {TestContext} */
@@ -332,15 +366,17 @@ const makeRegisterRunner = testOp => {
     let runner
     runner = mockRun(/** @type {Parameters<typeof mockRun<_RegisterMockOps, _RegisterMockState>>[0]} */ ({
         test: (ctx, name, xf, fn) => testOp(runner, ctx, name, xf, fn),
-        all: (...effects) => s =>
-            effects.reduce(
-                ([st, rs], e) => {
-                    const [ns, r] = runner(st)(e)
-                    return /** @type {readonly [_RegisterMockState, readonly unknown[]]} */ ([ns, [...rs, r]])
+        all: (...effects) => s => {
+            const [st, rs] = effects.reduce(
+                ([st1, rs1], e) => {
+                    const [ns, r] = runner(st1)(e)
+                    return [ns, [...rs1, r]]
                 },
                 /** @type {readonly [_RegisterMockState, readonly unknown[]]} */ ([s, []]),
-            ),
-        await: p => s => /** @type {const} */ ([s, [p]]),
+            )
+            return [st, ok(rs)]
+        },
+        await: p => s => /** @type {const} */ ([s, ok([p])]),
     }))
     return runner
 }
@@ -348,7 +384,7 @@ const makeRegisterRunner = testOp => {
 // registerModule appends ' ...' for inline runners (Bun).
 // This mock never invokes the registered callback; it only records names.
 export const registerSuffixes = () => {
-    const runner = makeRegisterRunner((_runner, _ctx, name, _xf, _fn) => s => [[...s, name], undefined])
+    const runner = makeRegisterRunner((_runner, _ctx, name, _xf, _fn) => s => [[...s, name], ok(undefined)])
 
     const proof = /** @type {const} */ ({
         ok: () => {},
@@ -368,6 +404,33 @@ export const registerSuffixes = () => {
     assertEq(inlineNames[1], 'import("./a.f.ts").proof.throw.a()')
 }
 
+// The registered callback panics when its own effects cannot be dispatched.
+// `Test` hands the body to an external framework that reads a throw and
+// nothing else, so a body that could not run must not be reported as a pass —
+// which is why `registerOne` ends in a `catchStep` that throws rather than in
+// a channel nobody reads.
+const registerBodyPanicsOnUndispatchableEffect = () => {
+    /** @type {_RegisterRunner} */
+    let runner
+    runner = mockRun(/** @type {Parameters<typeof mockRun<_RegisterMockOps, _RegisterMockState>>[0]} */ ({
+        test: (ctx, _name, _xf, fn) => s => [runner(s)(fn(ctx))[0], ok(undefined)],
+        all: (...effects) => s => {
+            const [st, rs] = effects.reduce(
+                ([st1, rs1], e) => {
+                    const [ns, r] = runner(st1)(e)
+                    return [ns, [...rs1, r]]
+                },
+                /** @type {readonly [_RegisterMockState, readonly unknown[]]} */ ([s, []]),
+            )
+            return [st, ok(rs)]
+        },
+        // The runner has no `await`, which is what the body's channel carries.
+        await: _p => s => [s, error(/** @type {const} */ (['notImplemented', 'await']))],
+    }))
+    const proof = /** @type {const} */ ({ a: () => Promise.resolve(undefined) })
+    runner([])(registerModule(registerNoopCtx, './a.f.ts', proof, ''))
+}
+
 // A `throw`-tagged test whose function completes without throwing (the
 // external framework, not this module, is responsible for turning that into
 // a failure via `expectFailure`). registerModule's own callback must still
@@ -381,7 +444,7 @@ export const registerThrowsWithoutThrowing = () => {
     const runner = makeRegisterRunner((runner, ctx, name, xf, fn) => s => {
         assert(xf)
         const [ns] = runner(s)(fn(ctx))
-        return [[...ns, name], undefined]
+        return [[...ns, name], ok(undefined)]
     })
 
     // Returns a sub-tree that would register more tests if it were walked.
@@ -396,11 +459,76 @@ export const registerThrowsWithoutThrowing = () => {
 // registerModule with an empty proof object registers zero tests and
 // returns without invoking the mock's `test` op at all.
 export const registerEmptyProof = () => {
-    const runner = makeRegisterRunner((_runner, _ctx, name, _xf, _fn) => s => [[...s, name], undefined])
+    const runner = makeRegisterRunner((_runner, _ctx, name, _xf, _fn) => s => [[...s, name], ok(undefined)])
     const [names] = runner([])(registerModule(registerNoopCtx, './a.f.ts', {}, ''))
     assertEq(names.length, 0)
 }
 
+// register (the NodeProgram entry point) against an empty virtual root: no
+// modules to register means registerModuleMap short-circuits before ever
+// calling the selected TestContext's `test` op, so this reaches that branch
+// without hitting the virtual harness's `test: todo` stub.
+export const registerEmptyModuleMap = () => {
+    const state = { ...emptyState, root: {} }
+    const [, code] = virtual(state)(register(options('.')))
+    assertEq(exitCode(code), 0)
+}
+
+// register's `star`/`ctx` selection, proven observably: the virtual harness's
+// own `test` op is `todo`, so a non-empty root can't go through `virtual()`
+// here without throwing. Instead this interprets register's effect with a
+// fully synthetic runner (discovery faked via `readdir`/`import`, mirroring
+// makeRegisterRunner's approach to `test`/`all`/`await`) that records which
+// TestContext object and which registered name each `test` call received —
+// so a swapped `engine` ternary or a deleted `inlineTestContext` branch
+// changes what's observed here, not just whether the line ran.
+export const registerSelectsContextAndStar = () => {
+    /** @type {TestContext} */
+    const nodeCtx = { test: todo }
+    /** @type {TestContext} */
+    const bunCtx = { test: todo }
+
+    /** @type {(extra: Partial<NodeProgramOptions>) => readonly (readonly [TestContext, string])[]} */
+    const runRegister = extra => {
+        /** @type {(readonly [TestContext, string])[]} */
+        let calls = []
+        /** @type {RunInstance<_RegisterMockOps | Readdir | Import, undefined>} */
+        let runner
+        runner = mockRun(/** @type {Parameters<typeof mockRun<_RegisterMockOps | Readdir | Import, undefined>>[0]} */ ({
+            readdir: (_path, _o) => s => [s, ok([{ name: 'a.proof.f.ts', parentPath: '.', isFile: true }])],
+            import: _path => s => [s, ok({ proof: { ok: () => {} } })],
+            all: (...effects) => s => {
+                const [st, rs] = effects.reduce(
+                    ([st1, rs1], e) => {
+                        const [ns, r] = runner(st1)(e)
+                        return [ns, [...rs1, r]]
+                    },
+                    /** @type {readonly [undefined, readonly unknown[]]} */ ([s, []]),
+                )
+                return [st, ok(rs)]
+            },
+            await: p => s => [s, ok([p])],
+            test: (ctx, name, _xf, _fn) => s => { calls = [...calls, [ctx, name]]; return [s, ok(undefined)] },
+        }))
+        runner(undefined)(/** @type {Effect<_RegisterMockOps | Readdir | Import, 0, number>} */ (register({
+            ...defaultNodeProgramOptions, env: {}, testContext: nodeCtx, bunTestContext: bunCtx, ...extra,
+        })))
+        return calls
+    }
+
+    // Node engine, non-inline context: registers under nodeCtx, no ' ...' suffix.
+    const nodeCalls = runRegister({})
+    assertEq(nodeCalls.length, 1)
+    assert(nodeCalls[0][0] === nodeCtx)
+    assertEq(nodeCalls[0][1], 'import("./a.proof.f.ts").proof.ok()')
+
+    // Bun engine, inline context: registers under bunCtx, with ' ...' suffix.
+    const bunCalls = runRegister({ inlineTestContext: true, engine: 'bun' })
+    assertEq(bunCalls.length, 1)
+    assert(bunCalls[0][0] === bunCtx)
+    assertEq(bunCalls[0][1], 'import("./a.proof.f.ts").proof.ok() ...')
+}
+
 // direct unit tests for the pure path-format helpers
 export const helpers = {
     isInteger: () => {
@@ -472,13 +600,13 @@ export const helpers = {
     parseTestSet: {
         nullReturnsEmpty: () => {
             const result = parseTestSet(false, null)
-            assertEq(Array.isArray(result), true)
-            assertEq((/** @type {unknown[]} */ (result)).length, 0)
+            assert(result instanceof Array, result)
+            assertEq(result.length, 0)
         },
         functionWithParamsReturnsEmpty: () => {
             const result = parseTestSet(false, (/** @type {number} */ _x) => _x)
-            assertEq(Array.isArray(result), true)
-            assertEq((/** @type {unknown[]} */ (result)).length, 0)
+            assert(result instanceof Array, result)
+            assertEq(result.length, 0)
         },
     },
 }
@@ -495,6 +623,9 @@ const defaultReporterExpectedToThrow = () => {
 }
 
 export const proof = {
+    throw: {
+        registerBodyPanicsOnUndispatchableEffect,
+    },
     flat,
     nested,
     throwKey,
@@ -510,9 +641,12 @@ export const proof = {
     defaultReporterOutputLargeDuration,
     defaultReporterFailOutput,
     githubReporterOutput,
+    reporterWriteFailure,
     registerSuffixes,
     registerThrowsWithoutThrowing,
     registerEmptyProof,
+    registerEmptyModuleMap,
+    registerSelectsContextAndStar,
     defaultReporterExpectedToThrow,
     helpers
 }

package/fjs/emergent_testing/types.d.ts

@@ -4,7 +4,7 @@
  * @module
  */
 import type { Effect, Operation } from '../effects/types.ts';
-import type { SandboxResult } from '../effects/node/types.ts';
+import type { IoChannel, SandboxResult } from '../effects/node/types.ts';
 /** A zero-argument test function whose return value may contain sub-tests. */
 export type TestFn = () => unknown;
 /**
@@ -37,11 +37,29 @@ export type Path = readonly (string | null)[];
  * leading to the current location; `null` marks a function-call boundary, e.g.
  * `['outer', null, 'inner']` means `outer` was invoked and its return value
  * contained `inner`.
+ *
+ * **Every method is fallible**, because reporting is IO and IO can fail: a
+ * write to a closed pipe, a runner that cannot dispatch `write` at all. The
+ * runner propagates what a method answers, so a reporter that cannot emit ends
+ * the run rather than being silently ignored.
+ *
+ * `result` and `summary` in particular *must* carry their `Result` in the type.
+ * They used to answer a raw effect of `void`, and TypeScript accepts an effect of
+ * any value type where a `void` one is expected — so an implementation whose
+ * writes were fallible type-checked while its failures went nowhere. That is
+ * the hazard the error channel exists to remove, and a `void` return position hides
+ * it exactly where a reporter's whole job is to perform IO.
+ *
+ * The channel is the standard node one ({@link IoChannel}) rather than a type
+ * parameter: a reporter is free in which *operations* it performs, but it fails
+ * the way node IO fails, and pinning it here keeps the type — and the program
+ * tail that reports it — free of a parameter every caller would have to thread
+ * through unchanged.
  */
 export type Reporter<O extends Operation> = {
-    readonly result: (file: string, path: Path, r: SandboxResult<unknown>, throws: boolean) => Effect<O, void>;
-    readonly summary: (pass: number, fail: number, time: number) => Effect<O, void>;
-    readonly test: (file: string, path: Path, set: TestEntry) => Effect<O, SandboxResult<unknown>>;
+    readonly result: (file: string, path: Path, r: SandboxResult<unknown>, throws: boolean) => Effect<O, void, IoChannel>;
+    readonly summary: (pass: number, fail: number, time: number) => Effect<O, void, IoChannel>;
+    readonly test: (file: string, path: Path, set: TestEntry) => Effect<O, SandboxResult<unknown>, IoChannel>;
 };
 /** @internal */
 export type _TestState = {

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

@@ -8,7 +8,7 @@
  * @import { ByteSet } from '../types/byte_set/types.ts'
  * @import { SortedSet } from '../types/sorted_set/types.ts'
  * @import { RangeMap, Properties, RangeMapArray, Entry } from '../types/range_map/types.ts'
- * @import { Fold, Scan } from '../types/function/operator/types.ts'
+ * @import { Fold } from '../types/function/operator/types.ts'
  */
 import type { List } from '../types/list/types.ts';
 import type { StringMap } from '../types/object/types.ts';
@@ -17,10 +17,20 @@ import type { RangeMapArray } from '../types/range_map/types.ts';
 export type _Rule = readonly [string, ByteSet, string];
 export type Grammar = List<_Rule>;
 export type _Dfa = StringMap<RangeMapArray<string>>;
-/** @type {(s: string) => ByteSet} */
+/** @typedef {readonly [string, ByteSet, string]} _Rule */
+/** @typedef {List<_Rule>} Grammar */
+/** @typedef {StringMap<RangeMapArray<string>>} _Dfa */
+/**
+ * The byte set of an inclusive ASCII character range, written as the two
+ * endpoint characters: `toRange('az')`.
+ *
+ * `fjs/text/ascii` owns "two-character string to inclusive `Range`", including
+ * the one-character case where both endpoints are that character, so this is
+ * its composition with `byte_set.range` and nothing more.
+ *
+ * @type {(s: string) => ByteSet}
+ */
 export declare const toRange: (s: string) => ByteSet;
-/** @type {(s: string) => ByteSet} */
-export declare const toUnion: (s: string) => ByteSet;
 /** @type {(grammar: Grammar) => _Dfa} */
 export declare const dfa: (grammar: Grammar) => _Dfa;
 /** @type {(dfa: _Dfa) => (input: List<number>) => List<string>} */

package/fjs/fsm/module.f.mjs

@@ -8,17 +8,17 @@
  * @import { ByteSet } from '../types/byte_set/types.ts'
  * @import { SortedSet } from '../types/sorted_set/types.ts'
  * @import { RangeMap, Properties, RangeMapArray, Entry } from '../types/range_map/types.ts'
- * @import { Fold, Scan } from '../types/function/operator/types.ts'
+ * @import { Fold } from '../types/function/operator/types.ts'
  */
 
-import { equal, isEmpty, fold, toArray, scan, foldScan, empty as emptyList } from '../types/list/module.f.mjs'
-import { toRangeMap, union as byteSetUnion, one, empty, range } from '../types/byte_set/module.f.mjs'
-import { intersect, union as sortedSetUnion } from '../types/sorted_set/module.f.mjs'
+import { equal, isEmpty, fold, map, toArray, foldScan, empty as emptyList } from '../types/list/module.f.mjs'
+import { toRangeMap, range } from '../types/byte_set/module.f.mjs'
+import { intersect, toKey, union as sortedSetUnion } from '../types/sorted_set/module.f.mjs'
 import { merge, get as rangeMapGet } from '../types/range_map/module.f.mjs'
 import { strictEqual } from '../types/function/operator/module.f.mjs'
-import { stringify } from '../media/json/module.f.mjs'
-import { identity } from '../types/function/module.f.mjs'
-import { stringToList } from '../text/utf16/module.f.mjs'
+import { range as asciiRange } from '../text/ascii/module.f.mjs'
+import { compose } from '../types/function/module.f.mjs'
+import { at } from '../types/object/module.f.mjs'
 import { cmp } from '../types/string/module.f.mjs'
 
 /** @typedef {readonly [string, ByteSet, string]} _Rule */
@@ -27,22 +27,18 @@ import { cmp } from '../types/string/module.f.mjs'
 
 /** @typedef {StringMap<RangeMapArray<string>>} _Dfa */
 
-const stringifyIdentity = stringify(identity)
 
-/** @type {(s: string) => ByteSet} */
-export const toRange = s => {
-    const [b, e] = toArray(stringToList(s))
-    return range([b, e])
-}
-
-/** @type {Fold<number, ByteSet>} */
-const toUnionOp = i => bs => byteSetUnion(bs)(one(i))
-
-/** @type {(s: string) => ByteSet} */
-export const toUnion = s => {
-    const codePoints = stringToList(s)
-    return fold(toUnionOp)(empty)(codePoints)
-}
+/**
+ * The byte set of an inclusive ASCII character range, written as the two
+ * endpoint characters: `toRange('az')`.
+ *
+ * `fjs/text/ascii` owns "two-character string to inclusive `Range`", including
+ * the one-character case where both endpoints are that character, so this is
+ * its composition with `byte_set.range` and nothing more.
+ *
+ * @type {(s: string) => ByteSet}
+ */
+export const toRange = compose(asciiRange)(range)
 
 /** @type {Properties<SortedSet<string>>} */
 const mergeOp = { union: sortedSetUnion(cmp), equal: equal(strictEqual), def: [] }
@@ -50,50 +46,71 @@ const mergeOp = { union: sortedSetUnion(cmp), equal: equal(strictEqual), def: []
 /** @type {(s: string) => (set: SortedSet<string>) => boolean} */
 const hasState = s => set => !isEmpty(intersect(cmp)([s])(set))
 
+/**
+ * Labels a byte set's ranges with the rule they lead to: a range inside the set
+ * transitions to `ruleOut`, one outside transitions nowhere.
+ *
+ * `byte_set.toRangeMap` answers only whether each range is in the set; which
+ * state that means is a DFA question, so it is answered here.
+ *
+ * @type {(ruleOut: string) => (entry: Entry<boolean>) => Entry<SortedSet<string>>}
+ */
+const labelRange = ruleOut => ([inSet, max]) => [inSet ? [ruleOut] : [], max]
+
 /** @type {(set: SortedSet<string>) => Fold<_Rule, RangeMap<SortedSet<string>>>} */
 const foldOp = set => ([ruleIn, bs, ruleOut]) => rm => {
-    if (hasState(ruleIn)(set)) { return merge(mergeOp)(rm)(toRangeMap(bs)(ruleOut)) }
+    if (hasState(ruleIn)(set)) {
+        return merge(mergeOp)(rm)(map(labelRange(ruleOut))(toRangeMap(bs)))
+    }
     return rm
 }
 
-/** @type {Scan<Entry<SortedSet<string>>, Entry<string>>} */
-const stringifyOp = ([sortedSet, max]) => [[stringifyIdentity(sortedSet), max], stringifyOp]
+/**
+ * Renders an entry's state set as its `_Dfa` key, keeping the range boundary.
+ *
+ * @type {(entry: Entry<SortedSet<string>>) => Entry<string>}
+ */
+const keyEntry = ([sortedSet, max]) => [toKey(sortedSet), max]
 
-const scanStringify = scan(stringifyOp)
+const keyEntries = map(keyEntry)
 
-/** @type {Scan<Entry<SortedSet<string>>, SortedSet<string>>} */
-const fetchOp = ([item, _]) => [item, fetchOp]
+/**
+ * Drops an entry's range boundary, leaving the state set.
+ *
+ * @type {(entry: Entry<SortedSet<string>>) => SortedSet<string>}
+ */
+const entryValue = ([value]) => value
 
-const scanFetch = scan(fetchOp)
+const entryValues = map(entryValue)
 
 /** @type {(grammar: Grammar) => Fold<SortedSet<string>, _Dfa>} */
 const addEntry = grammar => set => dfa => {
-    const s = stringifyIdentity(set)
-    if (s in dfa) { return dfa }
+    const s = toKey(set)
+    if (at(s)(dfa) !== null) { return dfa }
     const setMap = fold(foldOp(set))(emptyList)(grammar)
-    const stringMap = toArray(scanStringify(setMap))
+    const stringMap = toArray(keyEntries(setMap))
     const newDfa = { ...dfa, [s]: stringMap }
-    const newStates = scanFetch(setMap)
+    const newStates = entryValues(setMap)
     return fold(addEntry(grammar))(newDfa)(newStates)
 }
 
 /** @type {string[]} */
 const emptyState = []
 
-const emptyStateStringify = stringifyIdentity(emptyState)
+const emptyStateKey = toKey(emptyState)
 
 const initialState = ['']
 
-const initialStateStringify = stringifyIdentity(initialState)
+const initialStateKey = toKey(initialState)
 
 /** @type {(grammar: Grammar) => _Dfa} */
 export const dfa = grammar => addEntry(grammar)(initialState)({})
 
-const get = rangeMapGet(emptyStateStringify)
+const get = rangeMapGet(emptyStateKey)
 
 /** @type {(dfa: _Dfa) => Fold<number, string>} */
 const runOp = dfa => input => s => get(dfa[s] ?? [])(input)
 
 /** @type {(dfa: _Dfa) => (input: List<number>) => List<string>} */
 export const run = dfa => input =>
-    foldScan(runOp(dfa))(initialStateStringify)(input)
+    foldScan(runOp(dfa))(initialStateKey)(input)

package/fjs/fsm/proof.f.d.mts

@@ -1,7 +1,9 @@
 /**
  * @import { Grammar } from './module.f.mjs'
+ * @import { ByteSet } from '../types/byte_set/types.ts'
  */
 export declare const proof: {
+    toRange: (() => void)[];
     dfa: () => void;
     run: (() => void)[];
 };