functionalscript 0.44.0 → 0.45.0

package/fjs/asn.1/proof.f.d.mts

@@ -1,3 +1,7 @@
+/**
+ * @import { Vec } from '../types/bit_vec/types.ts'
+ * @import { SupportedRecord, ObjectIdentifier } from './types.ts'
+ */
 export declare const proof: {
     encodeSmall: () => void;
     encode7F: () => void;
@@ -38,6 +42,7 @@ export declare const proof: {
         integer: () => void;
         sequence: () => void;
         set: () => void;
+        objectIdentifier: () => void;
     };
     objectIdentifier: {
         simple: () => void;

package/fjs/asn.1/proof.f.mjs

@@ -1,6 +1,9 @@
-/** @import { Vec } from '../types/bit_vec/types.ts' */
-import { empty, isVec, length, msb, uint, unpack, vec, vec8 } from '../types/bit_vec/module.f.mjs'
+/**
+ * @import { Vec } from '../types/bit_vec/types.ts'
+ * @import { SupportedRecord, ObjectIdentifier } from './types.ts'
+ */
 
+import { empty, isVec, length, msb, uint, unpack, vec, vec8 } from '../types/bit_vec/module.f.mjs'
 import { asBase } from '../types/nominal/module.f.mjs'
 
 import {
@@ -15,10 +18,10 @@ import {
     octetString,
     boolean,
     constructedSet,
+    objectIdentifier,
     encodeObjectIdentifier,
     decodeObjectIdentifier,
 } from './module.f.mjs'
-/** @import { SupportedRecord, ObjectIdentifier } from './types.ts' */
 
 import { assert, assertEq } from '../asserts/module.f.mjs'
 
@@ -252,6 +255,15 @@ export const proof = {
                 ])
             )
         },
+        objectIdentifier: () => {
+            // exercises the objectIdentifier case in recordToRaw/rawToRecord
+            // via the generic encode/decode dispatch (the objectIdentifier
+            // tests below only call encodeObjectIdentifier/decodeObjectIdentifier
+            // directly, never through decode()).
+            /** @type {SupportedRecord} */
+            const r = [objectIdentifier, [1n, 2n, 840n, 113549n]]
+            ch0(r, encode(r), empty)
+        },
     },
     objectIdentifier: {
         simple: () => {

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

@@ -24,6 +24,20 @@ export declare const assert: (v: boolean, msg?: unknown) => asserts v;
  * @type {<T>(...x: readonly[T, T, unknown?]) => void}
  */
 export declare const assertEq: <T>(...x: readonly [T, T, unknown?]) => void;
+/**
+ * Asserts that `a` and `b` are structurally the same — equal leaves under the
+ * same shape, property order irrelevant — throwing `x` (the `[a, b]` pair, plus
+ * an optional third element used as an extra message) if they differ.
+ *
+ * This is the assertion to reach for when comparing two independently
+ * constructed values. `assertEq` is `===`, so it only ever answers "the same
+ * reference?" for objects, which is why proofs fell back to comparing
+ * `JSON.stringify` output; see `types/object/structurally_same/README.md` for
+ * why that is the wrong question and what this one does *not* cover.
+ *
+ * @type {(...x: readonly[unknown, unknown, unknown?]) => void}
+ */
+export declare const assertStructurallySame: (...x: readonly [unknown, unknown, unknown?]) => void;
 /**
  * Asserts that `a` is neither `null` nor `undefined` and returns it,
  * narrowed to `T`.

package/fjs/asserts/module.f.mjs

@@ -4,6 +4,8 @@
  * @module
  */
 
+import { structurallySame } from '../types/object/structurally_same/module.f.mjs'
+
 /**
  * Marks a code path as unimplemented. Always throws.
  * @type {() => never}
@@ -33,6 +35,24 @@ export const assertEq = (...x) => {
     assert(a === b, x)
 }
 
+/**
+ * Asserts that `a` and `b` are structurally the same — equal leaves under the
+ * same shape, property order irrelevant — throwing `x` (the `[a, b]` pair, plus
+ * an optional third element used as an extra message) if they differ.
+ *
+ * This is the assertion to reach for when comparing two independently
+ * constructed values. `assertEq` is `===`, so it only ever answers "the same
+ * reference?" for objects, which is why proofs fell back to comparing
+ * `JSON.stringify` output; see `types/object/structurally_same/README.md` for
+ * why that is the wrong question and what this one does *not* cover.
+ *
+ * @type {(...x: readonly[unknown, unknown, unknown?]) => void}
+ */
+export const assertStructurallySame = (...x) => {
+    const [a, b] = x
+    assert(structurallySame(a, b), x)
+}
+
 /**
  * Asserts that `a` is neither `null` nor `undefined` and returns it,
  * narrowed to `T`.

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

@@ -1,9 +1,12 @@
 export declare const proof: {
     assertPassesOnTrue: () => void;
     assertEqPassesOnEqual: () => void;
+    assertStructurallySamePassesOnSame: () => void;
     throw: {
         assertEqThrowsOnUnequal: () => void;
         assertEqThrowsOnUnequal3: () => void;
+        assertStructurallySameThrowsOnDifferent: () => void;
+        assertStructurallySameThrowsOnDifferent3: () => void;
         assertThrowsDefaultMsg: () => void;
         assertThrowsCustomMsg: () => void;
         todoThrows: () => never;

package/fjs/asserts/proof.f.mjs

@@ -1,4 +1,9 @@
-import { assert, assertEq, todo } from './module.f.mjs'
+import {
+    assert,
+    assertEq,
+    assertStructurallySame,
+    todo,
+} from './module.f.mjs'
 
 export const proof = {
     assertPassesOnTrue: () => {
@@ -9,9 +14,18 @@ export const proof = {
         assertEq(1, 1)
         assertEq('x', 'x')
     },
+    assertStructurallySamePassesOnSame: () => {
+        // the case `assertEq` cannot do: two separately built values
+        assertStructurallySame({ a: 1, b: [2, { c: 3 }] }, { b: [2, { c: 3 }], a: 1 })
+        assertStructurallySame(1, 1, 'with message')
+    },
     throw: {
         assertEqThrowsOnUnequal: () => assertEq(1, 2),
         assertEqThrowsOnUnequal3: () => assertEq(1, 2, "message"),
+        assertStructurallySameThrowsOnDifferent:
+            () => assertStructurallySame({ a: 1 }, { a: 2 }),
+        assertStructurallySameThrowsOnDifferent3:
+            () => assertStructurallySame({ a: 1 }, { a: 2 }, 'message'),
         assertThrowsDefaultMsg: () => assert(false),
         assertThrowsCustomMsg: () => assert(false, 'oops'),
         todoThrows: () => todo(),

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

@@ -1,2 +1,4 @@
-/** @import { Vec } from '../../types/bit_vec/types.ts' */
+/**
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ */
 export declare const proof: () => void;

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

@@ -1,4 +1,6 @@
-/** @import { Vec } from '../../types/bit_vec/types.ts' */
+/**
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ */
 
 import { empty, vec, vec8 } from '../../types/bit_vec/module.f.mjs'
 import { asBase } from '../../types/nominal/module.f.mjs'

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

@@ -7,7 +7,7 @@
  * @import { Nullable } from '../../types/nullable/types.ts'
  */
 
-import { msb, length, vec, maxLength } from '../../types/bit_vec/module.f.mjs'
+import { msb, length, vec } from '../../types/bit_vec/module.f.mjs'
 import { baseN } from "../module.f.mjs"
 
 const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
@@ -61,8 +61,12 @@ export const decode = input => {
     const lastChunk = stringToVec(body.slice(body.length - 1))
     if (lastChunk === null) { return null }
 
-    if (length(head) + realBits > maxLength) { return null }
-
+    // No `head`/`realBits` overflow check is needed here: `head` is built
+    // from whole 6-bit chunks, so its length is always a multiple of 6, and
+    // the largest such length `stringToVec` can return without itself
+    // failing is `maxLength - (maxLength % 6)` = `maxLength - 4`. Adding
+    // `realBits` (at most 4, when `padChars` is 1) reaches `maxLength`
+    // exactly and never exceeds it.
     const [kept, pad] = popFront(realBits)(lastChunk)
     // Padding bits must be zero (RFC 4648 §3.5).
     if (pad !== vec(removeBits)(0n)) { return null }

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

@@ -1,4 +1,6 @@
-/** @import { Vec } from '../../types/bit_vec/types.ts' */
+/**
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ */
 export declare const proof: {
     empty: () => void;
     oneByte: () => void;

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

@@ -1,4 +1,6 @@
-/** @import { Vec } from '../../types/bit_vec/types.ts' */
+/**
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ */
 
 import { assertEq } from '../../asserts/module.f.mjs'
 import { empty, vec, repeat, vec8, maxLength } from '../../types/bit_vec/module.f.mjs'
@@ -100,9 +102,10 @@ export const proof = {
         // ...and an invalid final character (the one holding the padding
         // bits) must be rejected via the last-character decode.
         assertEq(decode('A!=='), null)
-        // Same as `decodeOverflow`, but with a padded tail so it's the
-        // padded branch that measures the result against `maxLength` and
-        // rejects it.
+        // Same as `decodeOverflow`, but with a padded tail: `head` (all
+        // characters but the last) is still over `maxLength` on its own, so
+        // this is rejected by `head`'s own `stringToVec` overflow check, not
+        // by a separate `head`-plus-`realBits` measurement.
         assertEq(decode('A'.repeat(174_764) + '='), null)
     },
     encodeAtMaxLengthSucceeds: () => {

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

@@ -1,4 +1,6 @@
-/** @import { Vec } from '../../types/bit_vec/types.ts' */
+/**
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ */
 export declare const proof: {
     roundtrip5x: () => void;
     roundtrip: () => void;

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

@@ -1,4 +1,6 @@
-/** @import { Vec } from '../../types/bit_vec/types.ts' */
+/**
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ */
 
 import { empty, vec } from '../../types/bit_vec/module.f.mjs'
 import { cBase32ToVec, cBase32ToVec5x, vec5xToCBase32, vecToCBase32 } from './module.f.mjs'

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

@@ -9,7 +9,6 @@ import { sort } from '../../types/object/module.f.mjs'
 import { oneEncode, option, range, rangeDecode, repeat0Plus, set } from '../module.f.mjs'
 import { emptyTagMap, toData } from './module.f.mjs'
 import { assertEq } from '../../asserts/module.f.mjs'
-
 import { stringify } from '../../media/json/module.f.mjs'
 import { classic, deterministic } from '../testlib.f.mjs'
 

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

@@ -7,6 +7,10 @@
  * AST ({@link AstRuleMeta}). Nullability (which rule can match empty input) is
  * computed once by {@link emptyTagMap} in `fjs/bnf/data`.
  *
+ * The caller passes physical symbols only; the matcher synthesizes the one
+ * logical EOF ({@link eofSymbol}) after them, so a grammar can require the end
+ * of input with the `eof` terminal.
+ *
  * A failed result also carries a {@link DescentFailure}: the furthest position a
  * terminal was rejected at, which — unlike the result's own index — never
  * rewinds and is what diagnostics should be built from.
@@ -18,10 +22,21 @@
  * @import { TerminalRange } from '../types.ts'
  * @import { Rule as DataRule, Sequence } from '../data/types.ts'
  * @import { Rule as FRule } from '../types.ts'
- * @import { AstTag, AstSequenceMeta, DescentFailure, DescentMatch, DescentMatchResult, DescentMatchRule } from './types.ts'
+ * @import { AstRuleMeta, AstTag, AstSequenceMeta, CodePointMeta, DescentFailure, DescentMatch, DescentMatchResult, DescentMatchRule } from './types.ts'
  */
+import type { TerminalRange } from '../types.ts';
 import type { Rule as FRule } from '../types.ts';
-import type { DescentMatch } from './types.ts';
+import type { AstRuleMeta, DescentMatch } from './types.ts';
+export type _Cursor = number;
+export type _Failure = {
+    readonly pos: _Cursor;
+    readonly expected: readonly TerminalRange[];
+};
+export type _Result<T> = {
+    readonly ast: AstRuleMeta<T>;
+    readonly success: boolean;
+    readonly pos: _Cursor;
+};
 /**
  * Creates a recursive descent parser that preserves metadata for each consumed
  * code point.

package/fjs/bnf/descent/module.f.mjs

@@ -7,6 +7,10 @@
  * AST ({@link AstRuleMeta}). Nullability (which rule can match empty input) is
  * computed once by {@link emptyTagMap} in `fjs/bnf/data`.
  *
+ * The caller passes physical symbols only; the matcher synthesizes the one
+ * logical EOF ({@link eofSymbol}) after them, so a grammar can require the end
+ * of input with the `eof` terminal.
+ *
  * A failed result also carries a {@link DescentFailure}: the furthest position a
  * terminal was rejected at, which — unlike the result's own index — never
  * rewinds and is what diagnostics should be built from.
@@ -18,25 +22,89 @@
  * @import { TerminalRange } from '../types.ts'
  * @import { Rule as DataRule, Sequence } from '../data/types.ts'
  * @import { Rule as FRule } from '../types.ts'
- * @import { AstTag, AstSequenceMeta, DescentFailure, DescentMatch, DescentMatchResult, DescentMatchRule } from './types.ts'
+ * @import { AstRuleMeta, AstTag, AstSequenceMeta, CodePointMeta, DescentFailure, DescentMatch, DescentMatchResult, DescentMatchRule } from './types.ts'
  */
 
-import { rangeDecode } from '../module.f.mjs'
+import { eofSymbol, rangeDecode } from '../module.f.mjs'
 import { contains as rangeContains } from '../../types/range/module.f.mjs'
 import { definedEntries } from '../../types/object/module.f.mjs'
 import { emptyTagMap, toData } from '../data/module.f.mjs'
 
+/**
+ * A match position that includes EOF consumption: `0 .. cp.length` are the
+ * physical positions, and `cp.length + 1` is where the one synthesized EOF has
+ * been consumed.
+ *
+ * This is the complete cursor the design calls `(idx, eofConsumed)`, written as
+ * one number: `eofConsumed` can only be true at the physical end, so the pair
+ * and the extended position hold the same information, and comparing cursors
+ * compares progress — consuming EOF *is* progress even though the public index
+ * does not move.
+ *
+ * @typedef {number} _Cursor
+ */
+
+/**
+ * The furthest-failure record while matching, positioned by the complete
+ * cursor. {@link DescentFailure} is its public, physically-positioned form.
+ *
+ * @typedef {{
+ *     readonly pos: _Cursor
+ *     readonly expected: readonly TerminalRange[]
+ * }} _Failure
+ */
+
+/**
+ * The machine's own result: a {@link DescentMatchResult} positioned by the
+ * complete cursor, and with no failure record — that one is tracked per match
+ * rather than per frame.
+ *
+ * @template T
+ * @typedef {{
+ *     readonly ast: AstRuleMeta<T>
+ *     readonly success: boolean
+ *     readonly pos: _Cursor
+ * }} _Result
+ */
+
+/**
+ * The public, physical index of a cursor. Consuming EOF moves the cursor past
+ * the physical end, and both cursors report `input.length`.
+ *
+ * @type {(length: number) => (pos: _Cursor) => number}
+ */
+const physicalIdx = length => pos => Math.min(pos, length)
+
+/**
+ * The semantic symbol a cursor points at: a code point inside the physical
+ * input, and the synthesized {@link eofSymbol} at its end. Only meaningful
+ * where the cursor still has a symbol, `pos <= cp.length`.
+ *
+ * @type {<T>(cp: readonly CodePointMeta<T>[], pos: _Cursor) => number}
+ */
+const symbolAt = (cp, pos) => pos < cp.length ? cp[pos][0] : eofSymbol
+
+/**
+ * What consuming the symbol at a cursor contributes to the AST: the code point
+ * with its metadata, and nothing for the synthesized EOF — it has no physical
+ * source element.
+ *
+ * @type {<T>(cp: readonly CodePointMeta<T>[], pos: _Cursor) => AstSequenceMeta<T>}
+ */
+const leafAt = (cp, pos) => pos < cp.length ? [cp[pos]] : []
+
 /**
  * Folds one rejected terminal into the furthest-failure record: further along
- * replaces, the same position accumulates (ignoring repeats), earlier is
- * discarded.
+ * replaces, the same cursor accumulates (ignoring repeats), earlier is
+ * discarded. The comparison is on the complete cursor, so a failure after EOF
+ * was consumed is further than one at the same physical index before it.
  *
- * @type {(failure: DescentFailure, idx: number, terminal: TerminalRange) => DescentFailure}
+ * @type {(failure: _Failure, pos: _Cursor, terminal: TerminalRange) => _Failure}
  */
-const recordFailure = (failure, idx, terminal) => {
-    if (idx > failure.idx) { return { idx, expected: [terminal] } }
-    if (idx < failure.idx || failure.expected.includes(terminal)) { return failure }
-    return { idx, expected: [...failure.expected, terminal] }
+const recordFailure = (failure, pos, terminal) => {
+    if (pos > failure.pos) { return { pos, expected: [terminal] } }
+    if (pos < failure.pos || failure.expected.includes(terminal)) { return failure }
+    return { pos, expected: [...failure.expected, terminal] }
 }
 
 /**
@@ -51,6 +119,11 @@ export const descentParser = fr => {
     const data = toData(fr)
     const emptyTags = emptyTagMap(data[0])
 
+    /** @type {(tag: AstTag, sequence: AstSequenceMeta<T>, pos: _Cursor) => _Result<T>} */
+    const mrSuccess = (tag, sequence, pos) => ({ ast: {tag, sequence}, success: true, pos })
+    /** @type {(tag: AstTag, sequence: AstSequenceMeta<T>, pos: _Cursor) => _Result<T>} */
+    const mrFail = (tag, sequence, pos) => ({ ast: {tag, sequence}, success: false, pos })
+
     // A suspended sequence match: items[itemIndex] is being matched by the current
     // task; `seq` holds the ASTs of the items already matched.
     /**
@@ -59,7 +132,7 @@ export const descentParser = fr => {
      *     readonly tag: AstTag
      *     readonly items: Sequence
      *     readonly itemIndex: number
-     *     readonly startIdx: number
+     *     readonly startPos: _Cursor
      *     readonly seq: AstSequenceMeta<T>
      * }} _SeqFrame
      */
@@ -72,8 +145,8 @@ export const descentParser = fr => {
      *     readonly kind: 'variant'
      *     readonly entries: readonly (readonly [string, string])[]
      *     readonly entryIndex: number
-     *     readonly idx: number
-     *     readonly emptyResult: DescentMatchResult<T>
+     *     readonly pos: _Cursor
+     *     readonly emptyResult: _Result<T>
      * }} _VariantFrame
      */
 
@@ -93,7 +166,7 @@ export const descentParser = fr => {
      * @typedef {{
      *     readonly name: string
      *     readonly tag: AstTag
-     *     readonly idx: number
+     *     readonly pos: _Cursor
      * }} _Task
      */
 
@@ -104,29 +177,26 @@ export const descentParser = fr => {
     // grammar recursion depth — right-recursive rules (e.g. repeat0Plus chains) no longer
     // overflow on long input (see the longInput proof group).
     /** @type {DescentMatchRule<T>} */
-    const f = (name, tag, cp, idx) => {
-        /** @type {(tag: AstTag, sequence: AstSequenceMeta<T>, idx: number) => DescentMatchResult<T>} */
-        const mrSuccess = (tag, sequence, idx) => ({ ast: {tag, sequence}, success: true, idx })
-        /** @type {(tag: AstTag, sequence: AstSequenceMeta<T>, idx: number) => DescentMatchResult<T>} */
-        const mrFail = (tag, sequence, idx) => ({ ast: {tag, sequence}, success: false, idx })
+    const f = (name, tag, cp, startPos) => {
+        const physical = physicalIdx(cp.length)
 
         /** @type {_Stack} */
         let stack = null
         /** @type {_Task | null} */
-        let task = { name, tag, idx }
-        /** @type {DescentMatchResult<T>} */
-        let result = mrFail(undefined, [], idx)
+        let task = { name, tag, pos: startPos }
+        /** @type {_Result<T>} */
+        let result = mrFail(undefined, [], startPos)
         // High-water mark across the whole match, so it survives the rewinds a
         // failing sequence item does to `result`.
-        /** @type {DescentFailure} */
-        let furthest = { idx: 0, expected: [] }
+        /** @type {_Failure} */
+        let furthest = { pos: 0, expected: [] }
 
         while (true) {
             if (task !== null) {
                 // The explicit annotation cuts a control-flow inference cycle (TS7022):
                 // `name`'s narrowed type feeds `rule`, whose type would otherwise feed the
                 // later `task` assignments that `name`'s narrowing depends on.
-                const { name, tag, idx } = /** @type {_Task} */ (task)
+                const { name, tag, pos } = /** @type {_Task} */ (task)
                 task = null
                 /** @type {DataRule} */
                 const rule = data[0][name]
@@ -134,67 +204,74 @@ export const descentParser = fr => {
                     // No nullable case: `emptyTagOf` in `bnf/data` returns `undefined`
                     // for every terminal, so `emptyTags[name]` here is always
                     // `undefined` and a terminal either consumes one symbol or fails.
-                    if (idx < cp.length && rangeContains(...rangeDecode(rule))(cp[idx][0])) {
-                        result = mrSuccess(tag, [cp[idx]], idx + 1)
+                    // Past the synthesized EOF there is no symbol left to consume.
+                    if (pos <= cp.length && rangeContains(...rangeDecode(rule))(symbolAt(cp, pos))) {
+                        result = mrSuccess(tag, leafAt(cp, pos), pos + 1)
                     } else {
                         // The only place a terminal is rejected, so the only place
                         // the furthest failure can advance.
-                        furthest = recordFailure(furthest, idx, rule)
-                        result = mrFail(undefined, [], idx)
+                        furthest = recordFailure(furthest, pos, rule)
+                        result = mrFail(undefined, [], pos)
                     }
                 } else if (rule instanceof Array) {
                     if (rule.length === 0) {
-                        result = mrSuccess(tag, [], idx)
+                        result = mrSuccess(tag, [], pos)
                     } else {
-                        stack = { top: { kind: 'seq', tag, items: rule, itemIndex: 0, startIdx: idx, seq: [] }, rest: stack }
-                        task = { name: rule[0], tag: undefined, idx }
+                        stack = { top: { kind: 'seq', tag, items: rule, itemIndex: 0, startPos: pos, seq: [] }, rest: stack }
+                        task = { name: rule[0], tag: undefined, pos }
                     }
                 } else {
                     const entries = definedEntries(rule)
                     const emptyTag = emptyTags[name]
-                    const emptyResult = mrFail(emptyTag, [], idx)
+                    const emptyResult = mrFail(emptyTag, [], pos)
                     if (entries.length === 0) {
                         result = emptyResult
                     } else {
-                        stack = { top: { kind: 'variant', entries, entryIndex: 0, idx, emptyResult }, rest: stack }
+                        stack = { top: { kind: 'variant', entries, entryIndex: 0, pos, emptyResult }, rest: stack }
                         const [entryTag, entryName] = entries[0]
-                        task = { name: entryName, tag: entryTag, idx }
+                        task = { name: entryName, tag: entryTag, pos }
                     }
                 }
                 continue
             }
 
             if (stack === null) {
+                const { ast, success, pos } = result
+                /** @type {DescentMatchResult<T>} */
+                const mr = { ast, success, idx: physical(pos) }
                 // A success has nothing to diagnose; only a failure carries it.
-                return result.success ? result : { ...result, failure: furthest }
+                return success
+                    ? mr
+                    : { ...mr, failure: { idx: physical(furthest.pos), expected: furthest.expected } }
             }
             const frame = stack.top
             stack = stack.rest
 
             if (frame.kind === 'seq') {
-                const { ast: astRule, success, idx: nidx } = result
+                const { ast: astRule, success, pos } = result
                 if (success === false) {
-                    result = mrFail(frame.tag, [], frame.startIdx)
+                    result = mrFail(frame.tag, [], frame.startPos)
                 } else {
                     const seq = [...frame.seq, astRule]
                     const itemIndex = frame.itemIndex + 1
                     if (itemIndex < frame.items.length) {
                         stack = { top: { ...frame, itemIndex, seq }, rest: stack }
-                        task = { name: frame.items[itemIndex], tag: undefined, idx: nidx }
+                        task = { name: frame.items[itemIndex], tag: undefined, pos }
                     } else {
-                        result = mrSuccess(frame.tag, seq, nidx)
+                        result = mrSuccess(frame.tag, seq, pos)
                     }
                 }
             } else {
                 // success that consumed input wins immediately: the frame stays popped and
                 // `result` propagates to the frame below, matching the recursive `return m`.
-                if (!(result.success && frame.idx !== result.idx)) {
+                // Consuming EOF counts as consumption, because the cursor moved.
+                if (!(result.success && frame.pos !== result.pos)) {
                     const emptyResult = result.success ? result : frame.emptyResult
                     const entryIndex = frame.entryIndex + 1
                     if (entryIndex < frame.entries.length) {
                         stack = { top: { ...frame, entryIndex, emptyResult }, rest: stack }
                         const [entryTag, entryName] = frame.entries[entryIndex]
-                        task = { name: entryName, tag: entryTag, idx: frame.idx }
+                        task = { name: entryName, tag: entryTag, pos: frame.pos }
                     } else {
                         result = emptyResult
                     }

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

@@ -9,5 +9,6 @@ export declare const proof: {
     descentParser: (() => void)[];
     longInput: (() => void)[];
     descentParserWithMeta: (() => void)[];
+    logicalEof: (() => void)[];
     furthestFailure: (() => void)[];
 };