@tabnas/parser 0.8.7 → 0.8.10

package/dist/rules.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeRuleSpec = exports.makeNoRule = exports.makeRule = exports.AltMatch = exports.RuleSpec = exports.Rule = void 0;
 exports.validateAlt = validateAlt;
 exports.validateAlts = validateAlts;
+exports.continuationTins = continuationTins;
 const types_1 = require("./types");
 const utility_1 = require("./utility");
 const error_1 = require("./error");
@@ -377,6 +378,13 @@ class RuleSpec {
         let alts = (is_open ? def.open : def.close);
         // Handle "before" call.
         let befores = is_open ? (rule.bo ? def.bo : null) : rule.bc ? def.bc : null;
+        // Error recovery resumed this rule on a pass whose before actions
+        // already ran — do not replay them (see attemptRecover).
+        if (rule._skipBefores) {
+            ;
+            rule._skipBefores = false;
+            befores = null;
+        }
         if (befores) {
             let bout = undefined;
             for (let bI = 0; bI < befores.length; bI++) {
@@ -394,6 +402,12 @@ class RuleSpec {
             if (logging)
                 why += 'H';
         }
+        // Expose the alternate this pass resolved to (post-modifier, so a
+        // replacement from alt.h is what consumers see), for the parser's
+        // post-process ruleDone event. A pass with no alternates exposes
+        // null, matching the public RuleDone contract.
+        ;
+        ctx._dalt = 0 < alts.length ? alt : null;
         // Unconditional error.
         if (alt.e) {
             return this.bad(alt.e, rule, ctx, { is_open });
@@ -560,6 +574,20 @@ class RuleSpec {
         return next;
     }
     bad(tkn, rule, ctx, parse) {
+        // Opt-in recovery: record the error and continue from a sync point
+        // instead of throwing (options.parse.recover).
+        const rec = ctx.cfg?.parse?.recover;
+        if (rec?.enabled) {
+            const next = attemptRecover(tkn, rule, ctx, parse);
+            if (null != next)
+                return next;
+            // Recovery gave up (caps or exhausted stack). The error is
+            // already recorded; throw the last recorded one so parser.start
+            // can convert the parse to { value, errors }.
+            const lastErr = ctx.errs?.[ctx.errs.length - 1];
+            if (null != lastErr)
+                throw lastErr;
+        }
         throw new error_1.TabnasError(tkn.err || utility_1.S.unexpected, {
             ...tkn.use,
             state: parse.is_open ? utility_1.S.open : utility_1.S.close,
@@ -575,14 +603,401 @@ class RuleSpec {
 exports.RuleSpec = RuleSpec;
 const makeRuleSpec = (...params) => new RuleSpec(...params);
 exports.makeRuleSpec = makeRuleSpec;
-// First match wins.
-// NOTE: input AltSpecs are used to build the Alt output.
+const closeInfoCache = new WeakMap();
+// A bad token is produced without advancing the lex point (the
+// matchers declined it) — skipping one forward requires moving the
+// point past its span by hand, tracking rows and columns.
+// Bad-token codes raised from INSIDE a compound construct (string
+// body escapes and control characters): resuming the lexer just past
+// the offending character would restart lexing mid-construct and
+// mis-tokenize the remainder (a stray quote opens a "new" string).
+// For these, recovery advances to a lexical boundary — the next line
+// end — instead.
+const MID_CONSTRUCT = {
+    unprintable: true,
+    invalid_unicode: true,
+    invalid_ascii: true,
+};
+function advanceLexPast(lex, t, toLineEnd) {
+    const pnt = lex.pnt;
+    const src = lex.src;
+    const cfg = lex.ctx?.cfg;
+    // Config.line.rowChars is a Chars lookup object; fall back to '\n'
+    // when line lexing is not configured.
+    const rowsObj = cfg?.line?.rowChars;
+    const isRow = (ch) => (null != rowsObj ? !!rowsObj[ch] : '\n' === ch);
+    let target = Math.max(pnt.sI, t.sI + Math.max(1, t.len | 0));
+    if (toLineEnd) {
+        let e = target;
+        while (e < src.length && !isRow(src[e]))
+            e++;
+        // Include the line end itself so lexing resumes on a fresh row.
+        target = Math.max(target, Math.min(src.length, e + 1));
+    }
+    while (pnt.sI < target && pnt.sI < src.length) {
+        if (isRow(src[pnt.sI])) {
+            pnt.rI++;
+            pnt.cI = 1;
+        }
+        else {
+            pnt.cI++;
+        }
+        pnt.sI++;
+    }
+}
+function closeInfo(spec, groups, sig) {
+    const close = (spec.def?.close ?? []);
+    let info = closeInfoCache.get(close);
+    if (null == info || info.len !== close.length || info.sig !== sig) {
+        const sync = new Set();
+        const all = new Set();
+        let any = false;
+        for (const alt of close) {
+            if (0 === (alt.sN | 0)) {
+                any = true;
+                continue;
+            }
+            const lead = alt.t?.[0] ?? [];
+            for (const tin of lead)
+                all.add(tin);
+            const g = alt.g ?? [];
+            for (const tag of g) {
+                if (groups.includes(tag)) {
+                    for (const tin of lead)
+                        sync.add(tin);
+                    break;
+                }
+            }
+        }
+        info = { len: close.length, sig, sync, all, any };
+        closeInfoCache.set(close, info);
+    }
+    return info;
+}
+// The sync token set for the current error, computed from the live
+// rule stack: leading tins of close alternates whose g tags intersect
+// parse.recover.syncGroups, plus explicit syncTins. When the grammar
+// is untagged (sync set empty) the normative structural fallback
+// applies: every close-leading tin anywhere in the stack.
+function computeSyncTins(ctx, rule) {
+    const rec = ctx.cfg.parse.recover;
+    const sig = rec.syncGroups.join(',');
+    const out = new Set();
+    const addSync = (r) => {
+        if (null != r && r !== ctx.NORULE) {
+            closeInfo(r.spec, rec.syncGroups, sig).sync.forEach((t) => out.add(t));
+        }
+    };
+    addSync(rule);
+    for (let d = ctx.rsI - 1; 0 <= d; d--)
+        addSync(ctx.rs[d]);
+    // Structural fallback for untagged grammars is decided on the
+    // grammar-derived set alone — explicit syncTokens are extras, and
+    // must not disable the fallback by their mere presence.
+    if (0 === out.size) {
+        const addAll = (r) => {
+            if (null != r && r !== ctx.NORULE) {
+                closeInfo(r.spec, rec.syncGroups, sig).all.forEach((t) => out.add(t));
+            }
+        };
+        addAll(rule);
+        for (let d = ctx.rsI - 1; 0 <= d; d--)
+            addAll(ctx.rs[d]);
+    }
+    for (const tin of rec.syncTins)
+        out.add(tin);
+    return out;
+}
+// Does this rule's close state accept the token? An empty-s close
+// alternate accepts anything (over-approximation: conditions and
+// counters may still reject — cascade suppression absorbs that).
+function acceptsClose(spec, tin, groups, sig) {
+    const info = closeInfo(spec, groups, sig);
+    return info.any || info.all.has(tin);
+}
+// Legal-continuation tokens at an error point: the failing rule's
+// collated lookahead tins at the deepest position any alternate
+// matched (ctx._eMax), widened by a pop-closure — while a rule's close
+// state has an empty-s catch-all alternate (it can close on anything),
+// the parent's close continuations are legal here too. Powers
+// tn.continuations() (completion in the unified-LSP design).
+// How many leading positions of an alternate match the currently
+// buffered lookahead. Used by the continuation computation to decide
+// whether an alternate is FULLY matched (and so its push/replace
+// target's opening tokens are legal at this position).
+function altMatchDepth(alt, ctx) {
+    const aN = alt.sN | 0;
+    const tbuf = ctx.t;
+    const NOTOKEN = ctx.NOTOKEN;
+    const bitAA = 1 << (ctx.cfg.t.AA - 1);
+    let k = 0;
+    while (k < aN) {
+        const tk = tbuf[k];
+        if (null == tk || NOTOKEN === tk)
+            break;
+        const Sk = alt.S ? alt.S[k] : null;
+        if (null != Sk) {
+            const tin = tk.tin;
+            const part = (tin / 31) | 0;
+            const aaBit = 0 === part ? bitAA : 0;
+            if (0 === (Sk[part] & ((1 << ((tin % 31) - 1)) | aaBit)))
+                break;
+        }
+        k++;
+    }
+    return k;
+}
+function continuationTins(ctx, rule, atPos) {
+    const out = new Set();
+    if (null == rule || null == ctx || rule === ctx.NORULE)
+        return [];
+    // The buffer position being asked about: a token offered here must
+    // FOLLOW everything already buffered, never replace part of it.
+    const queryPos = null == atPos ? 0 : atPos;
+    // Path-aware tins recorded by parse_alts at the failure point; the
+    // collated tcol is the fallback (exact at position 0, where no
+    // prefix exists to disambiguate).
+    const cont = ctx._contTins;
+    if (null != cont && 0 < cont.length) {
+        for (const t of cont)
+            out.add(t);
+    }
+    else {
+        // No failure record (the prefix parsed): compute the same
+        // path-aware set directly from the buffer. Per alternate, only the
+        // position it is actually waiting on contributes — the collated
+        // tcol is path-blind and would offer a sibling alternate's later
+        // tokens whose own prefix never matched.
+        const stateAltsNow = (types_1.OPEN === rule.state
+            ? rule.spec.def?.open
+            : rule.spec.def?.close);
+        for (const a of stateAltsNow ?? []) {
+            const aN = a.sN | 0;
+            const k = altMatchDepth(a, ctx);
+            // An alternate speaks only for the position it actually reached.
+            // One that stopped short of the query (k < queryPos) mismatched a
+            // token that is already in the buffer, so the tokens it wants at
+            // k would have to REPLACE that token rather than follow it —
+            // offering them puts a sibling branch's opener in a completion
+            // list where it cannot legally appear.
+            if (k === queryPos && k < aN) {
+                for (const t of a.t?.[k] ?? [])
+                    out.add(t);
+            }
+        }
+    }
+    // Pop-closure over empty-close ancestors: bounded by the finite rule
+    // stack itself (d decrements to exhaustion), no arbitrary cap.
+    let r = rule;
+    let d = ctx.rsI - 1;
+    for (;;) {
+        const info = closeInfo(r.spec, [], '');
+        if (!info.any)
+            break;
+        const parent = 0 <= d ? ctx.rs[d--] : undefined;
+        if (null == parent || parent === ctx.NORULE)
+            break;
+        const ptcol = parent.spec.def?.tcol;
+        const pAt = ptcol?.[1]?.[0] ?? [];
+        for (const t of pAt)
+            out.add(t);
+        r = parent;
+    }
+    // Push/replace closure. An alternate whose token sequence is FULLY
+    // matched at this position is about to push (or become) another
+    // rule, so that rule's opening tokens are legal here too — this is
+    // what makes `[1,` offer the next element's value starters rather
+    // than only the closers its own close alternates name. Alternates
+    // that are only partially matched are deliberately excluded: they
+    // still require their own next token first (`{"a"` wants `:`, not
+    // a value).
+    const opened = new Set();
+    const addOpeners = (name) => {
+        if (null == name || false === name || 0 === name)
+            return;
+        const rn = String(name);
+        if ('' === rn || opened.has(rn))
+            return;
+        opened.add(rn);
+        const spec = ctx.rsm[rn];
+        if (null == spec)
+            return;
+        const openTins = spec.def?.tcol?.[0]?.[0] ?? [];
+        for (const t of openTins)
+            out.add(t);
+        // A rule that opens with an empty-sequence alternate immediately
+        // hands over to its own target: follow that through.
+        for (const a of (spec.def?.open ?? [])) {
+            if (0 === (a.sN | 0)) {
+                addOpeners(a.p);
+                addOpeners(a.r);
+            }
+        }
+    };
+    const stateAlts = (types_1.OPEN === rule.state
+        ? rule.spec.def?.open
+        : rule.spec.def?.close);
+    for (const a of stateAlts ?? []) {
+        const aN = a.sN | 0;
+        if (altMatchDepth(a, ctx) !== aN)
+            continue;
+        // Backtracking moves the handover point: an alternate that matches
+        // sN tokens and pushes back b of them leaves the target rule
+        // starting at sN-b, so its openers are legal at the QUERY position
+        // only when those coincide. Without this, `[A] {b:1, p:child}`
+        // would offer child's openers at the position after A even though
+        // child re-consumes A itself.
+        // The functional form (`b: (rule, ctx, alt) => n`) resolves only
+        // while the alternate is being matched, and this runs outside that
+        // — there is no resolved count to read, so the handover point is
+        // unknown. Skip: a missing completion beats a wrong one.
+        const ab = a.b;
+        if (null != ab && false !== ab && 'number' !== typeof ab)
+            continue;
+        const bN = 'number' === typeof ab ? ab : 0;
+        if (aN - bN !== queryPos)
+            continue;
+        addOpeners(a.p);
+        addOpeners(a.r);
+    }
+    return [...out].sort((a, b) => a - b);
+}
+// Panic-mode recovery: record the error, skip forward to a sync token,
+// pop the rule stack to a rule that can consume it, and return that
+// rule so the main loop continues. Returns undefined to give up (the
+// caller throws; parser.start converts to { value, errors } in
+// recovery mode).
+function attemptRecover(tkn, rule, ctx, parse) {
+    const rec = ctx.cfg.parse.recover;
+    const lex = ctx.lex;
+    if (null == lex)
+        return undefined;
+    // Record the error (the TabnasError constructor pushes to ctx.errs).
+    const err = new error_1.TabnasError(tkn.err || tkn.why || utility_1.S.unexpected, { ...tkn.use, state: parse.is_open ? utility_1.S.open : utility_1.S.close }, tkn, rule, ctx);
+    // Cascade suppression: an error within `suppress` consumed tokens of
+    // the previous recovery is dropped as a follow-on of the same fault.
+    const lastAbs = ctx._recoverAt;
+    if (null != lastAbs && ctx.vAbs - lastAbs < rec.suppress) {
+        if (ctx.errs[ctx.errs.length - 1] === err)
+            ctx.errs.pop();
+    }
+    if (rec.maxRecoveries < ctx.errs.length)
+        return undefined;
+    // Strict-progress guard: when nothing was consumed since the last
+    // recovery, the previous resume point failed to advance the parse
+    // (e.g. every accepting alternate's condition rejected). Requiring
+    // the next sync candidate to sit strictly beyond the previous one
+    // bounds total recoveries by source length, so a recovery can never
+    // loop in place.
+    const lastSI = ctx._recoverSI ?? -1;
+    const noProgress = null != lastAbs && lastAbs === ctx.vAbs;
+    ctx._recoverAt = ctx.vAbs;
+    const sync = computeSyncTins(ctx, rule);
+    const ZZ = ctx.cfg.t.ZZ;
+    const BD = ctx.cfg.t.BD;
+    const IGNORE = ctx.cfg.tokenSetTins.IGNORE;
+    const NOTOKEN = ctx.NOTOKEN;
+    const tbuf = ctx.t;
+    const advancePast = (t, toLineEnd) => advanceLexPast(lex, t, toLineEnd);
+    // Skip forward: drain already-fetched lookahead first (those tokens
+    // advanced the lexer and must not be lost), then pull fresh tokens.
+    // Bad tokens are skipped without recording — they are part of the
+    // same error region.
+    const pending = [];
+    for (let i = 0; i < tbuf.length; i++) {
+        const t = tbuf[i];
+        if (null != t && NOTOKEN !== t)
+            pending.push(t);
+        tbuf[i] = NOTOKEN;
+    }
+    const fetch = () => {
+        let t;
+        do {
+            t = lex.next(rule);
+        } while (IGNORE[t.tin]);
+        return t;
+    };
+    let cand = 0 < pending.length ? pending.shift() : fetch();
+    let skipped = 0;
+    while (ZZ !== cand.tin &&
+        (!sync.has(cand.tin) || (noProgress && cand.sI <= lastSI))) {
+        if (BD === cand.tin) {
+            advancePast(cand, true === MID_CONSTRUCT[cand.why]);
+        }
+        if (rec.maxSkip <= skipped++)
+            return undefined;
+        cand = 0 < pending.length ? pending.shift() : fetch();
+    }
+    // End of source with no progress since the last recovery: the
+    // grammar has already had its chance to close on the end token —
+    // give up rather than spin on the pinned end token.
+    if (ZZ === cand.tin && noProgress && lastSI >= cand.sI) {
+        return undefined;
+    }
+    ;
+    ctx._recoverSI = cand.sI;
+    // Restore the buffer: the sync token first, then any remaining
+    // pre-fetched lookahead in original order.
+    tbuf[0] = cand;
+    for (let i = 0; i < pending.length && i + 1 < tbuf.length; i++) {
+        tbuf[i + 1] = pending[i];
+    }
+    // The skipped region, for diagnostics consumers (not part of the
+    // structured diagnostic JSON shape).
+    ;
+    err.recovered = { skipped, sync: cand.tin };
+    const sig = rec.syncGroups.join(',');
+    if (rec.popUntilValid) {
+        // Resume with the erroring rule itself if its close state accepts
+        // the sync token, else pop ancestors until one does.
+        if (rule !== ctx.NORULE && acceptsClose(rule.spec, cand.tin, rec.syncGroups, sig)) {
+            if (types_1.OPEN === rule.state) {
+                rule.state = types_1.CLOSE;
+            }
+            else if (!parse.is_open) {
+                // The failed pass was this rule's OWN close: its before-close
+                // actions already ran, and re-processing the close pass would
+                // run them again — corrupting non-idempotent actions (e.g. an
+                // element append). Skip them on the resumed pass.
+                ;
+                rule._skipBefores = true;
+            }
+            return rule;
+        }
+        // The erroring rule itself is being abandoned (its close cannot
+        // accept the sync token, and it is not on ctx.rs): synthesize its
+        // close notification first so the structural stream stays balanced.
+        if (rule !== ctx.NORULE && ctx.sub.ruleDone) {
+            const done = { state: types_1.CLOSE, alt: null, forced: true };
+            ctx.sub.ruleDone.map((s) => s(rule, ctx, done));
+        }
+        while (0 < ctx.rsI) {
+            const r = ctx.rs[--ctx.rsI];
+            if (null != r && acceptsClose(r.spec, cand.tin, rec.syncGroups, sig)) {
+                return r;
+            }
+            // Force-popped without a close pass: synthesize the close
+            // notification so structural consumers (outline/folding) see a
+            // balanced event stream even through recovery.
+            if (null != r && ctx.sub.ruleDone) {
+                const done = { state: types_1.CLOSE, alt: null, forced: true };
+                ctx.sub.ruleDone.map((s) => s(r, ctx, done));
+            }
+        }
+        return undefined;
+    }
+    // Fixed-depth pop: one rule.
+    if (0 < ctx.rsI)
+        return ctx.rs[--ctx.rsI];
+    return undefined;
+}
 function parse_alts(is_open, alts, lex, rule, ctx) {
     // One reusable scratch AltMatch per parse Context (allocated lazily on
     // first use). Scoping it to the Context — rather than a module global —
     // keeps nested parses (a plugin action parsing with another instance)
     // from clobbering each other's in-flight match state.
     let out = ctx._palt || (ctx._palt = makeAltMatch());
+    ctx._contTins = undefined;
     out.b = 0; // Backtrack n tokens.
     out.p = types_1.EMPTY; // Push named rule onto stack.
     out.r = types_1.EMPTY; // Replace current rule with named rule.
@@ -627,6 +1042,7 @@ function parse_alts(is_open, alts, lex, rule, ctx) {
     let unCI = 0;
     let unQueue = null;
     let unEnd = undefined;
+    let deepest = 0;
     for (altI = 0; altI < len; altI++) {
         alt = alts[altI];
         // Number of positions that matched in this alt. Tracked so the
@@ -650,7 +1066,9 @@ function parse_alts(is_open, alts, lex, rule, ctx) {
             if (null == tkn || NOTOKEN === tkn) {
                 // Fetch (skipping IGNORE tokens) inline — a nested function here
                 // would allocate a closure on every parse_alts call.
+                let refetch = false;
                 do {
+                    refetch = false;
                     tkn = lex.next(rule, alt, altI, i);
                     ctx.tC++;
                     // Bad tokens abort the parse with their own error code
@@ -669,9 +1087,61 @@ function parse_alts(is_open, alts, lex, rule, ctx) {
                         if (null != tkn.use) {
                             details.use = tkn.use;
                         }
+                        // Opt-in recovery: lexer soft mode. Record the bad token's
+                        // own error and skip it, keeping the fetch going; beyond
+                        // the recovery cap the parse gives up as usual.
+                        const rec = ctx.cfg.parse.recover;
+                        if (rec.enabled) {
+                            const bderr = new error_1.TabnasError(tkn.why || UNEXPECTED, details, tkn, rule, ctx);
+                            // Coalesce a contiguous run of bad tokens (e.g. each
+                            // character of an unlexable word) into one recorded
+                            // error whose region metadata grows with the run, and
+                            // apply the same cascade-suppression window recoveries
+                            // use: a fresh bad region with no consumed tokens since
+                            // the previous recovery is a follow-on of the same fault.
+                            const runEnd = ctx._badTo;
+                            const runErr = ctx._badErr;
+                            const lastAbs = ctx._recoverAt;
+                            if (null != runEnd &&
+                                tkn.sI <= runEnd &&
+                                null != runErr &&
+                                ctx.errs[ctx.errs.length - 1] === bderr) {
+                                ctx.errs.pop();
+                                runErr.recovered.skipped++;
+                                // A run longer than maxSkip gives up like any other
+                                // over-long recovery.
+                                if (rec.maxSkip < runErr.recovered.skipped) {
+                                    throw bderr;
+                                }
+                            }
+                            else if (null != lastAbs &&
+                                ctx.vAbs - lastAbs < rec.suppress &&
+                                ctx.errs[ctx.errs.length - 1] === bderr) {
+                                ctx.errs.pop();
+                                ctx._badErr = null;
+                            }
+                            else {
+                                ;
+                                bderr.recovered = { skipped: 1, bad: true };
+                                ctx._badErr = bderr;
+                                ctx._recoverAt = ctx.vAbs;
+                            }
+                            ;
+                            ctx._badTo = tkn.sI + Math.max(1, tkn.len | 0);
+                            if (rec.maxRecoveries < ctx.errs.length) {
+                                throw bderr;
+                            }
+                            // The bad token did not advance the lex point — move
+                            // past it or the refetch would loop in place. Bad tokens
+                            // raised mid-construct (string escapes/control chars)
+                            // resynchronize at the next line end instead.
+                            advanceLexPast(lex, tkn, true === MID_CONSTRUCT[tkn.why]);
+                            refetch = true;
+                            continue;
+                        }
                         throw new error_1.TabnasError(tkn.why || UNEXPECTED, details, tkn, rule, ctx);
                     }
-                } while (IGNORE[tkn.tin]);
+                } while (refetch || IGNORE[tkn.tin]);
                 tbuf[i] = tkn;
             }
             const Si = S ? S[i] : null;
@@ -765,6 +1235,8 @@ function parse_alts(is_open, alts, lex, rule, ctx) {
             break;
         }
         else {
+            if (matched > deepest)
+                deepest = matched;
             alt = null;
             // This alternate renegotiated a token and then failed anyway —
             // put the cut back, so the alternates and rules that follow see
@@ -775,23 +1247,69 @@ function parse_alts(is_open, alts, lex, rule, ctx) {
                 for (let j = unI + 1; j < tbuf.length; j++) {
                     tbuf[j] = NOTOKEN;
                 }
+                // Re-announce the RESTORED token to lex subscribers: the recut
+                // fired an event when it was cut, and without a matching event
+                // for the undo, a position-keyed consumer's last-write-wins
+                // reconstruction would keep the abandoned recut. After this,
+                // "latest event per source position" is always the token the
+                // parse actually proceeded with.
+                if (ctx.sub.lex) {
+                    ctx.sub.lex.map((sub) => sub(unTkn, rule, ctx));
+                }
                 unI = -1;
             }
         }
     }
     if (!cond) {
         const bad = tbuf[0];
+        ctx._eMax = deepest;
+        // Path-aware continuation tins: for each alternate, count how many
+        // leading positions actually match the buffered lookahead, and
+        // collect the alternate's OWN next-position tins — tcol collation
+        // is path-blind (after matching A of [A,B], a sibling [C,D] must
+        // not contribute D). Error path only; no hot-path cost.
+        {
+            const cont = new Set();
+            for (let aI = 0; aI < len; aI++) {
+                const a = alts[aI];
+                const aN = a.sN | 0;
+                let k = 0;
+                while (k < aN) {
+                    const tk = tbuf[k];
+                    if (null == tk || NOTOKEN === tk)
+                        break;
+                    const Sk = a.S ? a.S[k] : null;
+                    if (null != Sk) {
+                        const tin = tk.tin;
+                        const part = (tin / 31) | 0;
+                        const aaBit = 0 === part ? bitAA : 0;
+                        if (0 === (Sk[part] & ((1 << ((tin % 31) - 1)) | aaBit)))
+                            break;
+                    }
+                    k++;
+                }
+                if (k < aN) {
+                    const next = a.t?.[k] ?? [];
+                    for (const tin of next)
+                        cont.add(tin);
+                }
+            }
+            ;
+            ctx._contTins = [...cont];
+        }
         // No alternate could use the token and it is a bad one: raise the
         // lexer's own error, exactly as the non-negotiated path does at
         // fetch time. Deferring that throw is what let the alternates try to
         // re-cut it; now that all of them have declined, the specific
         // diagnostic is the useful one.
-        if (RELEX && null != bad && BD === bad.tin) {
+        if (RELEX && null != bad && BD === bad.tin && !ctx.cfg.parse.recover.enabled) {
             const details = {};
             if (null != bad.use) {
                 details.use = bad.use;
             }
             throw new error_1.TabnasError(bad.why || UNEXPECTED, details, bad, rule, ctx);
+            // In recovery mode the bad token flows through out.e below into
+            // RuleSpec.bad, which routes it into attemptRecover.
         }
         out.e = tbuf[0] ?? NOTOKEN;
     }