parseman 0.26.2 → 0.27.0

package/dist/index.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../src/index.ts", "../src/combinators/first-set.ts", "../src/combinators/probe.ts", "../src/cst/capture-buffer.ts", "../src/combinators/literal.ts", "../src/regex/classes.ts", "../src/combinators/regex.ts", "../src/regex/first-set.ts", "../src/combinators/keywords.ts", "../src/recovery/scan.ts", "../src/combinators/expect.ts", "../src/combinators/choice.ts", "../src/cst/trivia-kinds.ts", "../src/combinators/trivia-skip.ts", "../src/combinators/sequence.ts", "../src/combinators/repeat.ts", "../src/combinators/ref.ts", "../src/compiler/value-usage.ts", "../src/combinators/parser.ts", "../src/combinators/not.ts", "../src/compiler/build-arity.ts", "../src/compiler/fields.ts", "../src/combinators/node.ts", "../src/combinators/map.ts", "../src/compiler/line-index.ts", "../src/combinators/grammar.ts", "../src/combinators/token.ts", "../src/compiler/scannable-run.ts", "../src/compiler/trivia-fast-path.ts", "../src/compiler/scannable-terminal.ts", "../src/compiler/inline-build.ts", "../src/compiler/inline-callback.ts", "../src/compiler/codegen.ts", "../src/combinators/scanTo.ts", "../src/compiler/ir-serialize.ts", "../src/compiler/linker.ts", "../src/combinators/guard.ts", "../src/combinators/withCtx.ts", "../src/combinators/completions.ts", "../src/cst/relative-spans.ts", "../src/functional/doc.ts", "../src/functional/run.ts", "../src/cst/trivia-index.ts", "../src/cst/walk.ts", "../src/cst/trivia-entries.ts", "../src/cst/offset-model.ts"],
-  "sourcesContent": ["export type { Combinator, ParseResult, ParseOk, ParseFail, ParseContext, ParseError, Span, ParserMeta, FirstSet, CharRange, ParserDef, ChoiceStrategy, AutoNotCheck, GatedArm, BuildHost, CstCollapsePredicate, FieldCapture, FieldMap } from './types.ts'\n\nexport { literal } from './combinators/literal.ts'\nexport type { LiteralOptions } from './combinators/literal.ts'\n\nexport { regex } from './combinators/regex.ts'\n// Wire the hand-rolled first-set analyzer into `regex()`. Importing the library\n// entry opts you into precise choice-dispatch fast paths; a deep-path\n// `import { regex }` (no library entry) gets a permissive fallback, so the\n// analyzer tree-shakes out entirely. The analyzer is a small dependency-free\n// regex parser (`./regex/first-set.ts`) \u2014 no `regexp-tree`, no codegen \u2014 so\n// interpreter-only bundles stay lean.\nimport { registerRegexAnalyzer } from './combinators/regex.ts'\nimport { firstSetFromRegex } from './regex/first-set.ts'\nregisterRegexAnalyzer(firstSetFromRegex)\nexport { keywords, word, makeWord } from './combinators/keywords.ts'\nexport type { KeywordsOptions } from './combinators/keywords.ts'\n\nexport { sequence } from './combinators/sequence.ts'\nexport { choice } from './combinators/choice.ts'\nexport { many, oneOrMore, optional, sepBy } from './combinators/repeat.ts'\nexport { rules } from './combinators/parser.ts'\nexport { ref } from './combinators/ref.ts'\nexport { not } from './combinators/not.ts'\nexport { node } from './combinators/node.ts'\nexport type { BuildNode, NodeOptions } from './combinators/node.ts'\n// lazy() is intentionally NOT exported.\nexport { transform, skip, trivia, label, field } from './combinators/map.ts'\nexport { parse, parser, noTrivia } from './combinators/grammar.ts'\nexport type { ParseOptions, ParserOptions, ParsemanParser } from './combinators/grammar.ts'\nexport { token } from './combinators/token.ts'\n\nexport { compile } from './compiler/codegen.ts'\nexport type { CompiledParser, LinkablePieces } from './compiler/codegen.ts'\n// `pick()` is deliberately NOT re-exported: build-inlining a `pick()` of an imported\n// grammar can't yet carry that grammar's ambient trivia across the module boundary, so\n// the macro would diverge from the interpreter. It stays internal (./compiler/linker.ts)\n// for later exploration of that lowering; `compose()` is the public composition primitive.\nexport { compose, cstBuildHost } from './compiler/linker.ts'\nexport type { CstBuildHostOptions, FusedRule } from './compiler/linker.ts'\n\nexport { buildLineIndex, offsetToLineCol, annotateSpan } from './compiler/line-index.ts'\nexport type { LineIndex } from './compiler/line-index.ts'\n\nexport { guard } from './combinators/guard.ts'\nexport { withCtx } from './combinators/withCtx.ts'\nexport { isParseError } from './combinators/expect.ts'\nexport { expect } from './combinators/expect.ts'\nexport { completionsAt } from './combinators/completions.ts'\nexport { scanTo, balanced } from './combinators/scanTo.ts'\nexport type { ScanToOptions } from './combinators/scanTo.ts'\n\nexport type { CSTNode, CSTLeaf, CSTError, CSTTrivia, CSTChild, CSTRawChild, NodeLike } from './cst/types.ts'\n\nexport { parseDoc } from './functional/doc.ts'\nexport type { ParseDoc, ParseDocOptions, Registry, RuleFn } from './functional/doc.ts'\nexport { run } from './functional/run.ts'\nexport type { RunResult, RunOptions, Runnable } from './functional/run.ts'\nexport { buildTriviaIndex } from './cst/trivia-index.ts'\nexport type { TriviaIndex, TriviaToken, TriviaIndexOptions } from './cst/trivia-index.ts'\nexport { walk, createVisitor } from './cst/walk.ts'\nexport type { Walkable, WalkVisitor, VisitApi, VisitorHandlers } from './cst/walk.ts'\nexport { triviaEntries } from './cst/trivia-entries.ts'\nexport type { TriviaEntriesView } from './cst/trivia-entries.ts'\nexport { triviaKindMask } from './cst/trivia-kinds.ts'\n\nexport {\n  OffsetIndex,\n  buildOffsetIndex,\n  collectLeafSlots,\n  gapText,\n  lineBreaksIn,\n  blankLinesIn,\n  lineStartWithin,\n  indentWidth,\n  indentMixed,\n  commentsIn,\n  gapIsSignificant,\n} from './cst/offset-model.ts'\nexport type { Slot, Gap } from './cst/offset-model.ts'\nexport {\n  relativize,\n  absolutize,\n  absoluteSpanAt,\n  shiftAbsolute,\n  applyEdit,\n  relativizeCST,\n  absolutizeCST,\n  absoluteSpanCST,\n} from './cst/relative-spans.ts'\nexport type { AbsNode, RelNode } from './cst/relative-spans.ts'\n", "import type { CharRange, FirstSet, Combinator, ParserDef } from '../types.ts'\n\nexport function union(a: FirstSet, b: FirstSet): FirstSet {\n  if (a.kind === 'any' || b.kind === 'any') return { kind: 'any' }\n  if (a.kind === 'empty') return b\n  if (b.kind === 'empty') return a\n  return { kind: 'ranges', ranges: mergeRanges([...a.ranges, ...b.ranges]) }\n}\n\nexport function intersects(a: FirstSet, b: FirstSet): boolean {\n  if (a.kind === 'any' || b.kind === 'any') return true\n  if (a.kind === 'empty' || b.kind === 'empty') return false\n  for (const ra of a.ranges) {\n    for (const rb of b.ranges) {\n      if (ra.lo <= rb.hi && rb.lo <= ra.hi) return true\n    }\n  }\n  return false\n}\n\nexport function fromChar(code: number): FirstSet {\n  return { kind: 'ranges', ranges: [{ lo: code, hi: code }] }\n}\n\nexport function fromRange(lo: number, hi: number): FirstSet {\n  return { kind: 'ranges', ranges: [{ lo, hi }] }\n}\n\nexport function any(): FirstSet {\n  return { kind: 'any' }\n}\n\nexport function empty(): FirstSet {\n  return { kind: 'empty' }\n}\n\n/**\n * Can this parser SUCCEED consuming zero characters (nullable / matches-empty)?\n * Used to compute a sound sequence first-set: a nullable leading term lets the\n * NEXT term's first chars start the whole sequence. MUST err toward `true` when\n * unsure \u2014 over-estimating nullability only widens the (over-approximated) first\n * set, which stays sound; under-estimating would drop valid start chars and make\n * first-char dispatch skip a matching arm.\n */\nexport function matchesEmpty(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  // Cycle guard: a mutually-nullable ref cycle (e.g. `A = oneOrMore(B); B = oneOrMore(A)`)\n  // would recurse forever. Treat a re-entered node as nullable \u2014 the safe (`true`)\n  // default, consistent with the err-toward-true contract below.\n  if (seen.has(p)) return true\n  seen.add(p)\n  const me = (c: Combinator<unknown>): boolean => matchesEmpty(c, seen)\n  const d = p._def as ParserDef\n  switch (d.tag) {\n    case 'literal':   return d.value.length === 0\n    case 'keywords':  return false\n    case 'regex':\n      // Precise: does the pattern admit a zero-length match? (`a*`, `a?`, `a|`, \u2026)\n      try { const m = new RegExp(d.source).exec(''); return m != null && m[0] === '' }\n      catch { return true }\n    case 'many':\n    case 'optional':\n    case 'not':       return true          // zero repetitions / absent / lookahead\n    case 'oneOrMore': return me(d.parser)\n    case 'sequence':  return d.parsers.every(me)\n    case 'choice':\n      return d.parsers.some(me)\n    case 'transform':\n    case 'label':\n    case 'trivia':\n    case 'token':\n    case 'expect':\n    case 'withCtx':\n    case 'node':\n    case 'grammar':\n    case 'recover':   return me(d.parser)\n    case 'skip':      return me(d.main)\n    case 'lazy':\n      try { return me(d.thunk()) } catch { return true }\n    default:          return true          // sepBy / scanTo / guard / unknown \u2192 assume nullable (safe)\n  }\n}\n\n/**\n * First-set of a sequence: union each term's first-set through the NULLABLE\n * PREFIX \u2014 a leading `optional(\u2026)` / `many(\u2026)` / nullable term can be skipped, so\n * the sequence can begin with a LATER term's first char. Stop at (and include)\n * the first non-nullable term. (`parsers[0].firstSet` alone under-approximates\n * and silently breaks first-char dispatch \u2014 see the InterpolatedSelector bug.)\n */\nexport function sequenceFirstSet(parsers: readonly Combinator<unknown>[]): FirstSet {\n  let fs: FirstSet = empty()\n  for (const p of parsers) {\n    fs = union(fs, p._meta.firstSet)\n    if (!matchesEmpty(p)) return fs\n  }\n  return fs\n}\n\n/**\n * Deep first-set that RESOLVES `lazy`/`ref` combinators to their targets. The\n * combinators bake `_meta.firstSet` at CONSTRUCTION, when a `ref()` still reads\n * `any()` (define() never updates it) \u2014 so a `choice`/`sequence` built over refs\n * caches a spuriously-`any` first-set and loses first-char dispatch. Recomputing\n * here, following refs, recovers the real set. Over-approximates on cycles /\n * unknown constructs (returns `any`) \u2014 always sound: a wider set only means \"try\n * this arm for more first chars\", never skips a real match.\n *\n * SOUND ONLY where refs are FINAL (monolithic compile). Under compose OVERRIDE a\n * referenced rule can be replaced with a WIDER first-set, so a baked deep set\n * would wrongly skip valid input \u2014 the compose path defers dispatch to fuse time.\n */\nexport function firstSetOf(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): FirstSet {\n  if (seen.has(p)) return any()               // cycle \u2192 any (safe over-approximation)\n  seen.add(p)\n  const fs = (c: Combinator<unknown>): FirstSet => firstSetOf(c, seen)\n  const d = p._def as ParserDef\n  switch (d.tag) {\n    case 'literal':\n    case 'regex':\n    case 'keywords':  return p._meta.firstSet  // terminals: no refs, cached set is exact\n    case 'lazy':\n      try { return fs(d.thunk()) } catch { return any() }\n    case 'choice': {\n      let out: FirstSet = empty()\n      for (const arm of d.parsers) out = union(out, fs(arm))\n      return out\n    }\n    case 'sequence': {\n      // Union through the nullable prefix (a leading nullable term lets a later\n      // term's first chars start the sequence) \u2014 ref-resolving `sequenceFirstSet`.\n      let out: FirstSet = empty()\n      for (const term of d.parsers) { out = union(out, fs(term)); if (!matchesEmpty(term)) return out }\n      return out\n    }\n    case 'oneOrMore':\n    case 'many':\n    case 'optional':\n    case 'transform':\n    case 'label':\n    case 'trivia':\n    case 'token':\n    case 'node':\n    case 'grammar':\n    case 'expect':    return fs(d.parser)\n    case 'sepBy':     return fs(d.parser)\n    case 'skip':      return fs(d.main)\n    default:          return p._meta.firstSet  // not / scanTo / guard / withCtx / recover / unknown\n  }\n}\n\nfunction mergeRanges(ranges: CharRange[]): CharRange[] {\n  if (ranges.length === 0) return []\n  const sorted = [...ranges].sort((a, b) => a.lo - b.lo)\n  // Always copy \u2014 never alias input objects\n  const out: CharRange[] = [{ lo: sorted[0]!.lo, hi: sorted[0]!.hi }]\n  for (let i = 1; i < sorted.length; i++) {\n    const top = out[out.length - 1]!\n    const cur = sorted[i]!\n    if (cur.lo <= top.hi + 1) {\n      if (cur.hi > top.hi) top.hi = cur.hi\n    } else {\n      out.push({ lo: cur.lo, hi: cur.hi })\n    }\n  }\n  return out\n}\n", "import type { ParseContext, ParseFail } from '../types.ts'\n\n/**\n * Creates a ParseFail and, if a completions probe is active, records it.\n *\n * Rules:\n * - Only failures at or before the probe's target offset are eligible.\n * - A deeper failure (higher pos) replaces the current best.\n * - A tie (same pos) merges expected arrays \u2014 this is what makes choice arms\n *   aggregate their alternatives rather than each overwriting the last.\n * - Shallower failures are ignored.\n */\nexport function failAt(ctx: ParseContext, expected: string[], pos: number): ParseFail {\n  const r: ParseFail = { ok: false, expected, span: { start: pos, end: pos } }\n  const probe = ctx._probe\n  if (probe !== undefined && pos <= probe.offset) {\n    const best = probe.best\n    if (best === null || pos > best.span.start) {\n      probe.best = r\n    } else if (pos === best.span.start) {\n      probe.best = { ...best, expected: [...best.expected, ...expected] }\n    }\n  }\n  return r\n}\n", "import type { ParseContext } from '../types.ts'\n\n/** Lazy per-node capture state \u2014 arrays materialized on first push. */\nexport type CstCaptureBuf = {\n  single?: unknown | undefined\n  ch?: unknown[] | undefined\n  rawSingle?: unknown | undefined\n  raw?: unknown[] | undefined\n  tl?: number[] | undefined\n}\n\nconst EMPTY: unknown[] = []\nconst EMPTY_TL: number[] = []\n\nexport function cstCaptureActive(ctx: ParseContext): boolean {\n  return ctx._cstBuf !== undefined || ctx._cstLeaves !== undefined\n}\n\nexport type CstNodeCaptureSaved = {\n  ch: ParseContext['_cstChildren']\n  lv: ParseContext['_cstLeaves']\n  raw: ParseContext['_cstRawChildren']\n  tl: ParseContext['_cstTriviaLog']\n  cap: boolean | undefined\n  buf: CstCaptureBuf | undefined\n}\n\nexport function beginCstNodeCapture(ctx: ParseContext): CstNodeCaptureSaved {\n  const saved: CstNodeCaptureSaved = {\n    ch: ctx._cstChildren,\n    lv: ctx._cstLeaves,\n    raw: ctx._cstRawChildren,\n    tl: ctx._cstTriviaLog,\n    cap: ctx.captureTrivia,\n    buf: ctx._cstBuf,\n  }\n  ctx._cstBuf = {}\n  ctx._cstChildren = undefined\n  ctx._cstLeaves = undefined\n  ctx._cstRawChildren = undefined\n  ctx._cstTriviaLog = undefined\n  ctx.captureTrivia = true\n  return saved\n}\n\nexport function finishCstBuf(buf: CstCaptureBuf | undefined): {\n  children: unknown[]\n  rawChildren: unknown[]\n  triviaLog: number[]\n} {\n  if (!buf) return { children: EMPTY, rawChildren: EMPTY, triviaLog: EMPTY_TL }\n  const children = buf.ch ?? (buf.single !== undefined ? [buf.single] : EMPTY)\n  const rawChildren = buf.raw ?? (buf.rawSingle !== undefined ? [buf.rawSingle] : EMPTY)\n  const triviaLog = buf.tl ?? EMPTY_TL\n  return { children, rawChildren, triviaLog }\n}\n\nexport function endCstNodeCapture(\n  ctx: ParseContext,\n  saved: CstNodeCaptureSaved,\n): { children: unknown[]; rawChildren: unknown[]; triviaLog: number[] } {\n  const materialized = finishCstBuf(ctx._cstBuf)\n  ctx._cstBuf = saved.buf\n  ctx._cstChildren = saved.ch\n  ctx._cstLeaves = saved.lv\n  ctx._cstRawChildren = saved.raw\n  ctx._cstTriviaLog = saved.tl\n  ctx.captureTrivia = saved.cap\n  return materialized\n}\n\nexport function pushCstLeaf(ctx: ParseContext, leaf: unknown): void {\n  pushCstChild(ctx, leaf, leaf)\n}\n\n/** Record a built sub-node into the active collector (children vs rawChildren may differ). */\nexport function pushCstChild(ctx: ParseContext, built: unknown, rawEntry: unknown): void {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.ch) b.ch.push(built)\n    else if (b.single !== undefined) { b.ch = [b.single, built]; b.single = undefined }\n    else b.single = built\n\n    if (b.raw) b.raw.push(rawEntry)\n    else if (b.rawSingle !== undefined) { b.raw = [b.rawSingle, rawEntry]; b.rawSingle = undefined }\n    else b.rawSingle = rawEntry\n    return\n  }\n  if (ctx._cstChildren) ctx._cstChildren.push(built)\n  else if (ctx._cstLeaves) ctx._cstLeaves.push(built)\n  if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry)\n}\n\nexport function cstRawLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.raw) return b.raw.length\n    return b.rawSingle !== undefined ? 1 : 0\n  }\n  return ctx._cstRawChildren?.length ?? 0\n}\n\nexport function cstLeavesLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.ch) return b.ch.length\n    return b.single !== undefined ? 1 : 0\n  }\n  return ctx._cstLeaves?.length ?? 0\n}\n\nexport function cstTlLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) return b.tl?.length ?? 0\n  return ctx._cstTriviaLog?.length ?? 0\n}\n\nexport type CstRollbackMark = { raw: number; tlog: number; leaves: number; fields: number; errors: number }\n\nexport function saveCstMark(ctx: ParseContext): CstRollbackMark {\n  return {\n    raw: cstRawLen(ctx),\n    tlog: cstTlLen(ctx),\n    leaves: cstLeavesLen(ctx),\n    fields: ctx._fields?.length ?? 0,\n    // Speculative rollback must truncate the flat recovery-error sink in lockstep\n    // with the CST leaves: a branch that recovered (pushing a ParseError to\n    // ctx._errors AND embedding it as a CST child via captureError) then failed\n    // must remove BOTH, or the flat error survives as a GHOST that a tree walk\n    // can't see (flat run().errors would disagree with the embedded set).\n    errors: ctx._errors?.length ?? 0,\n  }\n}\n\nfunction rollbackBufList(\n  b: CstCaptureBuf,\n  keyMulti: 'ch' | 'raw',\n  keySingle: 'single' | 'rawSingle',\n  len: number,\n): void {\n  const arr = b[keyMulti]\n  if (arr) {\n    if (len === 0) b[keyMulti] = undefined\n    else if (len === 1) { b[keySingle] = arr[0]; b[keyMulti] = undefined }\n    else arr.length = len\n    return\n  }\n  if (len === 0) b[keySingle] = undefined\n}\n\nexport function rollbackCstCapture(ctx: ParseContext, mark: CstRollbackMark): void {\n  // Truncate the flat recovery-error sink alongside the CST, so a rolled-back\n  // speculative branch leaves no ghost error (see saveCstMark). Guarded on a\n  // present sink + a defined mark (rollbackTrivia forwards the same field).\n  if (ctx._errors && mark.errors !== undefined) ctx._errors.length = mark.errors\n  const b = ctx._cstBuf\n  if (b) {\n    rollbackBufList(b, 'raw', 'rawSingle', mark.raw)\n    rollbackBufList(b, 'ch', 'single', mark.leaves)\n    if (b.tl) {\n      if (mark.tlog === 0) b.tl = undefined\n      else b.tl.length = mark.tlog\n    }\n    if (ctx._fields) ctx._fields.length = mark.fields\n    return\n  }\n  if (ctx._cstRawChildren) ctx._cstRawChildren.length = mark.raw\n  if (ctx._cstTriviaLog) ctx._cstTriviaLog.length = mark.tlog\n  if (ctx._cstLeaves) ctx._cstLeaves.length = mark.leaves\n  if (ctx._fields) ctx._fields.length = mark.fields\n}\n\nexport function pushCstTriviaEntry(\n  ctx: ParseContext,\n  start: number,\n  end: number,\n  kindIndex?: number,\n): void {\n  const insertIdx = cstRawLen(ctx)\n  const b = ctx._cstBuf\n  const withKind = ctx.triviaKindLabels !== undefined && kindIndex !== undefined\n  if (b) {\n    if (!b.tl) {\n      b.tl = withKind ? [start, end, insertIdx, kindIndex] : [start, end, insertIdx]\n    } else if (withKind) {\n      b.tl.push(start, end, insertIdx, kindIndex)\n    } else {\n      b.tl.push(start, end, insertIdx)\n    }\n    return\n  }\n  if (ctx._cstTriviaLog) {\n    if (withKind) ctx._cstTriviaLog.push(start, end, insertIdx, kindIndex)\n    else ctx._cstTriviaLog.push(start, end, insertIdx)\n  }\n}\n\nexport function pushTriviaLogEntry(\n  ctx: ParseContext,\n  start: number,\n  end: number,\n  kindIndex?: number,\n): void {\n  if (!ctx._triviaLog) return\n  if (ctx.triviaKindLabels !== undefined && kindIndex !== undefined) {\n    ctx._triviaLog.push(start, end, kindIndex)\n  } else {\n    ctx._triviaLog.push(start, end)\n  }\n}\n\nexport function cstDeferredTriviaActive(ctx: ParseContext): boolean {\n  return ctx._triviaLog !== undefined || ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { fromChar, empty } from './first-set.ts'\nimport { failAt } from './probe.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\n/**\n * ASCII case-fold equality \u2014 the interpreter twin of the compiler's `foldEq`\n * (and `/i`-flag regex lowering). Folds ASCII letters via bit 0x20, exact-matches\n * everything else. Deliberately NOT `Intl.Collator` (measured ~9\u00D7 slower, and its\n * Unicode accent-folding is the wrong semantic for a parser). Keeps interpreter /\n * compiled / macro output identical for case-insensitive `literal()`.\n */\nfunction asciiFoldEq(a: string, b: string): boolean {\n  if (a.length !== b.length) return false\n  for (let i = 0; i < a.length; i++) {\n    let ca = a.charCodeAt(i)\n    let cb = b.charCodeAt(i)\n    if (ca >= 65 && ca <= 90) ca += 32\n    if (cb >= 65 && cb <= 90) cb += 32\n    if (ca !== cb) return false\n  }\n  return true\n}\n\nexport type LiteralOptions = {\n  caseInsensitive?: boolean\n}\n\nexport function literal(value: string, opts: LiteralOptions = {}): Combinator<string> {\n  const caseInsensitive = opts.caseInsensitive ?? false\n\n  const firstSet = value.length > 0\n    ? fromChar(value.codePointAt(0)!)\n    : empty()\n\n  const meta: ParserMeta = {\n    firstSet,\n    canMatchNewline: value.includes('\\n'),\n    isTrivia: false,\n  }\n\n  if (caseInsensitive) {\n    const upper = value.toUpperCase()\n    const lower = value.toLowerCase()\n    const firstUpper = upper.codePointAt(0)\n    const firstLower = lower.codePointAt(0)\n    // Two discrete points, not one spanning range \u2014 `asciiFoldEq` accepts only\n    // the char and its fold twin, so `[min, max]` would over-approximate (e.g.\n    // 'a'/'A' \u2192 the whole 65..97 span, pulling B\u2013Z/`[\\]^_\\`` into dispatch).\n    meta.firstSet = firstLower !== undefined && firstUpper !== undefined\n      ? firstLower === firstUpper\n        ? { kind: 'ranges', ranges: [{ lo: firstLower, hi: firstLower }] }\n        : { kind: 'ranges', ranges: [\n            { lo: firstLower, hi: firstLower },\n            { lo: firstUpper, hi: firstUpper },\n          ]}\n      : firstSet\n  }\n\n  const expected = [JSON.stringify(value)]\n\n  // Single-char case-sensitive literals are the bulk of punctuation-heavy\n  // grammars (GraphQL `{ } ( ) : $ @ [ ] ! =`, JSON, CSS). A bare `charCodeAt`\n  // compare beats the generic `startsWith` builtin call, and an out-of-bounds\n  // `charCodeAt` returns NaN \u2014 so the length check folds into the compare.\n  const parse = !caseInsensitive && value.length === 1\n    ? (() => {\n        const code = value.charCodeAt(0)\n        return function parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n          if (input.charCodeAt(pos) === code) {\n            const span = { start: pos, end: pos + 1 }\n            if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value, span })\n            return { ok: true, value, span }\n          }\n          return failAt(ctx, expected, pos)\n        }\n      })()\n    : function parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n        const end = pos + value.length\n        if (end > input.length) {\n          return failAt(ctx, expected, pos)\n        }\n        const matchedValue = caseInsensitive ? input.slice(pos, end) : value\n        if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {\n          const span = { start: pos, end }\n          if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value: matchedValue, span })\n          return { ok: true, value: matchedValue, span }\n        }\n        return failAt(ctx, expected, pos)\n      }\n\n  return {\n    _tag: 'literal',\n    _meta: meta,\n    _def: { tag: 'literal', value, caseInsensitive },\n    parse,\n  }\n}\n", "/**\n * Low-level regex char-class primitives, shared by every hand-rolled regex\n * analysis in the codebase \u2014 the interpreter's first-set walker\n * (`./first-set.ts`), `regex()`'s short-scan fast path, and codegen's scannable\n * lowering (`../compiler/scannable-run.ts`). Kept dependency-free (no combinator,\n * no codegen imports) so it lands in even the leanest interpreter bundle.\n *\n * Everything here parses a regex STRUCTURE to code-point ranges; nothing encodes\n * a specific byte meaning (\"this is whitespace\"). `\\d`/`\\w` lower to their ASCII\n * ranges (correct for the default, non-`u` engine); `\\s` uses the fixed\n * `SPACE_RANGES` set (unaffected by the `u` flag).\n */\n\n/** Single-char escapes whose code point is fixed regardless of context. */\nexport const CLASS_ESCAPES: Record<string, number> = { t: 9, n: 10, r: 13, f: 12, v: 11, '0': 0 }\n\n/**\n * `\\s`'s code-point set per the spec's `WhiteSpace` + `LineTerminator`\n * productions \u2014 TAB/LF/VT/FF/CR, SPACE, NBSP, and the Unicode `Zs` space\n * separators. Fixed regardless of the `u` flag, so always safe to lower.\n */\nexport const SPACE_RANGES: Array<[number, number]> = [\n  [9, 13], [32, 32], [160, 160], [5760, 5760], [8192, 8202],\n  [8232, 8232], [8233, 8233], [8239, 8239], [8287, 8287], [12288, 12288], [65279, 65279],\n]\n\n/**\n * ASCII code-point ranges for the shorthand classes we lower. `\\d`/`\\w` are\n * ASCII-only in the default (non-`u`) engine; `\\s` maps to `SPACE_RANGES`.\n */\nexport function shorthandRanges(ch: 'd' | 'w' | 's'): Array<[number, number]> {\n  if (ch === 'd') return [[48, 57]]\n  if (ch === 's') return SPACE_RANGES\n  // Order matches the canonical `scannable-run` lowering (underscore last), so\n  // `ScanShape` output and generated code stay byte-identical. Membership is\n  // order-independent (ranges are iterated / the FirstSet union sorts), so the\n  // non-sorted order is purely representational \u2014 see PR #16 discussion.\n  return [[48, 57], [65, 90], [97, 122], [95, 95]]\n}\n\n/** `\\uXXXX` at `body[i]` \u2192 its code point and the index past it, or null. */\nexport function readUnicodeEscape(body: string, i: number): { cp: number; next: number } | null {\n  if (body[i] !== '\\\\' || body[i + 1] !== 'u') return null\n  const hex = body.slice(i + 2, i + 6)\n  if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null\n  return { cp: Number.parseInt(hex, 16), next: i + 6 }\n}\n\ntype ClassAtom = { cp: number } | { set: Array<[number, number]> }\n\n/**\n * Parse a regex char-class body (the chars BETWEEN `[` and `]`, negation `^`\n * already stripped by the caller) to code-point ranges. `\\d`/`\\w`/`\\s` expand to\n * their ranges; `\\uXXXX` and the fixed single-char escapes resolve to their code\n * point; any other letter escape (`\\D`, `\\W`, `\\S`, `\\b`, \u2026) returns null rather\n * than being mis-read as a literal letter, so callers fall back to a safe\n * over-approximation instead of a wrong set.\n */\nexport function parseClassRanges(body: string): Array<[number, number]> | null {\n  const ranges: Array<[number, number]> = []\n  let i = 0\n  const readAtom = (): ClassAtom | null => {\n    const ch = body[i]\n    if (ch === undefined) return null\n    if (ch === '\\\\') {\n      const uni = readUnicodeEscape(body, i)\n      if (uni) {\n        i = uni.next\n        return { cp: uni.cp }\n      }\n      const e = body[i + 1]\n      if (e === undefined) return null\n      i += 2\n      if (e in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[e]! }\n      if (e === 'd' || e === 'w' || e === 's') return { set: shorthandRanges(e) }\n      // Any other letter escape is a class we can't safely lower (\\D, \\W, \\S, \u2026).\n      if ((e >= 'a' && e <= 'z') || (e >= 'A' && e <= 'Z')) return null\n      return { cp: e.codePointAt(0)! }\n    }\n    i += ch.length\n    return { cp: ch.codePointAt(0)! }\n  }\n  while (i < body.length) {\n    const lo = readAtom()\n    if (lo === null) return null\n    if ('set' in lo) {\n      ranges.push(...lo.set)\n      continue\n    }\n    if (body[i] === '-' && body[i + 1] !== undefined && body[i + 1] !== ']') {\n      i += 1\n      const hi = readAtom()\n      if (hi === null || 'set' in hi) return null\n      ranges.push([lo.cp, hi.cp])\n    } else {\n      ranges.push([lo.cp, lo.cp])\n    }\n  }\n  return ranges.length ? ranges : null\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, FirstSet } from '../types.ts'\nimport { any } from './first-set.ts'\nimport { failAt } from './probe.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\nimport { shorthandRanges, parseClassRanges } from '../regex/classes.ts'\n\n/**\n * Computes a regex terminal's first-set (for choice-dispatch fast paths). The\n * implementation \u2014 `firstSetFromRegex` in `../regex/first-set.ts` \u2014 is a small,\n * dependency-free hand-rolled regex parser, registered by the interpreter/library\n * entry (`index.ts`) via `registerRegexAnalyzer`. It is injected rather than\n * imported so that consumers who import `regex` directly from this subpath (no\n * library entry) never pull the analyzer into their bundle at all. When no\n * analyzer is registered, `regex()` uses the permissive fallback below \u2014 this\n * only disables the dispatch fast paths, never changing matches.\n */\nexport type RegexFirstSetAnalyzer = (pattern: string) => { firstSet: FirstSet; canMatchNewline: boolean }\n\nlet firstSetAnalyzer: RegexFirstSetAnalyzer | null = null\n\nexport function registerRegexAnalyzer(analyzer: RegexFirstSetAnalyzer): void {\n  firstSetAnalyzer = analyzer\n}\n\n/** Fallback when no analyzer is registered: \"could start with any char / could\n * match a newline\" \u2014 the same conservative value `firstSetFromRegex` returns on\n * an unparseable pattern, so a missing analyzer degrades to \"no fast path\", not\n * a wrong one. */\nconst permissiveFirstSet: RegexFirstSetAnalyzer = () => ({ firstSet: any(), canMatchNewline: true })\n\nconst SCAN_BAIL_AT = 64\ntype ShortScanner = (input: string, pos: number) => number | null | undefined\n\nfunction inRanges(cp: number, ranges: Array<[number, number]>): boolean {\n  for (let i = 0; i < ranges.length; i++) {\n    const [lo, hi] = ranges[i]!\n    if (cp >= lo && cp <= hi) return true\n  }\n  return false\n}\n\n/**\n * The positive char-class body (chars between `[` and `]`) as ranges for the\n * short-scan fast path, or null if it can't be lowered \u2014 including a NEGATED\n * class (`[^\u2026]`), which the scan can't express. The class parsing itself is the\n * shared `parseClassRanges` (see `../regex/classes.ts`).\n */\nfunction readClassRanges(body: string): Array<[number, number]> | null {\n  if (body.startsWith('^')) return null\n  return parseClassRanges(body)\n}\n\nfunction shortScanner(source: string, flags: string): ShortScanner | null {\n  if (/[imsuvy]/.test(flags)) return null\n  let ranges: Array<[number, number]> | null = null\n  let quant = ''\n  if (source[0] === '[') {\n    let end = 1\n    while (end < source.length && source[end] !== ']') {\n      if (source[end] === '\\\\') end += 2\n      else end++\n    }\n    if (source[end] !== ']') return null\n    ranges = readClassRanges(source.slice(1, end))\n    quant = source.slice(end + 1)\n  } else if (source[0] === '\\\\' && (source[1] === 'd' || source[1] === 'w' || source[1] === 's')) {\n    ranges = shorthandRanges(source[1])\n    quant = source.slice(2)\n  }\n  if (!ranges || (quant !== '+' && quant !== '*')) return null\n  const minOne = quant === '+'\n  return (input, pos) => {\n    let end = pos\n    while (end < input.length && inRanges(input.charCodeAt(end), ranges)) {\n      end++\n      if (end - pos >= SCAN_BAIL_AT) return undefined\n    }\n    return minOne && end === pos ? null : end\n  }\n}\n\nexport function regex(pattern: string | RegExp, flags = ''): Combinator<string> {\n  const source = typeof pattern === 'string' ? pattern : pattern.source\n  const resolvedFlags = typeof pattern === 'string' ? flags : pattern.flags\n\n  const anchored = new RegExp(source, 'y' + resolvedFlags.replace(/[gy]/g, ''))\n  const scan = shortScanner(source, resolvedFlags)\n\n  const { firstSet, canMatchNewline } = (firstSetAnalyzer ?? permissiveFirstSet)(source)\n  const meta: ParserMeta = { firstSet, canMatchNewline, isTrivia: false }\n\n  return {\n    _tag: 'regex',\n    _meta: meta,\n    _def: { tag: 'regex', source, flags: resolvedFlags },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      const scanEnd = scan?.(input, pos)\n      if (scanEnd !== undefined) {\n        if (scanEnd === null) return failAt(ctx, [`/${source}/`], pos)\n        const value = input.slice(pos, scanEnd)\n        const span = { start: pos, end: scanEnd }\n        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value, span })\n        return { ok: true, value, span }\n      }\n      anchored.lastIndex = pos\n      const m = anchored.exec(input)\n      if (m === null) {\n        return failAt(ctx, [`/${source}/`], pos)\n      }\n      const span = { start: pos, end: pos + m[0]!.length }\n      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value: m[0]!, span })\n      return { ok: true, value: m[0]!, span }\n    },\n  }\n}\n", "/**\n * Hand-rolled first-set analysis for `regex()` terminals \u2014 the interpreter's\n * replacement for the old `regexp-tree`-backed analyzer (~264 KB). A `regex()`\n * terminal's first-set is used ONLY to let `choice()` do first-char dispatch\n * (see `choice.ts`); it is never consulted for whether a match succeeds. So this\n * analyzer only has to be SOUND as an OVER-approximation: every char the pattern\n * can actually start with must be in the returned set. Any construct it can't\n * pin down widens to `any()` (\u2014 \"could start with anything\" \u2014), which only\n * disables a dispatch fast path, never changes a parse. Under-approximating\n * (dropping a real start char) WOULD be a bug: dispatch would skip a matching\n * arm. The soundness fuzz test (`test/unit/regex-first-set.test.ts`) checks this\n * against the real `RegExp` engine as an oracle.\n *\n * It parses the regex into a tiny AST (single-char matchers, sequence,\n * alternation, repetition, zero-width) reusing the shared char-class primitives\n * in `./classes.ts`, then walks the AST unioning first-sets through the nullable\n * prefix \u2014 the same shape the `regexp-tree` walker used.\n *\n * Note: flags are not consulted (matching the prior `regexp-tree` seam, which\n * parsed `/${source}/` with no flags), so an `/i` pattern's first-set is its\n * literal-case set. Sound for dispatch because the interpreter's `/i` regex arms\n * are compared case-sensitively at the same seam.\n */\nimport type { FirstSet } from '../types.ts'\nimport { any, empty, fromRange, union } from '../combinators/first-set.ts'\nimport { shorthandRanges, parseClassRanges } from './classes.ts'\n\n// A minimal regex AST. Each node answers two questions: what first chars can a\n// non-empty match begin with (`firstSet`), and can the node match zero chars\n// (`nullable`). `any` is the over-approximation sentinel for anything we don't\n// model precisely.\ntype Node =\n  | { t: 'char'; set: FirstSet; nl: boolean } // matches exactly one char from `set`\n  | { t: 'any' }                              // unknown 1-char-ish construct: could start with anything\n  | { t: 'empty' }                            // zero-width: anchors, lookaround, word boundary\n  | { t: 'seq'; parts: Node[] }\n  | { t: 'alt'; arms: Node[] }\n  | { t: 'rep'; node: Node; min: number }     // quantified; min 0 \u21D2 nullable\n\nconst ANY: Node = { t: 'any' }\nconst EMPTY: Node = { t: 'empty' }\n\nfunction charNode(set: FirstSet, nl: boolean): Node {\n  return { t: 'char', set, nl }\n}\n\nfunction rangesToSet(ranges: Array<[number, number]>): FirstSet {\n  let fs: FirstSet = empty()\n  for (const [lo, hi] of ranges) fs = union(fs, fromRange(lo, hi))\n  return fs\n}\n\nfunction rangesHaveNewline(ranges: Array<[number, number]>): boolean {\n  return ranges.some(([lo, hi]) => lo <= 0x0a && 0x0a <= hi)\n}\n\n// ---------------------------------------------------------------------------\n// Parser: recursive descent over a raw regex source (no surrounding delimiters).\n// Throws `Bail` on a structure it can't parse (unbalanced group/class); the\n// entry point catches it and degrades the WHOLE pattern to `any()`. A construct\n// that parses but isn't modeled (a backreference, an exotic escape) becomes an\n// `any` NODE instead \u2014 sound and more precise, since it only pollutes the\n// first-set if reached in the nullable prefix.\n// ---------------------------------------------------------------------------\n\n/** Thrown on a structure the parser can't handle (unbalanced group/class); the\n * entry point catches it and degrades the whole pattern to `any()`. */\nconst BAIL = Symbol('regex-bail')\n\n/**\n * Parse a raw regex `src` (no delimiters) into a `Node`, or throw `BAIL`.\n * Closure over a single cursor `i` \u2014 recursive-descent: alt \u2192 seq \u2192 quantified\n * \u2192 atom.\n */\nfunction parseRegex(src: string): Node {\n  let i = 0\n\n  const parseAlt = (): Node => {\n    const arms: Node[] = [parseSeq()]\n    while (src[i] === '|') { i++; arms.push(parseSeq()) }\n    return arms.length === 1 ? arms[0]! : { t: 'alt', arms }\n  }\n\n  const parseSeq = (): Node => {\n    const parts: Node[] = []\n    while (i < src.length) {\n      const ch = src[i]!\n      if (ch === '|' || ch === ')') break\n      parts.push(parseQuantified())\n    }\n    if (parts.length === 0) return EMPTY\n    return parts.length === 1 ? parts[0]! : { t: 'seq', parts }\n  }\n\n  const parseQuantified = (): Node => {\n    const atom = parseAtom()\n    const ch = src[i]\n    let min: number | null = null\n    if (ch === '*') { min = 0; i++ }\n    else if (ch === '+') { min = 1; i++ }\n    else if (ch === '?') { min = 0; i++ }\n    else if (ch === '{') { min = parseBraceQuantifier() }\n    if (min === null) return atom\n    // Consume a lazy `?` on the quantifier \u2014 it changes greediness, not first-set.\n    if (src[i] === '?') i++\n    return { t: 'rep', node: atom, min }\n  }\n\n  // Parse `{n}` / `{n,}` / `{n,m}` at `i` (on `{`), returning the minimum; null\n  // (leaving `{` unconsumed) if it isn't a well-formed brace quantifier, so the\n  // caller keeps the `{` as the literal atom it already parsed.\n  const parseBraceQuantifier = (): number | null => {\n    const close = src.indexOf('}', i)\n    if (close === -1) return null\n    const m = /^(\\d+)(?:,(\\d*))?$/.exec(src.slice(i + 1, close))\n    if (!m) return null\n    i = close + 1\n    return Number.parseInt(m[1]!, 10)\n  }\n\n  const parseAtom = (): Node => {\n    const ch = src[i]!\n    switch (ch) {\n      case '(': return parseGroup()\n      case '[': return parseClass()\n      case '.': i++; return charNode(any(), false) // `.` matches any char except line terminators\n      case '\\\\': return parseEscape()\n      case '^':\n      case '$': i++; return EMPTY // anchors are zero-width\n      case '{': i++; return charNode(fromRange(0x7b, 0x7b), false) // a `{` with nothing to quantify is a literal brace\n      default:\n        i += ch.length\n        return charNode(fromRange(ch.codePointAt(0)!, ch.codePointAt(0)!), ch === '\\n')\n    }\n  }\n\n  const parseGroup = (): Node => {\n    i++ // consume '('\n    // Group prefixes: (?:\u2026) (?=\u2026) (?!\u2026) (?<=\u2026) (?<!\u2026) (?<name>\u2026)\n    let lookaround = false\n    if (src[i] === '?') {\n      const c1 = src[i + 1]\n      if (c1 === ':') i += 2\n      else if (c1 === '=' || c1 === '!') { i += 2; lookaround = true }\n      else if (c1 === '<') {\n        const c2 = src[i + 2]\n        if (c2 === '=' || c2 === '!') { i += 3; lookaround = true } // lookbehind\n        else { // named group (?<name>\u2026): skip to '>'\n          const gt = src.indexOf('>', i)\n          if (gt === -1) throw BAIL\n          i = gt + 1\n        }\n      } else throw BAIL // (? followed by something unexpected\n    }\n    const inner = parseAlt()\n    if (src[i] !== ')') throw BAIL\n    i++ // consume ')'\n    return lookaround ? EMPTY : inner // lookaround is zero-width\n  }\n\n  const parseClass = (): Node => {\n    // Read `[ ... ]`, honoring `\\]`; detect leading `^` negation.\n    let k = i + 1\n    const negated = src[k] === '^'\n    if (negated) k++\n    let body = ''\n    while (k < src.length && src[k] !== ']') {\n      if (src[k] === '\\\\') { body += src[k]! + (src[k + 1] ?? ''); k += 2 }\n      else { body += src[k]!; k++ }\n    }\n    if (src[k] !== ']') throw BAIL\n    i = k + 1\n    // A negated class can start with (almost) any char, and can match a newline\n    // unless it excludes it (we don't try to prove exclusion \u2014 `true` is the safe\n    // over-approximation).\n    if (negated) return charNode(any(), true)\n    const ranges = parseClassRanges(body)\n    if (!ranges) return charNode(any(), true) // unparseable class \u2192 widen\n    return charNode(rangesToSet(ranges), rangesHaveNewline(ranges))\n  }\n\n  const parseEscape = (): Node => {\n    const e = src[i + 1]\n    if (e === undefined) throw BAIL\n    // \\uXXXX\n    if (e === 'u' && /^[0-9a-fA-F]{4}$/.test(src.slice(i + 2, i + 6))) {\n      const cp = Number.parseInt(src.slice(i + 2, i + 6), 16)\n      i += 6\n      return charNode(fromRange(cp, cp), cp === 0x0a)\n    }\n    // \\xHH\n    if (e === 'x' && /^[0-9a-fA-F]{2}$/.test(src.slice(i + 2, i + 4))) {\n      const cp = Number.parseInt(src.slice(i + 2, i + 4), 16)\n      i += 4\n      return charNode(fromRange(cp, cp), cp === 0x0a)\n    }\n    i += 2\n    switch (e) {\n      case 'd': return charNode(rangesToSet(shorthandRanges('d')), false)\n      case 'w': return charNode(rangesToSet(shorthandRanges('w')), false)\n      case 's': return charNode(rangesToSet(shorthandRanges('s')), true)\n      case 'D': case 'W': case 'S': return charNode(any(), true) // negated shorthand \u2192 widen\n      case 'b': case 'B': return EMPTY // word boundary: zero-width\n      case 'n': return charNode(fromRange(0x0a, 0x0a), true)\n      case 'r': return charNode(fromRange(0x0d, 0x0d), false)\n      case 't': return charNode(fromRange(0x09, 0x09), false)\n      case 'f': return charNode(fromRange(0x0c, 0x0c), false)\n      case 'v': return charNode(fromRange(0x0b, 0x0b), false)\n      case '0': return charNode(fromRange(0, 0), false)\n      default:\n        // A digit escape is a backreference we don't resolve \u2192 widen.\n        if (e >= '1' && e <= '9') return ANY\n        // Any other escape is a literal char (escaped metachar, `\\/`, etc.).\n        return charNode(fromRange(e.codePointAt(0)!, e.codePointAt(0)!), e === '\\n')\n    }\n  }\n\n  const node = parseAlt()\n  if (i < src.length) throw BAIL // leftover (e.g. an unbalanced `)`)\n  return node\n}\n\n// ---------------------------------------------------------------------------\n// Walkers over the AST.\n// ---------------------------------------------------------------------------\n\n/** Can `n` succeed consuming zero characters? Err toward `true` when unsure \u2014\n * over-estimating nullability only widens the (over-approximated) first-set. */\nfunction nullable(n: Node): boolean {\n  switch (n.t) {\n    case 'char': return false\n    case 'any': return true\n    case 'empty': return true\n    case 'seq': return n.parts.every(nullable)\n    case 'alt': return n.arms.some(nullable)\n    case 'rep': return n.min === 0 || nullable(n.node)\n  }\n}\n\n/** First chars a non-empty match of `n` can begin with (over-approximated). */\nfunction firstSet(n: Node): FirstSet {\n  switch (n.t) {\n    case 'char': return n.set\n    case 'any': return any()\n    case 'empty': return empty()\n    case 'rep': return firstSet(n.node)\n    case 'alt': {\n      let fs: FirstSet = empty()\n      for (const arm of n.arms) fs = union(fs, firstSet(arm))\n      return fs\n    }\n    case 'seq': {\n      // Union each part's first-set through the nullable prefix: a leading\n      // nullable part lets a LATER part's first chars start the sequence.\n      let fs: FirstSet = empty()\n      for (const part of n.parts) {\n        fs = union(fs, firstSet(part))\n        if (!nullable(part)) break\n      }\n      return fs\n    }\n  }\n}\n\n/** Whether the first consumed char can be a newline (tracked separately from\n * `firstSet` because `.`/`\\D`/negated classes widen to `any` yet differ on\n * whether that includes a newline). */\nfunction firstCanBeNewline(n: Node): boolean {\n  switch (n.t) {\n    case 'char': return n.nl\n    case 'any': return true\n    case 'empty': return false\n    case 'rep': return firstCanBeNewline(n.node)\n    case 'alt': return n.arms.some(firstCanBeNewline)\n    case 'seq': {\n      for (const part of n.parts) {\n        if (firstCanBeNewline(part)) return true\n        if (!nullable(part)) break\n      }\n      return false\n    }\n  }\n}\n\n/**\n * Compute a regex terminal's first-set and newline-start flag from its SOURCE\n * (no delimiters, no flags). Over-approximates: an unparseable pattern degrades\n * to `{ any, canMatchNewline: true }` \u2014 the same conservative value the prior\n * `regexp-tree` seam returned on a parse failure.\n */\nexport function firstSetFromRegex(source: string): { firstSet: FirstSet; canMatchNewline: boolean } {\n  let ast: Node\n  try {\n    ast = parseRegex(source)\n  } catch {\n    return { firstSet: any(), canMatchNewline: true }\n  }\n  // A NULLABLE pattern (can match zero chars) must widen to `any()`: as a\n  // `choice()` arm it can succeed with an empty match at ANY position, so a\n  // narrow first-set would let first-char dispatch wrongly skip it. Only a\n  // pattern that must consume \u22651 char has a meaningful first-set.\n  if (nullable(ast)) return { firstSet: any(), canMatchNewline: true }\n  return { firstSet: firstSet(ast), canMatchNewline: firstCanBeNewline(ast) }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, FirstSet } from '../types.ts'\nimport { fromChar, union, empty } from './first-set.ts'\nimport { failAt } from './probe.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\nexport type KeywordsOptions = {\n  /** Match case-insensitively. */\n  caseInsensitive?: boolean\n  /**\n   * Character class (regex source, e.g. `'A-Za-z0-9_-'`) that must NOT follow a\n   * match \u2014 a word boundary. Prevents matching `red` inside `redish`.\n   */\n  boundary?: string\n}\n\n/**\n * Match a single keyword with an automatic word-boundary guard. Prevents\n * matching `true` inside `trueish`. The boundary defaults to `_0-9A-Za-z`,\n * which covers most programming-language identifiers.\n *\n *   word('true')              // matches \"true\" but not \"trueish\"\n *   word('color', 'A-Za-z-') // CSS-style identifier boundary\n */\nexport function word(str: string, boundary = '_0-9A-Za-z'): Combinator<string> {\n  return keywords([str], { boundary })\n}\n\n/**\n * Create a keyword factory with a fixed word-boundary class. Use when many\n * keywords share the same boundary (e.g. CSS identifiers). For a single keyword,\n * `word(str, boundary?)` is enough; you can also roll your own factory with\n * `(s) => word(s, boundary)`.\n *\n *   const kw = makeWord()                    // default: '_0-9A-Za-z'\n *   const cssKw = makeWord('A-Za-z0-9_-')    // dashes allowed in CSS idents\n *\n *   const query = kw('query')\n *   const color = cssKw('color')             // matches \"color\" but not \"color-scheme\"\n */\nexport function makeWord(boundary = '_0-9A-Za-z'): (str: string) => Combinator<string> {\n  return (str: string) => keywords([str], { boundary })\n}\n\nfunction escapeRe(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/**\n * Match any one of a set of fixed keywords, longest-first (so `border` wins over\n * `bord`), with an optional trailing word-boundary guard. Compiles to a single\n * sticky regex \u2014 far less error-prone than a hand-maintained alternation, and\n * the common case (keyword sets: CSS colors, units, at-rule names, HTML tags).\n *\n *   keywords(CSS_COLOR_NAMES, { caseInsensitive: true, boundary: 'A-Za-z0-9_-' })\n *\n * On success the matched text is recorded as a CSTLeaf (like literal()/regex()).\n */\nexport function keywords(words: readonly string[], opts: KeywordsOptions = {}): Combinator<string> {\n  // Longest-first keeps the alternation greedy-correct (regex alternation is\n  // first-match, not longest-match).\n  const sorted = [...new Set(words)].sort((a, b) => b.length - a.length)\n  const alt = sorted.map(escapeRe).join('|')\n  const boundary = opts.boundary ? `(?![${opts.boundary}])` : ''\n  const flags = opts.caseInsensitive ? 'iuy' : 'uy'\n  const re = new RegExp(`(?:${alt})${boundary}`, flags)\n\n  // First-set: the set of first code points across all keywords (and their\n  // case-folded variants when case-insensitive), for choice() dispatch.\n  let firstSet: FirstSet = empty()\n  for (const w of sorted) {\n    if (w.length === 0) continue\n    const cp = w.codePointAt(0)!\n    firstSet = union(firstSet, fromChar(cp))\n    if (opts.caseInsensitive) {\n      const u = String.fromCodePoint(cp).toUpperCase().codePointAt(0)\n      const l = String.fromCodePoint(cp).toLowerCase().codePointAt(0)\n      if (u !== undefined) firstSet = union(firstSet, fromChar(u))\n      if (l !== undefined) firstSet = union(firstSet, fromChar(l))\n    }\n  }\n\n  const meta: ParserMeta = { firstSet, canMatchNewline: false, isTrivia: false }\n\n  return {\n    _tag: 'keywords',\n    _meta: meta,\n    _def: { tag: 'keywords', words: sorted, caseInsensitive: opts.caseInsensitive ?? false, boundary: opts.boundary },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      re.lastIndex = pos\n      const m = re.exec(input)\n      if (m === null || m.index !== pos) {\n        return failAt(ctx, ['keyword'], pos)\n      }\n      const value = m[0]!\n      const span = { start: pos, end: pos + value.length }\n      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value, span })\n      return { ok: true, value, span }\n    },\n  }\n}\n", "import type { Combinator, FirstSet, ParseContext, ParseError, ParseResult, RecoveryHelpers } from '../types.ts'\nimport { cstCaptureActive, pushCstChild } from '../cst/capture-buffer.ts'\n\n/**\n * Recovery MECHANISM \u2014 sync-source-agnostic. These primitives implement \"scan\n * forward to a sync token and emit a ParseError\" and \"is the sync token here?\".\n * They are deliberately independent of WHERE the sync sentinel comes from: the\n * grammar never carries recovery config. Sync points are inferred automatically\n * from grammar structure (see `infer.ts`) and may be overridden externally by the\n * language service via `ctx._listSync`. This is the salvaged core of the old\n * `combinators/recover-scan.ts`.\n */\n\n/**\n * Run `sentinel` at `pos` as PURE lookahead: succeed/fail only, with every\n * side-effecting sink suppressed (CST leaves/children/trivia, the trivia log,\n * the recovery error sink, and the completions probe). A recovery scan probes the\n * sentinel at many positions and must not capture leaves, log trivia, or pollute\n * `completionsAt`'s furthest-failure set as a byproduct of looking ahead.\n */\nfunction probeAt(sentinel: Combinator<unknown>, input: string, pos: number, ctx: ParseContext): boolean {\n  const s = {\n    _probe: ctx._probe, _errors: ctx._errors,\n    _cstLeaves: ctx._cstLeaves, _cstChildren: ctx._cstChildren, _cstRawChildren: ctx._cstRawChildren,\n    _cstTriviaLog: ctx._cstTriviaLog, _triviaLog: ctx._triviaLog, _fields: ctx._fields, _cstBuf: ctx._cstBuf,\n    _tolerant: ctx._tolerant, _sync: ctx._sync,\n  }\n  ctx._probe = undefined; ctx._errors = undefined\n  ctx._cstLeaves = undefined; ctx._cstChildren = undefined; ctx._cstRawChildren = undefined\n  ctx._cstTriviaLog = undefined; ctx._triviaLog = undefined; ctx._fields = undefined; ctx._cstBuf = undefined\n  // A sentinel is pure lookahead: it must not itself enter tolerant recovery (nor\n  // read a stale outer `_sync`). Otherwise a sentinel that composes many/sepBy would\n  // run recovery on every probed position \u2014 wasted work, and it could resync to the\n  // enclosing list's sync token. Cleared here and restored in `finally`.\n  ctx._tolerant = undefined; ctx._sync = undefined\n  try {\n    return sentinel.parse(input, pos, ctx).ok\n  } finally {\n    ctx._probe = s._probe; ctx._errors = s._errors\n    ctx._cstLeaves = s._cstLeaves; ctx._cstChildren = s._cstChildren; ctx._cstRawChildren = s._cstRawChildren\n    ctx._cstTriviaLog = s._cstTriviaLog; ctx._triviaLog = s._triviaLog; ctx._fields = s._fields; ctx._cstBuf = s._cstBuf\n    ctx._tolerant = s._tolerant; ctx._sync = s._sync\n  }\n}\n\n/**\n * Combine two recovery sentinels into one that matches when either does \u2014 used by\n * tolerant `sepBy` to resync to its own separator OR the enclosing delimiter. Cold\n * path only; a bare wrapper so we don't pull `choice()` (and its analysis) in.\n */\nexport function orSentinel(\n  a: Combinator<unknown>,\n  b: Combinator<unknown> | undefined,\n): Combinator<unknown> {\n  if (b === undefined) return a\n  return {\n    _tag: 'orSentinel',\n    _meta: { firstSet: { kind: 'any' }, canMatchNewline: false, isTrivia: false },\n    _def: { tag: 'unknown' },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<unknown> {\n      const ra = a.parse(input, pos, ctx)\n      if (ra.ok) return ra\n      return b.parse(input, pos, ctx)\n    },\n  }\n}\n\n/**\n * A lightweight zero-width sentinel that \"matches\" (succeeds, consuming nothing)\n * when the input code point at `pos` starts the given first set. Sync inference\n * builds one from a list's follow set so a nested list can resync to the enclosing\n * delimiter with no grammar annotation. Returns `null` when the first set is `any`\n * or `empty` (no usable inference).\n */\nexport function firstSetSentinel(fs: FirstSet): Combinator<null> | null {\n  if (fs.kind !== 'ranges' || fs.ranges.length === 0) return null\n  const ranges = fs.ranges\n  return {\n    _tag: 'firstSetSentinel',\n    _meta: { firstSet: fs, canMatchNewline: false, isTrivia: false },\n    _def: { tag: 'unknown' },\n    parse(input: string, pos: number): ParseResult<null> {\n      const code = pos < input.length ? input.codePointAt(pos) : undefined\n      if (code !== undefined) {\n        for (const r of ranges) {\n          if (code >= r.lo && code <= r.hi) return { ok: true, value: null, span: { start: pos, end: pos } }\n        }\n      }\n      return { ok: false, expected: [], span: { start: pos, end: pos } }\n    },\n  }\n}\n\n/**\n * Cold-path recovery scan shared by tolerant `many()` / `sepBy()`. Scans forward\n * from `from` until `sync` matches (or EOF) \u2014 probing the sentinel as pure\n * lookahead \u2014 emits a {@link ParseError} spanning the skipped range, and pushes it\n * to `ctx._errors`. The sync token is NOT consumed; the caller's loop resumes from\n * `end`. Only ever reached after an element has failed, so entirely off the hot path.\n *\n * The caller owns the loop guard: `sepBy` progress is driven by its separator (a\n * zero-width error for a missing element is fine); `many` checks `matchesAt(sync)`\n * itself and breaks when sitting on the terminator, so a zero-width failure can\n * never spin.\n */\nexport function recoverScan(\n  input: string,\n  from: number,\n  ctx: ParseContext,\n  sync: Combinator<unknown>,\n  expected: string[],\n): { error: ParseError; end: number } {\n  let scanPos = from\n  while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++\n  const error: ParseError = { _tag: 'parseError', span: { start: from, end: scanPos }, expected }\n  ctx._errors?.push(error)\n  return { error, end: scanPos }\n}\n\n/**\n * Does `sentinel` match at `pos` (pure lookahead)? Used by the tolerant list loops\n * to detect \"we are sitting on the sync/terminator token\" without consuming it or\n * capturing anything.\n */\nexport function matchesAt(\n  sentinel: Combinator<unknown>,\n  input: string,\n  pos: number,\n  ctx: ParseContext,\n): boolean {\n  return probeAt(sentinel, input, pos, ctx)\n}\n\n/**\n * Embed a recovered error as a `parseError` CST child at the recovery point, so the\n * error lives IN the tree (rides reused subtrees across incremental edits; a tree\n * walk finds every diagnostic) \u2014 not only in the flat `ctx._errors` side-channel.\n * No-op when CST capture is off (value/AST mode). Both the interpreter list loops\n * and the compiled recovery branches call this (the latter via `_ctx._rec.capture`),\n * so the embedded node is identical on both paths.\n */\nexport function captureError(ctx: ParseContext, error: ParseError): void {\n  if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error)\n}\n\n/**\n * The recovery-helper bundle handed to a tolerant parse via `ctx._rec`. A COMPILED\n * grammar can't import these, so the driver (`run`, `parseDoc`) injects them; the\n * interpreter list loops read the same bundle, guaranteeing byte-identical recovery\n * across paths. Shared here so every driver installs the exact same instance.\n */\nexport const REC: RecoveryHelpers = { scan: recoverScan, at: matchesAt, or: orSentinel, sentinel: firstSetSentinel, capture: captureError }\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, ParseError } from '../types.ts'\nimport { captureError } from '../recovery/scan.ts'\n\nexport type { ParseError }\n\n/**\n * Statically derive the \"expected\" token set from a combinator's structure,\n * so a failure can name what it wanted without running anything:\n *\n *   literal('}')        -> ['\"}\"']\n *   keywords(['a','b']) -> ['\"a\"', '\"b\"']\n *   choice(x, y)        -> expected(x) ++ expected(y)   (all alternatives)\n *   sequence(a, b, \u2026)   -> expected(a)                  (only the first term can fail first)\n *   label('s', x)       -> ['s']                        (an explicit name wins)\n *\n * This is what lets expect() report a meaningful, IDENTICAL expectation in both\n * the interpreter and the compiled output (the compiled path does not rebuild the\n * runtime `expected` array, so it reads this precomputed set instead).\n */\nexport function deriveExpected(c: Combinator<unknown>): string[] {\n  const def = c._def\n  switch (def.tag) {\n    case 'literal':   return [JSON.stringify(def.value)]\n    case 'regex':     return [`/${def.source}/`]\n    case 'keywords':  return def.words.map(w => JSON.stringify(w))\n    case 'label':     return [def.label]\n    case 'choice':    return def.parsers.flatMap(deriveExpected)\n    case 'sequence':  return def.parsers.length > 0 ? deriveExpected(def.parsers[0]!) : []\n    case 'node':\n    case 'grammar':\n    case 'trivia':\n    case 'token':\n    case 'optional':\n    case 'many':\n    case 'oneOrMore':\n    case 'transform':\n    case 'not':       return deriveExpected(def.parser)\n    case 'lazy': {\n      // An EXTERNAL ref (a rule from a composed base grammar) has no local\n      // definition yet \u2014 its `thunk()` throws until fusion supplies it. Fall back\n      // to the rule name as the expected label instead of descending.\n      const name = (c as { _ruleName?: string })._ruleName\n      try { return deriveExpected(def.thunk()) }\n      catch { return name ? [name] : [] }\n    }\n    default:          return []\n  }\n}\n\n/**\n * Required-token combinator. Tries `combinator`; on success returns it verbatim.\n * On failure it does NOT fail \u2014 it records a {@link ParseError} (the statically\n * derived expected set, or `label` when given) into `ctx._errors` and RECOVERS IN\n * PLACE, returning a zero-width success so the enclosing sequence continues as if\n * the token were present.\n *\n * Use it to mark required delimiters/terminators (`}` `)` `;`, a selector before a\n * block) so a missing one is reported with position + expectation rather than\n * aborting the whole parse or being silently swallowed by a catch-all.\n *\n *   sequence(literal('{'), declList, expect(literal('}')))\n *\n * Errors are only collected when the parse runs with `{ recover: true }`; without\n * it, expect() still recovers in place but records nothing (zero overhead beyond\n * the inner attempt).\n */\nexport function expect<T>(combinator: Combinator<T>, label?: string): Combinator<T | ParseError> {\n  const expected = label !== undefined ? [label] : deriveExpected(combinator)\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'expect',\n    _meta: meta,\n    _def: { tag: 'expect', parser: combinator as Combinator<unknown>, label, expected },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T | ParseError> {\n      const result = combinator.parse(input, pos, ctx)\n      if (result.ok) return result as ParseResult<T | ParseError>\n      const error: ParseError = { _tag: 'parseError', span: { start: pos, end: pos }, expected }\n      ctx._errors?.push(error)\n      // Embed the missing-token error as a `parseError` CST child (no-op when CST\n      // capture is off), so it rides the tree exactly like list-recovery errors \u2014\n      // a tree walk finds every diagnostic and the error survives incremental\n      // reuse, rather than living only in the flat ctx._errors side-channel. Gated\n      // on tolerant like the list-recovery embed sites, so a strict CST build is\n      // byte-identical to before (and stays in parity with the compiled path,\n      // which can only embed when the recovery bundle `_rec` is installed).\n      if (ctx._tolerant) captureError(ctx, error)\n      return { ok: true, value: error, span: { start: pos, end: pos } }\n    },\n  }\n}\n\n/** True when `value` is a recovery {@link ParseError} node. */\nexport function isParseError(value: unknown): value is ParseError {\n  return typeof value === 'object' && value !== null && (value as ParseError)._tag === 'parseError'\n}\n", "import type {\n  Combinator, ParseContext, ParseResult, ParserMeta, FirstSet,\n  AutoNotCheck, CharRange, ChoiceStrategy, GatedArm,\n} from '../types.ts'\nimport { union, intersects, matchesEmpty } from './first-set.ts'\nimport { deriveExpected } from './expect.ts'\nimport { saveCstMark, rollbackCstCapture } from '../cst/capture-buffer.ts'\n\ntype ArmParser<T> = T extends GatedArm<infer U> ? Combinator<U> : T extends Combinator<infer U> ? Combinator<U> : never\ntype UnionArms<T extends (Combinator<unknown> | GatedArm<unknown>)[]> = {\n  [K in keyof T]: ArmParser<T[K]>\n}[number] extends Combinator<infer U> ? U : never\n\nexport function choice<T extends [Combinator<unknown> | GatedArm<unknown>, ...(Combinator<unknown> | GatedArm<unknown>)[]]>(\n  ...args: T\n): Combinator<UnionArms<T>> {\n  // Unwrap gated arms into (parser, gate) pairs\n  const parsers = args.map(a => ('gate' in a ? a.combinator : a)) as Combinator<unknown>[]\n  const gates   = args.map(a => ('gate' in a ? a.gate   : null)) as (((state: unknown) => boolean) | null)[]\n\n  const hasGates = gates.some(g => g !== null)\n\n  // O(1) first-char dispatch is sound when arms are pairwise-disjoint in their\n  // first char AND no arm can match empty. Non-nullability is what makes a GATED\n  // arm keep its dispatch slot: a gated arm is normally *skipped* so a later arm\n  // can retry the same position \u2014 but if every arm is non-nullable and first-sets\n  // are disjoint, no later arm can match this first char, so \"skip the gate then\n  // retry\" is exactly \"dispatch to this arm, check its gate, and fail the choice\n  // if the gate is false\". Every OTHER first char dispatches as before and never\n  // touches the gate. A nullable arm matches at ANY position (zero-width), so\n  // first-char dispatch can't represent it \u2192 such choices stay on firstMatch.\n  // (Requiring non-nullability universally also tightens the ungated path, which\n  // was already unsound for a nullable-but-first-set-disjoint arm; in practice no\n  // ungated disjoint choice has a nullable arm, so codegen output is unchanged.)\n  const disjoint = areDisjoint(parsers.map(p => p._meta.firstSet))\n    && parsers.every(p => !matchesEmpty(p))\n\n  let combined: FirstSet = { kind: 'empty' }\n  for (const p of parsers) combined = union(combined, p._meta.firstSet)\n\n  const meta: ParserMeta = {\n    firstSet: combined,\n    canMatchNewline: parsers.some(p => p._meta.canMatchNewline),\n    isTrivia: false,\n    disjoint,\n  }\n\n  // A disjoint choice dispatches by first char (gated arms check their gate inside\n  // the dispatched branch); a NON-disjoint gated choice falls to firstMatch \u2014 the\n  // greedy/longest-first strategies are incompatible with per-arm predicates.\n  const strategy = (disjoint || hasGates) ? null : detectStrategy(parsers)\n  const autoNot = (!disjoint && !hasGates && strategy?.tag === 'firstMatch')\n    ? computeAutoNot(parsers)\n    : parsers.map(() => null)\n\n  // Runtime state for each strategy (built once, reused on every parse call):\n  let greedyLitMap: Map<string, number> | null = null\n  let sortedParsers: Combinator<unknown>[] | null = null\n  const asciiDispatch = disjoint ? buildAsciiDispatch(parsers) : null\n\n  if (strategy?.tag === 'greedyClassify') {\n    greedyLitMap = new Map()\n    for (let i = 0; i < parsers.length; i++) {\n      if (i === strategy.superIndex) continue\n      const litVal = getCoreLiteralValue(parsers[i]!)\n      if (litVal !== null) greedyLitMap.set(litVal, i)\n    }\n  } else if (strategy?.tag === 'literalsLongestFirst') {\n    sortedParsers = strategy.sortedIndices.map(i => parsers[i]!)\n  }\n\n  return {\n    _tag: 'choice',\n    _meta: meta,\n    _def: {\n      tag: 'choice',\n      parsers,\n      gates,\n      disjoint,\n      strategy: strategy ?? { tag: 'firstMatch' },\n      autoNot,\n    },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<UnionArms<T>> {\n      const expected: string[] = []\n\n      // \u2500\u2500 Disjoint: O(1) first-char dispatch (arms may be gated) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      if (disjoint && pos < input.length) {\n        const code = input.codePointAt(pos)!\n        let idx = code < 128 ? asciiDispatch![code]! : -1\n        if (idx < 0) {\n          for (let i = 0; i < parsers.length; i++) {\n            if (inFirstSet(code, parsers[i]!._meta.firstSet)) { idx = i; break }\n          }\n        }\n        if (idx >= 0) {\n          const gate = gates[idx]\n          if (gate && !gate(ctx.state)) {\n            // Gate blocks this arm. Disjointness + non-nullable arms guarantee no\n            // OTHER arm can match this first char, so skip-and-retry is exactly\n            // fail-the-choice \u2014 we must not fall through to another arm.\n            return { ok: false, expected: deriveExpected(parsers[idx]!), span: { start: pos, end: pos } }\n          }\n          const result = parsers[idx]!.parse(input, pos, ctx)\n          if (result.ok) return result as ParseResult<UnionArms<T>>\n          expected.push(...result.expected)\n          return { ok: false, expected, span: { start: pos, end: pos } }\n        }\n        return {\n          ok: false,\n          expected: parsers.flatMap(p => {\n            const r = p.parse(input, pos, ctx)\n            return r.ok ? [] : r.expected\n          }),\n          span: { start: pos, end: pos },\n        }\n      }\n\n      // \u2500\u2500 greedyClassify: run one regex, classify by string equality \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      //    One parse call total. No backtracking.\n      if (strategy?.tag === 'greedyClassify') {\n        const superResult = parsers[strategy.superIndex]!.parse(input, pos, ctx)\n        if (!superResult.ok) return superResult as ParseResult<UnionArms<T>>\n\n        const end = superResult.span.end\n        const litIdx = greedyLitMap!.get(input.slice(pos, end))\n        if (litIdx !== undefined) {\n          const litVal = getCoreLiteralValue(parsers[litIdx]!)!\n          const value = applyTransforms(parsers[litIdx]!, litVal, { start: pos, end })\n          return { ok: true, value: value as UnionArms<T>, span: { start: pos, end } }\n        }\n        return superResult as ParseResult<UnionArms<T>>\n      }\n\n      // \u2500\u2500 literalsLongestFirst: sorted descending by length, no backtracking \u2500\n      if (strategy?.tag === 'literalsLongestFirst') {\n        for (const p of sortedParsers!) {\n          const r = p.parse(input, pos, ctx)\n          if (r.ok) return r as ParseResult<UnionArms<T>>\n          expected.push(...r.expected)\n        }\n        return { ok: false, expected, span: { start: pos, end: pos } }\n      }\n\n      // \u2500\u2500 firstMatch (+ gated arms): try each arm in order, skipping gated-off arms \u2500\u2500\n      for (let i = 0; i < parsers.length; i++) {\n        if (gates[i] && !gates[i]!(ctx.state)) continue   // gate blocks this arm\n        // Save leaf-array lengths so a failed/rejected arm can be rolled back.\n        const mark = saveCstMark(ctx)\n        const logLen = ctx._triviaLog?.length\n        const result = parsers[i]!.parse(input, pos, ctx)\n        if (!result.ok) {\n          rollbackCstCapture(ctx, mark)\n          if (logLen !== undefined && ctx._triviaLog) ctx._triviaLog.length = logLen\n          expected.push(...result.expected)\n          continue\n        }\n        const checks = autoNot[i]\n        if (checks && autoNotFires(input, result.span.end, checks)) {\n          rollbackCstCapture(ctx, mark)\n          if (logLen !== undefined && ctx._triviaLog) ctx._triviaLog.length = logLen\n          continue\n        }\n        return result as ParseResult<UnionArms<T>>\n      }\n      return { ok: false, expected, span: { start: pos, end: pos } }\n    },\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Strategy detection\n// ---------------------------------------------------------------------------\n\nfunction detectStrategy(parsers: Combinator<unknown>[]): ChoiceStrategy {\n  // greedyClassify: exactly one regex arm whose regex matches every literal arm's\n  // value exactly (and can potentially match more). All other arms must be literals.\n  const regexIndices: number[] = []\n  const literalIndices: number[] = []\n  for (let i = 0; i < parsers.length; i++) {\n    if (getCoreRegexDef(parsers[i]!) !== null) regexIndices.push(i)\n    else if (getCoreLiteralValue(parsers[i]!) !== null) literalIndices.push(i)\n  }\n\n  if (\n    regexIndices.length === 1 &&\n    literalIndices.length === parsers.length - 1 &&\n    literalIndices.length > 0\n  ) {\n    const superIndex = regexIndices[0]!\n    const regexDef = getCoreRegexDef(parsers[superIndex]!)!\n    const flags = 'y' + regexDef.flags.replace(/[gy]/g, '')\n    const re = new RegExp(regexDef.source, flags)\n    const allSubsumed = literalIndices.every(i => {\n      const litVal = getCoreLiteralValue(parsers[i]!)!\n      re.lastIndex = 0\n      const m = re.exec(litVal)\n      return m !== null && m[0] === litVal\n    })\n    if (allSubsumed) return { tag: 'greedyClassify', superIndex }\n  }\n\n  // literalsLongestFirst: every arm is a literal \u2014 try longest first, no backtracking\n  if (parsers.length === literalIndices.length) {\n    const sortedIndices = [...literalIndices].sort((a, b) =>\n      getCoreLiteralValue(parsers[b]!)!.length - getCoreLiteralValue(parsers[a]!)!.length\n    )\n    return { tag: 'literalsLongestFirst', sortedIndices }\n  }\n\n  return { tag: 'firstMatch' }\n}\n\n// ---------------------------------------------------------------------------\n// Auto-not analysis (firstMatch fallback only)\n// ---------------------------------------------------------------------------\n\nfunction computeAutoNot(parsers: Combinator<unknown>[]): (AutoNotCheck[] | null)[] {\n  return parsers.map((p, i) => {\n    const litVal = getCoreLiteralValue(p)\n    if (litVal === null) return null\n\n    const checks: AutoNotCheck[] = []\n    for (let j = i + 1; j < parsers.length; j++) {\n      const other = parsers[j]!\n      const otherLit = getCoreLiteralValue(other)\n      if (otherLit !== null && otherLit.startsWith(litVal) && otherLit.length > litVal.length) {\n        checks.push({ kind: 'startsWith', value: otherLit.slice(litVal.length) })\n        continue\n      }\n      const regexDef = getCoreRegexDef(other)\n      if (regexDef !== null) {\n        const contSet = continuationFirstSet(litVal, regexDef.source, regexDef.flags)\n        if (contSet !== null) checks.push({ kind: 'firstSet', set: contSet })\n      }\n    }\n    return checks.length > 0 ? checks : null\n  })\n}\n\nfunction autoNotFires(input: string, end: number, checks: AutoNotCheck[]): boolean {\n  for (const check of checks) {\n    if (check.kind === 'firstSet') {\n      const code = end < input.length ? (input.codePointAt(end) ?? -1) : -1\n      if (inFirstSet(code, check.set)) return true\n    } else {\n      if (input.startsWith(check.value, end)) return true\n    }\n  }\n  return false\n}\n\n// ---------------------------------------------------------------------------\n// Helpers: unwrap transform/sequence wrappers\n// ---------------------------------------------------------------------------\n\n/** Walk transform wrappers to find an inner literal's string value. */\nexport function getCoreLiteralValue(p: Combinator<unknown>): string | null {\n  const def = p._def\n  if (def.tag === 'literal' && !def.caseInsensitive) return def.value\n  if (def.tag === 'transform') return getCoreLiteralValue(def.parser)\n  return null\n}\n\n/** Walk transform wrappers to find an inner regex's source/flags. */\nexport function getCoreRegexDef(p: Combinator<unknown>): { source: string; flags: string } | null {\n  const def = p._def\n  if (def.tag === 'regex') return { source: def.source, flags: def.flags }\n  if (def.tag === 'transform') return getCoreRegexDef(def.parser)\n  if (def.tag === 'label') return getCoreRegexDef(def.parser)\n  return null\n}\n\n/**\n * Apply a parser's transform chain to an already-known value, without re-parsing.\n * Used by greedyClassify to avoid a second parse call for the winning literal arm.\n */\nfunction applyTransforms(p: Combinator<unknown>, value: unknown, span: { start: number; end: number }): unknown {\n  const def = p._def\n  if (def.tag === 'transform') {\n    const inner = applyTransforms(def.parser, value, span)\n    return def.fn(inner, span)\n  }\n  return value\n}\n\n// ---------------------------------------------------------------------------\n// Continuation first-set (for firstMatch auto-not analysis)\n// ---------------------------------------------------------------------------\n\nfunction continuationFirstSet(lit: string, source: string, flags: string): FirstSet | null {\n  const re = new RegExp(source, 'y' + flags.replace(/[gy]/g, ''))\n  re.lastIndex = 0\n  const base = re.exec(lit)\n  if (!base || base[0] !== lit) return null\n\n  const contCodes: number[] = []\n  for (let code = 1; code < 128; code++) {\n    re.lastIndex = 0\n    const m = re.exec(lit + String.fromCharCode(code))\n    if (m && m[0].length > lit.length) contCodes.push(code)\n  }\n  if (contCodes.length === 0) return null\n  return codesToFirstSet(contCodes)\n}\n\nfunction codesToFirstSet(codes: number[]): FirstSet {\n  codes.sort((a, b) => a - b)\n  const ranges: CharRange[] = []\n  let lo = codes[0]!, hi = codes[0]!\n  for (let i = 1; i < codes.length; i++) {\n    if (codes[i] === hi + 1) { hi = codes[i]! }\n    else { ranges.push({ lo, hi }); lo = hi = codes[i]! }\n  }\n  ranges.push({ lo, hi })\n  return { kind: 'ranges', ranges }\n}\n\nfunction inFirstSet(code: number, fs: FirstSet): boolean {\n  if (fs.kind === 'any') return true\n  if (fs.kind === 'empty') return false\n  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true\n  return false\n}\n\nfunction areDisjoint(sets: FirstSet[]): boolean {\n  if (sets.some(s => s.kind === 'any')) return false\n  for (let i = 0; i < sets.length; i++)\n    for (let j = i + 1; j < sets.length; j++)\n      if (intersects(sets[i]!, sets[j]!)) return false\n  return true\n}\n\n// ASCII first-char \u2192 arm INDEX (not the parser) so a gated arm's gate can be\n// looked up (gates[idx]) at dispatch time. -1 means \"no arm keys off this char\".\nfunction buildAsciiDispatch(parsers: Combinator<unknown>[]): number[] {\n  const table = Array<number>(128).fill(-1)\n  for (let i = 0; i < parsers.length; i++) {\n    const fs = parsers[i]!._meta.firstSet\n    if (fs.kind !== 'ranges') continue\n    for (const { lo, hi } of fs.ranges) {\n      for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) {\n        table[code] = i\n      }\n    }\n  }\n  return table\n}\n", "import type { Combinator, ParseContext } from '../types.ts'\nimport { getCoreRegexDef } from '../combinators/choice.ts'\nimport { pushCstTriviaEntry, pushTriviaLogEntry } from './capture-buffer.ts'\n\nexport type TriviaChunk = { start: number; end: number; kindIndex: number }\n\nexport type LabeledTriviaSpec = {\n  readonly labels: readonly string[]\n  readonly arms: ReadonlyArray<{ label: string; kindIndex: number; parser: Combinator<unknown> }>\n  readonly minRepeats: number\n}\n\nfunction unwrapTrivia(p: Combinator<unknown>): Combinator<unknown> {\n  let cur = p\n  while (cur._def.tag === 'trivia') cur = cur._def.parser\n  return cur\n}\n\n/** Strip `label()` wrapper; returns inner parser for matching. */\nexport function peelLabel(p: Combinator<unknown>): { label: string; parser: Combinator<unknown> } | null {\n  if (p._def.tag === 'label') return { label: p._def.label, parser: p._def.parser }\n  return null\n}\n\n/**\n * When every trivia arm is `label(name, parser)` inside `oneOrMore(choice(\u2026))`\n * (or a single labeled arm), return the label table and matchers.\n */\nexport function analyzeLabeledTrivia(trivia: Combinator<unknown>): LabeledTriviaSpec | null {\n  let core = unwrapTrivia(trivia)\n  let minRepeats = 1\n\n  if (core._def.tag === 'oneOrMore') {\n    core = core._def.parser\n    minRepeats = 1\n  } else if (core._def.tag === 'many') {\n    core = core._def.parser\n    minRepeats = 0\n  }\n\n  const arms: LabeledTriviaSpec['arms'][number][] = []\n\n  if (core._def.tag === 'choice') {\n    for (let i = 0; i < core._def.parsers.length; i++) {\n      const peeled = peelLabel(core._def.parsers[i]!)\n      if (!peeled) return null\n      arms.push({ label: peeled.label, kindIndex: i, parser: peeled.parser })\n    }\n  } else {\n    const peeled = peelLabel(core)\n    if (!peeled) return null\n    arms.push({ label: peeled.label, kindIndex: 0, parser: peeled.parser })\n  }\n\n  return { labels: arms.map(a => a.label), arms, minRepeats }\n}\n\n/** Label table on a `trivia()` combinator, if all arms are labeled. */\nexport function triviaKindLabels(trivia: Combinator<unknown> | undefined): readonly string[] | undefined {\n  if (!trivia) return undefined\n  const fromMeta = trivia._meta.triviaKindLabels\n  if (fromMeta) return fromMeta\n  return analyzeLabeledTrivia(trivia)?.labels\n}\n\nfunction matchArmAt(\n  input: string,\n  pos: number,\n  arm: Combinator<unknown>,\n): { end: number } | null {\n  const r = arm.parse(input, pos, { trackLines: false })\n  if (!r.ok || r.span.end <= pos) return null\n  return { end: r.span.end }\n}\n\n/**\n * Scan maximal labeled trivia chunks (PEG `oneOrMore(choice(\u2026))` semantics).\n * Each successful arm match becomes one entry with that arm's kind index.\n */\nexport function scanLabeledTriviaChunks(\n  input: string,\n  cur: number,\n  spec: LabeledTriviaSpec,\n): { end: number; chunks: TriviaChunk[] } {\n  const chunks: TriviaChunk[] = []\n  let pos = cur\n\n  while (pos < input.length) {\n    let matched: { end: number; kindIndex: number } | null = null\n    for (const arm of spec.arms) {\n      const m = matchArmAt(input, pos, arm.parser)\n      if (m) {\n        matched = { end: m.end, kindIndex: arm.kindIndex }\n        break\n      }\n    }\n    if (!matched) break\n    chunks.push({ start: pos, end: matched.end, kindIndex: matched.kindIndex })\n    pos = matched.end\n  }\n\n  if (chunks.length < spec.minRepeats) {\n    return { end: cur, chunks: [] }\n  }\n  return { end: pos, chunks }\n}\n\n/** Hand-rolled ws / block-comment scan with per-chunk kind indices (interpreter). */\nexport function scanFastWsCommentsChunks(\n  input: string,\n  cur: number,\n  wsKind: number,\n  commentKind: number,\n): { end: number; chunks: TriviaChunk[] } {\n  const chunks: TriviaChunk[] = []\n  let pos = cur\n\n  while (pos < input.length) {\n    const c = input.charCodeAt(pos)\n    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) {\n      const start = pos\n      pos++\n      while (pos < input.length) {\n        const c2 = input.charCodeAt(pos)\n        if (c2 === 32 || c2 === 9 || c2 === 10 || c2 === 13 || c2 === 12) pos++\n        else break\n      }\n      chunks.push({ start, end: pos, kindIndex: wsKind })\n      continue\n    }\n    if (c === 47 && input.charCodeAt(pos + 1) === 42) {\n      let j = pos + 2\n      while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++\n      // Require the closing `*/`; an unterminated comment is NOT trivia (the\n      // `/\\*\u2026\\*/` regex arm would fail), so stop here without consuming it \u2014\n      // matching scanLabeledTriviaChunks and the compiled delimited scan.\n      if (j + 1 < input.length && input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47) {\n        const start = pos\n        pos = j + 2\n        chunks.push({ start, end: pos, kindIndex: commentKind })\n        continue\n      }\n      break\n    }\n    break\n  }\n\n  return { end: pos, chunks }\n}\n\n/** Fast scan when trivia is labeled ws + block-comment (CSS `rw`). */\nexport function tryFastLabeledScan(\n  input: string,\n  cur: number,\n  trivia: Combinator<unknown>,\n): { end: number; chunks: TriviaChunk[] } | null {\n  const spec = analyzeLabeledTrivia(trivia)\n  if (!spec || spec.arms.length !== 2) return null\n\n  const wsArm = spec.arms.find(a => {\n    const src = getCoreRegexDef(a.parser)?.source\n    return src != null && !src.includes('\\\\*')\n  })\n  const commentArm = spec.arms.find(a => {\n    const src = getCoreRegexDef(a.parser)?.source\n    return src != null && src.includes('\\\\*')\n  })\n  if (!wsArm || !commentArm) return null\n\n  const { chunks } = scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex)\n  if (chunks.length < spec.minRepeats) return { end: cur, chunks: [] }\n  return scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex)\n}\n\nexport function recordTriviaChunks(ctx: ParseContext, chunks: readonly TriviaChunk[]): void {\n  const kinds = ctx.triviaKindLabels\n  const mask = ctx._triviaCaptureMask\n  for (const ch of chunks) {\n    // Global trivia log: always complete (never kind-filtered).\n    pushTriviaLogEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : undefined)\n    // Per-node CST log: honour the kind mask when both a mask and labels are\n    // present, so a host can capture (e.g.) comments only without logging every\n    // whitespace run. No mask / no labels \u2192 capture everything, as before.\n    if (ctx.captureTrivia && (ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined)) {\n      if (mask === undefined || kinds === undefined || (mask & (1 << ch.kindIndex)) !== 0) {\n        pushCstTriviaEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : undefined)\n      }\n    }\n  }\n}\n\n/**\n * Resolve a per-node trivia capture mask (`ctx._triviaCaptureMask`) from a trivia\n * label table and the kind names a host wants to keep. Returns `undefined` when\n * `labels` is absent (nothing to key on \u2192 capture everything).\n *\n * Names in `keep` that aren't in `labels` are **ignored by design**: `keep` is\n * often a dialect-independent list (e.g. `['blockComment', 'lineComment']`) applied\n * to a grammar whose trivia only defines some of them (CSS has no `lineComment`) \u2014\n * so an unknown name is a normal cross-dialect no-op, not necessarily a typo, and\n * is not worth a warning that would cry wolf on legitimate superset lists. An empty\n * `keep` (or one where nothing matches) yields `0`, which means \"capture NO trivia\n * into per-node logs\" \u2014 an intentional, valid state (the global `_triviaLog` is\n * unaffected either way). If you expect comments and get an empty per-node log,\n * check the name against the grammar's `triviaKindLabels`.\n */\nexport function triviaKindMask(\n  labels: readonly string[] | undefined,\n  keep: readonly string[],\n): number | undefined {\n  if (!labels) return undefined\n  let mask = 0\n  for (const name of keep) {\n    const idx = labels.indexOf(name)\n    if (idx >= 0) mask |= 1 << idx\n  }\n  return mask\n}\n", "import type { Combinator, ParseContext } from '../types.ts'\nimport { parseClassRanges } from '../regex/classes.ts'\nimport {\n  analyzeLabeledTrivia,\n  recordTriviaChunks,\n  scanLabeledTriviaChunks,\n  tryFastLabeledScan,\n} from '../cst/trivia-kinds.ts'\nimport {\n  pushCstTriviaEntry,\n  pushTriviaLogEntry,\n  rollbackCstCapture,\n  saveCstMark,\n} from '../cst/capture-buffer.ts'\n\n/**\n * Result of scanning trivia: the position after it, plus a `commit()` that\n * records the matched trivia tokens into the active rawChildren collector.\n * Recording is deferred so callers that may reject the following item (e.g.\n * many()/oneOrMore() retries) can advance speculatively without recording\n * trivia that doesn't actually sit between two accepted items.\n */\nexport type TriviaScan = { end: number; commit: () => void }\n\n/** Saved lengths for rolling back speculative trivia commits. */\nexport type TriviaRollbackMark = { raw: number; tlog: number; leaves: number; fields: number; errors: number; log: number }\n\nconst NOOP_COMMIT = () => {}\ntype FastTriviaScanner = (input: string, cur: number) => number\nconst fastTriviaCache = new WeakMap<Combinator<unknown>, FastTriviaScanner | null>()\n\n/** True when trivia recording must be deferred until the following term commits. */\nexport function needsDeferredTriviaCommit(ctx: ParseContext): boolean {\n  return ctx._triviaLog !== undefined || ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined\n}\n\nexport function saveTriviaMark(ctx: ParseContext): TriviaRollbackMark {\n  const m = saveCstMark(ctx)\n  return { raw: m.raw, tlog: m.tlog, leaves: m.leaves, fields: m.fields, errors: m.errors, log: ctx._triviaLog ? ctx._triviaLog.length : 0 }\n}\n\nexport function rollbackTrivia(ctx: ParseContext, mark: TriviaRollbackMark): void {\n  rollbackCstCapture(ctx, { raw: mark.raw, tlog: mark.tlog, leaves: mark.leaves, fields: mark.fields, errors: mark.errors })\n  if (ctx._triviaLog) ctx._triviaLog.length = mark.log\n}\n\nfunction scanWithLabels(input: string, cur: number, ctx: ParseContext): TriviaScan {\n  const triviaP = ctx.trivia!\n  const spec = analyzeLabeledTrivia(triviaP)\n  if (!spec) return { end: cur, commit: NOOP_COMMIT }\n\n  const fast = tryFastLabeledScan(input, cur, triviaP)\n  const { end, chunks } = fast ?? scanLabeledTriviaChunks(input, cur, spec)\n  if (end === cur) return { end: cur, commit: NOOP_COMMIT }\n\n  return {\n    end,\n    commit: () => recordTriviaChunks(ctx, chunks),\n  }\n}\n\n/**\n * Skip trivia at `cur` and return the new position. No recording, no wrapper\n * object \u2014 use between sequence/repeat terms when CST trivia capture is off.\n */\nexport function advanceTrivia(input: string, cur: number, ctx: ParseContext): number {\n  const triviaP = ctx.trivia\n  if (!triviaP) return cur\n  const fast = fastTriviaScanner(triviaP)\n  if (fast) return fast(input, cur)\n  if (ctx.triviaKindLabels) {\n    const scan = scanWithLabels(input, cur, ctx)\n    return scan.end\n  }\n  const tr = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state })\n  return tr.ok && tr.span.end > cur ? tr.span.end : cur\n}\n\n/**\n * Scan trivia at `cur` using `ctx.trivia`, WITHOUT recording it. Returns the\n * position after the trivia (or `cur` if none) and a `commit()` to record it.\n */\nexport function scanTrivia(input: string, cur: number, ctx: ParseContext): TriviaScan {\n  const triviaP = ctx.trivia\n  if (!triviaP) return { end: cur, commit: NOOP_COMMIT }\n\n  const log = ctx._triviaLog\n  const captureTl = ctx.captureTrivia && (ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined)\n\n  const fast = !ctx.triviaKindLabels ? fastTriviaScanner(triviaP) : null\n  if (fast && log === undefined && !captureTl) {\n    return { end: fast(input, cur), commit: NOOP_COMMIT }\n  }\n\n  if (ctx.triviaKindLabels && (log !== undefined || captureTl)) {\n    return scanWithLabels(input, cur, ctx)\n  }\n\n  if (log !== undefined || captureTl) {\n    const tr = triviaP.parse(input, cur, {\n      trackLines: log !== undefined ? false : ctx.trackLines,\n      state: ctx.state,\n    })\n    if (!tr.ok || tr.span.end === cur) return { end: cur, commit: NOOP_COMMIT }\n    const end = tr.span.end\n    return {\n      end,\n      commit: () => {\n        pushTriviaLogEntry(ctx, cur, end)\n        if (captureTl) pushCstTriviaEntry(ctx, cur, end)\n      },\n    }\n  }\n\n  const tr = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state })\n  return { end: tr.ok ? tr.span.end : cur, commit: NOOP_COMMIT }\n}\n\n/**\n * Consume trivia at `cur`, recording it immediately. For callers that always\n * accept the trivia between two committed terms (e.g. sequence/sepBy).\n */\nexport function consumeTrivia(input: string, cur: number, ctx: ParseContext): number {\n  if (!needsDeferredTriviaCommit(ctx)) return advanceTrivia(input, cur, ctx)\n  const scan = scanTrivia(input, cur, ctx)\n  scan.commit()\n  return scan.end\n}\n\nfunction fastTriviaScanner(trivia: Combinator<unknown>): FastTriviaScanner | null {\n  const cached = fastTriviaCache.get(trivia)\n  if (cached !== undefined) return cached\n  const scanner = buildFastTriviaScanner(trivia)\n  fastTriviaCache.set(trivia, scanner)\n  return scanner\n}\n\nfunction buildFastTriviaScanner(trivia: Combinator<unknown>): FastTriviaScanner | null {\n  const core = trivia._def.tag === 'trivia' ? trivia._def.parser : trivia\n  const direct = regexTriviaScanner(core)\n  if (direct) return direct\n\n  const repeat = core._def.tag === 'oneOrMore' || (core._def.tag === 'many' && core._def.min >= 1)\n    ? core._def.parser\n    : null\n  if (!repeat) return null\n\n  const one = regexTriviaScanner(repeat)\n  if (one) return loopScanner([one])\n\n  if (repeat._def.tag !== 'choice') return null\n  const arms = repeat._def.parsers.map(regexTriviaScanner)\n  if (arms.some(s => s === null)) return null\n  return loopScanner(arms as FastTriviaScanner[])\n}\n\nfunction loopScanner(arms: FastTriviaScanner[]): FastTriviaScanner {\n  return (input, cur) => {\n    let pos = cur\n    scan: while (pos < input.length) {\n      for (const arm of arms) {\n        const end = arm(input, pos)\n        if (end > pos) {\n          pos = end\n          continue scan\n        }\n      }\n      break\n    }\n    return pos\n  }\n}\n\nfunction regexTriviaScanner(parser: Combinator<unknown>): FastTriviaScanner | null {\n  if (parser._def.tag !== 'regex' || parser._def.flags) return null\n  const source = parser._def.source\n  return classRunSource(source)\n    ?? altStarSource(source)\n    ?? (blockCommentSource(source) ? scanBlockComment : null)\n}\n\nfunction inRanges(cp: number, ranges: Array<[number, number]>): boolean {\n  for (let i = 0; i < ranges.length; i++) {\n    const r = ranges[i]!\n    if (cp >= r[0] && cp <= r[1]) return true\n  }\n  return false\n}\n\n/** Greedy scanner for a positive char-class body (`^`-negated bodies are rejected upstream). */\nfunction classScanner(classBody: string): FastTriviaScanner | null {\n  const ranges = parseClassRanges(classBody)\n  if (!ranges) return null\n  return (input, cur) => {\n    let pos = cur\n    while (pos < input.length && inRanges(input.charCodeAt(pos), ranges)) pos++\n    return pos\n  }\n}\n\n/** Scanner for a `C[^\\n\\r]*` line comment \u2014 consumes `C` and the rest of the line. */\nfunction lineCommentScanner(commentCode: number): FastTriviaScanner {\n  return (input, cur) => {\n    if (input.charCodeAt(cur) !== commentCode) return cur\n    let pos = cur + 1\n    while (pos < input.length) {\n      const cc = input.charCodeAt(pos)\n      if (cc === 10 || cc === 13) break\n      pos++\n    }\n    return pos\n  }\n}\n\n/** A bare positive char-class run `[class]*` / `[class]+` (`[ \\t\\n\\r,]*`, \u2026). */\nfunction classRunSource(source: string): FastTriviaScanner | null {\n  const m = /^\\[([^\\]^](?:[^\\]]|\\\\.)*)\\][*+]$/.exec(source)\n  return m ? classScanner(m[1]!) : null\n}\n\n/**\n * One alternation arm of a `(?:\u2026)*` trivia group: a positive char-class run\n * `[class]` (a trailing `+`/`*` is redundant under the enclosing loop) or a line\n * comment `C[^\\n\\r]*` (`C` = one literal marker char, maybe escaped). Anything\n * else is unclassifiable \u2192 no fast path, never a wrong one.\n */\ntype TriviaArm =\n  | { kind: 'class'; ranges: Array<[number, number]> }\n  | { kind: 'comment'; code: number }\n\nfunction classifyTriviaArm(arm: string): TriviaArm | null {\n  const cls = /^\\[([^\\]^](?:[^\\]]|\\\\.)*)\\][*+]?$/.exec(arm)\n  if (cls) {\n    const ranges = parseClassRanges(cls[1]!)\n    return ranges ? { kind: 'class', ranges } : null\n  }\n  const lc = /^(\\\\?.)\\[\\^\\\\n\\\\r\\]\\*$/.exec(arm)\n  if (lc) {\n    const marker = lc[1]!\n    return { kind: 'comment', code: (marker.length === 2 ? marker[1]! : marker[0]!).charCodeAt(0) }\n  }\n  return null\n}\n\nfunction armScanner(arm: TriviaArm): FastTriviaScanner {\n  if (arm.kind === 'comment') return lineCommentScanner(arm.code)\n  const ranges = arm.ranges\n  return (input, cur) => {\n    let pos = cur\n    while (pos < input.length && inRanges(input.charCodeAt(pos), ranges)) pos++\n    return pos\n  }\n}\n\n/**\n * A single tight loop over a merged char-class range list plus (usually one)\n * line-comment marker \u2014 the fast form of `(?:[class]|C[^\\n\\r]*)*`. Requires the\n * caller to have checked marker/class disjointness (so a bare merged scan\n * matches the regex regardless of arm order).\n */\nfunction fusedTriviaScanner(ranges: Array<[number, number]>, commentCodes: number[]): FastTriviaScanner {\n  const c0 = commentCodes[0]!\n  const single = commentCodes.length === 1\n  return (input, cur) => {\n    let pos = cur\n    const len = input.length\n    for (;;) {\n      const c = input.charCodeAt(pos)\n      if (pos < len && inRanges(c, ranges)) { pos++; continue }\n      if (single ? c === c0 : commentCodes.includes(c)) {\n        pos++\n        while (pos < len) {\n          const cc = input.charCodeAt(pos)\n          if (cc === 10 || cc === 13) break\n          pos++\n        }\n        continue\n      }\n      break\n    }\n    return pos\n  }\n}\n\n/** Split a `(?:\u2026)*` body on top-level `|`, respecting `[\u2026]`; bail on nested groups. */\nfunction splitTopLevelAlts(body: string): string[] | null {\n  const arms: string[] = []\n  let inClass = false\n  let start = 0\n  for (let i = 0; i < body.length; i++) {\n    const c = body[i]\n    if (c === '\\\\') { i++; continue }\n    if (inClass) { if (c === ']') inClass = false; continue }\n    if (c === '[') inClass = true\n    else if (c === '(') return null // nested group \u2014 leave it to RegExp.exec\n    else if (c === '|') { arms.push(body.slice(start, i)); start = i + 1 }\n  }\n  arms.push(body.slice(start))\n  return arms\n}\n\n/**\n * Trivia written as a single regex alternation-star, `(?:arm|arm|\u2026)*` \u2014 e.g.\n * GraphQL's `(?:[ \\t\\n\\r,]|#[^\\n\\r]*)*`. Arms are classified independently and\n * order-independently: char-class arms merge into one range list and comment\n * markers are collected, so `(?:#\u2026|[class])*` scans the same as `(?:[class]|#\u2026)*`.\n * The common (disjoint) case compiles to one fused loop; a marker that also sits\n * inside a class is the one spot where arm order matters, so that falls back to\n * the ordered `loopScanner`.\n */\nfunction altStarSource(source: string): FastTriviaScanner | null {\n  const m = /^\\(\\?:(.*)\\)[*+]$/.exec(source)\n  if (!m) return null\n  const armSrcs = splitTopLevelAlts(m[1]!)\n  if (!armSrcs || armSrcs.length < 2) return null\n  const arms: TriviaArm[] = []\n  for (const src of armSrcs) {\n    const arm = classifyTriviaArm(src)\n    if (!arm) return null\n    arms.push(arm)\n  }\n  const ranges: Array<[number, number]> = []\n  const commentCodes: number[] = []\n  for (const arm of arms) {\n    if (arm.kind === 'class') ranges.push(...arm.ranges)\n    else commentCodes.push(arm.code)\n  }\n  if (commentCodes.some(code => inRanges(code, ranges))) {\n    return loopScanner(arms.map(armScanner)) // order-significant overlap\n  }\n  if (commentCodes.length === 0) return armScanner({ kind: 'class', ranges })\n  return fusedTriviaScanner(ranges, commentCodes)\n}\n\nfunction blockCommentSource(source: string): boolean {\n  return source === '\\\\/\\\\*(?:[^*]|\\\\*(?!\\\\/))*\\\\*\\\\/' || source === '\\\\/\\\\*[^]*?\\\\*\\\\/'\n}\n\nfunction scanBlockComment(input: string, cur: number): number {\n  if (input.charCodeAt(cur) !== 47 || input.charCodeAt(cur + 1) !== 42) return cur\n  const close = input.indexOf('*/', cur + 2)\n  return close === -1 ? cur : close + 2\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, ParseFail } from '../types.ts'\nimport { sequenceFirstSet, firstSetOf, union } from './first-set.ts'\nimport { advanceTrivia, needsDeferredTriviaCommit, rollbackTrivia, saveTriviaMark, scanTrivia } from './trivia-skip.ts'\nimport { firstSetSentinel } from '../recovery/scan.ts'\n\ntype UnwrapParsers<T extends Combinator<unknown>[]> = {\n  [K in keyof T]: T[K] extends Combinator<infer U> ? U : never\n}\n\nexport function sequence<T extends [Combinator<unknown>, ...Combinator<unknown>[]]>(\n  ...parsers: T\n): Combinator<UnwrapParsers<T>> {\n  const meta: ParserMeta = {\n    // Union through the nullable prefix \u2014 a leading optional()/many() lets a later\n    // term's first char start the sequence. Just `parsers[0]` under-approximates.\n    firstSet: sequenceFirstSet(parsers),\n    canMatchNewline: parsers.some(p => p._meta.canMatchNewline),\n    isTrivia: false,\n  }\n\n  const def: { tag: 'sequence'; parsers: Combinator<unknown>[]; valueUnused?: boolean } =\n    { tag: 'sequence', parsers: parsers as Combinator<unknown>[] }\n\n  // Automatic recovery-sync inference, built lazily on the first tolerant parse and\n  // never touched on the strict path: followSentinels[i] matches (zero-width) when\n  // the input could start any term AFTER i, so a list nested in term i can resync\n  // to this sequence's enclosing delimiter with NO grammar annotation. This is the\n  // whole of \"recovery config\" \u2014 derived from structure, not authored.\n  let followSentinels: (Combinator<null> | null)[] | undefined\n\n  // Tolerant twin of the strict loop: identical term-parsing, but around each term\n  // it publishes the inferred follow sentinel into ctx._sync so a nested list can\n  // resync to this sequence's enclosing delimiter. Cold path (tolerant only).\n  function parseTolerant(input: string, pos: number, ctx: ParseContext): ParseResult<UnwrapParsers<T>> {\n    followSentinels ??= parsers.map((_, i) => {\n      // A nested list can resync to the start of ANY term that follows it here, so\n      // union every following term's first set (not just up to the first\n      // non-nullable one \u2014 a mandatory middle term must not hide a later close).\n      const fs = parsers.slice(i + 1).reduce<ReturnType<typeof firstSetOf>>(\n        (acc, p) => union(acc, firstSetOf(p)),\n        { kind: 'empty' },\n      )\n      return firstSetSentinel(fs)\n    })\n    const values: unknown[] | undefined = def.valueUnused ? undefined : []\n    let cur = pos\n    const inheritedSync = ctx._sync\n    try {\n      for (let i = 0; i < parsers.length; i++) {\n        // Publish this term's follow set (or keep the inherited sync when the local\n        // follow isn't usable, e.g. the last term or an `any` first set).\n        ctx._sync = followSentinels[i] ?? inheritedSync\n        if (ctx.trivia && i > 0) {\n          const mark = saveTriviaMark(ctx)\n          let scanEnd: number\n          if (needsDeferredTriviaCommit(ctx)) {\n            const scan = scanTrivia(input, cur, ctx)\n            scan.commit()\n            scanEnd = scan.end\n          } else {\n            scanEnd = advanceTrivia(input, cur, ctx)\n          }\n          const result = parsers[i]!.parse(input, scanEnd, ctx)\n          if (!result.ok) return result as ParseFail\n          if (result.span.end > scanEnd) cur = result.span.end\n          else rollbackTrivia(ctx, mark)\n          if (values !== undefined) values.push(result.value)\n          continue\n        }\n        const result = parsers[i]!.parse(input, cur, ctx)\n        if (!result.ok) return result as ParseFail\n        if (values !== undefined) values.push(result.value)\n        cur = result.span.end\n      }\n    } finally {\n      ctx._sync = inheritedSync\n    }\n    return {\n      ok: true,\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion\n      value: (values ?? undefined) as UnwrapParsers<T>,\n      span: { start: pos, end: cur },\n    }\n  }\n\n  return {\n    _tag: 'sequence',\n    _meta: meta,\n    _def: def,\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<UnwrapParsers<T>> {\n      // One cold branch: in tolerant mode publish each term's follow-set as ctx._sync\n      // so a nested list resyncs to the enclosing delimiter (dynamic scoping through\n      // refs carries this across rule boundaries automatically). The strict loop\n      // below is byte-identical to a parser with no recovery.\n      if (ctx._tolerant) return parseTolerant(input, pos, ctx)\n\n      // Skip the tuple when it's never observed (markUnusedValues): terms still\n      // parse (and self-capture) \u2014 only the array of their values is elided.\n      const values: unknown[] | undefined = def.valueUnused ? undefined : []\n      let cur = pos\n\n      for (let i = 0; i < parsers.length; i++) {\n        if (ctx.trivia && i > 0) {\n          // Skip trivia between terms, but only *consume* it for span purposes if\n          // this term actually matches content past the trivia. A term that matches\n          // empty (optional/many/lookahead) leaves the trivia for the enclosing rule.\n          let scanEnd: number\n          let mark = saveTriviaMark(ctx)\n\n          if (needsDeferredTriviaCommit(ctx)) {\n            const scan = scanTrivia(input, cur, ctx)\n            scan.commit()\n            scanEnd = scan.end\n          } else {\n            scanEnd = advanceTrivia(input, cur, ctx)\n          }\n\n          const result = parsers[i]!.parse(input, scanEnd, ctx)\n          if (!result.ok) return result as ParseFail\n          if (result.span.end > scanEnd) {\n            cur = result.span.end\n          } else {\n            rollbackTrivia(ctx, mark)\n          }\n          if (values !== undefined) values.push(result.value)\n          continue\n        }\n\n        const result = parsers[i]!.parse(input, cur, ctx)\n        if (!result.ok) return result as ParseFail\n        if (values !== undefined) values.push(result.value)\n        cur = result.span.end\n      }\n\n      return {\n        ok: true,\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion\n        value: (values ?? undefined) as UnwrapParsers<T>,\n        span: { start: pos, end: cur },\n      }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { advanceTrivia, needsDeferredTriviaCommit, rollbackTrivia, saveTriviaMark, scanTrivia } from './trivia-skip.ts'\nimport { matchesEmpty } from './first-set.ts'\nimport { deriveExpected } from './expect.ts'\nimport { matchesAt, orSentinel, recoverScan, captureError } from '../recovery/scan.ts'\n\n/**\n * Parse one repetition item at `cur`, first skipping (and, in capture mode,\n * recording) any leading trivia \u2014 so a repeating combinator consumes the trivia\n * between items uniformly, the way advancing the index always should. Trivia is\n * committed *before* the item so rawChildren order stays [item, trivia, item];\n * if the item then fails or makes no progress the trivia is rolled back and the\n * loop stops (the trivia is trailing and belongs to the enclosing context).\n *\n * Returns the item value + end position, the underlying failure (so oneOrMore\n * can propagate a first-item failure), or 'stop'.\n */\nfunction repItem<T>(\n  combinator: Combinator<T>,\n  input: string,\n  cur: number,\n  ctx: ParseContext,\n): { value: T; end: number } | { fail: ParseResult<T>; failPos: number } | 'stop' {\n  const mark = saveTriviaMark(ctx)\n  let pos = cur\n  if (ctx.trivia) {\n    if (needsDeferredTriviaCommit(ctx)) {\n      const scan = scanTrivia(input, cur, ctx)\n      scan.commit()\n      pos = scan.end\n    } else {\n      pos = advanceTrivia(input, cur, ctx)\n    }\n  }\n  // Nothing but trivia left: don't speculatively parse an item at EOF (it would\n  // fail and could trigger an item's expect()/error side-effects). The trivia\n  // is trailing \u2014 roll it back for the enclosing context and stop.\n  if (pos >= input.length) {\n    rollbackTrivia(ctx, mark)\n    return 'stop'\n  }\n  const result = combinator.parse(input, pos, ctx)\n  if (!result.ok) {\n    rollbackTrivia(ctx, mark)\n    // Surface the POST-trivia position where the element actually failed. The\n    // tolerant recovery guard must check the sync token there \u2014 not at `cur`,\n    // which sits before any leading trivia \u2014 so trailing trivia before the sync\n    // isn't mistaken for junk and swallowed into a spurious ParseError.\n    return { fail: result, failPos: pos }\n  }\n  if (result.span.end === pos) {\n    rollbackTrivia(ctx, mark)\n    return 'stop'\n  }\n  return { value: result.value, end: result.span.end }\n}\n\nexport function many<T>(combinator: Combinator<T>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  const def: { tag: 'many'; parser: Combinator<unknown>; min: 0; valueUnused?: boolean } =\n    { tag: 'many', parser: combinator as Combinator<unknown>, min: 0 }\n  let expected: string[] | undefined\n\n  return {\n    _tag: 'many',\n    _meta: meta,\n    _def: def,\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {\n      // When the aggregate is never observed (markUnusedValues), skip the array:\n      // items still parse and self-capture into the enclosing node's children.\n      const values: T[] | undefined = def.valueUnused ? undefined : []\n      let cur = pos\n      while (cur < input.length) {\n        const item = repItem(combinator, input, cur, ctx)\n        if (item === 'stop') break\n        if ('fail' in item) {\n          // Cold path: only reached on an element failure. Strict mode \u21D2 `break`.\n          // Tolerant \u21D2 resync to the sync sentinel the enclosing sequence inferred\n          // and published as ctx._sync (the grammar carries no recovery config). No\n          // sync available \u21D2 nothing to skip to \u2192 break.\n          const sync = ctx._tolerant ? ctx._sync : undefined\n          if (sync === undefined) break\n          // Sync token at the POST-trivia failure position \u21D2 clean list end (the\n          // trailing trivia belongs to the enclosing context), not junk. Checking\n          // `item.failPos` (past leading trivia), not `cur`, keeps trivia out of\n          // both the break decision and the recovered error span.\n          if (matchesAt(sync, input, item.failPos, ctx)) break\n          expected ??= deriveExpected(combinator)\n          const { error, end } = recoverScan(input, item.failPos, ctx, sync, expected)\n          if (values !== undefined) values.push(error as unknown as T)\n          captureError(ctx, error)\n          cur = end\n          continue\n        }\n        if (values !== undefined) values.push(item.value)\n        cur = item.end\n      }\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion\n      return { ok: true, value: (values ?? undefined) as T[], span: { start: pos, end: cur } }\n    },\n  }\n}\n\nexport function oneOrMore<T>(combinator: Combinator<T>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  const def: { tag: 'oneOrMore'; parser: Combinator<unknown>; min: 1; valueUnused?: boolean } =\n    { tag: 'oneOrMore', parser: combinator as Combinator<unknown>, min: 1 }\n  let expected: string[] | undefined\n\n  return {\n    _tag: 'oneOrMore',\n    _meta: meta,\n    _def: def,\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {\n      // First item is mandatory (parsed at pos directly \u2014 leading trivia is the\n      // enclosing context's responsibility); subsequent items skip leading trivia.\n      const first = combinator.parse(input, pos, ctx)\n      if (!first.ok) return first\n      // Aggregate skipped when never observed (see `many`).\n      const values: T[] | undefined = def.valueUnused ? undefined : [first.value]\n      let cur = first.span.end\n      while (cur < input.length) {\n        const item = repItem(combinator, input, cur, ctx)\n        if (item === 'stop') break\n        if ('fail' in item) {\n          // Cold path (element failure). Strict: break. Tolerant: resync \u2014 see many().\n          const sync = ctx._tolerant ? ctx._sync : undefined\n          if (sync === undefined) break\n          if (matchesAt(sync, input, item.failPos, ctx)) break\n          expected ??= deriveExpected(combinator)\n          const { error, end } = recoverScan(input, item.failPos, ctx, sync, expected)\n          if (values !== undefined) values.push(error as unknown as T)\n          captureError(ctx, error)\n          cur = end\n          continue\n        }\n        if (values !== undefined) values.push(item.value)\n        cur = item.end\n      }\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion\n      return { ok: true, value: (values ?? undefined) as T[], span: { start: pos, end: cur } }\n    },\n  }\n}\n\nexport function optional<T>(combinator: Combinator<T>): Combinator<T | null> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  const firstSetSkippable = !matchesEmpty(combinator)\n\n  return {\n    _tag: 'optional',\n    _meta: meta,\n    _def: { tag: 'optional', parser: combinator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T | null> {\n      if (firstSetSkippable && ctx._probe === undefined && !startsFirstSet(combinator, input, pos)) {\n        return { ok: true, value: null, span: { start: pos, end: pos } }\n      }\n      const mark = saveTriviaMark(ctx)\n      const result = combinator.parse(input, pos, ctx)\n      if (result.ok) return result as ParseResult<T>\n      // Inner failed \u2192 roll back any CST leaves/trivia it captured before giving up.\n      rollbackTrivia(ctx, mark)\n      return { ok: true, value: null, span: { start: pos, end: pos } }\n    },\n  }\n}\n\nfunction startsFirstSet(combinator: Combinator<unknown>, input: string, pos: number): boolean {\n  const fs = combinator._meta.firstSet\n  if (fs.kind === 'any') return true\n  if (fs.kind === 'empty') return false\n  const code = input.codePointAt(pos)\n  if (code === undefined) return false\n  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true\n  return false\n}\n\nexport function sepBy<T, S>(combinator: Combinator<T>, separator: Combinator<S>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline || separator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  let expected: string[] | undefined\n\n  return {\n    _tag: 'sepBy',\n    _meta: meta,\n    _def: { tag: 'sepBy', parser: combinator as Combinator<unknown>, separator: separator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {\n      const first = combinator.parse(input, pos, ctx)\n      const values: T[] = []\n      let cur: number\n      if (first.ok) {\n        values.push(first.value)\n        cur = first.span.end\n      } else {\n        // Cold path. Strict: an empty/absent first element is a legal empty list.\n        // Tolerant: if the first element is JUNK (a terminator is inferable and we\n        // are not already sitting on it) recover it and enter the loop; otherwise\n        // it is a genuine empty list.\n        const term = ctx._tolerant ? ctx._sync : undefined\n        if (term === undefined || matchesAt(term, input, pos, ctx)) {\n          return { ok: true, value: [], span: { start: pos, end: pos } }\n        }\n        expected ??= deriveExpected(combinator)\n        const rec = recoverScan(input, pos, ctx, orSentinel(separator, term), expected)\n        values.push(rec.error as unknown as T)\n        captureError(ctx, rec.error)\n        cur = rec.end\n      }\n      while (cur < input.length) {\n        // One mark for the whole iteration (separator + following item): if the\n        // item fails, the trailing separator must be rolled back with it, or its\n        // captured leaves leak past the end of the list.\n        const loopMark = saveTriviaMark(ctx)\n        let sepPos = cur\n        if (ctx.trivia) {\n          if (needsDeferredTriviaCommit(ctx)) {\n            const scan = scanTrivia(input, cur, ctx)\n            scan.commit()\n            sepPos = scan.end\n          } else {\n            sepPos = advanceTrivia(input, cur, ctx)\n          }\n        }\n        const sep = separator.parse(input, sepPos, ctx)\n        if (!sep.ok) {\n          rollbackTrivia(ctx, loopMark)\n          break\n        }\n        let nextPos = sep.span.end\n        if (ctx.trivia) {\n          if (needsDeferredTriviaCommit(ctx)) {\n            const scan = scanTrivia(input, sep.span.end, ctx)\n            scan.commit()\n            nextPos = scan.end\n          } else {\n            nextPos = advanceTrivia(input, sep.span.end, ctx)\n          }\n        }\n        const next = combinator.parse(input, nextPos, ctx)\n        if (!next.ok) {\n          // Cold path. Strict: roll back the trailing separator + break. Tolerant:\n          // the separator we just consumed is real, so resync the bad element after\n          // it. If a terminator is inferable and already present at nextPos, the\n          // separator was a trailing one (e.g. `a;}`) \u2192 roll it back and stop.\n          const term = ctx._tolerant ? ctx._sync : undefined\n          if (term !== undefined && !matchesAt(term, input, nextPos, ctx)) {\n            expected ??= deriveExpected(combinator)\n            const rec = recoverScan(input, nextPos, ctx, orSentinel(separator, term), expected)\n            values.push(rec.error as unknown as T)\n            captureError(ctx, rec.error)\n            cur = rec.end\n            continue\n          }\n          rollbackTrivia(ctx, loopMark)\n          break\n        }\n        values.push(next.value)\n        cur = next.span.end\n      }\n      return { ok: true, value: values, span: { start: pos, end: cur } }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { any } from './first-set.ts'\n\n/**\n * Create a forward-declared parser slot for mutually recursive grammars.\n *\n * Because JS evaluates arguments eagerly, you can't reference a variable\n * before it's declared. ref() creates a placeholder you fill in later:\n *\n *   const value = ref<JSONValue>()\n *   const array  = transform(sequence(literal('['), sepBy(value, literal(',')), literal(']')), ...)\n *   const object = transform(sequence(literal('{'), sepBy(pair, literal(',')), literal('}')), ...)\n *   value.define(choice(object, array, string, number, bool, nullVal))\n *\n * Unlike lazy(() => x), you use the ref directly \u2014 no wrapping at each call site.\n */\nexport function ref<T>(): Combinator<T> & { define(p: Combinator<T>): void } {\n  let resolved: Combinator<T> | null = null\n\n  const meta: ParserMeta = {\n    firstSet: any(),\n    canMatchNewline: true,\n    isTrivia: false,\n  }\n\n  const slot = {\n    _tag: 'lazy' as const,\n    _meta: meta,\n    _def: {\n      tag: 'lazy' as const,\n      thunk: () => {\n        if (!resolved) throw new Error('ref<T>() used before .define() was called')\n        return resolved as Combinator<unknown>\n      },\n    },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      if (!resolved) throw new Error('ref<T>() used before .define() was called')\n      return resolved.parse(input, pos, ctx)\n    },\n    define(p: Combinator<T>): void {\n      if (resolved) throw new Error('ref<T>() already defined')\n      resolved = p\n      meta.firstSet = p._meta.firstSet\n      meta.canMatchNewline = p._meta.canMatchNewline\n      meta.isTrivia = p._meta.isTrivia\n      if (p._meta.triviaKindLabels !== undefined) meta.triviaKindLabels = p._meta.triviaKindLabels\n      else delete meta.triviaKindLabels\n      if (p._meta.disjoint !== undefined) meta.disjoint = p._meta.disjoint\n      else delete meta.disjoint\n    },\n  }\n\n  return slot\n}\n", "import type { Combinator, ParserDef } from '../types.ts'\n\n/**\n * Dead-value analysis (shared by the interpreter and codegen). A container\n * combinator \u2014 `many` / `oneOrMore` / `optional` / `sequence` \u2014 builds an\n * aggregate value (array / tuple / nullable). Under a `node()`, the node builds\n * from the *captured children*, never from that aggregate, so the aggregate is\n * built and thrown away. This pass marks those containers `valueUnused`; the\n * interpreter and the emitter then skip building the aggregate entirely (the\n * elements still parse and self-capture, so trees are identical).\n *\n * Walks ONE combinator tree (a single rule body, or a standalone root), stopping\n * at `lazy`/ref boundaries \u2014 other rules are analyzed on their own root. Starts\n * `consumed = true` (a rule's own value is assumed read \u2014 conservative); `node()`\n * flips it to false for its inner parser; `transform` forces it true (its map fn\n * reads the value). Sharing-safe: any `consumed = true` visit wins and is sticky,\n * so a container reachable from BOTH a consuming and a non-consuming site keeps\n * its aggregate (never wrongly elided).\n *\n * Soundness: a container is marked ONLY when every path to it passes through a\n * `node()` (value-discarding) without an intervening value-reader \u2014 i.e. its\n * aggregate provably isn't observed. Idempotent; safe to re-run.\n */\nexport function markUnusedValues(root: Combinator<unknown>): void {\n  const seenConsumed = new WeakSet<Combinator<unknown>>()\n  const seenUnconsumed = new WeakSet<Combinator<unknown>>()\n\n  const mark = (def: { valueUnused?: boolean }, consumed: boolean): void => {\n    if (consumed) def.valueUnused = false\n    else if (def.valueUnused !== false) def.valueUnused = true\n  }\n\n  const visit = (c: Combinator<unknown>, consumed: boolean): void => {\n    const seen = consumed ? seenConsumed : seenUnconsumed\n    if (seen.has(c)) return\n    seen.add(c)\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion\n    const def = c._def as ParserDef & { valueUnused?: boolean }\n\n    switch (def.tag) {\n      case 'many':\n      case 'oneOrMore':\n        mark(def, consumed)\n        visit(def.parser, consumed)\n        return\n      case 'optional':\n        // `optional` returns `inner | null` \u2014 no aggregate array/tuple to elide, so\n        // it carries no valueUnused flag. Still descend so an inner many/sequence\n        // under a node() is analyzed (it benefits even when its optional wrapper\n        // doesn't).\n        visit(def.parser, consumed)\n        return\n      case 'sequence':\n        mark(def, consumed)\n        for (const p of def.parsers) visit(p, consumed)\n        return\n      case 'choice':\n        // value is the winning arm's value \u2014 propagate consumed to each arm.\n        for (const p of def.parsers) visit(p, consumed)\n        return\n      case 'node':\n        // builds from captured children, NOT the inner parser value.\n        visit(def.parser, false)\n        return\n      case 'transform':\n        // the map fn reads the value \u2192 always consumed.\n        visit(def.parser, true)\n        return\n      case 'field':\n        // the field capture records the parsed value \u2192 always consumed.\n        visit(def.parser, true)\n        return\n      case 'skip':\n        visit(def.main, consumed)   // returns main's value\n        visit(def.skipped, false)   // skipped value is discarded\n        return\n      case 'sepBy':\n        // sepBy is NOT elided (no valueUnused), so it always builds its array and\n        // therefore always reads each item's value \u2014 regardless of whether sepBy's\n        // OWN value is observed. Item parser is unconditionally consumed.\n        visit(def.parser, true)\n        visit(def.separator, false)\n        return\n      case 'not':\n        visit(def.parser, false)    // lookahead \u2014 value never observed\n        return\n      case 'grammar':\n        visit(def.parser, consumed)\n        if (def.triviaParser) visit(def.triviaParser, false)\n        return\n      case 'recover':\n        visit(def.parser, consumed)\n        visit(def.sentinel, false)\n        return\n      case 'label':\n      case 'trivia':\n      case 'token':\n      case 'withCtx':\n      case 'expect':\n        visit(def.parser, consumed) // single-child pass-through wrappers\n        return\n      case 'lazy':\n        // An INNER ref boundary \u2014 a distinct rule, analyzed on its own root. Don't\n        // descend (and never call thunk(): an external ref would throw). A ref at\n        // the ROOT of a rule is different \u2014 it wraps this rule's own body \u2014 and is\n        // resolved by resolveRoot() before the walk starts.\n        return\n      default:\n        // literal / regex / keywords / guard / scanTo / unknown \u2014 no container child.\n        return\n    }\n  }\n\n  // A rule's root is often a `ref()`/`lazy` wrapping the real body \u2014 that is how\n  // rules() and compose() store forward-referenced and composed rules. Walking\n  // that lazy directly hits the boundary case and marks nothing, so resolve a\n  // ROOT lazy to its defined body first. Inner lazies (references to OTHER rules)\n  // stay boundaries \u2014 each rule is analyzed from its own resolved root.\n  const resolveRoot = (c: Combinator<unknown>): Combinator<unknown> => {\n    const guard = new Set<Combinator<unknown>>()\n    let cur = c\n    while (!guard.has(cur)) {\n      const d = cur._def as ParserDef\n      if (d.tag !== 'lazy') return cur\n      guard.add(cur)\n      try { cur = d.thunk() } catch { return c }  // undefined ref \u2192 leave as-is\n    }\n    return cur\n  }\n\n  visit(resolveRoot(root), true)\n}\n", "import type { Combinator } from '../types.ts'\nimport { ref } from './ref.ts'\nimport { markUnusedValues } from '../compiler/value-usage.ts'\n\n/**\n * Non-enumerable key on a `rules()` result holding the factory's declaration\n * order (the returned object's key order), which differs from the result's own\n * reference-creation key order. Read by `parseman/spec` for source-order output.\n */\nexport const RULE_ORDER = '__parsemanRuleOrder'\n\nfunction tagRule(r: Combinator<unknown>, key: string): void {\n  ;(r as unknown as { _ruleName?: string })._ruleName = key\n  if (r._def.tag === 'node' && r._def.type === undefined) r._def.type = key\n}\n\n/**\n * Define named grammar rules without forward declarations.\n *\n * Pass a factory that receives all rule names as references (via a Proxy)\n * and returns a record of combinators. rules() handles creating ref()\n * placeholders and wiring them up \u2014 the user never sees ref() at all.\n *\n *   const { value } = rules(g => ({\n *     value:  choice(g.object, g.array, str, num, bool, nil),\n *     object: transform(sequence('{', sepBy(g.pair, ','), '}'), Object.fromEntries),\n *     array:  transform(sequence('[', sepBy(g.value, ','), ']'), ([, items]) => items),\n *     pair:   transform(sequence(g.key, literal(':'), g.value), ([k,, v]) => [k, v]),\n *   }))\n *\n * Not every name in the factory must appear in the returned object \u2014 local helpers\n * (like `comma`, `key`) can be plain const inside the factory and composed normally.\n * Only names that OTHER rules reference via `g.xxx` need to be in the returned record.\n *\n * TypeScript: use an explicit type parameter for full type safety on `g`:\n *   rules<{ value: Combinator<JSONValue>; array: Combinator<JSONValue[]> }>(g => ({ ... }))\n * Without it, `g.*` accesses are typed as `any` but the return is still inferred.\n */\n/**\n * Grammar-level options for `rules()`. Parity with `parser({...})`, but declared\n * ONCE for the whole grammar instead of wrapped around a scope. `trivia` becomes\n * the ambient trivia for every rule (installed at the parse entry, inherited\n * everywhere, incremental parse included); `parser({trivia})` / `noTrivia` still\n * override it locally for a sub-region.\n */\nexport type RulesOptions = {\n  /** Ambient trivia for the whole grammar. See `parser({ trivia })` for the shape\n   * (`null` clears it \u2014 equivalent to omitting it at the grammar level). */\n  trivia?: Combinator<unknown> | null\n}\n\n// Options-first, mirroring `parser({ opts }, combinator)` \u2014 set once on the grammar\n// vs scope it locally, same options in the same position. The bare `rules(factory)`\n// form is unchanged. The impl also tolerates the legacy `rules(factory, opts)` order.\nexport function rules<T extends Record<string, Combinator<unknown>>>(factory: (self: any) => T): T\nexport function rules<T extends Record<string, Combinator<unknown>>>(options: RulesOptions, factory: (self: any) => T): T\nexport function rules<T extends Record<string, Combinator<unknown>>>(\n  a: ((self: any) => T) | RulesOptions,\n  b?: (self: any) => T,\n): T {\n  const factory = (typeof a === 'function' ? a : b) as (self: any) => T\n  const options = (typeof a === 'function' ? b : a) as RulesOptions | undefined\n  const cache: Partial<T> = {}\n\n  // Proxy: accessing any property creates a ref() placeholder on first touch.\n  const proxy = new Proxy(cache, {\n    get(target, key) {\n      if (typeof key !== 'string') return undefined\n      const record = target as Record<string, Combinator<unknown>>\n      if (!(key in record)) {\n        const r = ref()\n        // Tag the placeholder with its rule name so the linkable compiler can\n        // emit a by-name `_r_<key>` call for a reference to a rule defined in\n        // ANOTHER artifact (resolved at fuse time) \u2014 see compileLinkable.\n        tagRule(r, key)\n        record[key] = r\n      }\n      return record[key]\n    },\n  })\n\n  // Evaluate all rule definitions. JavaScript evaluates object-literal values\n  // left-to-right, so any `g.ruleName` access inside triggers placeholder creation\n  // before the rule's own parser is built \u2014 enabling forward references.\n  const definitions = factory(proxy)\n\n  // Fill each ref with its actual definition, or store directly if never accessed via proxy.\n  for (const key of Object.keys(definitions)) {\n    const placeholder = (cache as Record<string, Combinator<unknown>>)[key]\n    const parser = (definitions as Record<string, Combinator<unknown>>)[key]!\n    if (placeholder !== undefined && typeof (placeholder as any).define === 'function') {\n      tagRule(parser, key)\n      ;(placeholder as any).define(parser)\n      // Propagate actual first-set so later choices wrapping this ref get correct dispatch.\n      placeholder._meta.firstSet = parser._meta.firstSet\n      placeholder._meta.canMatchNewline = parser._meta.canMatchNewline\n    } else {\n      tagRule(parser, key)\n      ;(cache as Record<string, Combinator<unknown>>)[key] = parser\n    }\n  }\n\n  // Declare the grammar-level ambient trivia on every rule, so parsing ANY rule\n  // as an entry installs it (run()/parse() read this), and the macro can seed the\n  // compiled map. `parser({trivia})` / `noTrivia` still override it locally.\n  // `!= null`: a `trivia: null` grammar clears trivia \u2014 same as omitting it at the\n  // grammar level \u2014 so store nothing (and never write null, which has no `_meta`).\n  if (options?.trivia != null) {\n    for (const key of Object.keys(definitions)) {\n      const rule = (cache as Record<string, Combinator<unknown>>)[key]\n      // Skip trivia rules (e.g. the grammar's `rw`, returned so the driver can\n      // reach it as `g.rw`): a trivia rule must never carry ambient trivia, or it\n      // would recursively skip trivia within itself. Mirrors the codegen guard.\n      if (rule && !rule._meta.isTrivia) (rule._meta as { grammarTrivia?: Combinator<unknown> }).grammarTrivia = options.trivia\n    }\n  }\n\n  // Dead-value analysis: mark container aggregates that only feed a node()'s\n  // capture so the interpreter (and, via the same flag, the compiled output) skips\n  // building them. Each rule is its own root \u2014 refs are boundaries (see value-usage).\n  for (const key of Object.keys(definitions)) {\n    markUnusedValues((cache as Record<string, Combinator<unknown>>)[key]!)\n  }\n\n  // Record the factory's DECLARATION order (the returned object's key order).\n  // `cache`'s own key order is reference-creation order \u2014 a Proxy artifact \u2014 so\n  // it can lead with an internal rule instead of the entry rule. Consumers that\n  // want the order the author actually wrote (e.g. `parseman/spec`) read this.\n  // Non-enumerable, so Object.keys / spread / for-in over the grammar are\n  // unaffected and every existing consumer sees exactly the rules it did before.\n  Object.defineProperty(cache, RULE_ORDER, {\n    value: Object.keys(definitions),\n    enumerable: false,\n    configurable: true,\n  })\n\n  return cache as T\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { any } from './first-set.ts'\nimport { saveCstMark, rollbackCstCapture } from '../cst/capture-buffer.ts'\n\n/**\n * Negative lookahead. Succeeds (consuming nothing) when `combinator` fails;\n * fails when `combinator` succeeds.\n *\n * The standard way to match a keyword without also matching the prefix\n * of a longer identifier:\n *\n *   const kwTrue = sequence(literal('true'), not(regex(/\\w/)))\n *   // matches \"true\" in \"true && x\" but NOT in \"trueish\" or \"trueness\"\n */\nexport function not(combinator: Combinator<unknown>): Combinator<null> {\n  const meta: ParserMeta = {\n    firstSet: any(),     // we don't know what NOT matches\n    canMatchNewline: false,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'not',\n    _meta: meta,\n    _def: { tag: 'not', parser: combinator },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<null> {\n      // Negative lookahead is a pure predicate: whatever the inner attempt\n      // captured (CST leaves/trivia/fields) or recovered (a ParseError pushed to\n      // ctx._errors + embedded via captureError) must be rolled back on BOTH\n      // outcomes \u2014 not() consumes nothing and so may leave no side effect, or a\n      // speculatively-recovered error would ghost past the lookahead.\n      const mark = saveCstMark(ctx)\n      const result = combinator.parse(input, pos, ctx)\n      rollbackCstCapture(ctx, mark)\n      if (result.ok) {\n        return { ok: false, expected: [`not(${combinator._tag})`], span: { start: pos, end: pos } }\n      }\n      return { ok: true, value: null, span: { start: pos, end: pos } }\n    },\n  }\n}\n", "import type { ParserDef } from '../types.ts'\n\n/**\n * Per-node CST-trivia (5th build arg) and state-clone (6th build arg) capture is\n * dead work when the build never declares those formal params. This module derives\n * a build's *confirmed* formal-parameter arity so all three eval paths (interpreter,\n * compiler, macro) can elide that capture identically.\n *\n * Conservative by construction: any source we can't confidently parse \u2014 rest params,\n * destructuring, `arguments`, an unrecognized shape \u2014 yields `null` (arity unknown),\n * and callers KEEP full capture. We only ever return a number when the parameter list\n * is a plain comma-separated list of simple identifiers.\n */\n\ntype NodeDef = Extract<ParserDef, { tag: 'node' }>\n\n/** Matches the formal-parameter list of an arrow or function build, capturing its inner text. */\nconst PARAM_LIST_RE =\n  // (params) => ...   |   function name?(params) ...   |   single-ident arrow `x => ...`\n  /^(?:function\\b[^(]*\\(([^)]*)\\)|\\(([^)]*)\\)\\s*=>|([A-Za-z_$][\\w$]*)\\s*=>)/\n\n/**\n * A confirmable formal param: a plain identifier, optionally `?`-optional and\n * optionally carrying a TypeScript type annotation (`c`, `c?`, `c: any`,\n * `c?: Foo`). The build source is sliced verbatim from the (possibly TS) grammar\n * source, so typed params must be recognized or every typed grammar keeps full\n * capture. Type annotations containing a comma (generics/tuples/object types) are\n * split apart by the caller's `,`-split into non-matching fragments \u2192 `null`\n * (conservative). No `=` (default) is accepted \u2014 defaults stay unconfirmed.\n */\nconst CONFIRMABLE_PARAM_RE = /^[A-Za-z_$][\\w$]*\\s*\\??\\s*(?::[^,=]+)?$/\n\n/**\n * Confirmed count of simple formal parameters the build declares, or `null` when the\n * source can't be parsed into a plain identifier list (\u2192 caller keeps full capture).\n */\nexport function confirmedBuildArity(src: string): number | null {\n  const s = src.trim()\n  const m = PARAM_LIST_RE.exec(s)\n  if (!m) return null\n\n  // Single-ident arrow: `x => ...` \u2192 exactly one param.\n  if (m[3] !== undefined) return 1\n\n  const inner = (m[1] ?? m[2] ?? '').trim()\n  if (inner === '') return 0\n\n  // Reject anything that isn't a flat list of simple identifiers. A rest param\n  // (`...args`), destructuring (`{a}`, `[a]`), or default (`a = 1`) all appear here.\n  const parts = inner.split(',')\n  for (const part of parts) {\n    if (!CONFIRMABLE_PARAM_RE.test(part.trim())) return null\n  }\n\n  // A stray `arguments` reference defeats formal-arity reasoning entirely; only a\n  // full-source scan can rule it out. Cheap guard against the obvious cases.\n  if (/\\barguments\\b/.test(s)) return null\n\n  return parts.length\n}\n\n/** Build reads the 5th (triviaLog) arg? Unknown/unparseable \u2192 true (keep capture). */\nexport function buildReadsTrivia(def: NodeDef): boolean {\n  if (!def.build) return true // structural node: host may read trivia \u2014 keep capture\n  const src = def.buildSrc ?? def.build.toString()\n  const arity = confirmedBuildArity(src)\n  if (arity === null) return true\n  return arity >= 5\n}\n\n/** Build reads the 6th (state) arg? Unknown/unparseable \u2192 true (keep state clone). */\nexport function buildReadsState(def: NodeDef): boolean {\n  if (!def.build) return true // structural node: host may read state \u2014 keep clone\n  const src = def.buildSrc ?? def.build.toString()\n  const arity = confirmedBuildArity(src)\n  if (arity === null) return true\n  return arity >= 6\n}\n", "import type { Combinator, FieldMap, ParserDef } from '../types.ts'\nimport { confirmedBuildArity } from './build-arity.ts'\n\ntype NodeDef = Extract<ParserDef, { tag: 'node' }>\n\nexport function buildReadsFields(def: NodeDef): boolean {\n  if (!def.build) return true\n  const src = def.buildSrc ?? def.build.toString()\n  const arity = confirmedBuildArity(src)\n  if (arity === null) return true\n  return arity >= 2\n}\n\nexport function parserHasOwnFields(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  if (seen.has(p)) return false\n  seen.add(p)\n  const d = p._def\n  switch (d.tag) {\n    case 'field': return true\n    case 'node': return false\n    case 'lazy': {\n      try { return parserHasOwnFields(d.thunk(), seen) } catch { return false }\n    }\n    case 'sequence':\n    case 'choice': return d.parsers.some(x => parserHasOwnFields(x, seen))\n    case 'sepBy': return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.separator, seen)\n    case 'skip': return parserHasOwnFields(d.main, seen) || parserHasOwnFields(d.skipped, seen)\n    case 'grammar': return parserHasOwnFields(d.parser, seen) || (d.triviaParser ? parserHasOwnFields(d.triviaParser, seen) : false)\n    case 'scanTo': return parserHasOwnFields(d.sentinel, seen) || d.skip.some(x => parserHasOwnFields(x, seen))\n    case 'recover': return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.sentinel, seen)\n    case 'many':\n    case 'oneOrMore':\n    case 'optional':\n    case 'transform':\n    case 'trivia':\n    case 'token':\n    case 'label':\n    case 'expect':\n    case 'withCtx':\n    case 'not':\n      return parserHasOwnFields(d.parser, seen)\n    default:\n      return false\n  }\n}\n\nexport function buildFieldMap(captures: ReadonlyArray<{ name: string; value: unknown; span: { start: number; end: number } }> | undefined): FieldMap | undefined {\n  if (!captures?.length) return undefined\n  const out: FieldMap = {}\n  for (const cap of captures) {\n    const entry = { value: cap.value, span: cap.span }\n    const current = out[cap.name]\n    if (current === undefined) out[cap.name] = entry\n    else if (Array.isArray(current)) current.push(entry)\n    else out[cap.name] = [current, entry]\n  }\n  return out\n}\n", "import type { Combinator, FieldMap, ParseContext, ParseResult, ParserMeta, ParserDef } from '../types.ts'\nimport { beginCstNodeCapture, endCstNodeCapture, pushCstChild } from '../cst/capture-buffer.ts'\nimport { buildReadsTrivia, buildReadsState } from '../compiler/build-arity.ts'\nimport { buildFieldMap, buildReadsFields, parserHasOwnFields } from '../compiler/fields.ts'\n\n/**\n * A CST/AST node rule. Runs `combinator` while collecting its terminals into\n * `children` / `rawChildren` arrays and trivia spans into `triviaLog`, then\n * calls `build(children, fields, span, rawChildren, triviaLog, state)` to produce the node.\n *\n *   - `children`    \u2014 structural items in source order: spanned CSTLeaf terminals\n *                     and sub-nodes (whatever `build` returned for inner nodes).\n *   - `rawChildren` \u2014 structural children only (same items as `children`).\n *   - `triviaLog`   \u2014 flat log of trivia entries: each entry is `[start, end, insertIdx]`\n *                     consumed between terms. `insertIdx` is the rawChildren index\n *                     before which the trivia was consumed. Use `buildTriviaIndex`\n *                     to turn this into a before/after lookup table.\n *\n * If `build` returns a non-node value (e.g. a bare string for an unwrapped rule),\n * the parent records it as a spanned leaf so its source span is still recoverable.\n */\nexport type BuildNode<N> = (\n  children: ReadonlyArray<unknown>,\n  fields: FieldMap | undefined,\n  span: { start: number; end: number },\n  rawChildren: ReadonlyArray<unknown>,\n  triviaLog: readonly number[],\n  state: unknown,\n) => N\n\n/**\n * Options for `node()`.\n * - `unwrap` \u2014 an AST/value wrapper rule that IS its single child when it\n *   captured exactly one. A leaf unwraps to its string value; a sub-node is\n *   returned as-is.\n * - `collapse` \u2014 a structural wrapper rule that returns its single child exactly\n *   as captured. A leaf stays a CSTLeaf; a node stays a node.\n * Both skip `build` only for a one-child match; zero or two-plus children go\n * through `build` normally.\n */\nexport type NodeOptions = { unwrap?: boolean; collapse?: boolean }\n\n/** A captured child's value form: a leaf unwraps to its string value, else as-is. */\nfunction unwrapChild(child: unknown): unknown {\n  return child !== null && typeof child === 'object' && (child as { _tag?: string })._tag === 'leaf'\n    ? (child as { value: unknown }).value\n    : child\n}\n\nfunction isCstChild(value: unknown): boolean {\n  return typeof value === 'object'\n    && value !== null\n    && ((value as { _tag?: string })._tag === 'node'\n      || (value as { _tag?: string })._tag === 'leaf'\n      || (value as { _tag?: string })._tag === 'parseError')\n}\n\nfunction missingInferredType(): never {\n  throw new Error('node(): inferred node type requires a rules() key; pass node(\"Type\", parser) outside rules()')\n}\n\nexport function node<N>(combinator: Combinator<unknown>, build?: BuildNode<N>, opts?: NodeOptions): Combinator<N>\nexport function node<N>(type: string, combinator: Combinator<unknown>, build?: BuildNode<N>, opts?: NodeOptions): Combinator<N>\nexport function node<N>(\n  typeOrCombinator: string | Combinator<unknown>,\n  combinatorOrBuild?: Combinator<unknown> | BuildNode<N>,\n  buildOrOpts?: BuildNode<N> | NodeOptions,\n  maybeOpts?: NodeOptions,\n): Combinator<N> {\n  const hasExplicitType = typeof typeOrCombinator === 'string'\n  const type = hasExplicitType ? typeOrCombinator : undefined\n  const combinator = (hasExplicitType ? combinatorOrBuild : typeOrCombinator) as Combinator<unknown>\n  const build = (hasExplicitType ? buildOrOpts : combinatorOrBuild) as BuildNode<N> | undefined\n  const opts = (hasExplicitType ? maybeOpts : buildOrOpts) as NodeOptions | undefined\n  const baseDef = { tag: 'node' as const, parser: combinator, ...(type === undefined ? {} : { type }), ...(build === undefined ? {} : { build }) }\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  const unwrap = opts?.unwrap === true\n  const collapse = opts?.collapse === true\n  if (unwrap && collapse) {\n    throw new Error('node() options cannot set both unwrap and collapse')\n  }\n  const def: Extract<ParserDef, { tag: 'node' }> = unwrap || collapse\n    ? { ...baseDef, ...(unwrap ? { unwrap: true } : {}), ...(collapse ? { collapse: true } : {}) }\n    : baseDef\n  // Arity-gated elision \u2014 decided once, identically to the compiler (build-arity.ts).\n  // When the build never reads the trivia (4th) arg, disable per-node CST-trivia\n  // capture for the inner scope; when it never reads state (5th), skip the state clone.\n  // A STRUCTURAL node (no own build) defers to `ctx.build` / a default CST, which\n  // may read either, so capture both.\n  const capturesTrivia = build ? buildReadsTrivia(def) : true\n  const clonesState = build ? buildReadsState(def) : true\n  const capturesFields = parserHasOwnFields(combinator) && (build ? buildReadsFields(def) : true)\n  return {\n    _tag: 'node',\n    _meta: meta,\n    _def: def,\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<N> {\n      const saved = beginCstNodeCapture(ctx)\n      const savedFields = ctx._fields\n      ctx._fields = capturesFields ? [] : undefined\n      // Per-node-type trivia-kind mask: a structural (host-built) node may want\n      // only certain kinds captured (comments for Ruleset, whitespace for\n      // CompoundSelector). Scoped here, restored below \u2014 matches the compiled path.\n      const savedMask = ctx._triviaCaptureMask\n      if (build === undefined && ctx.build?._parsemanTriviaKinds !== undefined && def.type !== undefined) {\n        ctx._triviaCaptureMask = ctx.build._parsemanTriviaKinds(def.type)\n      }\n      // Short-circuit the per-node trivia push (scanTrivia gates on captureTrivia)\n      // without touching the global _triviaLog, which is committed independently.\n      if (!capturesTrivia) ctx.captureTrivia = false\n      const r = combinator.parse(input, pos, ctx)\n      const fields = capturesFields ? buildFieldMap(ctx._fields) : undefined\n      ctx._fields = savedFields\n      ctx._triviaCaptureMask = savedMask\n      const { children, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved)\n\n      if (!r.ok) return r\n\n      // unwrap/collapse: a single captured child IS the value \u2014 skip build.\n      const st = clonesState && ctx.state !== undefined ? Object.assign({}, ctx.state as Record<string, unknown>) : undefined\n      const nodeType = def.type ?? missingInferredType()\n      const built: unknown = unwrap && children.length === 1\n        ? unwrapChild(children[0])\n        : collapse && children.length === 1\n          ? children[0]\n        : !build\n          && ctx.build?._parsemanCstCollapse\n          && children.length === 1\n          && rawChildren.length === 1\n          && ctx.build._parsemanCstCollapse(nodeType, children[0], children, rawChildren)\n          ? children[0]\n        : build\n          ? build(children, fields, r.span, rawChildren, triviaLog, st)\n          // Structural node: a `ctx.build` host if present, else a default CST.\n          : ctx.build\n              ? ctx.build(nodeType, children, fields, r.span, rawChildren, triviaLog, st)\n              : { _tag: 'node', type: nodeType, span: { start: r.span.start, end: r.span.end }, state: st ?? null, children }\n      const rawEntry = isCstChild(built)\n        ? built\n        : { _tag: 'leaf', value: typeof built === 'string' ? built : '', span: r.span }\n      if (saved.buf !== undefined || saved.ch !== undefined) {\n        pushCstChild(ctx, built, rawEntry)\n      }\n      return { ok: true, value: built as N, span: r.span }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult } from '../types.ts'\nimport { analyzeLabeledTrivia } from '../cst/trivia-kinds.ts'\n\nexport function transform<T, U>(\n  combinator: Combinator<T>,\n  fn: (value: T, span: { start: number; end: number }) => U\n): Combinator<U> {\n  return {\n    _tag: 'transform',\n    _meta: combinator._meta,\n    _def: { tag: 'transform', parser: combinator as Combinator<unknown>, fn: fn as (v: unknown, span: { start: number; end: number }) => unknown },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<U> {\n      const result = combinator.parse(input, pos, ctx)\n      if (!result.ok) return result\n      return { ok: true, value: fn(result.value, result.span), span: result.span }\n    },\n  }\n}\n\nexport function skip<T, S>(main: Combinator<T>, skipped: Combinator<S>): Combinator<T> {\n  return {\n    _tag: 'skip',\n    _meta: main._meta,\n    _def: { tag: 'skip', main: main as Combinator<unknown>, skipped: skipped as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      const result = main.parse(input, pos, ctx)\n      if (!result.ok) return result\n      const s = skipped.parse(input, result.span.end, ctx)\n      if (!s.ok) return result\n      return { ok: true, value: result.value, span: { start: result.span.start, end: s.span.end } }\n    },\n  }\n}\n\nexport function trivia<T>(combinator: Combinator<T>): Combinator<T> {\n  const kindLabels = analyzeLabeledTrivia(combinator as Combinator<unknown>)?.labels\n  return {\n    _tag: combinator._tag,\n    _meta: {\n      ...combinator._meta,\n      isTrivia: true,\n      ...(kindLabels ? { triviaKindLabels: kindLabels } : {}),\n    },\n    _def: { tag: 'trivia', parser: combinator as Combinator<unknown> },\n    parse: combinator.parse.bind(combinator),\n  }\n}\n\n/**\n * Attach a string label to a parser arm (e.g. trivia `choice` branches).\n * Parse behavior is unchanged; the label is metadata for tooling and future\n * trivia-kind capture (`'whitespace'`, `'blockComment'`, \u2026).\n */\nexport function label<T>(name: string, combinator: Combinator<T>): Combinator<T> {\n  return {\n    _tag: combinator._tag,\n    _meta: combinator._meta,\n    _def: { tag: 'label', label: name, parser: combinator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      const result = combinator.parse(input, pos, ctx)\n      if (!result.ok) return { ok: false, expected: [name], span: result.span }\n      return result\n    },\n  }\n}\n\n/**\n * Capture a named parse result for the nearest enclosing node() builder.\n * Parse behavior and the normal returned value are unchanged.\n */\nexport function field<T>(name: string, combinator: Combinator<T>): Combinator<T> {\n  return {\n    _tag: combinator._tag,\n    _meta: combinator._meta,\n    _def: { tag: 'field', name, parser: combinator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      const result = combinator.parse(input, pos, ctx)\n      if (!result.ok) return result\n      ctx._fields?.push({ name, value: result.value, span: result.span })\n      return result\n    },\n  }\n}\n", "import type { Span } from '../types.ts'\n\n/**\n * Precomputed index of newline positions for O(log n) offset\u2192line/col lookup.\n * lineStarts[i] is the byte offset of the first character on line i+1.\n */\nexport type LineIndex = { lineStarts: number[] }\n\nexport function buildLineIndex(input: string): LineIndex {\n  const lineStarts = [0]\n  for (let i = 0; i < input.length; i++) {\n    if (input.charCodeAt(i) === 10) lineStarts.push(i + 1)\n  }\n  return { lineStarts }\n}\n\nexport function offsetToLineCol(\n  index: LineIndex,\n  offset: number\n): { line: number; col: number } {\n  const { lineStarts } = index\n  let lo = 0\n  let hi = lineStarts.length - 1\n  while (lo < hi) {\n    const mid = (lo + hi + 1) >> 1\n    if (lineStarts[mid]! <= offset) lo = mid\n    else hi = mid - 1\n  }\n  return { line: lo + 1, col: offset - lineStarts[lo]! + 1 }\n}\n\n/** Fills startLine/startColumn/endLine/endColumn on a span in-place. */\nexport function annotateSpan(span: Span, index: LineIndex): Span {\n  const s = offsetToLineCol(index, span.start)\n  const e = offsetToLineCol(index, span.end)\n  return {\n    ...span,\n    startLine: s.line,\n    startColumn: s.col,\n    endLine: e.line,\n    endColumn: e.col,\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParseFail } from '../types.ts'\nimport { buildLineIndex, annotateSpan } from '../compiler/line-index.ts'\nimport { markUnusedValues } from '../compiler/value-usage.ts'\nimport { triviaKindMask } from '../cst/trivia-kinds.ts'\n\nexport type ParseOptions = {\n  trackLines?: boolean\n  /**\n   * Enable the error-collection channel. When true, recovery points (expect(), and\n   * tolerant list recovery) collect their ParseErrors into a side-channel array\n   * rather than only embedding them in the value tree. The returned ParseOk will\n   * have an `errors` field listing all recovered errors. Top-level parse failures\n   * (where nothing recovered) still return ParseFail as usual.\n   */\n  recover?: boolean\n}\n\nexport type ParserOptions = ParseOptions & {\n  /**\n   * Trivia parser for this scope. Three states:\n   *   - a Combinator \u2192 skip this trivia between sequence/repeat terms\n   *   - `undefined`  \u2192 inherit the enclosing scope's trivia (no change)\n   *   - `null`       \u2192 CLEAR trivia: no trivia skipped, so terms must be contiguous.\n   *                    Re-enable inside a nested region with another parser({ trivia }).\n   */\n  trivia?: Combinator<unknown> | null\n  /** Record consumed trivia as CSTTrivia tokens in rawChildren. Default: skip. */\n  captureTrivia?: boolean\n  /**\n   * Restrict PER-NODE CST trivia capture to these trivia kinds (label names from\n   * the trivia's `label()` arms). Whitespace and any other unlisted kind is still\n   * skipped over but NOT recorded into a node's `triviaLog` \u2014 so a host that only\n   * consumes (say) comments pays nothing to log every whitespace run. The global\n   * trivia log is unaffected. Requires labeled trivia; ignored otherwise.\n   */\n  captureTriviaKinds?: readonly string[]\n}\n\nexport interface ParsemanParser<T> extends Combinator<T> {\n  parse(input: string): ParseResult<T>\n  parse(input: string, pos: number, ctx: ParseContext): ParseResult<T>\n}\n\nexport function parser<T>(opts: ParserOptions, root: Combinator<T>): ParsemanParser<T> {\n  const clearTrivia = opts.trivia === null\n  return {\n    _tag: 'grammar',\n    _meta: root._meta,\n    _def: {\n      tag: 'grammar',\n      parser: root as Combinator<unknown>,\n      triviaParser: clearTrivia ? undefined : (opts.trivia ?? undefined),\n      clearTrivia,\n      trackLines: opts.trackLines ?? false,\n    },\n    parse(input: string, pos?: number, _ctx?: ParseContext): ParseResult<T> {\n      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false\n      // Preserve any CST collectors / capture flag from the caller (e.g. an\n      // enclosing node()), layering this grammar's trivia on top. Without this,\n      // a parser() nested inside a node() would drop the node's child collectors.\n      const ctx: ParseContext = {\n        ..._ctx,\n        trackLines,\n        // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.\n        ...(clearTrivia ? {\n          trivia: undefined,\n          triviaKindLabels: undefined,\n        } : opts.trivia != null ? {\n          trivia: opts.trivia,\n          ...(opts.trivia._meta.triviaKindLabels\n            ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels }\n            : {}),\n        } : {}),\n        ...(opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {}),\n        // Kind-filter for per-node capture. Resolve against this scope's trivia\n        // labels \u2014 this parser's own trivia if it declares one, else the INHERITED\n        // labels (`_ctx.triviaKindLabels`), so captureTriviaKinds still applies when\n        // trivia is inherited rather than re-declared here. No labels \u2192 undefined\n        // (capture all).\n        ...(opts.captureTriviaKinds && !clearTrivia\n          ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) }\n          : {}),\n      }\n      const result = root.parse(input, pos ?? 0, ctx)\n      if (trackLines) {\n        const idx = buildLineIndex(input)\n        return { ...result, span: annotateSpan(result.span, idx) }\n      }\n      return result\n    },\n  } as ParsemanParser<T>\n}\n\n/**\n * Run `root` with the active trivia cleared \u2014 no trivia is skipped between its\n * sequence/repeat terms, so they must be contiguous in the input. (Trivia is\n * whatever parser({ trivia }) installed \u2014 often whitespace/comments, but it is\n * grammar-defined.) The inverse of parser({ trivia }); re-enable trivia in a\n * nested region with another parser({ trivia }).\n *\n * Wrap the WHOLE contiguous run: an enclosing sequence skips trivia *before* a\n * term runs, so wrapping just the inner part would let leading trivia through.\n *\n * For a static glued token just use one literal/regex; reach for noTrivia when a\n * glued part is a structured sub-rule \u2014 e.g. a head glued to a `[subscript]`\n * whose interior still allows trivia. Turn trivia back on for a region by nesting\n * another parser({ trivia }) (innermost wins, reverts on exit); put the WHOLE\n * spaced region \u2014 including its leading `[` \u2014 inside it, since sequence skips\n * trivia only between terms, not before its first:\n *\n *   // `arr[i + 1]` \u2014 `arr` touches `[`, but the subscript is a spaced expr:\n *   noTrivia(sequence(name,\n *     parser({ trivia: ws }, sequence(literal('['), expr, literal(']')))))\n */\nexport function noTrivia<T>(root: Combinator<T>): ParsemanParser<T> {\n  return parser({ trivia: null }, root)\n}\n\n// Roots already run through dead-value analysis, so a hot parse loop doesn't\n// re-walk the tree. (A `rules()` grammar was analyzed at build; a bare combinator\n// passed straight to parse() is analyzed once here.)\nconst _analyzed = new WeakSet<Combinator<unknown>>()\n\nexport function parse<T>(\n  combinator: Combinator<T>,\n  input: string,\n  opts: ParseOptions = {}\n): ParseResult<T> {\n  if (!_analyzed.has(combinator)) {\n    _analyzed.add(combinator)\n    markUnusedValues(combinator)\n  }\n  const trackLines = opts.trackLines ?? false\n  const _errors = opts.recover ? [] : undefined\n  // In recovery mode also track the furthest-position failure, so the caller can\n  // report \"where it got stuck + what was expected\" even when a permissive top\n  // rule succeeds with unconsumed trailing input. Off by default (it adds\n  // bookkeeping to every failed alternative).\n  const _probe = opts.recover ? { offset: input.length, best: null as ParseFail | null } : undefined\n  // Grammar-level ambient trivia declared via rules({ trivia }, factory): install\n  // it as ctx.trivia so it's ambient (interpreter). parser/noTrivia override locally.\n  const grammarTrivia = combinator._meta.grammarTrivia\n  const ctx: ParseContext = {\n    trackLines,\n    ...(grammarTrivia !== undefined\n      ? { trivia: grammarTrivia, ...(grammarTrivia._meta.triviaKindLabels ? { triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {}) }\n      : {}),\n    ...(_errors !== undefined ? { _errors } : {}),\n    ...(_probe !== undefined ? { _probe } : {}),\n  }\n  const result = combinator.parse(input, 0, ctx)\n  if (!result.ok) return result\n  const withErrors = _errors !== undefined\n    ? { ...result, errors: _errors, furthestFail: _probe?.best ?? null }\n    : result\n  if (trackLines) {\n    const idx = buildLineIndex(input)\n    return { ...withErrors, span: annotateSpan(withErrors.span, idx) }\n  }\n  return withErrors\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\n/**\n * Treat a parser as one source token.\n *\n * The wrapped parser runs with trivia cleared, so its parts must be contiguous.\n * On success the token returns the matched source text and captures one CST leaf\n * for the full span, suppressing any internal terminal leaves.\n */\nexport function token(root: Combinator<unknown>): Combinator<string> {\n  const meta: ParserMeta = {\n    firstSet: root._meta.firstSet,\n    canMatchNewline: root._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'token',\n    _meta: meta,\n    _def: { tag: 'token', parser: root },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      const savedTrivia = ctx.trivia\n      const savedKinds = ctx.triviaKindLabels\n      const savedBuf = ctx._cstBuf\n      const savedChildren = ctx._cstChildren\n      const savedLeaves = ctx._cstLeaves\n      const savedRaw = ctx._cstRawChildren\n      const savedTriviaLog = ctx._cstTriviaLog\n      const savedOuterTriviaLog = ctx._triviaLog\n      const wasCapturing = cstCaptureActive(ctx)\n\n      ctx.trivia = undefined\n      ctx.triviaKindLabels = undefined\n      ctx._cstBuf = undefined\n      ctx._cstChildren = undefined\n      ctx._cstLeaves = undefined\n      ctx._cstRawChildren = undefined\n      ctx._cstTriviaLog = undefined\n      delete ctx._triviaLog\n\n      let result: ParseResult<unknown>\n      try {\n        result = root.parse(input, pos, ctx)\n      } finally {\n        ctx.trivia = savedTrivia\n        ctx.triviaKindLabels = savedKinds\n        ctx._cstBuf = savedBuf\n        ctx._cstChildren = savedChildren\n        ctx._cstLeaves = savedLeaves\n        ctx._cstRawChildren = savedRaw\n        ctx._cstTriviaLog = savedTriviaLog\n        if (savedOuterTriviaLog === undefined) delete ctx._triviaLog\n        else ctx._triviaLog = savedOuterTriviaLog\n      }\n\n      if (!result.ok) return result\n\n      const span = result.span\n      const value = input.slice(pos, span.end)\n      if (wasCapturing) pushCstLeaf(ctx, { _tag: 'leaf', value, span })\n      return { ok: true, value, span }\n    },\n  }\n}\n", "/**\n * Structural recognition of \"scannable\" parser arms \u2014 regex shapes that lower to\n * a tight character-scan loop instead of `regex.exec` / combinator dispatch. Each\n * shape is derived from the regex STRUCTURE, not from any hardcoded knowledge\n * that a given regex \"is whitespace\" or \"is a comment\":\n *\n *   [X]+ / [X]*            \u2192 run while the char \u2208 X                (chars)\n *   <lit>[^X]*             \u2192 consume <lit>, run until char \u2208 X     (until)\n *   <open>(?:\u2026)*<close>    \u2192 consume <open>, run to <close> literal (delimited)\n *   x?<lit><[X]*>\u2026         \u2192 a general linear chain of lit/run     (seq)\n *\n * `seq` is the CATEGORY generalization: any chain of literal segments (required\n * or optional `x?`) and char-class runs (positive/negated, `?`/`*`/`+`). It\n * subsumes CSS/Less `-?ident`, `--custom`, `@-?keyword`, `[^\u2026]+`, `::?`, etc.\n * without hardcoding a single byte \u2014 lowered only when a greedy one-pass scan\n * provably equals the engine's backtracking (see `seqIsUnambiguous`).\n *\n * A `oneOrMore(choice(a, b, \u2026))` where every arm is one of these compiles to a\n * single char-dispatch loop with one branch per arm \u2014 any count/order, because\n * the shapes dispatch on their first 1\u20132 chars and are checked in turn. Trivia\n * (whitespace + comments) is just the value-discarded instance of this; nothing\n * here is trivia-specific.\n */\n\n/**\n * One segment of a `seq` shape. A `seq` is the general category \"a fixed linear\n * chain of literals and char-class runs\" \u2014 no alternation, no groups, no\n * backtracking. It subsumes every CSS/Less token that is \"(optional prefix)?\n * literal* char-run* \u2026\" without hardcoding any particular byte:\n *\n *   lit   \u2014 a run of fixed code points, optionally present (`x?`) or required.\n *   run   \u2014 a char-class run: positive/negated ranges, min 0/1, bounded to one\n *           char (`[x]`, `[x]?`) or unbounded (`[x]*`, `[x]+`).\n *   group \u2014 a non-capturing sub-pattern `(?:\u2026)` (\u00A78f), quantified the same way\n *           as `run` (`min`/`unbounded`). `inner` is any already-recognized\n *           `ScanShape` for the group's body (so a group can itself contain\n *           `seq`/`chars`/`alt`/\u2026 \u2014 including a nested alternation via \u00A78e).\n *           Only used when `groupInnerSafe(inner)` holds (see that function).\n *\n * We only lower a `seq` when greedy left-to-right scanning provably equals the\n * regex engine's backtracking match (see `seqIsUnambiguous`).\n */\nexport type SeqPart =\n  | { part: 'lit'; cps: number[]; optional: boolean }\n  // A char-class run with a general counted quantifier: `min`..`max` occurrences.\n  // `max === Infinity` is unbounded (`+`/`*`/`{n,}`). The four legacy shapes map\n  // as `+`\u2192{1,\u221E} `*`\u2192{0,\u221E} `?`\u2192{0,1} bare\u2192{1,1}; `{n,m}` (\u00A78c) fills the rest.\n  // Greedy scanning has \"wiggle\" a backtracker could exploit iff `max > min`.\n  | { part: 'run'; ranges: Array<[number, number]>; negated: boolean; min: number; max: number }\n  | { part: 'group'; inner: ScanShape; min: 0 | 1; unbounded: boolean }\n\nexport type ScanShape =\n  | { kind: 'chars'; ranges: Array<[number, number]>; minOne: boolean }\n  | { kind: 'ident'; head: Array<[number, number]>; tail: Array<[number, number]> }\n  | { kind: 'until'; open: number[]; stop: Array<[number, number]> }\n  | { kind: 'delimited'; open: number[]; close: number[] }\n  // <q>(?:[^<q>\\\\]|\\\\.)*<q> \u2014 a quote-delimited string with backslash escapes.\n  // `excluded` = the body's negated class (always contains the quote + backslash,\n  // maybe a newline); `escLineTerm` = whether `\\\\` may be followed by a line\n  // terminator (`\\\\[\\s\\S]` \u2192 true, `\\\\.` \u2192 false, since `.` excludes them).\n  | { kind: 'string'; quote: number; excluded: Array<[number, number]>; escLineTerm: boolean }\n  // A linear chain of literal/char-run segments (optional prefixes, literal\n  // openers, negated runs, \u2026) \u2014 the general CSS/Less token category.\n  | { kind: 'seq'; parts: SeqPart[] }\n  // A pure literal matched case-insensitively (`/i`): the general \"ASCII\n  // case-fold literal\" category (CSS `url(`, `@media` keywords under `i`, \u2026).\n  | { kind: 'litFold'; open: number[] }\n  // `<inner>(?!class)` / `<inner>(?=class)` \u2014 a trailing lookahead boundary\n  // check on an already-lowered shape. Zero-width: `end` is `inner`'s end, never\n  // extended. `classNegated` is the bracket's OWN `[^\u2026]` negation (e.g.\n  // `(?![0-9a-fA-F])` vs `(?=[^0-9])`), independent of `negative` (`!` vs `=`).\n  | { kind: 'lookahead'; inner: ScanShape; ranges: Array<[number, number]>; classNegated: boolean; negative: boolean }\n  // `A|B|C` \u2014 top-level alternation (\u00A78e), split outside any `[]`/`()`, each arm\n  // independently lowered. `disjoint` is true iff every pair of arms has\n  // provably non-overlapping first-char sets (`firsts[i]` holds that arm's set,\n  // or `null` if it could start with any char \u2014 an unbounded-optional `chars`\n  // arm, or a non-disjoint mix). When `disjoint`, codegen dispatches straight to\n  // the one matching arm; otherwise it tries arms in order and takes the first\n  // that succeeds \u2014 the same ordered-choice semantics as regex `|` itself (see\n  // the ordered-vs-longest verification in PERF_IDEAS \u00A78e).\n  | { kind: 'alt'; arms: ScanShape[]; disjoint: boolean; firsts: Array<CharSet | null> }\n\n/** Backslash (`\\`) code point \u2014 the escape lead char in string shapes. */\nexport const BACKSLASH = 92\n\nconst META = new Set('()[]{}*+?|^$.'.split(''))\n\n// Regex char-class primitives are shared with the interpreter's first-set\n// analyzer and `regex()`'s scanner \u2014 see `../regex/classes.ts`. `SPACE_RANGES`\n// and `parseClassRanges` are re-exported here because codegen's boundary-class\n// lowering imports them from this module.\nimport { CLASS_ESCAPES, SPACE_RANGES, shorthandRanges, readUnicodeEscape, parseClassRanges } from '../regex/classes.ts'\nexport { SPACE_RANGES, parseClassRanges }\n\n/** A single class token (`[...]` or `\\d`/`\\w`) to ranges, or null. Rejects negation. */\nfunction classToRanges(cls: string): Array<[number, number]> | null {\n  if (cls === '\\\\d') return shorthandRanges('d')\n  if (cls === '\\\\w') return shorthandRanges('w')\n  if (cls === '\\\\s') return shorthandRanges('s')\n  const body = cls.slice(1, -1)\n  if (body.startsWith('^')) return null\n  return parseClassRanges(body)\n}\n\n/** ASCII case-insensitive letter check for `i`-flag literal lowering. */\n// ASCII case-insensitive char compare. For a letter, upper/lower differ only in\n// bit 0x20, and `(c | 32) === <lowercase>` is satisfied by EXACTLY that letter's\n// two cases (nothing else) \u2014 one OR + one compare, ~1.75\u00D7 faster than the\n// two-compare `(c===U || c===L)` form (measured). `(\u2026 | 32)` is parenthesized\n// because `===` binds tighter than `|`. Non-letters keep an exact compare.\n// Exported so the case-insensitive `literal()` emitter (codegen) shares the exact\n// same ASCII fold as `/i`-flag regex lowering \u2014 no `Intl.Collator` on any path.\nexport const foldEq = (cVar: string, cp: number): string => {\n  if (cp >= 65 && cp <= 90) return `(${cVar} | 32) === ${cp + 32}`\n  if (cp >= 97 && cp <= 122) return `(${cVar} | 32) === ${cp}`\n  return `${cVar} === ${cp}`\n}\n\n/** All-literal regex fragment (`\\/\\*`, `\\/\\/`, \u2026) \u2192 its code points, or null on an unescaped metachar. */\nfunction literalCodePoints(frag: string): number[] | null {\n  const out: number[] = []\n  let i = 0\n  while (i < frag.length) {\n    const ch = frag[i]!\n    if (ch === '\\\\') {\n      const e = frag[i + 1]\n      if (e === undefined) return null\n      out.push(e in CLASS_ESCAPES ? CLASS_ESCAPES[e]! : e.codePointAt(0)!)\n      i += 2\n      continue\n    }\n    if (META.has(ch)) return null\n    out.push(ch.codePointAt(0)!)\n    i += 1\n  }\n  return out.length ? out : null\n}\n\n/**\n * Recognize a quote-delimited string with backslash escapes:\n *   <q>(?:[^\u2026]|\\\\.)*<q>  or  <q>(?:\\\\.|[^\u2026])*<q>   (`?:` optional)\n * where the negated body class contains the quote and the backslash, and the\n * escape body is `.` (no line terminators) or `[\\s\\S]` (any char). Returns null\n * for anything else so the caller falls back to `regex.exec`.\n */\nfunction parseStringShape(source: string): ScanShape | null {\n  const q = source[0]\n  if (q === undefined || q === '\\\\' || META.has(q)) return null\n  if (source.length < 3 || source[source.length - 1] !== q) return null\n  const inner = source.slice(1, -1)\n  const CLS = String.raw`\\[\\^((?:\\\\.|[^\\]])+)\\]`\n  const ESC = String.raw`\\\\\\\\(\\.|\\[\\\\s\\\\S\\]|\\[\\\\S\\\\s\\])`\n  // Two arm orders; `?:` optional. Capture groups differ, so read both out.\n  let body: string | undefined\n  let esc: string | undefined\n  let m = new RegExp(`^\\\\((?:\\\\?:)?${CLS}\\\\|${ESC}\\\\)\\\\*$`).exec(inner)\n  if (m) { body = m[1]; esc = m[2] }\n  else {\n    m = new RegExp(`^\\\\((?:\\\\?:)?${ESC}\\\\|${CLS}\\\\)\\\\*$`).exec(inner)\n    if (m) { esc = m[1]; body = m[2] }\n  }\n  if (body === undefined || esc === undefined) return null\n  const excluded = parseClassRanges(body)\n  if (!excluded) return null\n  const qcp = q.codePointAt(0)!\n  const inSet = (cp: number) => excluded.some(([lo, hi]) => cp >= lo && cp <= hi)\n  if (!inSet(qcp) || !inSet(BACKSLASH)) return null\n  return { kind: 'string', quote: qcp, excluded, escLineTerm: esc !== '.' }\n}\n\n/**\n * Parse a regex source into a linear chain of literal / char-run segments, or\n * null if it uses any construct outside that category (alternation, groups,\n * `.`, `{n,m}`, lookaround, unknown escapes). This is the STRUCTURAL recognizer\n * for the `seq` shape \u2014 it encodes categories (optional prefix, literal opener,\n * negated run, \u2026), never any specific byte value.\n */\nfunction parseSeqParts(source: string): SeqPart[] | null {\n  const parts: SeqPart[] = []\n  let lit: number[] = []\n  const flush = () => {\n    if (lit.length) { parts.push({ part: 'lit', cps: lit, optional: false }); lit = [] }\n  }\n  // Parse a `{n}` / `{n,}` / `{n,m}` counted quantifier at `source[at]` (`'{'`).\n  // Returns the bounds and the token length, or null when it isn't a well-formed\n  // brace quantifier (then the `{` is left for the caller's metachar decline).\n  const braceQuant = (at: number): { min: number; max: number; len: number } | null => {\n    const close = source.indexOf('}', at)\n    if (close === -1) return null\n    const body = source.slice(at + 1, close)\n    const m = /^(\\d+)(,(\\d*)?)?$/.exec(body)\n    if (!m) return null\n    const min = Number(m[1])\n    const max = m[2] === undefined ? min : m[3] ? Number(m[3]!) : Infinity\n    // Decline degenerate/empty-capable or invalid bounds \u2014 RegExp handles them.\n    if (max < 1 || min > max) return null\n    return { min, max, len: close - at + 1 }\n  }\n  const runFrom = (ranges: Array<[number, number]>, negated: boolean, at: number) => {\n    const q = source[at]\n    if (q === '+') { parts.push({ part: 'run', ranges, negated, min: 1, max: Infinity }); return 1 }\n    if (q === '*') { parts.push({ part: 'run', ranges, negated, min: 0, max: Infinity }); return 1 }\n    if (q === '?') { parts.push({ part: 'run', ranges, negated, min: 0, max: 1 }); return 1 }\n    if (q === '{') {\n      const b = braceQuant(at)\n      if (b) { parts.push({ part: 'run', ranges, negated, min: b.min, max: b.max }); return b.len }\n    }\n    parts.push({ part: 'run', ranges, negated, min: 1, max: 1 })\n    return 0\n  }\n  let i = 0\n  while (i < source.length) {\n    const ch = source[i]!\n    if (ch === '[') {\n      // Read a char class, honoring `\\]`.\n      let k = i + 1\n      const neg = source[k] === '^'\n      if (neg) k++\n      let body = ''\n      while (k < source.length && source[k] !== ']') {\n        if (source[k] === '\\\\') { body += source[k]! + (source[k + 1] ?? ''); k += 2 }\n        else { body += source[k]!; k++ }\n      }\n      if (source[k] !== ']') return null\n      const ranges = parseClassRanges(body)\n      if (!ranges) return null\n      flush()\n      i = k + 1\n      i += runFrom(ranges, neg, i)\n      continue\n    }\n    if (ch === '\\\\') {\n      const e = source[i + 1]\n      if (e === 'd' || e === 'w' || e === 's') {\n        flush()\n        i += 2\n        i += runFrom(shorthandRanges(e), false, i)\n        continue\n      }\n      // Escaped literal code point (incl. `\\uXXXX`, `\\t`, `\\(`, \u2026).\n      const uni = readUnicodeEscape(source, i)\n      let cp: number\n      if (uni) { cp = uni.cp; i = uni.next }\n      else if (e === undefined) return null\n      else if (e in CLASS_ESCAPES) { cp = CLASS_ESCAPES[e]!; i += 2 }\n      else if ((e >= 'a' && e <= 'z') || (e >= 'A' && e <= 'Z')) return null\n      else { cp = e.codePointAt(0)!; i += 2 }\n      if (source[i] === '?') { flush(); parts.push({ part: 'lit', cps: [cp], optional: true }); i++ }\n      else lit.push(cp)\n      continue\n    }\n    if (ch === '(') {\n      // Only a non-capturing group `(?:\u2026)` is modeled (\u00A78f) \u2014 a bare capturing\n      // group, or a lookaround appearing mid-pattern (a TRAILING one is peeled\n      // off separately by `stripTrailingLookahead` before we ever get here), is\n      // declined outright rather than risk misreading it.\n      if (source[i + 1] !== '?' || source[i + 2] !== ':') return null\n      let k = i + 3\n      let depth = 1\n      while (k < source.length && depth > 0) {\n        const c2 = source[k]\n        if (c2 === '\\\\') { k += 2; continue }\n        if (c2 === '[') {\n          let j = k + 1\n          if (source[j] === '^') j++\n          while (j < source.length && source[j] !== ']') {\n            if (source[j] === '\\\\') j += 2\n            else j++\n          }\n          if (source[j] !== ']') return null\n          k = j + 1\n          continue\n        }\n        if (c2 === '(') depth++\n        else if (c2 === ')') depth--\n        k++\n      }\n      if (depth !== 0) return null\n      const body = source.slice(i + 3, k - 1)\n      const inner = parseScanShape(body)\n      if (!inner || !groupInnerSafe(inner)) return null\n      const q = source[k]\n      // `{n,m}` on a group is a \u00A78c/\u00A78f combination not modeled \u2014 decline.\n      if (q === '{') return null\n      flush()\n      if (q === '+') {\n        if (shapeCanBeEmpty(inner)) return null // would loop forever \u2014 decline\n        parts.push({ part: 'group', inner, min: 1, unbounded: true })\n        i = k + 1\n      } else if (q === '*') {\n        if (shapeCanBeEmpty(inner)) return null\n        parts.push({ part: 'group', inner, min: 0, unbounded: true })\n        i = k + 1\n      } else if (q === '?') {\n        parts.push({ part: 'group', inner, min: 0, unbounded: false })\n        i = k + 1\n      } else {\n        parts.push({ part: 'group', inner, min: 1, unbounded: false })\n        i = k\n      }\n      continue\n    }\n    // A bare metachar (`|`, `.`, `{`, stray `*`/`+`/`?`, \u2026) is outside the\n    // linear-chain category \u2014 bail to the RegExp fallback.\n    if (META.has(ch)) return null\n    const cp = ch.codePointAt(0)!\n    i += ch.length\n    if (source[i] === '?') { flush(); parts.push({ part: 'lit', cps: [cp], optional: true }); i++ }\n    else lit.push(cp)\n  }\n  flush()\n  return parts.length ? parts : null\n}\n\n/**\n * Only lower a `seq` when greedy left-to-right scanning matches EXACTLY what the\n * backtracking regex engine would. The dangerous cases are (a) an optional part\n * that could also be consumed by what follows, and (b) an unbounded/repeated\n * part whose accepted class overlaps what follows \u2014 both let the engine\n * backtrack to a different boundary than a one-pass scan. We also require at\n * least one mandatory segment (so the token can't match zero-width).\n *\n * A skippable/repeatable part `p` at index `k` is checked against\n * `seqFirstAccept(parts.slice(k + 1))` \u2014 the accept-set of EVERYTHING that\n * could start at the very next position, unioned through any further chain of\n * optionals up to the next mandatory part (the exact same computation\n * `seqFirstAccept` already does for a seq's OWN leading accept-set). This\n * subsumes the simpler \"check only the immediate neighbor\" rule as the\n * one-part-following case, while also correctly handling a CHAIN of several\n * consecutive optional parts (e.g. two independent optional groups in a row,\n * `(?:\\.\\d+)?(?:[eE][+-]?\\d+)?` \u2014 JSON/GraphQL's number tail, \u00A78f): each is\n * safe precisely when disjoint from everything that could follow it, however\n * many further optionals that spans. An empty tail (`p` is the last part)\n * naturally resolves to a trivially-disjoint empty set \u2014 nothing to check.\n *\n * Uniform across `lit`/`run`/`group`: each part's own \"first char it could\n * start with\" (`partFirstAccept`) is compared via `firstSetsDisjoint` \u2014 the\n * same subset/disjoint math used everywhere else in this file (\u00A78b's\n * lookahead guard, \u00A78e's alt-dispatch guard).\n */\nfunction seqIsUnambiguous(parts: SeqPart[]): boolean {\n  let hasMandatory = false\n  for (let k = 0; k < parts.length; k++) {\n    const p = parts[k]!\n    const mandatory = p.part === 'lit' ? !p.optional : p.min >= 1\n    if (mandatory) hasMandatory = true\n    // A `group` part has a right-edge exposure (`groupPartExposure`): the chars a\n    // backtracking engine could give back by shrinking the body's own trailing\n    // quantifier, dropping the group (if optional/repeated), or \u2014 for a\n    // non-disjoint alt body \u2014 switching arms. Ordered-choice greedy scanning\n    // matches the engine only when NONE of those relinquished chars could also\n    // start what follows the group (else the scan and the engine disagree on\n    // where the group ends). Two outcomes:\n    //   - a concrete class \u2192 must be disjoint from `seqFirstAccept(rest)`. This\n    //     is the general fix for a group whose body ends in an unbounded run\n    //     (`(?:\\d+)\\d` must NOT lower), and it lets a mutually-exclusive fixed\n    //     alt (\u00A78i, exposure `null`) lower at ANY position, not just trailing.\n    //   - `'unsupported'` \u2192 the exposure can't be bounded (e.g. a non-disjoint\n    //     alt like `(?:a|ab)` that genuinely needs arm-switching). Sound only\n    //     when nothing follows to force reconsideration \u2014 the group must be the\n    //     trailing, matched-exactly-once part (\u00A78h); otherwise decline.\n    if (p.part === 'group') {\n      const exposure = groupPartExposure(p)\n      if (exposure === 'unsupported') {\n        const trailingOnce = k === parts.length - 1 && p.min === 1 && !p.unbounded\n        if (!trailingOnce) return false\n      } else if (exposure !== null) {\n        if (!firstSetsDisjoint(exposure, seqFirstAccept(parts.slice(k + 1)))) return false\n      }\n    }\n    // A part needs the disjoint-from-continuation check when a greedy one-pass\n    // scan has freedom a backtracking engine could resolve differently: an\n    // optional `lit`, a `run` with wiggle (`max > min` \u2014 covers `?`/`*`/`+` and\n    // bounded `{n,m}` with `m > n`; a fixed `{n}` run has none), or an\n    // optional/repeated `group`. A fixed-length run (`max === min`) consumes an\n    // exact count with no boundary to shift, so it never needs the check.\n    const needsDisjoint =\n      p.part === 'lit' ? p.optional\n      : p.part === 'run' ? p.max > p.min\n      : (p.unbounded || p.min === 0)\n    if (needsDisjoint) {\n      const rest = seqFirstAccept(parts.slice(k + 1))\n      if (!firstSetsDisjoint(partFirstAccept(p), rest)) return false\n    }\n  }\n  return hasMandatory\n}\n\nfunction rangesOverlap(a: Array<[number, number]>, b: Array<[number, number]>): boolean {\n  return a.some(([lo, hi]) => b.some(([lo2, hi2]) => lo <= hi2 && lo2 <= hi))\n}\n\n/** Is every range in `sub` fully contained in some range of `sup`? */\nfunction rangesSubset(sub: Array<[number, number]>, sup: Array<[number, number]>): boolean {\n  return sub.every(([lo, hi]) => sup.some(([lo2, hi2]) => lo >= lo2 && hi <= hi2))\n}\n\n/**\n * A `(?!X)`/`(?=X)` operand: a char class (`[...]`, incl. `[^...]`), a\n * shorthand class (`\\d`/`\\w`/`\\s`), or a single literal/escaped char \u2014 never a\n * sub-pattern (no alternation, no nested groups). Returns the ranges to test\n * membership against, and whether the bracket itself was negated (`[^...]`) \u2014\n * independent of the lookahead's own `!`/`=` polarity.\n */\nfunction parseClassOperand(body: string): { ranges: Array<[number, number]>; negated: boolean } | null {\n  if (body === '\\\\d' || body === '\\\\w' || body === '\\\\s') {\n    return { ranges: shorthandRanges(body[1] as 'd' | 'w' | 's'), negated: false }\n  }\n  if (body.length >= 2 && body[0] === '[' && body[body.length - 1] === ']') {\n    let inner = body.slice(1, -1)\n    const negated = inner.startsWith('^')\n    if (negated) inner = inner.slice(1)\n    const ranges = parseClassRanges(inner)\n    return ranges ? { ranges, negated } : null\n  }\n  const cps = literalCodePoints(body)\n  if (cps && cps.length === 1) return { ranges: [[cps[0]!, cps[0]!]], negated: false }\n  return null\n}\n\ntype TrailingLookahead = {\n  base: string\n  ranges: Array<[number, number]>\n  classNegated: boolean\n  negative: boolean\n}\n\ntype CharSet = { ranges: Array<[number, number]>; negated: boolean }\n\n/** Is char-set `t` fully contained in char-set `u`? Handles all 4 sign combos. */\nfunction classSubset(t: CharSet, u: CharSet): boolean {\n  if (!t.negated && !u.negated) return rangesSubset(t.ranges, u.ranges)\n  if (!t.negated && u.negated) return !rangesOverlap(t.ranges, u.ranges) // t \u2286 \u00ACu \u27FA t \u2229 u = \u2205\n  if (t.negated && !u.negated) return false // \u00ACt \u2286 u is never true for finite ranges u\n  return rangesSubset(u.ranges, t.ranges) // \u00ACt \u2286 \u00ACu \u27FA u \u2286 t\n}\n\n/** Are char-sets `t` and `u` disjoint (no overlap)? Handles all 4 sign combos. */\nfunction classDisjoint(t: CharSet, u: CharSet): boolean {\n  if (!t.negated && !u.negated) return !rangesOverlap(t.ranges, u.ranges)\n  if (!t.negated && u.negated) return rangesSubset(t.ranges, u.ranges) // t \u2229 \u00ACu = \u2205 \u27FA t \u2286 u\n  if (t.negated && !u.negated) return rangesSubset(u.ranges, t.ranges) // symmetric\n  return false // \u00ACt \u2229 \u00ACu = \u2205 would require t \u222A u = every code point \u2014 can't prove with finite ranges\n}\n\n/** `classDisjoint`, `'any'`-aware: an empty-capable part's first-set degrades\n * to `'any'` (see `shapeFirstAccept`), and `'any'` is never disjoint from\n * anything (it could start with literally any char, including whatever the\n * other side accepts). */\nfunction firstSetsDisjoint(a: CharSet | 'any', b: CharSet | 'any'): boolean {\n  if (a === 'any' || b === 'any') return false\n  return classDisjoint(a, b)\n}\n\n/**\n * A shape's match as a fixed-length list of per-position char-sets, or `null`\n * if its match length is NOT fixed. Only a `seq` of mandatory `lit`s (each code\n * point is one fixed position) and mandatory single-char runs (`[x]`, min 1,\n * bounded) qualifies \u2014 anything with an optional part, an unbounded/optional\n * run, or a nested group has a variable length and returns `null`. Used to\n * decide when a non-disjoint alternation's arms are mutually exclusive (\u00A78i).\n */\nfunction fixedClassSeq(shape: ScanShape): CharSet[] | null {\n  // A case-fold literal is fixed-length: each code point becomes a single-char\n  // class holding BOTH ASCII cases (so mutual-exclusivity is judged on what the\n  // `/i` match actually accepts \u2014 `and` vs `or` are disjoint at position 0).\n  if (shape.kind === 'litFold') {\n    return shape.open.map(cp => {\n      const other = cp >= 65 && cp <= 90 ? cp + 32 : cp >= 97 && cp <= 122 ? cp - 32 : cp\n      return other === cp\n        ? { ranges: [[cp, cp]] as Array<[number, number]>, negated: false }\n        : { ranges: [[Math.min(cp, other), Math.min(cp, other)], [Math.max(cp, other), Math.max(cp, other)]] as Array<[number, number]>, negated: false }\n    })\n  }\n  if (shape.kind !== 'seq') return null\n  const out: CharSet[] = []\n  for (const p of shape.parts) {\n    if (p.part === 'lit') {\n      if (p.optional) return null\n      for (const cp of p.cps) out.push({ ranges: [[cp, cp]], negated: false })\n    } else if (p.part === 'run' && p.max === p.min && Number.isFinite(p.max)) {\n      // A fixed-count run `[x]{n}` (incl. the bare `[x]`, n=1) is n fixed\n      // positions of the same class. Variable-length runs return null below.\n      for (let c = 0; c < p.max; c++) out.push({ ranges: p.ranges, negated: p.negated })\n    } else {\n      return null // optional/variable/unbounded run, or a nested group \u2014 length not fixed\n    }\n  }\n  return out.length ? out : null\n}\n\n/**\n * \u00A78i \u2014 is a NON-disjoint `alt` shape one whose arms are pairwise MUTUALLY\n * EXCLUSIVE fixed-length token sets? Every arm must be a `fixedClassSeq`, and no\n * arm's match may ever be a prefix (proper, or an equal-length overlap) of\n * another arm's \u2014 i.e. for every ordered pair (A, B) with `A.length <= B.length`\n * there is a position within A where their classes are DISJOINT. That property\n * guarantees at most one arm matches at any input position, so ordered-choice\n * commit lands on the SAME arm (and the SAME fixed end) the engine would, with\n * no arm to switch to under backtracking \u2014 sound in ANY position, not just\n * trailing (unlike the general non-disjoint alt, which needs the trailing-once\n * gate in `seqIsUnambiguous`). `(?:ab|ac)` and `(?:foo|barn)` qualify;\n * `(?:a|ab)` (arm `a` is a prefix of `ab`) does NOT.\n */\nfunction altFixedMutuallyExclusive(shape: ScanShape): boolean {\n  if (shape.kind !== 'alt' || shape.disjoint) return false\n  const lists: CharSet[][] = []\n  for (const arm of shape.arms) {\n    const f = fixedClassSeq(arm)\n    if (!f) return false\n    lists.push(f)\n  }\n  for (let i = 0; i < lists.length; i++) {\n    for (let j = 0; j < lists.length; j++) {\n      if (i === j) continue\n      const a = lists[i]!\n      const b = lists[j]!\n      if (a.length > b.length) continue // only check the shorter (a) as a prefix of the longer (b)\n      let disjointAt = false\n      for (let p = 0; p < a.length; p++) {\n        if (classDisjoint(a[p]!, b[p]!)) { disjointAt = true; break }\n      }\n      if (!disjointAt) return false // `a` could be a prefix of `b` \u2014 not mutually exclusive\n    }\n  }\n  return true\n}\n\n/**\n * The char-set a backtracking engine could relinquish at a `group` PART's right\n * edge \u2014 its \"trailing exposure\". Combines two independent backtrack moves: the\n * group body's OWN trailing wiggle (`trailingBacktrackClass(inner)`, e.g. the\n * body ends in an unbounded run), and \u2014 if the group is optional (`min 0`) or\n * repeated (`unbounded`) \u2014 the \"drop the last occurrence\" move, which exposes\n * the body's own first-char set. A required-once group (`min 1`, bounded) has\n * only the first move. Returns `'unsupported'` if either component can't be\n * pinned to a concrete set. This is the single computation used everywhere a\n * group's right boundary matters: `trailingBacktrackClass` (a `seq` ending in a\n * group) and `seqIsUnambiguous` (a group at ANY position, followed by more).\n */\nfunction groupPartExposure(part: Extract<SeqPart, { part: 'group' }>): CharSet | null | 'unsupported' {\n  const innerWiggle = trailingBacktrackClass(part.inner)\n  if (innerWiggle === 'unsupported') return 'unsupported'\n  const requiredOnce = !part.unbounded && part.min === 1\n  if (requiredOnce) return innerWiggle // no \"drop it\" move possible \u2014 only inner's own wiggle matters\n  const dropExposed = shapeFirstAccept(part.inner)\n  if (dropExposed === 'any') return 'unsupported'\n  if (innerWiggle === null) return dropExposed\n  const unioned = unionCharSets([innerWiggle, dropExposed])\n  return unioned === 'any' ? 'unsupported' : unioned\n}\n\n/**\n * The char-class a backtracking engine could expose by shrinking `shape`'s\n * OWN trailing quantifier by one position \u2014 i.e. the \"wiggle room\" a trailing\n * lookahead could interact with. Returns `null` when `shape`'s matched length\n * is fully fixed once it succeeds (no quantifier to shrink), which makes\n * wrapping it in a lookahead unconditionally safe. Returns `'unsupported'` for\n * shape kinds whose backtracking semantics aren't modeled here (declines the\n * lookahead lowering rather than risking an unproven guard).\n *\n * Only the LAST quantifier matters: `seqIsUnambiguous` already proves every\n * EARLIER part of a `seq` has exactly one valid parse (no alternate length),\n * so the sole remaining freedom a backtracking engine has \u2014 once we attach an\n * external trailing lookahead \u2014 is in whatever quantifier sits at the very end.\n */\nfunction trailingBacktrackClass(shape: ScanShape): CharSet | null | 'unsupported' {\n  if (shape.kind === 'chars') return { ranges: shape.ranges, negated: false }\n  if (shape.kind === 'ident') return { ranges: shape.tail, negated: false }\n  if (shape.kind === 'litFold') return null // fixed-length literal \u2014 no quantifier at all\n  if (shape.kind === 'seq') {\n    const last = shape.parts[shape.parts.length - 1]!\n    if (last.part === 'lit') return null // fixed literal tail \u2014 no wiggle room\n    if (last.part === 'run') {\n      // Wiggle iff `max > min`: unbounded (`+`/`*`/`{n,}`), optional (`[x]?`),\n      // or bounded `{n,m}` with `m > n` all let a backtracker shrink the trailing\n      // run by \u22651 position. A fixed run (`[x]`, `{n}`, `max === min`) has no\n      // choice \u2014 no wiggle, hence no risk.\n      if (last.max > last.min) return { ranges: last.ranges, negated: last.negated }\n      return null\n    }\n    // A trailing `group` (\u00A78f): its trailing exposure combines its body's own\n    // wiggle and (if optional/repeated) the \"drop it\" move \u2014 see\n    // `groupPartExposure`, shared with `seqIsUnambiguous`.\n    return groupPartExposure(last)\n  }\n  if (shape.kind === 'alt') {\n    // Arm-switching hazard (see `groupInnerSafe`) applies here too: a\n    // non-disjoint alt can't be trusted to expose the right wiggle class,\n    // since which arm ultimately \"wins\" could itself change under backtrack.\n    // A disjoint alt has no such hazard \u2014 exactly one arm is ever reachable\n    // from a given starting char, so the union of every arm's OWN wiggle\n    // covers whichever one is actually taken. A non-disjoint alt whose arms are\n    // fixed-length and mutually exclusive (\u00A78i) also has no wiggle \u2014 exactly one\n    // arm matches at any position and its length is fixed, so `null`.\n    if (!shape.disjoint) return altFixedMutuallyExclusive(shape) ? null : 'unsupported'\n    const classes = shape.arms.map(trailingBacktrackClass)\n    if (classes.some(c => c === 'unsupported')) return 'unsupported'\n    const concrete = classes.filter((c): c is CharSet => c !== null)\n    if (concrete.length === 0) return null\n    const unioned = unionCharSets(concrete)\n    return unioned === 'any' ? 'unsupported' : unioned\n  }\n  // `until`/`delimited`/`string`/nested `lookahead` \u2014 not modeled; decline.\n  return 'unsupported'\n}\n\n/**\n * Is it safe to lower `inner(?!ranges)` / `inner(?=ranges)` to a one-shot\n * post-match check (vs. requiring real backtracking)? See PERF_IDEAS \u00A78b.\n */\nfunction lookaheadUnambiguous(inner: ScanShape, operand: CharSet, negative: boolean): boolean {\n  const tail = trailingBacktrackClass(inner)\n  if (tail === 'unsupported') return false\n  if (tail === null) return true // inner's length is fixed \u2014 no backtracking possible\n  // Negative `(?!op)`: safe iff every char the tail could expose is ALSO\n  // excluded by `op` (so shrinking never turns a failure into a pass).\n  // Positive `(?=op)`: safe iff the tail is disjoint from `op` (so shrinking\n  // could never expose a char that suddenly satisfies `op`).\n  return negative ? classSubset(tail, operand) : classDisjoint(tail, operand)\n}\n\n/**\n * Strip a trailing `(?!class)` / `(?=class)` boundary assertion, if present.\n * Only a TRAILING lookahead with a char-class/single-char operand is\n * recognized \u2014 no sub-patterns, no nested groups. Anything else containing an\n * unescaped `(` is left to the other recognizers, which reject it as a\n * metachar (`META`) and fall back to `RegExp.exec`, so a false read here can\n * only fail to lower, never mis-lower.\n */\nfunction stripTrailingLookahead(source: string): TrailingLookahead | null {\n  if (!source.endsWith(')')) return null\n  for (const negative of [true, false] as const) {\n    const lead = negative ? '(?!' : '(?='\n    const idx = source.lastIndexOf(lead)\n    if (idx === -1) continue\n    const body = source.slice(idx + lead.length, -1)\n    const operand = body.length ? parseClassOperand(body) : null\n    if (!operand) continue\n    return { base: source.slice(0, idx), ranges: operand.ranges, classNegated: operand.negated, negative }\n  }\n  return null\n}\n\n/**\n * Strip ONE redundant outer `(?:\u2026)` wrapper, if it spans the ENTIRE source\n * (nothing before it, nothing \u2014 not even a quantifier \u2014 after its matching\n * close). A non-capturing group with no trailing quantifier is semantically\n * identical to its bare contents, so this is always safe to unwrap; it's what\n * lets `(?:a|b|c)` (a whole-token alternation written as idiomatic regex\n * style, e.g. CSS `basicSel`) reach the top-level `|` split below. Bails\n * (leaves `source` untouched) on anything that isn't a clean whole-string\n * wrap: unbalanced parens, or a group that closes before the string ends\n * (which would mean a quantifier or trailing content follows it).\n */\nfunction unwrapOuterGroup(source: string): string {\n  while (source.startsWith('(?:')) {\n    let depth = 1\n    let i = 3\n    let ok = true\n    while (i < source.length && depth > 0) {\n      const ch = source[i]\n      if (ch === '\\\\') { i += 2; continue }\n      if (ch === '[') {\n        let j = i + 1\n        if (source[j] === '^') j++\n        while (j < source.length && source[j] !== ']') {\n          if (source[j] === '\\\\') j += 2\n          else j++\n        }\n        if (source[j] !== ']') { ok = false; break }\n        i = j + 1\n        continue\n      }\n      if (ch === '(') depth++\n      else if (ch === ')') depth--\n      i++\n    }\n    if (!ok || depth !== 0 || i !== source.length) break\n    source = source.slice(3, -1)\n  }\n  return source\n}\n\n/**\n * Split a regex source on top-level `|` \u2014 i.e. `|` outside any `[]` bracket\n * class and outside any `(...)` group (parens still count toward depth even\n * though we don't otherwise understand groups; a `|` nested in one is never a\n * split point). Returns null if there's no top-level `|` at all, if brackets/\n * parens are unbalanced, or if any resulting alternative is empty (a\n * zero-width arm \u2014 an unmodeled edge case, decline rather than mis-lower).\n * One redundant whole-string `(?:\u2026)` wrapper is stripped first (see\n * `unwrapOuterGroup`) so `(?:a|b)` splits the same as bare `a|b`.\n */\nfunction splitTopLevelAlternation(source: string): string[] | null {\n  const body = unwrapOuterGroup(source)\n  const parts: string[] = []\n  let depth = 0\n  let last = 0\n  let i = 0\n  while (i < body.length) {\n    const ch = body[i]\n    if (ch === '\\\\') { i += 2; continue }\n    if (ch === '[') {\n      let j = i + 1\n      if (body[j] === '^') j++\n      while (j < body.length && body[j] !== ']') {\n        if (body[j] === '\\\\') j += 2\n        else j++\n      }\n      if (body[j] !== ']') return null\n      i = j + 1\n      continue\n    }\n    if (ch === '(') { depth++; i++; continue }\n    if (ch === ')') { depth--; if (depth < 0) return null; i++; continue }\n    if (ch === '|' && depth === 0) {\n      parts.push(body.slice(last, i))\n      last = i + 1\n      i++\n      continue\n    }\n    i++\n  }\n  if (depth !== 0) return null\n  parts.push(body.slice(last))\n  if (parts.length < 2 || parts.some(p => p.length === 0)) return null\n  return parts\n}\n\n/** Can `shape` match the empty string? Only an unbounded `chars` run with no\n * `+` (`[x]*`) can \u2014 every other shape requires at least one fixed/mandatory\n * char (`seq` always has \u22651 mandatory part per `seqIsUnambiguous`; `ident`/\n * `until`/`delimited`/`string`/`litFold` all require a fixed opening char). A\n * `lookahead`/`alt` defer to what they wrap. */\nfunction shapeCanBeEmpty(shape: ScanShape): boolean {\n  if (shape.kind === 'chars') return !shape.minOne\n  if (shape.kind === 'lookahead') return shapeCanBeEmpty(shape.inner)\n  if (shape.kind === 'alt') return shape.arms.some(shapeCanBeEmpty)\n  return false\n}\n\n/** Exact union of char-sets when it's computable, else `'any'` (conservative:\n * forces ordered dispatch rather than guessing at a mixed-polarity union, or\n * when any input is already `'any'`). A single concrete-set list is returned\n * as-is (including if negated) \u2014 the ambiguity is only in combining \u22652 sets\n * of differing polarity. */\nfunction unionCharSets(sets: Array<CharSet | 'any'>): CharSet | 'any' {\n  if (sets.some(s => s === 'any')) return 'any'\n  const concrete = sets as CharSet[]\n  if (concrete.length === 1) return concrete[0]!\n  if (concrete.some(s => s.negated)) return 'any'\n  return { ranges: concrete.flatMap(s => s.ranges), negated: false }\n}\n\n/** A single seq part's own first-char set, ignoring whether it's skippable.\n * A `group` part delegates to its inner shape's own first-set (\u00A78f) \u2014\n * possibly `'any'` if the inner shape can match empty or is a non-disjoint\n * `alt` (see `shapeFirstAccept`). */\nfunction partFirstAccept(part: SeqPart): CharSet | 'any' {\n  if (part.part === 'lit') return { ranges: [[part.cps[0]!, part.cps[0]!]], negated: false }\n  if (part.part === 'run') return { ranges: part.ranges, negated: part.negated }\n  return shapeFirstAccept(part.inner)\n}\n\n/** The char-set a `seq` can start with: union of each leading skippable part's\n * own set up to and including the first mandatory part (after which later\n * parts can no longer be what the very first input char matches). */\nfunction seqFirstAccept(parts: SeqPart[]): CharSet | 'any' {\n  const sets: Array<CharSet | 'any'> = []\n  for (const p of parts) {\n    const mandatory = p.part === 'lit' ? !p.optional : p.min >= 1\n    sets.push(partFirstAccept(p))\n    if (mandatory) break\n  }\n  return unionCharSets(sets)\n}\n\n/**\n * Is `inner` safe to use as a group's body (\u00A78f)? `chars`/`ident`/`seq`/\n * `litFold` are always safe: each is only ever constructed after proving (via\n * `seqIsUnambiguous` or equivalent) that greedy resolution is the UNIQUE valid\n * match at a given position \u2014 there is no alternate length for a backtracker\n * to reconsider, so treating the group as an atomic, resolve-once unit is\n * sound regardless of what follows it. A `lookahead` defers to what it wraps\n * (zero-width, adds no new choice). An `alt` is safe ONLY when `disjoint`:\n * a NON-disjoint alt (`(?:a|ab)`) genuinely can need real backtracking into a\n * DIFFERENT arm if something after the group fails (verified: `/^(?:a|ab)c/`\n * matches \"abc\" via the SECOND arm, only because the first arm's match left\n * \"c\" unsatisfied) \u2014 our ordered-dispatch codegen resolves once and never\n * reconsiders, so that case must decline. `until`/`delimited`/`string` are\n * declined outright, same conservative call as `trailingBacktrackClass`.\n */\nfunction groupInnerSafe(shape: ScanShape): boolean {\n  if (shape.kind === 'chars' || shape.kind === 'ident' || shape.kind === 'seq' || shape.kind === 'litFold') return true\n  if (shape.kind === 'lookahead') return groupInnerSafe(shape.inner)\n  // A disjoint alt is safe anywhere. A NON-disjoint alt is admitted here too,\n  // but its ordered-choice-commit is only sound in the trailing-once position \u2014\n  // `seqIsUnambiguous` (\u00A78h) enforces that positional constraint; a non-trailing\n  // or optional/repeated non-disjoint-alt group is rejected there.\n  if (shape.kind === 'alt') return true\n  return false\n}\n\n/**\n * The set of first chars a NON-EMPTY match of `shape` could start with, or\n * `'any'` if that can't be pinned down to a single char-set (used to decide\n * whether `alt` arms have disjoint first-sets). A shape that can match empty\n * degrades to `'any'`: since it could succeed with zero chars regardless of\n * what follows, it would \"accept\" any first char by never actually needing one\n * \u2014 treating that as disjoint from anything else would be unsound.\n */\nfunction shapeFirstAccept(shape: ScanShape): CharSet | 'any' {\n  if (shapeCanBeEmpty(shape)) return 'any'\n  switch (shape.kind) {\n    case 'chars': return { ranges: shape.ranges, negated: false }\n    case 'ident': return { ranges: shape.head, negated: false }\n    case 'until': return { ranges: [[shape.open[0]!, shape.open[0]!]], negated: false }\n    case 'delimited': return { ranges: [[shape.open[0]!, shape.open[0]!]], negated: false }\n    case 'string': return { ranges: [[shape.quote, shape.quote]], negated: false }\n    case 'litFold': {\n      const cp = shape.open[0]!\n      if (cp >= 65 && cp <= 90) return { ranges: [[cp, cp], [cp + 32, cp + 32]], negated: false }\n      if (cp >= 97 && cp <= 122) return { ranges: [[cp, cp], [cp - 32, cp - 32]], negated: false }\n      return { ranges: [[cp, cp]], negated: false }\n    }\n    case 'seq': return seqFirstAccept(shape.parts)\n    case 'lookahead': return shapeFirstAccept(shape.inner) // zero-width \u2014 doesn't change first-char acceptance\n    case 'alt': {\n      // The set of first chars is the union of every arm's own first-set,\n      // independent of whether the arms are mutually disjoint (that flag only\n      // governs dispatch, not what the shape can start with). Any arm whose\n      // first-set is itself `'any'` (stored as `null`) makes the union `'any'`.\n      const sets = shape.firsts.map((f): CharSet | 'any' => (f === null ? 'any' : f))\n      return unionCharSets(sets)\n    }\n  }\n}\n\n/** True iff every pair of `sets` is provably disjoint; `'any'` is disjoint from nothing. */\nfunction allPairsDisjoint(sets: Array<CharSet | 'any'>): boolean {\n  for (let i = 0; i < sets.length; i++) {\n    const a = sets[i]!\n    if (a === 'any') return false\n    for (let j = i + 1; j < sets.length; j++) {\n      const b = sets[j]!\n      if (b === 'any' || !classDisjoint(a, b)) return false\n    }\n  }\n  return true\n}\n\n/**\n * Recognize top-level alternation `A|B|C` (\u00A78e): split on `|` outside any\n * `[]`/`()`, lower each arm independently (an arm may itself be a `seq`,\n * `chars`, `lookahead`, \u2026, or even nested alternation via one redundant\n * `(?:\u2026)` wrapper \u2014 see `unwrapOuterGroup`). Declines (null) unless EVERY arm\n * independently lowers \u2014 a single unsupported arm (e.g. one with a nested\n * capturing/non-capturing group, \u00A78f) falls the whole alternation back to\n * `RegExp.exec` rather than partially lowering.\n */\nfunction parseAlternation(source: string): ScanShape | null {\n  const parts = splitTopLevelAlternation(source)\n  if (!parts) return null\n  const arms: ScanShape[] = []\n  for (const p of parts) {\n    const arm = parseScanShape(p)\n    if (!arm) return null\n    arms.push(arm)\n  }\n  const firstSets = arms.map(shapeFirstAccept)\n  const disjoint = allPairsDisjoint(firstSets)\n  return { kind: 'alt', arms, disjoint, firsts: firstSets.map(f => (f === 'any' ? null : f)) }\n}\n\n/**\n * Recognize one scannable arm from its regex source, or null if it isn't one of\n * the structural shapes. Top-level alternation (\u00A78e) is tried FIRST \u2014 `|` has\n * the lowest precedence in regex, so splitting on it happens before anything\n * else, with each arm then recursively re-entering this same function (so an\n * arm's own trailing lookahead, or its own nested `(?:\u2026)`-wrapped alternation,\n * is still recognized). Failing that: char-class run, ident, string, then\n * open-until-terminator, delimited, and finally the general linear `seq` chain.\n * A trailing `(?!class)`/`(?=class)` is peeled off next (\u00A78b) and re-wraps\n * whatever shape the remaining base recognizes as.\n */\nexport function parseScanShape(source: string): ScanShape | null {\n  const alt = parseAlternation(source)\n  if (alt) return alt\n  const la = stripTrailingLookahead(source)\n  if (la) {\n    const inner = parseScanShapeCore(la.base)\n    if (!inner) return null\n    const operand: CharSet = { ranges: la.ranges, negated: la.classNegated }\n    if (!lookaheadUnambiguous(inner, operand, la.negative)) return null\n    return { kind: 'lookahead', inner, ranges: la.ranges, classNegated: la.classNegated, negative: la.negative }\n  }\n  return parseScanShapeCore(source)\n}\n\n/**\n * Split a regex fragment on top-level `|` (outside `[]`/`()`), escape-aware.\n * Unlike `splitTopLevelAlternation` this allows a SINGLE arm (no `|` at all) and\n * does not unwrap an outer group \u2014 it's used to enumerate the arms of a\n * `delimited` body, which may legitimately be one bare arm (`[^x]`). Returns\n * null on unbalanced brackets/parens.\n */\nfunction splitDelimArms(body: string): string[] | null {\n  const arms: string[] = []\n  let depth = 0\n  let last = 0\n  let i = 0\n  while (i < body.length) {\n    const ch = body[i]\n    if (ch === '\\\\') { i += 2; continue }\n    if (ch === '[') {\n      let j = i + 1\n      if (body[j] === '^') j++\n      while (j < body.length && body[j] !== ']') {\n        if (body[j] === '\\\\') j += 2\n        else j++\n      }\n      if (body[j] !== ']') return null\n      i = j + 1\n      continue\n    }\n    if (ch === '(') { depth++; i++; continue }\n    if (ch === ')') { depth--; if (depth < 0) return null; i++; continue }\n    if (ch === '|' && depth === 0) { arms.push(body.slice(last, i)); last = i + 1 }\n    i++\n  }\n  if (depth !== 0) return null\n  arms.push(body.slice(last))\n  return arms\n}\n\n/**\n * Prove that the `delimited` lowering \u2014 \"scan the raw input to the first full\n * `close` literal, ignoring the body entirely\" \u2014 is EQUIVALENT to the real regex\n * `<open>(?:body)*<close>`. That equivalence holds iff `(?:body)*` can never\n * match a string that contains the `close` literal: then greedy repetition stops\n * exactly before the first `close`, which is where the scan lands too.\n *\n * We only PROVE this for the block-comment idiom (the sole shape that expresses\n * \"any char that doesn't form the close\"):\n *\n *   n === 1 (`close` is one char l0):   body must be exactly `[^l0]`.\n *   n === 2 (`close` is `l0 l1`):       body must be exactly `[^l0] | l0(?!l1)`.\n *\n * In both the bulk arm `[^l0]` consumes every char except l0, and the guard arm\n * (n === 2) consumes l0 only when it is NOT followed by l1 \u2014 so the body admits\n * l0 but never the full `l0 l1`, and rejects NOTHING else (a body that excluded\n * some non-close char would stop early while the raw scan skipped ahead to the\n * next close, diverging). Anything outside this template \u2014 an alternation whose\n * arms can consume the close (`z(?:a|[0-2]+)*a`), a bulk class narrower/wider\n * than `[^l0]`, a longer close, extra arms \u2014 is declined, falling through to\n * `RegExp.exec`. Sound-by-construction: we only ever return true for a body we\n * can prove never contains `close`.\n */\nfunction delimitedBodySound(body: string, close: number[]): boolean {\n  const l0 = close[0]!\n  if (close.length > 2) return false\n  const arms = splitDelimArms(body)\n  if (!arms) return false\n  let bulkSeen = false\n  let guardSeen = false\n  for (const arm of arms) {\n    // Bulk arm: a bare negated class `[^l0]` \u2014 excluded set is exactly {l0}.\n    const bulk = /^\\[\\^((?:\\\\.|[^\\]])+)\\]$/.exec(arm)\n    if (bulk) {\n      if (bulkSeen) return false\n      const ranges = parseClassRanges(bulk[1]!)\n      if (!ranges || ranges.length !== 1 || ranges[0]![0] !== l0 || ranges[0]![1] !== l0) return false\n      bulkSeen = true\n      continue\n    }\n    // Guard arm (n === 2 only): `l0(?!l1)` \u2014 consume l0 unless it starts the close.\n    if (close.length === 2 && arm.endsWith(')')) {\n      const idx = arm.indexOf('(?!')\n      if (idx === -1) return false\n      const prefix = literalCodePoints(arm.slice(0, idx))\n      const op = parseClassOperand(arm.slice(idx + 3, -1))\n      const prefixIsL0 = prefix?.length === 1 && prefix[0] === l0\n      const forbidsL1 = op && !op.negated && op.ranges.length === 1 &&\n        op.ranges[0]![0] === close[1] && op.ranges[0]![1] === close[1]\n      if (!prefixIsL0 || !forbidsL1 || guardSeen) return false\n      guardSeen = true\n      continue\n    }\n    return false\n  }\n  // Require the exact arm set: bulk always; guard iff the close is two chars.\n  return bulkSeen && guardSeen === (close.length === 2)\n}\n\n/**\n * Structurally recognize `<openLit>(?:<body>)*<closeLit>` \u2014 literal opener, a\n * single non-capturing `*`-repeated group, literal closer \u2014 and lower it to a\n * `delimited` scan ONLY when `delimitedBodySound` proves the body can't contain\n * the close. Returns null (\u2192 fall through to `seq`/`RegExp.exec`) otherwise.\n */\nfunction parseDelimited(source: string): ScanShape | null {\n  // An escape-aware body (a literal `\\\\` in the source \u21D2 string-like) is handled\n  // by `parseStringShape`; here \"scan to first close\" would wrongly stop at an\n  // escaped delimiter, so decline.\n  if (source.includes('\\\\\\\\')) return null\n  // Opener: literal chars up to the first unescaped `(`, which must open `(?:`.\n  let i = 0\n  while (i < source.length && source[i] !== '(') {\n    i += source[i] === '\\\\' ? 2 : 1\n  }\n  if (source[i] !== '(' || source[i + 1] !== '?' || source[i + 2] !== ':') return null\n  const openFrag = source.slice(0, i)\n  // Balanced scan of the group body to its matching `)`.\n  let k = i + 3\n  let depth = 1\n  while (k < source.length && depth > 0) {\n    const ch = source[k]\n    if (ch === '\\\\') { k += 2; continue }\n    if (ch === '[') {\n      let j = k + 1\n      if (source[j] === '^') j++\n      while (j < source.length && source[j] !== ']') {\n        if (source[j] === '\\\\') j += 2\n        else j++\n      }\n      if (source[j] !== ']') return null\n      k = j + 1\n      continue\n    }\n    if (ch === '(') depth++\n    else if (ch === ')') depth--\n    k++\n  }\n  if (depth !== 0) return null\n  const body = source.slice(i + 3, k - 1)\n  if (source[k] !== '*') return null\n  const closeFrag = source.slice(k + 1)\n  const open = literalCodePoints(openFrag)\n  const close = literalCodePoints(closeFrag)\n  if (!open || !close || !delimitedBodySound(body, close)) return null\n  return { kind: 'delimited', open, close }\n}\n\nfunction parseScanShapeCore(source: string): ScanShape | null {\n  // [X]+ / [X]* \u2014 a positive char-class run. A negated `[^X]+`/`[^X]*` is left to\n  // the general `seq` path (which lowers `[^X]+` and declines zero-width `[^X]*`).\n  let m = /^\\[((?:\\\\.|[^\\]])+)\\]([+*])$/.exec(source)\n  if (m && !m[1]!.startsWith('^')) {\n    const ranges = parseClassRanges(m[1]!)\n    return ranges ? { kind: 'chars', ranges, minOne: m[2] === '+' } : null\n  }\n  // \\d+ / \\w+ / \\s+ / \\d* / \\w* / \\s* \u2014 a bare shorthand-class run.\n  m = /^\\\\([dws])([+*])$/.exec(source)\n  if (m) {\n    return { kind: 'chars', ranges: shorthandRanges(m[1] as 'd' | 'w' | 's'), minOne: m[2] === '+' }\n  }\n  // <head><tail>* \u2014 identifier run: one head char, then a run of tail chars.\n  m = /^(\\[(?:\\\\.|[^\\]])+\\]|\\\\[dws])(\\[(?:\\\\.|[^\\]])+\\]|\\\\[dws])\\*$/.exec(source)\n  if (m) {\n    const head = classToRanges(m[1]!)\n    const tail = classToRanges(m[2]!)\n    if (head && tail) return { kind: 'ident', head, tail }\n  }\n  // <q>(?:[^q\\\\]|\\\\.)*<q> \u2014 a quote-delimited string with escapes.\n  const str = parseStringShape(source)\n  if (str) return str\n  // <lit>[^X]* \u2014 consume a literal opener, then run until a terminator char.\n  m = /^(.*?)\\[\\^((?:\\\\.|[^\\]])+)\\]\\*$/.exec(source)\n  if (m) {\n    const open = literalCodePoints(m[1]!)\n    const stop = parseClassRanges(m[2]!)\n    if (open && stop) return { kind: 'until', open, stop }\n  }\n  // <open>(?:\u2026)*<close> \u2014 delimited token scanned to its first close literal.\n  // Only lowered when the body provably can't contain the close (see\n  // `parseDelimited` / `delimitedBodySound`); any other `X(?:\u2026)*Y` declines here\n  // and falls through to the `seq` path / `RegExp.exec`.\n  const delim = parseDelimited(source)\n  if (delim) return delim\n  // General category: a linear chain of literals + char runs (optional prefixes,\n  // literal openers, negated runs), lowered only when unambiguously greedy.\n  const parts = parseSeqParts(source)\n  if (parts && seqIsUnambiguous(parts)) return { kind: 'seq', parts }\n  return null\n}\n\n/**\n * Flag-aware wrapper around `parseScanShape`. Lowering to a raw code-point scan\n * assumes default regex semantics, so any flag that changes matching (`i` case\n * folding, `u` surrogate handling, `m`/`s` anchor/dot behavior) disables it.\n * `g`/`y` are stickiness-only and safe.\n */\nexport function scanShapeFromRegex(source: string, flags: string): ScanShape | null {\n  if (/[msu]/.test(flags)) return null\n  if (/i/.test(flags)) return caseFoldShape(source)\n  return parseScanShape(source)\n}\n\n/**\n * Case-insensitive (`/i`) scannable shapes. Beyond a pure case-fold literal\n * (`litFold`), this recognizes a top-level alternation of literals (an ordered\n * `alt` of litFolds \u2014 CSS `(?:and|or)`, `(?:media|container|supports)`), each\n * optionally wrapped in a trailing lookahead boundary (`(?![-\\w])`, `(?=\\()`).\n * That last form is the regex spelling of `makeWord` \u2014 a keyword plus a word\n * boundary \u2014 the common CSS at-rule/keyword dispatcher. Anything else declines\n * (\u2192 `RegExp.exec`); a false read here can only fail to lower, never mis-lower.\n */\nfunction caseFoldShape(source: string): ScanShape | null {\n  const la = stripTrailingLookahead(source)\n  if (la) {\n    const inner = caseFoldLiteralOrAlt(la.base)\n    if (!inner) return null\n    const operand: CharSet = { ranges: la.ranges, negated: la.classNegated }\n    if (!lookaheadUnambiguous(inner, operand, la.negative)) return null\n    return { kind: 'lookahead', inner, ranges: la.ranges, classNegated: la.classNegated, negative: la.negative }\n  }\n  return caseFoldLiteralOrAlt(source)\n}\n\n/** A case-fold literal, or a top-level `a|b|c` alternation of pure literals. */\nfunction caseFoldLiteralOrAlt(source: string): ScanShape | null {\n  // `foldEq` only folds ASCII letters (65\u201390 / 97\u2013122). A non-ASCII code point\n  // with a Unicode case pair (\u00E9/\u00C9, \u00E4/\u00C4, \u2026) would be emitted as an exact compare\n  // and silently miss its alternate case \u2014 a mis-lower, not just a failed lower.\n  // Decline those so they fall back to `RegExp.exec` (correct Unicode folding),\n  // preserving this file's \"a false read can only fail to lower, never mis-lower\".\n  const asciiOnly = (cps: number[]): boolean => cps.every(cp => cp <= 127)\n\n  const open = literalCodePoints(source)\n  if (open) return asciiOnly(open) ? { kind: 'litFold', open } : null\n  // `splitTopLevelAlternation` unwraps the outer group itself, so no pre-strip.\n  const arms = splitTopLevelAlternation(source)\n  if (!arms || arms.length < 2) return null\n  const litArms: ScanShape[] = []\n  for (const arm of arms) {\n    const cp = literalCodePoints(arm)\n    if (!cp || !asciiOnly(cp)) return null\n    litArms.push({ kind: 'litFold', open: cp })\n  }\n  // Ordered choice: each litFold arm case-folds on its own, so skipping the\n  // first-char dispatch guard (disjoint:false, firsts:null) is always correct \u2014\n  // it just tries arms in order, exactly like regex `|`.\n  return { kind: 'alt', arms: litArms, disjoint: false, firsts: litArms.map(() => null) }\n}\n\nexport const classCond = (cVar: string, ranges: Array<[number, number]>): string =>\n  ranges\n    .map(([lo, hi]) => (lo === hi ? `${cVar} === ${lo}` : `(${cVar} >= ${lo} && ${cVar} <= ${hi})`))\n    .join(' || ')\n\n/** Literal-match condition at `base + k` for each code point; uses `firstVar` at offset 0. */\nexport const litCond = (base: string, cps: number[], firstVar?: string): string =>\n  cps\n    .map((cp, k) =>\n      k === 0 && firstVar\n        ? `${firstVar} === ${cp}`\n        : `input.charCodeAt(${base}${k ? ` + ${k}` : ''}) === ${cp}`,\n    )\n    .join(' && ')\n\n/** Line-terminator code points `.` does not match (`\\n \\r \\u2028 \\u2029`). */\nexport const LINE_TERMINATORS = [10, 13, 8232, 8233] as const\n\n/** The body-stop chars that abort a string match (excluded set minus quote/backslash). */\nexport function stringHardStop(\n  shape: Extract<ScanShape, { kind: 'string' }>,\n): Array<[number, number]> {\n  return shape.excluded.filter(\n    ([lo, hi]) => !(lo === hi && (lo === shape.quote || lo === BACKSLASH)),\n  )\n}\n\n/** Mints a fresh, unique local variable name (`prefix` + counter). */\nexport type Mint = (prefix?: string) => string\n\n/**\n * The SINGLE source of truth for how a scannable shape matches at `start`. Both\n * the terminal emitter and the trivia scan loop consume this, so no context can\n * silently reinterpret an incomplete match (e.g. an unterminated string):\n *\n *   - `setup`   statements (indented by `ind`) that compute the match.\n *   - `ok`      a boolean expr: did a token match at `start`? (zero-width for\n *               `chars*` counts as a match \u2014 terminals allow it.)\n *   - `end`     the position AFTER the token. **Invariant:** `end === start`\n *               whenever there is no progress (match failed or matched empty),\n *               so the trivia loop can gate purely on `end > start`.\n *\n * `firstChar`, when supplied, is an expression already equal to\n * `charCodeAt(start)` (the trivia loop reads it once and shares it).\n */\nexport type ShapeMatch = { setup: string[]; ok: string; end: string }\n\nconst codeAt = (start: string, firstChar?: string): string =>\n  firstChar ?? `input.charCodeAt(${start})`\n\n// Dispatch-planning thresholds for a disjoint alt's first-char `switch` \u2014 same\n// tuning as codegen's `planDisjointDispatch` (kept local to avoid a scannable-run\n// \u2192 codegen import cycle): only worth a jump table when every arm keys off a few\n// DISCRETE points; a wide range (`[a-z]+`) would explode into dozens of cases.\nconst ALT_SWITCH_RANGE_LIMIT = 4\nconst ALT_SWITCH_MAX_CASES = 48\nconst ALT_SWITCH_MIN_CASES = 3\n\n/**\n * A `switch` jump table for a *disjoint* alt when every arm's first-set is a few\n * discrete code points (operator/keyword first chars); else `{ kind: 'if' }` to\n * keep the range-comparison `if/else if` chain. Arms are pairwise-disjoint, so\n * each code point maps to exactly one arm.\n */\nfunction planAltSwitch(firsts: Array<CharSet | null>): { kind: 'switch'; cases: number[][] } | { kind: 'if' } {\n  const cases: number[][] = []\n  let total = 0\n  for (const fs of firsts) {\n    if (!fs || fs.negated) return { kind: 'if' } // any / negated \u2192 no discrete keys\n    const pts: number[] = []\n    for (const [lo, hi] of fs.ranges) {\n      if (hi - lo + 1 > ALT_SWITCH_RANGE_LIMIT) return { kind: 'if' }\n      for (let cp = lo; cp <= hi; cp++) pts.push(cp)\n    }\n    total += pts.length\n    if (total > ALT_SWITCH_MAX_CASES) return { kind: 'if' }\n    cases.push(pts)\n  }\n  return total >= ALT_SWITCH_MIN_CASES ? { kind: 'switch', cases } : { kind: 'if' }\n}\n\nexport function emitShapeMatch(\n  shape: ScanShape,\n  start: string,\n  mint: Mint,\n  ind: string,\n  firstChar?: string,\n): ShapeMatch {\n  if (shape.kind === 'lookahead') {\n    const inner = emitShapeMatch(shape.inner, start, mint, ind, firstChar)\n    const okV = mint('_ok')\n    const endV = mint('_end')\n    // `charInClass` folds the operand's OWN `[^\u2026]` negation in; `guardFails`\n    // then applies the lookahead's `!`/`=` polarity on top. Zero-width: `end`\n    // is always `inner.end` (on success) or `start` (on failure) \u2014 never past\n    // where `inner` itself stopped.\n    const rawIn = classCond(`input.charCodeAt(${inner.end})`, shape.ranges)\n    const charInClass = shape.classNegated ? `!(${rawIn})` : `(${rawIn})`\n    const hasMatchingChar = `${inner.end} < input.length && ${charInClass}`\n    const guardFails = shape.negative ? hasMatchingChar : `!(${hasMatchingChar})`\n    return {\n      setup: [\n        ...inner.setup,\n        `${ind}let ${okV} = ${inner.ok}`,\n        `${ind}let ${endV} = ${inner.end}`,\n        `${ind}if (${okV} && (${guardFails})) { ${okV} = false; ${endV} = ${start} }`,\n      ],\n      ok: okV,\n      end: endV,\n    }\n  }\n\n  if (shape.kind === 'alt') {\n    const okV = mint('_ok')\n    const endV = mint('_end')\n    const lines: string[] = [`${ind}let ${okV} = false`, `${ind}let ${endV} = ${start}`]\n    // Fast path: an alternation of case-fold literals (CSS keyword lists like\n    // `@media|@container|@supports`, `even|odd`) \u2192 a `switch` on the first char\n    // that jumps straight to the matching group, tails compared with the bit-OR\n    // fold. Measured ~2.4x over the ordered if-chain / ~1.4x over per-arm bit-OR.\n    // Ordered-choice is preserved: arms are grouped by their FOLDED first code\n    // point and, within a group, emitted in source order (first match wins);\n    // arms in different groups can't both match a given first char.\n    if (shape.arms.length >= 2 && shape.arms.every(a => a.kind === 'litFold' && a.open.length >= 1)) {\n      const groups = new Map<number, number[][]>()\n      for (const a of shape.arms) {\n        const open = (a as Extract<ScanShape, { kind: 'litFold' }>).open\n        const f = open[0]!\n        const lower = f >= 65 && f <= 90 ? f + 32 : f\n        ;(groups.get(lower) ?? groups.set(lower, []).get(lower)!).push(open)\n      }\n      lines.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`)\n      for (const [lower, arms] of groups) {\n        const labels = lower >= 97 && lower <= 122 ? `case ${lower}: case ${lower - 32}:` : `case ${lower}:`\n        lines.push(`${ind}  ${labels} {`)\n        for (const open of arms) {\n          const tail = open.slice(1).map((cp, i) => foldEq(`input.charCodeAt(${start} + ${i + 1})`, cp))\n          const cond = tail.length ? ` && ${tail.join(' && ')}` : ''\n          lines.push(`${ind}    if (${start} + ${open.length} <= input.length${cond}) { ${okV} = true; ${endV} = ${start} + ${open.length}; break }`)\n        }\n        lines.push(`${ind}    break`)\n        lines.push(`${ind}  }`)\n      }\n      lines.push(`${ind}}`)\n      return { setup: lines, ok: okV, end: endV }\n    }\n    if (shape.disjoint) {\n      // Mutually exclusive first-sets: dispatch straight to the one matching\n      // arm, no ordering/backtracking concerns (\u00A77b-style disjoint dispatch). A\n      // `switch` jump table when arms key off discrete first chars, else the\n      // range-comparison `if/else if` chain (same plan as codegen's choice()).\n      const plan = planAltSwitch(shape.firsts)\n      if (plan.kind === 'switch') {\n        lines.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`)\n        shape.arms.forEach((arm, k) => {\n          const labels = plan.cases[k]!.map(cp => `case ${cp}:`).join(' ')\n          const m = emitShapeMatch(arm, start, mint, `${ind}    `, firstChar)\n          lines.push(`${ind}  ${labels} {`)\n          lines.push(...m.setup)\n          lines.push(`${ind}    ${okV} = ${m.ok}`)\n          lines.push(`${ind}    ${endV} = ${m.ok} ? ${m.end} : ${start}`)\n          lines.push(`${ind}    break`)\n          lines.push(`${ind}  }`)\n        })\n        lines.push(`${ind}}`)\n      } else {\n        const c0 = codeAt(start, firstChar)\n        shape.arms.forEach((arm, k) => {\n          const fs = shape.firsts[k]! // non-null whenever `disjoint` is true\n          const cond = fs.negated ? `!(${classCond(c0, fs.ranges)})` : `(${classCond(c0, fs.ranges)})`\n          const m = emitShapeMatch(arm, start, mint, `${ind}  `, firstChar)\n          lines.push(`${ind}${k === 0 ? 'if' : 'else if'} (${start} < input.length && ${cond}) {`)\n          lines.push(...m.setup)\n          lines.push(`${ind}  ${okV} = ${m.ok}`)\n          lines.push(`${ind}  ${endV} = ${m.ok} ? ${m.end} : ${start}`)\n          lines.push(`${ind}}`)\n        })\n      }\n    } else {\n      // Overlapping first-sets: ordered choice \u2014 try each arm in turn and take\n      // the first that succeeds. This is exactly regex `|`'s own semantics:\n      // first alternative to match AT ALL wins on ITS OWN greedy length, never\n      // compared against a later alternative's (possibly longer) match.\n      const lbl = mint('_alt')\n      lines.push(`${ind}${lbl}: {`)\n      for (const arm of shape.arms) {\n        const m = emitShapeMatch(arm, start, mint, `${ind}  `, firstChar)\n        lines.push(...m.setup)\n        lines.push(`${ind}  if (${m.ok}) { ${okV} = true; ${endV} = ${m.end}; break ${lbl} }`)\n      }\n      lines.push(`${ind}}`)\n    }\n    return { setup: lines, ok: okV, end: endV }\n  }\n\n  if (shape.kind === 'chars') {\n    const cur = mint('_e')\n    return {\n      setup: [\n        `${ind}let ${cur} = ${start}`,\n        `${ind}while (${cur} < input.length && (${classCond(`input.charCodeAt(${cur})`, shape.ranges)})) ${cur}++`,\n      ],\n      // `*` always matches (possibly empty); `+` needs at least one char.\n      ok: shape.minOne ? `${cur} > ${start}` : 'true',\n      end: cur,\n    }\n  }\n\n  if (shape.kind === 'ident') {\n    const cur = mint('_e')\n    return {\n      setup: [\n        `${ind}let ${cur} = ${start}`,\n        `${ind}if (${start} < input.length && (${classCond(codeAt(start, firstChar), shape.head)})) {`,\n        `${ind}  ${cur} = ${start} + 1`,\n        `${ind}  while (${cur} < input.length && (${classCond(`input.charCodeAt(${cur})`, shape.tail)})) ${cur}++`,\n        `${ind}}`,\n      ],\n      ok: `${cur} > ${start}`,\n      end: cur,\n    }\n  }\n\n  if (shape.kind === 'seq') {\n    const endV = mint('_e')\n    const okV = mint('_ok')\n    const runCond = (p: Extract<SeqPart, { part: 'run' }>, at: string) => {\n      const c = classCond(`input.charCodeAt(${at})`, p.ranges)\n      return p.negated ? `!(${c})` : `(${c})`\n    }\n    const lines = [`${ind}let ${endV} = ${start}`, `${ind}let ${okV} = false`, `${ind}do {`]\n    let first = true\n    for (const p of shape.parts) {\n      if (p.part === 'lit') {\n        const L = p.cps.length\n        const cond = litCond(endV, p.cps, first ? firstChar : undefined)\n        if (p.optional) {\n          lines.push(`${ind}  if (${endV} + ${L} <= input.length && (${cond})) ${endV} += ${L}`)\n        } else {\n          lines.push(`${ind}  if (!(${endV} + ${L} <= input.length && (${cond}))) break`)\n          lines.push(`${ind}  ${endV} += ${L}`)\n        }\n      } else if (p.part === 'run' && p.max === Infinity) {\n        // Unbounded run (`+`/`*`/`{n,}`): greedy scan, then enforce the minimum.\n        const s = mint('_s')\n        lines.push(`${ind}  const ${s} = ${endV}`)\n        lines.push(`${ind}  while (${endV} < input.length && ${runCond(p, endV)}) ${endV}++`)\n        if (p.min === 1) lines.push(`${ind}  if (${endV} === ${s}) break`)\n        else if (p.min > 1) lines.push(`${ind}  if (${endV} - ${s} < ${p.min}) break`)\n      } else if (p.part === 'run' && p.max === 1) {\n        // Exactly one char: required (min 1) or optional (min 0).\n        if (p.min === 1) {\n          lines.push(`${ind}  if (!(${endV} < input.length && ${runCond(p, endV)})) break`)\n          lines.push(`${ind}  ${endV}++`)\n        } else {\n          lines.push(`${ind}  if (${endV} < input.length && ${runCond(p, endV)}) ${endV}++`)\n        }\n      } else if (p.part === 'run') {\n        // Bounded counted run `[x]{min,max}` (\u00A78c), max \u2265 2: consume up to `max`\n        // occurrences, then require at least `min` (greedy \u2014 sound because\n        // `seqIsUnambiguous` proved any wiggle is disjoint from what follows).\n        const s = mint('_s')\n        lines.push(`${ind}  const ${s} = ${endV}`)\n        lines.push(`${ind}  while (${endV} - ${s} < ${p.max} && ${endV} < input.length && ${runCond(p, endV)}) ${endV}++`)\n        if (p.min > 0) lines.push(`${ind}  if (${endV} - ${s} < ${p.min}) break`)\n      } else {\n        // `group` (\u00A78f): the group's own body is just another `ScanShape` \u2014\n        // recurse via `emitShapeMatch`, then splice its setup in as the body\n        // of a required-once check, an optional take, or a repeat loop.\n        const inner = emitShapeMatch(p.inner, endV, mint, `${ind}  `, first ? firstChar : undefined)\n        if (!p.unbounded) {\n          lines.push(...inner.setup)\n          if (p.min === 1) {\n            lines.push(`${ind}  if (!(${inner.ok})) break`)\n            lines.push(`${ind}  ${endV} = ${inner.end}`)\n          } else {\n            lines.push(`${ind}  if (${inner.ok}) ${endV} = ${inner.end}`)\n          }\n        } else {\n          const progV = mint('_prog')\n          lines.push(`${ind}  let ${progV} = false`)\n          lines.push(`${ind}  while (true) {`)\n          lines.push(...inner.setup)\n          lines.push(`${ind}    if (!(${inner.ok})) break`)\n          lines.push(`${ind}    ${endV} = ${inner.end}`)\n          lines.push(`${ind}    ${progV} = true`)\n          lines.push(`${ind}  }`)\n          if (p.min === 1) lines.push(`${ind}  if (!${progV}) break`)\n        }\n      }\n      first = false\n    }\n    lines.push(`${ind}  ${okV} = true`)\n    lines.push(`${ind}} while (false)`)\n    lines.push(`${ind}if (!${okV}) ${endV} = ${start}`)\n    return { setup: lines, ok: okV, end: endV }\n  }\n\n  if (shape.kind === 'litFold') {\n    const openLen = shape.open.length\n    const endV = mint('_end')\n    const checks = shape.open.map((cp, k) => {\n      const cVar = k === 0 && firstChar ? firstChar : `input.charCodeAt(${start} + ${k})`\n      return foldEq(cVar, cp)\n    })\n    return {\n      setup: [\n        `${ind}let ${endV} = ${start}`,\n        `${ind}if (${start} + ${openLen} <= input.length && (${checks.join(' && ')})) ${endV} = ${start} + ${openLen}`,\n      ],\n      ok: `${endV} > ${start}`,\n      end: endV,\n    }\n  }\n\n  if (shape.kind === 'until') {\n    const j = mint('_j')\n    const openLen = shape.open.length\n    const openChk = openLen === 1\n      ? `${codeAt(start, firstChar)} === ${shape.open[0]}`\n      : litCond(start, shape.open, firstChar)\n    return {\n      setup: [\n        `${ind}let ${j} = ${start}`,\n        `${ind}if (${start} + ${openLen} <= input.length && (${openChk})) {`,\n        `${ind}  ${j} = ${start} + ${openLen}`,\n        `${ind}  while (${j} < input.length && !(${classCond(`input.charCodeAt(${j})`, shape.stop)})) ${j}++`,\n        `${ind}}`,\n      ],\n      // An open-until-terminator always completes (stop char or EOF), so a matched\n      // open literal is a full match; `end === start` iff the open didn't match.\n      ok: `${j} > ${start}`,\n      end: j,\n    }\n  }\n\n  if (shape.kind === 'string') {\n    const okV = mint('_ok')\n    const endV = mint('_end')\n    const i = mint('_i')\n    const c2 = mint('_c')\n    const hard = stringHardStop(shape)\n    const ltLines = shape.escLineTerm\n      ? []\n      : (() => {\n          const c3 = mint('_c')\n          return [\n            `${ind}      const ${c3} = input.charCodeAt(${i} + 1)`,\n            `${ind}      if (${LINE_TERMINATORS.map(t => `${c3} === ${t}`).join(' || ')}) break`,\n          ]\n        })()\n    return {\n      setup: [\n        `${ind}let ${okV} = false`,\n        `${ind}let ${endV} = ${start}`,\n        `${ind}if (${start} < input.length && (${codeAt(start, firstChar)}) === ${shape.quote}) {`,\n        `${ind}  let ${i} = ${start} + 1`,\n        `${ind}  while (${i} < input.length) {`,\n        `${ind}    const ${c2} = input.charCodeAt(${i})`,\n        `${ind}    if (${c2} === ${shape.quote}) { ${okV} = true; ${endV} = ${i} + 1; break }`,\n        `${ind}    if (${c2} === ${BACKSLASH}) {`,\n        `${ind}      if (${i} + 1 >= input.length) break`,\n        ...ltLines,\n        `${ind}      ${i} += 2`,\n        `${ind}      continue`,\n        `${ind}    }`,\n        ...(hard.length ? [`${ind}    if (${classCond(c2, hard)}) break`] : []),\n        `${ind}    ${i}++`,\n        `${ind}  }`,\n        `${ind}}`,\n      ],\n      ok: okV,\n      end: endV,\n    }\n  }\n\n  // delimited: <open>\u2026<close>, requires the close literal (unclosed \u21D2 no match).\n  const j = mint('_j')\n  const endV = mint('_end')\n  const openLen = shape.open.length\n  const closeLen = shape.close.length\n  const openChk = openLen === 1\n    ? `${codeAt(start, firstChar)} === ${shape.open[0]}`\n    : litCond(start, shape.open, firstChar)\n  const closeChk = litCond(j, shape.close)\n  return {\n    setup: [\n      `${ind}let ${j} = ${start}`,\n      `${ind}let ${endV} = ${start}`,\n      `${ind}if (${start} + ${openLen} <= input.length && (${openChk})) {`,\n      `${ind}  ${j} = ${start} + ${openLen}`,\n      `${ind}  while (${j} + ${closeLen - 1} < input.length && !(${closeChk})) ${j}++`,\n      `${ind}  if (${j} + ${closeLen} <= input.length && (${closeChk})) ${endV} = ${j} + ${closeLen}`,\n      `${ind}}`,\n    ],\n    ok: `${endV} > ${start}`,\n    end: endV,\n  }\n}\n\n/**\n * One trivia-loop branch for a shape, dispatched on the current char `c`\n * (= charCodeAt(_e)). Advances `_e` and `continue`s ONLY on real progress\n * (`end > _e`) \u2014 an unterminated delimited/string token leaves `end === _e`, so\n * the loop stops there exactly as the interpreter's `oneOrMore(choice(\u2026))` would.\n */\nexport function scanBranch(shape: ScanShape, mint: Mint): string {\n  const m = emitShapeMatch(shape, '_e', mint, '    ', 'c')\n  return [...m.setup, `    if (${m.end} > _e) { _e = ${m.end}; continue }`].join('\\n')\n}\n\n/**\n * A labeled branch: match one token and, on progress, log its [start, end,\n * kindIndex] trivia chunk. Same completion semantics as scanBranch.\n */\nexport function scanBranchLabeled(shape: ScanShape, kindIndex: number, mint: Mint): string {\n  const m = emitShapeMatch(shape, '_e', mint, '    ', 'c')\n  return [\n    ...m.setup,\n    `    if (${m.end} > _e) {`,\n    `      if (_cap) {`,\n    `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, ${m.end}, ${kindIndex})`,\n    `        if (_ctx._cstTriviaLog !== undefined && (_ctx._triviaCaptureMask === undefined || (_ctx._triviaCaptureMask & ${1 << kindIndex}))) _ctx._cstTriviaLog.push(_e, ${m.end}, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${kindIndex})`,\n    `      }`,\n    `      _e = ${m.end}`,\n    `      continue`,\n    `    }`,\n  ].join('\\n')\n}\n", "import type { Combinator } from '../types.ts'\nimport { getCoreRegexDef } from '../combinators/choice.ts'\nimport type { LabeledTriviaSpec } from '../cst/trivia-kinds.ts'\nimport { analyzeLabeledTrivia } from '../cst/trivia-kinds.ts'\nimport { type ScanShape, type Mint, scanShapeFromRegex, scanBranch, scanBranchLabeled } from './scannable-run.ts'\n\n/** Fresh, collision-free local names for one generated scan function. */\nfunction makeMint(): Mint {\n  let n = 0\n  return (prefix = '_v') => `${prefix}${n++}`\n}\n\nfunction unwrapTrivia(p: Combinator<unknown>): Combinator<unknown> {\n  let cur = p\n  while (cur._def.tag === 'trivia') cur = cur._def.parser\n  return cur\n}\n\nfunction oneOrMoreInner(p: Combinator<unknown>): Combinator<unknown> | null {\n  const d = p._def\n  if (d.tag === 'oneOrMore') return d.parser\n  if (d.tag === 'many' && d.min >= 1) return d.parser\n  return null\n}\n\nfunction choiceArms(p: Combinator<unknown>): Combinator<unknown>[] | null {\n  if (p._def.tag === 'choice') return p._def.parsers\n  return null\n}\n\n/** The scannable shape of one arm (a regex), or null if it isn't scannable. */\nfunction armShape(arm: Combinator<unknown>): ScanShape | null {\n  const d = getCoreRegexDef(arm)\n  return d ? scanShapeFromRegex(d.source, d.flags) : null\n}\n\n/**\n * A trivia parser that lowers to a hand-rolled char-scan loop: `oneOrMore(choice(\n * \u2026))` (or `many`, min\u22651) where EVERY arm is a scannable shape (a `[X]+` run, a\n * `<lit>[^X]*` open-until-terminator, or a `<open>(?:\u2026)*<close>` delimited token\n * \u2014 see scannable-run.ts). Returns the per-arm shapes, or a single-element list\n * for a bare scannable regex, or null (\u2192 caller falls back to the regex/generic\n * trivia path). A single alternation regex is NOT scannable (one exec matches one\n * arm per call, defeating the loop).\n */\nexport function analyzeTriviaFastPath(trivia: Combinator<unknown>): ScanShape[] | null {\n  const core = unwrapTrivia(trivia)\n\n  const directDef = getCoreRegexDef(core)\n  if (directDef) {\n    const shape = scanShapeFromRegex(directDef.source, directDef.flags)\n    return shape && shape.kind === 'chars' ? [shape] : null\n  }\n\n  const inner = oneOrMoreInner(core)\n  if (!inner) return null\n\n  const innerShape = armShape(inner)\n  if (innerShape) return innerShape.kind === 'chars' ? [innerShape] : null\n\n  const arms = choiceArms(inner)\n  if (!arms || arms.length < 2) return null\n\n  const shapes: ScanShape[] = []\n  for (const arm of arms) {\n    const shape = armShape(arm)\n    if (!shape) return null\n    shapes.push(shape)\n  }\n  return shapes\n}\n\nconst CAP_RECORD = [\n  `  if (_cap && _e > _pos) {`,\n  `    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,\n  `    if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,\n  `  }`,\n].join('\\n')\n\n/** One char-scan loop carrying a branch per scannable shape, dispatched on `c`. */\nfunction composeFastLoop(shapes: ScanShape[]): string {\n  const mint = makeMint()\n  return [\n    `  while (_e < input.length) {`,\n    `    const c = input.charCodeAt(_e)`,\n    ...shapes.map(s => scanBranch(s, mint)),\n    `    break`,\n    `  }`,\n  ].join('\\n')\n}\n\n/** Emit a specialized `_tfN` that skips (unlabeled) trivia via a char-scan loop. */\nexport function buildFastTriviaFnDecl(fnName: string, shapes: ScanShape[]): string {\n  return [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    composeFastLoop(shapes),\n    CAP_RECORD,\n    `  return _e`,\n    `}`,\n  ].join('\\n')\n}\n\n/**\n * A LABELED trivia parser whose every arm is scannable \u2192 per-arm shape + kind\n * index, or null. Same recognition as analyzeTriviaFastPath, but keyed by the\n * labeled arm kinds so the fast loop can log each chunk's kind. Generalizes what\n * used to be a hardcoded ws-run + block-comment special case to any scannable\n * shape set / arm count.\n */\nexport function analyzeLabeledScannableRun(\n  trivia: Combinator<unknown>,\n): Array<{ shape: ScanShape; kindIndex: number }> | null {\n  const spec = analyzeLabeledTrivia(trivia)\n  if (!spec) return null\n  const out: Array<{ shape: ScanShape; kindIndex: number }> = []\n  for (const arm of spec.arms) {\n    const d = getCoreRegexDef(arm.parser)\n    const shape = d ? scanShapeFromRegex(d.source, d.flags) : null\n    if (!shape) return null\n    out.push({ shape, kindIndex: arm.kindIndex })\n  }\n  return out\n}\n\n/** Emit a labeled scannable trivia `_tfN`: char-scan loop with per-chunk kind capture. */\nexport function buildLabeledScannableTriviaFnDecl(\n  fnName: string,\n  arms: ReadonlyArray<{ shape: ScanShape; kindIndex: number }>,\n): string {\n  const mint = makeMint()\n  return [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  while (_e < input.length) {`,\n    `    const c = input.charCodeAt(_e)`,\n    ...arms.map(a => scanBranchLabeled(a.shape, a.kindIndex, mint)),\n    `    break`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n')\n}\n\n/** Labeled trivia with regex arms \u2014 per-chunk kind capture in compiled output. */\nexport function buildLabeledRegexTriviaFnDecl(\n  fnName: string,\n  spec: LabeledTriviaSpec,\n  reNames: string[],\n): string {\n  const tryArms = spec.arms.map((arm, i) => {\n    const re = reNames[i]!\n    const k = arm.kindIndex\n    return [\n      `    ${re}.lastIndex = _e`,\n      `    const _m${i} = ${re}.exec(input)`,\n      `    if (_m${i} && _m${i}.index === _e) {`,\n      `      const _ce = _e + _m${i}[0].length`,\n      `      if (_cap) {`,\n      `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, _ce, ${k})`,\n      `        if (_ctx._cstTriviaLog !== undefined && (_ctx._triviaCaptureMask === undefined || (_ctx._triviaCaptureMask & ${1 << k}))) _ctx._cstTriviaLog.push(_e, _ce, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${k})`,\n      `      }`,\n      `      _e = _ce`,\n      `      _matched = true`,\n      `      continue`,\n      `    }`,\n    ].join('\\n')\n  }).join('\\n')\n\n  return [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  while (_e < input.length) {`,\n    `    let _matched = false`,\n    tryArms,\n    `    if (!_matched) break`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n')\n}\n\nexport function labeledTriviaRegexArms(trivia: Combinator<unknown>): LabeledTriviaSpec | null {\n  const spec = analyzeLabeledTrivia(trivia)\n  if (!spec) return null\n  for (const arm of spec.arms) {\n    if (!getCoreRegexDef(arm.parser)) return null\n  }\n  return spec\n}\n\n/** Labeled trivia via per-arm runtime parsers (non-regex or mixed arms). */\nexport function buildLabeledRuntimeTriviaFnDecl(\n  fnName: string,\n  spec: LabeledTriviaSpec,\n  rpStartIndex: number,\n): string {\n  const tryArms = spec.arms.map((arm, i) => {\n    const k = arm.kindIndex\n    const ri = rpStartIndex + i\n    return [\n      `    const _r${i} = _rp[${ri}].parse(input, _e, _ctx)`,\n      `    if (_r${i}.ok && _r${i}.span.end > _e) {`,\n      `      const _ce = _r${i}.span.end`,\n      `      if (_cap) {`,\n      `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, _ce, ${k})`,\n      `        if (_ctx._cstTriviaLog !== undefined && (_ctx._triviaCaptureMask === undefined || (_ctx._triviaCaptureMask & ${1 << k}))) _ctx._cstTriviaLog.push(_e, _ce, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${k})`,\n      `      }`,\n      `      _e = _ce`,\n      `      _matched = true`,\n      `      continue`,\n      `    }`,\n    ].join('\\n')\n  }).join('\\n')\n\n  return [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  while (_e < input.length) {`,\n    `    let _matched = false`,\n    tryArms,\n    `    if (!_matched) break`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n')\n}\n", "/**\n * Lower scannable regex shapes to tight `charCodeAt` scan loops for terminal\n * `regex()` combinators (PERF_IDEAS \u00A78). Trivia uses the SAME match core via\n * `scannable-run.ts` (`emitShapeMatch`); this module is just the terminal\n * wrapper: run the shared match, fail when it doesn't match, then slice the\n * value. Keeping one match core means terminal and trivia can never disagree on\n * what an incomplete token (unclosed string/comment) means.\n */\nimport { type ScanShape, emitShapeMatch } from './scannable-run.ts'\n\nexport type ScanEmitCtx = {\n  ind: string\n  pos: string\n  valueVar: string\n  /** Emit `if (cond) { failLine }` lines (no trailing blank). */\n  failIf: (cond: string) => string[]\n  fresh: (prefix?: string) => string\n}\n\n/** Emit stmts for one terminal regex match, or null when the shape is unsupported. */\nexport function emitScannableTerminal(\n  shape: ScanShape,\n  c: ScanEmitCtx,\n): { stmts: string[]; endVar: string } | null {\n  const m = emitShapeMatch(shape, c.pos, c.fresh, c.ind)\n  const stmts = [...m.setup]\n  // `chars*` matches unconditionally (possibly empty) \u2014 no failure branch needed.\n  if (m.ok !== 'true') stmts.push(...c.failIf(`!(${m.ok})`))\n  stmts.push(`${c.ind}const ${c.valueVar} = input.slice(${c.pos}, ${m.end})`)\n  return { stmts, endVar: m.end }\n}\n", "import type { ParserDef } from '../types.ts'\n\n/** `(c, f, s, r, tl) => mk('Type', c, r, s, tl)` \u2014 CSS perf regression builder shape. */\nconst MK_BUILD_RE =\n  /^\\(\\s*(\\w+)\\s*,\\s*\\w+\\s*,\\s*(\\w+)\\s*,\\s*(\\w+)\\s*,\\s*(\\w+)\\s*\\)\\s*=>\\s*mk\\s*\\(\\s*(['\"])([^'\"]+)\\5\\s*,\\s*\\1\\s*,\\s*\\3\\s*,\\s*\\2\\s*,\\s*\\4\\s*\\)\\s*$/\n\nfunction escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/** Any callee \u2014 covers `mk`, `import_x.mk`, `__vite_ssr_import_0__.mk`, etc. */\nfunction looseMkBuildRe(type: string): RegExp {\n  return new RegExp(\n    String.raw`^\\(\\s*(\\w+)\\s*,\\s*\\w+\\s*,\\s*(\\w+)\\s*,\\s*(\\w+)\\s*,\\s*(\\w+)\\s*\\)\\s*=>\\s*.+\\(\\s*(['\"])${escapeRegExp(type)}\\5\\s*,\\s*\\1\\s*,\\s*\\3\\s*,\\s*\\2\\s*,\\s*\\4\\s*\\)\\s*$`,\n  )\n}\n\n/**\n * When a node() build is a thin `mk(type, \u2026)` wrapper, emit the object literal\n * at the call site instead of `_build[n](\u2026)`.\n */\nexport function analyzeMkInlineBuild(def: Extract<ParserDef, { tag: 'node' }>): string | null {\n  if (!def.build) return null // structural node \u2014 no own build to inline\n  if (def.type === undefined) return null\n  const src = (def.buildSrc ?? def.build.toString()).trim()\n  const strict = src.match(MK_BUILD_RE)\n  if (strict) {\n    const mkType = strict[6]!\n    return mkType === def.type ? def.type : null\n  }\n  if (looseMkBuildRe(def.type).test(src)) return def.type\n  return null\n}\n\n/** Object literal matching `stub-build.ts` `mk()` without the function call. */\nexport function emitInlineMkNodeExpr(\n  type: string,\n  chV: string,\n  rawV: string,\n  pos: string,\n  endVar: string,\n  tlV: string,\n): string {\n  return `{ _tag: 'node', type: ${JSON.stringify(type)}, span: { start: ${pos}, end: ${endVar} }, children: ${chV}, rawCount: ${rawV}.length, localTriviaLen: ${tlV}.length }`\n}\n", "/** Builtins allowed in inlined transform bodies (not treated as free closure refs). */\nconst INLINE_BUILTINS = new Set([\n  'parseInt', 'parseFloat', 'String', 'Number', 'Boolean', 'Object', 'Array', 'Math', 'JSON',\n  'undefined', 'null', 'true', 'false', 'NaN', 'Infinity',\n])\n\nfunction escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/** Source text for a transform callback \u2014 macro `fnSrc` or arrow `toString()`. */\nexport function transformFnSource(fn: Function, fnSrc?: string | null): string | null {\n  if (fnSrc) return fnSrc.trim()\n  const s = fn.toString().trim()\n  if (s.includes('[native code]')) return null\n  return s\n}\n\nfunction replaceParam(body: string, param: string, valueVar: string): string {\n  return body.replace(new RegExp(`\\\\b${escapeRegExp(param)}\\\\b`, 'g'), valueVar)\n}\n\nfunction stripForIdCheck(body: string): string {\n  return body\n    .replace(/'[^'\\\\]*(?:\\\\.[^'\\\\]*)*'|\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\"/g, '\"\"')\n    .replace(/\\bas\\s+const\\b/g, '')\n    .replace(/\\b[A-Za-z_$][\\w$]*\\s*:/g, ':')\n}\n\nfunction hasFreeIdentifiers(body: string, allowed: ReadonlySet<string>): boolean {\n  const stripped = stripForIdCheck(body)\n  const ids = stripped.match(/\\b[A-Za-z_$][\\w$]*\\b/g) ?? []\n  for (const id of ids) {\n    if (INLINE_BUILTINS.has(id)) continue\n    if (allowed.has(id)) continue\n    return true\n  }\n  return false\n}\n\n/** `s => expr` / `() => expr` when expr only uses the param (+ builtins). */\nexport function tryInlineUnaryTransform(src: string, valueVar: string): string | null {\n  const allowed = new Set([valueVar])\n  const nullary = src.match(/^\\(\\s*\\)\\s*=>\\s*(.+)$/)\n  if (nullary) {\n    const body = nullary[1]!.trim()\n    return hasFreeIdentifiers(body, allowed) ? null : body\n  }\n  const m = src.match(/^(\\w+)\\s*=>\\s*(.+)$/)\n  if (!m) return null\n  const body = replaceParam(m[2]!.trim(), m[1]!, valueVar)\n  return hasFreeIdentifiers(body, allowed) ? null : body\n}\n\n/** Parse `[a, , c]` destructuring slots (null = ignore). */\nexport function parseArrayDestructure(pattern: string, arity: number): (string | null)[] {\n  const slots: (string | null)[] = []\n  for (const part of pattern.split(',')) {\n    const name = part.trim()\n    slots.push(name === '' || name === '_' ? null : name)\n  }\n  while (slots.length < arity) slots.push(null)\n  return slots.slice(0, arity)\n}\n\n/**\n * `([x, y]) => body` \u2014 substitute destructure names with sequence value vars.\n * Caller must ensure body only references slotted params (+ builtins).\n */\nexport function tryInlineDestructureTransform(\n  src: string,\n  valueVars: string[],\n): string | null {\n  const m = src.match(/^\\(\\s*\\[([^\\]]*)\\]\\s*\\)\\s*=>\\s*(.+)$/s)\n  if (!m) return null\n  const slots = parseArrayDestructure(m[1]!, valueVars.length)\n  let body = m[2]!.trim()\n  const allowed = new Set(valueVars)\n  for (let i = 0; i < slots.length; i++) {\n    const name = slots[i]\n    if (name) body = replaceParam(body, name, valueVars[i]!)\n  }\n  return hasFreeIdentifiers(body, allowed) ? null : body\n}\n", "/**\n * Compile a Combinator<T> definition tree into an optimized JavaScript function.\n *\n * Design: every sub-emitter uses early-return on failure. Fallible contexts\n * (optional, sepBy loops, many loops) use labeled blocks so early-exit is a\n * `break <label>` rather than an IIFE return \u2014 no function call, no result\n * object allocation per node.\n */\nimport type { Combinator, ParserDef, FirstSet, ParseResult, ParseContext, ParseError, ChoiceStrategy, FieldMap } from '../types.ts'\nimport { getCoreLiteralValue, getCoreRegexDef } from '../combinators/choice.ts'\nimport { deriveExpected } from '../combinators/expect.ts'\nimport { firstSetOf, matchesEmpty, union } from '../combinators/first-set.ts'\nimport { markUnusedValues } from './value-usage.ts'\nimport { analyzeLabeledTrivia } from '../cst/trivia-kinds.ts'\nimport {\n  analyzeLabeledScannableRun,\n  analyzeTriviaFastPath,\n  buildFastTriviaFnDecl,\n  buildLabeledRegexTriviaFnDecl,\n  buildLabeledRuntimeTriviaFnDecl,\n  buildLabeledScannableTriviaFnDecl,\n  labeledTriviaRegexArms,\n} from './trivia-fast-path.ts'\nimport { scanShapeFromRegex, parseClassRanges, emitShapeMatch, foldEq, type ScanShape, type Mint } from './scannable-run.ts'\nimport { emitScannableTerminal } from './scannable-terminal.ts'\nimport { analyzeMkInlineBuild, emitInlineMkNodeExpr } from './inline-build.ts'\nimport { buildReadsTrivia, buildReadsState } from './build-arity.ts'\nimport { buildReadsFields, parserHasOwnFields } from './fields.ts'\nimport {\n  transformFnSource,\n  tryInlineUnaryTransform,\n  tryInlineDestructureTransform,\n} from './inline-callback.ts'\n\n/**\n * Runtime prelude helper for the structural-node capture gate. Answers \"does the\n * injected `_ctx.build` host read its (n+1)th positional arg?\" \u2014 `.length` alone\n * under-counts with rest/default params and can't see through a bound fn, so a\n * rest/default param or an `arguments` reference forces full capture (output-safe).\n * Plain positional and bound-native hosts (the common case) trust `.length`.\n * Emitted (memoized on `_ctx._pmCapTL`/`_pmCapST`) wherever a structural node()\n * arity-gates host capture; shared, un-namespaced, mirrors `_EMPTY_TL` placement.\n */\nexport const HOST_READS_DECL =\n  'const _hostReads = (b, n) => { if (b === undefined) return false; let s; try { s = Function.prototype.toString.call(b) } catch (e) { return true } if (/\\\\barguments\\\\b/.test(s)) return true; const m = /^[^(]*\\\\(([\\\\s\\\\S]*?)\\\\)/.exec(s); if (m && /\\\\.\\\\.\\\\.|=/.test(m[1])) return true; return b.length > n }'\n\n// ---------------------------------------------------------------------------\n// Regex-lowering diagnostics\n//\n// A regex terminal \"lowers\" when `scanShapeFromRegex` recognizes it and it emits\n// a tight `charCodeAt` scan loop. When it can't, emitRegex falls back to a real\n// `RegExp.exec` call \u2014 correct, but slower. Compilation is single-module and\n// synchronous, so a module-level capture sink (opened per transform, drained\n// after) records the un-lowered patterns without threading a field through every\n// Ctx and compile*() return. Keyed by regex source \u2192 one entry per unique pattern.\n// ---------------------------------------------------------------------------\nlet _loweringSink: Set<string> | null = null\n\n/** Begin capturing regexes that fall back to `RegExp.exec` (didn't lower). */\nexport function beginLoweringCapture(): void {\n  _loweringSink = new Set()\n}\n\n/** Stop capturing and return the un-lowered regex sources seen since begin. */\nexport function endLoweringCapture(): string[] {\n  const misses = _loweringSink ? [..._loweringSink] : []\n  _loweringSink = null\n  return misses\n}\n\n// ---------------------------------------------------------------------------\n// Codegen context\n// ---------------------------------------------------------------------------\ntype Ctx = {\n  vars: number\n  indent: number\n  /**\n   * Compile-time recovery gate (opt-in via `compile(g, { recovery: true })`).\n   * When off (default) NO recovery code is emitted \u2014 byte-identical output, and\n   * `runtimeParsers` stays empty so macro-inlining is unaffected. When on, lists\n   * emit a `_ctx._tolerant`-gated recovery branch and sequences publish an inferred\n   * sync sentinel; the machinery is dormant unless the parse is run tolerant.\n   */\n  recovery?: boolean | undefined\n  /** Regex declarations hoisted to module scope */\n  regexDecls: string[]\n  /** Dedup map: \"source/flags\" \u2192 variable name (_re0 etc.) */\n  regexMap: Map<string, string>\n  /** Frozen constant expected-set arrays hoisted to module scope (_fx0 etc.) */\n  expectedDecls: string[]\n  /** Dedup map: array source \u2192 hoisted const name */\n  expectedMap: Map<string, string>\n  /** Map functions that need to be captured at compile time */\n  mapFns: Array<(v: unknown, span: { start: number; end: number }) => unknown>\n  /**\n   * Source text of each map function, captured in lockstep with `mapFns`\n   * (parallel array). Populated from `def.fnSrc` when present \u2014 lets the macro\n   * inline transform callbacks in codegen-traversal order without a fragile\n   * pre-accumulated positional array. `null` entries mean the source was not\n   * available (interpreter/compile() path with no macro source).\n   */\n  mapFnSrcs: Array<string | null>\n  /** Runtime parser fallbacks (for unknown/_def-less parsers) */\n  runtimeParsers: Array<Combinator<unknown>>\n  /** Whether any node() elided trivia capture and needs the shared frozen empty log. */\n  needsEmptyTl?: boolean | undefined\n  /** Whether any structural node() arity-gates host capture and needs the `_hostReads` helper. */\n  needsHostReads?: boolean | undefined\n  /** Lazy/ref parsers and trivia helpers: parser identity \u2192 generated function name */\n  namedParsers: Map<Combinator<unknown>, string>\n  /**\n   * Rule-map composition (linkable form): the `ref` placeholder for each named\n   * rule \u2192 its canonical `_r_<Name>` function name. When a `lazy`/`ref` in\n   * `emitLazy` is one of these, it is emitted once as `_r_<Name>` (never inlined,\n   * so it stays addressable/overridable by name) and siblings call it by that\n   * name \u2014 so the whole map fuses into one scope with direct local calls. Unset\n   * for single-combinator `compile()` (no rule map \u2192 today's `_pfN` naming).\n   */\n  ruleNames?: Map<Combinator<unknown>, string> | undefined\n  /**\n   * Namespace prefix for HOISTED closure-level names (`_re`, `_fx`, `_pf`, `_mf`,\n   * `_build`) so two independently-compiled rule maps fuse into one scope without\n   * colliding (the linkable form). Empty by default \u2192 byte-identical output.\n   * Function-local vars (`_v`/`_e`/\u2026) are per-scope and never namespaced; the\n   * sentinel protocol (`_NAMED_FN_*`), `_EMPTY_TL` are SHARED across\n   * fused packages (a namespaced sentinel would break cross-package calls) and so\n   * are also left un-prefixed; `_r_<Name>` is the composition surface (intended\n   * collision = override) and is never prefixed.\n   */\n  ns?: string | undefined\n  /**\n   * Linkable (compose) mode: a `choice` arm that is a named rule REF must not bake\n   * an inline first-set dispatch guard \u2014 the referenced rule can be overridden at\n   * fuse time, changing its first-set. Instead emit a `/*@FS:rule:codevar@*\u200B/true`\n   * placeholder that fusedBody() substitutes with the WINNING rule's first-set\n   * condition (or leaves `true` = always-try when unknown). Off for monolithic\n   * compile() / compileRuleMap where rules are final.\n   */\n  deferFirstSetRefs?: boolean | undefined\n  /** Generated function declaration strings, prepended before the main body */\n  namedFnDecls: string[]\n  /** Active trivia parser (set by grammar() wrappers, cleared on exit) */\n  activeTrivia?: Combinator<unknown> | undefined\n  /** Label table from grammar trivia for default ParseContext. */\n  triviaKindLabels?: readonly string[] | undefined\n  /**\n   * Whether this compile contains any node() rule. When true, terminals emit a\n   * `_ctx._cstLeaves` capture and trivia skips capture trivia tokens \u2014 flowing\n   * through `_ctx` so capture crosses named-function (ref) boundaries correctly.\n   * When false (no node() anywhere) NO capture code is emitted, so non-CST\n   * grammars compile byte-identically to before.\n   */\n  capturing?: boolean\n  /** Inside the trivia-capture fn: terminals emit CSTTrivia tokens, not leaves. */\n  capAsTrivia?: boolean | undefined\n  /**\n   * Set on a transient probe ctx (e.g. scanTo's `capturing: false` sentinel/skip\n   * probe) where emitted code must have NO capture side effects. Suppresses\n   * shared-combinator hoisting so a probe never defines \u2014 nor reuses \u2014 a named\n   * function compiled in the surrounding capturing context (whose runtime-gated\n   * `_cstLeaves` push would fire during the probe).\n   */\n  noHoist?: boolean | undefined\n  /** Trivia parser \u2192 name of its capturing variant fn (separate from namedParsers). */\n  triviaCaptureNames: Map<Combinator<unknown>, string>\n  /**\n   * Trivia parser \u2192 name of its fast number-returning variant fn (non-capturing\n   * mode). Returns the new position directly instead of a {ok,value,span} object,\n   * eliminating two object allocations per trivia skip.\n   */\n  triviaFnNames: Map<Combinator<unknown>, string>\n  /** node() build functions captured at compile time (parallel to buildSrcs). */\n  buildFns: Array<(children: ReadonlyArray<unknown>, fields: FieldMap | undefined, span: { start: number; end: number }, raw: ReadonlyArray<unknown>, triviaLog: readonly number[], state: unknown) => unknown>\n  /** Source text of each build fn (set from def.buildSrc; null when unavailable). */\n  buildSrcs: Array<string | null>\n  /**\n   * When set, `failStmt` emits `break <label>` instead of `return { ok: false }`.\n   * Used by emitFallible to let labeled blocks act as the failure boundary.\n   */\n  failLabel?: string | undefined\n  /**\n   * Whether a leaf failure should record its payload into `_ctx._fe`/`_ctx._fx`\n   * for an enclosing reader (node/choice/ref/withCtx/runtime) to propagate.\n   * Swallowers (optional, many/sepBy loop bodies, not) set this false around the\n   * sub-parse whose failure they discard, so the hot path pays nothing. Default\n   * true (safe: always record). Only meaningful together with `failLabel`.\n   */\n  recordFail: boolean\n  /**\n   * Precomputed by analyzeLazyUsage() before codegen starts. emitLazy consults\n   * this to inline a single-use, non-recursive ref directly at its call site\n   * instead of hoisting it into a named function. Undefined when compile()\n   * hasn't run the pre-pass (should not happen in practice \u2014 always set in\n   * compile() \u2014 but kept optional so emitLazy degrades to \"always named\" if\n   * ever invoked without it, e.g. future direct unit tests of emitLazy).\n   */\n  lazyUsage?: {\n    counts: Map<Combinator<unknown>, number>\n    recursive: Set<Combinator<unknown>>\n    /** Approx subtree node count (lazy refs counted as 1 leaf), memoized. Gates\n     * shared-combinator hoisting: only subtrees big enough that de-duplicating\n     * them beats the added call cost are hoisted; tiny shared wrappers stay inline. */\n    sizes: Map<Combinator<unknown>, number>\n  }\n}\n\nfunction v(ctx: Ctx, prefix = '_v'): string { return `${prefix}${ctx.vars++}` }\nfunction ind(ctx: Ctx): string { return '  '.repeat(ctx.indent) }\n\n/** Namespace prefix for hoisted closure-level names (empty unless linkable). */\nfunction nsp(ctx: Ctx): string { return ctx.ns ?? '' }\n/** Hoisted map-fn array name (`_mf`, namespaced in linkable mode). */\nfunction mfRef(ctx: Ctx): string { return `${nsp(ctx)}_mf` }\n/** Hoisted build-fn array name (`_build`, namespaced in linkable mode). */\nfunction buildRef(ctx: Ctx): string { return `${nsp(ctx)}_build` }\n\n/** Re-indent emitted lines to an absolute depth while preserving relative nesting. */\nfunction reindentStmts(stmts: string[], targetLevels: number): string[] {\n  const nonEmpty = stmts.filter(s => s.trim().length > 0)\n  if (nonEmpty.length === 0) return stmts\n  const minLeading = Math.min(...nonEmpty.map(s => s.length - s.trimStart().length))\n  const targetPrefix = '  '.repeat(targetLevels)\n  return stmts.map(s => (s.trim().length === 0 ? '' : targetPrefix + s.slice(minLeading)))\n}\n\nfunction failReturn(expected: string, posExpr: string): string {\n  return `return { ok: false, expected: [${expected}], span: { start: ${posExpr}, end: ${posExpr} } }`\n}\n\nfunction failReturnArr(expectedArr: string, posExpr: string): string {\n  return `return { ok: false, expected: ${expectedArr}, span: { start: ${posExpr}, end: ${posExpr} } }`\n}\n\n/**\n * Hoist a COMPILE-TIME-CONSTANT expected-set array to a shared module-level\n * const and return its variable name. Leaf failures (literal, regex, keyword,\n * not, \u2026) have a fixed expected set, so recording it on the hot failure path\n * must NOT allocate a fresh array every time \u2014 a choice arm that misses or a\n * many/sepBy loop that terminates hits this on essentially every token. We store\n * a reference to the shared array instead (one pointer write, zero allocation).\n *\n * The shared array is NEVER mutated in place by generated code, and every path\n * that surfaces `_ctx._fx` as a user-facing ParseResult copies it first (see\n * `resultFromRecorded` / the dynamic direct-return in `failArrBody`), so the\n * public `expected` array stays fresh & independent. (We deliberately do NOT\n * `Object.freeze` it: a user grammar may define a rule named `Object`, which \u2014\n * once inlined as a local \u2014 would shadow the global and break the freeze call.)\n */\nfunction hoistExpected(ctx: Ctx, constArrSource: string): string {\n  let name = ctx.expectedMap.get(constArrSource)\n  if (name === undefined) {\n    name = `${nsp(ctx)}_fx${ctx.expectedDecls.length}`\n    ctx.expectedDecls.push(`const ${name} = ${constArrSource}`)\n    ctx.expectedMap.set(constArrSource, name)\n  }\n  return name\n}\n\n/**\n * Compiled mirror of the interpreter's `failAt` (probe.ts): a `_ctx._probe`-gated\n * furthest-failure update emitted at leaf-fail sites when IDE support is compiled in\n * (`ctx.recovery`). A deeper failure replaces the best; a tie MERGES expected arrays\n * (so choice arms aggregate their alternatives). Fires even inside swallowers\n * (`recordFail` off) \u2014 a completion's deepest failure is often inside an optional/\n * many. Dormant unless `completionsAt` set `_ctx._probe`, so a normal/tolerant parse\n * pays one property read per leaf fail. Empty (no side effects) when recovery is off.\n */\nfunction probeUpdate(ctx: Ctx, expectedArr: string, posExpr: string, constant = true): string {\n  if (!ctx.recovery) return ''\n  const fx = constant ? hoistExpected(ctx, expectedArr) : expectedArr\n  const pb = v(ctx, '_pb')\n  return `if (_ctx._probe !== undefined && ${posExpr} <= _ctx._probe.offset) { const ${pb} = _ctx._probe.best; if (${pb} === null || ${posExpr} > ${pb}.span.start) _ctx._probe.best = { ok: false, expected: [...${fx}], span: { start: ${posExpr}, end: ${posExpr} } }; else if (${posExpr} === ${pb}.span.start) _ctx._probe.best = { ok: false, expected: [...${pb}.expected, ...${fx}], span: { start: ${posExpr}, end: ${posExpr} } } } `\n}\n\nfunction failBody(ctx: Ctx, expected: string, posExpr: string): string {\n  // Record the failure payload before breaking so an enclosing composite\n  // construct can propagate this (deepest) failure verbatim \u2014 parity with the\n  // interpreter, which returns the inner failure result. Recording is skipped\n  // when no consumer will read it (see `ctx.recordFail`): swallowers like\n  // optional/many/sepBy/not never inspect `_ctx._fx`, so a leaf failing inside\n  // them just breaks \u2014 the hot path (loop terminations, first-arm misses) pays\n  // nothing. The direct-return path is the final answer and needs no recording.\n  const probe = probeUpdate(ctx, `[${expected}]`, posExpr)\n  if (ctx.failLabel) {\n    if (!ctx.recordFail) return probe ? `{ ${probe}break ${ctx.failLabel} }` : `break ${ctx.failLabel}`\n    return `{ ${probe}_ctx._fe = ${posExpr}; _ctx._fx = ${hoistExpected(ctx, `[${expected}]`)}; break ${ctx.failLabel} }`\n  }\n  return probe + failReturn(expected, posExpr)\n}\n\n/**\n * Like {@link failBody} but the caller already has an array source. When\n * `constant` (the default), the array is hoisted+frozen (zero-alloc hot path).\n * Pass `constant: false` for dynamic sources (e.g. `_ctx._fx`, a runtime concat)\n * that must be assigned verbatim.\n */\nfunction failArrBody(ctx: Ctx, expectedArr: string, posExpr: string, constant = true): string {\n  const probe = probeUpdate(ctx, expectedArr, posExpr, constant)\n  if (ctx.failLabel) {\n    if (!ctx.recordFail) return probe ? `{ ${probe}break ${ctx.failLabel} }` : `break ${ctx.failLabel}`\n    const fx = constant ? hoistExpected(ctx, expectedArr) : expectedArr\n    return `{ ${probe}_ctx._fe = ${posExpr}; _ctx._fx = ${fx}; break ${ctx.failLabel} }`\n  }\n  // Direct-return (no enclosing fail label). A dynamic source may reference the\n  // shared frozen `_ctx._fx`; copy it so the (possibly frozen) constant never\n  // escapes into a user-facing result. Constant sources are inline literals.\n  if (!constant) return `${probe}return { ok: false, expected: [...${expectedArr}], span: { start: ${posExpr}, end: ${posExpr} } }`\n  return probe + failReturnArr(expectedArr, posExpr)\n}\n\n/** Build a ParseResult from the recorded deepest failure, copying `_fx` so the\n * shared frozen array never escapes into user-facing results. */\nfunction resultFromRecorded(feExpr = '_ctx._fe', fxExpr = '_ctx._fx'): string {\n  return `return { ok: false, expected: [...${fxExpr}], span: { start: ${feExpr}, end: ${feExpr} } }`\n}\n\n/**\n * Propagate the already-recorded deepest failure (`_ctx._fe`/`_ctx._fx`) rather\n * than synthesizing a coarse `[\"node\"]`-style placeholder. Used by composite\n * constructs whose interpreter counterpart returns the inner failure verbatim\n * (node, ref/lazy, withCtx, runtime fallback). `srcCtx` is the ctx var holding\n * the payload (`_ctx`, or a spread child ctx for withCtx).\n */\nfunction propagateFailBody(ctx: Ctx, srcCtx = '_ctx'): string {\n  if (srcCtx !== '_ctx') {\n    // withCtx ran on a spread child ctx; copy its recorded failure back (only\n    // when a consumer will read it) before propagating.\n    if (ctx.failLabel) {\n      if (!ctx.recordFail) return `break ${ctx.failLabel}`\n      return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; break ${ctx.failLabel} }`\n    }\n    return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; ${resultFromRecorded()} }`\n  }\n  // Same-ctx: `_ctx._fx` already holds the deepest failure \u2014 just break/return.\n  if (ctx.failLabel) return `break ${ctx.failLabel}`\n  return resultFromRecorded()\n}\n\nfunction emitIfFail(ctx: Ctx, cond: string, body: string): string[] {\n  return [\n    `${ind(ctx)}if (${cond}) {`,\n    `${ind(ctx)}  ${body}`,\n    `${ind(ctx)}}`,\n  ]\n}\n\nfunction emitElseFail(ctx: Ctx, body: string): string[] {\n  return [\n    `${ind(ctx)}else {`,\n    `${ind(ctx)}  ${body}`,\n    `${ind(ctx)}}`,\n  ]\n}\n\n/** Sentinel + end-position slot for compiled `rules()` / `withCtx` named fns. */\nconst NAMED_FN_FAIL = '_pfFail'\nconst NAMED_FN_END = '_pfEnd'\n\nfunction namedFnPrelude(): string[] {\n  return [`const ${NAMED_FN_FAIL} = {}`, `let ${NAMED_FN_END}`]\n}\n\nfunction pushNamedFnDecl(\n  ctx: Ctx,\n  fnName: string,\n  bodyStmts: string[],\n  valueVar: string,\n  endVar: string,\n): void {\n  // Success path returns the value DIRECTLY (setting the shared end slot first);\n  // failure breaks `_pfail` and falls through to the sentinel return. No `_pfok`\n  // flag / post-block check \u2014 fewer ops on the hot (matched) path, and smaller.\n  ctx.namedFnDecls.push([\n    `function ${fnName}(input, _pos, _ctx) {`,\n    `  _pfail: {`,\n    ...reindentStmts(bodyStmts, 2),\n    `    ${NAMED_FN_END} = ${endVar}`,\n    `    return ${valueVar}`,\n    `  }`,\n    `  return ${NAMED_FN_FAIL}`,\n    `}`,\n  ].join('\\n'))\n}\n\nfunction emitNamedFnCall(ctx: Ctx, fnName: string, pos: string): ER {\n  const vv = v(ctx, '_pfv')\n  const ev = v(ctx, '_pfe')\n  return {\n    stmts: [\n      `${ind(ctx)}const ${vv} = ${fnName}(input, ${pos}, _ctx)`,\n      // ref/lazy returns the inner failure verbatim \u2014 propagate the recorded\n      // deepest failure (shares _ctx with the named fn), not a \"parser\" label.\n      ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, propagateFailBody(ctx)),\n      `${ind(ctx)}const ${ev} = ${NAMED_FN_END}`,\n    ],\n    valueVar: vv,\n    endVar: ev,\n  }\n}\n\n/**\n * Emit a spanned-leaf capture into the active node()'s collectors (via _ctx,\n * matching the interpreter). Emitted only in a capturing compile; the runtime\n * `if (_ctx._cstLeaves)` guard means terminals outside a node() pay one\n * predictable branch and nothing else.\n */\nfunction emitLeafCapture(ctx: Ctx, valExpr: string, startExpr: string, endExpr: string): string[] {\n  if (!ctx.capturing) return []\n  if (ctx.capAsTrivia) return []\n  const i = ind(ctx)\n  const lf = v(ctx, '_lf')\n  return [\n    `${i}if (_ctx._cstLeaves) {`,\n    `${i}  const ${lf} = { _tag: 'leaf', value: ${valExpr}, span: { start: ${startExpr}, end: ${endExpr} } }`,\n    `${i}  _ctx._cstLeaves.push(${lf})`,\n    `${i}  if (_ctx._cstRawChildren) _ctx._cstRawChildren.push(${lf})`,\n    `${i}}`,\n  ]\n}\n\nfunction ensureRegexDecl(ctx: Ctx, source: string, flags: string): string {\n  const f = 'y' + flags.replace(/[gy]/g, '')\n  const key = `${source}/${f}`\n  let rName = ctx.regexMap.get(key)\n  if (rName === undefined) {\n    rName = `${nsp(ctx)}_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${rName} = /${source}/${f}`)\n    ctx.regexMap.set(key, rName)\n  }\n  return rName\n}\n\n/**\n * When `cap` is truthy, also records `[start, end]` (and optional insertIdx) into\n * `_ctx._triviaLog` / `_ctx._cstTriviaLog`. One emitted function serves both skip\n * and capture call sites \u2014 no duplicate trivia parser tree, no _tc wrapper call.\n */\nfunction ensureTriviaFn(ctx: Ctx): string {\n  const trivia = ctx.activeTrivia!\n  const existing = ctx.triviaFnNames.get(trivia)\n  if (existing) return existing\n  // Namespaced like every other hoisted name (`_re`/`_pf`/`_fx`): two fused pieces\n  // each define their own `_tf0` (e.g. CSS block-only vs Less block+line trivia),\n  // so without the ns prefix they collide in the fused scope and the wrong trivia\n  // skipper wins. `nsp(ctx)` is '' for standalone output (byte-identical).\n  const fnName = `${nsp(ctx)}_tf${ctx.triviaFnNames.size}`\n  ctx.triviaFnNames.set(trivia, fnName)\n  ctx.triviaCaptureNames.set(trivia, fnName)\n\n  const labeledSpec = analyzeLabeledTrivia(trivia)\n\n  // UNLABELED trivia: any scannable shape set \u2192 char-scan loop with a single\n  // whole-run [start,end] capture (no per-arm kinds needed).\n  if (!labeledSpec) {\n    const fastShapes = analyzeTriviaFastPath(trivia)\n    if (fastShapes) {\n      ctx.namedFnDecls.push(buildFastTriviaFnDecl(fnName, fastShapes))\n      return fnName\n    }\n  } else {\n    // LABELED trivia: if every arm is scannable, the same char-scan loop but with\n    // per-chunk kind capture (generalizes the old hardcoded ws-run + block-comment\n    // case to any shape set / arm count). Otherwise fall to the regex/runtime\n    // kind-tracking loops, which handle non-scannable arms.\n    const labeledShapes = analyzeLabeledScannableRun(trivia)\n    if (labeledShapes) {\n      ctx.namedFnDecls.push(buildLabeledScannableTriviaFnDecl(fnName, labeledShapes))\n      return fnName\n    }\n\n    const regexSpec = labeledTriviaRegexArms(trivia)\n    if (regexSpec) {\n      const reNames: string[] = []\n      for (const arm of regexSpec.arms) {\n        const def = arm.parser._def\n        if (def.tag !== 'regex') break\n        reNames.push(ensureRegexDecl(ctx, def.source, def.flags))\n      }\n      if (reNames.length === regexSpec.arms.length) {\n        ctx.namedFnDecls.push(buildLabeledRegexTriviaFnDecl(fnName, regexSpec, reNames))\n        return fnName\n      }\n    }\n\n    const rpStart = ctx.runtimeParsers.length\n    for (const arm of labeledSpec.arms) {\n      ctx.runtimeParsers.push(arm.parser)\n    }\n    ctx.namedFnDecls.push(buildLabeledRuntimeTriviaFnDecl(fnName, labeledSpec, rpStart))\n    return fnName\n  }\n\n  const savedIndent    = ctx.indent\n  const savedFailLabel = ctx.failLabel\n  const savedTrivia    = ctx.activeTrivia\n  const savedCapAsTrivia = ctx.capAsTrivia\n  ctx.indent    = 2\n  ctx.failLabel = '_triv'\n  ctx.capAsTrivia = true  // trivia terminals must not push into _cstLeaves\n  ctx.activeTrivia = undefined  // trivia parser must not skip trivia within itself\n  const r = emit(trivia, ctx, '_pos')\n  ctx.indent    = savedIndent\n  ctx.failLabel = savedFailLabel\n  ctx.capAsTrivia = savedCapAsTrivia\n  ctx.activeTrivia = savedTrivia\n\n  ctx.namedFnDecls.push([\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  _triv: {`,\n    ...reindentStmts(r.stmts, 2),\n    `    _e = ${r.endVar}`,\n    `  }`,\n    `  if (_cap && _e > _pos) {`,\n    `    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,\n    `    if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n'))\n  return fnName\n}\n\n/** Capturing trivia skip \u2014 same compiled fn as ensureTriviaFn, pass `_cap = 1`. */\nfunction ensureTriviaCaptureFn(ctx: Ctx): string {\n  return ensureTriviaFn(ctx)\n}\n\n// ---------------------------------------------------------------------------\n// The result every emitter returns.\n// After the emitted stmts, `valueVar` holds the parsed value and `endVar`\n// holds the new position. On failure the emitter already emitted an early\n// `return failResult`.\n// ---------------------------------------------------------------------------\ntype ER = { stmts: string[]; valueVar: string; endVar: string }\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\nexport function firstSetCond(codeVar: string, fs: FirstSet): string {\n  if (fs.kind === 'any') return 'true'\n  if (fs.kind === 'empty') return 'false'\n  return fs.ranges.map(r =>\n    r.lo === r.hi\n      ? `${codeVar} === ${r.lo}`\n      : `(${codeVar} >= ${r.lo} && ${codeVar} <= ${r.hi})`\n  ).join(' || ')\n}\n\n// A first code point that keys a switch case is only worth enumerating when the\n// arm dispatches on a few DISCRETE points (keyword/operator first chars). A wide\n// range (a char-class arm like `[a-z]+`) would explode into dozens of `case`\n// labels, so those keep the if/else range-comparison form.\nconst SWITCH_RANGE_LIMIT = 4\nconst SWITCH_MAX_CASES = 48\nconst SWITCH_MIN_CASES = 3\n\n// Benchmark/test-only hook: force the `if/else if` disjoint-dispatch form so it\n// can be A/B'd against the `switch` jump table in the same process. Defaults to\n// off \u2014 production always uses planDisjointDispatch. See bench/codegen-ab.ts.\nlet _forceDisjointIf = false\nexport function __setForceDisjointIf(on: boolean): void { _forceDisjointIf = on }\n\n/**\n * Choose the dispatch form for a *disjoint* choice. Returns per-arm case code\n * points for a `switch` (jump table) when every arm keys off a small discrete\n * set, or `if` to keep the range-comparison `if/else if` chain. The arms are\n * pairwise-disjoint by construction, so each code point maps to exactly one arm.\n */\nfunction planDisjointDispatch(\n  parsers: ReadonlyArray<Combinator<unknown>>,\n): { kind: 'switch'; cases: number[][] } | { kind: 'if' } {\n  const cases: number[][] = []\n  let total = 0\n  for (const p of parsers) {\n    const fs = p._meta.firstSet\n    if (fs.kind !== 'ranges') return { kind: 'if' } // any/empty \u2192 no discrete keys\n    const pts: number[] = []\n    for (const r of fs.ranges) {\n      if (r.hi - r.lo + 1 > SWITCH_RANGE_LIMIT) return { kind: 'if' }\n      for (let cp = r.lo; cp <= r.hi; cp++) pts.push(cp)\n    }\n    total += pts.length\n    if (total > SWITCH_MAX_CASES) return { kind: 'if' }\n    cases.push(pts)\n  }\n  return total >= SWITCH_MIN_CASES ? { kind: 'switch', cases } : { kind: 'if' }\n}\n\n// \u2500\u2500 CST/trivia capture rollback: cheap when no buffer is active \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// The four capture buffers (`_cstLeaves`, `_cstRawChildren`, `_cstTriviaLog`,\n// `_triviaLog`) are usually all undefined on the hot path (a grammar with any\n// node() compiles with ctx.capturing=true, but at runtime most callers don't\n// request a CST \u2014 they only want the value). Reading `_x?.length ?? 0` four\n// times per fallible block \u2014 and emitFallible runs for every sequence term,\n// repeat item, optional, and choice arm \u2014 turned into a measurable de-opt\n// (compiled CSS regressed ~2.3\u00D7). We gate the whole save/restore on a single\n// boolean: when no buffer is live the marks are 0 and the restore is one test.\n/** Body of a capture restore \u2014 resets each live buffer to its saved length. */\nfunction captureRestoreBody(mL: string, mR: string, mTl: string, mLg: string | null, mF: string | null = null): string {\n  const fieldRestore = mF ? `; if (_ctx._fields) _ctx._fields.length = ${mF}` : ''\n  const base = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${mL}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${mR}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${mTl}${fieldRestore}`\n  // `_triviaLog` is the standalone diagnostic trivia log. The interpreter only\n  // rewinds it on a failed *choice* arm (choice.ts), NOT on a failed sequence\n  // term \u2014 a sequence returns the failure with earlier trivia still logged. To\n  // stay byte-for-byte at parity with the interpreter, only rewind it where the\n  // interpreter does (choice arms); sequence-term rollbacks (emitFallible) leave\n  // it intact.\n  return mLg ? `${base}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${mLg}` : base\n}\n\n/**\n * True when parsing `p` may push a capture (leaf/child/trivia) into the active\n * buffers and THEN fail, leaving partial state that an enclosing node() would\n * wrongly absorb. Used to decide whether a fallible block needs CST-rollback.\n *\n * Sound over-approximation: the ONLY constructs that capture-then-fail are\n *   - a sequence whose non-final term captures before a later term can fail\n *   - a sepBy/oneOrMore item-then-separator partial (handled by their own\n *     dedicated rollback, so still covered conservatively here)\n * Atomic terminals (literal/regex/keywords/charClass/guard/not) fail without\n * having captured. node() buffers into a private sub-scope and discards it on\n * failure, so it never leaks. choice/firstMatch roll back each failed arm\n * internally. optional/many never \"fail\" with partial output. Delegating\n * wrappers (transform/label/grammar/withCtx/expect/skip) pass through to inner.\n */\nfunction mayLeavePartialCapture(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  if (seen.has(p)) return false\n  seen.add(p)\n  const d = p._def\n  switch (d.tag) {\n    // Atomic / non-capturing-then-failing: a failure happens before any push.\n    case 'literal':\n    case 'regex':\n    case 'keywords':\n    case 'guard':\n    case 'not':\n    case 'trivia':\n    case 'token':\n    case 'scanTo':\n    case 'unknown':\n      return false\n    // node() captures into its own private buffers and rolls them back on\n    // failure (emitNode restores _ctx.* and never pushes on the !ok path).\n    case 'node':\n      return false\n    // choice/firstMatch already roll back each failed arm; on overall failure\n    // nothing committed remains.\n    case 'choice':\n      return false\n    // optional never fails; many/oneOrMore only \"fail\" with zero captured items.\n    case 'optional':\n    case 'many':\n    case 'oneOrMore':\n      return false\n    // sepBy emits its own per-iteration rollback in emitSepBy.\n    case 'sepBy':\n      return false\n    // A sequence is the real case: an earlier capturing term followed by a term\n    // that can fail leaves the earlier captures buffered.\n    case 'sequence': {\n      const parts = d.parsers\n      // Only risky if >=2 terms and some non-final term can capture.\n      if (parts.length < 2) return parts.some(x => mayLeavePartialCapture(x, seen))\n      for (let i = 0; i < parts.length - 1; i++) {\n        if (hasNodeDef(parts[i]!) || capturesLeaf(parts[i]!)) return true\n      }\n      return false\n    }\n    // Delegating wrappers: defer to the wrapped parser.\n    case 'transform':\n    case 'label':\n    case 'field':\n    case 'expect':\n    case 'withCtx':\n    case 'grammar':\n      return mayLeavePartialCapture(d.parser, seen)\n    case 'skip':\n      return mayLeavePartialCapture(d.main, seen)\n    case 'recover':\n      return mayLeavePartialCapture(d.parser, seen)\n    case 'lazy': {\n      try { return mayLeavePartialCapture(d.thunk(), seen) } catch { return true }\n    }\n    // Unknown shapes: be safe and keep the rollback.\n    default:\n      return true\n  }\n}\n\n/** True when `p` can push a leaf/node into the capture buffers on success. */\nfunction capturesLeaf(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  if (seen.has(p)) return false\n  seen.add(p)\n  const d = p._def\n  switch (d.tag) {\n    case 'literal':\n    case 'regex':\n    case 'keywords':\n    case 'node':\n    case 'token':\n      return true\n    case 'not':\n    case 'guard':\n    case 'trivia':\n    case 'unknown':\n      return false\n    case 'sequence':\n    case 'choice':\n      return d.parsers.some(x => capturesLeaf(x, seen))\n    case 'sepBy':\n      return capturesLeaf(d.parser, seen) || capturesLeaf(d.separator, seen)\n    case 'many':\n    case 'oneOrMore':\n    case 'optional':\n    case 'transform':\n    case 'label':\n    case 'field':\n    case 'expect':\n    case 'withCtx':\n    case 'grammar':\n    case 'recover':\n      return capturesLeaf(d.parser, seen)\n    case 'skip':\n      return capturesLeaf(d.main, seen)\n    case 'scanTo':\n      return true\n    case 'lazy': {\n      try { return capturesLeaf(d.thunk(), seen) } catch { return true }\n    }\n    default:\n      return true\n  }\n}\n\n/** Wrap stmts + success return in an IIFE. Returns the IIFE expression string. */\nfunction asIIFE(stmts: string[], valueVar: string, endVar: string, startPos: string, indent: string): string {\n  return [\n    `(() => {`,\n    ...stmts,\n    `${indent}  return { ok: true, value: ${valueVar}, span: { start: ${startPos}, end: ${endVar} } }`,\n    `${indent}})()`,\n  ].join('\\n')\n}\n\n/**\n * Emit `inner` as a labeled block with flat result variables \u2014 no IIFE call,\n * no `{ ok, value, span }` object allocation.  The returned stmts declare:\n *   let ${okVar} = false, ${valVar}, ${endVar} = ${pos}\n *   ${label}: { <inner stmts using break ${label} on failure>; capture success }\n * Callers read ${okVar} to branch on success/failure.\n */\nfunction emitFallible(\n  inner: Combinator<unknown>,\n  ctx: Ctx,\n  pos: string,\n  /**\n   * When true, the caller DISCARDS this failure (optional/many/sepBy/not) \u2014 the\n   * inner leaves need not record `_ctx._fx`, since nobody reads it. Suppresses\n   * the hot-path failure bookkeeping for the sub-parse.\n   */\n  swallow = false,\n): { stmts: string[]; okVar: string; valVar: string; endVar: string } {\n  const lbl  = v(ctx, '_lbl')\n  const okV  = `${lbl}ok`\n  const valV = `${lbl}v`\n  const endV = `${lbl}e`\n\n  const savedLabel  = ctx.failLabel\n  const savedIndent = ctx.indent\n  const savedRecord = ctx.recordFail\n  ctx.failLabel = lbl\n  ctx.indent    = savedIndent + 1\n  if (swallow) ctx.recordFail = false\n  const r = emit(inner, ctx, pos)\n  ctx.failLabel = savedLabel\n  ctx.indent    = savedIndent\n  ctx.recordFail = savedRecord\n\n  const ind0 = ind(ctx)\n  // In capturing mode, roll back any CST captures made by a FAILED attempt \u2014 a\n  // sub-parser may match terminals (e.g. a sequence that consumes '[') and then\n  // fail on a later term, breaking out with those leaves/trivia still buffered.\n  // Without this they leak into the enclosing node()'s children. (The non-disjoint\n  // choice path does the same per-arm; a disjoint choice commits to one arm and\n  // relies on this boundary to undo a failed commit.)\n  //\n  // The rollback is only needed when `inner` can push a capture and THEN fail\n  // (i.e. leave partial buffered state). Atomic terminals, self-contained nodes,\n  // choices/repeats that roll back internally, etc. never leave partial captures\n  // \u2014 emitting the save/restore around every fallible block (every sequence term)\n  // was a ~2.3\u00D7 compiled-CSS regression. Gate it on the structural predicate so\n  // hot grammars compile back to tight code while correctness is preserved.\n  // A failed sequence term does NOT rewind `_triviaLog` (the interpreter leaves\n  // earlier trivia logged) \u2014 only the CST child buffers are restored here.\n  const needsRollback = ctx.capturing && mayLeavePartialCapture(inner)\n  const needsFieldRollback = needsRollback && parserHasOwnFields(inner)\n  const mL  = needsRollback ? v(ctx, '_fcl')  : null\n  const mR  = needsRollback ? v(ctx, '_fcr')  : null\n  const mTl = needsRollback ? v(ctx, '_fctl') : null\n  const mF  = needsFieldRollback ? v(ctx, '_fcf')  : null\n  const stmts = [\n    `${ind0}let ${okV} = false, ${valV}, ${endV} = ${pos}`,\n    ...(mL ? [\n      `${ind0}const ${mL} = _ctx._cstLeaves?.length ?? 0`,\n      `${ind0}const ${mR} = _ctx._cstRawChildren?.length ?? 0`,\n      `${ind0}const ${mTl} = _ctx._cstTriviaLog?.length ?? 0`,\n      ...(mF ? [`${ind0}const ${mF} = _ctx._fields?.length ?? 0`] : []),\n    ] : []),\n    `${ind0}${lbl}: {`,\n    ...r.stmts,\n    `${ind0}  ${valV} = ${r.valueVar}; ${endV} = ${r.endVar}; ${okV} = true`,\n    `${ind0}}`,\n    ...(mL ? [\n      `${ind0}if (!${okV}) { ${captureRestoreBody(mL, mR!, mTl!, null, mF)} }`,\n    ] : []),\n  ]\n  return { stmts, okVar: okV, valVar: valV, endVar: endV }\n}\n\n\n// ---------------------------------------------------------------------------\n// Per-combinator emitters\n// ---------------------------------------------------------------------------\n\n/**\n * Above this length, an unrolled `charCodeAt` chain stops paying for itself:\n * measured crossover where native `startsWith` wins on runtime is ~256\u2013512\n * chars, but the unrolled chain's *generated source* grows ~4\u201330\u00D7 faster than\n * `startsWith`'s near-constant call site (see PERF_IDEAS.md). No literal in a\n * real grammar (keywords, punctuation) gets remotely close to this \u2014 the\n * longest in this repo's example grammars is `important` (9 chars) \u2014 so this\n * threshold exists to cap codegen bloat on a pathological literal, not because\n * `startsWith` is faster there.\n */\nconst CHARCODE_CHAIN_MAX = 16\n\nfunction emitLit(def: Extract<ParserDef, { tag: 'literal' }>, ctx: Ctx, pos: string): ER {\n  const { value, caseInsensitive } = def\n  const len = value.length\n  const vv = v(ctx)\n  const expectedStr = JSON.stringify(JSON.stringify(value))\n  const stmts: string[] = []\n\n  if (caseInsensitive && len > 0) {\n    // ASCII case fold, the same `(c | 32) === lower` bit-OR compare that `/i`-flag\n    // regex lowering uses (foldEq) \u2014 NOT Intl.Collator (measured ~9\u00D7 slower, and\n    // its Unicode accent-folding is the wrong semantic for a parser anyway). Folds\n    // ASCII letters, exact-matches everything else. The captured value is the\n    // input's own casing (slice), not the pattern's.\n    const match = Array.from({ length: len }, (_, i) =>\n      `(${foldEq(`input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ''})`, value.charCodeAt(i))})`\n    ).join(' && ')\n    stmts.push(\n      ...emitIfFail(ctx, `${pos} + ${len} > input.length || !(${match})`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = input.slice(${pos}, ${pos} + ${len})`,\n    )\n  } else if (len === 0) {\n    stmts.push(`${ind(ctx)}const ${vv} = ''`)\n  } else if (len === 1) {\n    const code = value.codePointAt(0)!\n    stmts.push(\n      ...emitIfFail(ctx, `${pos} >= input.length || input.charCodeAt(${pos}) !== ${code}`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`,\n    )\n  } else if (len <= CHARCODE_CHAIN_MAX) {\n    const checks = Array.from({ length: len }, (_, i) =>\n      `input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ''}) !== ${value.codePointAt(i)!}`\n    ).join(' || ')\n    stmts.push(\n      ...emitIfFail(ctx, `${pos} + ${len} > input.length || ${checks}`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`,\n    )\n  } else {\n    // startsWith(str, pos) avoids allocating a slice \u2014 it handles the bounds check\n    // internally and compares in-place. No first-char guard needed either.\n    stmts.push(\n      ...emitIfFail(ctx, `!input.startsWith(${JSON.stringify(value)}, ${pos})`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`,\n    )\n  }\n\n  const endVar = len === 0 ? pos : `${pos} + ${len}`\n  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar))\n  return { stmts, valueVar: vv, endVar }\n}\n\nfunction escapeKeywordRe(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/**\n * Fast path for `keywords()`/`word()`/`makeWord()`: each word is a FIXED\n * literal (optionally wrapped in the shared boundary lookahead), so this\n * reuses the exact `seq`/`litFold`/`lookahead` `ScanShape` machinery from\n * `scannable-run.ts` (PERF_IDEAS \u00A78b) instead of one `RegExp.exec` alternation\n * per match. Unconditionally ambiguity-safe: `trailingBacktrackClass` treats a\n * single-literal `seq` and `litFold` as fixed-length (no quantifier to\n * backtrack), so wrapping either in a lookahead is safe for ANY boundary class\n * \u2014 no `seqIsUnambiguous`-style check is needed here.\n *\n * Declines (returns `null`, caller falls back to the regex alternation) for:\n *   - an empty-string keyword (degenerate; not worth special-casing)\n *   - a keyword containing an astral (surrogate-pair) code point \u2014 the `seq`/\n *     `litFold` codegen advances one `charCodeAt` UTF-16 unit per code POINT,\n *     which only holds for the BMP (same reason `scanShapeFromRegex` refuses\n *     the `u` flag entirely); real keyword sets are BMP identifiers, so this\n *     is a defensive, not a practical, limitation\n *   - a boundary class this file can't parse (defensive; `parseClassRanges`\n *     handles every realistic boundary string, e.g. `_0-9A-Za-z`)\n *   - `caseInsensitive` combined with a boundary \u2014 the boundary class would\n *     ALSO need ASCII case-folding to match the original regex's `/i` flag\n *     (the general \"`/i` on a char class\" problem, PERF_IDEAS \u00A78d, not yet\n *     built), so this combination is left on the safe, slower path rather\n *     than risk silently narrowing which chars the boundary excludes.\n */\nfunction emitKeywordsFast(def: Extract<ParserDef, { tag: 'keywords' }>, ctx: Ctx, pos: string): ER | null {\n  if (def.words.length === 0 || def.words.some(w => w.length === 0)) return null\n  if (def.words.some(w => Array.from(w).length !== w.length)) return null\n  if (def.caseInsensitive && def.boundary) return null\n\n  let boundary: { ranges: Array<[number, number]>; negated: boolean } | null = null\n  if (def.boundary) {\n    let body = def.boundary\n    const negated = body.startsWith('^')\n    if (negated) body = body.slice(1)\n    const ranges = parseClassRanges(body)\n    if (!ranges) return null\n    boundary = { ranges, negated }\n  }\n\n  const mint: Mint = (prefix = '_v') => v(ctx, prefix)\n  const lbl = v(ctx, '_kwLbl')\n  const valV = v(ctx, '_kwv')\n  const endV = v(ctx, '_kwe')\n  const bodyInd = ind(ctx) + '  '\n\n  const tries: string[] = []\n  for (const w of def.words) {\n    const cps = Array.from(w, ch => ch.codePointAt(0)!)\n    let shape: ScanShape = def.caseInsensitive\n      ? { kind: 'litFold', open: cps }\n      : { kind: 'seq', parts: [{ part: 'lit', cps, optional: false }] }\n    if (boundary) {\n      shape = { kind: 'lookahead', inner: shape, ranges: boundary.ranges, classNegated: boundary.negated, negative: true }\n    }\n    const m = emitShapeMatch(shape, pos, mint, bodyInd)\n    tries.push(\n      ...m.setup,\n      // Slice from input rather than reusing the literal word: `caseInsensitive`\n      // must return the text as it actually appeared (e.g. \"ABC\" for keyword\n      // \"abc\"), matching what the original `RegExp.exec()[0]` returned.\n      `${bodyInd}if (${m.ok}) { ${valV} = input.slice(${pos}, ${m.end}); ${endV} = ${m.end}; break ${lbl} }`,\n    )\n  }\n\n  const stmts = [\n    `${ind(ctx)}let ${valV} = '', ${endV} = ${pos}`,\n    `${ind(ctx)}${lbl}: {`,\n    ...tries,\n    `${ind(ctx)}}`,\n    // Every word has length >= 1 (checked above), so a real match always\n    // advances past `pos` \u2014 `endV === pos` only happens when no candidate matched.\n    ...emitIfFail(ctx, `${endV} === ${pos}`, failBody(ctx, '\"keyword\"', pos)),\n  ]\n  stmts.push(...emitLeafCapture(ctx, valV, pos, endV))\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\nfunction emitKeywords(def: Extract<ParserDef, { tag: 'keywords' }>, ctx: Ctx, pos: string): ER {\n  const fast = emitKeywordsFast(def, ctx, pos)\n  if (fast) return fast\n\n  const alt = def.words.map(escapeKeywordRe).join('|')\n  const boundary = def.boundary ? `(?![${def.boundary}])` : ''\n  const flags = def.caseInsensitive ? 'iuy' : 'uy'\n  const source = `(?:${alt})${boundary}`\n  const key = `${source}/${flags}`\n  let rName = ctx.regexMap.get(key)\n  if (rName === undefined) {\n    rName = `${nsp(ctx)}_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${rName} = /${source}/${flags}`)\n    ctx.regexMap.set(key, rName)\n  }\n\n  const mv = v(ctx, '_m')\n  const vv = v(ctx)\n  const stmts = [\n    `${ind(ctx)}${rName}.lastIndex = ${pos}`,\n    `${ind(ctx)}const ${mv} = ${rName}.exec(input)`,\n    ...emitIfFail(ctx, `${mv} === null`, failBody(ctx, '\"keyword\"', pos)),\n    `${ind(ctx)}const ${vv} = ${mv}[0]`,\n  ]\n  const endVar = `${pos} + ${vv}.length`\n  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar))\n  return { stmts, valueVar: vv, endVar }\n}\n\nfunction emitRegex(def: Extract<ParserDef, { tag: 'regex' }>, ctx: Ctx, pos: string): ER {\n  const expectedStr = JSON.stringify(`/${def.source}/`)\n  const shape = scanShapeFromRegex(def.source, def.flags)\n  if (shape) {\n    const vv = v(ctx)\n    const scanned = emitScannableTerminal(shape, {\n      ind: ind(ctx),\n      pos,\n      valueVar: vv,\n      failIf: (cond: string) => emitIfFail(ctx, cond, failBody(ctx, expectedStr, pos)),\n      fresh: (prefix?: string) => v(ctx, prefix),\n    })\n    if (scanned) {\n      const stmts = [...scanned.stmts, ...emitLeafCapture(ctx, vv, pos, scanned.endVar)]\n      return { stmts, valueVar: vv, endVar: scanned.endVar }\n    }\n  }\n\n  // Didn't lower to the fast charCodeAt scan \u2014 record it and fall back to RegExp.\n  _loweringSink?.add(`/${def.source}/${def.flags}`)\n\n  const flags = 'y' + def.flags.replace(/[gy]/g, '')\n  const key = `${def.source}/${flags}`\n  let rName = ctx.regexMap.get(key)\n  if (rName === undefined) {\n    rName = `${nsp(ctx)}_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${rName} = /${def.source}/${flags}`)\n    ctx.regexMap.set(key, rName)\n  }\n\n  const mv = v(ctx, '_m')\n  const vv = v(ctx)\n  const stmts = [\n    `${ind(ctx)}${rName}.lastIndex = ${pos}`,\n    `${ind(ctx)}const ${mv} = ${rName}.exec(input)`,\n    ...emitIfFail(ctx, `${mv} === null`, failBody(ctx, expectedStr, pos)),\n    `${ind(ctx)}const ${vv} = ${mv}[0]`,\n  ]\n  const endVar = `${pos} + ${vv}.length`\n  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar))\n  return { stmts, valueVar: vv, endVar }\n}\n\n/**\n * A JS expression that builds a zero-width follow-set sync sentinel for `fs` at\n * RUNTIME via `_ctx._rec.sentinel(...)` \u2014 never `_rp` \u2014 so a recovery-enabled\n * grammar keeps `runtimeParsers` empty and stays macro-inlinable. Returns null when\n * the first-set is `any`/`empty` (no usable sentinel). The build is only reached on\n * the tolerant path (the publish that uses it is `_ctx._tolerant`-gated), so a strict\n * parse of the shipped grammar allocates nothing.\n */\nfunction syncSentinelExpr(fs: FirstSet): string | null {\n  if (fs.kind !== 'ranges' || fs.ranges.length === 0) return null\n  return `_ctx._rec.sentinel({ kind: 'ranges', ranges: ${JSON.stringify(fs.ranges)} })`\n}\n\nfunction emitSeqValues(def: Extract<ParserDef, { tag: 'sequence' }>, ctx: Ctx, pos: string): ER & { valueVars: string[] } {\n  const startV = v(ctx, '_start')\n  const curV = v(ctx, '_cur')\n  const stmts: string[] = [\n    `${ind(ctx)}const ${startV} = ${pos}`,\n    `${ind(ctx)}let ${curV} = ${pos}`,\n  ]\n  const valueVars: string[] = []\n\n  // Recovery sync publish (compile-time gate): save the inherited sync at entry,\n  // then before each term set `_ctx._sync` to the inferred follow-set sentinel of\n  // the remaining terms (or the inherited sync when none is usable) so a nested\n  // list resyncs to the enclosing delimiter. Runtime-gated by `_ctx._tolerant`;\n  // strict parses never touch it.\n  const syncInV = ctx.recovery ? v(ctx, '_syncIn') : ''\n  if (ctx.recovery) stmts.push(`${ind(ctx)}const ${syncInV} = _ctx._sync`)\n  const publishSync = (i: number): string => {\n    if (!ctx.recovery) return ''\n    const fs = def.parsers.slice(i + 1).reduce<FirstSet>((acc, p) => union(acc, firstSetOf(p)), { kind: 'empty' })\n    const ref = syncSentinelExpr(fs)\n    return `${ind(ctx)}if (_ctx._tolerant) _ctx._sync = ${ref ?? syncInV}`\n  }\n\n  for (let i = 0; i < def.parsers.length; i++) {\n    const syncPub = publishSync(i)\n    if (syncPub) stmts.push(syncPub)\n    if (i > 0 && ctx.activeTrivia) {\n      if (ctx.capturing) {\n        const capFn = ensureTriviaCaptureFn(ctx)\n        const markV = v(ctx, '_mk')\n        const markTl = v(ctx, '_mktl')\n        const markLog = v(ctx, '_mklg')\n        const scanEndV = v(ctx, '_sne')\n        stmts.push(\n          `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n          `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,\n          `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,\n          `${ind(ctx)}const ${scanEndV} = ${capFn}(input, ${curV}, _ctx, 1)`,\n        )\n        const r = emit(def.parsers[i]!, ctx, scanEndV)\n        stmts.push(...r.stmts)\n        const endAfterV = v(ctx, '_sea')\n        stmts.push(\n          `${ind(ctx)}const ${endAfterV} = ${r.endVar}`,\n          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) { ${curV} = ${endAfterV} } else { if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; }`,\n        )\n        valueVars.push(r.valueVar)\n        continue\n      } else {\n        // Match the interpreter (sequence.ts): scan trivia to a temp position, but\n        // only *commit* it (advance cur) if the following term consumes content past\n        // it. A term matching empty (optional/many/lookahead) leaves cur pre-trivia,\n        // so trailing whitespace stays out of the sequence's span. The non-capturing\n        // trivFn has no side effects when called without `_cap`, so there is nothing\n        // to roll back \u2014 just keep cur unchanged.\n        const trivFn = ensureTriviaFn(ctx)\n        const scanEndV = v(ctx, '_sne')\n        stmts.push(`${ind(ctx)}const ${scanEndV} = ${trivFn}(input, ${curV}, _ctx)`)\n        const r = emit(def.parsers[i]!, ctx, scanEndV)\n        stmts.push(...r.stmts)\n        const endAfterV = v(ctx, '_sea')\n        stmts.push(\n          `${ind(ctx)}const ${endAfterV} = ${r.endVar}`,\n          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) ${curV} = ${endAfterV}`,\n        )\n        valueVars.push(r.valueVar)\n        continue\n      }\n    }\n    const r = emit(def.parsers[i]!, ctx, curV)\n    stmts.push(...r.stmts, `${ind(ctx)}${curV} = ${r.endVar}`)\n    valueVars.push(r.valueVar)\n  }\n\n  return { stmts, valueVar: valueVars[valueVars.length - 1] ?? 'null', endVar: curV, valueVars }\n}\n\nfunction emitSeq(def: Extract<ParserDef, { tag: 'sequence' }>, ctx: Ctx, pos: string): ER {\n  const { stmts, endVar, valueVars } = emitSeqValues(def, ctx, pos)\n  // The tuple is never observed (markUnusedValues) \u2014 terms still parse + capture;\n  // skip allocating `[v1, v2, \u2026]`.\n  if (def.valueUnused) return { stmts, valueVar: 'undefined', endVar }\n  const arrV = v(ctx, '_arr')\n  stmts.push(`${ind(ctx)}const ${arrV} = [${valueVars.join(', ')}]`)\n  return { stmts, valueVar: arrV, endVar }\n}\n\n/**\n * Deep-first `expected` labels for a choice's arms \u2014 the concatenation of each\n * arm's leftmost-leaf expected set, matching what the interpreter collects when\n * no arm's first-set matches (choice.ts) and what expect()'s deriveExpected()\n * reports. Falls back to the arm's tag only for arms with no static expectation\n * (e.g. runtime-fallback combinators), preserving the previous behaviour there.\n */\nfunction deriveExpectedArr(parsers: Combinator<unknown>[]): string {\n  return JSON.stringify(parsers.flatMap(p => {\n    const e = deriveExpected(p)\n    return e.length > 0 ? e : [p._tag]\n  }))\n}\n\n/**\n * True when `p` can only fail at its own start position (its failure span is\n * `{pos,pos}` and its expected set is a fixed label). Such disjoint-choice arms\n * can be emitted inline: their leaf failure already matches the interpreter's\n * `{expected: <label>, span: {pos,pos}}`. Composite arms (sequence, node, \u2026) can\n * fail deeper, so they must be wrapped to re-anchor the span at the choice pos.\n */\nfunction failsAtStart(p: Combinator<unknown>): boolean {\n  const d = p._def\n  switch (d.tag) {\n    case 'literal': case 'regex': case 'keywords': case 'guard': case 'not':\n      return true\n    case 'transform': case 'label': case 'field':\n      return failsAtStart(d.parser)\n    default:\n      return false\n  }\n}\n\n/** Hoisted module-level const for one arm's static `expected` labels. */\nfunction armStaticExpected(ctx: Ctx, p: Combinator<unknown>): string {\n  return hoistExpected(ctx, deriveExpectedArr([p]))\n}\n\n/**\n * True when `p` can succeed at `pos` without consuming input (e.g. a starred\n * regex, optional, many). Such arms must still be tried even when the current\n * code point is outside their first-set \u2014 skipping them would change semantics.\n */\nfunction canMatchEmptyAtStart(p: Combinator<unknown>): boolean {\n  const d = p._def\n  switch (d.tag) {\n    case 'regex':\n      return /(?:[*?]|\\{0,|\\{\\d*,)/.test(d.source)\n    case 'optional': return true\n    case 'many': return true\n    case 'transform': case 'label': case 'field':\n      return canMatchEmptyAtStart(d.parser)\n    case 'literal':\n      return d.value.length === 0\n    default:\n      return false\n  }\n}\n\n/** Emit a first-set guard when the arm cannot match empty and has a finite first-set. */\nfunction needsFirstSetGuard(p: Combinator<unknown>): boolean {\n  const fs = p._meta.firstSet\n  return fs.kind !== 'any' && !canMatchEmptyAtStart(p)\n}\n\n/**\n * Emit one arm of a disjoint choice, assigning its value/end to `valV`/`endV`.\n * Leaf arms (failsAtStart) are inlined \u2014 their leaf failure already matches the\n * interpreter. Composite arms are wrapped so that on failure the choice reports\n * the arm's deep `expected` (via _ctx._fx) but re-anchors the span at the choice\n * position `pos` \u2014 exactly what the interpreter's disjoint dispatch returns.\n */\nfunction emitDisjointArm(p: Combinator<unknown>, ctx: Ctx, pos: string, valV: string, endV: string): string[] {\n  if (failsAtStart(p)) {\n    const r = emit(p, ctx, pos)\n    return [...r.stmts, `${ind(ctx)}${valV} = ${r.valueVar}`, `${ind(ctx)}${endV} = ${r.endVar}`]\n  }\n  const { stmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos)\n  return [\n    ...stmts,\n    ...emitIfFail(ctx, `!${okVar}`, failArrBody(ctx, '_ctx._fx', pos, false)),\n    `${ind(ctx)}${valV} = ${valVar}`,\n    `${ind(ctx)}${endV} = ${endVar}`,\n  ]\n}\n\n/**\n * Register a disjoint-choice arm's gate predicate (if any) into `mapFns` and emit\n * the guarded arm body. Mirrors emitFirstMatch's gate handling: the gate closure\n * is pushed into `mapFns` (with its source into `mapFnSrcs` \u2014 `def.gateSrcs[i]`\n * for the macro, null for compile()) BEFORE the arm body is emitted, so the\n * per-arm push order (gate, then arm transforms) stays parallel with the macro's\n * pre-accumulated sources and the emitFirstMatch layout.\n *\n * A gated arm dispatches on its first char, then checks the gate INSIDE that\n * branch: gate true \u2192 run the arm; gate false \u2192 FAIL the choice at `pos` (sound\n * because disjoint + non-nullable arms guarantee no other arm matches this char).\n */\nfunction emitDisjointArmGated(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  i: number,\n  ctx: Ctx,\n  pos: string,\n  valV: string,\n  endV: string,\n): string[] {\n  const p = def.parsers[i]!\n  const gate = def.gates[i]\n  if (!gate) return emitDisjointArm(p, ctx, pos, valV, endV)\n\n  const gateIdx = ctx.mapFns.length\n  ctx.mapFns.push(gate as (v: unknown, span: unknown) => unknown)\n  // Macro path inlines the captured gate source; compile() has no source \u2192 null.\n  // Parallel-length invariant with mapFns preserved either way.\n  ctx.mapFnSrcs.push(def.gateSrcs?.[i] ?? null)\n  const gateCond = `${mfRef(ctx)}[${gateIdx}](_ctx.state)`\n\n  const stmts = [`${ind(ctx)}if (${gateCond}) {`]\n  ctx.indent++\n  stmts.push(...emitDisjointArm(p, ctx, pos, valV, endV))\n  ctx.indent--\n  stmts.push(`${ind(ctx)}} else { ${failArrBody(ctx, deriveExpectedArr([p]), pos)} }`)\n  return stmts\n}\n\nfunction emitChoice(def: Extract<ParserDef, { tag: 'choice' }>, ctx: Ctx, pos: string): ER {\n  const allExpected = deriveExpectedArr(def.parsers)\n\n  // \u2500\u2500 Disjoint: O(1) first-char dispatch (arms may be gated) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  if (def.disjoint) {\n    const codeV = v(ctx, '_code')\n    const valV = v(ctx, '_chv')\n    const endV = v(ctx, '_che')\n    const stmts: string[] = [\n      `${ind(ctx)}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,\n      `${ind(ctx)}let ${valV}, ${endV} = ${pos}`,\n    ]\n\n    const plan = _forceDisjointIf ? { kind: 'if' as const } : planDisjointDispatch(def.parsers)\n\n    // Switch (jump table) when arms key off a few discrete first code points.\n    if (plan.kind === 'switch') {\n      stmts.push(`${ind(ctx)}switch (${codeV}) {`)\n      ctx.indent++\n      for (let i = 0; i < def.parsers.length; i++) {\n        for (const cp of plan.cases[i]!) stmts.push(`${ind(ctx)}case ${cp}:`)\n        stmts.push(`${ind(ctx)}{`)\n        ctx.indent++\n        stmts.push(\n          ...emitDisjointArmGated(def, i, ctx, pos, valV, endV),\n          `${ind(ctx)}break`,\n        )\n        ctx.indent--\n        stmts.push(`${ind(ctx)}}`)\n      }\n      stmts.push(`${ind(ctx)}default: ${failArrBody(ctx, allExpected, pos)}`)\n      ctx.indent--\n      stmts.push(`${ind(ctx)}}`)\n      return { stmts, valueVar: valV, endVar: endV }\n    }\n\n    // Otherwise if/else if with range comparisons (cheaper for char-class arms).\n    let first = true\n    for (let i = 0; i < def.parsers.length; i++) {\n      const p = def.parsers[i]!\n      const cond = firstSetCond(codeV, p._meta.firstSet)\n      const kw = first ? 'if' : 'else if'\n      first = false\n      stmts.push(`${ind(ctx)}${kw} (${cond}) {`)\n      ctx.indent++\n      stmts.push(...emitDisjointArmGated(def, i, ctx, pos, valV, endV))\n      ctx.indent--\n      stmts.push(`${ind(ctx)}}`)\n    }\n    stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)))\n    return { stmts, valueVar: valV, endVar: endV }\n  }\n\n  return emitNonDisjoint(def, def.strategy, allExpected, ctx, pos)\n}\n\n// \u2500\u2500 greedyClassify: run the super-regex once, classify by string equality \u2500\u2500\u2500\u2500\n// Single regex exec + O(n_literals) string comparisons. Zero backtracking.\nfunction emitGreedyClassify(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  superIndex: number,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const superParser = def.parsers[superIndex]!\n  const regexDef = getCoreRegexDef(superParser)!\n\n  // Hoist the regex (same mechanism as emitRegex, with dedup)\n  const cleanFlags = 'y' + regexDef.flags.replace(/[gy]/g, '')\n  const reKey = `${regexDef.source}/${cleanFlags}`\n  let reVar = ctx.regexMap.get(reKey)\n  if (reVar === undefined) {\n    reVar = `${nsp(ctx)}_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${reVar} = /${regexDef.source}/${cleanFlags}`)\n    ctx.regexMap.set(reKey, reVar)\n  }\n\n  const matchV = v(ctx, '_gm')\n  const wordV  = v(ctx, '_gw')\n  const endV   = v(ctx, '_ge')\n  const valV   = v(ctx, '_gcv')\n\n  // On no-match the interpreter returns the super-regex arm's failure verbatim\n  // (choice.ts) \u2014 report only the regex's expected, not every classified literal.\n  const regexExpected = JSON.stringify(deriveExpected(superParser))\n  const stmts: string[] = [\n    `${ind(ctx)}${reVar}.lastIndex = ${pos}`,\n    `${ind(ctx)}const ${matchV} = ${reVar}.exec(input)`,\n    ...emitIfFail(ctx, `${matchV} === null`, failArrBody(ctx, regexExpected, pos)),\n    `${ind(ctx)}const ${wordV} = ${matchV}[0]`,\n    `${ind(ctx)}const ${endV} = ${pos} + ${wordV}.length`,\n    `${ind(ctx)}let ${valV}`,\n  ]\n\n  // For each literal arm: if word === literal, capture + transform chain\n  let first = true\n  for (let i = 0; i < def.parsers.length; i++) {\n    if (i === superIndex) continue\n    const p = def.parsers[i]!\n    const litVal = getCoreLiteralValue(p)\n    if (litVal === null) continue\n\n    const kw = first ? 'if' : 'else if'\n    first = false\n    stmts.push(`${ind(ctx)}${kw} (${wordV} === ${JSON.stringify(litVal)}) {`)\n    ctx.indent++\n    const tR = emitTransformChain(p, JSON.stringify(litVal), endV, pos, ctx)\n    stmts.push(...emitLeafCapture(ctx, JSON.stringify(litVal), pos, endV))\n    stmts.push(...tR.stmts, `${ind(ctx)}${valV} = ${tR.valueVar}`)\n    ctx.indent--\n    stmts.push(`${ind(ctx)}}`)\n  }\n\n  // Regex arm: capture + transform chain for the matched word\n  const rR = emitTransformChain(superParser, wordV, endV, pos, ctx)\n  const regexKw = first ? 'if' : 'else'\n  stmts.push(`${ind(ctx)}${regexKw} {`)\n  ctx.indent++\n  stmts.push(...emitLeafCapture(ctx, wordV, pos, endV), ...rR.stmts, `${ind(ctx)}${valV} = ${rR.valueVar}`)\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\n// \u2500\u2500 literalsLongestFirst: sorted startsWith checks, no backtracking \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfunction emitLiteralsLongestFirst(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  sortedIndices: number[],\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const valV = v(ctx, '_llv')\n  const endV = v(ctx, '_lle')\n  const stmts: string[] = [`${ind(ctx)}let ${valV}, ${endV} = ${pos}`]\n\n  let first = true\n  for (const idx of sortedIndices) {\n    const p = def.parsers[idx]!\n    const litVal = getCoreLiteralValue(p)!\n    const litLen = litVal.length\n\n    // Emit the literal check as a direct condition (no IIFE/try-catch \u2014 literals never throw)\n    const litCond = emitLiteralCondition(litVal, pos)\n    const kw = first ? 'if' : 'else if'\n    first = false\n\n    const litEnd = `${pos} + ${litLen}`\n    stmts.push(`${ind(ctx)}${kw} (${litCond}) {`)\n    ctx.indent++\n    const tR = emitTransformChain(p, JSON.stringify(litVal), litEnd, pos, ctx)\n    stmts.push(\n      ...emitLeafCapture(ctx, JSON.stringify(litVal), pos, litEnd),\n      ...tR.stmts,\n      `${ind(ctx)}${valV} = ${tR.valueVar}`,\n      `${ind(ctx)}${endV} = ${litEnd}`,\n    )\n    ctx.indent--\n    stmts.push(`${ind(ctx)}}`)\n  }\n  stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)))\n\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\n// \u2500\u2500 firstMatch fallback: PEG + auto-not inline rejection + per-arm gates \u2500\u2500\u2500\u2500\u2500\n// Uses labeled blocks (emitFallible) instead of IIFE+try/catch to avoid V8\n// deoptimization from exception-based control flow.\nfunction emitFirstMatch(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const resValV = v(ctx, '_crv')\n  const resEndV = v(ctx, '_cre')\n  const resOkV  = v(ctx, '_crok')\n  const codeV   = v(ctx, '_chcode')\n  // For a TOTAL failure we report the concatenation of each tried arm's deep\n  // `expected` (interpreter parity). To keep the hot success path allocation-free\n  // (a choice that ultimately matches must NOT pay for error bookkeeping), each\n  // failed arm snapshots its expected into a scalar slot (a pointer store, no\n  // array/spread). Leaf arms that fail-at-start use a hoisted static const;\n  // composite arms snapshot `_ctx._fx`. The concat array is materialized only in\n  // the rare all-arms-failed branch. Auto-not-rejected arms leave their slot\n  // unset \u2014 matching choice.ts.\n  const slots = def.parsers.map(() => v(ctx, '_cfx'))\n  const ind0 = ind(ctx)\n  const stmts: string[] = [\n    `${ind0}let ${resValV}, ${resEndV} = ${pos}, ${resOkV} = false`,\n    `${ind0}let ${slots.join(', ')}`,\n    `${ind0}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,\n  ]\n\n  for (let i = 0; i < def.parsers.length; i++) {\n    const p = def.parsers[i]!\n    const gate    = def.gates[i]\n    const autoNot = def.autoNot[i]\n    const atStart = failsAtStart(p)\n    const staticFx = armStaticExpected(ctx, p)\n    // A named rule REF in linkable mode: defer its first-char guard to fuse time\n    // (the rule can be overridden). Emit a placeholder that fusedBody() rewrites\n    // with the WINNING rule's first-set \u2014 `true` (always-try) if left unresolved.\n    const deferRuleName = ctx.deferFirstSetRefs\n      ? (p as unknown as { _ruleName?: string })._ruleName\n      : undefined\n    // Non-defer (monolithic, refs are final): if the arm's CACHED first-set is `any`\n    // only because it was built over `ref()`s (which cache `any()` at construction),\n    // recover a real guard from the DEEP, ref-resolving first-set. Sound here because\n    // refs can't be overridden; the compose path defers instead (above).\n    const fsGuard = deferRuleName !== undefined\n      ? `/*@FS:${deferRuleName}:${codeV}@*/true`\n      : needsFirstSetGuard(p)\n        ? firstSetCond(codeV, p._meta.firstSet)\n        : (() => {\n            if (p._meta.firstSet.kind !== 'any' || matchesEmpty(p)) return null\n            const deep = firstSetOf(p)\n            return deep.kind === 'ranges' ? firstSetCond(codeV, deep) : null\n          })()\n\n    // Gate: register predicate in mapFns; condition guards entire arm attempt\n    let gateCond: string | null = null\n    if (gate) {\n      const gateIdx = ctx.mapFns.length\n      ctx.mapFns.push(gate as (v: unknown, span: unknown) => unknown)\n      // Macro path: inline the captured gate source (def.gateSrcs[i]); runtime\n      // compile() has no source \u2192 null (closure in mapFns drives it). Parallel-\n      // length invariant preserved either way.\n      ctx.mapFnSrcs.push(def.gateSrcs?.[i] ?? null)\n      gateCond = `${mfRef(ctx)}[${gateIdx}](_ctx.state)`\n    }\n    const skipCond = gateCond ? `!${resOkV} && ${gateCond}` : `!${resOkV}`\n\n    const armHasAutoNot = !!(autoNot && autoNot.length > 0)\n    const armNeedsRollback = ctx.capturing &&\n      (mayLeavePartialCapture(p) || (armHasAutoNot && capturesLeaf(p)))\n    const armNeedsFieldRollback = armNeedsRollback && parserHasOwnFields(p)\n    const markLeaves = armNeedsRollback ? v(ctx, '_cml') : null\n    const markRaw    = armNeedsRollback ? v(ctx, '_cmr') : null\n    const markTl     = armNeedsRollback ? v(ctx, '_cmtl') : null\n    const markLog    = armNeedsRollback ? v(ctx, '_cmlg') : null\n    const markFields = armNeedsFieldRollback ? v(ctx, '_cmf') : null\n    const rollback   = markLeaves\n      ? captureRestoreBody(markLeaves, markRaw!, markTl!, markLog!, markFields)\n      : ''\n    const failSlot = atStart ? staticFx : '_ctx._fx'\n\n    stmts.push(`${ind0}if (${skipCond}) {`)\n    if (fsGuard) stmts.push(`${ind(ctx)}if (${fsGuard}) {`)\n    ctx.indent += fsGuard ? 2 : 1\n\n    if (markLeaves) {\n      stmts.push(\n        `${ind(ctx)}const ${markLeaves} = _ctx._cstLeaves?.length ?? 0`,\n        `${ind(ctx)}const ${markRaw} = _ctx._cstRawChildren?.length ?? 0`,\n        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog?.length ?? 0`,\n        `${ind(ctx)}const ${markLog} = _ctx._triviaLog?.length ?? 0`,\n        ...(markFields ? [`${ind(ctx)}const ${markFields} = _ctx._fields?.length ?? 0`] : []),\n      )\n    }\n    const { stmts: armStmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos, atStart)\n    stmts.push(...armStmts)\n\n    if (autoNot && autoNot.length > 0) {\n      const anCode = v(ctx, '_anc')\n      const rejectCond = autoNot.map(check =>\n        check.kind === 'firstSet'\n          ? firstSetCond(anCode, check.set)\n          : `input.startsWith(${JSON.stringify(check.value)}, ${endVar})`\n      ).join(' || ')\n      stmts.push(`${ind(ctx)}if (${okVar}) {`)\n      stmts.push(`${ind(ctx)}  const ${anCode} = ${endVar} < input.length ? input.charCodeAt(${endVar}) : -1`)\n      stmts.push(`${ind(ctx)}  if (!(${rejectCond})) {`)\n      stmts.push(`${ind(ctx)}    ${resValV} = ${valVar}`)\n      stmts.push(`${ind(ctx)}    ${resEndV} = ${endVar}`)\n      stmts.push(`${ind(ctx)}    ${resOkV} = true`)\n      stmts.push(`${ind(ctx)}  }`)\n      stmts.push(`${ind(ctx)}}`)\n      stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot} }`)\n      if (rollback) stmts.push(`${ind(ctx)}if (!${resOkV}) { ${rollback} }`)\n    } else {\n      stmts.push(`${ind(ctx)}if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true }`)\n      stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot}${rollback ? `; ${rollback}` : ''} }`)\n    }\n\n    ctx.indent -= fsGuard ? 2 : 1\n    if (fsGuard) stmts.push(`${ind(ctx)}} else { ${slots[i]} = ${staticFx} }`)\n    stmts.push(`${ind0}}`)\n  }\n  const concatExpr = `[${slots.map(s => `...(${s} || [])`).join(', ')}]`\n  stmts.push(...emitIfFail(ctx, `!${resOkV}`, failArrBody(ctx, concatExpr, pos, false)))\n  return { stmts, valueVar: resValV, endVar: resEndV }\n}\n\nfunction emitNonDisjoint(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  strategy: ChoiceStrategy,\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  if (strategy.tag === 'greedyClassify')\n    return emitGreedyClassify(def, strategy.superIndex, ctx, pos)\n  if (strategy.tag === 'literalsLongestFirst')\n    return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos)\n  return emitFirstMatch(def, ctx, pos)\n}\n\n// \u2500\u2500 helpers for emitGreedyClassify / emitLiteralsLongestFirst \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/** Apply transform chain only \u2014 no parsing, value already known. */\n/** Register a map fn, INTERNING by source so identical callbacks (e.g. every\n * balanced()'s merge closure) share one `_mf` slot. Relies on `mapFns` and\n * `mapFnSrcs` staying parallel \u2014 gate/guard/withCtx push a `null` source alongside\n * their `mapFns` entry to preserve that invariant, so interning keeps firing after\n * one of them (a `null` never matches a real source, so their slots are never\n * aliased). */\nfunction pushMapFn(ctx: Ctx, fn: Ctx['mapFns'][number], src: string | null): number {\n  if (src !== null && ctx.mapFns.length === ctx.mapFnSrcs.length) {\n    const hit = ctx.mapFnSrcs.indexOf(src)\n    if (hit !== -1) return hit\n  }\n  const idx = ctx.mapFns.length\n  ctx.mapFns.push(fn)\n  ctx.mapFnSrcs.push(src)\n  return idx\n}\n\nfunction emitTransformChain(p: Combinator<unknown>, baseValue: string, endV: string, startPos: string, ctx: Ctx): ER {\n  const def = p._def\n  if (def.tag === 'transform') {\n    const innerR = emitTransformChain(def.parser, baseValue, endV, startPos, ctx)\n    const fnIdx = pushMapFn(ctx, def.fn, def.fnSrc ?? null)\n    const vv = v(ctx)\n    return {\n      stmts: [...innerR.stmts, `${ind(ctx)}const ${vv} = ${mfRef(ctx)}[${fnIdx}](${innerR.valueVar}, { start: ${startPos}, end: ${endV} })`],\n      valueVar: vv,\n      endVar: endV,\n    }\n  }\n  return { stmts: [], valueVar: baseValue, endVar: endV }\n}\n\n/** Emit a condition that is true iff input matches `litVal` at `pos`. No side effects. */\nfunction emitLiteralCondition(litVal: string, pos: string): string {\n  const len = litVal.length\n  if (len === 0) return 'true'\n  if (len > CHARCODE_CHAIN_MAX) return `input.startsWith(${JSON.stringify(litVal)}, ${pos})`\n  // Short string: charCodeAt checks (same as emitLit)\n  const checks = [`${pos} + ${len} <= input.length`]\n  for (let i = 0; i < len; i++) {\n    const code = litVal.codePointAt(i)!\n    checks.push(`input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ''}) === ${code}`)\n  }\n  return checks.join(' && ')\n}\n\nfunction emitMany(def: Extract<ParserDef, { tag: 'many' | 'oneOrMore' }>, ctx: Ctx, pos: string): ER {\n  // `valueUnused` (markUnusedValues): the array is never observed (this many sits\n  // under a node() that builds from captured children). Skip building it \u2014 the\n  // loop still runs and items self-capture. Value is `undefined` (unread).\n  const wantValue = !def.valueUnused\n  const arrV = v(ctx, '_arr')\n  const curV = v(ctx, '_cur')\n  const stmts: string[] = [\n    ...(wantValue ? [`${ind(ctx)}const ${arrV} = []`] : []),\n    `${ind(ctx)}let ${curV} = ${pos}`,\n  ]\n  // Capture this list's recovery sync at ENTRY: a nested element sequence will\n  // clobber `_ctx._sync` (and doesn't restore it, unlike the interpreter's\n  // finally), so the loop must read its own saved sync, not the live one.\n  const mySyncV = ctx.recovery ? v(ctx, '_mysy') : ''\n  if (ctx.recovery) stmts.push(`${ind(ctx)}const ${mySyncV} = _ctx._sync`)\n\n  if (def.min === 1) {\n    // Inline first mandatory match with early-return on failure\n    const firstR = emit(def.parser, ctx, curV)\n    stmts.push(...firstR.stmts)\n    if (wantValue) stmts.push(`${ind(ctx)}${arrV}.push(${firstR.valueVar})`)\n    stmts.push(`${ind(ctx)}${curV} = ${firstR.endVar}`)\n  }\n\n  stmts.push(`${ind(ctx)}while (${curV} < input.length) {`)\n  ctx.indent++\n\n  // Mirror interpreter repeat.ts \u2014 skip trivia before each iteration. In capture\n  // mode the trivia is committed to rawChildren immediately and rolled back\n  // (array truncation) if the following item doesn't materialize.\n  let itemPos = curV\n  let rollback = ''\n  if (ctx.activeTrivia) {\n    if (ctx.capturing) {\n      const capFn = ensureTriviaCaptureFn(ctx)\n      const markV = v(ctx, '_mk')\n      const markTl = v(ctx, '_mktl')\n      const markLog = v(ctx, '_mklg')\n      const npV = v(ctx, '_np')\n      stmts.push(\n        `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,\n        `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,\n        `${ind(ctx)}const ${npV} = ${capFn}(input, ${curV}, _ctx, 1)`,\n      )\n      itemPos = npV\n      rollback = `if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `\n    } else {\n      const trivFn = ensureTriviaFn(ctx)\n      const npV = v(ctx, '_np')\n      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${curV}, _ctx)`)\n      itemPos = npV\n    }\n  }\n\n  const { stmts: iterStmts, okVar: iterOk, valVar: iterVal, endVar: iterEnd } = emitFallible(def.parser, ctx, itemPos, true)\n  stmts.push(...iterStmts)\n  if (ctx.recovery) {\n    // Tolerant recovery (dormant unless `_ctx._tolerant`): an element that fails \u2014\n    // and isn't sitting on the inferred sync token \u2014 is skipped to that token via\n    // the SAME interpreter recoverScan (parity), emitted as a ParseError; the loop\n    // continues. Zero-width progress is still a clean stop.\n    const rrV = v(ctx, '_rr')\n    const exp = hoistExpected(ctx, deriveExpectedArr([def.parser]))\n    stmts.push(\n      `${ind(ctx)}if (!${iterOk}) {`,\n      `${ind(ctx)}  ${rollback}if (_ctx._tolerant && ${mySyncV} !== undefined && !_ctx._rec.at(${mySyncV}, input, ${itemPos}, _ctx)) {`,\n      `${ind(ctx)}    const ${rrV} = _ctx._rec.scan(input, ${itemPos}, _ctx, ${mySyncV}, ${exp})`,\n      ...(wantValue ? [`${ind(ctx)}    ${arrV}.push(${rrV}.error)`] : []),\n      `${ind(ctx)}    _ctx._rec.capture(_ctx, ${rrV}.error)`,\n      `${ind(ctx)}    ${curV} = ${rrV}.end`,\n      `${ind(ctx)}    continue`,\n      `${ind(ctx)}  }`,\n      `${ind(ctx)}  break`,\n      `${ind(ctx)}}`,\n      `${ind(ctx)}if (${iterEnd} <= ${itemPos}) { ${rollback}break }`,\n    )\n  } else {\n    stmts.push(`${ind(ctx)}if (!${iterOk} || ${iterEnd} <= ${itemPos}) { ${rollback}break }`)\n  }\n  if (wantValue) stmts.push(`${ind(ctx)}${arrV}.push(${iterVal})`)\n  stmts.push(`${ind(ctx)}${curV} = ${iterEnd}`)\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n\n  return { stmts, valueVar: wantValue ? arrV : 'undefined', endVar: curV }\n}\n\nfunction emitOptional(def: Extract<ParserDef, { tag: 'optional' }>, ctx: Ctx, pos: string): ER {\n  const valV = v(ctx, '_opt')\n  const endV = v(ctx, '_opte')\n\n  const { stmts: lblStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos, true)\n\n  const ind0 = ind(ctx)\n  const stmts = [\n    ...lblStmts,\n    `${ind0}const ${valV} = ${okVar} ? ${valVar} : null`,\n    `${ind0}const ${endV} = ${okVar} ? ${endVar} : ${pos}`,\n  ]\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\nfunction emitSepBy(_p: Combinator<unknown>, def: Extract<ParserDef, { tag: 'sepBy' }>, ctx: Ctx, pos: string): ER {\n  const arrV = v(ctx, '_arr')\n  const curV = v(ctx, '_cur')\n  const rec = !!ctx.recovery\n  // Recovery sync = the separator's own follow (resync to the next separator) OR the\n  // enclosing delimiter published as _ctx._sync \u2014 captured at ENTRY (element parses\n  // clobber _ctx._sync). The separator sentinel is exact for single-char separators.\n  const mySyncV = rec ? v(ctx, '_mysy') : ''\n  const exp = rec ? hoistExpected(ctx, deriveExpectedArr([def.parser])) : ''\n  const sepSent = rec ? syncSentinelExpr(firstSetOf(def.separator)) : null\n  const scanSync = sepSent ? `_ctx._rec.or(${sepSent}, ${mySyncV})` : mySyncV\n\n  const { stmts: firstStmts, okVar: firstOk, valVar: firstVal, endVar: firstEnd } =\n    emitFallible(def.parser, ctx, pos, true)\n\n  const stmts: string[] = [\n    `${ind(ctx)}const ${arrV} = []`,\n    `${ind(ctx)}let ${curV} = ${pos}`,\n    ...(rec ? [`${ind(ctx)}const ${mySyncV} = _ctx._sync`] : []),\n    ...firstStmts,\n  ]\n\n  // A failed element after a real separator. Strict \u2192 the exact original break\n  // (byte-identical). Tolerant \u2192 skip to the sync, emit a ParseError, and continue\n  // (unless already sitting on the enclosing sync). `originalFail` is that site's\n  // exact strict string (the three sites differ \u2014 braces / rollback).\n  const failItem = (nextOkVar: string, itemPosVar: string, rb: string, originalFail: string): string[] => {\n    if (!rec) return [originalFail]\n    const rr = v(ctx, '_rr')\n    return [\n      `${ind(ctx)}if (!${nextOkVar}) {`,\n      `${ind(ctx)}  if (_ctx._tolerant && ${mySyncV} !== undefined && !_ctx._rec.at(${mySyncV}, input, ${itemPosVar}, _ctx)) {`,\n      `${ind(ctx)}    const ${rr} = _ctx._rec.scan(input, ${itemPosVar}, _ctx, ${scanSync}, ${exp})`,\n      `${ind(ctx)}    ${arrV}.push(${rr}.error); _ctx._rec.capture(_ctx, ${rr}.error); ${curV} = ${rr}.end; continue`,\n      `${ind(ctx)}  }`,\n      `${ind(ctx)}  ${rb}break`,\n      `${ind(ctx)}}`,\n    ]\n  }\n\n  // First element + loop entry. Strict keeps the exact `if (firstOk) { \u2026 while }`\n  // shape (byte-identical). Tolerant recovers a junk first element (unless sitting\n  // on the enclosing sync) and still enters the loop via a `did` flag.\n  if (rec) {\n    const rr0 = v(ctx, '_rr0')\n    const didV = v(ctx, '_did')\n    stmts.push(\n      `${ind(ctx)}let ${didV} = false`,\n      `${ind(ctx)}if (${firstOk}) { ${arrV}.push(${firstVal}); ${curV} = ${firstEnd}; ${didV} = true }`,\n      `${ind(ctx)}else if (_ctx._tolerant && ${mySyncV} !== undefined && !_ctx._rec.at(${mySyncV}, input, ${pos}, _ctx)) {`,\n      `${ind(ctx)}  const ${rr0} = _ctx._rec.scan(input, ${pos}, _ctx, ${scanSync}, ${exp})`,\n      `${ind(ctx)}  ${arrV}.push(${rr0}.error); _ctx._rec.capture(_ctx, ${rr0}.error); ${curV} = ${rr0}.end; ${didV} = true`,\n      `${ind(ctx)}}`,\n      `${ind(ctx)}if (${didV}) {`,\n    )\n    ctx.indent++\n    stmts.push(`${ind(ctx)}while (${curV} < input.length) {`)\n    ctx.indent++\n  } else {\n    stmts.push(`${ind(ctx)}if (${firstOk}) {`)\n    ctx.indent++\n    stmts.push(\n      `${ind(ctx)}${arrV}.push(${firstVal})`,\n      `${ind(ctx)}${curV} = ${firstEnd}`,\n      `${ind(ctx)}while (${curV} < input.length) {`,\n    )\n    ctx.indent++\n  }\n\n  // Mirror interpreter sepBy \u2014 separate rollback marks for pre-sep and post-sep trivia.\n  let sepAtPos = curV\n  if (ctx.activeTrivia) {\n    if (ctx.capturing) {\n      const capFn = ensureTriviaCaptureFn(ctx)\n      const markV = v(ctx, '_mk')\n      const markTl = v(ctx, '_mktl')\n      const markLog = v(ctx, '_mklg')\n      const markLv = v(ctx, '_mklv')\n      const spV = v(ctx, '_sp')\n      // Marks taken BEFORE the separator. If either the separator OR the following\n      // item fails, the whole iteration unwinds to here \u2014 crucially undoing the\n      // separator's own captured leaves (markLv) when the item after it fails.\n      stmts.push(\n        `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,\n        `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,\n        `${ind(ctx)}const ${markLv} = _ctx._cstLeaves ? _ctx._cstLeaves.length : 0`,\n        `${ind(ctx)}const ${spV} = ${capFn}(input, ${curV}, _ctx, 1)`,\n      )\n      sepAtPos = spV\n      const rollbackToSep = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `\n      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true)\n      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}break }`)\n\n      const npV = v(ctx, '_np')\n      stmts.push(`${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx, 1)`)\n      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } =\n        emitFallible(def.parser, ctx, npV, true)\n      stmts.push(\n        ...nextStmts,\n        // item failed \u2192 unwind the separator too, back to the end of the last item\n        ...failItem(nextOk, npV, rollbackToSep, `${ind(ctx)}if (!${nextOk}) { ${rollbackToSep}break }`),\n        `${ind(ctx)}${arrV}.push(${nextVal})`,\n        `${ind(ctx)}${curV} = ${nextEnd}`,\n      )\n    } else {\n      const trivFn = ensureTriviaFn(ctx)\n      const spV = v(ctx, '_sp')\n      stmts.push(`${ind(ctx)}const ${spV} = ${trivFn}(input, ${curV}, _ctx)`)\n      sepAtPos = spV\n      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true)\n      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`)\n\n      const npV = v(ctx, '_np')\n      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${sepEnd}, _ctx)`)\n      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } =\n        emitFallible(def.parser, ctx, npV, true)\n      stmts.push(\n        ...nextStmts,\n        ...failItem(nextOk, npV, '', `${ind(ctx)}if (!${nextOk}) break`),\n        `${ind(ctx)}${arrV}.push(${nextVal})`,\n        `${ind(ctx)}${curV} = ${nextEnd}`,\n      )\n    }\n  } else {\n    // No trivia. Still mark the leaf buffers before the separator so that an item\n    // failing after the separator unwinds the separator's captured leaves too.\n    const markLv = ctx.capturing ? v(ctx, '_mklv') : null\n    const markRw = ctx.capturing ? v(ctx, '_mkrw') : null\n    if (markLv) {\n      stmts.push(\n        `${ind(ctx)}const ${markLv} = _ctx._cstLeaves ? _ctx._cstLeaves.length : 0`,\n        `${ind(ctx)}const ${markRw} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n      )\n    }\n    const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true)\n    stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`)\n    const nextRb = markLv\n      ? `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markRw}; `\n      : ''\n    const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } =\n      emitFallible(def.parser, ctx, sepEnd, true)\n    stmts.push(\n      ...nextStmts,\n      ...failItem(nextOk, sepEnd, nextRb, `${ind(ctx)}if (!${nextOk}) { ${nextRb}break }`),\n      `${ind(ctx)}${arrV}.push(${nextVal})`,\n      `${ind(ctx)}${curV} = ${nextEnd}`,\n    )\n  }\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n\n  return { stmts, valueVar: arrV, endVar: curV }\n}\n\nfunction emitScanTo(\n  def: Extract<ParserDef, { tag: 'scanTo' }>,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const curV   = v(ctx, '_stcur')\n  const foundV = v(ctx, '_stfnd')\n  const stmts: string[] = [\n    `${ind(ctx)}let ${curV} = ${pos}`,\n    `${ind(ctx)}let ${foundV} = false`,\n    `${ind(ctx)}while (${curV} < input.length) {`,\n  ]\n  ctx.indent++\n\n  // Sentinel check and skippers must not emit CST leaves \u2014 they are pure position\n  // probes. Use a non-capturing ctx so their literal()/regex() don't push leaves.\n  const probeCtx: Ctx = { ...ctx, capturing: false, noHoist: true }\n\n  // Sentinel check \u2014 labeled block, no IIFE\n  const { stmts: sentStmts, okVar: sentOk } = emitFallible(def.sentinel, probeCtx, curV)\n  stmts.push(...sentStmts, `${ind(ctx)}if (${sentOk}) { ${foundV} = true; break }`)\n\n  // Skippers \u2014 labeled block per skipper; a failure just means \"not this one\"\n  if (def.skip.length > 0) {\n    const advV = v(ctx, '_stadv')\n    stmts.push(`${ind(ctx)}let ${advV} = false`)\n    for (const skipper of def.skip) {\n      const { stmts: skStmts, okVar: skOk, endVar: skEnd } = emitFallible(skipper, probeCtx, curV)\n      stmts.push(\n        `${ind(ctx)}if (!${advV}) {`,\n        ...skStmts,\n        `${ind(ctx)}  if (${skOk} && ${skEnd} > ${curV}) { ${curV} = ${skEnd}; ${advV} = true }`,\n        `${ind(ctx)}}`,\n      )\n    }\n    stmts.push(`${ind(ctx)}if (!${advV}) ${curV}++`)\n  } else {\n    stmts.push(`${ind(ctx)}${curV}++`)\n  }\n\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n\n  // Fail if sentinel was never found (unless orEOF)\n  if (!def.orEOF) {\n    const sentDef = def.sentinel._def\n    const expectedStr = sentDef.tag === 'literal'\n      ? JSON.stringify([JSON.stringify(sentDef.value)])\n      : `[\"sentinel\"]`\n    stmts.push(...emitIfFail(ctx, `!${foundV}`, failArrBody(ctx, expectedStr, pos)))\n  }\n\n  const valV = v(ctx)\n  stmts.push(`${ind(ctx)}const ${valV} = input.slice(${pos}, ${curV})`)\n  // scanTo records its scanned span as one leaf (matching the interpreter), but\n  // only when it actually consumed something.\n  if (ctx.capturing) {\n    const cap = reindentStmts(emitLeafCapture(ctx, valV, pos, curV), ctx.indent + 1)\n    stmts.push(`${ind(ctx)}if (${curV} > ${pos}) {`, ...cap, `${ind(ctx)}}`)\n  }\n  return { stmts, valueVar: valV, endVar: curV }\n}\n\n/**\n * Negative lookahead. Run the inner parser in a labeled block; if it succeeds,\n * fail; if it fails, succeed consuming nothing (value null, end === pos).\n */\nfunction emitNot(def: Extract<ParserDef, { tag: 'not' }>, ctx: Ctx, pos: string): ER {\n  // not() discards the inner failure (inner failing = not succeeding), so the\n  // inner sub-parse need not record \u2014 swallow it.\n  const { stmts, okVar } = emitFallible(def.parser, ctx, pos, true)\n  // not() fails (at its own pos) when the inner parser SUCCEEDS; the interpreter\n  // reports `not(<innerTag>)` as the expected token \u2014 match that label exactly.\n  const label = JSON.stringify(`not(${def.parser._tag})`)\n  return {\n    stmts: [\n      ...stmts,\n      ...emitIfFail(ctx, okVar, failBody(ctx, label, pos)),\n    ],\n    valueVar: 'null',\n    endVar: pos,\n  }\n}\n\nfunction escapeTokenLiteral(value: string): string {\n  return value.replace(/[\\\\^$.*+?()[\\]{}|]/g, '\\\\$&')\n}\n\nfunction regexMatchesEmpty(source: string, flags: string): boolean {\n  try { return new RegExp(`^(?:${source})$`, flags).test('') }\n  catch { return true }\n}\n\nfunction tokenTerminalSource(p: Combinator<unknown>): { source: string; caseInsensitive: boolean; rawCaseSensitive: string } | null {\n  const def = p._def\n  switch (def.tag) {\n    case 'literal':\n      if (def.value.length === 0) return null\n      return {\n        source: escapeTokenLiteral(def.value),\n        caseInsensitive: def.caseInsensitive,\n        rawCaseSensitive: def.caseInsensitive ? '' : def.value,\n      }\n    case 'regex': {\n      if (def.flags.replace(/i/g, '') !== '') return null\n      if (regexMatchesEmpty(def.source, def.flags)) return null\n      return {\n        source: `(?:${def.source})`,\n        caseInsensitive: def.flags.includes('i'),\n        rawCaseSensitive: def.flags.includes('i') ? '' : def.source,\n      }\n    }\n    default:\n      return null\n  }\n}\n\nfunction tokenSequenceSource(p: Combinator<unknown>): { source: string; flags: string; hasCaseSensitiveLetters: boolean } | null {\n  const def = p._def\n  const parts = def.tag === 'sequence'\n    ? def.parsers.map(tokenTerminalSource)\n    : [tokenTerminalSource(p)]\n  if (parts.some(part => part === null)) return null\n  const typed = parts as Array<{ source: string; caseInsensitive: boolean; rawCaseSensitive: string }>\n  const flags = typed.some(part => part.caseInsensitive) ? 'i' : ''\n  if (flags.includes('i') && typed.some(part => /[A-Za-z]/.test(part.rawCaseSensitive))) return null\n  return {\n    source: typed.map(part => part.source).join(''),\n    flags,\n    hasCaseSensitiveLetters: typed.some(part => /[A-Za-z]/.test(part.rawCaseSensitive)),\n  }\n}\n\nfunction combineTokenRegexSources(parts: Array<{ source: string; flags: string; hasCaseSensitiveLetters: boolean }>): { source: string; flags: string } | null {\n  const flags = parts.some(part => part.flags.includes('i')) ? 'i' : ''\n  if (flags.includes('i') && parts.some(part => part.flags === '' && part.hasCaseSensitiveLetters)) return null\n  return { source: parts.map(part => part.source).join(''), flags }\n}\n\nfunction tokenNullableRegex(def: Extract<ParserDef, { tag: 'token' }>): Extract<ParserDef, { tag: 'regex' }> | null {\n  const inner = def.parser._def\n  if (inner.tag === 'many') {\n    const seq = tokenSequenceSource(inner.parser)\n    if (!seq) return null\n    return { tag: 'regex', source: `(?:${seq.source})*`, flags: seq.flags }\n  }\n  if (inner.tag === 'optional') {\n    const seq = tokenSequenceSource(inner.parser)\n    if (!seq) return null\n    return { tag: 'regex', source: `(?:${seq.source})?`, flags: seq.flags }\n  }\n  if (inner.tag === 'sepBy') {\n    const item = tokenSequenceSource(inner.parser)\n    const sep = tokenSequenceSource(inner.separator)\n    if (!item || !sep) return null\n    const combined = combineTokenRegexSources([item, sep])\n    if (!combined) return null\n    return { tag: 'regex', source: `(?:${item.source}(?:${sep.source}${item.source})*)?`, flags: combined.flags }\n  }\n  return null\n}\n\nfunction emitToken(def: Extract<ParserDef, { tag: 'token' }>, ctx: Ctx, pos: string): ER {\n  const lowered = tokenNullableRegex(def)\n  if (lowered) return emitRegex(lowered, ctx, pos)\n\n  const savedTrivia = ctx.activeTrivia\n  const savedKindLabels = ctx.triviaKindLabels\n  ctx.activeTrivia = undefined\n  ctx.triviaKindLabels = undefined\n  const inner = emitFallible(def.parser, ctx, pos)\n  ctx.activeTrivia = savedTrivia\n  ctx.triviaKindLabels = savedKindLabels\n\n  const i = ind(ctx)\n  const sc = v(ctx, '_tokCh')\n  const sl = v(ctx, '_tokLv')\n  const sr = v(ctx, '_tokRaw')\n  const sv = v(ctx, '_tokTr')\n  const sk = v(ctx, '_tokKinds')\n  const stl = v(ctx, '_tokTl')\n  const sol = v(ctx, '_tokLog')\n  const sb = v(ctx, '_tokBuf')\n  const valV = v(ctx, '_tok')\n\n  return {\n    stmts: [\n      `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${sv} = _ctx.trivia, ${sk} = _ctx.triviaKindLabels, ${stl} = _ctx._cstTriviaLog, ${sol} = _ctx._triviaLog, ${sb} = _ctx._cstBuf`,\n      `${i}_ctx.trivia = undefined; _ctx.triviaKindLabels = undefined; _ctx._cstChildren = undefined; _ctx._cstLeaves = undefined; _ctx._cstRawChildren = undefined; _ctx._cstTriviaLog = undefined; _ctx._triviaLog = undefined; _ctx._cstBuf = undefined`,\n      `${i}try {`,\n      ...reindentStmts(inner.stmts, ctx.indent + 1).map(stmt => stmt.replace(/^(\\s*)(?:const|let)\\s+/, '$1var ')),\n      `${i}} finally {`,\n      `${i}  _ctx.trivia = ${sv}; _ctx.triviaKindLabels = ${sk}; _ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx._cstTriviaLog = ${stl}; _ctx._triviaLog = ${sol}; _ctx._cstBuf = ${sb}`,\n      `${i}}`,\n      ...emitIfFail(ctx, `!${inner.okVar}`, propagateFailBody(ctx)),\n      `${i}const ${valV} = input.slice(${pos}, ${inner.endVar})`,\n      ...emitLeafCapture(ctx, valV, pos, inner.endVar),\n    ],\n    valueVar: valV,\n    endVar: inner.endVar,\n  }\n}\n\n/**\n * CST node rule. Collects the inner parse's terminals/trivia into fresh local\n * arrays (capture is emitted inline by the terminals while capChildren is set),\n * calls the build fn, then records the node in the enclosing node()'s collectors.\n */\nfunction emitNode(def: Extract<ParserDef, { tag: 'node' }>, ctx: Ctx, pos: string): ER {\n  if (def.type === undefined) {\n    throw new Error('node(): inferred node type requires a rules() key; pass node(\"Type\", parser) outside rules()')\n  }\n  // A STRUCTURAL node has no own build \u2014 it builds via the `ctx.build` host at\n  // parse time, else a default positioned CST. No build fn is captured.\n  const structural = def.build === undefined\n  const mkType = structural ? null : analyzeMkInlineBuild(def)\n  let buildIdx: number | null = null\n  if (!mkType && !structural) {\n    buildIdx = ctx.buildFns.length\n    ctx.buildFns.push(def.build!)\n    ctx.buildSrcs.push(def.buildSrc ?? null)\n  }\n  const i = ind(ctx)\n\n  // Arity-gated elision: when the build provably never reads the trivia (4th) or\n  // state (5th) arg, skip that capture entirely. The mk-inline path reads\n  // `tlV.length` for `localTriviaLen`, so it always keeps trivia capture.\n  //\n  // A STRUCTURAL node builds via the injected `_ctx.build` host, whose arity is\n  // only known at parse time \u2014 so instead of defensively capturing both (the old\n  // behaviour), gate on what the host reads via the `_hostReads` helper (memoized\n  // once per parse on `_ctx._pmCapTL`/`_pmCapST`). Host sig is\n  // `(type, children, fields, span, rawChildren, triviaLog, state)`: not reading arg 5\n  // (index) means no trivia log, arg 6 means no state (when no host, the default\n  // CST embeds `state` \u2192 keep the clone). `_hostReads` is conservative \u2014 a\n  // rest/default param or `arguments` forces full capture, so a spread host never\n  // silently loses data. jess hosts can ask for fields with arity 3 while trivia/state stay dead\n  // (the cstTriviaLog per-token push dominates \u2014 ~28% of a real jess parse).\n  const capturesTrivia = mkType !== null || (!structural && buildReadsTrivia(def))\n  const clonesState = !structural && buildReadsState(def)\n  const hasFields = parserHasOwnFields(def.parser)\n  const capturesFields = hasFields && !structural && buildReadsFields(def)\n\n  const chV = v(ctx, '_ch')\n  const rawV = v(ctx, '_raw')\n  const capTLv = structural ? v(ctx, '_ctl') : null\n  const capSTv = structural ? v(ctx, '_cst') : null\n  const capFv = structural && hasFields ? v(ctx, '_cf') : null\n  const tlV = capturesTrivia || structural ? v(ctx, '_tl') : '_EMPTY_TL'\n  if (!capturesTrivia) ctx.needsEmptyTl = true\n  const sc = v(ctx, '_sc'), sl = v(ctx, '_sl'), sr = v(ctx, '_sr'), st = v(ctx, '_st'), stl = v(ctx, '_stl')\n  // Per-node-type trivia-kind mask (structural/host nodes only): a host may want\n  // one node type captured comments-only and another whitespace-and-all. Scoped\n  // here and restored after the inner parse, exactly like captureTrivia/_cstTriviaLog.\n  const smk = structural ? v(ctx, '_smk') : null\n  if (structural) ctx.needsHostReads = true\n  const hostTriviaGate = `_ctx.build !== undefined && (_ctx.build._parsemanCaptureTrivia !== undefined ? _ctx.build._parsemanCaptureTrivia(${JSON.stringify(def.type)}) : (_ctx._pmCapTL ??= _hostReads(_ctx.build, 5)))`\n  const allocStmt = structural\n    ? `${i}const ${capTLv} = ${hostTriviaGate}, ${capSTv} = _ctx._pmCapST ??= (_ctx.build === undefined || _hostReads(_ctx.build, 6))${capFv ? `, ${capFv} = _ctx.build !== undefined && _hostReads(_ctx.build, 2)` : ''}\\n`\n      + `${i}const ${chV} = [], ${rawV} = [], ${tlV} = ${capTLv} ? [] : _EMPTY_TL`\n    : capturesTrivia\n      ? `${i}const ${chV} = [], ${rawV} = [], ${tlV} = []`\n      : `${i}const ${chV} = [], ${rawV} = []`\n  // When not capturing, set _ctx._cstTriviaLog = undefined so inner trivia terminals'\n  // `if (_ctx._cstTriviaLog !== undefined)` guard short-circuits (no per-token push).\n  const innerTl = structural ? `${capTLv} ? ${tlV} : undefined` : capturesTrivia ? tlV : 'undefined'\n  const fieldsOn = structural ? (capFv ?? 'false') : capturesFields ? 'true' : 'false'\n  const sf = hasFields ? v(ctx, '_sf') : null\n  const fArr = hasFields ? v(ctx, '_fa') : null\n  const fObj = hasFields ? v(ctx, '_fields') : 'undefined'\n  const stmts: string[] = [\n    allocStmt,\n    `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${st} = _ctx.captureTrivia, ${stl} = _ctx._cstTriviaLog${smk ? `, ${smk} = _ctx._triviaCaptureMask` : ''}${sf ? `, ${sf} = _ctx._fields` : ''}`,\n    `${i}_ctx._cstChildren = ${chV}; _ctx._cstLeaves = ${chV}; _ctx._cstRawChildren = ${rawV}; _ctx.captureTrivia = true; _ctx._cstTriviaLog = ${innerTl}${smk ? `; _ctx._triviaCaptureMask = ${capTLv} && _ctx.build._parsemanTriviaKinds !== undefined ? _ctx.build._parsemanTriviaKinds(${JSON.stringify(def.type)}) : ${smk}` : ''}${sf ? `; _ctx._fields = ${fieldsOn} ? [] : undefined` : ''}`,\n  ]\n  const { stmts: innerStmts, okVar, endVar } = emitFallible(def.parser, ctx, pos)\n  stmts.push(...innerStmts)\n  if (sf && fArr) {\n    stmts.push(`${i}const ${fArr} = _ctx._fields`)\n  }\n  stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx.captureTrivia = ${st}; _ctx._cstTriviaLog = ${stl}${smk ? `; _ctx._triviaCaptureMask = ${smk}` : ''}${sf ? `; _ctx._fields = ${sf}` : ''}`)\n  // node() returns the inner failure verbatim (interpreter parity) \u2014 propagate\n  // the recorded deepest failure, not a coarse [\"node\"] at the node's start.\n  stmts.push(...emitIfFail(ctx, `!${okVar}`, propagateFailBody(ctx)))\n\n  let stV = 'undefined'\n  if (structural) {\n    stV = v(ctx, '_nst')\n    stmts.push(`${i}const ${stV} = ${capSTv} && _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`)\n  } else if (clonesState) {\n    stV = v(ctx, '_nst')\n    stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`)\n  }\n  if (sf && fArr) {\n    const fe = v(ctx, '_fe')\n    const cur = v(ctx, '_fc')\n    stmts.push(\n      `${i}let ${fObj} = undefined`,\n      `${i}if (${fArr} && ${fArr}.length) {`,\n      `${i}  ${fObj} = {}`,\n      `${i}  for (const ${fe} of ${fArr}) {`,\n      `${i}    const ${cur} = ${fObj}[${fe}.name], _entry = { value: ${fe}.value, span: ${fe}.span }`,\n      `${i}    if (${cur} === undefined) ${fObj}[${fe}.name] = _entry`,\n      `${i}    else if (Array.isArray(${cur})) ${cur}.push(_entry)`,\n      `${i}    else ${fObj}[${fe}.name] = [${cur}, _entry]`,\n      `${i}  }`,\n      `${i}}`,\n    )\n  }\n  const ndV = v(ctx, '_nd')\n  // A structural node's own \"builder\" is a default positioned CST; a built node's\n  // is its inline-mk expr or captured build fn.\n  const buildExpr = structural\n    ? `{ _tag: 'node', type: ${JSON.stringify(def.type)}, span: { start: ${pos}, end: ${endVar} }, state: ${stV} ?? null, children: ${chV} }`\n    : mkType\n      ? emitInlineMkNodeExpr(mkType, chV, rawV, pos, endVar, tlV)\n      : `${buildRef(ctx)}[${buildIdx!}](${chV}, ${fObj}, { start: ${pos}, end: ${endVar} }, ${rawV}, ${tlV}, ${stV})`\n  // Modes (RULE_ABI_PLAN \u00A77): a per-parse `_ctx.build` host (keyed by node type)\n  // may override construction \u2014 so ONE fused grammar serves eval-AST vs\n  // positioned-CST modes. Emitted when `ctx.ns` (linkable) OR for a structural\n  // node (whose whole point is the injected host). A built standalone node stays\n  // byte-identical (no `_ctx.build` branch).\n  const ndExpr = ctx.ns || structural\n    ? `_ctx.build !== undefined ? _ctx.build(${JSON.stringify(def.type)}, ${chV}, ${fObj}, { start: ${pos}, end: ${endVar} }, ${rawV}, ${tlV}, ${stV}) : (${buildExpr})`\n    : buildExpr\n  // unwrap/collapse: a single captured child IS the value; unwrap turns a leaf\n  // into its string, collapse returns the child exactly. Mirrors node.ts.\n  const hostCollapseExpr = (ctx.ns || structural)\n    ? `_ctx.build !== undefined && _ctx.build._parsemanCstCollapse !== undefined && ${chV}.length === 1 && ${rawV}.length === 1 && _ctx.build._parsemanCstCollapse(${JSON.stringify(def.type)}, ${chV}[0], ${chV}, ${rawV}) ? ${chV}[0] : (${ndExpr})`\n    : ndExpr\n  const unwrapExpr = `${chV}.length === 1 ? (${chV}[0] !== null && typeof ${chV}[0] === 'object' && ${chV}[0]._tag === 'leaf' ? ${chV}[0].value : ${chV}[0]) : (${ndExpr})`\n  const collapseExpr = `${chV}.length === 1 ? ${chV}[0] : (${ndExpr})`\n  const finalExpr = def.unwrap\n    ? unwrapExpr\n    : def.collapse\n      ? collapseExpr\n    : hostCollapseExpr\n  stmts.push(\n    `${i}const ${ndV} = ${finalExpr}`,\n    `${i}if (${sc}) ${sc}.push(${ndV})`,\n    `${i}if (${sr}) ${sr}.push((typeof ${ndV} === 'object' && ${ndV} !== null && (${ndV}._tag === 'node' || ${ndV}._tag === 'leaf' || ${ndV}._tag === 'parseError')) ? ${ndV} : { _tag: 'leaf', value: typeof ${ndV} === 'string' ? ${ndV} : '', span: { start: ${pos}, end: ${endVar} } })`,\n  )\n\n  return { stmts, valueVar: ndV, endVar }\n}\n\nfunction emitRuntimeFallback(parser: Combinator<unknown>, ctx: Ctx, pos: string): ER {\n  const idx = ctx.runtimeParsers.length\n  ctx.runtimeParsers.push(parser)\n  const rv = v(ctx, '_rt')\n  const vv = v(ctx, '_rtv')\n  const ev = v(ctx, '_rte')\n  // The runtime parser IS the real combinator, so its result is exactly the\n  // interpreter's \u2014 record its failure payload and propagate it verbatim (only\n  // when a consumer will read it).\n  const failStmt = ctx.failLabel\n    ? (ctx.recordFail\n        ? `{ _ctx._fe = ${rv}.span.start; _ctx._fx = ${rv}.expected; break ${ctx.failLabel} }`\n        : `break ${ctx.failLabel}`)\n    : `return { ok: false, expected: ${rv}.expected, span: ${rv}.span }`\n  const stmts = [\n    `${ind(ctx)}const ${rv} = _rp[${idx}].parse(input, ${pos}, _ctx)`,\n    ...emitIfFail(ctx, `!${rv}.ok`, failStmt),\n    `${ind(ctx)}const ${vv} = ${rv}.value`,\n    `${ind(ctx)}const ${ev} = ${rv}.span.end`,\n  ]\n  return { stmts, valueVar: vv, endVar: ev }\n}\n\n/**\n * Compile a lazy/ref parser into a named function declaration.\n *\n * The named function is registered in ctx.namedParsers BEFORE its body is\n * emitted. This breaks the recursion cycle: when the body emitter encounters\n * the same ref again it finds it already registered and emits a call instead\n * of recursing infinitely.\n *\n * All named functions share the parent function's scope (via closure), so they\n * can read _rp, _mf, and all hoisted regex consts without extra args.\n *\n * JavaScript hoists function declarations within a function body, so the order\n * we push to namedFnDecls doesn't affect correctness.\n */\nfunction emitLazy(p: Combinator<unknown>, def: Extract<ParserDef, { tag: 'lazy' }>, ctx: Ctx, pos: string): ER {\n  // Single-use, non-recursive ref: inline its body at this call site instead\n  // of hoisting a named function nobody else calls. Uses the CURRENT ctx\n  // indent/failLabel (unlike the named-function path below, which resets\n  // both for a fresh function scope) \u2014 the resolved combinator is emitted\n  // exactly as if the grammar author had written it inline directly.\n  // A named rule (in the rule map) is NEVER inlined: it must stay a standalone\n  // `_r_<Name>` function so it's addressable and overridable by name (the\n  // linkable/fusable form). Only private (non-map) single-use refs inline.\n  const canonical = ctx.ruleNames?.get(p)\n  const usage = ctx.lazyUsage\n  if (!canonical && usage && (usage.counts.get(p) ?? 0) <= 1 && !usage.recursive.has(p)) {\n    let resolved: Combinator<unknown>\n    try {\n      resolved = def.thunk()\n    } catch {\n      return emitRuntimeFallback(p, ctx, pos)\n    }\n    return emit(resolved, ctx, pos)\n  }\n\n  if (!ctx.namedParsers.has(p)) {\n    const fnName = canonical ?? `${nsp(ctx)}_pf${ctx.namedParsers.size}`\n    ctx.namedParsers.set(p, fnName)   // register FIRST so recursive refs see it\n\n    let resolved: Combinator<unknown>\n    try {\n      resolved = def.thunk()\n    } catch {\n      // ref.define() not called yet \u2014 fall back to runtime\n      ctx.namedParsers.delete(p)\n      return emitRuntimeFallback(p, ctx, pos)\n    }\n\n    const savedIndent    = ctx.indent\n    const savedFailLabel = ctx.failLabel\n    const savedRecord    = ctx.recordFail\n    ctx.indent    = 1\n    ctx.failLabel = '_pfail'  // failures break _pfail (labeled block in fn body)\n    // A named fn is compiled ONCE but shared across every call site, so its body\n    // must always record `_ctx._fx` \u2014 the caller (emitNamedFnCall) decides via\n    // its own recordFail whether to propagate. Baking the first caller's\n    // (possibly swallowed) recordFail into the shared body would leave `_ctx._fx`\n    // unset for other callers that DO read it.\n    ctx.recordFail = true\n    const r = emit(resolved, ctx, '_pos')\n    ctx.indent    = savedIndent\n    ctx.failLabel = savedFailLabel\n    ctx.recordFail = savedRecord\n\n    pushNamedFnDecl(ctx, fnName, r.stmts, r.valueVar, r.endVar)\n  }\n\n  const fnName = ctx.namedParsers.get(p)!\n  return emitNamedFnCall(ctx, fnName, pos)\n}\n\n// \u2500\u2500 recover: try inner; on failure scan to sentinel, emit ParseError node \u2500\u2500\u2500\u2500\nfunction emitRecover(def: Extract<ParserDef, { tag: 'recover' }>, ctx: Ctx, pos: string): ER {\n  const { stmts: innerStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos)\n\n  const ind0  = ind(ctx)\n  const scanV = v(ctx, '_sc')\n  const errV  = v(ctx, '_err')\n\n  // Sentinel check runs inside the while loop.\n  const whileBodyLevels = ctx.indent + 2\n  const { stmts: sentStmts, okVar: sentOk } = emitFallible(def.sentinel, ctx, scanV)\n\n  const stmts: string[] = [\n    ...innerStmts,\n    `${ind0}if (!${okVar}) {`,\n    `${ind0}  let ${scanV} = ${pos}`,\n    `${ind0}  while (${scanV} < input.length) {`,\n    ...reindentStmts(sentStmts, whileBodyLevels),\n    `${ind0}    if (${sentOk}) break`,\n    `${ind0}    ${scanV}++`,\n    `${ind0}  }`,\n    `${ind0}  const ${errV} = { _tag: 'parseError', span: { start: ${pos}, end: ${scanV} }, expected: ${JSON.stringify(deriveExpected(def.parser))} }`,\n    `${ind0}  if (_ctx._errors) _ctx._errors.push(${errV})`,\n    `${ind0}  ${valVar} = ${errV}`,\n    `${ind0}  ${endVar} = ${scanV}`,\n    `${ind0}  ${okVar} = true`,\n    `${ind0}}`,\n  ]\n  return { stmts, valueVar: valVar, endVar }\n}\n\n// \u2500\u2500 expect: try inner; on failure record a ParseError + recover in place \u2500\u2500\u2500\u2500\u2500\nfunction emitExpect(def: Extract<ParserDef, { tag: 'expect' }>, ctx: Ctx, pos: string): ER {\n  const { stmts: innerStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos)\n  const ind0 = ind(ctx)\n  const errV = v(ctx, '_err')\n  const stmts: string[] = [\n    ...innerStmts,\n    `${ind0}if (!${okVar}) {`,\n    `${ind0}  const ${errV} = { _tag: 'parseError', span: { start: ${pos}, end: ${pos} }, expected: ${JSON.stringify(def.expected)} }`,\n    `${ind0}  if (_ctx._errors) _ctx._errors.push(${errV})`,\n    // Embed the missing-token error as a `parseError` CST child, mirroring the\n    // interpreter (expect.ts) and the list-recovery emit sites \u2014 guarded on\n    // `_ctx._tolerant`, under which the driver always installs `_ctx._rec`.\n    `${ind0}  if (_ctx._tolerant) _ctx._rec.capture(_ctx, ${errV})`,\n    `${ind0}  ${valVar} = ${errV}`,\n    `${ind0}  ${endVar} = ${pos}`,\n    `${ind0}  ${okVar} = true`,\n    `${ind0}}`,\n  ]\n  return { stmts, valueVar: valVar, endVar }\n}\n\n// ---------------------------------------------------------------------------\n// Main dispatch\n// ---------------------------------------------------------------------------\n\n/**\n * Object-identity de-duplication wrapper around `emitDispatch`. A COMPOUND\n * combinator referenced from more than one place (a shared `const value =\n * choice(...)`, or a sub-parser reached from two positions within one rule) is\n * emitted ONCE as a private named function and CALLED at every reference \u2014\n * instead of pasting its full lowered body at each site, which multiplies\n * combinatorially through nested `many`/`sepBy`/`sequence`. Mirrors emitLazy's\n * named-function path (same `_pf` naming, same recordFail/scope reset). Leaf\n * terminals and `lazy` refs are handled elsewhere; named rules keep their own\n * `_r_<Name>` path; probe/ trivia-capture contexts opt out (see `noHoist`).\n */\nfunction emit(p: Combinator<unknown>, ctx: Ctx, pos: string): ER {\n  const usage = ctx.lazyUsage\n  if (\n    usage &&\n    !ctx.noHoist &&\n    !ctx.capAsTrivia &&\n    !ctx.ruleNames?.has(p) &&\n    isHoistableTag(p._def.tag) &&\n    (usage.counts.get(p) ?? 0) > 1 &&\n    // Only hoist subtrees big enough that de-duplicating them beats the call\n    // overhead. A tiny shared wrapper (e.g. `optional(literal(';'))`) inlines\n    // faster than it calls and barely moves the byte count; the size explosion\n    // is all in LARGE choices/sequences referenced from many positions.\n    (usage.sizes.get(p) ?? 0) >= HOIST_MIN_SUBTREE\n  ) {\n    const existing = ctx.namedParsers.get(p)\n    if (existing !== undefined) return emitNamedFnCall(ctx, existing, pos)\n    const fnName = `${nsp(ctx)}_pf${ctx.namedParsers.size}`\n    ctx.namedParsers.set(p, fnName)   // register FIRST (defensive; a compound ref never self-recurses)\n    const savedIndent    = ctx.indent\n    const savedFailLabel = ctx.failLabel\n    const savedRecord    = ctx.recordFail\n    ctx.indent    = 1\n    ctx.failLabel = '_pfail'  // failures break _pfail (labeled block in the fn body)\n    ctx.recordFail = true     // shared body always records; each caller decides propagation\n    const r = emitDispatch(p, ctx, '_pos')\n    ctx.indent    = savedIndent\n    ctx.failLabel = savedFailLabel\n    ctx.recordFail = savedRecord\n    pushNamedFnDecl(ctx, fnName, r.stmts, r.valueVar, r.endVar)\n    return emitNamedFnCall(ctx, fnName, pos)\n  }\n  return emitDispatch(p, ctx, pos)\n}\n\nfunction emitDispatch(p: Combinator<unknown>, ctx: Ctx, pos: string): ER {\n  const def = p._def\n  switch (def.tag) {\n    case 'literal':   return emitLit(def, ctx, pos)\n    case 'regex':     return emitRegex(def, ctx, pos)\n    case 'keywords':  return emitKeywords(def, ctx, pos)\n    case 'sequence':  return emitSeq(def, ctx, pos)\n    case 'choice':    return emitChoice(def, ctx, pos)\n    case 'many':\n    case 'oneOrMore': return emitMany(def, ctx, pos)\n    case 'optional':  return emitOptional(def, ctx, pos)\n    case 'sepBy':     return emitSepBy(p, def, ctx, pos)\n    case 'transform': {\n      const fnSrc = transformFnSource(def.fn, def.fnSrc)\n      if (fnSrc && def.parser._def.tag === 'sequence') {\n        const seqR = emitSeqValues(def.parser._def, ctx, pos)\n        const inlined = tryInlineDestructureTransform(fnSrc, seqR.valueVars)\n        if (inlined) {\n          const mv = v(ctx, '_mapped')\n          return {\n            stmts: [...seqR.stmts, `${ind(ctx)}const ${mv} = ${inlined}`],\n            valueVar: mv,\n            endVar: seqR.endVar,\n          }\n        }\n      }\n      const inner = emit(def.parser, ctx, pos)\n      if (fnSrc) {\n        const unary = tryInlineUnaryTransform(fnSrc, inner.valueVar)\n        if (unary) {\n          const mv = v(ctx, '_mapped')\n          return {\n            stmts: [...inner.stmts, `${ind(ctx)}const ${mv} = ${unary}`],\n            valueVar: mv,\n            endVar: inner.endVar,\n          }\n        }\n      }\n      const fnIdx = pushMapFn(ctx, def.fn, def.fnSrc ?? null)\n      const mv = v(ctx, '_mapped')\n      return {\n        stmts: [\n          ...inner.stmts,\n          `${ind(ctx)}const ${mv} = ${mfRef(ctx)}[${fnIdx}](${inner.valueVar}, { start: ${pos}, end: ${inner.endVar} })`,\n        ],\n        valueVar: mv,\n        endVar: inner.endVar,\n      }\n    }\n    case 'skip': {\n      const mainR = emit(def.main, ctx, pos)\n      const skipR = emit(def.skipped, ctx, mainR.endVar)\n      // skipped is optional \u2014 if it fails we just keep main's end\n      const endV = v(ctx, '_skipe')\n      return {\n        stmts: [\n          ...mainR.stmts,\n          // try skipped; if fails, keep main end\n          `${ind(ctx)}let ${endV} = ${mainR.endVar}`,\n          `${ind(ctx)}try {`,\n          ...reindentStmts(skipR.stmts, ctx.indent + 1),\n          `${ind(ctx)}  ${endV} = ${skipR.endVar}`,\n          `${ind(ctx)}} catch {}`,\n        ],\n        valueVar: mainR.valueVar,\n        endVar: endV,\n      }\n    }\n    case 'lazy':     return emitLazy(p, def, ctx, pos)\n    case 'trivia':   return emit(def.parser, ctx, pos)\n    case 'token':    return emitToken(def, ctx, pos)\n    case 'label': {\n      const inner = emitFallible(def.parser, ctx, pos)\n      return {\n        stmts: [\n          ...inner.stmts,\n          ...emitIfFail(ctx, `!${inner.okVar}`, failBody(ctx, JSON.stringify(def.label), '_ctx._fe')),\n        ],\n        valueVar: inner.valVar,\n        endVar: inner.endVar,\n      }\n    }\n    case 'field': {\n      const inner = emit(def.parser, ctx, pos)\n      return {\n        stmts: [\n          ...inner.stmts,\n          `${ind(ctx)}if (_ctx._fields) _ctx._fields.push({ name: ${JSON.stringify(def.name)}, value: ${inner.valueVar}, span: { start: ${pos}, end: ${inner.endVar} } })`,\n        ],\n        valueVar: inner.valueVar,\n        endVar: inner.endVar,\n      }\n    }\n    case 'grammar': {\n      const savedTrivia = ctx.activeTrivia\n      const savedKindLabels = ctx.triviaKindLabels\n      if (def.clearTrivia) {\n        // noTrivia / parser({ trivia: null }): contiguous terms, no trivia skipped.\n        ctx.activeTrivia = undefined\n        ctx.triviaKindLabels = undefined\n      } else if (def.triviaParser) {\n        ctx.activeTrivia = def.triviaParser\n        if (def.triviaParser._meta.triviaKindLabels) {\n          ctx.triviaKindLabels = def.triviaParser._meta.triviaKindLabels\n        }\n      }\n      const r = emit(def.parser, ctx, pos)\n      ctx.activeTrivia = savedTrivia\n      ctx.triviaKindLabels = savedKindLabels\n      return r\n    }\n    case 'not':     return emitNot(def, ctx, pos)\n    case 'node':    return emitNode(def, ctx, pos)\n    case 'scanTo':  return emitScanTo(def, ctx, pos)\n    case 'recover': return emitRecover(def, ctx, pos)\n    case 'expect':  return emitExpect(def, ctx, pos)\n    case 'guard': {\n      const fnIdx = ctx.mapFns.length\n      ctx.mapFns.push(def.predicate as (v: unknown, span: unknown) => unknown)\n      // Macro path: inline the captured predicate source; runtime compile() \u2192 null.\n      ctx.mapFnSrcs.push(def.predSrc ?? null)\n      const vv = v(ctx)\n      return {\n        stmts: [\n          ...emitIfFail(ctx, `!${mfRef(ctx)}[${fnIdx}](_ctx.state)`, failBody(ctx, '\"gate\"', pos)),\n          `${ind(ctx)}const ${vv} = null`,\n        ],\n        valueVar: vv,\n        endVar: pos,\n      }\n    }\n    case 'withCtx': {\n      // Store getter for extra value \u2014 _mf[N]() returns the captured value.\n      const evIdx = ctx.mapFns.length\n      const extra = def.extra\n      ctx.mapFns.push((() => extra) as (v: unknown, span: unknown) => unknown)\n      // Macro path: inline the captured `extra` as a getter `() => (extra)` so\n      // `_mf[evIdx]()` returns the value; runtime compile() \u2192 null (closure above).\n      ctx.mapFnSrcs.push(def.extraSrc !== undefined ? `() => (${def.extraSrc})` : null)\n\n      // Wrap inner parser as a named function so it receives _ctx as a parameter.\n      // That lets us call it with a modified ctx (user changed) without polluting\n      // the outer _ctx variable for subsequent emits.\n      const innerParser = def.parser as Combinator<unknown>\n      if (!ctx.namedParsers.has(innerParser)) {\n        const fnName = `_wcf${ctx.namedParsers.size}`\n        ctx.namedParsers.set(innerParser, fnName)\n        const savedIndent    = ctx.indent\n        const savedFailLabel = ctx.failLabel\n        const savedRecord    = ctx.recordFail\n        ctx.indent    = 1\n        ctx.failLabel = '_pfail'  // failures break _pfail (same as emitLazy)\n        ctx.recordFail = true     // shared body always records (see emitLazy)\n        const innerR = emit(innerParser, ctx, '_pos')\n        ctx.indent    = savedIndent\n        ctx.failLabel = savedFailLabel\n        ctx.recordFail = savedRecord\n        pushNamedFnDecl(ctx, fnName, innerR.stmts, innerR.valueVar, innerR.endVar)\n      }\n      const fn = ctx.namedParsers.get(innerParser)!\n\n      const rv = v(ctx, '_wcr')\n      const vv = v(ctx, '_wcv')\n      const ev = v(ctx, '_wce')\n      return {\n        stmts: [\n          `${ind(ctx)}const ${rv} = { ..._ctx, state: ${mfRef(ctx)}[${evIdx}]() }`,\n          `${ind(ctx)}const ${vv} = ${fn}(input, ${pos}, ${rv})`,\n          // withCtx runs on a spread child ctx \u2014 copy its recorded failure back\n          // and propagate the inner failure verbatim (interpreter parity).\n          ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, propagateFailBody(ctx, rv)),\n          `${ind(ctx)}const ${ev} = ${NAMED_FN_END}`,\n        ],\n        valueVar: vv,\n        endVar: ev,\n      }\n    }\n    default:         return emitRuntimeFallback(p, ctx, pos)\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\nexport type CompiledParser<T> = {\n  parse(input: string, pos?: number): ParseResult<T>\n  /** Like parse(), but with a caller-supplied ParseContext (e.g. `_triviaLog` for CST grammars). */\n  parseWithContext(input: string, ctx: ParseContext, pos?: number): ParseResult<T>\n  /**\n   * Like parse(), but activates the error-collection channel. Recovery points\n   * (expect()) collect their ParseErrors into result.errors instead of only\n   * embedding them as values. Always returns ParseOk \u2014 top-level failures are\n   * still ParseFail.\n   */\n  parseWithErrors(input: string, pos?: number): ParseResult<T> & { errors: ParseError[] }\n  /** The generated source (for inspection / future source maps) */\n  source: string\n  /**\n   * A self-contained JS expression (IIFE) that evaluates to a parse function.\n   * Safe to inline directly into transformed source \u2014 no external references\n   * except for runtime-fallback parsers embedded via closures.\n   * Returns null if the parser cannot be fully inlined (e.g. contains user\n   * closures that can't be serialized).\n   */\n  inlineExpression: string | null\n}\n\n/**\n * Does this combinator tree contain a node() anywhere (following ref/lazy\n * thunks)? Determines whether the compile emits CST capture \u2014 so non-node\n * grammars stay byte-identical. `seen` guards against recursion cycles.\n */\nfunction hasNodeDef(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  if (seen.has(p)) return false\n  seen.add(p)\n  const d = p._def\n  switch (d.tag) {\n    case 'node':      return true\n    case 'lazy':      { try { return hasNodeDef(d.thunk(), seen) } catch { return false } }\n    case 'grammar':\n    case 'trivia':\n    case 'token':\n    case 'label':\n    case 'field':\n    case 'optional':\n    case 'many':\n    case 'oneOrMore':\n    case 'not':\n    case 'transform': return hasNodeDef(d.parser, seen)\n    case 'skip':      return hasNodeDef(d.main, seen) || hasNodeDef(d.skipped, seen)\n    case 'sequence':\n    case 'choice':    return d.parsers.some(x => hasNodeDef(x, seen))\n    case 'sepBy':     return hasNodeDef(d.parser, seen) || hasNodeDef(d.separator, seen)\n    case 'scanTo':    return hasNodeDef(d.sentinel, seen) || d.skip.some(x => hasNodeDef(x, seen))\n    case 'recover':   return hasNodeDef(d.parser, seen) || hasNodeDef(d.sentinel, seen)\n    case 'expect':    return hasNodeDef(d.parser, seen)\n    case 'withCtx':   return hasNodeDef(d.parser, seen)\n    default:          return false\n  }\n}\n\n/** Immediate child combinators of a def, for generic tree walks (childrenOf). */\nfunction childrenOf(def: ParserDef): Combinator<unknown>[] {\n  switch (def.tag) {\n    case 'sequence':\n    case 'choice':    return def.parsers\n    case 'many':\n    case 'optional':\n    case 'transform':\n    case 'trivia':\n    case 'token':\n    case 'label':\n    case 'field':\n    case 'grammar':\n    case 'not':\n    case 'node':\n    case 'withCtx':\n    case 'expect':    return [def.parser]\n    // emitMany's oneOrMore branch and emitSepBy both codegen `def.parser` TWICE\n    // (a mandatory first match, then again inside the repeat loop) \u2014 two real\n    // emit() call sites, so the usage analysis must see two edges here or it\n    // undercounts a single-use `parser` ref as inline-safe when it's actually\n    // referenced from two positions within this one compiled function.\n    case 'oneOrMore': return [def.parser, def.parser]\n    case 'sepBy':     return [def.parser, def.parser, def.separator]\n    case 'skip':      return [def.main, def.skipped]\n    case 'recover':   return [def.parser, def.sentinel]\n    case 'scanTo':    return [def.sentinel, ...def.skip]\n    case 'lazy':\n    case 'literal':\n    case 'regex':\n    case 'keywords':\n    case 'guard':\n    case 'unknown':   return []\n  }\n}\n\n/**\n * Compound combinators worth hoisting into a shared named function when the SAME\n * object is referenced more than once. Leaf terminals (`literal`/`regex`/\n * `keywords`/`guard`) aren't worth a call; `lazy` is owned by emitLazy; the\n * context-bearing wrappers (`grammar`/`trivia`/`label`/`withCtx`/`expect`/`skip`/\n * `recover`/`scanTo`) are excluded so no per-site context (active trivia, capture\n * mode) can be baked into a shared body.\n */\nconst HOISTABLE_TAGS: ReadonlySet<ParserDef['tag']> = new Set<ParserDef['tag']>([\n  'sequence', 'choice', 'many', 'oneOrMore', 'optional', 'sepBy', 'transform', 'node', 'not',\n])\nfunction isHoistableTag(tag: ParserDef['tag']): boolean {\n  return HOISTABLE_TAGS.has(tag)\n}\n\n/** Minimum approximate subtree size (see `subtreeSizes`) for a shared combinator\n * to be hoisted into a named function rather than inlined at each reference.\n * Small enough to catch every real explosion (a value `choice` is ~12+), large\n * enough that trivial shared wrappers stay inline and keep the hot path fast. */\nconst HOIST_MIN_SUBTREE = 3\n\n/**\n * Static-occurrence analysis for `lazy` (ref()) combinators, ahead of codegen.\n * `emitLazy` currently hoists EVERY lazy ref into its own named function\n * (_pfN), even when it's referenced from exactly one place \u2014 necessary for\n * genuinely recursive/shared rules, wasteful for the common case of a `g.foo`\n * helper rule used for grammar readability but only ever called once. On a\n * large mutually-referential grammar (many `g.xxx` helper rules, each used\n * from ~1 call site) this multiplies function count far past the number of\n * rules a grammar author actually wrote \u2014 observed on the Less grammar:\n * ~1700 compiled functions from ~150 source rules, vs a roughly 1:3 ratio on\n * a comparably-sized but flatter grammar.\n *\n * Returns, for every reachable `lazy` combinator: how many static call sites\n * reference it (`counts`), and whether it participates in a reference cycle\n * (`recursive` \u2014 must stay a named function; inlining a cycle would recurse\n * forever). A ref with count <= 1 and no cycle membership is safe to inline\n * directly at its single call site instead of becoming a named function.\n *\n * Traversal cost: each `lazy` ref's body is descended into at most once\n * (subsequent occurrences just bump the counter) \u2014 polynomial in the number\n * of distinct reachable combinators, matching emitLazy's own memoized\n * codegen cost. Non-lazy nodes are walked without memoization, same as\n * `emit()` itself (a directly-shared non-ref subtree \u2014 discouraged by the\n * `g.xxx` convention but not disallowed \u2014 is revisited per occurrence, same\n * cost class as compilation already pays for it today).\n */\ntype LazyUsage = {\n  counts: Map<Combinator<unknown>, number>\n  recursive: Set<Combinator<unknown>>\n  sizes: Map<Combinator<unknown>, number>\n}\n\nfunction analyzeLazyUsage(root: Combinator<unknown>): LazyUsage {\n  return analyzeLazyUsageMulti([root])\n}\n\n/**\n * Memoized approximate subtree size: number of combinator nodes reachable from\n * `p` WITHOUT crossing a `lazy` boundary (a ref counts as 1 leaf \u2014 it lowers to a\n * call, not an inline expansion). This is the size that would be DUPLICATED if the\n * subtree were pasted at another reference, so it's the right quantity to gate\n * hoisting on. Cycles (only possible through a `lazy`, which is a leaf here) can't\n * recur. */\nfunction subtreeSizes(roots: Iterable<Combinator<unknown>>): Map<Combinator<unknown>, number> {\n  const sizes = new Map<Combinator<unknown>, number>()\n  // A node's inline-expansion size: itself + each child's size, but a `lazy` child\n  // counts as 1 (it lowers to a call, so it isn't part of the duplicated bytes).\n  // Never crosses a lazy, so it can't cycle (compound nodes don't cycle alone).\n  const sz = (p: Combinator<unknown>): number => {\n    const cached = sizes.get(p)\n    if (cached !== undefined) return cached\n    const def = p._def\n    let s = 1\n    if (def.tag !== 'lazy') {\n      for (const child of childrenOf(def)) s += child._def.tag === 'lazy' ? 1 : sz(child)\n    }\n    sizes.set(p, s)\n    return s\n  }\n  // Visit crosses lazy boundaries (the roots ARE lazy rule-refs) so every reachable\n  // compound node gets a size entry; sz() then fills the whole non-lazy subtree.\n  const visitedLazy = new Set<Combinator<unknown>>()\n  const visit = (p: Combinator<unknown>): void => {\n    const def = p._def\n    if (def.tag === 'lazy') {\n      if (visitedLazy.has(p)) return\n      visitedLazy.add(p)\n      let resolved: Combinator<unknown>\n      try { resolved = def.thunk() } catch { return }\n      visit(resolved)\n      return\n    }\n    sz(p)\n    for (const child of childrenOf(def)) visit(child)\n  }\n  for (const root of roots) visit(root)\n  return sizes\n}\n\n/**\n * Multi-root variant, for compileRuleMap(): a `rules()` factory's returned\n * map has many top-level entries that legitimately share reachable sub-rules\n * (e.g. `Stylesheet` and `Declaration` both reach `g.valueList`). Walking each\n * entry as its own root into ONE shared counts/descended/active state means a\n * ref's count correctly reflects total usage across the WHOLE rule map \u2014 used\n * once as its own top-level entry AND referenced once internally elsewhere is\n * count 2 (stays a named function, shared correctly), not two independent 1s\n * from two unrelated single-root analyses.\n */\nfunction analyzeLazyUsageMulti(roots: Iterable<Combinator<unknown>>): LazyUsage {\n  const counts = new Map<Combinator<unknown>, number>()\n  const recursive = new Set<Combinator<unknown>>()\n  const descended = new Set<Combinator<unknown>>()\n  const active = new Set<Combinator<unknown>>()\n\n  function walk(p: Combinator<unknown>): void {\n    const def = p._def\n    if (def.tag === 'lazy') {\n      counts.set(p, (counts.get(p) ?? 0) + 1)\n      if (active.has(p)) {\n        recursive.add(p)\n        return\n      }\n      if (descended.has(p)) return\n      descended.add(p)\n      let resolved: Combinator<unknown>\n      try {\n        resolved = def.thunk()\n      } catch {\n        return // ref.define() not called yet \u2014 emitLazy's own try/catch handles this at codegen time\n      }\n      active.add(p)\n      walk(resolved)\n      active.delete(p)\n      return\n    }\n    // A non-lazy COMPOUND combinator shared by object identity (e.g. a\n    // `const value = choice(...)` referenced from several rules, or a sub-parser\n    // reached through nested `many`/`sepBy`) is counted per reference edge, so\n    // codegen can hoist a multiply-referenced subtree into ONE named function\n    // instead of pasting its full lowered body at every reference \u2014 the\n    // multiplication that makes nested value grammars explode. We intentionally do\n    // NOT memoize the descent here: cycle detection for `lazy` relies on fully\n    // traversing every active path (a compound `descended` short-circuit would let\n    // the walker return before re-reaching an active `self` ref and marking it\n    // recursive \u2192 emitLazy would then inline a recursive ref forever). Non-lazy\n    // nodes never form a cycle without passing through a `lazy` (which has its own\n    // active/descended guards), so the re-walk stays finite \u2014 same cost as before.\n    if (isHoistableTag(def.tag)) {\n      counts.set(p, (counts.get(p) ?? 0) + 1)\n    }\n    for (const child of childrenOf(def)) walk(child)\n  }\n\n  const rootsArr = [...roots]\n  for (const root of rootsArr) walk(root)\n  return { counts, recursive, sizes: subtreeSizes(rootsArr) }\n}\n\n/**\n * Dependency manifest for the linkable form: for each rule in the map, the set\n * of OTHER rule names its body references (by name). A referenced rule is a\n * boundary \u2014 we record the edge and do NOT descend into it (its own deps are its\n * own entry). Used by the linker for \u00E0 la carte dep-closure selection and the\n * compose-time name-closure check (every referenced name must resolve in the\n * final set). Self-references are included (a recursive rule depends on itself).\n */\nexport function ruleDependencies(\n  ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>,\n): Map<string, string[]> {\n  const nameOf = new Map<Combinator<unknown>, string>()\n  for (const [name, comb] of ruleMap) nameOf.set(comb, name)\n\n  const deps = new Map<string, string[]>()\n  for (const [name, comb] of ruleMap) {\n    const found = new Set<string>()\n    const seen = new Set<Combinator<unknown>>()\n    const walk = (p: Combinator<unknown>, isRoot: boolean): void => {\n      const def = p._def\n      // A named `ref` (local OR external) is a rule boundary: record the edge and\n      // don't descend. `_ruleName` (set by rules()) also catches EXTERNAL refs \u2014\n      // rules referenced by name but defined in another artifact.\n      const boundary = def.tag === 'lazy'\n        ? ((p as unknown as { _ruleName?: string })._ruleName ?? nameOf.get(p))\n        : nameOf.get(p)\n      if (!isRoot && boundary !== undefined) { found.add(boundary); return }\n      if (seen.has(p)) return\n      seen.add(p)\n      if (def.tag === 'lazy') {\n        let resolved: Combinator<unknown>\n        try { resolved = def.thunk() } catch { return }\n        walk(resolved, false)\n        return\n      }\n      for (const child of childrenOf(def)) walk(child, false)\n    }\n    walk(comb, true)\n    deps.set(name, [...found])\n  }\n  return deps\n}\n\n/**\n * Compile a combinator tree into an optimized parse function at runtime.\n *\n * Uses `new Function` internally, so it will fail in environments with a strict\n * Content Security Policy that omits `'unsafe-eval'`. Prefer the interpreter or\n * macro build plugin in those cases.\n *\n * @see https://www.greadme.com/blog/security/what-is-content-security-policy-complete-guide\n */\nexport function compile<T>(combinator: Combinator<T>, mapFnSources?: string[], opts?: { recovery?: boolean }): CompiledParser<T> {\n  markUnusedValues(combinator)\n  // Grammar-level ambient trivia declared via rules({ trivia }, factory): seed it\n  // as the default activeTrivia so every rule bakes it (unless a local\n  // parser({trivia}) / noTrivia overrides). This is the compiled mirror of the\n  // interpreter installing it as ctx.trivia at the entry.\n  const grammarTrivia = (combinator._meta as { grammarTrivia?: Combinator<unknown> }).grammarTrivia\n  const ctx: Ctx = {\n    vars: 0,\n    indent: 1,\n    regexDecls: [],\n    regexMap: new Map(),\n    expectedDecls: [],\n    expectedMap: new Map(),\n    recordFail: true,\n    mapFns: [],\n    mapFnSrcs: [],\n    buildFns: [],\n    buildSrcs: [],\n    runtimeParsers: [],\n    namedParsers: new Map(),\n    triviaCaptureNames: new Map(),\n    triviaFnNames: new Map(),\n    namedFnDecls: [],\n    capturing: hasNodeDef(combinator as Combinator<unknown>),\n    recovery: opts?.recovery ?? false,\n    lazyUsage: analyzeLazyUsage(combinator as Combinator<unknown>),\n    ...(grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {}),\n  }\n\n  const r = emit(combinator as Combinator<unknown>, ctx, '_pos')\n\n  const namedPrelude = ctx.namedFnDecls.length > 0 ? [...namedFnPrelude(), ''] : []\n  const emptyTlDecls = ctx.needsEmptyTl ? ['const _EMPTY_TL = Object.freeze([])'] : []\n  const hostReadsDecls = ctx.needsHostReads ? [HOST_READS_DECL] : []\n\n  const source = [\n    ...emptyTlDecls,\n    ...hostReadsDecls,\n    ...ctx.regexDecls,\n    ...ctx.expectedDecls,\n    '',\n    ...namedPrelude,\n    ctx.namedFnDecls.join('\\n\\n'),\n    `function _parse(input, _pos, _rp, _mf, _build, _ctx) {`,\n    `  let pos = _pos`,\n    ...r.stmts,\n    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n    `}`,\n  ].join('\\n')\n\n  const fn = new Function('input', '_pos', '_rp', '_mf', '_build', '_ctx', [\n    ...emptyTlDecls,\n    ...hostReadsDecls,\n    ...ctx.regexDecls,\n    ...ctx.expectedDecls,\n    ...namedPrelude,\n    ...ctx.namedFnDecls.flatMap((decl, i) => (i > 0 ? ['', decl] : [decl])),\n    `let pos = _pos`,\n    ...r.stmts,\n    `return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n  ].join('\\n')) as (\n    input: string,\n    pos: number,\n    rp: Array<Combinator<unknown>>,\n    mf: Array<(v: unknown, span: { start: number; end: number }) => unknown>,\n    build: Ctx['buildFns'],\n    ctx: ParseContext,\n  ) => ParseResult<T>\n\n  const defaultCtx: ParseContext = {\n    trackLines: false,\n    ...(ctx.triviaKindLabels ? { triviaKindLabels: ctx.triviaKindLabels } : {}),\n  }\n\n  // Prefer per-def sources captured in codegen-traversal order (set by the\n  // macro via def.fnSrc). Fall back to a caller-provided positional array.\n  // The derived array is only usable when every traversed transform carried a\n  // source \u2014 otherwise we can't inline the closures.\n  const derivedSrcs = ctx.mapFnSrcs.length === ctx.mapFns.length && ctx.mapFnSrcs.every((s): s is string => s !== null)\n    ? ctx.mapFnSrcs as string[]\n    : undefined\n  const effectiveSources = mapFnSources ?? derivedSrcs\n\n  // node() build fns inline the same way: every traversed node must carry its\n  // build source (set by the macro via def.buildSrc) or we can't inline.\n  const buildCovered = ctx.buildFns.length === 0 || ctx.buildSrcs.every((s): s is string => s !== null)\n  const buildSources = ctx.buildFns.length === 0 ? undefined : (ctx.buildSrcs as string[])\n\n  // Build an inline expression when there are no runtime fallbacks, and either\n  // no map-function closures or their source text has been provided for injection.\n  const mfCovered = ctx.mapFns.length === 0 || (effectiveSources !== undefined && effectiveSources.length === ctx.mapFns.length)\n  const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered\n  const inlineExpression: string | null = canInline ? buildInlineExpression(ctx, r, effectiveSources, buildSources) : null\n\n  return {\n    source,\n    inlineExpression,\n    parse(input: string, pos = 0): ParseResult<T> {\n      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, defaultCtx)\n    },\n    parseWithContext(input: string, parseCtx: ParseContext, pos = 0): ParseResult<T> {\n      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, parseCtx)\n    },\n    // Note: collects expect() errors via _errors. Unlike interpreter\n    // parse({recover:true}) it does NOT populate furthestFail \u2014 the compiled path\n    // inlines failures for throughput and deliberately skips _probe bookkeeping.\n    // Callers wanting a furthest-position diagnostic detect unconsumed input\n    // (span.end < input.length) instead, which is mode-agnostic.\n    parseWithErrors(input: string, pos = 0): ParseResult<T> & { errors: ParseError[] } {\n      const errors: ParseError[] = []\n      const result = fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, { ...defaultCtx, _errors: errors })\n      return { ...result, errors } as ParseResult<T> & { errors: ParseError[] }\n    },\n  }\n}\n\n/**\n * Compile every entry of a `rules(factory)` map's returned object using ONE\n * shared codegen Ctx (regexes, named functions, map/build-fn arrays) instead\n * of running `compile()` independently per entry.\n *\n * Why this exists: `compile()` per entry gives each entry its own namedParsers\n * cache, so a sub-rule reachable from N different top-level entries (e.g.\n * `valueList` reachable from `Declaration`, `CustomDeclaration`, `Guard`, \u2026)\n * gets fully re-compiled N times \u2014 on a richly cross-referential grammar\n * (Less: ~125 rule-map entries, deep mutual reference) this multiplies total\n * compiled size far past what the source grammar actually needs, independent\n * of the per-ref single-use inlining `analyzeLazyUsage` already handles\n * within one compile() call. Sharing one Ctx here means a sub-rule compiles\n * exactly once for the WHOLE rule map, however many entries reach it.\n *\n * Returns a single `replacement` \u2014 ONE shared IIFE, evaluated once, whose\n * result is the `{ key: fn, ... }` map \u2014 meant to replace the entire\n * `rules(factory)` call-expression (not one expression per key; splicing a\n * separate self-contained expression per key would either re-run the shared\n * prelude once per entry or duplicate its text per entry, undoing the win).\n * `keys` lists every entry compileRuleMap() saw, for the caller to validate\n * against the source's own key list.\n *\n * Returns null (same all-or-nothing contract the per-entry `compile()` +\n * `inlineExpression === null` check gave the plugin before) when the map\n * contains anything that can't be inlined \u2014 a runtime-fallback parser, or an\n * uncaptured transform/build closure source. The plugin's existing \"warn and\n * leave this rules() call interpreted\" fallback covers this case unchanged.\n */\n/**\n * Grammar rule names compile to `_r_<Name>` functions and `@FS:<name>` dispatch\n * placeholders, so they MUST be valid JS identifiers. A non-identifier name (e.g.\n * `'my-rule'`) is a grammar-authoring error \u2014 throw rather than silently mangle it\n * to `_r_my_rule`, which could collide with a real `my_rule` rule.\n */\nconst RULE_NAME_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/\nfunction assertRuleName(name: string): void {\n  if (!RULE_NAME_RE.test(name)) {\n    throw new Error(\n      `parseman: grammar rule name ${JSON.stringify(name)} is not a valid JS identifier. ` +\n      `Rule names compile to _r_<Name> functions and dispatch guards \u2014 use letters, digits, ` +\n      `_ or $ (and don't start with a digit).`,\n    )\n  }\n}\n\nfunction publicRuleWrapperSource(rule: Combinator<unknown>, fnSource: string): string {\n  const labels = rule._meta.triviaKindLabels\n  if (labels === undefined) return fnSource\n  return `Object.assign(${fnSource}, { _meta: { triviaKindLabels: ${JSON.stringify(labels)} } })`\n}\n\nexport function compileRuleMap(\n  ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>,\n  opts?: { trivia?: Combinator<unknown>; recovery?: boolean },\n): { keys: string[]; replacement: string } | null {\n  for (const [, rule] of ruleMap) markUnusedValues(rule)\n  // Grammar-level ambient trivia declared via rules({ trivia }, factory): seed it\n  // as the default activeTrivia so every rule in the map bakes it (unless a local\n  // parser({trivia}) / noTrivia overrides). Mirrors the interpreter installing it\n  // as ctx.trivia at the entry, and compile()'s single-entry seed.\n  const grammarTrivia = opts?.trivia\n  const ctx: Ctx = {\n    vars: 0,\n    indent: 1,\n    regexDecls: [],\n    regexMap: new Map(),\n    expectedDecls: [],\n    expectedMap: new Map(),\n    recordFail: true,\n    mapFns: [],\n    mapFnSrcs: [],\n    buildFns: [],\n    buildSrcs: [],\n    runtimeParsers: [],\n    namedParsers: new Map(),\n    triviaCaptureNames: new Map(),\n    triviaFnNames: new Map(),\n    namedFnDecls: [],\n    capturing: ruleMap.some(([, rule]) => hasNodeDef(rule)),\n    recovery: opts?.recovery ?? false,\n    lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),\n    ...(grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {}),\n  }\n\n  // Reverse map: each rule's `ref` placeholder \u2192 its canonical `_r_<Name>` fn\n  // name. `emitLazy` uses this so every reference to a named rule (sibling call\n  // OR the map entry itself) resolves to one shared `_r_<Name>` function \u2014 the\n  // linkable form that fuses into a single scope with direct local calls.\n  const seenNames = new Map<string, number>()\n  const ruleNames = new Map<Combinator<unknown>, string>()\n  for (const [key, rule] of ruleMap) {\n    assertRuleName(key)\n    const base = `_r_${key}`\n    const n = seenNames.get(base) ?? 0\n    seenNames.set(base, n + 1)\n    ruleNames.set(rule, n === 0 ? base : `${base}$${n}`)\n  }\n  ctx.ruleNames = ruleNames\n\n  // A trivia rule (e.g. the grammar's `rw`, returned from the factory so the\n  // driver can reach it as `g.rw`) must NOT bake the grammar-level ambient trivia\n  // into itself \u2014 it would recursively skip trivia between its own terms and stop\n  // short. Emit it with activeTrivia cleared, matching the inline-trivia guard.\n  const perEntry = ruleMap.map(([key, rule]) => {\n    const savedTrivia = ctx.activeTrivia\n    if (rule._meta.isTrivia) ctx.activeTrivia = undefined\n    const r = emit(rule, ctx, '_pos')\n    ctx.activeTrivia = savedTrivia\n    return { key, rule, r }\n  })\n\n  const derivedSrcs = ctx.mapFnSrcs.length === ctx.mapFns.length && ctx.mapFnSrcs.every((s): s is string => s !== null)\n    ? ctx.mapFnSrcs as string[]\n    : undefined\n  const buildCovered = ctx.buildFns.length === 0 || ctx.buildSrcs.every((s): s is string => s !== null)\n  const buildSources = ctx.buildFns.length === 0 ? undefined : (ctx.buildSrcs as string[])\n  const mfCovered = ctx.mapFns.length === 0 || derivedSrcs !== undefined\n  const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered\n  if (!canInline) return null\n\n  const mfDecl = derivedSrcs?.length ? `  const ${mfRef(ctx)} = [${derivedSrcs.join(', ')}]` : ''\n  const buildDecl = buildSources?.length ? `  const ${buildRef(ctx)} = [${buildSources.join(', ')}]` : ''\n  const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : []\n  const hoistedDecls = [\n    ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : '',\n    ctx.needsHostReads ? `  ${HOST_READS_DECL}` : '',\n    ...ctx.regexDecls.map(d => `  ${d}`),\n    ...ctx.expectedDecls.map(d => `  ${d}`),\n    mfDecl,\n    buildDecl,\n    ...namedPrelude.map(l => `  ${l}`),\n    ...ctx.namedFnDecls.flatMap((decl, i) => {\n      const lines = decl.split('\\n').map(l => `  ${l}`)\n      return i > 0 ? ['', ...lines] : lines\n    }),\n  ].filter(Boolean)\n\n  const entryFnText = (r: ER): string => [\n    `function(input, _pos, _ctx) {`,\n    `  let pos = _pos`,\n    ...r.stmts,\n    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n    `}`,\n  ].join('\\n')\n\n  // One shared IIFE, evaluated ONCE, returning the whole `{ key: fn, ... }`\n  // map \u2014 this whole string is the caller's replacement for the entire\n  // `rules(factory)` call-expression (NOT one expression per key spliced into\n  // a separately-built object literal, which would either re-run the shared\n  // prelude per entry or duplicate its text per entry \u2014 both defeat the point).\n  const objBody = perEntry\n    .map(({ key, rule, r }) => {\n      const src = publicRuleWrapperSource(rule, entryFnText(r))\n      return `    ${JSON.stringify(key)}: ${src.split('\\n').join('\\n    ')}`\n    })\n    .join(',\\n')\n  const replacement = [\n    `/* @__PURE__ */ (() => {`,\n    ...hoistedDecls,\n    `  return {`,\n    objBody,\n    `  }`,\n    `})()`,\n  ].join('\\n')\n\n  return { keys: perEntry.map(e => e.key), replacement }\n}\n\n/**\n * The linkable form of a rule map (RULE_ABI_PLAN \u00A73): the same compiled rule\n * bodies as `compileRuleMap`, but returned as **splice-able pieces** under a\n * namespace `ns` so multiple independently-compiled maps fuse into one scope\n * (see `fuseRules`). `ns` MUST be non-empty and unique per artifact (the caller\n * derives it \u2014 module identity in the macro, a counter in `compile()`).\n *\n *   prelude  \u2014 namespaced hoisted decls (regexes, expected, `_mf`/`_build`, and\n *              private `_pf` helper fns). Sentinels / `_EMPTY_TL`\n *              are NOT here \u2014 they are SHARED, emitted once by the linker.\n *   ruleFns  \u2014 name \u2192 `function _r_<Name>(\u2026) { \u2026 }` source (the composition\n *              surface; siblings call these by name).\n *   wrappers \u2014 name \u2192 public `(input,pos,ctx) => ParseResult` wrapper source.\n *   deps     \u2014 name \u2192 referenced rule names (from `ruleDependencies`).\n *\n * Returns null on the same \"can't inline\" conditions as `compileRuleMap`.\n */\nexport type LinkablePieces = {\n  ns: string\n  keys: string[]\n  prelude: string[]\n  ruleFns: Map<string, string>\n  wrappers: Map<string, string>\n  /**\n   * Per-rule first-set (this artifact's own rules). fusedBody() uses the WINNING\n   * artifact's entry to resolve `/*@FS:rule:codevar@*\u200B/true` dispatch placeholders\n   * emitted for rule-ref choice arms \u2014 sound under compose override.\n   */\n  firstSets: Map<string, FirstSet>\n  deps: Map<string, string[]>\n  needsEmptyTl: boolean\n  needsHostReads: boolean\n  /**\n   * Transform (`_mf`) / build (`_build`) callback FUNCTIONS, injected into the\n   * fused scope via `_env` when their SOURCE isn't available (runtime `compile()`\n   * mode). Empty when the callbacks were inlined from source (macro mode). Keyed\n   * for `_env` as `<ns>mf` / `<ns>build`.\n   */\n  mfFns: ReadonlyArray<(...args: unknown[]) => unknown>\n  buildFns: ReadonlyArray<(...args: unknown[]) => unknown>\n}\n\nexport function compileLinkable(\n  ruleMapArg: ReadonlyArray<readonly [string, Combinator<unknown>]>,\n  ns: string,\n  opts?: { trivia?: Combinator<unknown>; recovery?: boolean },\n): LinkablePieces | null {\n  if (!ns) throw new Error('compileLinkable: ns must be a non-empty namespace')\n  for (const [, rule] of ruleMapArg) markUnusedValues(rule)\n  // Grammar-level ambient trivia through compose(): a piece from rules({ trivia },\n  // \u2026) tags `grammarTrivia` on its rules (runtime path), or the macro threads it via\n  // `opts.trivia`. Seed it as the default activeTrivia so every fused rule bakes it \u2014\n  // the compose mirror of compileRuleMap's seed. `parser`/`noTrivia` still override.\n  const grammarTrivia = opts?.trivia\n    ?? ruleMapArg.map(([, r]) => (r._meta as { grammarTrivia?: Combinator<unknown> }).grammarTrivia).find(Boolean)\n  // Drop EXTERNAL entries: `rules(g => \u2026)` returns a cache that also holds every\n  // `g.X` that was ACCESSED, so an accessed-but-not-defined rule (defined in\n  // another artifact) leaks into `Object.entries` as an undefined `ref`. Those\n  // are not local rules \u2014 they're by-name references resolved at fuse time (the\n  // pre-scan below emits their calls). A rule is local iff its value is non-lazy\n  // or a `ref` that resolves.\n  const ruleMap = ruleMapArg.filter(([, val]) => {\n    const d = val._def\n    if (d.tag !== 'lazy') return true\n    try { d.thunk(); return true } catch { return false }\n  })\n  const ctx: Ctx = {\n    vars: 0, indent: 1, regexDecls: [], regexMap: new Map(),\n    expectedDecls: [], expectedMap: new Map(), recordFail: true,\n    mapFns: [], mapFnSrcs: [], buildFns: [], buildSrcs: [], runtimeParsers: [],\n    namedParsers: new Map(), triviaCaptureNames: new Map(),\n    triviaFnNames: new Map(), namedFnDecls: [],\n    capturing: ruleMap.some(([, rule]) => hasNodeDef(rule)),\n    recovery: opts?.recovery ?? false,\n    lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),\n    ns,\n    deferFirstSetRefs: true,\n    ...(grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {}),\n  }\n  // Canonical name per rule. Register in BOTH ruleNames (so sibling `emitLazy`\n  // refs resolve by name) AND namedParsers up-front (so a rule emitted before a\n  // recursive back-edge still finds itself). Unlike `compileRuleMap`, EVERY rule\n  // is force-emitted as a named fn \u2014 even one referenced by nobody but its own\n  // entry (its map value is the bare combinator, not a `ref`, so it would\n  // otherwise inline and never get a name).\n  const seen = new Map<string, number>()\n  const ruleNames = new Map<Combinator<unknown>, string>()\n  const fnNameToKey = new Map<string, string>()\n  for (const [key, rule] of ruleMap) {\n    assertRuleName(key)\n    const base = `_r_${key}`\n    const n = seen.get(base) ?? 0\n    seen.set(base, n + 1)\n    const fn = n === 0 ? base : `${base}$${n}`\n    ruleNames.set(rule, fn)\n    fnNameToKey.set(fn, key)\n  }\n  ctx.ruleNames = ruleNames\n\n  // Pre-register EXTERNAL rule references: a named `ref` placeholder that doesn't\n  // resolve locally (defined in ANOTHER artifact). Emit a by-name `_r_<Name>`\n  // call for it \u2014 no body here; it's provided at fuse time. This is what lets a\n  // fragment reference a consumer/base rule (`g.value`, `g.Digits`) without its\n  // source.\n  {\n    const scanned = new Set<Combinator<unknown>>()\n    const scanExternal = (p: Combinator<unknown>): void => {\n      if (scanned.has(p)) return\n      scanned.add(p)\n      const def = p._def\n      if (def.tag === 'lazy') {\n        let resolved: Combinator<unknown> | undefined\n        try { resolved = def.thunk() } catch { resolved = undefined }\n        if (resolved === undefined) {\n          const name = (p as unknown as { _ruleName?: string })._ruleName\n          if (name && !ctx.namedParsers.has(p)) {\n            assertRuleName(name)\n            const fn = `_r_${name}`\n            ruleNames.set(p, fn)\n            ctx.namedParsers.set(p, fn)\n          }\n          return\n        }\n        scanExternal(resolved)\n        return\n      }\n      for (const child of childrenOf(def)) scanExternal(child)\n    }\n    for (const [, rule] of ruleMap) scanExternal(rule)\n  }\n\n  // Emit each rule's body as its `_r_<Name>` fn (resolving a `ref` placeholder to\n  // its target), then build a public wrapper that calls it.\n  const perEntry: Array<{ key: string; rule: Combinator<unknown>; r: ER }> = []\n  for (const [key, rule] of ruleMap) {\n    const fn = ruleNames.get(rule)!\n    if (!ctx.namedParsers.has(rule)) {\n      ctx.namedParsers.set(rule, fn)\n      let resolved: Combinator<unknown> = rule\n      const def = rule._def\n      if (def.tag === 'lazy') {\n        try { resolved = def.thunk() } catch { return null }\n      }\n      const savedIndent = ctx.indent, savedFail = ctx.failLabel, savedRec = ctx.recordFail\n      ctx.indent = 1; ctx.failLabel = '_pfail'; ctx.recordFail = true\n      // A trivia rule must never carry the ambient trivia (it would recursively\n      // skip trivia within itself). Mirrors compileRuleMap's guard.\n      const savedTrivia = ctx.activeTrivia\n      if (rule._meta.isTrivia) ctx.activeTrivia = undefined\n      const body = emit(resolved, ctx, '_pos')\n      ctx.activeTrivia = savedTrivia\n      ctx.indent = savedIndent; ctx.failLabel = savedFail; ctx.recordFail = savedRec\n      pushNamedFnDecl(ctx, fn, body.stmts, body.valueVar, body.endVar)\n    }\n    // Public wrapper: call the named fn, adapt sentinel \u2192 ParseResult.\n    perEntry.push({ key, rule, r: emitNamedFnCall(ctx, fn, '_pos') })\n  }\n\n  // A runtime-parser fallback can't be fused (no source AND no stable identity to\n  // inject). Callback fns, by contrast, ARE fusable \u2014 inline their source when\n  // available (macro), else inject the fn objects via `_env` (runtime).\n  if (ctx.runtimeParsers.length !== 0) return null\n  const mfSrcs = ctx.mapFns.length > 0 && ctx.mapFnSrcs.every((s): s is string => s !== null)\n    ? ctx.mapFnSrcs as string[] : null\n  const buildSrcs = ctx.buildFns.length > 0 && ctx.buildSrcs.every((s): s is string => s !== null)\n    ? ctx.buildSrcs as string[] : null\n\n  // Split named fns: `_r_<Name>` are the composition surface (ruleFns), everything\n  // else (`_ns_pf\u2026` private helpers) is private prelude bundled with the artifact.\n  const ruleFns = new Map<string, string>()\n  const privateFns: string[] = []\n  for (const decl of ctx.namedFnDecls) {\n    const fnName = decl.match(/^function (\\S+?)\\(/)?.[1]\n    const key = fnName ? fnNameToKey.get(fnName) : undefined\n    if (key !== undefined) ruleFns.set(key, decl)\n    else privateFns.push(decl)\n  }\n\n  const mfDecl = ctx.mapFns.length === 0 ? ''\n    : mfSrcs ? `const ${mfRef(ctx)} = [${mfSrcs.join(', ')}]`\n    : `const ${mfRef(ctx)} = _env[${JSON.stringify(nsp(ctx) + 'mf')}]`\n  const buildDecl = ctx.buildFns.length === 0 ? ''\n    : buildSrcs ? `const ${buildRef(ctx)} = [${buildSrcs.join(', ')}]`\n    : `const ${buildRef(ctx)} = _env[${JSON.stringify(nsp(ctx) + 'build')}]`\n  const prelude = [\n    ...ctx.regexDecls,\n    ...ctx.expectedDecls,\n    mfDecl,\n    buildDecl,\n    ...privateFns,\n  ].filter(Boolean)\n\n  const wrappers = new Map<string, string>()\n  for (const { key, rule, r } of perEntry) {\n    wrappers.set(key, publicRuleWrapperSource(rule, [\n      `function(input, _pos, _ctx) {`,\n      `  let pos = _pos`,\n      ...r.stmts,\n      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n      `}`,\n    ].join('\\n')))\n  }\n\n  // Per-rule first-set table for fuse-time dispatch: fusedBody() substitutes each\n  // `/*@FS:rule:codevar@*\u200B/true` placeholder (emitted for rule-ref choice arms)\n  // with the WINNING rule's condition. Resolve each rule to its real first-set;\n  // a rule that can match empty at start gets `any` (\u2192 no guard, always try).\n  const firstSets = new Map<string, FirstSet>()\n  for (const [key, rule] of ruleMap) {\n    let resolved: Combinator<unknown> = rule\n    const d = rule._def\n    if (d.tag === 'lazy') { try { resolved = d.thunk() } catch { resolved = rule } }\n    firstSets.set(key, canMatchEmptyAtStart(resolved) ? { kind: 'any' } : resolved._meta.firstSet)\n  }\n\n  return {\n    ns,\n    keys: perEntry.map(e => e.key),\n    prelude,\n    ruleFns,\n    wrappers,\n    firstSets,\n    deps: ruleDependencies(ruleMap),\n    needsEmptyTl: !!ctx.needsEmptyTl,\n    needsHostReads: !!ctx.needsHostReads,\n    mfFns: mfSrcs ? [] : (ctx.mapFns as ReadonlyArray<(...a: unknown[]) => unknown>),\n    buildFns: buildSrcs ? [] : (ctx.buildFns as ReadonlyArray<(...a: unknown[]) => unknown>),\n  }\n}\n\nfunction buildInlineExpression(\n  ctx: Ctx,\n  r: ER,\n  mapFnSources?: string[],\n  buildSources?: string[],\n): string {\n  const bodyLines = [\n    `  let pos = _pos`,\n    ...r.stmts,\n    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n  ]\n\n  const innerFn = [\n    `function(input, _pos, _ctx) {`,\n    ...bodyLines,\n    `}`,\n  ].join('\\n')\n\n  // Declare _mf / _build inline so the emitted _mf[i] / _build[i] references\n  // resolve without runtime closure arrays.\n  const mfDecl = mapFnSources?.length ? `  const _mf = [${mapFnSources.join(', ')}]` : ''\n  const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(', ')}]` : ''\n\n  const emptyTlDecl = ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : ''\n  const hostReadsDecl = ctx.needsHostReads ? `  ${HOST_READS_DECL}` : ''\n  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl || !!hostReadsDecl\n  if (!needsWrapper) return innerFn\n\n  const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : []\n  const hoistedDecls = [\n    emptyTlDecl,\n    hostReadsDecl,\n    ...ctx.regexDecls.map(d => `  ${d}`),\n    ...ctx.expectedDecls.map(d => `  ${d}`),\n    mfDecl,\n    buildDecl,\n    ...namedPrelude.map(l => `  ${l}`),\n    ...ctx.namedFnDecls.flatMap((decl, i) => {\n      const lines = decl.split('\\n').map(l => `  ${l}`)\n      return i > 0 ? ['', ...lines] : lines\n    }),\n  ].filter(Boolean)\n  return [\n    `/* @__PURE__ */ (() => {`,\n    ...hoistedDecls,\n    `  return ${innerFn}`,\n    `})()`,\n  ].join('\\n')\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { literal } from './literal.ts'\nimport { regex } from './regex.ts'\nimport { sequence } from './sequence.ts'\nimport { choice } from './choice.ts'\nimport { many } from './repeat.ts'\nimport { transform } from './map.ts'\nimport { expect } from './expect.ts'\nimport { any } from './first-set.ts'\nimport { ref } from './ref.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\nexport type ScanToOptions = {\n  /** Parsers that match \"container\" regions to skip over intact (balanced parens, strings, comments\u2026) */\n  skip?: Combinator<unknown>[]\n  /**\n   * If true, reaching EOF without finding the sentinel is a success \u2014 returns\n   * everything consumed so far. Default false (fail at EOF).\n   */\n  orEOF?: boolean\n}\n\n/**\n * Consume input up to (but not including) the sentinel, skipping over any\n * \"hole\" patterns in order so their contents are never mistaken for the sentinel.\n *\n * Returns the consumed text as a string. The sentinel is NOT consumed.\n * Fails if the sentinel is never found (unless orEOF is true).\n *\n *   const selector = scanTo(literal('{'), {\n *     skip: [cssComment, stringLit, balanced('(', ')'), balanced('[', ']')],\n *   })\n */\nexport function scanTo(\n  sentinel: Combinator<unknown>,\n  { skip = [], orEOF = false }: ScanToOptions = {},\n): Combinator<string> {\n  const meta: ParserMeta = {\n    firstSet: any(),\n    canMatchNewline: true,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'scanTo',\n    _meta: meta,\n    _def: { tag: 'scanTo', sentinel, skip, orEOF },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      let cur = pos\n\n      // Sentinel checks and skip scans must not emit CST children of their own \u2014\n      // scanTo represents the whole scanned span as one leaf. Probe them with a\n      // collector-free context so their internal literal()/regex() don't push.\n      // The error channel IS forwarded, so a committed skipper (e.g. balanced()\n      // whose open delimiter was consumed) can still report an unmatched close.\n      const probeCtx: ParseContext = {\n        trackLines: ctx.trackLines,\n        state: ctx.state,\n        ...(ctx._errors !== undefined ? { _errors: ctx._errors } : {}),\n      }\n\n      // Record the scanned text as a CSTLeaf so buildNode-driven grammars can\n      // see it in children/rawChildren (it would otherwise be lost \u2014 only the\n      // returned value carries it). Skipped when no collector is active.\n      const emit = (end: number) => {\n        if (end > pos && cstCaptureActive(ctx)) {\n          const leaf = { _tag: 'leaf', value: input.slice(pos, end), span: { start: pos, end } }\n          pushCstLeaf(ctx, leaf)\n        }\n      }\n\n      while (cur < input.length) {\n        // Check sentinel \u2014 if it matches here, stop and return consumed text.\n        const s = sentinel.parse(input, cur, probeCtx)\n        if (s.ok) {\n          emit(cur)\n          return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } }\n        }\n\n        // Try each skipper in order; take first that advances.\n        let advanced = false\n        for (const skipper of skip) {\n          const r = skipper.parse(input, cur, probeCtx)\n          if (r.ok && r.span.end > cur) {\n            cur = r.span.end\n            advanced = true\n            break\n          }\n        }\n\n        // Nothing matched \u2014 consume one character and continue.\n        if (!advanced) cur++\n      }\n\n      // Reached EOF without finding sentinel.\n      if (orEOF) {\n        emit(cur)\n        return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } }\n      }\n      const sentDef = sentinel._def\n      const expected = sentDef.tag === 'literal' ? [JSON.stringify(sentDef.value)] : ['sentinel']\n      return { ok: false, expected, span: { start: pos, end: cur } }\n    },\n  }\n}\n\n/**\n * Match a balanced open/close pair, skipping over any holes inside.\n * Returns the full matched text including delimiters.\n *\n *   const parenGroup = balanced('(', ')', { skip: [comment, stringLit] })\n */\nexport function balanced(\n  open: string,\n  close: string,\n  options: ScanToOptions = {},\n): Combinator<string> {\n  // The interior scan must skip NESTED same-delimiter pairs so depth is counted \u2014\n  // otherwise `{{x}}` stops at the first `}`. `self` references this balanced\n  // combinator; added to the interior scan's skip list, a nested `open` is\n  // consumed intact (recursively) before the scan looks for the matching `close`.\n  const self = ref<string>()\n  const skips = options.skip ?? []\n  // PREDICTIVE interior \u2014 no char-walk. The body is `many(choice(self, \u2026skips,\n  // contentRun))`, where contentRun is a regex of chars that are NOT this pair's\n  // delimiters and NOT the start of any skip (so a string/comment arm still wins\n  // its position). At any other character \u2014 a stray close, or a *different* bracket\n  // type \u2014 no arm matches, `many` stops, and the required close (expect()) reports\n  // \"expected <close>\". So an unmatched open, a cross-type close `(a]`, and a stray\n  // close all surface as errors; nothing is silently swallowed. Well-formed input\n  // is consumed identically.\n  const stop = new Set<string>([open, close])\n  let bounded = true\n  for (const sk of skips) {\n    const cs = firstSetClassChars(sk)\n    if (cs === null) { bounded = false; break }\n    for (const ch of cs) stop.add(ch)\n  }\n  const cls = [...stop].map(escapeClassChar).join('')\n  // A run when every skip's start is bounded (fast); else one char at a time so a\n  // skip arm always gets the chance to match at its position.\n  const content = bounded\n    ? regex(new RegExp(`[^${cls}]+`))\n    : regex(new RegExp(`[^${escapeClassChar(open)}${escapeClassChar(close)}]`))\n  const inner = many(choice(self, ...skips, content))\n  const combi = transform(\n    sequence(literal(open), inner, expect(literal(close))),\n    // parts: strings (content/self) or arrays (a sequence-shaped skip) or a\n    // ParseError (recovered close). `c` is the close string or a ParseError.\n    ([o, parts, c]) => o + (parts as unknown[]).map(p => typeof p === 'string' ? p : Array.isArray(p) ? p.join('') : '').join('') + (typeof c === 'string' ? c : ''),\n  )\n  // Provide the callback source so the macro can inline this library-internal\n  // transform (codegen derives map-fn sources from def.fnSrc).\n  if (combi._def.tag === 'transform') {\n    combi._def.fnSrc = '([o, parts, c]) => o + parts.map(p => typeof p === \"string\" ? p : Array.isArray(p) ? p.join(\"\") : \"\").join(\"\") + (typeof c === \"string\" ? c : \"\")'\n  }\n  self.define(combi as Combinator<string>)\n  return combi\n}\n\n/**\n * The characters a combinator can START with, as char-class members \u2014 or null if\n * its first set is unbounded ('any') or too broad to be a delimiter. Used by\n * balanced() to keep a content run from eating the start of a skip.\n */\nfunction firstSetClassChars(c: Combinator<unknown>): string[] | null {\n  const fs = c._meta.firstSet\n  if (fs.kind === 'empty') return []\n  if (fs.kind !== 'ranges') return null\n  const out: string[] = []\n  for (const { lo, hi } of fs.ranges) {\n    if (hi - lo > 8) return null\n    for (let cp = lo; cp <= hi; cp++) out.push(String.fromCodePoint(cp))\n  }\n  return out\n}\n\nfunction escapeClassChar(ch: string): string {\n  return ch.replace(/[\\\\\\]^-]/g, '\\\\$&')\n}\n", "/**\n * Serialize a compiled rule map BACK to a compact combinator-construction source\n * expression \u2014 the \"IR\" a composed grammar carries instead of ~1MB of fully\n * lowered `_r_<Name>` function source. At fuse time the expression is evaluated\n * (with the combinator constructors in scope) to reconstruct the rule map, then\n * re-lowered via `compileLinkable` \u2014 identical behaviour, a fraction of the bytes.\n *\n * The output mirrors how a grammar is WRITTEN, not how it lowers:\n *   - a rule reference (`g.Foo`, a `lazy` carrying `_ruleName`) \u2192 `g[\"Foo\"]`\n *   - a sub-combinator shared by identity (referenced \u22652\u00D7, e.g. a `balanced` const\n *     reused across rules) \u2192 a hoisted `const _s<N> = \u2026`, referenced by name, so it\n *     stays shared through the round trip (and `compileLinkable` re-hoists it)\n *   - a self-referential combinator (`balanced`'s internal `self = ref()`) \u2192 a\n *     `ref()` + `.define()` closure, the same shape the library combinator emits\n *   - `transform`/`node` callbacks \u2192 their captured source (`fnSrc`/`buildSrc`)\n *\n * Returns null if the map can't be faithfully serialized (a callback without\n * source, or an unsupported construct) \u2014 the caller then keeps the lowered source.\n */\nimport type { Combinator, ParserDef } from '../types.ts'\nimport { rules } from '../combinators/parser.ts'\nimport { ref } from '../combinators/ref.ts'\nimport { regex } from '../combinators/regex.ts'\nimport { literal } from '../combinators/literal.ts'\nimport { keywords } from '../combinators/keywords.ts'\nimport { sequence } from '../combinators/sequence.ts'\nimport { choice } from '../combinators/choice.ts'\nimport { many, oneOrMore, optional, sepBy } from '../combinators/repeat.ts'\nimport { not } from '../combinators/not.ts'\nimport { node } from '../combinators/node.ts'\nimport { parser } from '../combinators/grammar.ts'\nimport { scanTo } from '../combinators/scanTo.ts'\nimport { token } from '../combinators/token.ts'\nimport { transform, skip, trivia, label, field } from '../combinators/map.ts'\nimport { expect as expectC } from '../combinators/expect.ts'\n\ntype Comb = Combinator<unknown>\n\n/** Child combinators of a def, in construction order (mirrors codegen's childrenOf). */\nfunction childrenOf(def: ParserDef): Comb[] {\n  switch (def.tag) {\n    case 'sequence':\n    case 'choice':    return def.parsers\n    case 'many':\n    case 'oneOrMore':\n    case 'optional':\n    case 'transform':\n    case 'trivia':\n    case 'token':\n    case 'label':\n    case 'field':\n    case 'not':\n    case 'node':\n    case 'expect':    return [def.parser]\n    case 'grammar':   return def.triviaParser ? [def.parser, def.triviaParser] : [def.parser]\n    case 'sepBy':     return [def.parser, def.separator]\n    case 'skip':      return [def.main, def.skipped]\n    case 'scanTo':    return [def.sentinel, ...def.skip]\n    case 'lazy':\n    case 'literal':\n    case 'regex':\n    case 'keywords':\n    case 'guard':\n    case 'withCtx':\n    case 'recover':\n    case 'unknown':   return []\n  }\n}\n\nconst ruleNameOf = (c: Comb): string | undefined =>\n  (c as unknown as { _ruleName?: string })._ruleName\n\n/** Resolve a lazy's target, or null if it isn't defined yet (external ref). */\nfunction lazyTarget(c: Comb): Comb | null {\n  if (c._def.tag !== 'lazy') return null\n  try { return c._def.thunk() } catch { return null }\n}\n\nclass Unserializable extends Error {}\n\nexport function serializeRuleMap(\n  ruleMap: ReadonlyArray<readonly [string, Comb]>,\n): string | null {\n  try {\n    return new Serializer(ruleMap).run()\n  } catch (e) {\n    if (e instanceof Unserializable) {\n      if (process.env.PARSEMAN_IR_DEBUG) console.error(`[ir] fallback: ${(e as Error).message}`)\n      return null\n    }\n    throw e\n  }\n}\n\n/** Reconstruct a rule map from serialized IR (the inverse of `serializeRuleMap`) \u2014\n * evaluate the combinator-construction expression with every constructor in scope.\n * Used at fuse time (runtime linker + build-time plugin) to re-lower carried IR. */\nexport function evalRuleMapIR(ir: string): Array<[string, Comb]> {\n  // `_tf`/`_nd` reconstruct a transform/node AND restore its captured callback\n  // source (`_def.fnSrc`/`buildSrc`) so re-lowering inlines it statically. The live\n  // fn is only needed for interpreted mode; a self-contained transform source is\n  // eval'd, a node build (which may reference imported AST classes) is left to its\n  // source only.\n  const _tf = (child: Comb, src: string): Comb => {\n    let fn: (...a: unknown[]) => unknown\n    // eslint-disable-next-line no-eval\n    try { fn = (0, eval)(`(${src})`) } catch { fn = () => { throw new Error('IR transform fn not materialized') } }\n    const t = transform(child as never, fn as never)\n    ;(t._def as { fnSrc?: string }).fnSrc = src\n    return t as Comb\n  }\n  const _nd = (type: string, child: Comb, src: string, opts?: unknown): Comb => {\n    const n = node(type, child as never, undefined, opts as never)\n    ;(n._def as { buildSrc?: string }).buildSrc = src\n    return n as Comb\n  }\n  // `_gch` rebuilds a GATED choice AND restores its `_def.gateSrcs` (parallel to the\n  // arms) \u2014 the gate mirror of `_tf`/`_nd`. Each item is either a plain arm or a\n  // `[gateSource, arm]` tuple: the source is eval'd to the live predicate (interpreted\n  // mode) and recorded as the arm's gateSrcs entry so re-lowering INLINES the gate\n  // statically (keeping the artifact fusible via `emitFusedSource`). A missing/failed\n  // source falls back to a throwing predicate \u2014 the same contract as `_tf`.\n  const _gch = (items: Array<Comb | [string, Comb]>): Comb => {\n    const gateSrcs: (string | null)[] = []\n    const arms = items.map(it => {\n      if (Array.isArray(it)) {\n        const [src, comb] = it\n        gateSrcs.push(src)\n        let gate: (s: unknown) => boolean\n        // eslint-disable-next-line no-eval\n        try { gate = (0, eval)(`(${src})`) } catch { gate = () => { throw new Error('IR gate fn not materialized') } }\n        return { gate, combinator: comb }\n      }\n      gateSrcs.push(null)\n      return it\n    })\n    const c = (choice as (...a: unknown[]) => Comb)(...arms)\n    // `choice` is the authority on gate alignment; `gateSrcs` must line up 1:1 with\n    // the constructed `_def.gates`. They always do on the normal path (both from the\n    // same `items.map`), but assert it so a future change in `choice` that coalesces\n    // or drops arms can't silently ship a mis-aligned gate-source array.\n    const gates = (c._def as { gates?: unknown[] }).gates\n    if (gates && gates.length !== gateSrcs.length) {\n      throw new Error(`_gch: gateSrcs length ${gateSrcs.length} != choice gates length ${gates.length}`)\n    }\n    ;(c._def as { gateSrcs?: (string | null)[] }).gateSrcs = gateSrcs\n    return c\n  }\n  // eslint-disable-next-line no-new-func\n  const fn = new Function(\n    'rules', 'ref', 'regex', 'literal', 'keywords', 'sequence', 'choice',\n    'many', 'oneOrMore', 'optional', 'sepBy', 'not', 'node', 'parser',\n    'scanTo', 'token', 'transform', 'skip', 'trivia', 'label', 'field', 'expect', '_tf', '_nd', '_gch',\n    `return (${ir})`,\n  )\n  const map = fn(\n    rules, ref, regex, literal, keywords, sequence, choice,\n    many, oneOrMore, optional, sepBy, not, node, parser,\n    scanTo, token, transform, skip, trivia, label, field, expectC, _tf, _nd, _gch,\n  ) as Record<string, Comb>\n  return Object.entries(map)\n}\n\nclass Serializer {\n  private counts = new Map<Comb, number>()\n  private selfRef = new Set<Comb>()       // combinators reached by an unnamed lazy pointing back into their own subtree\n  private constName = new Map<Comb, string>()\n  private emitted = new Set<string>()\n  private decls: string[] = []\n  private ruleValues = new Set<Comb>()\n  private ruleMap: ReadonlyArray<readonly [string, Comb]>\n\n  constructor(ruleMap: ReadonlyArray<readonly [string, Comb]>) {\n    this.ruleMap = ruleMap\n    for (const [, c] of ruleMap) this.ruleValues.add(this.body(c))\n  }\n\n  /** A `rules()` map wraps each rule value in a named `lazy` proxy; the real body is\n   * its target (compileLinkable unwraps the same way). A ref INSIDE a body stays a\n   * `g[name]` ref \u2014 only the top-level entry is unwrapped. */\n  private body(c: Comb): Comb {\n    return c._def.tag === 'lazy' && ruleNameOf(c) !== undefined ? (lazyTarget(c) ?? c) : c\n  }\n\n  run(): string {\n    for (const [, c] of this.ruleMap) this.analyze(this.body(c), new Set())\n    // A shared sub-combinator (count \u2265 2) or a self-ref target gets a const, EXCEPT\n    // a top-level rule value (it already lives under its rule name).\n    let n = 0\n    for (const [c, count] of this.counts) {\n      if (this.ruleValues.has(c)) continue\n      if (count >= 2 || this.selfRef.has(c)) this.constName.set(c, `_s${n++}`)\n    }\n    const body = this.ruleMap\n      .map(([name, c]) => `  ${JSON.stringify(name)}: ${this.wrap(this.body(c))}`)\n      .join(',\\n')\n    // Shared consts go INSIDE the factory: they can reference `g[name]` rule refs,\n    // and `g` only exists in the factory scope.\n    if (this.decls.length === 0) return `rules((g) => ({\\n${body}\\n}))`\n    return `rules((g) => {\\n${this.decls.map(d => '  ' + d).join('\\n')}\\n  return ({\\n${body}\\n})\\n})`\n  }\n\n  /** Count identity references and flag self-referential subtrees. `active` is the\n   * set of combinators on the current DFS path (to detect a lazy pointing back). */\n  private analyze(c: Comb, active: Set<Comb>): void {\n    const def = c._def\n    if (def.tag === 'lazy') {\n      if (ruleNameOf(c) !== undefined) return          // named rule ref \u2014 resolved by g[name]\n      const target = lazyTarget(c)\n      if (!target) throw new Unserializable('unresolved unnamed ref')\n      if (active.has(target)) { this.selfRef.add(target); return }  // recursion into an ancestor\n      this.analyze(target, active)                      // inline (unnamed, non-recursive) \u2014 rare\n      return\n    }\n    if (def.tag === 'guard' || def.tag === 'withCtx' || def.tag === 'recover' || def.tag === 'unknown') {\n      throw new Unserializable(`unsupported tag ${def.tag}`)\n    }\n    this.counts.set(c, (this.counts.get(c) ?? 0) + 1)\n    if ((this.counts.get(c) ?? 0) > 1) return           // already descended\n    active.add(c)\n    for (const child of childrenOf(def)) this.analyze(child, active)\n    active.delete(c)\n  }\n\n  /** Reference `c`: a const var if it has one (emitting its decl first), else inline.\n   * `selfOf` is the const currently being wrapped in a ref()/define closure \u2014 an\n   * unnamed lazy back into it emits the local ref var instead of recursing. */\n  private ref(c: Comb, selfOf: { comb: Comb; var: string } | null): string {\n    const cn = this.constName.get(c)\n    if (cn) { this.emitDecl(c); return cn }\n    return this.expr(c, selfOf)\n  }\n\n  private emitDecl(c: Comb): void {\n    const name = this.constName.get(c)!\n    if (this.emitted.has(name)) return\n    this.emitted.add(name)                              // mark first (cycle-safe)\n    this.decls.push(`const ${name} = ${this.wrap(c)}`)\n  }\n\n  private selfN = 0\n\n  /** Emit `c`'s own constructor call, wrapping it in a `ref()`+`.define()` closure\n   * if it is self-referential (an unnamed lazy in its subtree points back to it) \u2014\n   * the shape `balanced()` and other recursive library combinators build. */\n  private wrap(c: Comb): string {\n    if (!this.selfRef.has(c)) return this.expr(c, null)\n    const rv = `_rr${this.selfN++}`\n    const bodyExpr = this.expr(c, { comb: c, var: rv })\n    return `(() => { const ${rv} = ref(); const _b = ${bodyExpr}; ${rv}.define(_b); return _b })()`\n  }\n\n  /** Emit the constructor-call source for `c` (never a const shortcut for `c` itself). */\n  private expr(c: Comb, selfOf: { comb: Comb; var: string } | null): string {\n    const def = c._def\n    const kid = (x: Comb) => this.ref(x, selfOf)\n    switch (def.tag) {\n      case 'lazy': {\n        if (ruleNameOf(c) !== undefined) return `g[${JSON.stringify(ruleNameOf(c))}]`\n        const target = lazyTarget(c)!\n        if (selfOf && target === selfOf.comb) return selfOf.var\n        return this.ref(target, selfOf)\n      }\n      case 'literal':\n        return `literal(${JSON.stringify(def.value)}${def.caseInsensitive ? ', { caseInsensitive: true }' : ''})`\n      case 'regex':\n        return `regex(${JSON.stringify(def.source)}, ${JSON.stringify(def.flags)})`\n      case 'keywords':\n        return `keywords(${JSON.stringify(def.words)}, { caseInsensitive: ${def.caseInsensitive}${def.boundary !== undefined ? `, boundary: ${JSON.stringify(def.boundary)}` : ''} })`\n      case 'sequence':\n        return `sequence(${def.parsers.map(kid).join(', ')})`\n      case 'choice': {\n        // Ungated choices stay `choice(a, b, \u2026)` byte-for-byte as before.\n        const gates = def.gates\n        if (gates.every(g => g === null)) return `choice(${def.parsers.map(kid).join(', ')})`\n        // A gated choice round-trips through `_gch`, which rebuilds the choice AND\n        // re-attaches `_def.gateSrcs` from each arm's captured gate SOURCE. Preserving\n        // gateSrcs is load-bearing: on re-lowering, codegen inlines the gate from its\n        // source (a static callback), so the re-lowered artifact stays STATICALLY\n        // FUSIBLE. A plain `choice({ gate: fn, \u2026 })` would rebuild the predicate as a\n        // source-less runtime closure \u2192 a non-static callback \u2192 `emitFusedSource`\n        // (macro static fusion) fails and `compose()` silently falls back to a runtime\n        // fuse. Without a captured source we cannot re-emit the gate \u2192 keep full pieces.\n        const gateSrcs = def.gateSrcs\n        const items = def.parsers.map((p, i) => {\n          if (gates[i] === null) return kid(p)\n          const src = gateSrcs?.[i]\n          if (src == null) throw new Unserializable('choice gate() has no captured source')\n          // `[gateSource, arm]` \u2014 `_gch` evals the source to the live predicate and\n          // records it as the arm's `gateSrcs` entry.\n          return `[${JSON.stringify(src)}, ${kid(p)}]`\n        })\n        return `_gch([${items.join(', ')}])`\n      }\n      case 'many':      return `many(${kid(def.parser)})`\n      case 'oneOrMore': return `oneOrMore(${kid(def.parser)})`\n      case 'optional':  return `optional(${kid(def.parser)})`\n      case 'sepBy':     return `sepBy(${kid(def.parser)}, ${kid(def.separator)})`\n      case 'not':       return `not(${kid(def.parser)})`\n      case 'trivia':    return `trivia(${kid(def.parser)})`\n      case 'token':     return `token(${kid(def.parser)})`\n      case 'label':     return `label(${JSON.stringify(def.label)}, ${kid(def.parser)})`\n      case 'field':     return `field(${JSON.stringify(def.name)}, ${kid(def.parser)})`\n      case 'expect':    return `expect(${kid(def.parser)}${def.label !== undefined ? `, ${JSON.stringify(def.label)}` : ''})`\n      case 'skip':      return `skip(${kid(def.main)}, ${kid(def.skipped)})`\n      case 'scanTo':\n        return `scanTo(${kid(def.sentinel)}, { skip: [${def.skip.map(kid).join(', ')}], orEOF: ${def.orEOF} })`\n      case 'transform': {\n        if (def.fnSrc === undefined) throw new Unserializable('transform without fnSrc')\n        // `_tf` sets `_def.fnSrc` so re-lowering INLINES the callback (a plain\n        // `transform(child, fn)` would leave fnSrc unset \u2192 a non-static runtime\n        // callback that emitFusedSource can't inline).\n        return `_tf(${kid(def.parser)}, ${JSON.stringify(def.fnSrc)})`\n      }\n      case 'node': {\n        if (def.build !== undefined && def.buildSrc === undefined) throw new Unserializable('node build without buildSrc')\n        const opts = def.unwrap || def.collapse\n          ? `, { ${def.unwrap ? 'unwrap: true' : 'collapse: true'} }`\n          : ''\n        // `_nd` sets `_def.buildSrc` (same reason as `_tf`). No build \u2192 plain node.\n        if (def.type === undefined) {\n          if (def.buildSrc !== undefined) throw new Unserializable('inferred node build without inferred type')\n          return opts ? `node(${kid(def.parser)}, undefined${opts})` : `node(${kid(def.parser)})`\n        }\n        if (def.buildSrc !== undefined) return `_nd(${JSON.stringify(def.type)}, ${kid(def.parser)}, ${JSON.stringify(def.buildSrc)}${opts})`\n        return opts ? `node(${JSON.stringify(def.type)}, ${kid(def.parser)}, undefined${opts})` : `node(${JSON.stringify(def.type)}, ${kid(def.parser)})`\n      }\n      case 'grammar': {\n        const trivia = def.clearTrivia ? 'null' : def.triviaParser ? kid(def.triviaParser) : 'undefined'\n        return `parser({ trivia: ${trivia}${def.trackLines ? ', trackLines: true' : ''} }, ${kid(def.parser)})`\n      }\n      case 'guard':\n      case 'withCtx':\n      case 'recover':\n      case 'unknown':\n        throw new Unserializable(`unsupported tag ${def.tag}`)\n    }\n  }\n}\n", "/**\n * The linker (RULE_ABI_PLAN \u00A74): fuse independently-compiled linkable artifacts\n * (`compileLinkable`) into ONE closure of parse functions.\n *\n * Every rule is a canonical `_r_<Name>` function and every sibling reference is a\n * call to that name; because fusion drops them all into one scope, those calls\n * are **direct local calls** (0% dispatch). Composition is by name:\n *   - **override** \u2014 later artifact wins per rule name; because references resolve\n *     by name in the shared scope, overriding a rule reroutes EVERY call to it,\n *     including calls inside a base artifact's own rules (open recursion).\n *   - **\u00E0 la carte** \u2014 `pick(artifact, names)` keeps only those rules + their\n *     transitive dependency closure.\n * Private per-artifact state (`_ns_re`, `_ns_pf`, \u2026) is namespaced so it can't\n * collide; the sentinel protocol / `_EMPTY_TL` are shared and\n * emitted once.\n *\n * Uses `new Function` (like `compile()`), so it needs `'unsafe-eval'` under a\n * strict CSP; a build-time variant that emits fused source instead is a later\n * addition. Fusion runs ONCE at parser construction \u2014 parsing is then full speed.\n */\nimport { compileLinkable, firstSetCond, HOST_READS_DECL } from './codegen.ts'\nimport { evalRuleMapIR, serializeRuleMap } from './ir-serialize.ts'\nimport type { LinkablePieces } from './codegen.ts'\nimport type { BuildHost, Combinator, CstCollapsePredicate, FirstSet } from '../types.ts'\n\n/**\n * Compile a `rules()` map to a **linkable artifact** \u2014 the composable, shippable\n * form (RULE_ABI_PLAN \u00A74). A package exports `linkable(rules(g => \u2026))`; consumers\n * import that artifact and `fuse([...])` it \u2014 **no source of the base grammar is\n * ever read**. Under the macro this is precompiled to static pieces; in the\n * interpreter it compiles here at load (like `compile()`).\n *\n * `ns` is a per-artifact namespace; omit it to auto-assign a process-unique one\n * (fine at runtime \u2014 the macro supplies a stable module-derived ns instead).\n */\nlet _nsCounter = 0\nexport function linkable(\n  rulesMap: Record<string, Combinator<unknown>>,\n  ns?: string,\n  trivia?: Combinator<unknown>,\n): LinkablePieces {\n  const pieces = compileLinkable(Object.entries(rulesMap), ns ?? `_lk${_nsCounter++}_`, trivia ? { trivia } : undefined)\n  if (!pieces) throw new Error('linkable(): this grammar cannot be compiled to a linkable artifact (contains a runtime-only parser fallback)')\n  return pieces\n}\n\nexport type CstBuildHostOptions = {\n  /**\n   * Collapse transparent one-child CST wrapper nodes at build time.\n   * - `true`: collapse any one-child node whose rawChildren also has exactly one\n   *   entry, so trivia/error boundaries are not silently dropped.\n   * - `string[]`: collapse only these grammar node types.\n   * - predicate: final policy hook for language-specific public CSTs.\n   */\n  collapse?: boolean | readonly string[] | CstCollapsePredicate\n}\n\nfunction normalizeCstCollapse(collapse: CstBuildHostOptions['collapse']): CstCollapsePredicate | undefined {\n  if (collapse === true) return () => true\n  if (Array.isArray(collapse)) {\n    const types = new Set(collapse)\n    return type => types.has(type)\n  }\n  return typeof collapse === 'function' ? collapse : undefined\n}\n\nfunction buildCstNode(\n  type: string,\n  children: ReadonlyArray<unknown>,\n  _fields: unknown,\n  span: { start: number; end: number },\n  _rawChildren?: ReadonlyArray<unknown>,\n  _triviaLog?: readonly number[],\n  state?: unknown,\n): unknown {\n  // Carry the grammar's `ctx.state` snapshot onto the node (null when unset) \u2014 the\n  // CST contract includes `state` and incremental re-parse replays it on edit.\n  return { _tag: 'node', type, span: { start: span.start, end: span.end }, state: state ?? null, children: [...children] }\n}\n\n/**\n * A generic positioned-CST build host (RULE_ABI_PLAN \u00A77). Pass as `ctx.build`\n * (or `parseDoc(..., { build: cstBuildHost })`) to make ANY linkable/fused\n * grammar produce a uniform CST \u2014 `{ _tag:'node', type, span, state, children }`\n * \u2014 instead of its own eval-AST builders. This is the host the linter and IDE\n * drivers use; the eval driver leaves `ctx.build` unset (grammar's own builders).\n *\n * For public syntax trees, call `cstBuildHost({ collapse })`: Parseman will skip\n * allocating wrapper CST nodes whose single child should stand in for the rule.\n */\nexport function cstBuildHost(options?: CstBuildHostOptions): BuildHost\nexport function cstBuildHost(\n  type: string,\n  children: ReadonlyArray<unknown>,\n  fields: unknown,\n  span: { start: number; end: number },\n  rawChildren?: ReadonlyArray<unknown>,\n  triviaLog?: readonly number[],\n  state?: unknown,\n): unknown\nexport function cstBuildHost(\n  typeOrOptions?: string | CstBuildHostOptions,\n  children?: ReadonlyArray<unknown>,\n  _fields?: unknown,\n  span?: { start: number; end: number },\n  rawChildren?: ReadonlyArray<unknown>,\n  triviaLog?: readonly number[],\n  state?: unknown,\n): unknown {\n  if (typeof typeOrOptions === 'string') {\n    return buildCstNode(typeOrOptions, children ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state)\n  }\n  const collapse = normalizeCstCollapse(typeOrOptions?.collapse)\n  const host: BuildHost = (\n    type: string,\n    children: ReadonlyArray<unknown>,\n    fields: unknown,\n    span: { start: number; end: number },\n    rawChildren: ReadonlyArray<unknown>,\n    triviaLog: readonly number[],\n    state: unknown,\n  ) => buildCstNode(type, children, fields, span, rawChildren, triviaLog, state)\n  if (collapse) host._parsemanCstCollapse = collapse\n  return host\n}\n\nexport type FusedRule = (\n  input: string,\n  pos: number,\n  ctx: Record<string, unknown>,\n) => { ok: boolean; value?: unknown; span: { start: number; end: number } }\n\n/**\n * Restrict a grammar/artifact to `names` plus their transitive rule-dependency\n * closure (\u00E0 la carte selection) \u2014 e.g. Jess taking parts of Less and parts of\n * Sass: `compose([pick(less, ['MixinCall']), pick(sass, ['EachFor']), css])`. A\n * picked rule pulls in every rule name it references, so the result is always\n * self-consistent within the artifact. Accepts a grammar (`rules()` result) or a\n * compiled artifact; returns an artifact for `compose()`.\n */\nexport function pick(\n  grammar: LinkablePieces | Record<string, Combinator<unknown>>,\n  names: string[],\n): LinkablePieces {\n  // A COMPOSED grammar (`compose([...])` result): it has no single rule map \u2014 its rules\n  // live across several carried pieces. Materialize them under the composing trivia it\n  // was built with (so the selection keeps composing-wins trivia), then filter across\n  // pieces to `names` + their transitive dep closure, keeping each rule in the piece\n  // that WINS it (compose override order = last wins). Return a composed-like value so a\n  // downstream `compose([pick(composed, \u2026)])` flattens it the same way.\n  const carried = (grammar as Record<symbol, unknown>)[COMPOSED_PIECES]\n  if (Array.isArray(carried)) {\n    const trivia = (grammar as Record<symbol, unknown>)[COMPOSED_TRIVIA] as Combinator<unknown> | undefined\n    const pieces = (carried as Array<LinkablePieces | IRPiece>).map(pc => materializePiece(pc, trivia))\n    const filtered = pickPieces(pieces, names)\n    // A composed-like value (carries COMPOSED_PIECES, no single rule map). It is only\n    // ever consumed through compose()'s COMPOSED_PIECES branch \u2014 which is checked before\n    // any LinkablePieces field \u2014 so this masquerades as LinkablePieces for the signature.\n    const out: Record<string, unknown> = {}\n    Object.defineProperty(out, COMPOSED_PIECES, { value: filtered, enumerable: false })\n    if (trivia) Object.defineProperty(out, COMPOSED_TRIVIA, { value: trivia, enumerable: false })\n    return out as unknown as LinkablePieces\n  }\n\n  const p = (grammar as LinkablePieces).ruleFns instanceof Map\n    ? (grammar as LinkablePieces)\n    : linkable(grammar as Record<string, Combinator<unknown>>)\n  return pickPieces([p], names)[0] ?? { ...p, keys: [], ruleFns: new Map(), wrappers: new Map(), deps: new Map() }\n}\n\n/** Restrict a set of linkable pieces to `names` + their transitive dep closure,\n * keeping each surviving rule in the piece that WINS it (later piece wins, matching\n * compose override order). Shared by `pick()` (runtime) and the macro's build-time\n * `pick(...)` handling, so \u00E0-la-carte selection is identical on both paths. */\nexport function pickPieces(pieces: LinkablePieces[], names: string[]): LinkablePieces[] {\n  const winner = new Map<string, LinkablePieces>()\n  for (const pc of pieces) for (const k of pc.keys) winner.set(k, pc)\n  // A requested name that isn't in the grammar is a typo \u2014 fail here, not later with a\n  // confusing name-closure error at compose() time.\n  for (const n of names) {\n    if (!winner.has(n)) throw new Error(`pick: rule \"${n}\" is not in this grammar (available: ${[...winner.keys()].join(', ')})`)\n  }\n  const keep = new Set<string>()\n  const visit = (n: string): void => {\n    // A missing winner is an EXTERNAL dep (a base-grammar rule) \u2014 it resolves at\n    // compose() time, not here. Top-level `names` were already validated above.\n    const w = winner.get(n)\n    if (keep.has(n) || !w) return\n    keep.add(n)\n    for (const d of w.deps.get(n) ?? []) visit(d)\n  }\n  for (const n of names) visit(n)\n  const filt = <V>(m: Map<string, V>, pc: LinkablePieces): Map<string, V> =>\n    new Map([...m].filter(([k]) => keep.has(k) && winner.get(k) === pc))\n  return pieces\n    .map(pc => ({ ...pc, keys: pc.keys.filter(k => keep.has(k) && winner.get(k) === pc), ruleFns: filt(pc.ruleFns, pc), wrappers: filt(pc.wrappers, pc), deps: filt(pc.deps, pc) }))\n    .filter(pc => pc.keys.length > 0)\n}\n\n/**\n * Build the fused-closure body (shared by the runtime `fuseRules` and the\n * build-time `emitFusedSource`). Returns the closure body (which reads `_env`\n * for any non-inlined callbacks) and the `_env` to bind. In macro mode callbacks\n * are inlined from source, so `_env` is empty and the body is fully static.\n */\nfunction fusedBody(pieces: LinkablePieces[]): { body: string; env: Record<string, unknown> } {\n  // Winner per rule name \u2014 later pieces override earlier ones.\n  const winner = new Map<string, LinkablePieces>()\n  for (const p of pieces) for (const k of p.keys) winner.set(k, p)\n\n  // Name-closure check: every referenced rule must resolve in the fused set.\n  for (const [k, p] of winner) {\n    for (const d of p.deps.get(k) ?? []) {\n      if (!winner.has(d)) throw new Error(`compose: rule \"${k}\" references missing rule \"${d}\"`)\n    }\n  }\n\n  const contributing = new Set(winner.values())\n  const contributingPieces = [...contributing]\n  const needsEmptyTl = contributingPieces.some(p => p.needsEmptyTl)\n  const needsHostReads = contributingPieces.some(p => p.needsHostReads)\n\n  const lines: string[] = [\n    // Shared sentinel protocol (must match NAMED_FN_FAIL / NAMED_FN_END in codegen).\n    'const _pfFail = {}',\n    'let _pfEnd',\n    ...(needsEmptyTl ? ['const _EMPTY_TL = Object.freeze([])'] : []),\n    ...(needsHostReads ? [HOST_READS_DECL] : []),\n    // Each contributing artifact's namespaced private prelude (regexes, _pf, \u2026).\n    ...new Set(contributingPieces.flatMap(p => p.prelude)),\n    // The winning `_r_<Name>` function for each rule (one per name \u2192 no redeclare).\n    ...[...winner].map(([k, p]) => p.ruleFns.get(k)!),\n  ]\n  const wrapperEntries = [...winner].map(([k, p]) => `${JSON.stringify(k)}: ${p.wrappers.get(k)!}`)\n  const rawBody = [...lines, 'return {', wrapperEntries.join(',\\n'), '}'].join('\\n')\n\n  // Fuse-time first-set dispatch: a rule-ref choice arm was emitted (in linkable\n  // mode) as `/*@FS:rule:codevar@*\u200B/true`. Resolve it now against the WINNING\n  // rule's first-set \u2014 sound under override, since we use the final rule, not the\n  // one visible when the referencing rule was compiled. Unknown / `any` /\n  // empty-matching rule \u2192 leave `true` (always try the arm; correctness over\n  // pruning). Non-composed callers with no `firstSets` table also fall through.\n  const finalFS = new Map<string, FirstSet>()\n  for (const [k, p] of winner) { const fs = p.firstSets?.get(k); if (fs) finalFS.set(k, fs) }\n  const body = rawBody.replace(\n    // Rule name + code-point var are both JS identifiers (rule names are validated\n    // at compile time \u2014 see assertRuleName in codegen), so an identifier class\n    // matches every well-formed placeholder.\n    /\\/\\*@FS:([A-Za-z0-9_$]+):([A-Za-z0-9_$]+)@\\*\\/true/g,\n    (_m, name: string, codevar: string) => {\n      const fs = finalFS.get(name)\n      if (!fs || fs.kind === 'any' || fs.kind === 'empty') return 'true'\n      return `(${firstSetCond(codevar, fs)})`\n    },\n  )\n\n  // Non-inlined callbacks (runtime compile() mode), keyed `<ns>mf` / `<ns>build`.\n  const env: Record<string, unknown> = {}\n  for (const p of contributingPieces) {\n    if (p.mfFns.length) env[`${p.ns}mf`] = p.mfFns\n    if (p.buildFns.length) env[`${p.ns}build`] = p.buildFns\n  }\n  return { body, env }\n}\n\n/** Fuse at RUNTIME (via `new Function`) \u2014 used by `compose()` when not compiled\n * by the macro (like `compile()`). The macro path uses `emitFusedSource` instead. */\nexport function fuseRules(pieces: LinkablePieces[]): Record<string, FusedRule> {\n  const { body, env } = fusedBody(pieces)\n  // eslint-disable-next-line no-new-func\n  return new Function('_env', body)(env) as Record<string, FusedRule>\n}\n\n/**\n * Fuse at BUILD time \u2014 emit the fused closure as a self-contained SOURCE\n * expression (`(() => { \u2026 })()`), with **no `new Function`**. This is what the\n * macro splices in for a `compose([...])` call, so macro output stays eval-free.\n * Requires every callback to be inlined from source (macro mode); throws if any\n * artifact carries runtime-only callback functions.\n */\nexport function emitFusedSource(pieces: LinkablePieces[]): string {\n  const { body, env } = fusedBody(pieces)\n  if (Object.keys(env).length > 0) {\n    throw new Error('emitFusedSource: artifact carries non-static callbacks (runtime-only); cannot emit static source')\n  }\n  return `/* @__PURE__ */ (() => {\\n${body}\\n})()`\n}\n\n/**\n * Compose grammars/artifacts into a runnable parser map \u2014 the ONLY public\n * composition entry point. `compose([base, ext, \u2026])`: later entries override\n * earlier ones by rule name, and because fusion re-binds every reference in one\n * shared scope, an override reroutes the base's OWN calls too (open recursion).\n *\n * Each entry may be a **grammar** (a `rules()` result \u2014 a map of combinators,\n * linkable-ified here) OR an already-compiled **linkable artifact** (what the\n * macro emits and a package ships). So a package needs no opt-in wrapper to be\n * composable \u2014 `compose([importedGrammar, myRules])` just works.\n *\n * The macro compiles `compose([...])` to STATIC fused source (no `new Function`).\n * Called at runtime (no macro, like `compile()`) it fuses via `new Function`.\n */\n/** A composed parser carries its flattened source pieces (non-enumerable) so it\n * can be composed AGAIN \u2014 `compose([lessGrammar, delta])` where `lessGrammar` is\n * itself a `compose([...])` result. */\nconst COMPOSED_PIECES = Symbol.for('parseman.composedPieces')\n\n/** The composing (outermost) trivia a runtime `compose()` applied \u2014 stored so a\n * later `pick(composedGrammar, \u2026)` can re-lower the selected rules under the SAME\n * trivia (composing-wins survives \u00E0-la-carte selection). The carried IR pieces hold\n * no trivia of their own, so it must be remembered separately. Not serialized by the\n * macro (which delegates pick to the runtime linker). */\nconst COMPOSED_TRIVIA = Symbol.for('parseman.composedTrivia')\n\n/** The compact IR form a grammar carries instead of its lowered rule source: the\n * combinator-construction expression, re-lowered here at fuse time. */\nexport type IRPiece = { ns: string; ir: string }\n\nfunction isIRPiece(p: unknown): p is IRPiece {\n  return !!p && typeof p === 'object'\n    && typeof (p as IRPiece).ir === 'string' && typeof (p as IRPiece).ns === 'string'\n    && !('ruleFns' in (p as object))\n}\n\n/** Materialize a carried item to full `LinkablePieces`: an IR piece is evaluated\n * back to a rule map and re-lowered; a full piece passes through. */\nexport function materializePiece(p: LinkablePieces | IRPiece, trivia?: Combinator<unknown>): LinkablePieces {\n  if (!isIRPiece(p)) return p\n  const pieces = compileLinkable(evalRuleMapIR(p.ir), p.ns, trivia ? { trivia } : undefined)\n  if (!pieces) throw new Error(`compose: carried IR for ns \"${p.ns}\" could not be re-lowered`)\n  return pieces\n}\n\n/** Flatten one `compose()` item to its pieces: a prior composed result \u2192 its\n * carried list; an artifact \u2192 itself; a grammar (`rules()` map) \u2192 linkable-ified. */\nfunction nextComposeNs(used: Set<string>): string {\n  let ns: string\n  do { ns = `_lk${_nsCounter++}_` } while (used.has(ns))\n  used.add(ns)\n  return ns\n}\n\n/** Flatten one `compose()` item to its RE-LOWERABLE carried items \u2014 the form stored\n * on the composed result so it can be composed AGAIN under a NEW composing trivia.\n * A grammar (`rules()` map) is carried as compact IR (`{ns, ir}`), NOT baked source,\n * so a later `compose([thisResult, delta])` re-lowers it with the delta's trivia\n * (multi-level composing-wins). A prior composed result contributes its OWN carried\n * items (already IR); a pre-compiled artifact has no source, so it stays baked. */\nfunction itemCarried(\n  item: LinkablePieces | Record<string, unknown>,\n  used: Set<string>,\n  trivia?: Combinator<unknown>,\n): Array<LinkablePieces | IRPiece> {\n  const carried = (item as Record<symbol, unknown>)[COMPOSED_PIECES]\n  // A prior composed result (runtime or macro-compiled): its carried list is already\n  // re-lowerable (IR pieces, plus any pre-compiled artifacts). Pass it through so THIS\n  // compose re-lowers it under its own composing trivia. Reserve its namespaces so a\n  // sibling grammar map can't collide with them.\n  if (Array.isArray(carried)) {\n    const items = carried as Array<LinkablePieces | IRPiece>\n    for (const p of items) used.add(p.ns)\n    return items\n  }\n  // A pre-compiled artifact (`linkable()`/`pick()`): no source to re-lower \u2014 its trivia\n  // was baked when it was compiled. Keep it as-is.\n  if ((item as LinkablePieces).ruleFns instanceof Map) {\n    const p = item as LinkablePieces\n    used.add(p.ns)\n    return [p]\n  }\n  // A grammar (`rules()` map): carry it as compact IR so a later compose re-lowers it\n  // under ITS trivia. Unserializable \u2192 bake now with this compose's trivia (can't\n  // re-lower later; acceptable fallback, mirrors the macro's full-pieces fallback).\n  const map = item as Record<string, Combinator<unknown>>\n  const ns = nextComposeNs(used)\n  // Drop EXTERNAL entries first (same filter as compileLinkable): a `rules()` cache\n  // also holds every ACCESSED-but-undefined `g.X` as an unresolved-lazy entry. Left in,\n  // serializeRuleMap would emit `X: g[\"X\"]` \u2014 a self-referential rule that shadows the\n  // sibling artifact defining X and recurses forever. They resolve by name at fuse time.\n  const entries = Object.entries(map).filter(([, val]) => {\n    const d = val._def\n    if (d.tag !== 'lazy') return true\n    try { d.thunk(); return true } catch { return false }\n  })\n  const ir = serializeRuleMap(entries)\n  return ir ? [{ ns, ir }] : [linkable(map, ns, trivia)]\n}\n\n/** The composed grammar's ambient trivia = the LAST composed item that declares a\n * grammar-level trivia (via `rules({ trivia }, \u2026)`, which tags `grammarTrivia` on its\n * rules). Outermost wins: the composing grammar's trivia applies to every fused rule,\n * including those inherited from a base \u2014 so e.g. an SCSS `rw` (which extends Less's)\n * governs the inherited Less/CSS rules too. `parser`/`noTrivia` still override locally. */\nfunction composingTriviaOf(items: Array<LinkablePieces | Record<string, unknown>>): Combinator<unknown> | undefined {\n  for (let i = items.length - 1; i >= 0; i--) {\n    const item = items[i] as Record<string, unknown> | undefined\n    if (!item || (item as LinkablePieces).ruleFns instanceof Map || (item as Record<symbol, unknown>)[COMPOSED_PIECES]) continue\n    for (const v of Object.values(item)) {\n      const t = (v as Combinator<unknown> | undefined)?._meta?.grammarTrivia\n      if (t) return t\n    }\n  }\n  return undefined\n}\n\nexport function compose(\n  items: Array<LinkablePieces | Record<string, unknown>>,\n): Record<string, FusedRule> {\n  const used = new Set<string>()\n  // The composed grammar's ambient trivia comes from the composing grammar itself \u2014\n  // whatever the last piece declared via rules({ trivia }, \u2026). No separate option:\n  // the trivia rides with the grammar that declared it.\n  const trivia = composingTriviaOf(items)\n  // Carried items are RE-LOWERABLE (IR); materialize them ONCE with this compose's\n  // trivia for the now-fuse, but STORE the un-materialized carried list so a later\n  // compose can re-lower it under a different trivia (multi-level composing-wins).\n  const carried = items.flatMap(item => itemCarried(item, used, trivia))\n  const pieces = carried.map(p => materializePiece(p, trivia))\n  const map = fuseRules(pieces)\n  Object.defineProperty(map, COMPOSED_PIECES, { value: carried, enumerable: false })\n  if (trivia) Object.defineProperty(map, COMPOSED_TRIVIA, { value: trivia, enumerable: false })\n  return map\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\n\n/**\n * Zero-width assertion: succeeds (consuming nothing) only when `predicate`\n * returns true for `ctx.state`. Fails otherwise.\n *\n * Intended for use inside sequence() to gate subsequent parsing on runtime\n * context set with withCtx().\n *\n *   const returnStmt = sequence(\n *     guard(ctx => (ctx as { inFn: boolean }).inFn),\n *     literal('return'), optional(expr)\n *   )\n */\nexport function guard(predicate: (state: unknown) => boolean): Combinator<null> {\n  const meta: ParserMeta = {\n    firstSet: { kind: 'any' },\n    canMatchNewline: false,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'guard',\n    _meta: meta,\n    _def: { tag: 'guard', predicate },\n    parse(_input: string, pos: number, ctx: ParseContext): ParseResult<null> {\n      if (predicate(ctx.state))\n        return { ok: true, value: null, span: { start: pos, end: pos } }\n      return { ok: false, expected: ['guard'], span: { start: pos, end: pos } }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\n\n/**\n * Runs `combinator` with `ctx.state` set to `extra` for the duration of the parse.\n * The outer user context is restored on exit (lexical scoping).\n *\n *   const functionBody = withCtx({ inFn: true },\n *     sequence(literal('{'), many(statement), literal('}'))\n *   )\n *\n * Read back with guard() or from within a transform's span argument.\n */\nexport function withCtx<U, T>(extra: U, combinator: Combinator<T>): Combinator<T> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'withCtx',\n    _meta: meta,\n    _def: { tag: 'withCtx', extra, parser: combinator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      return combinator.parse(input, pos, { ...ctx, state: extra })\n    },\n  }\n}\n", "import type { Combinator, ParseFail, ParseContext, ParseResult } from '../types.ts'\nimport { REC } from '../recovery/scan.ts'\n\n/** Anything `completionsAt` can probe: an interpreter combinator OR a `compile()`d\n * grammar. A grammar compiled with `{ recovery: true }` records the probe on its fast\n * path, so completions work on the published compiled artifact \u2014 no interpreter needed. */\ntype CompletionsTarget =\n  | Combinator<unknown>\n  | { parseWithContext(input: string, ctx: ParseContext, pos?: number): ParseResult<unknown> }\n\n/**\n * Returns the set of expected tokens at the given cursor offset.\n * Useful for implementing IDE completions.\n *\n * Runs the parser on input truncated at `offset` with a probe that tracks the\n * highest-position failure seen, even when sepBy/many backtrack past the cursor.\n * Returns the expected tokens from that deepest failure.\n *\n * Works on the interpreter combinator OR a `compile(g, { recovery: true })` grammar\n * (the probe is recorded on the compiled fast path). Returns an empty array when the\n * input up to `offset` parses completely with no failures at or before the cursor.\n *\n * The returned strings use the same labels as ParseFail.expected:\n * quoted literals like `\"\\\"{\\\"\"` and regex patterns like `\"/[0-9]+/\"`.\n */\nexport function completionsAt(\n  target: CompletionsTarget,\n  input: string,\n  offset: number,\n  options: { tolerant?: boolean } = {},\n): string[] {\n  const probe: { offset: number; best: ParseFail | null } = { offset, best: null }\n  // In tolerant mode, list recovery keeps the enclosing node parsing past a bad\n  // element so the failure at the cursor is actually recorded \u2014 the completion set\n  // is otherwise empty when a permissive top rule \"succeeds\" with an unconsumed tail.\n  const ctx: ParseContext = { trackLines: false, _probe: probe, ...(options.tolerant ? { _tolerant: true, _rec: REC } : {}) }\n  const sliced = input.slice(0, offset)\n  const result = 'parseWithContext' in target\n    ? target.parseWithContext(sliced, ctx, 0)\n    : target.parse(sliced, 0, ctx)\n\n  // If the parser consumed everything up to offset successfully, there is nothing\n  // to complete \u2014 the input is already valid at this position. In tolerant mode the\n  // parse \"succeeds\" (list recovery swallowed the incomplete element at the cursor),\n  // so the meaningful expectation lives in the deepest failure the probe recorded\n  // while recovering: return that instead of an empty set.\n  if (result.ok) return options.tolerant ? (probe.best?.expected ?? []) : []\n\n  // Use whichever failure (probe or top-level) sits at the deeper position.\n  const best = deeperFail(probe.best, result)\n  return best?.expected ?? []\n}\n\nfunction deeperFail(a: ParseFail | null, b: ParseFail | null): ParseFail | null {\n  if (!a) return b\n  if (!b) return a\n  return a.span.start >= b.span.start ? a : b\n}\n", "/**\n * Relative span model for incremental edits.\n *\n * Absolute source offsets are simple but fragile: an insertion at offset `at`\n * shifts EVERY downstream offset, so a whole-tree renumber is O(nodes-after-edit).\n * Storing each node's span RELATIVE to its parent's start makes edits local: an\n * insertion inside child k of a node only changes\n *   (a) child k's relative end,\n *   (b) the relative start of siblings after k,\n * and leaves the *children* of those shifted siblings untouched \u2014 they move with\n * their parent for free. So the mutation count is O(depth + trailing siblings),\n * not O(all following nodes), and every unaffected subtree is shared by identity.\n *\n * An absolute view is recovered on query by accumulating the parent base as you\n * descend (the `absolutize` / `absoluteSpanAt` cursor) \u2014 one source of truth,\n * two manifestations.\n */\n\n/** A node with an ABSOLUTE source span and ordered children. */\nexport type AbsNode = {\n  readonly start: number\n  readonly end: number\n  readonly children: readonly AbsNode[]\n}\n\n/** A node whose `start`/`end` are RELATIVE to its parent's start (root base = 0). */\nexport type RelNode = {\n  readonly start: number\n  readonly end: number\n  readonly children: readonly RelNode[]\n}\n\n/** Convert an absolute tree to parent-relative spans. */\nexport function relativize(node: AbsNode, parentBase = 0): RelNode {\n  return {\n    start: node.start - parentBase,\n    end: node.end - parentBase,\n    children: node.children.map((c) => relativize(c, node.start)),\n  }\n}\n\n/** Reconstruct absolute spans from a relative tree. Inverse of `relativize`. */\nexport function absolutize(node: RelNode, parentBase = 0): AbsNode {\n  const start = parentBase + node.start\n  return {\n    start,\n    end: parentBase + node.end,\n    children: node.children.map((c) => absolutize(c, start)),\n  }\n}\n\n/**\n * Absolute span of the node at `path` (child indices from the root), accumulating\n * the base as it descends \u2014 O(path length), no full absolutize. The relative-form\n * cursor: query any node's absolute position without materializing the whole tree.\n */\nexport function absoluteSpanAt(root: RelNode, path: readonly number[]): { start: number; end: number } {\n  let base = 0\n  let node = root\n  for (const idx of path) {\n    base += node.start\n    const child = node.children[idx]\n    if (!child) throw new RangeError(`absoluteSpanAt: no child ${idx} on path ${path.join('.')}`)\n    node = child\n  }\n  return { start: base + node.start, end: base + node.end }\n}\n\n// ---------------------------------------------------------------------------\n// CST-shaped projection (parseDoc incremental trees)\n//\n// The bare Abs/RelNode helpers above are the reference model. The functions\n// below apply the same relative-span algebra to real CST children \u2014 nodes,\n// leaves, and error nodes \u2014 where the span is a nested `{ start, end }` and\n// children are heterogeneous (leaves carry a span but no `children`). Trivia\n// never appears in structural `children`, so every child has a span.\n// ---------------------------------------------------------------------------\n\n/**\n * A CST child as far as span projection cares: a nested span + optional children.\n * `children` is typed loosely (`unknown[]`) so the real heterogeneous CST unions\n * (nodes, leaves, error nodes \u2014 a leaf has no `children`) satisfy it directly.\n */\ntype Spanned = {\n  readonly span: { readonly start: number; readonly end: number }\n  readonly children?: readonly unknown[]\n}\n\n/**\n * Rewrite a CST subtree's spans to be RELATIVE to `parentBase` (the absolute\n * start of the node's parent; root base = 0). Each child's own children are\n * relativized against *this* node's absolute start. Preserves every other field\n * (`_tag`, `type`, `state`, leaf `value`, \u2026) by shallow spread.\n */\nexport function relativizeCST<T extends Spanned>(node: T, parentBase = 0): T {\n  const span = { start: node.span.start - parentBase, end: node.span.end - parentBase }\n  if (node.children) {\n    const base = node.span.start\n    return { ...node, span, children: node.children.map((c) => relativizeCST(c as Spanned, base)) } as T\n  }\n  return { ...node, span } as T\n}\n\n/** Reconstruct absolute CST spans from a relative subtree. Inverse of `relativizeCST`. */\nexport function absolutizeCST<T extends Spanned>(node: T, parentBase = 0): T {\n  const start = parentBase + node.span.start\n  const span = { start, end: parentBase + node.span.end }\n  if (node.children) {\n    return { ...node, span, children: node.children.map((c) => absolutizeCST(c as Spanned, start)) } as T\n  }\n  return { ...node, span } as T\n}\n\n/**\n * Absolute span of the CST node at `path` (child indices from the root),\n * accumulating the base as it descends \u2014 O(path length), no full absolutize.\n * The relative-form cursor for a positioned CST: query one node's absolute\n * position without materializing the whole tree.\n */\nexport function absoluteSpanCST(root: Spanned, path: readonly number[]): { start: number; end: number } {\n  let base = 0\n  let node: Spanned = root\n  for (const idx of path) {\n    base += node.span.start\n    const child = node.children?.[idx] as Spanned | undefined\n    if (!child) throw new RangeError(`absoluteSpanCST: no child ${idx} on path ${path.join('.')}`)\n    node = child\n  }\n  return { start: base + node.span.start, end: base + node.span.end }\n}\n\n/** Naive absolute reshift (baseline): shift every offset >= `at` by `delta`. */\nexport function shiftAbsolute(node: AbsNode, at: number, delta: number): AbsNode {\n  const s = node.start >= at ? node.start + delta : node.start\n  const e = node.end >= at ? node.end + delta : node.end\n  return {\n    start: s,\n    end: e,\n    children: node.children.map((c) => shiftAbsolute(c, at, delta)),\n  }\n}\n\n/**\n * Apply an edit of `delta` characters at absolute offset `at` to a RELATIVE tree.\n * Returns a new relative tree; every subtree that ends at/before `at` (in absolute\n * terms) is returned by IDENTITY (unchanged), so the result structurally shares\n * all unaffected subtrees with the input.\n *\n * `stats.allocated` counts nodes that had to be re-created \u2014 the incremental cost.\n */\nexport function applyEdit(\n  root: RelNode,\n  at: number,\n  delta: number,\n  stats?: { allocated: number },\n): RelNode {\n  // The root has no parent; its base never shifts (base 0).\n  return editNode(root, at, delta, 0, 0, stats)\n}\n\nfunction editNode(\n  node: RelNode,\n  at: number,\n  delta: number,\n  parentBase: number,\n  parentShift: number, // how much this node's parent base moved (0 or delta)\n  stats?: { allocated: number },\n): RelNode {\n  const absStart = parentBase + node.start\n  const absEnd = parentBase + node.end\n\n  // Strictly before the edit \u2192 unchanged (its parent base is also unshifted).\n  // Uses `< at` (not `<=`) to match the shift convention: offsets `>= at` move,\n  // so a node ending exactly at `at` grows and must be rewritten.\n  if (absEnd < at) return node\n\n  // Fully after the edit AND the parent moved by `delta` too \u2192 this node moves as\n  // one unit with its parent, so its parent-relative offsets are identical. Share\n  // the ENTIRE subtree by identity \u2014 this is the O(depth) locality win.\n  const startShifts = absStart >= at\n  if (startShifts && parentShift === delta) return node\n\n  if (stats) stats.allocated++\n\n  const newAbsStart = startShifts ? absStart + delta : absStart\n  const newAbsEnd = absEnd + delta // absEnd > at here (fully-before returned above)\n  const newParentBase = parentBase + parentShift\n  const newStart = newAbsStart - newParentBase\n  const newEnd = newAbsEnd - newParentBase\n\n  // Children are relative to this node's absolute start. Our own shift (0 or delta)\n  // becomes their parentShift.\n  const ownShift = newAbsStart - absStart\n  let changed = false\n  const newChildren: RelNode[] = []\n  for (const c of node.children) {\n    const nc = editNode(c, at, delta, absStart, ownShift, stats)\n    if (nc !== c) changed = true\n    newChildren.push(nc)\n  }\n\n  return {\n    start: newStart,\n    end: newEnd,\n    children: changed ? newChildren : node.children,\n  }\n}\n", "/**\n * Incremental parse document \u2014 incremental re-parse over a rules() registry.\n */\nimport type { Combinator, ParseContext, ParseError, ParseResult, ParserDef, Span } from '../types.ts'\nimport type { NodeLike, CSTLeaf, CSTError } from '../cst/types.ts'\nimport { relativizeCST, absoluteSpanCST } from '../cst/relative-spans.ts'\nimport { REC } from '../recovery/scan.ts'\n\n/**\n * Build the parse ctx for a (re)parse. In `tolerant` mode the same recovery bundle\n * the interpreter/`run` use is installed (`_tolerant` + `_rec`), so a broken edit\n * keeps producing a tree (with recovered `ParseError`s embedded) instead of\n * collapsing to `null`. Strict mode is byte-identical to before. Every reparse site\n * \u2014 root, localized rule reparse, list-splice middle, and the soundness probes \u2014\n * threads the SAME flag, so a probe's tolerance matches the parse it is checking\n * (a mismatch would spuriously diverge and forgo reuse, never miscompare).\n */\nfunction mkCtx(state: unknown, build: ParseContext['build'], tolerant: boolean): ParseContext {\n  return tolerant\n    ? { trackLines: false, state, build, _tolerant: true, _rec: REC, _errors: [] }\n    : { trackLines: false, state, build }\n}\n\n/** A single compiled (or interpreted) rule: parse from `pos`, producing node `N`. */\nexport type RuleFn<N> = (input: string, pos: number, ctx: ParseContext) => ParseResult<N>\n\n/**\n * Rule name \u2192 parser. Each entry is either a bare parse function or a\n * `Combinator` (what `rules()` returns). Passing the `rules()` combinators\n * directly lets `.edit()` inspect the grammar \u2014 required for **sound** structural\n * list-reuse (see `structuralReuse`): only a rule the grammar proves is a genuine\n * repetition is ever spliced. A bare-function registry still parses correctly; it\n * just can't be structurally reused (the splice is skipped, never guessed).\n */\nexport type Registry<N> = Record<string, RuleFn<N> | Combinator<N>>\n\n/** Normalize a registry entry to a callable parse function. */\nfunction asRuleFn<N>(entry: RuleFn<N> | Combinator<N>): RuleFn<N> {\n  return typeof entry === 'function' ? entry : (input, pos, ctx) => entry.parse(input, pos, ctx)\n}\n\n/** The combinator def behind a registry entry, if it carries one (bare functions don't). */\nfunction defOf(entry: unknown): ParserDef | undefined {\n  return typeof entry === 'object' && entry !== null && '_def' in entry\n    ? (entry as { _def: ParserDef })._def\n    : undefined\n}\n\n/**\n * Does this rule's grammar produce its element children via a genuine, unbounded\n * **repetition** (`sepBy` / `many` / `oneOrMore`) \u2014 as opposed to a fixed-arity\n * sequence of same-typed tokens (e.g. `Triple = Num ',' Num ',' Num`)? Only the\n * former is sound to structurally reuse: a full reparse accepts any element count,\n * so splicing one in or out matches it; a fixed-arity rule would not. We walk the\n * def, transparently unwrapping semantic wrappers (`node`, `transform`, \u2026) and\n * looking through a top-level `sequence` / `optional` (the `[ (sepBy)? ]` shape),\n * and return true iff a repetition combinator is reachable that way. Structurally\n * indistinguishable-from-the-CST cases (fixed sequences) return false and fall\n * back to a full, correct reparse. This is what makes `structuralReuse` sound\n * rather than a promise the caller has to keep.\n */\nfunction producesRepetition(def: ParserDef | undefined, depth = 0): boolean {\n  if (!def || depth > 24) return false\n  const d = def as ParserDef & Record<string, unknown>\n  switch (d.tag) {\n    case 'sepBy':\n    case 'many':\n    case 'oneOrMore':\n      return true\n    // Rule entries and `ref`s wrap their body in a `lazy` thunk \u2014 resolve it. The\n    // `depth` cap bounds any self-referential cycle (a repetition, if present, is\n    // found shallowly before recursion goes deep).\n    case 'lazy': {\n      const thunk = d.thunk as (() => { _def?: ParserDef }) | undefined\n      let inner: { _def?: ParserDef } | undefined\n      try { inner = typeof thunk === 'function' ? thunk() : undefined } catch { return false }\n      return producesRepetition(inner?._def, depth + 1)\n    }\n    // Transparent wrappers \u2014 look through to the inner parser.\n    case 'node':\n    case 'transform':\n    case 'token':\n    case 'label':\n    case 'field':\n    case 'expect':\n    case 'withCtx':\n    case 'grammar':\n    case 'optional':\n      return producesRepetition(defOf(d.parser), depth + 1)\n    case 'skip':\n      return producesRepetition(defOf(d.main), depth + 1)\n    // A bracketed/anchored list is a sequence whose element run is a repetition.\n    case 'sequence':\n      return (d.parsers as unknown[]).some(p => producesRepetition(defOf(p), depth + 1))\n    default:\n      return false\n  }\n}\n\nexport type ParseDocOptions<N extends NodeLike> = {\n  /** Initial grammar state threaded into ctx.state for the root parse. */\n  state?: unknown\n  /**\n   * Reconstruct a parent node with one child replaced (used when grafting a\n   * re-parsed subtree into its ancestors). Defaults to a shallow spread, which\n   * works for plain-object nodes; class-instance ASTs should supply their own.\n   */\n  rebuild?: (node: N, children: ReadonlyArray<N | CSTLeaf | CSTError>) => N\n  /**\n   * Mode host for a linkable/fused grammar (RULE_ABI_PLAN \u00A77): threaded into\n   * `ctx.build` on every (re)parse so `node()` rules build a positioned CST /\n   * language-service tree instead of their own eval-AST. Unset \u2192 the grammar's\n   * own builders (eval mode).\n   */\n  build?: ParseContext['build']\n  /**\n   * Enable structural list-reuse: on a length-changing *structural* edit (adding\n   * or removing a whole element in a collection) that would otherwise force a full\n   * reparse, reparse only the disturbed span and reuse the collection's untouched\n   * tail elements by identity \u2014 turning an insert near the top of a large list from\n   * O(list) into O(edit + trailing siblings).\n   *\n   * OFF by default because it is sound only when a rule whose CST children form a\n   * homogeneous, separator-delimited element list is a genuine REPETITION\n   * (`many` / `sepBy` / `oneOrMore`), not a fixed-arity sequence of same-typed\n   * tokens (e.g. `Triple = Num ',' Num ',' Num`) \u2014 the two are structurally\n   * indistinguishable without the grammar, and splicing the latter would accept an\n   * element count it shouldn't. Turn it on when your list rules are true\n   * repetitions (the common case: JSON arrays/objects, CSS value lists, argument\n   * lists). Every splice is still guarded (exact tiling + lookahead probe +\n   * stateless-tail check) and falls back to a full, correct reparse when unproven;\n   * the flag only authorises *attempting* the reuse.\n   */\n  structuralReuse?: boolean\n  /**\n   * Parse tolerantly: `many`/`sepBy`/`oneOrMore` recover from a failed element\n   * (skip to an inferred sync point, embed a `ParseError` over the skipped span),\n   * so a broken edit keeps producing a tree instead of collapsing to `null` \u2014 the\n   * editor-backend path. Off by default (strict, byte-identical). Recovery is a cold\n   * path: well-formed input never triggers it. Every reparse the doc does \u2014 root,\n   * localized rule, and list-splice \u2014 inherits this flag, and the reuse-soundness\n   * probes run at the same tolerance so incremental reuse stays valid under recovery\n   * (a scan that would cross a splice boundary just falls back to a full reparse).\n   */\n  tolerant?: boolean\n  /**\n   * The grammar's trivia rule, used ONLY to compute `unconsumedFrom`: a root rule\n   * consumes trivia BETWEEN terms but not after the last, so trailing\n   * whitespace/comments would otherwise read as leftover input. Given the trivia\n   * rule, the tail is skipped before reporting the first unconsumed offset \u2014\n   * matching `run()`'s semantics. Defaults to the root rule's own\n   * `_meta.grammarTrivia` (from `rules({ trivia })`); set it only to override.\n   */\n  trivia?: Combinator<unknown>\n}\n\nexport interface ParseDoc<N extends NodeLike> {\n  /**\n   * The parse tree with PARENT-RELATIVE spans \u2014 each node's `span` is relative to\n   * its parent's start (root base 0). This is the shareable representation: a\n   * length-changing `.edit()` keeps every untouched subtree shared by identity,\n   * and reading the tree is O(1) (no offset rewrite). For absolute positions use\n   * the O(depth) cursor `spanAt(path)`, or `absolutizeCST(doc.tree)` to\n   * materialize the whole absolute tree. A fresh non-incremental `node().parse()`\n   * result is unchanged \u2014 still absolute.\n   */\n  readonly tree: N | null\n  /**\n   * Recovery diagnostics collected during the (re)parse \u2014 the missing-token\n   * `expect()` errors and tolerant-list recovery errors that ride the tree as\n   * `parseError` nodes, surfaced here as a flat list too (spans ABSOLUTE). Empty\n   * in strict mode. On a hard (non-recovered) parse failure this holds the single\n   * top-level failure. This is what makes an editor document able to see syntax\n   * errors \u2014 a blank `errors: []` (the prior behaviour) hid every recovery.\n   */\n  readonly errors: ParseError[]\n  /**\n   * Offset where unparsed input begins \u2014 the first non-trivia character the parse\n   * left unconsumed (trailing trivia skipped when a trivia rule is available), or\n   * `null` if the whole input was consumed. This is how a document detects \"the\n   * grammar stopped short, there's junk here\"; computed exactly as `run()` does.\n   */\n  readonly unconsumedFrom: number | null\n  readonly input: string\n  /**\n   * Absolute span of the node at `path` (child indices from the root) \u2014 O(depth),\n   * without materializing the absolute tree. The projection cursor for the\n   * relative representation; use it for spot queries on a large incremental doc.\n   */\n  spanAt(path: readonly number[]): { start: number; end: number }\n  /**\n   * Incrementally re-parse after a text change. `from`/`to` are byte offsets in\n   * the OLD input; `replacement` fills that range (editor change-event shape).\n   * Sound: the result tree is always structurally identical to a fresh\n   * `parseDoc` of the edited text (the Stage-2 guard falls back to a full\n   * reparse whenever reuse can't be proven safe). Reuse/strategy is intentionally\n   * NOT reported here \u2014 an observer derives it by diffing this tree against the\n   * previous one (see the incremental tests); the runtime's job is to be fast,\n   * not to measure itself.\n   */\n  edit(from: number, to: number, replacement: string): ParseDoc<N>\n}\n\n// ---------------------------------------------------------------------------\n// Tree navigation (generic over NodeLike \u2014 no class, no CST assumptions)\n// ---------------------------------------------------------------------------\n\n/**\n * A reentry candidate is only worth reparsing if it's meaningfully smaller than\n * the whole document \u2014 reparsing a rule that spans (say) >half the input costs\n * about as much as a full reparse with none of the reuse. Above this fraction of\n * the input length, `.edit()` skips straight to a full reparse. Keeps the worst\n * case (a structural edit near the front) at ~1\u00D7 full reparse, never several.\n */\nconst REENTRY_MAX_SPAN_FRACTION = 0.5\n\ntype FoundNode<N extends NodeLike> = { node: N; path: number[] }\n\nfunction isNode(x: unknown): x is NodeLike {\n  return typeof x === 'object' && x !== null && (x as { _tag?: string })._tag === 'node'\n}\n\n/**\n * Locate the deepest node containing absolute offset `pos`. The tree stores\n * PARENT-RELATIVE spans (see relative-spans), so we thread each node's absolute\n * start down the descent: a child's absolute start is `nodeAbsStart +\n * child.span.start`.\n */\nfunction findContaining<N extends NodeLike>(\n  node: N,\n  nodeAbsStart: number,\n  pos: number,\n  path: number[] = [],\n): FoundNode<N> | null {\n  for (let i = 0; i < node.children.length; i++) {\n    const child = node.children[i]!\n    if (!isNode(child)) continue\n    const childAbsStart = nodeAbsStart + child.span.start\n    const childAbsEnd = nodeAbsStart + child.span.end\n    if (childAbsStart <= pos && pos < childAbsEnd) {\n      const inner = findContaining(child as N, childAbsStart, pos, [...path, i])\n      return inner ?? { node: child as N, path: [...path, i] }\n    }\n  }\n  return null\n}\n\nfunction ancestorsAt<N extends NodeLike>(root: N, path: number[]): N[] {\n  const ancestors: N[] = [root]\n  let cur: N = root\n  for (const idx of path.slice(0, -1)) {\n    const child = cur.children[idx]\n    if (!child || !isNode(child)) break\n    ancestors.push(child as N)\n    cur = child as N\n  }\n  return ancestors\n}\n\nfunction replaceAtPath<N extends NodeLike>(\n  rebuild: NonNullable<ParseDocOptions<N>['rebuild']>,\n  root: N,\n  path: number[],\n  newNode: N,\n): N {\n  if (path.length === 0) return newNode\n  const [idx, ...rest] = path as [number, ...number[]]\n  const newChildren = [...root.children] as Array<N | CSTLeaf | CSTError>\n  newChildren[idx] = rest.length === 0\n    ? newNode\n    : replaceAtPath(rebuild, root.children[idx] as N, rest, newNode)\n  return rebuild(root, newChildren)\n}\n\nfunction defaultRebuild<N extends NodeLike>(node: N, children: ReadonlyArray<N | CSTLeaf | CSTError>): N {\n  return { ...node, children } as N\n}\n\ntype SpanChild = { span: { start: number; end: number }; children?: readonly unknown[] }\n\n/**\n * Shift a node's PARENT-RELATIVE span by `delta`. Used for siblings that sit\n * *after* a length-changing edit inside the same parent: the node moved as a\n * unit, so both endpoints slide by `delta`, but its own children are relative to\n * *its* start and are unchanged \u2014 so `children` is shared by identity. That's the\n * relative-span win: O(1) per trailing sibling, not O(subtree). (Contrast the old\n * absolute model, which had to deep-rewrite every descendant.)\n */\nfunction shiftRelStart<T>(child: T, delta: number): T {\n  const c = child as unknown as SpanChild\n  return { ...(c as object), span: { start: c.span.start + delta, end: c.span.end + delta } } as unknown as T\n}\n\n/**\n * Graft `newNode` at `path` into a parent-relative tree for a length-changing\n * edit (`delta !== 0`): children before the edit are shared by reference, the\n * edited child is replaced, children *after* it have their relative start slid by\n * `delta` (one shallow alloc each \u2014 their subtrees are shared by identity), and\n * each ancestor's relative `span.end` grows by `delta` while its start is\n * untouched. Cost is O(depth + trailing siblings along the spine), independent of\n * how many nodes sit inside those trailing siblings.\n */\nfunction graftRelative<N extends NodeLike>(root: N, path: number[], newNode: N, delta: number): N {\n  if (path.length === 0) return newNode\n  const [idx, ...rest] = path as [number, ...number[]]\n  const oldChildren = root.children as ReadonlyArray<N | CSTLeaf | CSTError>\n  const newChildren = oldChildren.map((child, i) => {\n    if (i < idx) return child\n    if (i === idx) {\n      return rest.length === 0 ? newNode : graftRelative(child as N, rest, newNode, delta)\n    }\n    return shiftRelStart(child, delta)\n  })\n  return {\n    ...root,\n    span: { start: root.span.start, end: root.span.end + delta },\n    children: newChildren,\n  } as N\n}\n\n// ---------------------------------------------------------------------------\n// List-splice reuse (structural edits in a collection)\n//\n// A structural edit \u2014 inserting or deleting a whole element in a list \u2014 makes the\n// innermost-rule reparse fail to converge, and the containing collection is often\n// too big to reparse (that's the \"insert at the top of a large array\" case where\n// a whole-rule reparse costs ~a full reparse). Instead of reparsing the whole\n// collection, reparse ONLY the disturbed span between the last untouched element\n// before the edit and the first untouched element after it, then splice: the head\n// children are shared as-is, the freshly-parsed middle replaces the changed run,\n// and the tail children are reused with their relative start slid by `delta`\n// (O(1) each \u2014 their subtrees are shared by identity, the relative-span win).\n//\n// Soundness rests on: (1) the reparsed middle exactly fills [reStart, reEnd) and\n// lands on element/separator boundaries; (2) a lookahead probe proving the middle\n// read nothing at/after the splice point (else it peeked into the reused tail);\n// (3) a stateless-reentry precondition on the reused tail (its saved `state` is\n// null), so a forward, context-free grammar reproduces those subtrees unchanged.\n// Any failure \u21D2 `null` \u21D2 the caller falls back to a full, correct reparse. The\n// incremental oracle fuzz (edit() \u2261 full reparse, 400 seeds \u00D7 3 list grammars +\n// edge cases) is the end-to-end correctness net.\n// ---------------------------------------------------------------------------\n\ntype AnyChild = { readonly _tag: string; readonly span: { start: number; end: number }; readonly value?: string; readonly type?: string; readonly state?: unknown; readonly children?: readonly unknown[] }\n\n/**\n * Parse the collection's disturbed middle `[reStart, reEnd)` as an\n * `element (separator element)*` run (optionally with a trailing separator that\n * connects to the reused tail), C-relative. Alternation is STRICT: after an\n * element, if we're not yet at `reEnd`, the separator MUST match \u2014 element/element\n * juxtaposition is rejected (that's a `sepBy` violation). When the grammar has no\n * separator (`separator === null`, i.e. a bare repetition), consecutive elements\n * are allowed. Returns the C-relative children, or `null` if the run doesn't tile\n * `[reStart, reEnd)` exactly on token boundaries.\n */\nfunction parseMiddle(\n  input: string,\n  reStart: number,\n  reEnd: number,\n  cStart: number,\n  ruleFn: RuleFn<NodeLike>,\n  separator: string | null,\n  build: ParseContext['build'],\n  tolerant: boolean,\n): AnyChild[] | null {\n  const ctx: ParseContext = mkCtx(null, build, tolerant)\n  const out: AnyChild[] = []\n  let pos = reStart\n  let guard = 0\n  while (pos < reEnd) {\n    if (++guard > reEnd - reStart + 2) return null // no-progress backstop\n    // After an element, a separator is mandatory before the next element (unless\n    // the grammar is separator-free). This is what keeps `elem elem` \u2014 invalid in\n    // a `sepBy` \u2014 from being accepted as two elements.\n    if (separator && out.length > 0 && out[out.length - 1]!._tag === 'node') {\n      if (pos + separator.length > reEnd || !input.startsWith(separator, pos)) return null\n      out.push({ _tag: 'leaf', value: separator, span: { start: pos - cStart, end: pos + separator.length - cStart } })\n      pos += separator.length\n      continue\n    }\n    let r: ParseResult<NodeLike>\n    try {\n      r = ruleFn(input, pos, ctx)\n    } catch {\n      return null\n    }\n    if (!r.ok || r.span.end <= pos || r.span.end > reEnd) return null\n    out.push(relativizeCST(r.value as unknown as AnyChild, cStart))\n    pos = r.span.end\n  }\n  return pos === reEnd ? out : null\n}\n\n/**\n * Try to reuse the untouched tail of collection `C` (at `path`, absolute start\n * `cStart`) around a length-changing edit, reparsing only the disturbed middle.\n * Returns the new relative root, or `null` to fall back to a full reparse.\n */\nfunction tryListSplice<N extends NodeLike>(\n  root: N,\n  path: number[],\n  C: N,\n  cStart: number,\n  newInput: string,\n  from: number,\n  to: number,\n  delta: number,\n  registry: Record<string, RuleFn<N>>,\n  build: ParseContext['build'],\n  tolerant: boolean,\n): N | null {\n  const kids = C.children as ReadonlyArray<AnyChild>\n  if (kids.length === 0) return null\n\n  // head = maximal prefix ending before the edit, backed off so it ends at a\n  // leaf (open delimiter or separator) \u2014 i.e. where an ELEMENT is next expected.\n  let h = 0\n  while (h < kids.length && cStart + kids[h]!.span.end <= from) h++\n  while (h > 0 && kids[h - 1]!._tag === 'node') h--\n  // tail = maximal suffix starting after the edit, advanced so it BEGINS at an\n  // element (node) boundary \u2014 a self-contained element run to reuse.\n  let t = kids.length\n  while (t > h && cStart + kids[t - 1]!.span.start >= to) t--\n  while (t < kids.length && kids[t]!._tag !== 'node') t++\n  if (t >= kids.length) return null // nothing reusable after the edit\n\n  // Stateless-reentry precondition on the reused tail (see soundness note).\n  for (let i = t; i < kids.length; i++) {\n    if (kids[i]!._tag === 'node' && kids[i]!.state != null) return null\n  }\n\n  // C must look like a genuine homogeneous COLLECTION \u2014 a repetition of one\n  // element rule joined by one separator \u2014 not a fixed heterogeneous sequence\n  // (e.g. `Pair = Key ':' Val`, whose `:` is not a list separator). Require: all\n  // element (node) children share a type, and there are \u22652 elements joined by a\n  // consistent separator leaf. This rejects fixed sequences (their nodes differ\n  // in type, or there's only one) so we never treat them as splice-able lists.\n  let elemType: string | undefined\n  let elemCount = 0\n  for (const k of kids) {\n    if (k._tag !== 'node') continue\n    elemCount++\n    if (elemType === undefined) elemType = k.type\n    else if (k.type !== elemType) return null // heterogeneous \u2192 not a collection\n  }\n  if (elemType === undefined || elemCount < 2) return null\n  const ruleFn = registry[elemType]\n  if (!ruleFn) return null\n  // The separator is the leaf that appears between two elements; require it to be\n  // consistent everywhere two elements meet (a real list delimiter).\n  let separator: string | null = null\n  for (let i = 1; i < kids.length - 1; i++) {\n    if (kids[i - 1]!._tag === 'node' && kids[i + 1]!._tag === 'node') {\n      if (kids[i]!._tag !== 'leaf') return null\n      const sep = kids[i]!.value ?? null\n      if (separator === null) separator = sep\n      else if (sep !== separator) return null // inconsistent delimiter \u2192 not a plain list\n    }\n  }\n  if (separator === null) return null // \u22652 elements but no delimiter between any pair\n\n  // The disturbed middle must be pure elements + separators. If the collection is\n  // bracketed, its OPENING / CLOSING delimiter (a leaf whose value isn't the\n  // separator, sitting before the first / after the last element) must lie OUTSIDE\n  // the edit \u2014 otherwise the edit changed the collection's own framing and a\n  // whole-rule reparse (not a splice) is required.\n  const first = kids[0]!\n  const last = kids[kids.length - 1]!\n  if (first._tag === 'leaf' && first.value !== separator && from < cStart + first.span.end) return null\n  if (last._tag === 'leaf' && last.value !== separator && to > cStart + last.span.start) return null\n\n  const reStart = h > 0 ? cStart + kids[h - 1]!.span.end : cStart\n  const reEnd = cStart + kids[t]!.span.start + delta\n  if (reEnd < reStart) return null\n\n  const middle = parseMiddle(newInput, reStart, reEnd, cStart, ruleFn as RuleFn<NodeLike>, separator, build, tolerant)\n  if (!middle) return null\n\n  // Junction check: `tail` always begins with an ELEMENT (we advanced `t` to a\n  // node), so a non-empty middle must END with a SEPARATOR to connect validly \u2014\n  // otherwise the edit deleted the delimiter between the middle's last element and\n  // the tail's first, and splicing would fuse two elements with no separator (a\n  // `sepBy` violation the whole-collection reparse would never produce). When the\n  // middle is empty the tail is preceded by `head`'s last token, itself already a\n  // separator or the open delimiter (head was backed off to a leaf), so it's fine.\n  if (middle.length > 0) {\n    const last = middle[middle.length - 1]!\n    if (!(last._tag === 'leaf' && last.value === separator)) return null\n  }\n\n  // Lookahead guard: the middle must have read nothing at/after `reEnd`, else it\n  // peeked into the reused tail. Re-run over an input whose tail is overwritten\n  // with a sentinel and require an identical middle. Two sentinels so the real\n  // byte at `reEnd` can't accidentally match the probe.\n  if (reEnd < newInput.length) {\n    for (const sentinel of [' ', '\uFFFF']) {\n      if (newInput[reEnd] === sentinel) continue\n      const probed = newInput.slice(0, reEnd) + sentinel.repeat(newInput.length - reEnd)\n      const probe = parseMiddle(probed, reStart, reEnd, cStart, ruleFn as RuleFn<NodeLike>, separator, build, tolerant)\n      if (!probe || probe.length !== middle.length) return null\n      for (let i = 0; i < middle.length; i++) if (!structurallyEqual(probe[i], middle[i])) return null\n    }\n  }\n\n  const head = kids.slice(0, h)\n  const tail = kids.slice(t).map((k) => shiftRelStart(k, delta))\n  const newC = {\n    ...C,\n    span: { start: C.span.start, end: C.span.end + delta },\n    children: [...head, ...middle, ...tail],\n  } as N\n\n  // Replace C at `path` and slide C's own trailing siblings / ancestor ends.\n  return graftRelative(root, path, newC, delta)\n}\n\n// ---------------------------------------------------------------------------\n// Stage-2 soundness guard\n// ---------------------------------------------------------------------------\n\n/**\n * Deep structural equality on parse trees: `_tag`, `span`, node `type`, leaf\n * `value`, and children pairwise. This is the oracle relation `.edit()` must\n * preserve against a full reparse; it's also what the Stage-2 guard compares\n * probe results with.\n */\nexport function structurallyEqual(a: unknown, b: unknown): boolean {\n  if (a === b) return true\n  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) return false\n  const at = (a as { _tag?: string })._tag\n  const bt = (b as { _tag?: string })._tag\n  if (at !== bt) return false\n  const as = (a as { span?: { start: number; end: number } }).span\n  const bs = (b as { span?: { start: number; end: number } }).span\n  if (as || bs) {\n    if (!as || !bs || as.start !== bs.start || as.end !== bs.end) return false\n  }\n  if (at === 'leaf' || at === 'trivia') {\n    return (a as { value: string }).value === (b as { value: string }).value\n  }\n  if (at === 'parseError') {\n    // Embedded recovered error: span already compared above; also compare the\n    // expected-token set so two errors at the same span but different expectations\n    // are not conflated (the oracle must distinguish them).\n    const ae = (a as { expected?: readonly string[] }).expected ?? []\n    const be = (b as { expected?: readonly string[] }).expected ?? []\n    return ae.length === be.length && ae.every((x, i) => x === be[i])\n  }\n  if ((a as { type?: string }).type !== (b as { type?: string }).type) return false\n  const ac = (a as { children?: readonly unknown[] }).children\n  const bc = (b as { children?: readonly unknown[] }).children\n  if (ac || bc) {\n    if (!ac || !bc || ac.length !== bc.length) return false\n    for (let i = 0; i < ac.length; i++) if (!structurallyEqual(ac[i], bc[i])) return false\n  }\n  return true\n}\n\n/**\n * A reused suffix spliced at `boundary` (new-input coords) is sound only if the\n * re-parse of the containing rule did NOT read any input at or after `boundary`\n * \u2014 otherwise a lookahead or backtrack peeked across the splice and the reused\n * tail could be wrong. We prove independence by re-running the same rule at the\n * same start on an input whose entire tail from `boundary` is overwritten with a\n * sentinel: if the produced node is byte-for-byte structurally identical,\n * nothing past `boundary` was inspected. Two distinct sentinels are tried so the\n * real char at `boundary` can't accidentally equal the probe. Conservative by\n * construction \u2014 any probe difference, failure, or throw \u21D2 not safe \u21D2 the caller\n * widens toward a full reparse (correctness over reuse fraction).\n */\nfunction boundaryIsSafe<N extends NodeLike>(\n  ruleFn: RuleFn<N>,\n  newInput: string,\n  start: number,\n  boundary: number,\n  state: unknown,\n  build: ParseContext['build'],\n  produced: ParseResult<N>,\n  tolerant: boolean,\n): boolean {\n  if (!produced.ok) return false\n  if (boundary >= newInput.length) return true // nothing after the node to peek at\n  for (const sentinel of [' ', '\uFFFF']) {\n    if (newInput[boundary] === sentinel) continue\n    const probed = newInput.slice(0, boundary) + sentinel.repeat(newInput.length - boundary)\n    const ctx: ParseContext = mkCtx(state, build, tolerant)\n    let r: ParseResult<N>\n    try {\n      r = ruleFn(probed, start, ctx)\n    } catch {\n      return false\n    }\n    if (!r.ok || r.span.end !== produced.span.end) return false\n    if (!structurallyEqual(r.value, produced.value)) return false\n  }\n  return true\n}\n\n// ---------------------------------------------------------------------------\n// Document\n// ---------------------------------------------------------------------------\n\nclass ParseDocImpl<N extends NodeLike> implements ParseDoc<N> {\n  private readonly _registry: Registry<N>\n  /** Registry entries normalized to callable parse functions (memoized once). */\n  private readonly _fns: Record<string, RuleFn<N>>\n  /** Rule names the grammar proves are genuine repetitions \u2014 the ONLY splice-safe types. */\n  private readonly _reps: Set<string>\n  private readonly _rootRule: string\n  private readonly _opts: ParseDocOptions<N>\n  /**\n   * The tree, held in whichever coordinate system it arrived in. A fresh parse\n   * arrives ABSOLUTE (`_abs` set); an incremental graft arrives PARENT-RELATIVE\n   * (`_rel` set). The public `tree` is always the RELATIVE form (so untouched\n   * subtrees stay shared by identity across edits and reads are O(1)); it's\n   * materialized from `_abs` once, on demand, and memoized. `undefined` = not yet\n   * computed; `null` = failed parse. A fresh parse that's never edited nor\n   * tree-read pays no conversion \u2014 important for the full-reparse fallback path.\n   */\n  private _abs: N | null | undefined\n  private _rel: N | null | undefined\n  readonly errors: ParseError[]\n  readonly unconsumedFrom: number | null\n  readonly input: string\n\n  constructor(\n    registry: Registry<N>,\n    rootRule: string,\n    opts: ParseDocOptions<N>,\n    trees: { abs?: N | null; rel?: N | null },\n    errors: ParseError[],\n    unconsumedFrom: number | null,\n    input: string,\n  ) {\n    this._registry = registry\n    this._fns = {}\n    this._reps = new Set()\n    for (const [name, entry] of Object.entries(registry)) {\n      this._fns[name] = asRuleFn(entry)\n      if (producesRepetition(defOf(entry))) this._reps.add(name)\n    }\n    this._rootRule = rootRule\n    this._opts = opts\n    this._abs = trees.abs\n    this._rel = trees.rel\n    this.errors = errors\n    this.unconsumedFrom = unconsumedFrom\n    this.input = input\n  }\n\n  /**\n   * The parse tree with PARENT-RELATIVE spans \u2014 a node's `span` is relative to\n   * its parent's start (root base 0). This is the shareable representation:\n   * untouched subtrees keep the same identity across `.edit()`s, and reading the\n   * tree after a length-changing edit is O(1) (no offset rewrite). For absolute\n   * positions use the O(depth) cursor `spanAt(path)`, or `absolutizeCST(tree)` to\n   * materialize the whole absolute tree. (A fresh non-incremental `node().parse()`\n   * result is unchanged \u2014 still absolute.)\n   */\n  get tree(): N | null {\n    if (this._rel === undefined) {\n      this._rel = this._abs ? (relativizeCST(this._abs as unknown as N & { span: Span }, 0) as unknown as N) : null\n    }\n    return this._rel\n  }\n\n  spanAt(path: readonly number[]): { start: number; end: number } {\n    const rel = this.tree\n    if (!rel) throw new Error('spanAt on a failed parse (tree is null)')\n    return absoluteSpanCST(rel as unknown as { span: Span; children?: readonly unknown[] }, path)\n  }\n\n  /**\n   * Wrap a reused (grafted/spliced) RELATIVE tree, recomputing `errors` and\n   * `unconsumedFrom` from it so both stay consistent with the tree across the\n   * edit (the flat errors are recovered errors embedded in the reused subtrees;\n   * unconsumedFrom re-derives trailing junk over the new input).\n   */\n  private wrapReuse(newTree: N, newInput: string): ParseDoc<N> {\n    const trivia = triviaOf(this._registry[this._rootRule], this._opts)\n    const end = (newTree as unknown as { span: { end: number } }).span.end\n    const errors = collectEmbeddedErrors(newTree, 0, [])\n    const unconsumedFrom = unconsumedAfter(end, newInput, trivia)\n    return new ParseDocImpl(this._registry, this._rootRule, this._opts, { rel: newTree }, errors, unconsumedFrom, newInput)\n  }\n\n  edit(from: number, to: number, replacement: string): ParseDoc<N> {\n    const newInput = this.input.slice(0, from) + replacement + this.input.slice(to)\n    const reparse = () => parseDoc(this._registry, this._rootRule, newInput, this._opts)\n\n    const root = this.tree\n    if (!root) return reparse()\n\n    const delta = replacement.length - (to - from)\n    // When `from` sits on the root's own boundary (e.g. right after a top-level\n    // element, before its separator), no child node contains it and\n    // `findContaining` returns null \u2014 but the root still does. Fall back to the\n    // root as the container so the structural splice below still gets a shot\n    // (this is exactly the \"insert/delete a top-level list element\" position).\n    const found = findContaining(root, 0, from) ?? { node: root, path: [] as number[] }\n\n    // Try the innermost containing rule first, then widen outward.\n    const ancestors = ancestorsAt(root, found.path)\n    const candidates: FoundNode<N>[] = [found]\n    const pathCopy = [...found.path]\n    for (let i = ancestors.length - 2; i >= 0; i--) {\n      pathCopy.pop()\n      candidates.push({ node: ancestors[i + 1]!, path: [...pathCopy] })\n    }\n\n    const rebuild = this._opts.rebuild ?? defaultRebuild\n    for (const { node, path } of candidates) {\n      // Absolute span of this candidate, projected from the relative root (O(depth)).\n      const { start: absStart, end: absEnd } = absoluteSpanCST(root as unknown as { span: Span; children?: readonly unknown[] }, path)\n      // Reentry only pays off when the re-parsed rule is substantially smaller\n      // than the whole document. Candidates widen deepest\u2192root (monotonically\n      // growing span), so once one covers most of the input, reparsing it \u2014 and\n      // every larger ancestor after it \u2014 can't beat a full reparse and would just\n      // be wasted work before the fallback. Bail to the full reparse NOW. This\n      // caps `.edit()` at ~one full reparse in the worst case (e.g. a structural\n      // insert near the front) instead of stacking several near-full reparses.\n      if (absEnd - absStart > this.input.length * REENTRY_MAX_SPAN_FRACTION) break\n      const ruleFn = this._fns[node.type]\n      if (!ruleFn) continue\n      // The reused subtree must FULLY CONTAIN the edited range (old coords).\n      // `findContaining` only locates `from`; if the edit's end `to` spills past\n      // this node's end, the edit also changed a sibling/separator after it, and\n      // reusing the untouched suffix would be unsound \u2014 widen to an ancestor\n      // that does span the whole edit (ultimately a full reparse).\n      if (!(absStart <= from && to <= absEnd)) continue\n      const ctx: ParseContext = mkCtx(node.state, this._opts.build, !!this._opts.tolerant)\n      const r = ruleFn(newInput, absStart, ctx)\n      if (!r.ok) continue\n      if (r.span.end !== absEnd + delta) continue\n\n      // Stage-2 soundness guard: only reuse the untouched suffix if the re-parse\n      // provably read no input past its own end (else a lookahead/backtrack\n      // crossed the splice). Widen to the next candidate \u2014 ultimately a full\n      // reparse \u2014 when it can't be proven.\n      if (!boundaryIsSafe(ruleFn, newInput, absStart, absEnd + delta, node.state, this._opts.build, r, !!this._opts.tolerant)) {\n        continue\n      }\n\n      // The re-parse produced an ABSOLUTE subtree; rebase it to parent-relative\n      // for splicing into the relative tree. The parent's absolute start is\n      // `absStart - node.span.start` (node.span is already relative to it).\n      const parentBase = absStart - node.span.start\n      const newRel = relativizeCST(r.value as unknown as N & { span: Span }, parentBase) as unknown as N\n\n      // delta === 0: relative spans are unchanged, so the spine graft (sharing\n      // every untouched sibling by reference) is already correct.\n      if (delta === 0) {\n        const newTree = replaceAtPath(rebuild, root, path, newRel)\n        return this.wrapReuse(newTree, newInput)\n      }\n      // Length-changing edit: trailing siblings' relative starts slide by `delta`.\n      // A custom `rebuild` (possibly a class instance) can't have its span slid\n      // safely, so fall back to a full, correct reparse.\n      if (this._opts.rebuild) return reparse()\n      const newTree = graftRelative(root, path, newRel, delta)\n      return this.wrapReuse(newTree, newInput)\n    }\n\n    // No localized rule reparse converged \u2014 the edit is structural. Before paying\n    // a full reparse, try reusing the untouched tail of a containing collection\n    // (add/remove an element in a list). We only ever splice a rule the GRAMMAR\n    // proves is a genuine repetition (`this._reps`, from its combinator def) \u2014 a\n    // fixed-arity same-typed sequence is structurally indistinguishable from a list\n    // by its CST alone, so splicing it could accept a wrong element count; it's\n    // excluded here and falls back to a full, correct reparse. Innermost containing\n    // collection first; a candidate whose disturbed middle doesn't tile cleanly\n    // returns null and we widen. Correctness net is the incremental oracle fuzz.\n    if (this._opts.structuralReuse && delta !== 0 && !this._opts.rebuild) {\n      // Candidates run innermost\u2192ancestor but never include the root itself; the\n      // splice-able collection can BE the root (e.g. a top-level `sepBy` list), so\n      // consider it last.\n      const spliceCandidates: FoundNode<N>[] = [...candidates, { node: root, path: [] }]\n      for (const { node, path } of spliceCandidates) {\n        if (!this._reps.has(node.type)) continue // grammar didn't prove this rule a repetition\n        const { start: cStart, end: cEnd } = absoluteSpanCST(root as unknown as { span: Span; children?: readonly unknown[] }, path)\n        if (!(cStart <= from && to <= cEnd)) continue\n        const spliced = tryListSplice(root, path, node, cStart, newInput, from, to, delta, this._fns, this._opts.build, !!this._opts.tolerant)\n        if (spliced) return this.wrapReuse(spliced, newInput)\n      }\n    }\n\n    return reparse()\n  }\n}\n\n/**\n * The relative (parent-offset) tree backing a doc. Currently identical to the\n * public `doc.tree` (which is relative); kept as a named internal handle for the\n * reuse-metric tests, which assert on the shareable representation explicitly.\n */\nexport function relTreeOf<N extends NodeLike>(doc: ParseDoc<N>): N | null {\n  return doc.tree\n}\n\n/**\n * The grammar trivia rule to skip when computing `unconsumedFrom`: an explicit\n * `trivia` option wins; otherwise the root entry's ambient `grammarTrivia` (the\n * same source `run()` derives it from). A bare-function registry carries no meta,\n * so trailing trivia can't be inferred and the parse must reach the exact end.\n */\nfunction triviaOf<N extends NodeLike>(\n  entry: RuleFn<N> | Combinator<N> | undefined,\n  opts: ParseDocOptions<N>,\n): Combinator<unknown> | undefined {\n  if (opts.trivia) return opts.trivia\n  // Only an interpreter Combinator carries `_meta`; a bare parse function or a\n  // compiled-grammar object (which bakes its ambient trivia into codegen) does\n  // not, so there's nothing to derive and trailing trivia isn't skipped.\n  if (entry === undefined || typeof entry === 'function') return undefined\n  const meta = (entry as { _meta?: { grammarTrivia?: Combinator<unknown> } })._meta\n  return meta ? meta.grammarTrivia : undefined\n}\n\n/**\n * First unconsumed non-trivia offset after a parse that ended at `end` (trailing\n * trivia skipped when a trivia rule is available), or `null` when the whole input\n * was consumed \u2014 byte-for-byte the computation in `run()` (run.ts:117-129).\n */\nfunction unconsumedAfter(end: number, input: string, trivia: Combinator<unknown> | undefined): number | null {\n  let pos = end\n  if (trivia && pos < input.length) {\n    const t = trivia.parse(input, pos, { trackLines: false })\n    if (t.ok && t.span.end > pos) pos = t.span.end\n  }\n  return pos < input.length ? pos : null\n}\n\n/**\n * Collect embedded `parseError` recovery nodes from a PARENT-RELATIVE tree,\n * projecting each to an ABSOLUTE span (root base 0) \u2014 the flat mirror of the\n * errors that ride the tree, recomputed for a reuse-path (grafted/spliced) result\n * so `doc.errors` stays consistent with the tree across incremental edits.\n */\nfunction collectEmbeddedErrors(node: unknown, base: number, out: ParseError[]): ParseError[] {\n  const c = node as { _tag?: string; span?: { start: number; end: number }; expected?: string[]; children?: readonly unknown[] }\n  if (!c || typeof c !== 'object' || !c.span) return out\n  const start = base + c.span.start\n  if (c._tag === 'parseError') {\n    out.push({ _tag: 'parseError', span: { start, end: base + c.span.end }, expected: c.expected ?? [] })\n    return out\n  }\n  if (Array.isArray(c.children)) for (const k of c.children) collectEmbeddedErrors(k, start, out)\n  return out\n}\n\n/**\n * Parse `input` from `rootRule` and wrap the result in a ParseDoc that can\n * be incrementally re-parsed via `.edit()`.\n */\nexport function parseDoc<N extends NodeLike>(\n  registry: Registry<N>,\n  rootRule: string,\n  input: string,\n  opts: ParseDocOptions<N> = {},\n): ParseDoc<N> {\n  const entry = registry[rootRule]\n  if (!entry) throw new Error(`No rule '${rootRule}' in registry`)\n  const ctx: ParseContext = mkCtx(opts.state, opts.build, !!opts.tolerant)\n  const r: ParseResult<N> = asRuleFn(entry)(input, 0, ctx)\n  if (r.ok) {\n    // A fresh parse is ABSOLUTE; the relative form is materialized lazily on the\n    // first edit/spanAt, so a parse that's never edited pays no conversion. The\n    // recovery errors the tolerant parse collected into ctx._errors are surfaced\n    // flat too (like run()), and unconsumedFrom reports any trailing junk.\n    const errors = ctx._errors ? [...ctx._errors] : []\n    const unconsumedFrom = unconsumedAfter(r.span.end, input, triviaOf(entry, opts))\n    return new ParseDocImpl(registry, rootRule, opts, { abs: r.value }, errors, unconsumedFrom, input)\n  }\n  // Hard (non-recovered) failure: the single top-level failure, as a parseError.\n  const fail: ParseError = { _tag: 'parseError', span: r.span, expected: r.expected }\n  return new ParseDocImpl(registry, rootRule, opts, { abs: null }, [fail], null, input)\n}\n", "import type { Combinator, ParseContext, ParseError, ParseResult } from '../types.ts'\nimport { REC } from '../recovery/scan.ts'\n\n/**\n * Run a compiled/interpreted grammar entry against an input and collect the raw\n * outcome a tool needs to shape a parse result \u2014 WITHOUT the consumer having to\n * hand-build a `ctx`, branch on function-vs-combinator, or scan for leftover\n * input itself.\n *\n * A `compile()`/macro grammar hands you a map of bare parse FUNCTIONS; the\n * interpreter hands you COMBINATORS. `run()` invokes either, threads the standard\n * framework ctx (trivia log, recover/expect error sink, the `ctx.build` host,\n * grammar state), and \u2014 given the grammar's trivia parser \u2014 reports where\n * non-trivia input was left unconsumed. The consumer keeps only its own policy:\n * how to shape the tree and how to turn diagnostics into its error type.\n */\n\n/** A compiled rule (macro/`compile()` output) OR an interpreter combinator. */\nexport type Runnable =\n  | ((input: string, pos: number, ctx: ParseContext) => ParseResult<unknown>)\n  | Combinator<unknown>\n\nexport type RunOptions = {\n  /** `ctx.build` host \u2014 makes structural `node()` rules build a CST / AST via the\n   * host instead of their own eval builders. Omit for a grammar's own builders. */\n  build?: ParseContext['build']\n  /** Initial grammar state threaded into `ctx.state`. */\n  state?: unknown\n  /**\n   * The grammar's trivia rule. A root rule consumes trivia BETWEEN terms but not\n   * after the last one, so trailing whitespace/comments would otherwise look like\n   * unparsed input. Given the trivia rule, `run` skips that tail before computing\n   * `unconsumedFrom` \u2014 so only real leftover is reported. Also encodes dialect\n   * differences for free: pass the CSS trivia and a trailing `//` counts as\n   * leftover; pass the Less trivia (which treats `//` as a line comment) and it\n   * doesn't. An UNTERMINATED comment (which the trivia rule won't match) surfaces\n   * at its start. Omit to require the parse to reach the exact end itself.\n   */\n  trivia?: Runnable\n  /**\n   * Restrict PER-NODE CST trivia capture (the `triviaLog` a node's builder sees)\n   * to these trivia kinds \u2014 a bitmask over the grammar's `triviaKindLabels`\n   * indices (build it with `triviaKindMask(labels, ['comment', \u2026])`). Unlisted\n   * kinds (e.g. whitespace) are skipped over but not recorded per node, so a host\n   * that only reads comments doesn't pay to log every whitespace run. The global\n   * `triviaLog` returned by `run()` is unaffected. Omit to capture every kind.\n   */\n  triviaCaptureMask?: number\n  /**\n   * Activate automatic list recovery. When true, `many`/`sepBy`/`oneOrMore` recover\n   * from a failed element \u2014 skip to a sync point (a resume token inferred from the\n   * grammar's structure; the grammar carries no recovery config), emit a\n   * `ParseError` over the skipped span (collected in `errors`), and keep parsing the\n   * rest of the list \u2014 instead of stopping at the first bad element. Omit (the\n   * default) for the strict \"one clean error and stop\" behavior, byte-identical to a\n   * run with no recovery. Recovery is a cold path: on well-formed input nothing\n   * fails, so none of the machinery runs.\n   */\n  tolerant?: boolean\n}\n\nexport type RunResult = {\n  ok: boolean\n  /** The entry's value on success; undefined on failure. */\n  value: unknown\n  span: { start: number; end: number }\n  /** Expected-token set when the TOP-LEVEL parse failed (empty on success). */\n  expected: string[]\n  /** Recovery diagnostics (tolerant lists / `expect()`) collected during the parse (in order). */\n  errors: ParseError[]\n  /**\n   * Flat trivia log for building a trivia map. Entry width depends on whether the\n   * grammar uses labeled trivia: 2 numbers per entry (`start, end`) for plain\n   * trivia, 3 numbers per entry (`start, end, kindIndex`) for labeled trivia\n   * (grammars with `label()` arms in their trivia choice). Use `buildTriviaIndex`\n   * / `triviaEntries` to consume it format-agnostically rather than iterating raw.\n   */\n  triviaLog: number[]\n  /** Offset where unparsed input begins \u2014 the first non-trivia character the parse\n   * left unconsumed (trailing trivia skipped when `trivia` is given), or null if\n   * the whole input was consumed. This is how you detect \"the grammar stopped short,\n   * there's junk here\". Only meaningful on success \u2014 a failed parse reports its own\n   * `span`/`expected`. */\n  unconsumedFrom: number | null\n}\n\nconst invoke = (r: Runnable, input: string, pos: number, ctx: ParseContext): ParseResult<unknown> =>\n  typeof r === 'function' ? r(input, pos, ctx) : r.parse(input, pos, ctx)\n\nexport function run(entry: Runnable, input: string, options: RunOptions = {}): RunResult {\n  if (typeof entry !== 'function' && typeof (entry as Combinator<unknown> | undefined)?.parse !== 'function') {\n    throw new TypeError(\n      `run(): start production is ${entry === null ? 'null' : typeof entry}, not a rule \u2014 the requested grammar rule does not exist (check the rule name).`,\n    )\n  }\n  const triviaLog: number[] = []\n  const errors: ParseError[] = []\n  // Grammar-level ambient trivia declared via rules({ trivia }, factory): install\n  // it as ctx.trivia so it's ambient for the whole parse (the interpreter path;\n  // a compiled entry has it baked in and carries no _meta). parser/noTrivia still\n  // override locally.\n  const grammarTrivia = typeof entry !== 'function' ? entry._meta.grammarTrivia : undefined\n  const ctx: ParseContext = {\n    trackLines: false,\n    _triviaLog: triviaLog,\n    _errors: errors,\n    build: options.build,\n    state: options.state,\n    ...(grammarTrivia !== undefined\n      ? { trivia: grammarTrivia, ...(grammarTrivia._meta.triviaKindLabels ? { triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {}) }\n      : {}),\n    ...(options.triviaCaptureMask !== undefined ? { _triviaCaptureMask: options.triviaCaptureMask } : {}),\n    ...(options.tolerant ? { _tolerant: true, _rec: REC } : {}),\n  }\n  const r = invoke(entry, input, 0, ctx)\n\n  let unconsumedFrom: number | null = null\n  if (r.ok) {\n    let pos = r.span?.end ?? 0\n    if (options.trivia && pos < input.length) {\n      // Throwaway ctx: trailing trivia must NOT pollute the parse's trivia log.\n      const t = invoke(options.trivia, input, pos, { trackLines: false })\n      if (t.ok && t.span.end > pos) pos = t.span.end\n    }\n    unconsumedFrom = pos < input.length ? pos : null\n  }\n\n  return {\n    ok: r.ok,\n    value: r.ok ? (r as { value: unknown }).value : undefined,\n    span: r.span ?? { start: 0, end: 0 },\n    expected: r.ok ? [] : ((r as { expected?: string[] }).expected ?? []),\n    errors,\n    triviaLog,\n    unconsumedFrom,\n  }\n}\n", "import type { Span } from '../types.ts'\n\n/** One captured trivia token (a whitespace run or a comment) with its source span. */\nexport type TriviaToken = { readonly value: string; readonly span: Span }\n\n/**\n * Before/after offset index of captured trivia. Built from a tree whose nodes\n * carry a `triviaLog` property (the flat `[start, end, insertIdx, ...]` array\n * produced by parseman when `parser({ captureTrivia: true })` wraps a `node()` grammar).\n *\n *   index.before.get(node.span.start)  // trivia immediately before a node\n *   index.after.get(node.span.end)     // trivia immediately after a node\n *\n * A given trivia entry is registered under BOTH the following item's start\n * (`before`) and the preceding item's end (`after`), so either lookup finds it.\n */\nexport type TriviaIndex = {\n  readonly before: Map<number, TriviaToken[]>\n  readonly after: Map<number, TriviaToken[]>\n}\n\ntype Spanned = { readonly span: Span }\ntype NodeWithTrivia = {\n  readonly span?: Span\n  readonly children?: ReadonlyArray<unknown>\n  readonly rawChildren?: ReadonlyArray<Spanned>\n  readonly triviaLog?: readonly number[]\n}\n\nfunction merge(map: Map<number, TriviaToken[]>, key: number, run: TriviaToken[]): void {\n  if (run.length === 0) return\n  const existing = map.get(key)\n  if (existing) existing.push(...run)\n  else map.set(key, [...run])\n}\n\n/**\n * Options for trailing/leading trivia at the document boundary. A repeating root\n * (e.g. `many()`) rolls back the trivia after its last item \u2014 it's \"trailing\" and\n * belongs to the enclosing context, which at the document root is the document\n * itself. Pass `{ trivia }` to re-scan and register that boundary trivia,\n * so a round-trippable trivia map isn't missing the run before EOF.\n */\nexport type TriviaIndexOptions = {\n  /**\n   * A regex matching ONE trivia token (a whitespace run or a comment). Applied\n   * repeatedly to tokenize the boundary trivia. Each match becomes one token, so\n   * write it to match a maximal run, e.g.\n   * `/[ \\t\\n\\r\\f]+|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\//`.\n   */\n  trivia: RegExp\n}\n\n/**\n * Walk a tree whose nodes carry `triviaLog` (from `node()` + `captureTrivia`)\n * and build a before/after trivia index. Each node must have\n * `triviaLog: readonly number[]` (flat `[start, end, insertIdx, \u2026]` \u2014\n * three numbers per entry) and `rawChildren` (structural items with `.span`).\n * `input` is the source string used to materialize trivia values.\n *\n * With `opts`, also captures leading trivia (before the root's content) and\n * trailing trivia (after it, up to EOF) \u2014 the document boundaries a repeating\n * root rolls back.\n */\nexport function buildTriviaIndex(root: unknown, input = '', opts?: TriviaIndexOptions): TriviaIndex {\n  const before = new Map<number, TriviaToken[]>()\n  const after = new Map<number, TriviaToken[]>()\n\n  const visit = (node: NodeWithTrivia): void => {\n    const log = node.triviaLog\n    const raw = node.rawChildren\n\n    if (log && log.length && raw) {\n      for (let i = 0; i < log.length; i += 3) {\n        const tStart = log[i]!, tEnd = log[i + 1]!, insertIdx = log[i + 2]!\n        if (tEnd <= tStart) continue\n        const run: TriviaToken[] = [{ value: input.slice(tStart, tEnd), span: { start: tStart, end: tEnd } }]\n        const next = raw[insertIdx]\n        if (next) merge(before, next.span.start, run)\n        const prev = insertIdx > 0 ? raw[insertIdx - 1] : undefined\n        if (prev) merge(after, prev.span.end, run)\n      }\n    }\n\n    const ch = node.children\n    if (ch) {\n      for (const c of ch) {\n        if (typeof c === 'object' && c !== null && (c as NodeWithTrivia).children !== undefined) {\n          visit(c as NodeWithTrivia)\n        }\n      }\n    }\n  }\n\n  if (root) visit(root as NodeWithTrivia)\n\n  // Document-boundary trivia: re-scan leading (offset 0) and trailing (root end\n  // \u2192 EOF) trivia that a repeating root rolled back.\n  if (opts && input) {\n    const rootSpan = (root as NodeWithTrivia | null)?.span\n    const re = new RegExp(opts.trivia.source, opts.trivia.flags.replace(/[gy]/g, '') + 'y')\n    const scanFrom = (from: number): TriviaToken[] => {\n      const run: TriviaToken[] = []\n      let pos = from\n      re.lastIndex = pos\n      let m = re.exec(input)\n      while (m && m.index === pos && m[0].length > 0) {\n        run.push({ value: m[0], span: { start: pos, end: pos + m[0].length } })\n        pos += m[0].length\n        re.lastIndex = pos\n        m = re.exec(input)\n      }\n      return run\n    }\n\n    if (rootSpan && rootSpan.start > 0) {\n      const lead = scanFrom(0)\n      if (lead.length) merge(before, rootSpan.start, lead)\n    }\n    const end = rootSpan ? rootSpan.end : 0\n    if (end < input.length) {\n      const trail = scanFrom(end)\n      if (trail.length) {\n        merge(after, end, trail)\n        merge(before, end + trail.reduce((n, t) => n + (t.span.end - t.span.start), 0), trail)\n      }\n    }\n  }\n\n  return { before, after }\n}\n", "/**\n * Tree traversal for the CST/AST a grammar produces. Pars\u00E9man hands back a plain\n * object tree, so you *can* recurse it yourself \u2014 these helpers save you from\n * re-writing the same recursion for diagnostics, folding, or lowering a tree.\n *\n * Two entry points:\n *   - `walk`          \u2014 imperative depth-first traversal with enter/leave hooks.\n *   - `createVisitor` \u2014 Chevrotain-style dispatch keyed on each node's `type`.\n *\n * Both default to the built-in CST shape (`CSTChild` \u2014 the `node()` / leaf / error\n * union), so with no annotation you get precise typing out of the box. Parsing to\n * a custom AST? Pass your node type as a generic: `walk<MyNode>(root, \u2026)`.\n */\nimport type { CSTChild } from './types.ts'\n\n/**\n * The minimal shape these helpers traverse: a `_tag`, an optional rule `type`,\n * and optional structural `children`. The built-in `CSTChild` satisfies it, and\n * so does any custom AST node (that's what the generic override targets).\n */\nexport type Walkable = {\n  readonly _tag: string\n  readonly type?: string\n  readonly children?: ReadonlyArray<Walkable>\n}\n\nexport interface WalkVisitor<N extends Walkable = CSTChild, C = undefined> {\n  /**\n   * Called on entering a node, before its children. Return `false` to skip\n   * descending into this node's children (`leave` still runs).\n   */\n  enter?(node: N, parent: N | null, ctx: C): boolean | void\n  /** Called on leaving a node, after its children. */\n  leave?(node: N, parent: N | null, ctx: C): void\n}\n\n/**\n * Depth-first traversal. Visits `root`, then each structural child in order.\n * `ctx` is threaded to both hooks unchanged (use it as an accumulator).\n *\n * Defaults to the CST shape; override with `walk<MyNode>(root, \u2026)`:\n *\n *   const idents: string[] = []\n *   walk(tree, {\n *     enter(node) {\n *       if (node._tag === 'leaf') idents.push(node.value)\n *     },\n *   })\n */\nexport function walk<N extends Walkable = CSTChild, C = undefined>(\n  root: N,\n  visitor: WalkVisitor<N, C>,\n  ctx: C = undefined as C,\n): void {\n  const go = (node: N, parent: N | null): void => {\n    const descend = visitor.enter ? visitor.enter(node, parent, ctx) : undefined\n    const children = node.children as ReadonlyArray<N> | undefined\n    if (descend !== false && Array.isArray(children)) {\n      for (const child of children) go(child, node)\n    }\n    visitor.leave?.(node, parent, ctx)\n  }\n  go(root, null)\n}\n\nexport interface VisitApi<R, N extends Walkable = CSTChild> {\n  /** Dispatch a node to its handler (by `type`); returns the handler's result. */\n  visit(node: N): R | undefined\n  /** Visit every structural child, collecting the defined results in order. */\n  visitChildren(node: N): R[]\n}\n\nexport type VisitorHandlers<R, N extends Walkable = CSTChild> = Record<\n  string,\n  (node: N, api: VisitApi<R, N>) => R\n>\n\n/**\n * Build a visitor that dispatches on each node's `type` \u2014 the direct analog of a\n * generated CST-visitor base class. Handlers are keyed by rule name and receive\n * an `api` with `visit` / `visitChildren` to recurse:\n *\n *   const evalExpr = createVisitor<number>({\n *     Num: (n) => Number((n as NumNode).value),\n *     Add: (n, api) => api.visitChildren(n).reduce((a, b) => a + b, 0),\n *   })\n *   const total = evalExpr(tree)\n *\n * Defaults to the CST shape; override the return type and node type together with\n * `createVisitor<number, MyNode>({ \u2026 })`. A node whose `type` has no handler\n * falls through to visiting its children (results discarded), so partial visitors\n * work without listing every rule.\n */\nexport function createVisitor<R = void, N extends Walkable = CSTChild>(\n  handlers: VisitorHandlers<R, N>,\n): (node: N) => R | undefined {\n  const api: VisitApi<R, N> = {\n    visit(node) {\n      const handler = node.type !== undefined ? handlers[node.type] : undefined\n      if (handler) return handler(node, api)\n      api.visitChildren(node)\n      return undefined\n    },\n    visitChildren(node) {\n      const out: R[] = []\n      const children = node.children as ReadonlyArray<N> | undefined\n      if (Array.isArray(children)) {\n        for (const child of children) {\n          const r = api.visit(child)\n          if (r !== undefined) out.push(r)\n        }\n      }\n      return out\n    },\n  }\n  return (node) => api.visit(node)\n}\n", "/** View over a flat trivia log (`_triviaLog` or per-node `triviaLog`). */\nexport type TriviaEntriesView = {\n  readonly length: number\n  readonly labels: readonly string[] | undefined\n  readonly stride: number\n  start(i: number): number\n  end(i: number): number\n  kindIndex(i: number): number | undefined\n  kind(i: number): string | undefined\n  text(i: number, input: string): string\n}\n\nfunction entryOffset(i: number, stride: number): number {\n  return i * stride\n}\n\n/**\n * Wrap a flat trivia log. Stride is inferred from `labels`:\n * - root `_triviaLog`: 2 (start, end) or 3 (+ kindIndex)\n * - node `triviaLog`: 3 (start, end, insertIdx) or 4 (+ kindIndex)\n */\nexport function triviaEntries(\n  log: readonly number[],\n  labels?: readonly string[],\n  opts?: { nodeLog?: boolean },\n): TriviaEntriesView {\n  const baseStride = opts?.nodeLog ? 3 : 2\n  const stride = labels ? baseStride + 1 : baseStride\n  const length = Math.floor(log.length / stride)\n\n  return {\n    length,\n    labels,\n    stride,\n    start(i) {\n      return log[entryOffset(i, stride)]!\n    },\n    end(i) {\n      return log[entryOffset(i, stride) + 1]!\n    },\n    kindIndex(i) {\n      if (!labels) return undefined\n      return log[entryOffset(i, stride) + baseStride]\n    },\n    kind(i) {\n      const ki = labels ? log[entryOffset(i, stride) + baseStride] : undefined\n      return ki !== undefined ? labels![ki] : undefined\n    },\n    text(i, input) {\n      const s = log[entryOffset(i, stride)]!\n      const e = log[entryOffset(i, stride) + 1]!\n      return input.slice(s, e)\n    },\n  }\n}\n", "import type { Span } from '../types.ts'\n\n/**\n * Trivia-offset-inference model.\n *\n * The premise (see docs): most trivia carries nothing that isn't already implied\n * by the source offsets of the tokens around it. A gap between a slot ending at\n * 100 and the next starting at 103 IS three characters of trivia \u2014 known without\n * storing anything. So we store only the slot boundaries (which the tree already\n * has) and reconstruct trivia from them:\n *\n *   - exact printing: slice the source between two slots (`gapText`);\n *   - inference: widths / indents / alignment / blank-lines are subtraction;\n *   - positional queries: binary search over the sorted slot array (O(log n)),\n *     collapsing the old double-indexed before/after maps into one index.\n *\n * A \"slot\" is a leaf token's source span. Trivia lives in the GAPS between\n * consecutive slots (plus the leading gap before the first slot and the trailing\n * gap after the last). Gaps are fully determined by the sorted slot list, so\n * there is no separate trivia store for whitespace at all.\n */\n\n/** A leaf token's source span \u2014 the anchor points; trivia is between them. */\nexport type Slot = { readonly start: number; readonly end: number }\n\n/** A trivia region between two slots (or a document boundary). Half-open `[start, end)`. */\nexport type Gap = { readonly start: number; readonly end: number }\n\nconst { isFinite } = Number\n\n/** Binary search: greatest index `i` in `arr[0..len)` with `arr[i] <= x`, or -1. */\nfunction floorIndex(arr: readonly number[], len: number, x: number): number {\n  let lo = 0\n  let hi = len - 1\n  let ans = -1\n  while (lo <= hi) {\n    const mid = (lo + hi) >>> 1\n    if (arr[mid]! <= x) {\n      ans = mid\n      lo = mid + 1\n    } else {\n      hi = mid - 1\n    }\n  }\n  return ans\n}\n\n/**\n * A positional index over an ordered set of slots (leaf spans) within a source\n * of length `docEnd`. Answers \"what trivia is before/after/around this offset\"\n * by binary search, and reconstructs the exact trivia text by slicing `source`.\n *\n * Slots must be non-overlapping. They are sorted by `start` on construction;\n * out-of-order or overlapping input throws (the caller's spans are wrong).\n */\nexport class OffsetIndex {\n  /** Slot starts, sorted ascending. Parallel to `_ends`. */\n  private readonly _starts: number[]\n  private readonly _ends: number[]\n  readonly count: number\n  readonly docStart: number\n  readonly docEnd: number\n\n  constructor(slots: readonly Slot[], docStart = 0, docEnd?: number) {\n    const sorted = [...slots].sort((a, b) => a.start - b.start)\n    const starts: number[] = []\n    const ends: number[] = []\n    let prevEnd = docStart\n    for (const s of sorted) {\n      if (!isFinite(s.start) || !isFinite(s.end) || s.end < s.start) {\n        throw new RangeError(`OffsetIndex: invalid slot [${s.start}, ${s.end}]`)\n      }\n      if (s.start < prevEnd) {\n        throw new RangeError(`OffsetIndex: overlapping/out-of-order slot [${s.start}, ${s.end}] after end ${prevEnd}`)\n      }\n      starts.push(s.start)\n      ends.push(s.end)\n      prevEnd = s.end\n    }\n    this._starts = starts\n    this._ends = ends\n    this.count = starts.length\n    this.docStart = docStart\n    this.docEnd = docEnd ?? (this.count ? Math.max(prevEnd, ends[ends.length - 1]!) : docStart)\n  }\n\n  /** The slot at index `i` (0-based, source order), or undefined. */\n  slot(i: number): Slot | undefined {\n    if (i < 0 || i >= this.count) return undefined\n    return { start: this._starts[i]!, end: this._ends[i]! }\n  }\n\n  /**\n   * Index of the gap that CONTAINS `offset`, in `[0, count]`. Gap `i` spans\n   * `[endOf(i-1), startOf(i))` where `endOf(-1)=docStart` and `startOf(count)=docEnd`.\n   * An offset that lands inside a slot returns that slot's TRAILING gap index\n   * (i.e. the gap after it) \u2014 callers querying at slot boundaries get the\n   * intuitive answer via `gapBefore`/`gapAfter`.\n   */\n  gapIndexAt(offset: number): number {\n    // Find the last slot whose start <= offset.\n    const i = floorIndex(this._starts, this.count, offset)\n    if (i < 0) return 0 // before the first slot \u2192 leading gap\n    // offset is at or past slot i's start. If it's before slot i's end, it's\n    // inside slot i \u2192 the gap after slot i is index i+1.\n    if (offset < this._ends[i]!) return i + 1\n    // offset is at/after slot i's end \u2192 in the gap after slot i (index i+1),\n    // unless there's a later slot it precedes; either way that's gap i+1.\n    return i + 1\n  }\n\n  /** The gap at index `i` in `[0, count]`. */\n  gap(i: number): Gap | undefined {\n    if (i < 0 || i > this.count) return undefined\n    const start = i === 0 ? this.docStart : this._ends[i - 1]!\n    const end = i === this.count ? this.docEnd : this._starts[i]!\n    return { start, end }\n  }\n\n  /**\n   * The trivia gap immediately BEFORE `offset` (`[prevSlotEnd, offset)`), where\n   * `prevSlotEnd` is the end of the last slot ending at or before `offset` (or\n   * `docStart`). For a real slot start this is the gap preceding that slot; for an\n   * adjacent slot the gap is empty and agrees with `gapAfter` on the same seam.\n   */\n  gapBefore(offset: number): Gap | undefined {\n    const e = floorIndex(this._ends, this.count, offset) // last slot end <= offset\n    const start = e >= 0 ? this._ends[e]! : this.docStart\n    return { start, end: offset }\n  }\n\n  /**\n   * The trivia gap immediately AFTER `offset` (`[offset, nextSlotStart)`), where\n   * `nextSlotStart` is the least slot start at or after `offset` (or `docEnd`).\n   */\n  gapAfter(offset: number): Gap | undefined {\n    return { start: offset, end: this._ceilStart(offset) }\n  }\n\n  /** Least slot start `>= offset`, else `docEnd`. */\n  private _ceilStart(offset: number): number {\n    let lo = 0\n    let hi = this.count - 1\n    let ans = this.docEnd\n    while (lo <= hi) {\n      const mid = (lo + hi) >>> 1\n      if (this._starts[mid]! >= offset) {\n        ans = this._starts[mid]!\n        hi = mid - 1\n      } else {\n        lo = mid + 1\n      }\n    }\n    return ans\n  }\n\n  /** Is this gap empty (adjacent slots, no trivia)? */\n  isEmpty(gap: Gap): boolean {\n    return gap.end <= gap.start\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Reconstruction algebra: everything spatial is a subtraction over slot offsets\n// plus the source (for exact printing) or the sparse marks (for inference).\n// ---------------------------------------------------------------------------\n\nconst NL = 10 // '\\n'\nconst CR = 13 // '\\r'\nconst SP = 32 // ' '\nconst TAB = 9 // '\\t'\n\n/** Exact trivia text of a gap: `source.slice(gap.start, gap.end)`. */\nexport function gapText(source: string, gap: Gap): string {\n  return gap.end > gap.start ? source.slice(gap.start, gap.end) : ''\n}\n\n/** Count of line breaks (`\\n`, with `\\r\\n` counted once) within a gap. */\nexport function lineBreaksIn(source: string, gap: Gap): number {\n  let n = 0\n  for (let i = gap.start; i < gap.end; i++) {\n    const c = source.charCodeAt(i)\n    if (c === NL) n++\n    else if (c === CR && source.charCodeAt(i + 1) !== NL) n++ // lone CR\n  }\n  return n\n}\n\n/** Blank lines in a gap = breaks - 1 (a single break is just a line end, not a blank line). */\nexport function blankLinesIn(source: string, gap: Gap): number {\n  return Math.max(0, lineBreaksIn(source, gap) - 1)\n}\n\n/**\n * Offset just after the last line break in the gap (the start of the final\n * line's indent), or `gap.start` if the gap has no break. This is the ONE\n * non-inferable position; every indent quantity derives from it by subtraction.\n */\nexport function lineStartWithin(source: string, gap: Gap): number {\n  for (let i = gap.end - 1; i >= gap.start; i--) {\n    const c = source.charCodeAt(i)\n    if (c === NL || c === CR) return i + 1\n  }\n  return gap.start\n}\n\n/**\n * Indent width of the line the NEXT slot sits on: `nextStart - lineStart`.\n * `nextStart` is `gap.end` (the following slot's start). Zero if the gap has no\n * line break (the next slot is on the same line).\n */\nexport function indentWidth(source: string, gap: Gap): number {\n  const ls = lineStartWithin(source, gap)\n  if (ls === gap.start) return 0 // same line, no break\n  return gap.end - ls\n}\n\n/** True if the final line's indent mixes tabs and spaces (the one case width can't capture). */\nexport function indentMixed(source: string, gap: Gap): boolean {\n  const ls = lineStartWithin(source, gap)\n  let sawSpace = false\n  let sawTab = false\n  for (let i = ls; i < gap.end; i++) {\n    const c = source.charCodeAt(i)\n    if (c === SP) sawSpace = true\n    else if (c === TAB) sawTab = true\n  }\n  return sawSpace && sawTab\n}\n\n/** Comment spans within a gap (absolute offsets), tokenized by `comment`. */\nexport function commentsIn(source: string, gap: Gap, comment: RegExp): Span[] {\n  const re = new RegExp(comment.source, comment.flags.replace(/[gy]/g, '') + 'g')\n  re.lastIndex = gap.start\n  const out: Span[] = []\n  let m: RegExpExecArray | null\n  while ((m = re.exec(source)) && m.index < gap.end) {\n    if (m[0].length === 0) { re.lastIndex++; continue }\n    if (m.index + m[0].length > gap.end) break\n    out.push({ start: m.index, end: m.index + m[0].length })\n  }\n  return out\n}\n\n/**\n * Does the gap carry anything a normalizing printer must preserve? True if it\n * contains a comment or a line break; a pure inline-whitespace gap returns false\n * and needs no record at all (the printer re-derives canonical spacing).\n */\nexport function gapIsSignificant(source: string, gap: Gap, comment?: RegExp): boolean {\n  if (gap.end <= gap.start) return false\n  if (lineBreaksIn(source, gap) > 0) return true\n  if (comment && commentsIn(source, gap, comment).length > 0) return true\n  return false\n}\n\n// ---------------------------------------------------------------------------\n// CST adapter: the positioned tree IS the index. Flatten a parseman CST to its\n// leaf (terminal) slots in source order; the gaps between them are the trivia \u2014\n// no separate trivia store needed.\n// ---------------------------------------------------------------------------\n\ntype AnyCstChild = {\n  readonly _tag?: string\n  readonly span?: { readonly start: number; readonly end: number }\n  readonly children?: ReadonlyArray<unknown>\n}\n\n/**\n * Collect the leaf-token spans of a CST in source order. Nodes/errors (which\n * carry `children`) are descended into; only childless spanned items (terminals)\n * become slots. Node spans are skipped \u2014 they overlap their children and would\n * double-cover the gaps.\n */\nexport function collectLeafSlots(root: unknown): Slot[] {\n  const slots: Slot[] = []\n  const visit = (n: AnyCstChild): void => {\n    const kids = n.children\n    if (kids && kids.length) {\n      for (const c of kids) visit(c as AnyCstChild)\n    } else if (n.span) {\n      slots.push({ start: n.span.start, end: n.span.end })\n    }\n  }\n  if (root) visit(root as AnyCstChild)\n  return slots\n}\n\n/**\n * Build an `OffsetIndex` directly from a parseman CST root and its source. This\n * is the drop-in replacement for the double-indexed `buildTriviaIndex`: the same\n * before/after trivia is recovered by `gapBefore`/`gapAfter` + `gapText`, and it\n * additionally supports arbitrary positional queries and inference \u2014 with nothing\n * stored per whitespace gap.\n */\nexport function buildOffsetIndex(root: unknown, input = ''): OffsetIndex {\n  return new OffsetIndex(collectLeafSlots(root), 0, input.length)\n}\n"],
-  "mappings": "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",
+  "sources": ["../src/index.ts", "../src/combinators/first-set.ts", "../src/combinators/probe.ts", "../src/cst/capture-buffer.ts", "../src/combinators/literal.ts", "../src/regex/classes.ts", "../src/combinators/regex.ts", "../src/regex/first-set.ts", "../src/combinators/keywords.ts", "../src/recovery/scan.ts", "../src/combinators/expect.ts", "../src/combinators/choice.ts", "../src/cst/trivia-kinds.ts", "../src/combinators/trivia-skip.ts", "../src/combinators/sequence.ts", "../src/combinators/repeat.ts", "../src/combinators/ref.ts", "../src/compiler/value-usage.ts", "../src/combinators/parser.ts", "../src/combinators/not.ts", "../src/compiler/build-arity.ts", "../src/compiler/fields.ts", "../src/combinators/node.ts", "../src/combinators/map.ts", "../src/compiler/line-index.ts", "../src/combinators/grammar.ts", "../src/combinators/token.ts", "../src/compiler/scannable-run.ts", "../src/compiler/trivia-fast-path.ts", "../src/compiler/scannable-terminal.ts", "../src/compiler/inline-build.ts", "../src/compiler/inline-callback.ts", "../src/compiler/codegen.ts", "../src/combinators/scanTo.ts", "../src/combinators/withCtx.ts", "../src/compiler/ir-serialize.ts", "../src/compiler/linker.ts", "../src/combinators/guard.ts", "../src/combinators/completions.ts", "../src/cst/relative-spans.ts", "../src/functional/doc.ts", "../src/functional/run.ts", "../src/cst/trivia-index.ts", "../src/cst/walk.ts", "../src/cst/trivia-entries.ts", "../src/cst/offset-model.ts"],
+  "sourcesContent": ["export type { Combinator, ParseResult, ParseOk, ParseFail, ParseContext, ParseError, Span, ParserMeta, FirstSet, CharRange, ParserDef, ChoiceStrategy, AutoNotCheck, GatedArm, BuildHost, CstCollapsePredicate, FieldCapture, FieldMap } from './types.ts'\n\nexport { literal } from './combinators/literal.ts'\nexport type { LiteralOptions } from './combinators/literal.ts'\n\nexport { regex } from './combinators/regex.ts'\n// Wire the hand-rolled first-set analyzer into `regex()`. Importing the library\n// entry opts you into precise choice-dispatch fast paths; a deep-path\n// `import { regex }` (no library entry) gets a permissive fallback, so the\n// analyzer tree-shakes out entirely. The analyzer is a small dependency-free\n// regex parser (`./regex/first-set.ts`) \u2014 no `regexp-tree`, no codegen \u2014 so\n// interpreter-only bundles stay lean.\nimport { registerRegexAnalyzer } from './combinators/regex.ts'\nimport { firstSetFromRegex } from './regex/first-set.ts'\nregisterRegexAnalyzer(firstSetFromRegex)\nexport { keywords, word, makeWord } from './combinators/keywords.ts'\nexport type { KeywordsOptions } from './combinators/keywords.ts'\n\nexport { sequence } from './combinators/sequence.ts'\nexport { choice } from './combinators/choice.ts'\nexport { many, oneOrMore, optional, sepBy } from './combinators/repeat.ts'\nexport { rules } from './combinators/parser.ts'\nexport { ref } from './combinators/ref.ts'\nexport { not } from './combinators/not.ts'\nexport { node } from './combinators/node.ts'\nexport type { BuildNode, NodeOptions } from './combinators/node.ts'\n// lazy() is intentionally NOT exported.\nexport { transform, skip, trivia, label, field } from './combinators/map.ts'\nexport { parse, parser, noTrivia } from './combinators/grammar.ts'\nexport type { ParseOptions, ParserOptions, ParsemanParser } from './combinators/grammar.ts'\nexport { token } from './combinators/token.ts'\n\nexport { compile } from './compiler/codegen.ts'\nexport type { CompiledParser, LinkablePieces } from './compiler/codegen.ts'\n// `pick()` is deliberately NOT re-exported: build-inlining a `pick()` of an imported\n// grammar can't yet carry that grammar's ambient trivia across the module boundary, so\n// the macro would diverge from the interpreter. It stays internal (./compiler/linker.ts)\n// for later exploration of that lowering; `compose()` is the public composition primitive.\nexport { compose, cstBuildHost } from './compiler/linker.ts'\nexport type { CstBuildHostOptions, FusedRule } from './compiler/linker.ts'\n\nexport { buildLineIndex, offsetToLineCol, annotateSpan } from './compiler/line-index.ts'\nexport type { LineIndex } from './compiler/line-index.ts'\n\nexport { guard } from './combinators/guard.ts'\nexport { withCtx } from './combinators/withCtx.ts'\nexport { isParseError } from './combinators/expect.ts'\nexport { expect } from './combinators/expect.ts'\nexport { completionsAt } from './combinators/completions.ts'\nexport { scanTo, balanced } from './combinators/scanTo.ts'\nexport type { ScanToOptions } from './combinators/scanTo.ts'\n\nexport type { CSTNode, CSTLeaf, CSTError, CSTTrivia, CSTChild, CSTRawChild, NodeLike } from './cst/types.ts'\n\nexport { parseDoc } from './functional/doc.ts'\nexport type { ParseDoc, ParseDocOptions, Registry, RuleFn } from './functional/doc.ts'\nexport { run } from './functional/run.ts'\nexport type { RunResult, RunOptions, RunProfile, RunProfilePass, Runnable } from './functional/run.ts'\nexport { buildTriviaIndex } from './cst/trivia-index.ts'\nexport type { TriviaIndex, TriviaToken, TriviaIndexOptions } from './cst/trivia-index.ts'\nexport { walk, createVisitor } from './cst/walk.ts'\nexport type { Walkable, WalkVisitor, VisitApi, VisitorHandlers } from './cst/walk.ts'\nexport { triviaEntries } from './cst/trivia-entries.ts'\nexport type { TriviaEntriesView } from './cst/trivia-entries.ts'\nexport { triviaKindMask } from './cst/trivia-kinds.ts'\n\nexport {\n  OffsetIndex,\n  buildOffsetIndex,\n  collectLeafSlots,\n  gapText,\n  lineBreaksIn,\n  blankLinesIn,\n  lineStartWithin,\n  indentWidth,\n  indentMixed,\n  commentsIn,\n  gapIsSignificant,\n} from './cst/offset-model.ts'\nexport type { Slot, Gap } from './cst/offset-model.ts'\nexport {\n  relativize,\n  absolutize,\n  absoluteSpanAt,\n  shiftAbsolute,\n  applyEdit,\n  relativizeCST,\n  absolutizeCST,\n  absoluteSpanCST,\n} from './cst/relative-spans.ts'\nexport type { AbsNode, RelNode } from './cst/relative-spans.ts'\n", "import type { CharRange, FirstSet, Combinator, ParserDef } from '../types.ts'\n\nexport function union(a: FirstSet, b: FirstSet): FirstSet {\n  if (a.kind === 'any' || b.kind === 'any') return { kind: 'any' }\n  if (a.kind === 'empty') return b\n  if (b.kind === 'empty') return a\n  return { kind: 'ranges', ranges: mergeRanges([...a.ranges, ...b.ranges]) }\n}\n\nexport function intersects(a: FirstSet, b: FirstSet): boolean {\n  if (a.kind === 'any' || b.kind === 'any') return true\n  if (a.kind === 'empty' || b.kind === 'empty') return false\n  for (const ra of a.ranges) {\n    for (const rb of b.ranges) {\n      if (ra.lo <= rb.hi && rb.lo <= ra.hi) return true\n    }\n  }\n  return false\n}\n\nexport function fromChar(code: number): FirstSet {\n  return { kind: 'ranges', ranges: [{ lo: code, hi: code }] }\n}\n\nexport function fromRange(lo: number, hi: number): FirstSet {\n  return { kind: 'ranges', ranges: [{ lo, hi }] }\n}\n\nexport function any(): FirstSet {\n  return { kind: 'any' }\n}\n\nexport function empty(): FirstSet {\n  return { kind: 'empty' }\n}\n\n/**\n * Can this parser SUCCEED consuming zero characters (nullable / matches-empty)?\n * Used to compute a sound sequence first-set: a nullable leading term lets the\n * NEXT term's first chars start the whole sequence. MUST err toward `true` when\n * unsure \u2014 over-estimating nullability only widens the (over-approximated) first\n * set, which stays sound; under-estimating would drop valid start chars and make\n * first-char dispatch skip a matching arm.\n */\nexport function matchesEmpty(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  // Cycle guard: a mutually-nullable ref cycle (e.g. `A = oneOrMore(B); B = oneOrMore(A)`)\n  // would recurse forever. Treat a re-entered node as nullable \u2014 the safe (`true`)\n  // default, consistent with the err-toward-true contract below.\n  if (seen.has(p)) return true\n  seen.add(p)\n  const me = (c: Combinator<unknown>): boolean => matchesEmpty(c, seen)\n  const d = p._def as ParserDef\n  switch (d.tag) {\n    case 'literal':   return d.value.length === 0\n    case 'keywords':  return false\n    case 'regex':\n      // Precise: does the pattern admit a zero-length match? (`a*`, `a?`, `a|`, \u2026)\n      try { const m = new RegExp(d.source).exec(''); return m != null && m[0] === '' }\n      catch { return true }\n    case 'many':\n    case 'optional':\n    case 'not':       return true          // zero repetitions / absent / lookahead\n    case 'oneOrMore': return me(d.parser)\n    case 'sequence':  return d.parsers.every(me)\n    case 'choice':\n      return d.parsers.some(me)\n    case 'transform':\n    case 'label':\n    case 'trivia':\n    case 'token':\n    case 'expect':\n    case 'withCtx':\n    case 'node':\n    case 'grammar':\n    case 'recover':   return me(d.parser)\n    case 'skip':      return me(d.main)\n    case 'lazy':\n      try { return me(d.thunk()) } catch { return true }\n    default:          return true          // sepBy / scanTo / guard / unknown \u2192 assume nullable (safe)\n  }\n}\n\n/**\n * First-set of a sequence: union each term's first-set through the NULLABLE\n * PREFIX \u2014 a leading `optional(\u2026)` / `many(\u2026)` / nullable term can be skipped, so\n * the sequence can begin with a LATER term's first char. Stop at (and include)\n * the first non-nullable term. (`parsers[0].firstSet` alone under-approximates\n * and silently breaks first-char dispatch \u2014 see the InterpolatedSelector bug.)\n */\nexport function sequenceFirstSet(parsers: readonly Combinator<unknown>[]): FirstSet {\n  let fs: FirstSet = empty()\n  for (const p of parsers) {\n    fs = union(fs, p._meta.firstSet)\n    if (!matchesEmpty(p)) return fs\n  }\n  return fs\n}\n\n/**\n * Deep first-set that RESOLVES `lazy`/`ref` combinators to their targets. The\n * combinators bake `_meta.firstSet` at CONSTRUCTION, when a `ref()` still reads\n * `any()` (define() never updates it) \u2014 so a `choice`/`sequence` built over refs\n * caches a spuriously-`any` first-set and loses first-char dispatch. Recomputing\n * here, following refs, recovers the real set. Over-approximates on cycles /\n * unknown constructs (returns `any`) \u2014 always sound: a wider set only means \"try\n * this arm for more first chars\", never skips a real match.\n *\n * SOUND ONLY where refs are FINAL (monolithic compile). Under compose OVERRIDE a\n * referenced rule can be replaced with a WIDER first-set, so a baked deep set\n * would wrongly skip valid input \u2014 the compose path defers dispatch to fuse time.\n */\nexport function firstSetOf(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): FirstSet {\n  if (seen.has(p)) return any()               // cycle \u2192 any (safe over-approximation)\n  seen.add(p)\n  const fs = (c: Combinator<unknown>): FirstSet => firstSetOf(c, seen)\n  const d = p._def as ParserDef\n  switch (d.tag) {\n    case 'literal':\n    case 'regex':\n    case 'keywords':  return p._meta.firstSet  // terminals: no refs, cached set is exact\n    case 'lazy':\n      try { return fs(d.thunk()) } catch { return any() }\n    case 'choice': {\n      let out: FirstSet = empty()\n      for (const arm of d.parsers) out = union(out, fs(arm))\n      return out\n    }\n    case 'sequence': {\n      // Union through the nullable prefix (a leading nullable term lets a later\n      // term's first chars start the sequence) \u2014 ref-resolving `sequenceFirstSet`.\n      let out: FirstSet = empty()\n      for (const term of d.parsers) { out = union(out, fs(term)); if (!matchesEmpty(term)) return out }\n      return out\n    }\n    case 'oneOrMore':\n    case 'many':\n    case 'optional':\n    case 'transform':\n    case 'label':\n    case 'trivia':\n    case 'token':\n    case 'node':\n    case 'grammar':\n    case 'expect':    return fs(d.parser)\n    case 'sepBy':     return fs(d.parser)\n    case 'skip':      return fs(d.main)\n    default:          return p._meta.firstSet  // not / scanTo / guard / withCtx / recover / unknown\n  }\n}\n\nfunction mergeRanges(ranges: CharRange[]): CharRange[] {\n  if (ranges.length === 0) return []\n  const sorted = [...ranges].sort((a, b) => a.lo - b.lo)\n  // Always copy \u2014 never alias input objects\n  const out: CharRange[] = [{ lo: sorted[0]!.lo, hi: sorted[0]!.hi }]\n  for (let i = 1; i < sorted.length; i++) {\n    const top = out[out.length - 1]!\n    const cur = sorted[i]!\n    if (cur.lo <= top.hi + 1) {\n      if (cur.hi > top.hi) top.hi = cur.hi\n    } else {\n      out.push({ lo: cur.lo, hi: cur.hi })\n    }\n  }\n  return out\n}\n", "import type { ParseContext, ParseFail } from '../types.ts'\n\n/**\n * Creates a ParseFail and, if a completions probe is active, records it.\n *\n * Rules:\n * - Only failures at or before the probe's target offset are eligible.\n * - A deeper failure (higher pos) replaces the current best.\n * - A tie (same pos) merges expected arrays \u2014 this is what makes choice arms\n *   aggregate their alternatives rather than each overwriting the last.\n * - Shallower failures are ignored.\n */\nexport function failAt(ctx: ParseContext, expected: string[], pos: number): ParseFail {\n  const r: ParseFail = { ok: false, expected, span: { start: pos, end: pos } }\n  const probe = ctx._probe\n  if (probe !== undefined && pos <= probe.offset) {\n    const best = probe.best\n    if (best === null || pos > best.span.start) {\n      probe.best = r\n    } else if (pos === best.span.start) {\n      probe.best = { ...best, expected: [...best.expected, ...expected] }\n    }\n  }\n  return r\n}\n", "import type { ParseContext } from '../types.ts'\n\n/** Lazy per-node capture state \u2014 arrays materialized on first push. */\nexport type CstCaptureBuf = {\n  single?: unknown | undefined\n  ch?: unknown[] | undefined\n  rawSingle?: unknown | undefined\n  raw?: unknown[] | undefined\n  tl?: number[] | undefined\n}\n\nconst EMPTY: unknown[] = []\nconst EMPTY_TL: number[] = []\n\nexport function cstCaptureActive(ctx: ParseContext): boolean {\n  return ctx._cstBuf !== undefined || ctx._cstLeaves !== undefined\n}\n\nexport type CstNodeCaptureSaved = {\n  ch: ParseContext['_cstChildren']\n  lv: ParseContext['_cstLeaves']\n  raw: ParseContext['_cstRawChildren']\n  tl: ParseContext['_cstTriviaLog']\n  cap: boolean | undefined\n  buf: CstCaptureBuf | undefined\n}\n\nexport function beginCstNodeCapture(ctx: ParseContext): CstNodeCaptureSaved {\n  const saved: CstNodeCaptureSaved = {\n    ch: ctx._cstChildren,\n    lv: ctx._cstLeaves,\n    raw: ctx._cstRawChildren,\n    tl: ctx._cstTriviaLog,\n    cap: ctx.captureTrivia,\n    buf: ctx._cstBuf,\n  }\n  ctx._cstBuf = {}\n  ctx._cstChildren = undefined\n  ctx._cstLeaves = undefined\n  ctx._cstRawChildren = undefined\n  ctx._cstTriviaLog = undefined\n  ctx.captureTrivia = true\n  return saved\n}\n\nexport function finishCstBuf(buf: CstCaptureBuf | undefined): {\n  children: unknown[]\n  rawChildren: unknown[]\n  triviaLog: number[]\n} {\n  if (!buf) return { children: EMPTY, rawChildren: EMPTY, triviaLog: EMPTY_TL }\n  const children = buf.ch ?? (buf.single !== undefined ? [buf.single] : EMPTY)\n  const rawChildren = buf.raw ?? (buf.rawSingle !== undefined ? [buf.rawSingle] : EMPTY)\n  const triviaLog = buf.tl ?? EMPTY_TL\n  return { children, rawChildren, triviaLog }\n}\n\nexport function endCstNodeCapture(\n  ctx: ParseContext,\n  saved: CstNodeCaptureSaved,\n): { children: unknown[]; rawChildren: unknown[]; triviaLog: number[] } {\n  const materialized = finishCstBuf(ctx._cstBuf)\n  ctx._cstBuf = saved.buf\n  ctx._cstChildren = saved.ch\n  ctx._cstLeaves = saved.lv\n  ctx._cstRawChildren = saved.raw\n  ctx._cstTriviaLog = saved.tl\n  ctx.captureTrivia = saved.cap\n  return materialized\n}\n\nexport function pushCstLeaf(ctx: ParseContext, leaf: unknown): void {\n  pushCstChild(ctx, leaf, leaf)\n}\n\n/** Record a built sub-node into the active collector (children vs rawChildren may differ). */\nexport function pushCstChild(ctx: ParseContext, built: unknown, rawEntry: unknown): void {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.ch) b.ch.push(built)\n    else if (b.single !== undefined) { b.ch = [b.single, built]; b.single = undefined }\n    else b.single = built\n\n    if (b.raw) b.raw.push(rawEntry)\n    else if (b.rawSingle !== undefined) { b.raw = [b.rawSingle, rawEntry]; b.rawSingle = undefined }\n    else b.rawSingle = rawEntry\n    return\n  }\n  if (ctx._cstChildren) ctx._cstChildren.push(built)\n  else if (ctx._cstLeaves) ctx._cstLeaves.push(built)\n  if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry)\n}\n\nexport function cstRawLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.raw) return b.raw.length\n    return b.rawSingle !== undefined ? 1 : 0\n  }\n  return ctx._cstRawChildren?.length ?? 0\n}\n\nexport function cstLeavesLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.ch) return b.ch.length\n    return b.single !== undefined ? 1 : 0\n  }\n  return ctx._cstLeaves?.length ?? 0\n}\n\nexport function cstTlLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) return b.tl?.length ?? 0\n  return ctx._cstTriviaLog?.length ?? 0\n}\n\nexport type CstRollbackMark = { raw: number; tlog: number; leaves: number; fields: number; errors: number }\n\nexport function saveCstMark(ctx: ParseContext): CstRollbackMark {\n  return {\n    raw: cstRawLen(ctx),\n    tlog: cstTlLen(ctx),\n    leaves: cstLeavesLen(ctx),\n    fields: ctx._fields?.length ?? 0,\n    // Speculative rollback must truncate the flat recovery-error sink in lockstep\n    // with the CST leaves: a branch that recovered (pushing a ParseError to\n    // ctx._errors AND embedding it as a CST child via captureError) then failed\n    // must remove BOTH, or the flat error survives as a GHOST that a tree walk\n    // can't see (flat run().errors would disagree with the embedded set).\n    errors: ctx._errors?.length ?? 0,\n  }\n}\n\nfunction rollbackBufList(\n  b: CstCaptureBuf,\n  keyMulti: 'ch' | 'raw',\n  keySingle: 'single' | 'rawSingle',\n  len: number,\n): void {\n  const arr = b[keyMulti]\n  if (arr) {\n    if (len === 0) b[keyMulti] = undefined\n    else if (len === 1) { b[keySingle] = arr[0]; b[keyMulti] = undefined }\n    else arr.length = len\n    return\n  }\n  if (len === 0) b[keySingle] = undefined\n}\n\nexport function rollbackCstCapture(ctx: ParseContext, mark: CstRollbackMark): void {\n  // Truncate the flat recovery-error sink alongside the CST, so a rolled-back\n  // speculative branch leaves no ghost error (see saveCstMark). Guarded on a\n  // present sink + a defined mark (rollbackTrivia forwards the same field).\n  if (ctx._errors && mark.errors !== undefined) ctx._errors.length = mark.errors\n  const b = ctx._cstBuf\n  if (b) {\n    rollbackBufList(b, 'raw', 'rawSingle', mark.raw)\n    rollbackBufList(b, 'ch', 'single', mark.leaves)\n    if (b.tl) {\n      if (mark.tlog === 0) b.tl = undefined\n      else b.tl.length = mark.tlog\n    }\n    if (ctx._fields) ctx._fields.length = mark.fields\n    return\n  }\n  if (ctx._cstRawChildren) ctx._cstRawChildren.length = mark.raw\n  if (ctx._cstTriviaLog) ctx._cstTriviaLog.length = mark.tlog\n  if (ctx._cstLeaves) ctx._cstLeaves.length = mark.leaves\n  if (ctx._fields) ctx._fields.length = mark.fields\n}\n\nexport function pushCstTriviaEntry(\n  ctx: ParseContext,\n  start: number,\n  end: number,\n  kindIndex?: number,\n): void {\n  const insertIdx = cstRawLen(ctx)\n  const b = ctx._cstBuf\n  const withKind = ctx.triviaKindLabels !== undefined && kindIndex !== undefined\n  if (b) {\n    if (!b.tl) {\n      b.tl = withKind ? [start, end, insertIdx, kindIndex] : [start, end, insertIdx]\n    } else if (withKind) {\n      b.tl.push(start, end, insertIdx, kindIndex)\n    } else {\n      b.tl.push(start, end, insertIdx)\n    }\n    return\n  }\n  if (ctx._cstTriviaLog) {\n    if (withKind) ctx._cstTriviaLog.push(start, end, insertIdx, kindIndex)\n    else ctx._cstTriviaLog.push(start, end, insertIdx)\n  }\n}\n\nexport function pushTriviaLogEntry(\n  ctx: ParseContext,\n  start: number,\n  end: number,\n  kindIndex?: number,\n): void {\n  if (!ctx._triviaLog) return\n  if (ctx.triviaKindLabels !== undefined && kindIndex !== undefined) {\n    ctx._triviaLog.push(start, end, kindIndex)\n  } else {\n    ctx._triviaLog.push(start, end)\n  }\n}\n\nexport function cstDeferredTriviaActive(ctx: ParseContext): boolean {\n  return ctx._triviaLog !== undefined || ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { fromChar, empty } from './first-set.ts'\nimport { failAt } from './probe.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\n/**\n * ASCII case-fold equality \u2014 the interpreter twin of the compiler's `foldEq`\n * (and `/i`-flag regex lowering). Folds ASCII letters via bit 0x20, exact-matches\n * everything else. Deliberately NOT `Intl.Collator` (measured ~9\u00D7 slower, and its\n * Unicode accent-folding is the wrong semantic for a parser). Keeps interpreter /\n * compiled / macro output identical for case-insensitive `literal()`.\n */\nfunction asciiFoldEq(a: string, b: string): boolean {\n  if (a.length !== b.length) return false\n  for (let i = 0; i < a.length; i++) {\n    let ca = a.charCodeAt(i)\n    let cb = b.charCodeAt(i)\n    if (ca >= 65 && ca <= 90) ca += 32\n    if (cb >= 65 && cb <= 90) cb += 32\n    if (ca !== cb) return false\n  }\n  return true\n}\n\nexport type LiteralOptions = {\n  caseInsensitive?: boolean\n}\n\nexport function literal(value: string, opts: LiteralOptions = {}): Combinator<string> {\n  const caseInsensitive = opts.caseInsensitive ?? false\n\n  const firstSet = value.length > 0\n    ? fromChar(value.codePointAt(0)!)\n    : empty()\n\n  const meta: ParserMeta = {\n    firstSet,\n    canMatchNewline: value.includes('\\n'),\n    isTrivia: false,\n  }\n\n  if (caseInsensitive) {\n    const upper = value.toUpperCase()\n    const lower = value.toLowerCase()\n    const firstUpper = upper.codePointAt(0)\n    const firstLower = lower.codePointAt(0)\n    // Two discrete points, not one spanning range \u2014 `asciiFoldEq` accepts only\n    // the char and its fold twin, so `[min, max]` would over-approximate (e.g.\n    // 'a'/'A' \u2192 the whole 65..97 span, pulling B\u2013Z/`[\\]^_\\`` into dispatch).\n    meta.firstSet = firstLower !== undefined && firstUpper !== undefined\n      ? firstLower === firstUpper\n        ? { kind: 'ranges', ranges: [{ lo: firstLower, hi: firstLower }] }\n        : { kind: 'ranges', ranges: [\n            { lo: firstLower, hi: firstLower },\n            { lo: firstUpper, hi: firstUpper },\n          ]}\n      : firstSet\n  }\n\n  const expected = [JSON.stringify(value)]\n\n  // Single-char case-sensitive literals are the bulk of punctuation-heavy\n  // grammars (GraphQL `{ } ( ) : $ @ [ ] ! =`, JSON, CSS). A bare `charCodeAt`\n  // compare beats the generic `startsWith` builtin call, and an out-of-bounds\n  // `charCodeAt` returns NaN \u2014 so the length check folds into the compare.\n  const parse = !caseInsensitive && value.length === 1\n    ? (() => {\n        const code = value.charCodeAt(0)\n        return function parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n          if (input.charCodeAt(pos) === code) {\n            const span = { start: pos, end: pos + 1 }\n            if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value, span })\n            return { ok: true, value, span }\n          }\n          return failAt(ctx, expected, pos)\n        }\n      })()\n    : function parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n        const end = pos + value.length\n        if (end > input.length) {\n          return failAt(ctx, expected, pos)\n        }\n        const matchedValue = caseInsensitive ? input.slice(pos, end) : value\n        if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {\n          const span = { start: pos, end }\n          if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value: matchedValue, span })\n          return { ok: true, value: matchedValue, span }\n        }\n        return failAt(ctx, expected, pos)\n      }\n\n  return {\n    _tag: 'literal',\n    _meta: meta,\n    _def: { tag: 'literal', value, caseInsensitive },\n    parse,\n  }\n}\n", "/**\n * Low-level regex char-class primitives, shared by every hand-rolled regex\n * analysis in the codebase \u2014 the interpreter's first-set walker\n * (`./first-set.ts`), `regex()`'s short-scan fast path, and codegen's scannable\n * lowering (`../compiler/scannable-run.ts`). Kept dependency-free (no combinator,\n * no codegen imports) so it lands in even the leanest interpreter bundle.\n *\n * Everything here parses a regex STRUCTURE to code-point ranges; nothing encodes\n * a specific byte meaning (\"this is whitespace\"). `\\d`/`\\w` lower to their ASCII\n * ranges (correct for the default, non-`u` engine); `\\s` uses the fixed\n * `SPACE_RANGES` set (unaffected by the `u` flag).\n */\n\n/** Single-char escapes whose code point is fixed regardless of context. */\nexport const CLASS_ESCAPES: Record<string, number> = { t: 9, n: 10, r: 13, f: 12, v: 11, '0': 0 }\n\n/**\n * `\\s`'s code-point set per the spec's `WhiteSpace` + `LineTerminator`\n * productions \u2014 TAB/LF/VT/FF/CR, SPACE, NBSP, and the Unicode `Zs` space\n * separators. Fixed regardless of the `u` flag, so always safe to lower.\n */\nexport const SPACE_RANGES: Array<[number, number]> = [\n  [9, 13], [32, 32], [160, 160], [5760, 5760], [8192, 8202],\n  [8232, 8232], [8233, 8233], [8239, 8239], [8287, 8287], [12288, 12288], [65279, 65279],\n]\n\n/**\n * ASCII code-point ranges for the shorthand classes we lower. `\\d`/`\\w` are\n * ASCII-only in the default (non-`u`) engine; `\\s` maps to `SPACE_RANGES`.\n */\nexport function shorthandRanges(ch: 'd' | 'w' | 's'): Array<[number, number]> {\n  if (ch === 'd') return [[48, 57]]\n  if (ch === 's') return SPACE_RANGES\n  // Order matches the canonical `scannable-run` lowering (underscore last), so\n  // `ScanShape` output and generated code stay byte-identical. Membership is\n  // order-independent (ranges are iterated / the FirstSet union sorts), so the\n  // non-sorted order is purely representational \u2014 see PR #16 discussion.\n  return [[48, 57], [65, 90], [97, 122], [95, 95]]\n}\n\n/** `\\uXXXX` at `body[i]` \u2192 its code point and the index past it, or null. */\nexport function readUnicodeEscape(body: string, i: number): { cp: number; next: number } | null {\n  if (body[i] !== '\\\\' || body[i + 1] !== 'u') return null\n  const hex = body.slice(i + 2, i + 6)\n  if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null\n  return { cp: Number.parseInt(hex, 16), next: i + 6 }\n}\n\ntype ClassAtom = { cp: number } | { set: Array<[number, number]> }\n\n/**\n * Parse a regex char-class body (the chars BETWEEN `[` and `]`, negation `^`\n * already stripped by the caller) to code-point ranges. `\\d`/`\\w`/`\\s` expand to\n * their ranges; `\\uXXXX` and the fixed single-char escapes resolve to their code\n * point; any other letter escape (`\\D`, `\\W`, `\\S`, `\\b`, \u2026) returns null rather\n * than being mis-read as a literal letter, so callers fall back to a safe\n * over-approximation instead of a wrong set.\n */\nexport function parseClassRanges(body: string): Array<[number, number]> | null {\n  const ranges: Array<[number, number]> = []\n  let i = 0\n  const readAtom = (): ClassAtom | null => {\n    const ch = body[i]\n    if (ch === undefined) return null\n    if (ch === '\\\\') {\n      const uni = readUnicodeEscape(body, i)\n      if (uni) {\n        i = uni.next\n        return { cp: uni.cp }\n      }\n      const e = body[i + 1]\n      if (e === undefined) return null\n      i += 2\n      if (e in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[e]! }\n      if (e === 'd' || e === 'w' || e === 's') return { set: shorthandRanges(e) }\n      // Any other letter escape is a class we can't safely lower (\\D, \\W, \\S, \u2026).\n      if ((e >= 'a' && e <= 'z') || (e >= 'A' && e <= 'Z')) return null\n      return { cp: e.codePointAt(0)! }\n    }\n    i += ch.length\n    return { cp: ch.codePointAt(0)! }\n  }\n  while (i < body.length) {\n    const lo = readAtom()\n    if (lo === null) return null\n    if ('set' in lo) {\n      ranges.push(...lo.set)\n      continue\n    }\n    if (body[i] === '-' && body[i + 1] !== undefined && body[i + 1] !== ']') {\n      i += 1\n      const hi = readAtom()\n      if (hi === null || 'set' in hi) return null\n      ranges.push([lo.cp, hi.cp])\n    } else {\n      ranges.push([lo.cp, lo.cp])\n    }\n  }\n  return ranges.length ? ranges : null\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, FirstSet } from '../types.ts'\nimport { any } from './first-set.ts'\nimport { failAt } from './probe.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\nimport { shorthandRanges, parseClassRanges } from '../regex/classes.ts'\n\n/**\n * Computes a regex terminal's first-set (for choice-dispatch fast paths). The\n * implementation \u2014 `firstSetFromRegex` in `../regex/first-set.ts` \u2014 is a small,\n * dependency-free hand-rolled regex parser, registered by the interpreter/library\n * entry (`index.ts`) via `registerRegexAnalyzer`. It is injected rather than\n * imported so that consumers who import `regex` directly from this subpath (no\n * library entry) never pull the analyzer into their bundle at all. When no\n * analyzer is registered, `regex()` uses the permissive fallback below \u2014 this\n * only disables the dispatch fast paths, never changing matches.\n */\nexport type RegexFirstSetAnalyzer = (pattern: string) => { firstSet: FirstSet; canMatchNewline: boolean }\n\nlet firstSetAnalyzer: RegexFirstSetAnalyzer | null = null\n\nexport function registerRegexAnalyzer(analyzer: RegexFirstSetAnalyzer): void {\n  firstSetAnalyzer = analyzer\n}\n\n/** Fallback when no analyzer is registered: \"could start with any char / could\n * match a newline\" \u2014 the same conservative value `firstSetFromRegex` returns on\n * an unparseable pattern, so a missing analyzer degrades to \"no fast path\", not\n * a wrong one. */\nconst permissiveFirstSet: RegexFirstSetAnalyzer = () => ({ firstSet: any(), canMatchNewline: true })\n\nconst SCAN_BAIL_AT = 64\ntype ShortScanner = (input: string, pos: number) => number | null | undefined\n\nfunction inRanges(cp: number, ranges: Array<[number, number]>): boolean {\n  for (let i = 0; i < ranges.length; i++) {\n    const [lo, hi] = ranges[i]!\n    if (cp >= lo && cp <= hi) return true\n  }\n  return false\n}\n\n/**\n * The positive char-class body (chars between `[` and `]`) as ranges for the\n * short-scan fast path, or null if it can't be lowered \u2014 including a NEGATED\n * class (`[^\u2026]`), which the scan can't express. The class parsing itself is the\n * shared `parseClassRanges` (see `../regex/classes.ts`).\n */\nfunction readClassRanges(body: string): Array<[number, number]> | null {\n  if (body.startsWith('^')) return null\n  return parseClassRanges(body)\n}\n\nfunction shortScanner(source: string, flags: string): ShortScanner | null {\n  if (/[imsuvy]/.test(flags)) return null\n  let ranges: Array<[number, number]> | null = null\n  let quant = ''\n  if (source[0] === '[') {\n    let end = 1\n    while (end < source.length && source[end] !== ']') {\n      if (source[end] === '\\\\') end += 2\n      else end++\n    }\n    if (source[end] !== ']') return null\n    ranges = readClassRanges(source.slice(1, end))\n    quant = source.slice(end + 1)\n  } else if (source[0] === '\\\\' && (source[1] === 'd' || source[1] === 'w' || source[1] === 's')) {\n    ranges = shorthandRanges(source[1])\n    quant = source.slice(2)\n  }\n  if (!ranges || (quant !== '+' && quant !== '*')) return null\n  const minOne = quant === '+'\n  return (input, pos) => {\n    let end = pos\n    while (end < input.length && inRanges(input.charCodeAt(end), ranges)) {\n      end++\n      if (end - pos >= SCAN_BAIL_AT) return undefined\n    }\n    return minOne && end === pos ? null : end\n  }\n}\n\nexport function regex(pattern: string | RegExp, flags = ''): Combinator<string> {\n  const source = typeof pattern === 'string' ? pattern : pattern.source\n  const resolvedFlags = typeof pattern === 'string' ? flags : pattern.flags\n\n  const anchored = new RegExp(source, 'y' + resolvedFlags.replace(/[gy]/g, ''))\n  const scan = shortScanner(source, resolvedFlags)\n\n  const { firstSet, canMatchNewline } = (firstSetAnalyzer ?? permissiveFirstSet)(source)\n  const meta: ParserMeta = { firstSet, canMatchNewline, isTrivia: false }\n\n  return {\n    _tag: 'regex',\n    _meta: meta,\n    _def: { tag: 'regex', source, flags: resolvedFlags },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      const scanEnd = scan?.(input, pos)\n      if (scanEnd !== undefined) {\n        if (scanEnd === null) return failAt(ctx, [`/${source}/`], pos)\n        const value = input.slice(pos, scanEnd)\n        const span = { start: pos, end: scanEnd }\n        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value, span })\n        return { ok: true, value, span }\n      }\n      anchored.lastIndex = pos\n      const m = anchored.exec(input)\n      if (m === null) {\n        return failAt(ctx, [`/${source}/`], pos)\n      }\n      const span = { start: pos, end: pos + m[0]!.length }\n      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value: m[0]!, span })\n      return { ok: true, value: m[0]!, span }\n    },\n  }\n}\n", "/**\n * Hand-rolled first-set analysis for `regex()` terminals \u2014 the interpreter's\n * replacement for the old `regexp-tree`-backed analyzer (~264 KB). A `regex()`\n * terminal's first-set is used ONLY to let `choice()` do first-char dispatch\n * (see `choice.ts`); it is never consulted for whether a match succeeds. So this\n * analyzer only has to be SOUND as an OVER-approximation: every char the pattern\n * can actually start with must be in the returned set. Any construct it can't\n * pin down widens to `any()` (\u2014 \"could start with anything\" \u2014), which only\n * disables a dispatch fast path, never changes a parse. Under-approximating\n * (dropping a real start char) WOULD be a bug: dispatch would skip a matching\n * arm. The soundness fuzz test (`test/unit/regex-first-set.test.ts`) checks this\n * against the real `RegExp` engine as an oracle.\n *\n * It parses the regex into a tiny AST (single-char matchers, sequence,\n * alternation, repetition, zero-width) reusing the shared char-class primitives\n * in `./classes.ts`, then walks the AST unioning first-sets through the nullable\n * prefix \u2014 the same shape the `regexp-tree` walker used.\n *\n * Note: flags are not consulted (matching the prior `regexp-tree` seam, which\n * parsed `/${source}/` with no flags), so an `/i` pattern's first-set is its\n * literal-case set. Sound for dispatch because the interpreter's `/i` regex arms\n * are compared case-sensitively at the same seam.\n */\nimport type { FirstSet } from '../types.ts'\nimport { any, empty, fromRange, union } from '../combinators/first-set.ts'\nimport { shorthandRanges, parseClassRanges } from './classes.ts'\n\n// A minimal regex AST. Each node answers two questions: what first chars can a\n// non-empty match begin with (`firstSet`), and can the node match zero chars\n// (`nullable`). `any` is the over-approximation sentinel for anything we don't\n// model precisely.\ntype Node =\n  | { t: 'char'; set: FirstSet; nl: boolean } // matches exactly one char from `set`\n  | { t: 'any' }                              // unknown 1-char-ish construct: could start with anything\n  | { t: 'empty' }                            // zero-width: anchors, lookaround, word boundary\n  | { t: 'seq'; parts: Node[] }\n  | { t: 'alt'; arms: Node[] }\n  | { t: 'rep'; node: Node; min: number }     // quantified; min 0 \u21D2 nullable\n\nconst ANY: Node = { t: 'any' }\nconst EMPTY: Node = { t: 'empty' }\n\nfunction charNode(set: FirstSet, nl: boolean): Node {\n  return { t: 'char', set, nl }\n}\n\nfunction rangesToSet(ranges: Array<[number, number]>): FirstSet {\n  let fs: FirstSet = empty()\n  for (const [lo, hi] of ranges) fs = union(fs, fromRange(lo, hi))\n  return fs\n}\n\nfunction rangesHaveNewline(ranges: Array<[number, number]>): boolean {\n  return ranges.some(([lo, hi]) => lo <= 0x0a && 0x0a <= hi)\n}\n\n// ---------------------------------------------------------------------------\n// Parser: recursive descent over a raw regex source (no surrounding delimiters).\n// Throws `Bail` on a structure it can't parse (unbalanced group/class); the\n// entry point catches it and degrades the WHOLE pattern to `any()`. A construct\n// that parses but isn't modeled (a backreference, an exotic escape) becomes an\n// `any` NODE instead \u2014 sound and more precise, since it only pollutes the\n// first-set if reached in the nullable prefix.\n// ---------------------------------------------------------------------------\n\n/** Thrown on a structure the parser can't handle (unbalanced group/class); the\n * entry point catches it and degrades the whole pattern to `any()`. */\nconst BAIL = Symbol('regex-bail')\n\n/**\n * Parse a raw regex `src` (no delimiters) into a `Node`, or throw `BAIL`.\n * Closure over a single cursor `i` \u2014 recursive-descent: alt \u2192 seq \u2192 quantified\n * \u2192 atom.\n */\nfunction parseRegex(src: string): Node {\n  let i = 0\n\n  const parseAlt = (): Node => {\n    const arms: Node[] = [parseSeq()]\n    while (src[i] === '|') { i++; arms.push(parseSeq()) }\n    return arms.length === 1 ? arms[0]! : { t: 'alt', arms }\n  }\n\n  const parseSeq = (): Node => {\n    const parts: Node[] = []\n    while (i < src.length) {\n      const ch = src[i]!\n      if (ch === '|' || ch === ')') break\n      parts.push(parseQuantified())\n    }\n    if (parts.length === 0) return EMPTY\n    return parts.length === 1 ? parts[0]! : { t: 'seq', parts }\n  }\n\n  const parseQuantified = (): Node => {\n    const atom = parseAtom()\n    const ch = src[i]\n    let min: number | null = null\n    if (ch === '*') { min = 0; i++ }\n    else if (ch === '+') { min = 1; i++ }\n    else if (ch === '?') { min = 0; i++ }\n    else if (ch === '{') { min = parseBraceQuantifier() }\n    if (min === null) return atom\n    // Consume a lazy `?` on the quantifier \u2014 it changes greediness, not first-set.\n    if (src[i] === '?') i++\n    return { t: 'rep', node: atom, min }\n  }\n\n  // Parse `{n}` / `{n,}` / `{n,m}` at `i` (on `{`), returning the minimum; null\n  // (leaving `{` unconsumed) if it isn't a well-formed brace quantifier, so the\n  // caller keeps the `{` as the literal atom it already parsed.\n  const parseBraceQuantifier = (): number | null => {\n    const close = src.indexOf('}', i)\n    if (close === -1) return null\n    const m = /^(\\d+)(?:,(\\d*))?$/.exec(src.slice(i + 1, close))\n    if (!m) return null\n    i = close + 1\n    return Number.parseInt(m[1]!, 10)\n  }\n\n  const parseAtom = (): Node => {\n    const ch = src[i]!\n    switch (ch) {\n      case '(': return parseGroup()\n      case '[': return parseClass()\n      case '.': i++; return charNode(any(), false) // `.` matches any char except line terminators\n      case '\\\\': return parseEscape()\n      case '^':\n      case '$': i++; return EMPTY // anchors are zero-width\n      case '{': i++; return charNode(fromRange(0x7b, 0x7b), false) // a `{` with nothing to quantify is a literal brace\n      default:\n        i += ch.length\n        return charNode(fromRange(ch.codePointAt(0)!, ch.codePointAt(0)!), ch === '\\n')\n    }\n  }\n\n  const parseGroup = (): Node => {\n    i++ // consume '('\n    // Group prefixes: (?:\u2026) (?=\u2026) (?!\u2026) (?<=\u2026) (?<!\u2026) (?<name>\u2026)\n    let lookaround = false\n    if (src[i] === '?') {\n      const c1 = src[i + 1]\n      if (c1 === ':') i += 2\n      else if (c1 === '=' || c1 === '!') { i += 2; lookaround = true }\n      else if (c1 === '<') {\n        const c2 = src[i + 2]\n        if (c2 === '=' || c2 === '!') { i += 3; lookaround = true } // lookbehind\n        else { // named group (?<name>\u2026): skip to '>'\n          const gt = src.indexOf('>', i)\n          if (gt === -1) throw BAIL\n          i = gt + 1\n        }\n      } else throw BAIL // (? followed by something unexpected\n    }\n    const inner = parseAlt()\n    if (src[i] !== ')') throw BAIL\n    i++ // consume ')'\n    return lookaround ? EMPTY : inner // lookaround is zero-width\n  }\n\n  const parseClass = (): Node => {\n    // Read `[ ... ]`, honoring `\\]`; detect leading `^` negation.\n    let k = i + 1\n    const negated = src[k] === '^'\n    if (negated) k++\n    let body = ''\n    while (k < src.length && src[k] !== ']') {\n      if (src[k] === '\\\\') { body += src[k]! + (src[k + 1] ?? ''); k += 2 }\n      else { body += src[k]!; k++ }\n    }\n    if (src[k] !== ']') throw BAIL\n    i = k + 1\n    // A negated class can start with (almost) any char, and can match a newline\n    // unless it excludes it (we don't try to prove exclusion \u2014 `true` is the safe\n    // over-approximation).\n    if (negated) return charNode(any(), true)\n    const ranges = parseClassRanges(body)\n    if (!ranges) return charNode(any(), true) // unparseable class \u2192 widen\n    return charNode(rangesToSet(ranges), rangesHaveNewline(ranges))\n  }\n\n  const parseEscape = (): Node => {\n    const e = src[i + 1]\n    if (e === undefined) throw BAIL\n    // \\uXXXX\n    if (e === 'u' && /^[0-9a-fA-F]{4}$/.test(src.slice(i + 2, i + 6))) {\n      const cp = Number.parseInt(src.slice(i + 2, i + 6), 16)\n      i += 6\n      return charNode(fromRange(cp, cp), cp === 0x0a)\n    }\n    // \\xHH\n    if (e === 'x' && /^[0-9a-fA-F]{2}$/.test(src.slice(i + 2, i + 4))) {\n      const cp = Number.parseInt(src.slice(i + 2, i + 4), 16)\n      i += 4\n      return charNode(fromRange(cp, cp), cp === 0x0a)\n    }\n    i += 2\n    switch (e) {\n      case 'd': return charNode(rangesToSet(shorthandRanges('d')), false)\n      case 'w': return charNode(rangesToSet(shorthandRanges('w')), false)\n      case 's': return charNode(rangesToSet(shorthandRanges('s')), true)\n      case 'D': case 'W': case 'S': return charNode(any(), true) // negated shorthand \u2192 widen\n      case 'b': case 'B': return EMPTY // word boundary: zero-width\n      case 'n': return charNode(fromRange(0x0a, 0x0a), true)\n      case 'r': return charNode(fromRange(0x0d, 0x0d), false)\n      case 't': return charNode(fromRange(0x09, 0x09), false)\n      case 'f': return charNode(fromRange(0x0c, 0x0c), false)\n      case 'v': return charNode(fromRange(0x0b, 0x0b), false)\n      case '0': return charNode(fromRange(0, 0), false)\n      default:\n        // A digit escape is a backreference we don't resolve \u2192 widen.\n        if (e >= '1' && e <= '9') return ANY\n        // Any other escape is a literal char (escaped metachar, `\\/`, etc.).\n        return charNode(fromRange(e.codePointAt(0)!, e.codePointAt(0)!), e === '\\n')\n    }\n  }\n\n  const node = parseAlt()\n  if (i < src.length) throw BAIL // leftover (e.g. an unbalanced `)`)\n  return node\n}\n\n// ---------------------------------------------------------------------------\n// Walkers over the AST.\n// ---------------------------------------------------------------------------\n\n/** Can `n` succeed consuming zero characters? Err toward `true` when unsure \u2014\n * over-estimating nullability only widens the (over-approximated) first-set. */\nfunction nullable(n: Node): boolean {\n  switch (n.t) {\n    case 'char': return false\n    case 'any': return true\n    case 'empty': return true\n    case 'seq': return n.parts.every(nullable)\n    case 'alt': return n.arms.some(nullable)\n    case 'rep': return n.min === 0 || nullable(n.node)\n  }\n}\n\n/** First chars a non-empty match of `n` can begin with (over-approximated). */\nfunction firstSet(n: Node): FirstSet {\n  switch (n.t) {\n    case 'char': return n.set\n    case 'any': return any()\n    case 'empty': return empty()\n    case 'rep': return firstSet(n.node)\n    case 'alt': {\n      let fs: FirstSet = empty()\n      for (const arm of n.arms) fs = union(fs, firstSet(arm))\n      return fs\n    }\n    case 'seq': {\n      // Union each part's first-set through the nullable prefix: a leading\n      // nullable part lets a LATER part's first chars start the sequence.\n      let fs: FirstSet = empty()\n      for (const part of n.parts) {\n        fs = union(fs, firstSet(part))\n        if (!nullable(part)) break\n      }\n      return fs\n    }\n  }\n}\n\n/** Whether the first consumed char can be a newline (tracked separately from\n * `firstSet` because `.`/`\\D`/negated classes widen to `any` yet differ on\n * whether that includes a newline). */\nfunction firstCanBeNewline(n: Node): boolean {\n  switch (n.t) {\n    case 'char': return n.nl\n    case 'any': return true\n    case 'empty': return false\n    case 'rep': return firstCanBeNewline(n.node)\n    case 'alt': return n.arms.some(firstCanBeNewline)\n    case 'seq': {\n      for (const part of n.parts) {\n        if (firstCanBeNewline(part)) return true\n        if (!nullable(part)) break\n      }\n      return false\n    }\n  }\n}\n\n/**\n * Compute a regex terminal's first-set and newline-start flag from its SOURCE\n * (no delimiters, no flags). Over-approximates: an unparseable pattern degrades\n * to `{ any, canMatchNewline: true }` \u2014 the same conservative value the prior\n * `regexp-tree` seam returned on a parse failure.\n */\nexport function firstSetFromRegex(source: string): { firstSet: FirstSet; canMatchNewline: boolean } {\n  let ast: Node\n  try {\n    ast = parseRegex(source)\n  } catch {\n    return { firstSet: any(), canMatchNewline: true }\n  }\n  // A NULLABLE pattern (can match zero chars) must widen to `any()`: as a\n  // `choice()` arm it can succeed with an empty match at ANY position, so a\n  // narrow first-set would let first-char dispatch wrongly skip it. Only a\n  // pattern that must consume \u22651 char has a meaningful first-set.\n  if (nullable(ast)) return { firstSet: any(), canMatchNewline: true }\n  return { firstSet: firstSet(ast), canMatchNewline: firstCanBeNewline(ast) }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, FirstSet } from '../types.ts'\nimport { fromChar, union, empty } from './first-set.ts'\nimport { failAt } from './probe.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\nexport type KeywordsOptions = {\n  /** Match case-insensitively. */\n  caseInsensitive?: boolean\n  /**\n   * Character class (regex source, e.g. `'A-Za-z0-9_-'`) that must NOT follow a\n   * match \u2014 a word boundary. Prevents matching `red` inside `redish`.\n   */\n  boundary?: string\n}\n\n/**\n * Match a single keyword with an automatic word-boundary guard. Prevents\n * matching `true` inside `trueish`. The boundary defaults to `_0-9A-Za-z`,\n * which covers most programming-language identifiers.\n *\n *   word('true')              // matches \"true\" but not \"trueish\"\n *   word('color', 'A-Za-z-') // CSS-style identifier boundary\n */\nexport function word(str: string, boundary = '_0-9A-Za-z'): Combinator<string> {\n  return keywords([str], { boundary })\n}\n\n/**\n * Create a keyword factory with a fixed word-boundary class. Use when many\n * keywords share the same boundary (e.g. CSS identifiers). For a single keyword,\n * `word(str, boundary?)` is enough; you can also roll your own factory with\n * `(s) => word(s, boundary)`.\n *\n *   const kw = makeWord()                    // default: '_0-9A-Za-z'\n *   const cssKw = makeWord('A-Za-z0-9_-')    // dashes allowed in CSS idents\n *\n *   const query = kw('query')\n *   const color = cssKw('color')             // matches \"color\" but not \"color-scheme\"\n */\nexport function makeWord(boundary = '_0-9A-Za-z'): (str: string) => Combinator<string> {\n  return (str: string) => keywords([str], { boundary })\n}\n\nfunction escapeRe(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/**\n * Match any one of a set of fixed keywords, longest-first (so `border` wins over\n * `bord`), with an optional trailing word-boundary guard. Compiles to a single\n * sticky regex \u2014 far less error-prone than a hand-maintained alternation, and\n * the common case (keyword sets: CSS colors, units, at-rule names, HTML tags).\n *\n *   keywords(CSS_COLOR_NAMES, { caseInsensitive: true, boundary: 'A-Za-z0-9_-' })\n *\n * On success the matched text is recorded as a CSTLeaf (like literal()/regex()).\n */\nexport function keywords(words: readonly string[], opts: KeywordsOptions = {}): Combinator<string> {\n  // Longest-first keeps the alternation greedy-correct (regex alternation is\n  // first-match, not longest-match).\n  const sorted = [...new Set(words)].sort((a, b) => b.length - a.length)\n  const alt = sorted.map(escapeRe).join('|')\n  const boundary = opts.boundary ? `(?![${opts.boundary}])` : ''\n  const flags = opts.caseInsensitive ? 'iuy' : 'uy'\n  const re = new RegExp(`(?:${alt})${boundary}`, flags)\n\n  // First-set: the set of first code points across all keywords (and their\n  // case-folded variants when case-insensitive), for choice() dispatch.\n  let firstSet: FirstSet = empty()\n  for (const w of sorted) {\n    if (w.length === 0) continue\n    const cp = w.codePointAt(0)!\n    firstSet = union(firstSet, fromChar(cp))\n    if (opts.caseInsensitive) {\n      const u = String.fromCodePoint(cp).toUpperCase().codePointAt(0)\n      const l = String.fromCodePoint(cp).toLowerCase().codePointAt(0)\n      if (u !== undefined) firstSet = union(firstSet, fromChar(u))\n      if (l !== undefined) firstSet = union(firstSet, fromChar(l))\n    }\n  }\n\n  const meta: ParserMeta = { firstSet, canMatchNewline: false, isTrivia: false }\n\n  return {\n    _tag: 'keywords',\n    _meta: meta,\n    _def: { tag: 'keywords', words: sorted, caseInsensitive: opts.caseInsensitive ?? false, boundary: opts.boundary },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      re.lastIndex = pos\n      const m = re.exec(input)\n      if (m === null || m.index !== pos) {\n        return failAt(ctx, ['keyword'], pos)\n      }\n      const value = m[0]!\n      const span = { start: pos, end: pos + value.length }\n      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value, span })\n      return { ok: true, value, span }\n    },\n  }\n}\n", "import type { Combinator, FirstSet, ParseContext, ParseError, ParseResult, RecoveryHelpers } from '../types.ts'\nimport { cstCaptureActive, pushCstChild } from '../cst/capture-buffer.ts'\n\n/**\n * Recovery MECHANISM \u2014 sync-source-agnostic. These primitives implement \"scan\n * forward to a sync token and emit a ParseError\" and \"is the sync token here?\".\n * They are deliberately independent of WHERE the sync sentinel comes from: the\n * grammar never carries recovery config. Sync points are inferred automatically\n * from grammar structure (see `infer.ts`) and may be overridden externally by the\n * language service via `ctx._listSync`. This is the salvaged core of the old\n * `combinators/recover-scan.ts`.\n */\n\n/**\n * Run `sentinel` at `pos` as PURE lookahead: succeed/fail only, with every\n * side-effecting sink suppressed (CST leaves/children/trivia, the trivia log,\n * the recovery error sink, and the completions probe). A recovery scan probes the\n * sentinel at many positions and must not capture leaves, log trivia, or pollute\n * `completionsAt`'s furthest-failure set as a byproduct of looking ahead.\n */\nfunction probeAt(sentinel: Combinator<unknown>, input: string, pos: number, ctx: ParseContext): boolean {\n  const s = {\n    _probe: ctx._probe, _errors: ctx._errors,\n    _cstLeaves: ctx._cstLeaves, _cstChildren: ctx._cstChildren, _cstRawChildren: ctx._cstRawChildren,\n    _cstTriviaLog: ctx._cstTriviaLog, _triviaLog: ctx._triviaLog, _fields: ctx._fields, _cstBuf: ctx._cstBuf,\n    _tolerant: ctx._tolerant, _sync: ctx._sync,\n  }\n  ctx._probe = undefined; ctx._errors = undefined\n  ctx._cstLeaves = undefined; ctx._cstChildren = undefined; ctx._cstRawChildren = undefined\n  ctx._cstTriviaLog = undefined; ctx._triviaLog = undefined; ctx._fields = undefined; ctx._cstBuf = undefined\n  // A sentinel is pure lookahead: it must not itself enter tolerant recovery (nor\n  // read a stale outer `_sync`). Otherwise a sentinel that composes many/sepBy would\n  // run recovery on every probed position \u2014 wasted work, and it could resync to the\n  // enclosing list's sync token. Cleared here and restored in `finally`.\n  ctx._tolerant = undefined; ctx._sync = undefined\n  try {\n    return sentinel.parse(input, pos, ctx).ok\n  } finally {\n    ctx._probe = s._probe; ctx._errors = s._errors\n    ctx._cstLeaves = s._cstLeaves; ctx._cstChildren = s._cstChildren; ctx._cstRawChildren = s._cstRawChildren\n    ctx._cstTriviaLog = s._cstTriviaLog; ctx._triviaLog = s._triviaLog; ctx._fields = s._fields; ctx._cstBuf = s._cstBuf\n    ctx._tolerant = s._tolerant; ctx._sync = s._sync\n  }\n}\n\n/**\n * Combine two recovery sentinels into one that matches when either does \u2014 used by\n * tolerant `sepBy` to resync to its own separator OR the enclosing delimiter. Cold\n * path only; a bare wrapper so we don't pull `choice()` (and its analysis) in.\n */\nexport function orSentinel(\n  a: Combinator<unknown>,\n  b: Combinator<unknown> | undefined,\n): Combinator<unknown> {\n  if (b === undefined) return a\n  return {\n    _tag: 'orSentinel',\n    _meta: { firstSet: { kind: 'any' }, canMatchNewline: false, isTrivia: false },\n    _def: { tag: 'unknown' },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<unknown> {\n      const ra = a.parse(input, pos, ctx)\n      if (ra.ok) return ra\n      return b.parse(input, pos, ctx)\n    },\n  }\n}\n\n/**\n * A lightweight zero-width sentinel that \"matches\" (succeeds, consuming nothing)\n * when the input code point at `pos` starts the given first set. Sync inference\n * builds one from a list's follow set so a nested list can resync to the enclosing\n * delimiter with no grammar annotation. Returns `null` when the first set is `any`\n * or `empty` (no usable inference).\n */\nexport function firstSetSentinel(fs: FirstSet): Combinator<null> | null {\n  if (fs.kind !== 'ranges' || fs.ranges.length === 0) return null\n  const ranges = fs.ranges\n  return {\n    _tag: 'firstSetSentinel',\n    _meta: { firstSet: fs, canMatchNewline: false, isTrivia: false },\n    _def: { tag: 'unknown' },\n    parse(input: string, pos: number): ParseResult<null> {\n      const code = pos < input.length ? input.codePointAt(pos) : undefined\n      if (code !== undefined) {\n        for (const r of ranges) {\n          if (code >= r.lo && code <= r.hi) return { ok: true, value: null, span: { start: pos, end: pos } }\n        }\n      }\n      return { ok: false, expected: [], span: { start: pos, end: pos } }\n    },\n  }\n}\n\n/**\n * Cold-path recovery scan shared by tolerant `many()` / `sepBy()`. Scans forward\n * from `from` until `sync` matches (or EOF) \u2014 probing the sentinel as pure\n * lookahead \u2014 emits a {@link ParseError} spanning the skipped range, and pushes it\n * to `ctx._errors`. The sync token is NOT consumed; the caller's loop resumes from\n * `end`. Only ever reached after an element has failed, so entirely off the hot path.\n *\n * The caller owns the loop guard: `sepBy` progress is driven by its separator (a\n * zero-width error for a missing element is fine); `many` checks `matchesAt(sync)`\n * itself and breaks when sitting on the terminator, so a zero-width failure can\n * never spin.\n */\nexport function recoverScan(\n  input: string,\n  from: number,\n  ctx: ParseContext,\n  sync: Combinator<unknown>,\n  expected: string[],\n): { error: ParseError; end: number } {\n  let scanPos = from\n  while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++\n  const error: ParseError = { _tag: 'parseError', span: { start: from, end: scanPos }, expected }\n  ctx._errors?.push(error)\n  return { error, end: scanPos }\n}\n\n/**\n * Does `sentinel` match at `pos` (pure lookahead)? Used by the tolerant list loops\n * to detect \"we are sitting on the sync/terminator token\" without consuming it or\n * capturing anything.\n */\nexport function matchesAt(\n  sentinel: Combinator<unknown>,\n  input: string,\n  pos: number,\n  ctx: ParseContext,\n): boolean {\n  return probeAt(sentinel, input, pos, ctx)\n}\n\n/**\n * Embed a recovered error as a `parseError` CST child at the recovery point, so the\n * error lives IN the tree (rides reused subtrees across incremental edits; a tree\n * walk finds every diagnostic) \u2014 not only in the flat `ctx._errors` side-channel.\n * No-op when CST capture is off (value/AST mode). Both the interpreter list loops\n * and the compiled recovery branches call this (the latter via `_ctx._rec.capture`),\n * so the embedded node is identical on both paths.\n */\nexport function captureError(ctx: ParseContext, error: ParseError): void {\n  if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error)\n}\n\n/**\n * The recovery-helper bundle handed to a tolerant parse via `ctx._rec`. A COMPILED\n * grammar can't import these, so the driver (`run`, `parseDoc`) injects them; the\n * interpreter list loops read the same bundle, guaranteeing byte-identical recovery\n * across paths. Shared here so every driver installs the exact same instance.\n */\nexport const REC: RecoveryHelpers = { scan: recoverScan, at: matchesAt, or: orSentinel, sentinel: firstSetSentinel, capture: captureError }\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, ParseError } from '../types.ts'\nimport { captureError } from '../recovery/scan.ts'\n\nexport type { ParseError }\n\n/**\n * Statically derive the \"expected\" token set from a combinator's structure,\n * so a failure can name what it wanted without running anything:\n *\n *   literal('}')        -> ['\"}\"']\n *   keywords(['a','b']) -> ['\"a\"', '\"b\"']\n *   choice(x, y)        -> expected(x) ++ expected(y)   (all alternatives)\n *   sequence(a, b, \u2026)   -> expected(a)                  (only the first term can fail first)\n *   label('s', x)       -> ['s']                        (an explicit name wins)\n *\n * This is what lets expect() report a meaningful, IDENTICAL expectation in both\n * the interpreter and the compiled output (the compiled path does not rebuild the\n * runtime `expected` array, so it reads this precomputed set instead).\n */\nexport function deriveExpected(c: Combinator<unknown>): string[] {\n  const def = c._def\n  switch (def.tag) {\n    case 'literal':   return [JSON.stringify(def.value)]\n    case 'regex':     return [`/${def.source}/`]\n    case 'keywords':  return def.words.map(w => JSON.stringify(w))\n    case 'label':     return [def.label]\n    case 'choice':    return def.parsers.flatMap(deriveExpected)\n    case 'sequence':  return def.parsers.length > 0 ? deriveExpected(def.parsers[0]!) : []\n    case 'node':\n    case 'grammar':\n    case 'trivia':\n    case 'token':\n    case 'optional':\n    case 'many':\n    case 'oneOrMore':\n    case 'transform':\n    case 'not':       return deriveExpected(def.parser)\n    case 'lazy': {\n      // An EXTERNAL ref (a rule from a composed base grammar) has no local\n      // definition yet \u2014 its `thunk()` throws until fusion supplies it. Fall back\n      // to the rule name as the expected label instead of descending.\n      const name = (c as { _ruleName?: string })._ruleName\n      try { return deriveExpected(def.thunk()) }\n      catch { return name ? [name] : [] }\n    }\n    default:          return []\n  }\n}\n\n/**\n * Required-token combinator. Tries `combinator`; on success returns it verbatim.\n * On failure it does NOT fail \u2014 it records a {@link ParseError} (the statically\n * derived expected set, or `label` when given) into `ctx._errors` and RECOVERS IN\n * PLACE, returning a zero-width success so the enclosing sequence continues as if\n * the token were present.\n *\n * Use it to mark required delimiters/terminators (`}` `)` `;`, a selector before a\n * block) so a missing one is reported with position + expectation rather than\n * aborting the whole parse or being silently swallowed by a catch-all.\n *\n *   sequence(literal('{'), declList, expect(literal('}')))\n *\n * Errors are only collected when the parse runs with `{ recover: true }`; without\n * it, expect() still recovers in place but records nothing (zero overhead beyond\n * the inner attempt).\n */\nexport function expect<T>(combinator: Combinator<T>, label?: string): Combinator<T | ParseError> {\n  const expected = label !== undefined ? [label] : deriveExpected(combinator)\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'expect',\n    _meta: meta,\n    _def: { tag: 'expect', parser: combinator as Combinator<unknown>, label, expected },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T | ParseError> {\n      const result = combinator.parse(input, pos, ctx)\n      if (result.ok) return result as ParseResult<T | ParseError>\n      const error: ParseError = { _tag: 'parseError', span: { start: pos, end: pos }, expected }\n      ctx._errors?.push(error)\n      // Embed the missing-token error as a `parseError` CST child (no-op when CST\n      // capture is off), so it rides the tree exactly like list-recovery errors \u2014\n      // a tree walk finds every diagnostic and the error survives incremental\n      // reuse, rather than living only in the flat ctx._errors side-channel. Gated\n      // on tolerant like the list-recovery embed sites, so a strict CST build is\n      // byte-identical to before (and stays in parity with the compiled path,\n      // which can only embed when the recovery bundle `_rec` is installed).\n      if (ctx._tolerant) captureError(ctx, error)\n      return { ok: true, value: error, span: { start: pos, end: pos } }\n    },\n  }\n}\n\n/** True when `value` is a recovery {@link ParseError} node. */\nexport function isParseError(value: unknown): value is ParseError {\n  return typeof value === 'object' && value !== null && (value as ParseError)._tag === 'parseError'\n}\n", "import type {\n  Combinator, ParseContext, ParseResult, ParserMeta, FirstSet,\n  AutoNotCheck, CharRange, ChoiceStrategy, GatedArm,\n} from '../types.ts'\nimport { union, intersects, matchesEmpty } from './first-set.ts'\nimport { deriveExpected } from './expect.ts'\nimport { saveCstMark, rollbackCstCapture } from '../cst/capture-buffer.ts'\n\ntype ArmParser<T> = T extends GatedArm<infer U> ? Combinator<U> : T extends Combinator<infer U> ? Combinator<U> : never\ntype UnionArms<T extends (Combinator<unknown> | GatedArm<unknown>)[]> = {\n  [K in keyof T]: ArmParser<T[K]>\n}[number] extends Combinator<infer U> ? U : never\n\nexport function choice<T extends [Combinator<unknown> | GatedArm<unknown>, ...(Combinator<unknown> | GatedArm<unknown>)[]]>(\n  ...args: T\n): Combinator<UnionArms<T>> {\n  // Unwrap gated arms into (parser, gate) pairs\n  const parsers = args.map(a => ('gate' in a ? a.combinator : a)) as Combinator<unknown>[]\n  const gates   = args.map(a => ('gate' in a ? a.gate   : null)) as (((state: unknown) => boolean) | null)[]\n\n  const hasGates = gates.some(g => g !== null)\n\n  // O(1) first-char dispatch is sound when arms are pairwise-disjoint in their\n  // first char AND no arm can match empty. Non-nullability is what makes a GATED\n  // arm keep its dispatch slot: a gated arm is normally *skipped* so a later arm\n  // can retry the same position \u2014 but if every arm is non-nullable and first-sets\n  // are disjoint, no later arm can match this first char, so \"skip the gate then\n  // retry\" is exactly \"dispatch to this arm, check its gate, and fail the choice\n  // if the gate is false\". Every OTHER first char dispatches as before and never\n  // touches the gate. A nullable arm matches at ANY position (zero-width), so\n  // first-char dispatch can't represent it \u2192 such choices stay on firstMatch.\n  // (Requiring non-nullability universally also tightens the ungated path, which\n  // was already unsound for a nullable-but-first-set-disjoint arm; in practice no\n  // ungated disjoint choice has a nullable arm, so codegen output is unchanged.)\n  const disjoint = areDisjoint(parsers.map(p => p._meta.firstSet))\n    && parsers.every(p => !matchesEmpty(p))\n\n  let combined: FirstSet = { kind: 'empty' }\n  for (const p of parsers) combined = union(combined, p._meta.firstSet)\n\n  const meta: ParserMeta = {\n    firstSet: combined,\n    canMatchNewline: parsers.some(p => p._meta.canMatchNewline),\n    isTrivia: false,\n    disjoint,\n  }\n\n  // A disjoint choice dispatches by first char (gated arms check their gate inside\n  // the dispatched branch); a NON-disjoint gated choice falls to firstMatch \u2014 the\n  // greedy/longest-first strategies are incompatible with per-arm predicates.\n  const strategy = (disjoint || hasGates) ? null : detectStrategy(parsers)\n  const autoNot = (!disjoint && !hasGates && strategy?.tag === 'firstMatch')\n    ? computeAutoNot(parsers)\n    : parsers.map(() => null)\n\n  // Runtime state for each strategy (built once, reused on every parse call):\n  let greedyLitMap: Map<string, number> | null = null\n  let sortedParsers: Combinator<unknown>[] | null = null\n  const asciiDispatch = disjoint ? buildAsciiDispatch(parsers) : null\n\n  if (strategy?.tag === 'greedyClassify') {\n    greedyLitMap = new Map()\n    for (let i = 0; i < parsers.length; i++) {\n      if (i === strategy.superIndex) continue\n      const litVal = getCoreLiteralValue(parsers[i]!)\n      if (litVal !== null) greedyLitMap.set(litVal, i)\n    }\n  } else if (strategy?.tag === 'literalsLongestFirst') {\n    sortedParsers = strategy.sortedIndices.map(i => parsers[i]!)\n  }\n\n  return {\n    _tag: 'choice',\n    _meta: meta,\n    _def: {\n      tag: 'choice',\n      parsers,\n      gates,\n      disjoint,\n      strategy: strategy ?? { tag: 'firstMatch' },\n      autoNot,\n    },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<UnionArms<T>> {\n      const expected: string[] = []\n\n      // \u2500\u2500 Disjoint: O(1) first-char dispatch (arms may be gated) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      if (disjoint && pos < input.length) {\n        const code = input.codePointAt(pos)!\n        let idx = code < 128 ? asciiDispatch![code]! : -1\n        if (idx < 0) {\n          for (let i = 0; i < parsers.length; i++) {\n            if (inFirstSet(code, parsers[i]!._meta.firstSet)) { idx = i; break }\n          }\n        }\n        if (idx >= 0) {\n          const gate = gates[idx]\n          if (gate && !gate(ctx.state)) {\n            // Gate blocks this arm. Disjointness + non-nullable arms guarantee no\n            // OTHER arm can match this first char, so skip-and-retry is exactly\n            // fail-the-choice \u2014 we must not fall through to another arm.\n            return { ok: false, expected: deriveExpected(parsers[idx]!), span: { start: pos, end: pos } }\n          }\n          const result = parsers[idx]!.parse(input, pos, ctx)\n          if (result.ok) return result as ParseResult<UnionArms<T>>\n          expected.push(...result.expected)\n          return { ok: false, expected, span: { start: pos, end: pos } }\n        }\n        return {\n          ok: false,\n          expected: parsers.flatMap(p => {\n            const r = p.parse(input, pos, ctx)\n            return r.ok ? [] : r.expected\n          }),\n          span: { start: pos, end: pos },\n        }\n      }\n\n      // \u2500\u2500 greedyClassify: run one regex, classify by string equality \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      //    One parse call total. No backtracking.\n      if (strategy?.tag === 'greedyClassify') {\n        const superResult = parsers[strategy.superIndex]!.parse(input, pos, ctx)\n        if (!superResult.ok) return superResult as ParseResult<UnionArms<T>>\n\n        const end = superResult.span.end\n        const litIdx = greedyLitMap!.get(input.slice(pos, end))\n        if (litIdx !== undefined) {\n          const litVal = getCoreLiteralValue(parsers[litIdx]!)!\n          const value = applyTransforms(parsers[litIdx]!, litVal, { start: pos, end })\n          return { ok: true, value: value as UnionArms<T>, span: { start: pos, end } }\n        }\n        return superResult as ParseResult<UnionArms<T>>\n      }\n\n      // \u2500\u2500 literalsLongestFirst: sorted descending by length, no backtracking \u2500\n      if (strategy?.tag === 'literalsLongestFirst') {\n        for (const p of sortedParsers!) {\n          const r = p.parse(input, pos, ctx)\n          if (r.ok) return r as ParseResult<UnionArms<T>>\n          expected.push(...r.expected)\n        }\n        return { ok: false, expected, span: { start: pos, end: pos } }\n      }\n\n      // \u2500\u2500 firstMatch (+ gated arms): try each arm in order, skipping gated-off arms \u2500\u2500\n      for (let i = 0; i < parsers.length; i++) {\n        if (gates[i] && !gates[i]!(ctx.state)) continue   // gate blocks this arm\n        // Save leaf-array lengths so a failed/rejected arm can be rolled back.\n        const mark = saveCstMark(ctx)\n        const logLen = ctx._triviaLog?.length\n        const result = parsers[i]!.parse(input, pos, ctx)\n        if (!result.ok) {\n          rollbackCstCapture(ctx, mark)\n          if (logLen !== undefined && ctx._triviaLog) ctx._triviaLog.length = logLen\n          expected.push(...result.expected)\n          continue\n        }\n        const checks = autoNot[i]\n        if (checks && autoNotFires(input, result.span.end, checks)) {\n          rollbackCstCapture(ctx, mark)\n          if (logLen !== undefined && ctx._triviaLog) ctx._triviaLog.length = logLen\n          continue\n        }\n        return result as ParseResult<UnionArms<T>>\n      }\n      return { ok: false, expected, span: { start: pos, end: pos } }\n    },\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Strategy detection\n// ---------------------------------------------------------------------------\n\nfunction detectStrategy(parsers: Combinator<unknown>[]): ChoiceStrategy {\n  // greedyClassify: exactly one regex arm whose regex matches every literal arm's\n  // value exactly (and can potentially match more). All other arms must be literals.\n  const regexIndices: number[] = []\n  const literalIndices: number[] = []\n  for (let i = 0; i < parsers.length; i++) {\n    if (getCoreRegexDef(parsers[i]!) !== null) regexIndices.push(i)\n    else if (getCoreLiteralValue(parsers[i]!) !== null) literalIndices.push(i)\n  }\n\n  if (\n    regexIndices.length === 1 &&\n    literalIndices.length === parsers.length - 1 &&\n    literalIndices.length > 0\n  ) {\n    const superIndex = regexIndices[0]!\n    const regexDef = getCoreRegexDef(parsers[superIndex]!)!\n    const flags = 'y' + regexDef.flags.replace(/[gy]/g, '')\n    const re = new RegExp(regexDef.source, flags)\n    const allSubsumed = literalIndices.every(i => {\n      const litVal = getCoreLiteralValue(parsers[i]!)!\n      re.lastIndex = 0\n      const m = re.exec(litVal)\n      return m !== null && m[0] === litVal\n    })\n    if (allSubsumed) return { tag: 'greedyClassify', superIndex }\n  }\n\n  // literalsLongestFirst: every arm is a literal \u2014 try longest first, no backtracking\n  if (parsers.length === literalIndices.length) {\n    const sortedIndices = [...literalIndices].sort((a, b) =>\n      getCoreLiteralValue(parsers[b]!)!.length - getCoreLiteralValue(parsers[a]!)!.length\n    )\n    return { tag: 'literalsLongestFirst', sortedIndices }\n  }\n\n  return { tag: 'firstMatch' }\n}\n\n// ---------------------------------------------------------------------------\n// Auto-not analysis (firstMatch fallback only)\n// ---------------------------------------------------------------------------\n\nfunction computeAutoNot(parsers: Combinator<unknown>[]): (AutoNotCheck[] | null)[] {\n  return parsers.map((p, i) => {\n    const litVal = getCoreLiteralValue(p)\n    if (litVal === null) return null\n\n    const checks: AutoNotCheck[] = []\n    for (let j = i + 1; j < parsers.length; j++) {\n      const other = parsers[j]!\n      const otherLit = getCoreLiteralValue(other)\n      if (otherLit !== null && otherLit.startsWith(litVal) && otherLit.length > litVal.length) {\n        checks.push({ kind: 'startsWith', value: otherLit.slice(litVal.length) })\n        continue\n      }\n      const regexDef = getCoreRegexDef(other)\n      if (regexDef !== null) {\n        const contSet = continuationFirstSet(litVal, regexDef.source, regexDef.flags)\n        if (contSet !== null) checks.push({ kind: 'firstSet', set: contSet })\n      }\n    }\n    return checks.length > 0 ? checks : null\n  })\n}\n\nfunction autoNotFires(input: string, end: number, checks: AutoNotCheck[]): boolean {\n  for (const check of checks) {\n    if (check.kind === 'firstSet') {\n      const code = end < input.length ? (input.codePointAt(end) ?? -1) : -1\n      if (inFirstSet(code, check.set)) return true\n    } else {\n      if (input.startsWith(check.value, end)) return true\n    }\n  }\n  return false\n}\n\n// ---------------------------------------------------------------------------\n// Helpers: unwrap transform/sequence wrappers\n// ---------------------------------------------------------------------------\n\n/** Walk transform wrappers to find an inner literal's string value. */\nexport function getCoreLiteralValue(p: Combinator<unknown>): string | null {\n  const def = p._def\n  if (def.tag === 'literal' && !def.caseInsensitive) return def.value\n  if (def.tag === 'transform') return getCoreLiteralValue(def.parser)\n  return null\n}\n\n/** Walk transform wrappers to find an inner regex's source/flags. */\nexport function getCoreRegexDef(p: Combinator<unknown>): { source: string; flags: string } | null {\n  const def = p._def\n  if (def.tag === 'regex') return { source: def.source, flags: def.flags }\n  if (def.tag === 'transform') return getCoreRegexDef(def.parser)\n  if (def.tag === 'label') return getCoreRegexDef(def.parser)\n  return null\n}\n\n/**\n * Apply a parser's transform chain to an already-known value, without re-parsing.\n * Used by greedyClassify to avoid a second parse call for the winning literal arm.\n */\nfunction applyTransforms(p: Combinator<unknown>, value: unknown, span: { start: number; end: number }): unknown {\n  const def = p._def\n  if (def.tag === 'transform') {\n    const inner = applyTransforms(def.parser, value, span)\n    return def.fn(inner, span)\n  }\n  return value\n}\n\n// ---------------------------------------------------------------------------\n// Continuation first-set (for firstMatch auto-not analysis)\n// ---------------------------------------------------------------------------\n\nfunction continuationFirstSet(lit: string, source: string, flags: string): FirstSet | null {\n  const re = new RegExp(source, 'y' + flags.replace(/[gy]/g, ''))\n  re.lastIndex = 0\n  const base = re.exec(lit)\n  if (!base || base[0] !== lit) return null\n\n  const contCodes: number[] = []\n  for (let code = 1; code < 128; code++) {\n    re.lastIndex = 0\n    const m = re.exec(lit + String.fromCharCode(code))\n    if (m && m[0].length > lit.length) contCodes.push(code)\n  }\n  if (contCodes.length === 0) return null\n  return codesToFirstSet(contCodes)\n}\n\nfunction codesToFirstSet(codes: number[]): FirstSet {\n  codes.sort((a, b) => a - b)\n  const ranges: CharRange[] = []\n  let lo = codes[0]!, hi = codes[0]!\n  for (let i = 1; i < codes.length; i++) {\n    if (codes[i] === hi + 1) { hi = codes[i]! }\n    else { ranges.push({ lo, hi }); lo = hi = codes[i]! }\n  }\n  ranges.push({ lo, hi })\n  return { kind: 'ranges', ranges }\n}\n\nfunction inFirstSet(code: number, fs: FirstSet): boolean {\n  if (fs.kind === 'any') return true\n  if (fs.kind === 'empty') return false\n  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true\n  return false\n}\n\nfunction areDisjoint(sets: FirstSet[]): boolean {\n  if (sets.some(s => s.kind === 'any')) return false\n  for (let i = 0; i < sets.length; i++)\n    for (let j = i + 1; j < sets.length; j++)\n      if (intersects(sets[i]!, sets[j]!)) return false\n  return true\n}\n\n// ASCII first-char \u2192 arm INDEX (not the parser) so a gated arm's gate can be\n// looked up (gates[idx]) at dispatch time. -1 means \"no arm keys off this char\".\nfunction buildAsciiDispatch(parsers: Combinator<unknown>[]): number[] {\n  const table = Array<number>(128).fill(-1)\n  for (let i = 0; i < parsers.length; i++) {\n    const fs = parsers[i]!._meta.firstSet\n    if (fs.kind !== 'ranges') continue\n    for (const { lo, hi } of fs.ranges) {\n      for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) {\n        table[code] = i\n      }\n    }\n  }\n  return table\n}\n", "import type { Combinator, ParseContext } from '../types.ts'\nimport { getCoreRegexDef } from '../combinators/choice.ts'\nimport { pushCstTriviaEntry, pushTriviaLogEntry } from './capture-buffer.ts'\n\nexport type TriviaChunk = { start: number; end: number; kindIndex: number }\n\nexport type LabeledTriviaSpec = {\n  readonly labels: readonly string[]\n  readonly arms: ReadonlyArray<{ label: string; kindIndex: number; parser: Combinator<unknown> }>\n  readonly minRepeats: number\n}\n\nfunction unwrapTrivia(p: Combinator<unknown>): Combinator<unknown> {\n  let cur = p\n  while (cur._def.tag === 'trivia') cur = cur._def.parser\n  return cur\n}\n\n/** Strip `label()` wrapper; returns inner parser for matching. */\nexport function peelLabel(p: Combinator<unknown>): { label: string; parser: Combinator<unknown> } | null {\n  if (p._def.tag === 'label') return { label: p._def.label, parser: p._def.parser }\n  return null\n}\n\n/**\n * When every trivia arm is `label(name, parser)` inside `oneOrMore(choice(\u2026))`\n * (or a single labeled arm), return the label table and matchers.\n */\nexport function analyzeLabeledTrivia(trivia: Combinator<unknown>): LabeledTriviaSpec | null {\n  let core = unwrapTrivia(trivia)\n  let minRepeats = 1\n\n  if (core._def.tag === 'oneOrMore') {\n    core = core._def.parser\n    minRepeats = 1\n  } else if (core._def.tag === 'many') {\n    core = core._def.parser\n    minRepeats = 0\n  }\n\n  const arms: LabeledTriviaSpec['arms'][number][] = []\n\n  if (core._def.tag === 'choice') {\n    for (let i = 0; i < core._def.parsers.length; i++) {\n      const peeled = peelLabel(core._def.parsers[i]!)\n      if (!peeled) return null\n      arms.push({ label: peeled.label, kindIndex: i, parser: peeled.parser })\n    }\n  } else {\n    const peeled = peelLabel(core)\n    if (!peeled) return null\n    arms.push({ label: peeled.label, kindIndex: 0, parser: peeled.parser })\n  }\n\n  return { labels: arms.map(a => a.label), arms, minRepeats }\n}\n\n/** Label table on a `trivia()` combinator, if all arms are labeled. */\nexport function triviaKindLabels(trivia: Combinator<unknown> | undefined): readonly string[] | undefined {\n  if (!trivia) return undefined\n  const fromMeta = trivia._meta.triviaKindLabels\n  if (fromMeta) return fromMeta\n  return analyzeLabeledTrivia(trivia)?.labels\n}\n\nfunction matchArmAt(\n  input: string,\n  pos: number,\n  arm: Combinator<unknown>,\n): { end: number } | null {\n  const r = arm.parse(input, pos, { trackLines: false })\n  if (!r.ok || r.span.end <= pos) return null\n  return { end: r.span.end }\n}\n\n/**\n * Scan maximal labeled trivia chunks (PEG `oneOrMore(choice(\u2026))` semantics).\n * Each successful arm match becomes one entry with that arm's kind index.\n */\nexport function scanLabeledTriviaChunks(\n  input: string,\n  cur: number,\n  spec: LabeledTriviaSpec,\n): { end: number; chunks: TriviaChunk[] } {\n  const chunks: TriviaChunk[] = []\n  let pos = cur\n\n  while (pos < input.length) {\n    let matched: { end: number; kindIndex: number } | null = null\n    for (const arm of spec.arms) {\n      const m = matchArmAt(input, pos, arm.parser)\n      if (m) {\n        matched = { end: m.end, kindIndex: arm.kindIndex }\n        break\n      }\n    }\n    if (!matched) break\n    chunks.push({ start: pos, end: matched.end, kindIndex: matched.kindIndex })\n    pos = matched.end\n  }\n\n  if (chunks.length < spec.minRepeats) {\n    return { end: cur, chunks: [] }\n  }\n  return { end: pos, chunks }\n}\n\n/** Hand-rolled ws / block-comment scan with per-chunk kind indices (interpreter). */\nexport function scanFastWsCommentsChunks(\n  input: string,\n  cur: number,\n  wsKind: number,\n  commentKind: number,\n): { end: number; chunks: TriviaChunk[] } {\n  const chunks: TriviaChunk[] = []\n  let pos = cur\n\n  while (pos < input.length) {\n    const c = input.charCodeAt(pos)\n    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) {\n      const start = pos\n      pos++\n      while (pos < input.length) {\n        const c2 = input.charCodeAt(pos)\n        if (c2 === 32 || c2 === 9 || c2 === 10 || c2 === 13 || c2 === 12) pos++\n        else break\n      }\n      chunks.push({ start, end: pos, kindIndex: wsKind })\n      continue\n    }\n    if (c === 47 && input.charCodeAt(pos + 1) === 42) {\n      let j = pos + 2\n      while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++\n      // Require the closing `*/`; an unterminated comment is NOT trivia (the\n      // `/\\*\u2026\\*/` regex arm would fail), so stop here without consuming it \u2014\n      // matching scanLabeledTriviaChunks and the compiled delimited scan.\n      if (j + 1 < input.length && input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47) {\n        const start = pos\n        pos = j + 2\n        chunks.push({ start, end: pos, kindIndex: commentKind })\n        continue\n      }\n      break\n    }\n    break\n  }\n\n  return { end: pos, chunks }\n}\n\n/** Fast scan when trivia is labeled ws + block-comment (CSS `rw`). */\nexport function tryFastLabeledScan(\n  input: string,\n  cur: number,\n  trivia: Combinator<unknown>,\n): { end: number; chunks: TriviaChunk[] } | null {\n  const spec = analyzeLabeledTrivia(trivia)\n  if (!spec || spec.arms.length !== 2) return null\n\n  const wsArm = spec.arms.find(a => {\n    const src = getCoreRegexDef(a.parser)?.source\n    return src != null && !src.includes('\\\\*')\n  })\n  const commentArm = spec.arms.find(a => {\n    const src = getCoreRegexDef(a.parser)?.source\n    return src != null && src.includes('\\\\*')\n  })\n  if (!wsArm || !commentArm) return null\n\n  const { chunks } = scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex)\n  if (chunks.length < spec.minRepeats) return { end: cur, chunks: [] }\n  return scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex)\n}\n\nexport function recordTriviaChunks(ctx: ParseContext, chunks: readonly TriviaChunk[]): void {\n  const kinds = ctx.triviaKindLabels\n  const mask = ctx._triviaCaptureMask\n  for (const ch of chunks) {\n    // Global trivia log: always complete (never kind-filtered).\n    pushTriviaLogEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : undefined)\n    // Per-node CST log: honour the kind mask when both a mask and labels are\n    // present, so a host can capture (e.g.) comments only without logging every\n    // whitespace run. No mask / no labels \u2192 capture everything, as before.\n    if (ctx.captureTrivia && (ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined)) {\n      if (mask === undefined || kinds === undefined || (mask & (1 << ch.kindIndex)) !== 0) {\n        pushCstTriviaEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : undefined)\n      }\n    }\n  }\n}\n\n/**\n * Resolve a per-node trivia capture mask (`ctx._triviaCaptureMask`) from a trivia\n * label table and the kind names a host wants to keep. Returns `undefined` when\n * `labels` is absent (nothing to key on \u2192 capture everything).\n *\n * Names in `keep` that aren't in `labels` are **ignored by design**: `keep` is\n * often a dialect-independent list (e.g. `['blockComment', 'lineComment']`) applied\n * to a grammar whose trivia only defines some of them (CSS has no `lineComment`) \u2014\n * so an unknown name is a normal cross-dialect no-op, not necessarily a typo, and\n * is not worth a warning that would cry wolf on legitimate superset lists. An empty\n * `keep` (or one where nothing matches) yields `0`, which means \"capture NO trivia\n * into per-node logs\" \u2014 an intentional, valid state (the global `_triviaLog` is\n * unaffected either way). If you expect comments and get an empty per-node log,\n * check the name against the grammar's `triviaKindLabels`.\n */\nexport function triviaKindMask(\n  labels: readonly string[] | undefined,\n  keep: readonly string[],\n): number | undefined {\n  if (!labels) return undefined\n  let mask = 0\n  for (const name of keep) {\n    const idx = labels.indexOf(name)\n    if (idx >= 0) mask |= 1 << idx\n  }\n  return mask\n}\n", "import type { Combinator, ParseContext } from '../types.ts'\nimport { parseClassRanges } from '../regex/classes.ts'\nimport {\n  analyzeLabeledTrivia,\n  recordTriviaChunks,\n  scanLabeledTriviaChunks,\n  tryFastLabeledScan,\n} from '../cst/trivia-kinds.ts'\nimport {\n  pushCstTriviaEntry,\n  pushTriviaLogEntry,\n  rollbackCstCapture,\n  saveCstMark,\n} from '../cst/capture-buffer.ts'\n\n/**\n * Result of scanning trivia: the position after it, plus a `commit()` that\n * records the matched trivia tokens into the active rawChildren collector.\n * Recording is deferred so callers that may reject the following item (e.g.\n * many()/oneOrMore() retries) can advance speculatively without recording\n * trivia that doesn't actually sit between two accepted items.\n */\nexport type TriviaScan = { end: number; commit: () => void }\n\n/** Saved lengths for rolling back speculative trivia commits. */\nexport type TriviaRollbackMark = { raw: number; tlog: number; leaves: number; fields: number; errors: number; log: number }\n\nconst NOOP_COMMIT = () => {}\ntype FastTriviaScanner = (input: string, cur: number) => number\nconst fastTriviaCache = new WeakMap<Combinator<unknown>, FastTriviaScanner | null>()\n\n/** True when trivia recording must be deferred until the following term commits. */\nexport function needsDeferredTriviaCommit(ctx: ParseContext): boolean {\n  return ctx._triviaLog !== undefined || ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined\n}\n\nexport function saveTriviaMark(ctx: ParseContext): TriviaRollbackMark {\n  const m = saveCstMark(ctx)\n  return { raw: m.raw, tlog: m.tlog, leaves: m.leaves, fields: m.fields, errors: m.errors, log: ctx._triviaLog ? ctx._triviaLog.length : 0 }\n}\n\nexport function rollbackTrivia(ctx: ParseContext, mark: TriviaRollbackMark): void {\n  rollbackCstCapture(ctx, { raw: mark.raw, tlog: mark.tlog, leaves: mark.leaves, fields: mark.fields, errors: mark.errors })\n  if (ctx._triviaLog) ctx._triviaLog.length = mark.log\n}\n\nfunction scanWithLabels(input: string, cur: number, ctx: ParseContext): TriviaScan {\n  const triviaP = ctx.trivia!\n  const spec = analyzeLabeledTrivia(triviaP)\n  if (!spec) return { end: cur, commit: NOOP_COMMIT }\n\n  const fast = tryFastLabeledScan(input, cur, triviaP)\n  const { end, chunks } = fast ?? scanLabeledTriviaChunks(input, cur, spec)\n  if (end === cur) return { end: cur, commit: NOOP_COMMIT }\n\n  return {\n    end,\n    commit: () => recordTriviaChunks(ctx, chunks),\n  }\n}\n\n/**\n * Skip trivia at `cur` and return the new position. No recording, no wrapper\n * object \u2014 use between sequence/repeat terms when CST trivia capture is off.\n */\nexport function advanceTrivia(input: string, cur: number, ctx: ParseContext): number {\n  const triviaP = ctx.trivia\n  if (!triviaP) return cur\n  const fast = fastTriviaScanner(triviaP)\n  if (fast) return fast(input, cur)\n  if (ctx.triviaKindLabels) {\n    const scan = scanWithLabels(input, cur, ctx)\n    return scan.end\n  }\n  const tr = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state })\n  return tr.ok && tr.span.end > cur ? tr.span.end : cur\n}\n\n/**\n * Scan trivia at `cur` using `ctx.trivia`, WITHOUT recording it. Returns the\n * position after the trivia (or `cur` if none) and a `commit()` to record it.\n */\nexport function scanTrivia(input: string, cur: number, ctx: ParseContext): TriviaScan {\n  const triviaP = ctx.trivia\n  if (!triviaP) return { end: cur, commit: NOOP_COMMIT }\n\n  const log = ctx._triviaLog\n  const captureTl = ctx.captureTrivia && (ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined)\n\n  const fast = !ctx.triviaKindLabels ? fastTriviaScanner(triviaP) : null\n  if (fast && log === undefined && !captureTl) {\n    return { end: fast(input, cur), commit: NOOP_COMMIT }\n  }\n\n  if (ctx.triviaKindLabels && (log !== undefined || captureTl)) {\n    return scanWithLabels(input, cur, ctx)\n  }\n\n  if (log !== undefined || captureTl) {\n    const tr = triviaP.parse(input, cur, {\n      trackLines: log !== undefined ? false : ctx.trackLines,\n      state: ctx.state,\n    })\n    if (!tr.ok || tr.span.end === cur) return { end: cur, commit: NOOP_COMMIT }\n    const end = tr.span.end\n    return {\n      end,\n      commit: () => {\n        pushTriviaLogEntry(ctx, cur, end)\n        if (captureTl) pushCstTriviaEntry(ctx, cur, end)\n      },\n    }\n  }\n\n  const tr = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state })\n  return { end: tr.ok ? tr.span.end : cur, commit: NOOP_COMMIT }\n}\n\n/**\n * Consume trivia at `cur`, recording it immediately. For callers that always\n * accept the trivia between two committed terms (e.g. sequence/sepBy).\n */\nexport function consumeTrivia(input: string, cur: number, ctx: ParseContext): number {\n  if (!needsDeferredTriviaCommit(ctx)) return advanceTrivia(input, cur, ctx)\n  const scan = scanTrivia(input, cur, ctx)\n  scan.commit()\n  return scan.end\n}\n\nfunction fastTriviaScanner(trivia: Combinator<unknown>): FastTriviaScanner | null {\n  const cached = fastTriviaCache.get(trivia)\n  if (cached !== undefined) return cached\n  const scanner = buildFastTriviaScanner(trivia)\n  fastTriviaCache.set(trivia, scanner)\n  return scanner\n}\n\nfunction buildFastTriviaScanner(trivia: Combinator<unknown>): FastTriviaScanner | null {\n  const core = trivia._def.tag === 'trivia' ? trivia._def.parser : trivia\n  const direct = regexTriviaScanner(core)\n  if (direct) return direct\n\n  const repeat = core._def.tag === 'oneOrMore' || (core._def.tag === 'many' && core._def.min >= 1)\n    ? core._def.parser\n    : null\n  if (!repeat) return null\n\n  const one = regexTriviaScanner(repeat)\n  if (one) return loopScanner([one])\n\n  if (repeat._def.tag !== 'choice') return null\n  const arms = repeat._def.parsers.map(regexTriviaScanner)\n  if (arms.some(s => s === null)) return null\n  return loopScanner(arms as FastTriviaScanner[])\n}\n\nfunction loopScanner(arms: FastTriviaScanner[]): FastTriviaScanner {\n  return (input, cur) => {\n    let pos = cur\n    scan: while (pos < input.length) {\n      for (const arm of arms) {\n        const end = arm(input, pos)\n        if (end > pos) {\n          pos = end\n          continue scan\n        }\n      }\n      break\n    }\n    return pos\n  }\n}\n\nfunction regexTriviaScanner(parser: Combinator<unknown>): FastTriviaScanner | null {\n  if (parser._def.tag !== 'regex' || parser._def.flags) return null\n  const source = parser._def.source\n  return classRunSource(source)\n    ?? altStarSource(source)\n    ?? (blockCommentSource(source) ? scanBlockComment : null)\n}\n\nfunction inRanges(cp: number, ranges: Array<[number, number]>): boolean {\n  for (let i = 0; i < ranges.length; i++) {\n    const r = ranges[i]!\n    if (cp >= r[0] && cp <= r[1]) return true\n  }\n  return false\n}\n\n/** Greedy scanner for a positive char-class body (`^`-negated bodies are rejected upstream). */\nfunction classScanner(classBody: string): FastTriviaScanner | null {\n  const ranges = parseClassRanges(classBody)\n  if (!ranges) return null\n  return (input, cur) => {\n    let pos = cur\n    while (pos < input.length && inRanges(input.charCodeAt(pos), ranges)) pos++\n    return pos\n  }\n}\n\n/** Scanner for a `C[^\\n\\r]*` line comment \u2014 consumes `C` and the rest of the line. */\nfunction lineCommentScanner(commentCode: number): FastTriviaScanner {\n  return (input, cur) => {\n    if (input.charCodeAt(cur) !== commentCode) return cur\n    let pos = cur + 1\n    while (pos < input.length) {\n      const cc = input.charCodeAt(pos)\n      if (cc === 10 || cc === 13) break\n      pos++\n    }\n    return pos\n  }\n}\n\n/** A bare positive char-class run `[class]*` / `[class]+` (`[ \\t\\n\\r,]*`, \u2026). */\nfunction classRunSource(source: string): FastTriviaScanner | null {\n  const m = /^\\[([^\\]^](?:[^\\]]|\\\\.)*)\\][*+]$/.exec(source)\n  return m ? classScanner(m[1]!) : null\n}\n\n/**\n * One alternation arm of a `(?:\u2026)*` trivia group: a positive char-class run\n * `[class]` (a trailing `+`/`*` is redundant under the enclosing loop) or a line\n * comment `C[^\\n\\r]*` (`C` = one literal marker char, maybe escaped). Anything\n * else is unclassifiable \u2192 no fast path, never a wrong one.\n */\ntype TriviaArm =\n  | { kind: 'class'; ranges: Array<[number, number]> }\n  | { kind: 'comment'; code: number }\n\nfunction classifyTriviaArm(arm: string): TriviaArm | null {\n  const cls = /^\\[([^\\]^](?:[^\\]]|\\\\.)*)\\][*+]?$/.exec(arm)\n  if (cls) {\n    const ranges = parseClassRanges(cls[1]!)\n    return ranges ? { kind: 'class', ranges } : null\n  }\n  const lc = /^(\\\\?.)\\[\\^\\\\n\\\\r\\]\\*$/.exec(arm)\n  if (lc) {\n    const marker = lc[1]!\n    return { kind: 'comment', code: (marker.length === 2 ? marker[1]! : marker[0]!).charCodeAt(0) }\n  }\n  return null\n}\n\nfunction armScanner(arm: TriviaArm): FastTriviaScanner {\n  if (arm.kind === 'comment') return lineCommentScanner(arm.code)\n  const ranges = arm.ranges\n  return (input, cur) => {\n    let pos = cur\n    while (pos < input.length && inRanges(input.charCodeAt(pos), ranges)) pos++\n    return pos\n  }\n}\n\n/**\n * A single tight loop over a merged char-class range list plus (usually one)\n * line-comment marker \u2014 the fast form of `(?:[class]|C[^\\n\\r]*)*`. Requires the\n * caller to have checked marker/class disjointness (so a bare merged scan\n * matches the regex regardless of arm order).\n */\nfunction fusedTriviaScanner(ranges: Array<[number, number]>, commentCodes: number[]): FastTriviaScanner {\n  const c0 = commentCodes[0]!\n  const single = commentCodes.length === 1\n  return (input, cur) => {\n    let pos = cur\n    const len = input.length\n    for (;;) {\n      const c = input.charCodeAt(pos)\n      if (pos < len && inRanges(c, ranges)) { pos++; continue }\n      if (single ? c === c0 : commentCodes.includes(c)) {\n        pos++\n        while (pos < len) {\n          const cc = input.charCodeAt(pos)\n          if (cc === 10 || cc === 13) break\n          pos++\n        }\n        continue\n      }\n      break\n    }\n    return pos\n  }\n}\n\n/** Split a `(?:\u2026)*` body on top-level `|`, respecting `[\u2026]`; bail on nested groups. */\nfunction splitTopLevelAlts(body: string): string[] | null {\n  const arms: string[] = []\n  let inClass = false\n  let start = 0\n  for (let i = 0; i < body.length; i++) {\n    const c = body[i]\n    if (c === '\\\\') { i++; continue }\n    if (inClass) { if (c === ']') inClass = false; continue }\n    if (c === '[') inClass = true\n    else if (c === '(') return null // nested group \u2014 leave it to RegExp.exec\n    else if (c === '|') { arms.push(body.slice(start, i)); start = i + 1 }\n  }\n  arms.push(body.slice(start))\n  return arms\n}\n\n/**\n * Trivia written as a single regex alternation-star, `(?:arm|arm|\u2026)*` \u2014 e.g.\n * GraphQL's `(?:[ \\t\\n\\r,]|#[^\\n\\r]*)*`. Arms are classified independently and\n * order-independently: char-class arms merge into one range list and comment\n * markers are collected, so `(?:#\u2026|[class])*` scans the same as `(?:[class]|#\u2026)*`.\n * The common (disjoint) case compiles to one fused loop; a marker that also sits\n * inside a class is the one spot where arm order matters, so that falls back to\n * the ordered `loopScanner`.\n */\nfunction altStarSource(source: string): FastTriviaScanner | null {\n  const m = /^\\(\\?:(.*)\\)[*+]$/.exec(source)\n  if (!m) return null\n  const armSrcs = splitTopLevelAlts(m[1]!)\n  if (!armSrcs || armSrcs.length < 2) return null\n  const arms: TriviaArm[] = []\n  for (const src of armSrcs) {\n    const arm = classifyTriviaArm(src)\n    if (!arm) return null\n    arms.push(arm)\n  }\n  const ranges: Array<[number, number]> = []\n  const commentCodes: number[] = []\n  for (const arm of arms) {\n    if (arm.kind === 'class') ranges.push(...arm.ranges)\n    else commentCodes.push(arm.code)\n  }\n  if (commentCodes.some(code => inRanges(code, ranges))) {\n    return loopScanner(arms.map(armScanner)) // order-significant overlap\n  }\n  if (commentCodes.length === 0) return armScanner({ kind: 'class', ranges })\n  return fusedTriviaScanner(ranges, commentCodes)\n}\n\nfunction blockCommentSource(source: string): boolean {\n  return source === '\\\\/\\\\*(?:[^*]|\\\\*(?!\\\\/))*\\\\*\\\\/' || source === '\\\\/\\\\*[^]*?\\\\*\\\\/'\n}\n\nfunction scanBlockComment(input: string, cur: number): number {\n  if (input.charCodeAt(cur) !== 47 || input.charCodeAt(cur + 1) !== 42) return cur\n  const close = input.indexOf('*/', cur + 2)\n  return close === -1 ? cur : close + 2\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta, ParseFail } from '../types.ts'\nimport { sequenceFirstSet, firstSetOf, union } from './first-set.ts'\nimport { advanceTrivia, needsDeferredTriviaCommit, rollbackTrivia, saveTriviaMark, scanTrivia } from './trivia-skip.ts'\nimport { firstSetSentinel } from '../recovery/scan.ts'\n\ntype UnwrapParsers<T extends Combinator<unknown>[]> = {\n  [K in keyof T]: T[K] extends Combinator<infer U> ? U : never\n}\n\nexport function sequence<T extends [Combinator<unknown>, ...Combinator<unknown>[]]>(\n  ...parsers: T\n): Combinator<UnwrapParsers<T>> {\n  const meta: ParserMeta = {\n    // Union through the nullable prefix \u2014 a leading optional()/many() lets a later\n    // term's first char start the sequence. Just `parsers[0]` under-approximates.\n    firstSet: sequenceFirstSet(parsers),\n    canMatchNewline: parsers.some(p => p._meta.canMatchNewline),\n    isTrivia: false,\n  }\n\n  const def: { tag: 'sequence'; parsers: Combinator<unknown>[]; valueUnused?: boolean } =\n    { tag: 'sequence', parsers: parsers as Combinator<unknown>[] }\n\n  // Automatic recovery-sync inference, built lazily on the first tolerant parse and\n  // never touched on the strict path: followSentinels[i] matches (zero-width) when\n  // the input could start any term AFTER i, so a list nested in term i can resync\n  // to this sequence's enclosing delimiter with NO grammar annotation. This is the\n  // whole of \"recovery config\" \u2014 derived from structure, not authored.\n  let followSentinels: (Combinator<null> | null)[] | undefined\n\n  // Tolerant twin of the strict loop: identical term-parsing, but around each term\n  // it publishes the inferred follow sentinel into ctx._sync so a nested list can\n  // resync to this sequence's enclosing delimiter. Cold path (tolerant only).\n  function parseTolerant(input: string, pos: number, ctx: ParseContext): ParseResult<UnwrapParsers<T>> {\n    followSentinels ??= parsers.map((_, i) => {\n      // A nested list can resync to the start of ANY term that follows it here, so\n      // union every following term's first set (not just up to the first\n      // non-nullable one \u2014 a mandatory middle term must not hide a later close).\n      const fs = parsers.slice(i + 1).reduce<ReturnType<typeof firstSetOf>>(\n        (acc, p) => union(acc, firstSetOf(p)),\n        { kind: 'empty' },\n      )\n      return firstSetSentinel(fs)\n    })\n    const values: unknown[] | undefined = def.valueUnused ? undefined : []\n    let cur = pos\n    const inheritedSync = ctx._sync\n    try {\n      for (let i = 0; i < parsers.length; i++) {\n        // Publish this term's follow set (or keep the inherited sync when the local\n        // follow isn't usable, e.g. the last term or an `any` first set).\n        ctx._sync = followSentinels[i] ?? inheritedSync\n        if (ctx.trivia && i > 0) {\n          const mark = saveTriviaMark(ctx)\n          let scanEnd: number\n          if (needsDeferredTriviaCommit(ctx)) {\n            const scan = scanTrivia(input, cur, ctx)\n            scan.commit()\n            scanEnd = scan.end\n          } else {\n            scanEnd = advanceTrivia(input, cur, ctx)\n          }\n          const result = parsers[i]!.parse(input, scanEnd, ctx)\n          if (!result.ok) return result as ParseFail\n          if (result.span.end > scanEnd) cur = result.span.end\n          else rollbackTrivia(ctx, mark)\n          if (values !== undefined) values.push(result.value)\n          continue\n        }\n        const result = parsers[i]!.parse(input, cur, ctx)\n        if (!result.ok) return result as ParseFail\n        if (values !== undefined) values.push(result.value)\n        cur = result.span.end\n      }\n    } finally {\n      ctx._sync = inheritedSync\n    }\n    return {\n      ok: true,\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion\n      value: (values ?? undefined) as UnwrapParsers<T>,\n      span: { start: pos, end: cur },\n    }\n  }\n\n  return {\n    _tag: 'sequence',\n    _meta: meta,\n    _def: def,\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<UnwrapParsers<T>> {\n      // One cold branch: in tolerant mode publish each term's follow-set as ctx._sync\n      // so a nested list resyncs to the enclosing delimiter (dynamic scoping through\n      // refs carries this across rule boundaries automatically). The strict loop\n      // below is byte-identical to a parser with no recovery.\n      if (ctx._tolerant) return parseTolerant(input, pos, ctx)\n\n      // Skip the tuple when it's never observed (markUnusedValues): terms still\n      // parse (and self-capture) \u2014 only the array of their values is elided.\n      const values: unknown[] | undefined = def.valueUnused ? undefined : []\n      let cur = pos\n\n      for (let i = 0; i < parsers.length; i++) {\n        if (ctx.trivia && i > 0) {\n          // Skip trivia between terms, but only *consume* it for span purposes if\n          // this term actually matches content past the trivia. A term that matches\n          // empty (optional/many/lookahead) leaves the trivia for the enclosing rule.\n          let scanEnd: number\n          let mark = saveTriviaMark(ctx)\n\n          if (needsDeferredTriviaCommit(ctx)) {\n            const scan = scanTrivia(input, cur, ctx)\n            scan.commit()\n            scanEnd = scan.end\n          } else {\n            scanEnd = advanceTrivia(input, cur, ctx)\n          }\n\n          const result = parsers[i]!.parse(input, scanEnd, ctx)\n          if (!result.ok) return result as ParseFail\n          if (result.span.end > scanEnd) {\n            cur = result.span.end\n          } else {\n            rollbackTrivia(ctx, mark)\n          }\n          if (values !== undefined) values.push(result.value)\n          continue\n        }\n\n        const result = parsers[i]!.parse(input, cur, ctx)\n        if (!result.ok) return result as ParseFail\n        if (values !== undefined) values.push(result.value)\n        cur = result.span.end\n      }\n\n      return {\n        ok: true,\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion\n        value: (values ?? undefined) as UnwrapParsers<T>,\n        span: { start: pos, end: cur },\n      }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { advanceTrivia, needsDeferredTriviaCommit, rollbackTrivia, saveTriviaMark, scanTrivia } from './trivia-skip.ts'\nimport { matchesEmpty } from './first-set.ts'\nimport { deriveExpected } from './expect.ts'\nimport { matchesAt, orSentinel, recoverScan, captureError } from '../recovery/scan.ts'\n\n/**\n * Parse one repetition item at `cur`, first skipping (and, in capture mode,\n * recording) any leading trivia \u2014 so a repeating combinator consumes the trivia\n * between items uniformly, the way advancing the index always should. Trivia is\n * committed *before* the item so rawChildren order stays [item, trivia, item];\n * if the item then fails or makes no progress the trivia is rolled back and the\n * loop stops (the trivia is trailing and belongs to the enclosing context).\n *\n * Returns the item value + end position, the underlying failure (so oneOrMore\n * can propagate a first-item failure), or 'stop'.\n */\nfunction repItem<T>(\n  combinator: Combinator<T>,\n  input: string,\n  cur: number,\n  ctx: ParseContext,\n): { value: T; end: number } | { fail: ParseResult<T>; failPos: number } | 'stop' {\n  const mark = saveTriviaMark(ctx)\n  let pos = cur\n  if (ctx.trivia) {\n    if (needsDeferredTriviaCommit(ctx)) {\n      const scan = scanTrivia(input, cur, ctx)\n      scan.commit()\n      pos = scan.end\n    } else {\n      pos = advanceTrivia(input, cur, ctx)\n    }\n  }\n  // Nothing but trivia left: don't speculatively parse an item at EOF (it would\n  // fail and could trigger an item's expect()/error side-effects). The trivia\n  // is trailing \u2014 roll it back for the enclosing context and stop.\n  if (pos >= input.length) {\n    rollbackTrivia(ctx, mark)\n    return 'stop'\n  }\n  const result = combinator.parse(input, pos, ctx)\n  if (!result.ok) {\n    rollbackTrivia(ctx, mark)\n    // Surface the POST-trivia position where the element actually failed. The\n    // tolerant recovery guard must check the sync token there \u2014 not at `cur`,\n    // which sits before any leading trivia \u2014 so trailing trivia before the sync\n    // isn't mistaken for junk and swallowed into a spurious ParseError.\n    return { fail: result, failPos: pos }\n  }\n  if (result.span.end === pos) {\n    rollbackTrivia(ctx, mark)\n    return 'stop'\n  }\n  return { value: result.value, end: result.span.end }\n}\n\nexport function many<T>(combinator: Combinator<T>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  const def: { tag: 'many'; parser: Combinator<unknown>; min: 0; valueUnused?: boolean } =\n    { tag: 'many', parser: combinator as Combinator<unknown>, min: 0 }\n  let expected: string[] | undefined\n\n  return {\n    _tag: 'many',\n    _meta: meta,\n    _def: def,\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {\n      // When the aggregate is never observed (markUnusedValues), skip the array:\n      // items still parse and self-capture into the enclosing node's children.\n      const values: T[] | undefined = def.valueUnused ? undefined : []\n      let cur = pos\n      while (cur < input.length) {\n        const item = repItem(combinator, input, cur, ctx)\n        if (item === 'stop') break\n        if ('fail' in item) {\n          // Cold path: only reached on an element failure. Strict mode \u21D2 `break`.\n          // Tolerant \u21D2 resync to the sync sentinel the enclosing sequence inferred\n          // and published as ctx._sync (the grammar carries no recovery config). No\n          // sync available \u21D2 nothing to skip to \u2192 break.\n          const sync = ctx._tolerant ? ctx._sync : undefined\n          if (sync === undefined) break\n          // Sync token at the POST-trivia failure position \u21D2 clean list end (the\n          // trailing trivia belongs to the enclosing context), not junk. Checking\n          // `item.failPos` (past leading trivia), not `cur`, keeps trivia out of\n          // both the break decision and the recovered error span.\n          if (matchesAt(sync, input, item.failPos, ctx)) break\n          expected ??= deriveExpected(combinator)\n          const { error, end } = recoverScan(input, item.failPos, ctx, sync, expected)\n          if (values !== undefined) values.push(error as unknown as T)\n          captureError(ctx, error)\n          cur = end\n          continue\n        }\n        if (values !== undefined) values.push(item.value)\n        cur = item.end\n      }\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion\n      return { ok: true, value: (values ?? undefined) as T[], span: { start: pos, end: cur } }\n    },\n  }\n}\n\nexport function oneOrMore<T>(combinator: Combinator<T>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  const def: { tag: 'oneOrMore'; parser: Combinator<unknown>; min: 1; valueUnused?: boolean } =\n    { tag: 'oneOrMore', parser: combinator as Combinator<unknown>, min: 1 }\n  let expected: string[] | undefined\n\n  return {\n    _tag: 'oneOrMore',\n    _meta: meta,\n    _def: def,\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {\n      // First item is mandatory (parsed at pos directly \u2014 leading trivia is the\n      // enclosing context's responsibility); subsequent items skip leading trivia.\n      const first = combinator.parse(input, pos, ctx)\n      if (!first.ok) return first\n      // Aggregate skipped when never observed (see `many`).\n      const values: T[] | undefined = def.valueUnused ? undefined : [first.value]\n      let cur = first.span.end\n      while (cur < input.length) {\n        const item = repItem(combinator, input, cur, ctx)\n        if (item === 'stop') break\n        if ('fail' in item) {\n          // Cold path (element failure). Strict: break. Tolerant: resync \u2014 see many().\n          const sync = ctx._tolerant ? ctx._sync : undefined\n          if (sync === undefined) break\n          if (matchesAt(sync, input, item.failPos, ctx)) break\n          expected ??= deriveExpected(combinator)\n          const { error, end } = recoverScan(input, item.failPos, ctx, sync, expected)\n          if (values !== undefined) values.push(error as unknown as T)\n          captureError(ctx, error)\n          cur = end\n          continue\n        }\n        if (values !== undefined) values.push(item.value)\n        cur = item.end\n      }\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion\n      return { ok: true, value: (values ?? undefined) as T[], span: { start: pos, end: cur } }\n    },\n  }\n}\n\nexport function optional<T>(combinator: Combinator<T>): Combinator<T | null> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  const firstSetSkippable = !matchesEmpty(combinator)\n\n  return {\n    _tag: 'optional',\n    _meta: meta,\n    _def: { tag: 'optional', parser: combinator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T | null> {\n      if (firstSetSkippable && ctx._probe === undefined && !startsFirstSet(combinator, input, pos)) {\n        return { ok: true, value: null, span: { start: pos, end: pos } }\n      }\n      const mark = saveTriviaMark(ctx)\n      const result = combinator.parse(input, pos, ctx)\n      if (result.ok) return result as ParseResult<T>\n      // Inner failed \u2192 roll back any CST leaves/trivia it captured before giving up.\n      rollbackTrivia(ctx, mark)\n      return { ok: true, value: null, span: { start: pos, end: pos } }\n    },\n  }\n}\n\nfunction startsFirstSet(combinator: Combinator<unknown>, input: string, pos: number): boolean {\n  const fs = combinator._meta.firstSet\n  if (fs.kind === 'any') return true\n  if (fs.kind === 'empty') return false\n  const code = input.codePointAt(pos)\n  if (code === undefined) return false\n  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true\n  return false\n}\n\nexport function sepBy<T, S>(combinator: Combinator<T>, separator: Combinator<S>): Combinator<T[]> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline || separator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  let expected: string[] | undefined\n\n  return {\n    _tag: 'sepBy',\n    _meta: meta,\n    _def: { tag: 'sepBy', parser: combinator as Combinator<unknown>, separator: separator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {\n      const first = combinator.parse(input, pos, ctx)\n      const values: T[] = []\n      let cur: number\n      if (first.ok) {\n        values.push(first.value)\n        cur = first.span.end\n      } else {\n        // Cold path. Strict: an empty/absent first element is a legal empty list.\n        // Tolerant: if the first element is JUNK (a terminator is inferable and we\n        // are not already sitting on it) recover it and enter the loop; otherwise\n        // it is a genuine empty list.\n        const term = ctx._tolerant ? ctx._sync : undefined\n        if (term === undefined || matchesAt(term, input, pos, ctx)) {\n          return { ok: true, value: [], span: { start: pos, end: pos } }\n        }\n        expected ??= deriveExpected(combinator)\n        const rec = recoverScan(input, pos, ctx, orSentinel(separator, term), expected)\n        values.push(rec.error as unknown as T)\n        captureError(ctx, rec.error)\n        cur = rec.end\n      }\n      while (cur < input.length) {\n        // One mark for the whole iteration (separator + following item): if the\n        // item fails, the trailing separator must be rolled back with it, or its\n        // captured leaves leak past the end of the list.\n        const loopMark = saveTriviaMark(ctx)\n        let sepPos = cur\n        if (ctx.trivia) {\n          if (needsDeferredTriviaCommit(ctx)) {\n            const scan = scanTrivia(input, cur, ctx)\n            scan.commit()\n            sepPos = scan.end\n          } else {\n            sepPos = advanceTrivia(input, cur, ctx)\n          }\n        }\n        const sep = separator.parse(input, sepPos, ctx)\n        if (!sep.ok) {\n          rollbackTrivia(ctx, loopMark)\n          break\n        }\n        let nextPos = sep.span.end\n        if (ctx.trivia) {\n          if (needsDeferredTriviaCommit(ctx)) {\n            const scan = scanTrivia(input, sep.span.end, ctx)\n            scan.commit()\n            nextPos = scan.end\n          } else {\n            nextPos = advanceTrivia(input, sep.span.end, ctx)\n          }\n        }\n        const next = combinator.parse(input, nextPos, ctx)\n        if (!next.ok) {\n          // Cold path. Strict: roll back the trailing separator + break. Tolerant:\n          // the separator we just consumed is real, so resync the bad element after\n          // it. If a terminator is inferable and already present at nextPos, the\n          // separator was a trailing one (e.g. `a;}`) \u2192 roll it back and stop.\n          const term = ctx._tolerant ? ctx._sync : undefined\n          if (term !== undefined && !matchesAt(term, input, nextPos, ctx)) {\n            expected ??= deriveExpected(combinator)\n            const rec = recoverScan(input, nextPos, ctx, orSentinel(separator, term), expected)\n            values.push(rec.error as unknown as T)\n            captureError(ctx, rec.error)\n            cur = rec.end\n            continue\n          }\n          rollbackTrivia(ctx, loopMark)\n          break\n        }\n        values.push(next.value)\n        cur = next.span.end\n      }\n      return { ok: true, value: values, span: { start: pos, end: cur } }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { any } from './first-set.ts'\n\n/**\n * Create a forward-declared parser slot for mutually recursive grammars.\n *\n * Because JS evaluates arguments eagerly, you can't reference a variable\n * before it's declared. ref() creates a placeholder you fill in later:\n *\n *   const value = ref<JSONValue>()\n *   const array  = transform(sequence(literal('['), sepBy(value, literal(',')), literal(']')), ...)\n *   const object = transform(sequence(literal('{'), sepBy(pair, literal(',')), literal('}')), ...)\n *   value.define(choice(object, array, string, number, bool, nullVal))\n *\n * Unlike lazy(() => x), you use the ref directly \u2014 no wrapping at each call site.\n */\nexport function ref<T>(): Combinator<T> & { define(p: Combinator<T>): void } {\n  let resolved: Combinator<T> | null = null\n\n  const meta: ParserMeta = {\n    firstSet: any(),\n    canMatchNewline: true,\n    isTrivia: false,\n  }\n\n  const slot = {\n    _tag: 'lazy' as const,\n    _meta: meta,\n    _def: {\n      tag: 'lazy' as const,\n      thunk: () => {\n        if (!resolved) throw new Error('ref<T>() used before .define() was called')\n        return resolved as Combinator<unknown>\n      },\n    },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      if (!resolved) throw new Error('ref<T>() used before .define() was called')\n      return resolved.parse(input, pos, ctx)\n    },\n    define(p: Combinator<T>): void {\n      if (resolved) throw new Error('ref<T>() already defined')\n      resolved = p\n      meta.firstSet = p._meta.firstSet\n      meta.canMatchNewline = p._meta.canMatchNewline\n      meta.isTrivia = p._meta.isTrivia\n      if (p._meta.triviaKindLabels !== undefined) meta.triviaKindLabels = p._meta.triviaKindLabels\n      else delete meta.triviaKindLabels\n      if (p._meta.disjoint !== undefined) meta.disjoint = p._meta.disjoint\n      else delete meta.disjoint\n    },\n  }\n\n  return slot\n}\n", "import type { Combinator, ParserDef } from '../types.ts'\n\n/**\n * Dead-value analysis (shared by the interpreter and codegen). A container\n * combinator \u2014 `many` / `oneOrMore` / `optional` / `sequence` \u2014 builds an\n * aggregate value (array / tuple / nullable). Under a `node()`, the node builds\n * from the *captured children*, never from that aggregate, so the aggregate is\n * built and thrown away. This pass marks those containers `valueUnused`; the\n * interpreter and the emitter then skip building the aggregate entirely (the\n * elements still parse and self-capture, so trees are identical).\n *\n * Walks ONE combinator tree (a single rule body, or a standalone root), stopping\n * at `lazy`/ref boundaries \u2014 other rules are analyzed on their own root. Starts\n * `consumed = true` (a rule's own value is assumed read \u2014 conservative); `node()`\n * flips it to false for its inner parser; `transform` forces it true (its map fn\n * reads the value). Sharing-safe: any `consumed = true` visit wins and is sticky,\n * so a container reachable from BOTH a consuming and a non-consuming site keeps\n * its aggregate (never wrongly elided).\n *\n * Soundness: a container is marked ONLY when every path to it passes through a\n * `node()` (value-discarding) without an intervening value-reader \u2014 i.e. its\n * aggregate provably isn't observed. Idempotent; safe to re-run.\n */\nexport function markUnusedValues(root: Combinator<unknown>): void {\n  const seenConsumed = new WeakSet<Combinator<unknown>>()\n  const seenUnconsumed = new WeakSet<Combinator<unknown>>()\n\n  const mark = (def: { valueUnused?: boolean }, consumed: boolean): void => {\n    if (consumed) def.valueUnused = false\n    else if (def.valueUnused !== false) def.valueUnused = true\n  }\n\n  const visit = (c: Combinator<unknown>, consumed: boolean): void => {\n    const seen = consumed ? seenConsumed : seenUnconsumed\n    if (seen.has(c)) return\n    seen.add(c)\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion\n    const def = c._def as ParserDef & { valueUnused?: boolean }\n\n    switch (def.tag) {\n      case 'many':\n      case 'oneOrMore':\n        mark(def, consumed)\n        visit(def.parser, consumed)\n        return\n      case 'optional':\n        // `optional` returns `inner | null` \u2014 no aggregate array/tuple to elide, so\n        // it carries no valueUnused flag. Still descend so an inner many/sequence\n        // under a node() is analyzed (it benefits even when its optional wrapper\n        // doesn't).\n        visit(def.parser, consumed)\n        return\n      case 'sequence':\n        mark(def, consumed)\n        for (const p of def.parsers) visit(p, consumed)\n        return\n      case 'choice':\n        // value is the winning arm's value \u2014 propagate consumed to each arm.\n        for (const p of def.parsers) visit(p, consumed)\n        return\n      case 'node':\n        // builds from captured children, NOT the inner parser value.\n        visit(def.parser, false)\n        return\n      case 'transform':\n        // the map fn reads the value \u2192 always consumed.\n        visit(def.parser, true)\n        return\n      case 'field':\n        // the field capture records the parsed value \u2192 always consumed.\n        visit(def.parser, true)\n        return\n      case 'skip':\n        visit(def.main, consumed)   // returns main's value\n        visit(def.skipped, false)   // skipped value is discarded\n        return\n      case 'sepBy':\n        // sepBy is NOT elided (no valueUnused), so it always builds its array and\n        // therefore always reads each item's value \u2014 regardless of whether sepBy's\n        // OWN value is observed. Item parser is unconditionally consumed.\n        visit(def.parser, true)\n        visit(def.separator, false)\n        return\n      case 'not':\n        visit(def.parser, false)    // lookahead \u2014 value never observed\n        return\n      case 'grammar':\n        visit(def.parser, consumed)\n        if (def.triviaParser) visit(def.triviaParser, false)\n        return\n      case 'recover':\n        visit(def.parser, consumed)\n        visit(def.sentinel, false)\n        return\n      case 'label':\n      case 'trivia':\n      case 'token':\n      case 'withCtx':\n      case 'expect':\n        visit(def.parser, consumed) // single-child pass-through wrappers\n        return\n      case 'lazy':\n        // An INNER ref boundary \u2014 a distinct rule, analyzed on its own root. Don't\n        // descend (and never call thunk(): an external ref would throw). A ref at\n        // the ROOT of a rule is different \u2014 it wraps this rule's own body \u2014 and is\n        // resolved by resolveRoot() before the walk starts.\n        return\n      default:\n        // literal / regex / keywords / guard / scanTo / unknown \u2014 no container child.\n        return\n    }\n  }\n\n  // A rule's root is often a `ref()`/`lazy` wrapping the real body \u2014 that is how\n  // rules() and compose() store forward-referenced and composed rules. Walking\n  // that lazy directly hits the boundary case and marks nothing, so resolve a\n  // ROOT lazy to its defined body first. Inner lazies (references to OTHER rules)\n  // stay boundaries \u2014 each rule is analyzed from its own resolved root.\n  const resolveRoot = (c: Combinator<unknown>): Combinator<unknown> => {\n    const guard = new Set<Combinator<unknown>>()\n    let cur = c\n    while (!guard.has(cur)) {\n      const d = cur._def as ParserDef\n      if (d.tag !== 'lazy') return cur\n      guard.add(cur)\n      try { cur = d.thunk() } catch { return c }  // undefined ref \u2192 leave as-is\n    }\n    return cur\n  }\n\n  visit(resolveRoot(root), true)\n}\n", "import type { Combinator } from '../types.ts'\nimport { ref } from './ref.ts'\nimport { markUnusedValues } from '../compiler/value-usage.ts'\n\n/**\n * Non-enumerable key on a `rules()` result holding the factory's declaration\n * order (the returned object's key order), which differs from the result's own\n * reference-creation key order. Read by `parseman/spec` for source-order output.\n */\nexport const RULE_ORDER = '__parsemanRuleOrder'\n\nfunction tagRule(r: Combinator<unknown>, key: string): void {\n  ;(r as unknown as { _ruleName?: string })._ruleName = key\n  if (r._def.tag === 'node' && r._def.type === undefined) r._def.type = key\n}\n\n/**\n * Define named grammar rules without forward declarations.\n *\n * Pass a factory that receives all rule names as references (via a Proxy)\n * and returns a record of combinators. rules() handles creating ref()\n * placeholders and wiring them up \u2014 the user never sees ref() at all.\n *\n *   const { value } = rules(g => ({\n *     value:  choice(g.object, g.array, str, num, bool, nil),\n *     object: transform(sequence('{', sepBy(g.pair, ','), '}'), Object.fromEntries),\n *     array:  transform(sequence('[', sepBy(g.value, ','), ']'), ([, items]) => items),\n *     pair:   transform(sequence(g.key, literal(':'), g.value), ([k,, v]) => [k, v]),\n *   }))\n *\n * Not every name in the factory must appear in the returned object \u2014 local helpers\n * (like `comma`, `key`) can be plain const inside the factory and composed normally.\n * Only names that OTHER rules reference via `g.xxx` need to be in the returned record.\n *\n * TypeScript: use an explicit type parameter for full type safety on `g`:\n *   rules<{ value: Combinator<JSONValue>; array: Combinator<JSONValue[]> }>(g => ({ ... }))\n * Without it, `g.*` accesses are typed as `any` but the return is still inferred.\n */\n/**\n * Grammar-level options for `rules()`. Parity with `parser({...})`, but declared\n * ONCE for the whole grammar instead of wrapped around a scope. `trivia` becomes\n * the ambient trivia for every rule (installed at the parse entry, inherited\n * everywhere, incremental parse included); `parser({trivia})` / `noTrivia` still\n * override it locally for a sub-region.\n */\nexport type RulesOptions = {\n  /** Ambient trivia for the whole grammar. See `parser({ trivia })` for the shape\n   * (`null` clears it \u2014 equivalent to omitting it at the grammar level). */\n  trivia?: Combinator<unknown> | null\n}\n\n// Options-first, mirroring `parser({ opts }, combinator)` \u2014 set once on the grammar\n// vs scope it locally, same options in the same position. The bare `rules(factory)`\n// form is unchanged. The impl also tolerates the legacy `rules(factory, opts)` order.\nexport function rules<T extends Record<string, Combinator<unknown>>>(factory: (self: any) => T): T\nexport function rules<T extends Record<string, Combinator<unknown>>>(options: RulesOptions, factory: (self: any) => T): T\nexport function rules<T extends Record<string, Combinator<unknown>>>(\n  a: ((self: any) => T) | RulesOptions,\n  b?: (self: any) => T,\n): T {\n  const factory = (typeof a === 'function' ? a : b) as (self: any) => T\n  const options = (typeof a === 'function' ? b : a) as RulesOptions | undefined\n  const cache: Partial<T> = {}\n\n  // Proxy: accessing any property creates a ref() placeholder on first touch.\n  const proxy = new Proxy(cache, {\n    get(target, key) {\n      if (typeof key !== 'string') return undefined\n      const record = target as Record<string, Combinator<unknown>>\n      if (!(key in record)) {\n        const r = ref()\n        // Tag the placeholder with its rule name so the linkable compiler can\n        // emit a by-name `_r_<key>` call for a reference to a rule defined in\n        // ANOTHER artifact (resolved at fuse time) \u2014 see compileLinkable.\n        tagRule(r, key)\n        record[key] = r\n      }\n      return record[key]\n    },\n  })\n\n  // Evaluate all rule definitions. JavaScript evaluates object-literal values\n  // left-to-right, so any `g.ruleName` access inside triggers placeholder creation\n  // before the rule's own parser is built \u2014 enabling forward references.\n  const definitions = factory(proxy)\n\n  // Fill each ref with its actual definition, or store directly if never accessed via proxy.\n  for (const key of Object.keys(definitions)) {\n    const placeholder = (cache as Record<string, Combinator<unknown>>)[key]\n    const parser = (definitions as Record<string, Combinator<unknown>>)[key]!\n    if (placeholder !== undefined && typeof (placeholder as any).define === 'function') {\n      tagRule(parser, key)\n      ;(placeholder as any).define(parser)\n      // Propagate actual first-set so later choices wrapping this ref get correct dispatch.\n      placeholder._meta.firstSet = parser._meta.firstSet\n      placeholder._meta.canMatchNewline = parser._meta.canMatchNewline\n    } else {\n      tagRule(parser, key)\n      ;(cache as Record<string, Combinator<unknown>>)[key] = parser\n    }\n  }\n\n  // Declare the grammar-level ambient trivia on every rule, so parsing ANY rule\n  // as an entry installs it (run()/parse() read this), and the macro can seed the\n  // compiled map. `parser({trivia})` / `noTrivia` still override it locally.\n  // `!= null`: a `trivia: null` grammar clears trivia \u2014 same as omitting it at the\n  // grammar level \u2014 so store nothing (and never write null, which has no `_meta`).\n  if (options?.trivia != null) {\n    for (const key of Object.keys(definitions)) {\n      const rule = (cache as Record<string, Combinator<unknown>>)[key]\n      // Skip trivia rules (e.g. the grammar's `rw`, returned so the driver can\n      // reach it as `g.rw`): a trivia rule must never carry ambient trivia, or it\n      // would recursively skip trivia within itself. Mirrors the codegen guard.\n      if (rule && !rule._meta.isTrivia) (rule._meta as { grammarTrivia?: Combinator<unknown> }).grammarTrivia = options.trivia\n    }\n  }\n\n  // Dead-value analysis: mark container aggregates that only feed a node()'s\n  // capture so the interpreter (and, via the same flag, the compiled output) skips\n  // building them. Each rule is its own root \u2014 refs are boundaries (see value-usage).\n  for (const key of Object.keys(definitions)) {\n    markUnusedValues((cache as Record<string, Combinator<unknown>>)[key]!)\n  }\n\n  // Record the factory's DECLARATION order (the returned object's key order).\n  // `cache`'s own key order is reference-creation order \u2014 a Proxy artifact \u2014 so\n  // it can lead with an internal rule instead of the entry rule. Consumers that\n  // want the order the author actually wrote (e.g. `parseman/spec`) read this.\n  // Non-enumerable, so Object.keys / spread / for-in over the grammar are\n  // unaffected and every existing consumer sees exactly the rules it did before.\n  Object.defineProperty(cache, RULE_ORDER, {\n    value: Object.keys(definitions),\n    enumerable: false,\n    configurable: true,\n  })\n\n  return cache as T\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { any } from './first-set.ts'\nimport { saveCstMark, rollbackCstCapture } from '../cst/capture-buffer.ts'\n\n/**\n * Negative lookahead. Succeeds (consuming nothing) when `combinator` fails;\n * fails when `combinator` succeeds.\n *\n * The standard way to match a keyword without also matching the prefix\n * of a longer identifier:\n *\n *   const kwTrue = sequence(literal('true'), not(regex(/\\w/)))\n *   // matches \"true\" in \"true && x\" but NOT in \"trueish\" or \"trueness\"\n */\nexport function not(combinator: Combinator<unknown>): Combinator<null> {\n  const meta: ParserMeta = {\n    firstSet: any(),     // we don't know what NOT matches\n    canMatchNewline: false,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'not',\n    _meta: meta,\n    _def: { tag: 'not', parser: combinator },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<null> {\n      // Negative lookahead is a pure predicate: whatever the inner attempt\n      // captured (CST leaves/trivia/fields) or recovered (a ParseError pushed to\n      // ctx._errors + embedded via captureError) must be rolled back on BOTH\n      // outcomes \u2014 not() consumes nothing and so may leave no side effect, or a\n      // speculatively-recovered error would ghost past the lookahead.\n      const mark = saveCstMark(ctx)\n      const result = combinator.parse(input, pos, ctx)\n      rollbackCstCapture(ctx, mark)\n      if (result.ok) {\n        return { ok: false, expected: [`not(${combinator._tag})`], span: { start: pos, end: pos } }\n      }\n      return { ok: true, value: null, span: { start: pos, end: pos } }\n    },\n  }\n}\n", "import type { ParserDef } from '../types.ts'\n\n/**\n * Per-node CST-trivia (5th build arg) and state-clone (6th build arg) capture is\n * dead work when the build never declares those formal params. This module derives\n * a build's *confirmed* formal-parameter arity so all three eval paths (interpreter,\n * compiler, macro) can elide that capture identically.\n *\n * Conservative by construction: any source we can't confidently parse \u2014 rest params,\n * destructuring, `arguments`, an unrecognized shape \u2014 yields `null` (arity unknown),\n * and callers KEEP full capture. We only ever return a number when the parameter list\n * is a plain comma-separated list of simple identifiers.\n */\n\ntype NodeDef = Extract<ParserDef, { tag: 'node' }>\n\n/** Matches the formal-parameter list of an arrow or function build, capturing its inner text. */\nconst PARAM_LIST_RE =\n  // (params) => ...   |   function name?(params) ...   |   single-ident arrow `x => ...`\n  /^(?:function\\b[^(]*\\(([^)]*)\\)|\\(([^)]*)\\)\\s*=>|([A-Za-z_$][\\w$]*)\\s*=>)/\n\n/**\n * A confirmable formal param: a plain identifier, optionally `?`-optional and\n * optionally carrying a TypeScript type annotation (`c`, `c?`, `c: any`,\n * `c?: Foo`). The build source is sliced verbatim from the (possibly TS) grammar\n * source, so typed params must be recognized or every typed grammar keeps full\n * capture. Type annotations containing a comma (generics/tuples/object types) are\n * split apart by the caller's `,`-split into non-matching fragments \u2192 `null`\n * (conservative). No `=` (default) is accepted \u2014 defaults stay unconfirmed.\n */\nconst CONFIRMABLE_PARAM_RE = /^[A-Za-z_$][\\w$]*\\s*\\??\\s*(?::[^,=]+)?$/\n\n/**\n * Confirmed count of simple formal parameters the build declares, or `null` when the\n * source can't be parsed into a plain identifier list (\u2192 caller keeps full capture).\n */\nexport function confirmedBuildArity(src: string): number | null {\n  const s = src.trim()\n  const m = PARAM_LIST_RE.exec(s)\n  if (!m) return null\n\n  // Single-ident arrow: `x => ...` \u2192 exactly one param.\n  if (m[3] !== undefined) return 1\n\n  const inner = (m[1] ?? m[2] ?? '').trim()\n  if (inner === '') return 0\n\n  // Reject anything that isn't a flat list of simple identifiers. A rest param\n  // (`...args`), destructuring (`{a}`, `[a]`), or default (`a = 1`) all appear here.\n  const parts = inner.split(',')\n  for (const part of parts) {\n    if (!CONFIRMABLE_PARAM_RE.test(part.trim())) return null\n  }\n\n  // A stray `arguments` reference defeats formal-arity reasoning entirely; only a\n  // full-source scan can rule it out. Cheap guard against the obvious cases.\n  if (/\\barguments\\b/.test(s)) return null\n\n  return parts.length\n}\n\n/** Build reads the 5th (triviaLog) arg? Unknown/unparseable \u2192 true (keep capture). */\nexport function buildReadsTrivia(def: NodeDef): boolean {\n  if (!def.build) return true // structural node: host may read trivia \u2014 keep capture\n  const src = def.buildSrc ?? def.build.toString()\n  const arity = confirmedBuildArity(src)\n  if (arity === null) return true\n  return arity >= 5\n}\n\n/** Build reads the 6th (state) arg? Unknown/unparseable \u2192 true (keep state clone). */\nexport function buildReadsState(def: NodeDef): boolean {\n  if (!def.build) return true // structural node: host may read state \u2014 keep clone\n  const src = def.buildSrc ?? def.build.toString()\n  const arity = confirmedBuildArity(src)\n  if (arity === null) return true\n  return arity >= 6\n}\n", "import type { Combinator, FieldMap, ParserDef } from '../types.ts'\nimport { confirmedBuildArity } from './build-arity.ts'\n\ntype NodeDef = Extract<ParserDef, { tag: 'node' }>\n\nexport function buildReadsFields(def: NodeDef): boolean {\n  if (!def.build) return true\n  const src = def.buildSrc ?? def.build.toString()\n  const arity = confirmedBuildArity(src)\n  if (arity === null) return true\n  return arity >= 2\n}\n\nexport function parserHasOwnFields(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  if (seen.has(p)) return false\n  seen.add(p)\n  const d = p._def\n  switch (d.tag) {\n    case 'field': return true\n    case 'node': return false\n    case 'lazy': {\n      try { return parserHasOwnFields(d.thunk(), seen) } catch { return false }\n    }\n    case 'sequence':\n    case 'choice': return d.parsers.some(x => parserHasOwnFields(x, seen))\n    case 'sepBy': return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.separator, seen)\n    case 'skip': return parserHasOwnFields(d.main, seen) || parserHasOwnFields(d.skipped, seen)\n    case 'grammar': return parserHasOwnFields(d.parser, seen) || (d.triviaParser ? parserHasOwnFields(d.triviaParser, seen) : false)\n    case 'scanTo': return parserHasOwnFields(d.sentinel, seen) || d.skip.some(x => parserHasOwnFields(x, seen))\n    case 'recover': return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.sentinel, seen)\n    case 'many':\n    case 'oneOrMore':\n    case 'optional':\n    case 'transform':\n    case 'trivia':\n    case 'token':\n    case 'label':\n    case 'expect':\n    case 'withCtx':\n    case 'not':\n      return parserHasOwnFields(d.parser, seen)\n    default:\n      return false\n  }\n}\n\n/**\n * Does the node's OWN parse frame ever have a trivia run logged into it?\n * Trivia is logged only by the trivia-skip fn, which runs at `sequence`/`many`/\n * repeat boundaries. A bare terminal (regex/literal/keywords/\u2026) has NO trivia\n * site, so its `_cstTriviaLog` stays empty and its `captureTrivia`/`_cstTriviaLog`/\n * `_triviaCaptureMask` save+install+restore is dead work \u2014 the per-node scope\n * trivia frame can be elided for it (see emitNode `needsTriviaFrame`).\n *\n * Stops at a nested `node()` (it manages its OWN trivia frame; trivia inside it\n * never logs to THIS node's frame). CONSERVATIVE: any unknown / trivia-bearing\n * shape returns `true` (keep the frame) \u2014 we only elide when provably safe.\n */\nexport function parserHasTriviaSite(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  if (seen.has(p)) return true // cycle \u2192 conservative (keep the frame)\n  seen.add(p)\n  const d = p._def\n  switch (d.tag) {\n    // Trivia is skipped between/around elements or iterations \u2192 a site.\n    case 'sequence':\n    case 'many':\n    case 'oneOrMore':\n    case 'sepBy':\n    case 'scanTo':\n    case 'recover':\n    case 'skip':\n      return true\n    // Nested node manages its own trivia frame; none logs here.\n    case 'node': return false\n    // Pure terminals + trivia-suppressing token: no site.\n    case 'regex':\n    case 'literal':\n    case 'keywords':\n    case 'guard':\n    case 'token':\n      return false\n    // Transparent single-child wrappers: recurse.\n    case 'optional':\n    case 'transform':\n    case 'trivia':\n    case 'label':\n    case 'expect':\n    case 'withCtx':\n    case 'not':\n    case 'field':\n      return parserHasTriviaSite(d.parser, seen)\n    case 'choice': return d.parsers.some(x => parserHasTriviaSite(x, seen))\n    case 'grammar': return parserHasTriviaSite(d.parser, seen)\n    case 'lazy': {\n      try { return parserHasTriviaSite(d.thunk(), seen) } catch { return true }\n    }\n    default: return true // unknown shape \u2192 conservative\n  }\n}\n\nexport function buildFieldMap(captures: ReadonlyArray<{ name: string; value: unknown; span: { start: number; end: number } }> | undefined): FieldMap | undefined {\n  if (!captures?.length) return undefined\n  const out: FieldMap = {}\n  for (const cap of captures) {\n    const entry = { value: cap.value, span: cap.span }\n    const current = out[cap.name]\n    if (current === undefined) out[cap.name] = entry\n    else if (Array.isArray(current)) current.push(entry)\n    else out[cap.name] = [current, entry]\n  }\n  return out\n}\n", "import type { Combinator, FieldMap, ParseContext, ParseResult, ParserMeta, ParserDef } from '../types.ts'\nimport { beginCstNodeCapture, endCstNodeCapture, pushCstChild } from '../cst/capture-buffer.ts'\nimport { buildReadsTrivia, buildReadsState } from '../compiler/build-arity.ts'\nimport { buildFieldMap, buildReadsFields, parserHasOwnFields } from '../compiler/fields.ts'\n\n/**\n * A CST/AST node rule. Runs `combinator` while collecting its terminals into\n * `children` / `rawChildren` arrays and trivia spans into `triviaLog`, then\n * calls `build(children, fields, span, rawChildren, triviaLog, state)` to produce the node.\n *\n *   - `children`    \u2014 structural items in source order: spanned CSTLeaf terminals\n *                     and sub-nodes (whatever `build` returned for inner nodes).\n *   - `rawChildren` \u2014 structural children only (same items as `children`).\n *   - `triviaLog`   \u2014 flat log of trivia entries: each entry is `[start, end, insertIdx]`\n *                     consumed between terms. `insertIdx` is the rawChildren index\n *                     before which the trivia was consumed. Use `buildTriviaIndex`\n *                     to turn this into a before/after lookup table.\n *\n * If `build` returns a non-node value (e.g. a bare string for an unwrapped rule),\n * the parent records it as a spanned leaf so its source span is still recoverable.\n */\nexport type BuildNode<N> = (\n  children: ReadonlyArray<unknown>,\n  fields: FieldMap | undefined,\n  span: { start: number; end: number },\n  rawChildren: ReadonlyArray<unknown>,\n  triviaLog: readonly number[],\n  state: unknown,\n) => N\n\n/**\n * Options for `node()`.\n * - `unwrap` \u2014 an AST/value wrapper rule that IS its single child when it\n *   captured exactly one. A leaf unwraps to its string value; a sub-node is\n *   returned as-is.\n * - `collapse` \u2014 a structural wrapper rule that returns its single child exactly\n *   as captured. A leaf stays a CSTLeaf; a node stays a node.\n * Both skip `build` only for a one-child match; zero or two-plus children go\n * through `build` normally.\n */\nexport type NodeOptions = { unwrap?: boolean; collapse?: boolean }\n\n/** A captured child's value form: a leaf unwraps to its string value, else as-is. */\nfunction unwrapChild(child: unknown): unknown {\n  return child !== null && typeof child === 'object' && (child as { _tag?: string })._tag === 'leaf'\n    ? (child as { value: unknown }).value\n    : child\n}\n\nfunction isCstChild(value: unknown): boolean {\n  return typeof value === 'object'\n    && value !== null\n    && ((value as { _tag?: string })._tag === 'node'\n      || (value as { _tag?: string })._tag === 'leaf'\n      || (value as { _tag?: string })._tag === 'parseError')\n}\n\nfunction missingInferredType(): never {\n  throw new Error('node(): inferred node type requires a rules() key; pass node(\"Type\", parser) outside rules()')\n}\n\nexport function node<N>(combinator: Combinator<unknown>, build?: BuildNode<N>, opts?: NodeOptions): Combinator<N>\nexport function node<N>(type: string, combinator: Combinator<unknown>, build?: BuildNode<N>, opts?: NodeOptions): Combinator<N>\nexport function node<N>(\n  typeOrCombinator: string | Combinator<unknown>,\n  combinatorOrBuild?: Combinator<unknown> | BuildNode<N>,\n  buildOrOpts?: BuildNode<N> | NodeOptions,\n  maybeOpts?: NodeOptions,\n): Combinator<N> {\n  const hasExplicitType = typeof typeOrCombinator === 'string'\n  const type = hasExplicitType ? typeOrCombinator : undefined\n  const combinator = (hasExplicitType ? combinatorOrBuild : typeOrCombinator) as Combinator<unknown>\n  const build = (hasExplicitType ? buildOrOpts : combinatorOrBuild) as BuildNode<N> | undefined\n  const opts = (hasExplicitType ? maybeOpts : buildOrOpts) as NodeOptions | undefined\n  const baseDef = { tag: 'node' as const, parser: combinator, ...(type === undefined ? {} : { type }), ...(build === undefined ? {} : { build }) }\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  const unwrap = opts?.unwrap === true\n  const collapse = opts?.collapse === true\n  if (unwrap && collapse) {\n    throw new Error('node() options cannot set both unwrap and collapse')\n  }\n  const def: Extract<ParserDef, { tag: 'node' }> = unwrap || collapse\n    ? { ...baseDef, ...(unwrap ? { unwrap: true } : {}), ...(collapse ? { collapse: true } : {}) }\n    : baseDef\n  // Arity-gated elision \u2014 decided once, identically to the compiler (build-arity.ts).\n  // When the build never reads the trivia (4th) arg, disable per-node CST-trivia\n  // capture for the inner scope; when it never reads state (5th), skip the state clone.\n  // A STRUCTURAL node (no own build) defers to `ctx.build` / a default CST, which\n  // may read either, so capture both.\n  const capturesTrivia = build ? buildReadsTrivia(def) : true\n  const clonesState = build ? buildReadsState(def) : true\n  const capturesFields = parserHasOwnFields(combinator) && (build ? buildReadsFields(def) : true)\n  return {\n    _tag: 'node',\n    _meta: meta,\n    _def: def,\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<N> {\n      const saved = beginCstNodeCapture(ctx)\n      const savedFields = ctx._fields\n      ctx._fields = capturesFields ? [] : undefined\n      // Per-node-type trivia-kind mask: a structural (host-built) node may want\n      // only certain kinds captured (comments for Ruleset, whitespace for\n      // CompoundSelector). Scoped here, restored below \u2014 matches the compiled path.\n      const savedMask = ctx._triviaCaptureMask\n      if (build === undefined && ctx.build?._parsemanTriviaKinds !== undefined && def.type !== undefined) {\n        ctx._triviaCaptureMask = ctx.build._parsemanTriviaKinds(def.type)\n      }\n      // Short-circuit the per-node trivia push (scanTrivia gates on captureTrivia)\n      // without touching the global _triviaLog, which is committed independently.\n      if (!capturesTrivia) ctx.captureTrivia = false\n      const r = combinator.parse(input, pos, ctx)\n      const fields = capturesFields ? buildFieldMap(ctx._fields) : undefined\n      ctx._fields = savedFields\n      ctx._triviaCaptureMask = savedMask\n      const { children, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved)\n\n      if (!r.ok) return r\n\n      // unwrap/collapse: a single captured child IS the value \u2014 skip build.\n      const st = clonesState && ctx.state !== undefined ? Object.assign({}, ctx.state as Record<string, unknown>) : undefined\n      const nodeType = def.type ?? missingInferredType()\n      const built: unknown = unwrap && children.length === 1\n        ? unwrapChild(children[0])\n        : collapse && children.length === 1\n          ? children[0]\n        : !build\n          && ctx.build?._parsemanCstCollapse\n          && children.length === 1\n          && rawChildren.length === 1\n          && ctx.build._parsemanCstCollapse(nodeType, children[0], children, rawChildren)\n          ? children[0]\n        : build\n          ? build(children, fields, r.span, rawChildren, triviaLog, st)\n          // Structural node: a `ctx.build` host if present, else a default CST.\n          : ctx.build\n              ? ctx.build(nodeType, children, fields, r.span, rawChildren, triviaLog, st)\n              : { _tag: 'node', type: nodeType, span: { start: r.span.start, end: r.span.end }, state: st ?? null, children }\n      const rawEntry = isCstChild(built)\n        ? built\n        : { _tag: 'leaf', value: typeof built === 'string' ? built : '', span: r.span }\n      if (saved.buf !== undefined || saved.ch !== undefined) {\n        pushCstChild(ctx, built, rawEntry)\n      }\n      return { ok: true, value: built as N, span: r.span }\n    },\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult } from '../types.ts'\nimport { analyzeLabeledTrivia } from '../cst/trivia-kinds.ts'\n\nexport function transform<T, U>(\n  combinator: Combinator<T>,\n  fn: (value: T, span: { start: number; end: number }) => U\n): Combinator<U> {\n  return {\n    _tag: 'transform',\n    _meta: combinator._meta,\n    _def: { tag: 'transform', parser: combinator as Combinator<unknown>, fn: fn as (v: unknown, span: { start: number; end: number }) => unknown },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<U> {\n      const result = combinator.parse(input, pos, ctx)\n      if (!result.ok) return result\n      return { ok: true, value: fn(result.value, result.span), span: result.span }\n    },\n  }\n}\n\nexport function skip<T, S>(main: Combinator<T>, skipped: Combinator<S>): Combinator<T> {\n  return {\n    _tag: 'skip',\n    _meta: main._meta,\n    _def: { tag: 'skip', main: main as Combinator<unknown>, skipped: skipped as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      const result = main.parse(input, pos, ctx)\n      if (!result.ok) return result\n      const s = skipped.parse(input, result.span.end, ctx)\n      if (!s.ok) return result\n      return { ok: true, value: result.value, span: { start: result.span.start, end: s.span.end } }\n    },\n  }\n}\n\nexport function trivia<T>(combinator: Combinator<T>): Combinator<T> {\n  const kindLabels = analyzeLabeledTrivia(combinator as Combinator<unknown>)?.labels\n  return {\n    _tag: combinator._tag,\n    _meta: {\n      ...combinator._meta,\n      isTrivia: true,\n      ...(kindLabels ? { triviaKindLabels: kindLabels } : {}),\n    },\n    _def: { tag: 'trivia', parser: combinator as Combinator<unknown> },\n    parse: combinator.parse.bind(combinator),\n  }\n}\n\n/**\n * Attach a string label to a parser arm (e.g. trivia `choice` branches).\n * Parse behavior is unchanged; the label is metadata for tooling and future\n * trivia-kind capture (`'whitespace'`, `'blockComment'`, \u2026).\n */\nexport function label<T>(name: string, combinator: Combinator<T>): Combinator<T> {\n  return {\n    _tag: combinator._tag,\n    _meta: combinator._meta,\n    _def: { tag: 'label', label: name, parser: combinator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      const result = combinator.parse(input, pos, ctx)\n      if (!result.ok) return { ok: false, expected: [name], span: result.span }\n      return result\n    },\n  }\n}\n\n/**\n * Capture a named parse result for the nearest enclosing node() builder.\n * Parse behavior and the normal returned value are unchanged.\n */\nexport function field<T>(name: string, combinator: Combinator<T>): Combinator<T> {\n  return {\n    _tag: combinator._tag,\n    _meta: combinator._meta,\n    _def: { tag: 'field', name, parser: combinator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      const result = combinator.parse(input, pos, ctx)\n      if (!result.ok) return result\n      ctx._fields?.push({ name, value: result.value, span: result.span })\n      return result\n    },\n  }\n}\n", "import type { Span } from '../types.ts'\n\n/**\n * Precomputed index of newline positions for O(log n) offset\u2192line/col lookup.\n * lineStarts[i] is the byte offset of the first character on line i+1.\n */\nexport type LineIndex = { lineStarts: number[] }\n\nexport function buildLineIndex(input: string): LineIndex {\n  const lineStarts = [0]\n  for (let i = 0; i < input.length; i++) {\n    if (input.charCodeAt(i) === 10) lineStarts.push(i + 1)\n  }\n  return { lineStarts }\n}\n\nexport function offsetToLineCol(\n  index: LineIndex,\n  offset: number\n): { line: number; col: number } {\n  const { lineStarts } = index\n  let lo = 0\n  let hi = lineStarts.length - 1\n  while (lo < hi) {\n    const mid = (lo + hi + 1) >> 1\n    if (lineStarts[mid]! <= offset) lo = mid\n    else hi = mid - 1\n  }\n  return { line: lo + 1, col: offset - lineStarts[lo]! + 1 }\n}\n\n/** Fills startLine/startColumn/endLine/endColumn on a span in-place. */\nexport function annotateSpan(span: Span, index: LineIndex): Span {\n  const s = offsetToLineCol(index, span.start)\n  const e = offsetToLineCol(index, span.end)\n  return {\n    ...span,\n    startLine: s.line,\n    startColumn: s.col,\n    endLine: e.line,\n    endColumn: e.col,\n  }\n}\n", "import type { Combinator, ParseContext, ParseResult, ParseFail } from '../types.ts'\nimport { buildLineIndex, annotateSpan } from '../compiler/line-index.ts'\nimport { markUnusedValues } from '../compiler/value-usage.ts'\nimport { triviaKindMask } from '../cst/trivia-kinds.ts'\n\nexport type ParseOptions = {\n  trackLines?: boolean\n  /**\n   * Enable the error-collection channel. When true, recovery points (expect(), and\n   * tolerant list recovery) collect their ParseErrors into a side-channel array\n   * rather than only embedding them in the value tree. The returned ParseOk will\n   * have an `errors` field listing all recovered errors. Top-level parse failures\n   * (where nothing recovered) still return ParseFail as usual.\n   */\n  recover?: boolean\n}\n\nexport type ParserOptions = ParseOptions & {\n  /**\n   * Trivia parser for this scope. Three states:\n   *   - a Combinator \u2192 skip this trivia between sequence/repeat terms\n   *   - `undefined`  \u2192 inherit the enclosing scope's trivia (no change)\n   *   - `null`       \u2192 CLEAR trivia: no trivia skipped, so terms must be contiguous.\n   *                    Re-enable inside a nested region with another parser({ trivia }).\n   */\n  trivia?: Combinator<unknown> | null\n  /** Record consumed trivia as CSTTrivia tokens in rawChildren. Default: skip. */\n  captureTrivia?: boolean\n  /**\n   * Restrict PER-NODE CST trivia capture to these trivia kinds (label names from\n   * the trivia's `label()` arms). Whitespace and any other unlisted kind is still\n   * skipped over but NOT recorded into a node's `triviaLog` \u2014 so a host that only\n   * consumes (say) comments pays nothing to log every whitespace run. The global\n   * trivia log is unaffected. Requires labeled trivia; ignored otherwise.\n   */\n  captureTriviaKinds?: readonly string[]\n}\n\nexport interface ParsemanParser<T> extends Combinator<T> {\n  parse(input: string): ParseResult<T>\n  parse(input: string, pos: number, ctx: ParseContext): ParseResult<T>\n}\n\nexport function parser<T>(opts: ParserOptions, root: Combinator<T>): ParsemanParser<T> {\n  const clearTrivia = opts.trivia === null\n  return {\n    _tag: 'grammar',\n    _meta: root._meta,\n    _def: {\n      tag: 'grammar',\n      parser: root as Combinator<unknown>,\n      triviaParser: clearTrivia ? undefined : (opts.trivia ?? undefined),\n      clearTrivia,\n      trackLines: opts.trackLines ?? false,\n    },\n    parse(input: string, pos?: number, _ctx?: ParseContext): ParseResult<T> {\n      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false\n      // Preserve any CST collectors / capture flag from the caller (e.g. an\n      // enclosing node()), layering this grammar's trivia on top. Without this,\n      // a parser() nested inside a node() would drop the node's child collectors.\n      const ctx: ParseContext = {\n        ..._ctx,\n        trackLines,\n        // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.\n        ...(clearTrivia ? {\n          trivia: undefined,\n          triviaKindLabels: undefined,\n        } : opts.trivia != null ? {\n          trivia: opts.trivia,\n          ...(opts.trivia._meta.triviaKindLabels\n            ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels }\n            : {}),\n        } : {}),\n        ...(opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {}),\n        // Kind-filter for per-node capture. Resolve against this scope's trivia\n        // labels \u2014 this parser's own trivia if it declares one, else the INHERITED\n        // labels (`_ctx.triviaKindLabels`), so captureTriviaKinds still applies when\n        // trivia is inherited rather than re-declared here. No labels \u2192 undefined\n        // (capture all).\n        ...(opts.captureTriviaKinds && !clearTrivia\n          ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) }\n          : {}),\n      }\n      const result = root.parse(input, pos ?? 0, ctx)\n      if (trackLines) {\n        const idx = buildLineIndex(input)\n        return { ...result, span: annotateSpan(result.span, idx) }\n      }\n      return result\n    },\n  } as ParsemanParser<T>\n}\n\n/**\n * Run `root` with the active trivia cleared \u2014 no trivia is skipped between its\n * sequence/repeat terms, so they must be contiguous in the input. (Trivia is\n * whatever parser({ trivia }) installed \u2014 often whitespace/comments, but it is\n * grammar-defined.) The inverse of parser({ trivia }); re-enable trivia in a\n * nested region with another parser({ trivia }).\n *\n * Wrap the WHOLE contiguous run: an enclosing sequence skips trivia *before* a\n * term runs, so wrapping just the inner part would let leading trivia through.\n *\n * For a static glued token just use one literal/regex; reach for noTrivia when a\n * glued part is a structured sub-rule \u2014 e.g. a head glued to a `[subscript]`\n * whose interior still allows trivia. Turn trivia back on for a region by nesting\n * another parser({ trivia }) (innermost wins, reverts on exit); put the WHOLE\n * spaced region \u2014 including its leading `[` \u2014 inside it, since sequence skips\n * trivia only between terms, not before its first:\n *\n *   // `arr[i + 1]` \u2014 `arr` touches `[`, but the subscript is a spaced expr:\n *   noTrivia(sequence(name,\n *     parser({ trivia: ws }, sequence(literal('['), expr, literal(']')))))\n */\nexport function noTrivia<T>(root: Combinator<T>): ParsemanParser<T> {\n  return parser({ trivia: null }, root)\n}\n\n// Roots already run through dead-value analysis, so a hot parse loop doesn't\n// re-walk the tree. (A `rules()` grammar was analyzed at build; a bare combinator\n// passed straight to parse() is analyzed once here.)\nconst _analyzed = new WeakSet<Combinator<unknown>>()\n\nexport function parse<T>(\n  combinator: Combinator<T>,\n  input: string,\n  opts: ParseOptions = {}\n): ParseResult<T> {\n  if (!_analyzed.has(combinator)) {\n    _analyzed.add(combinator)\n    markUnusedValues(combinator)\n  }\n  const trackLines = opts.trackLines ?? false\n  const _errors = opts.recover ? [] : undefined\n  // In recovery mode also track the furthest-position failure, so the caller can\n  // report \"where it got stuck + what was expected\" even when a permissive top\n  // rule succeeds with unconsumed trailing input. Off by default (it adds\n  // bookkeeping to every failed alternative).\n  const _probe = opts.recover ? { offset: input.length, best: null as ParseFail | null } : undefined\n  // Grammar-level ambient trivia declared via rules({ trivia }, factory): install\n  // it as ctx.trivia so it's ambient (interpreter). parser/noTrivia override locally.\n  const grammarTrivia = combinator._meta.grammarTrivia\n  const ctx: ParseContext = {\n    trackLines,\n    ...(grammarTrivia !== undefined\n      ? { trivia: grammarTrivia, ...(grammarTrivia._meta.triviaKindLabels ? { triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {}) }\n      : {}),\n    ...(_errors !== undefined ? { _errors } : {}),\n    ...(_probe !== undefined ? { _probe } : {}),\n  }\n  const result = combinator.parse(input, 0, ctx)\n  if (!result.ok) return result\n  const withErrors = _errors !== undefined\n    ? { ...result, errors: _errors, furthestFail: _probe?.best ?? null }\n    : result\n  if (trackLines) {\n    const idx = buildLineIndex(input)\n    return { ...withErrors, span: annotateSpan(withErrors.span, idx) }\n  }\n  return withErrors\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\n/**\n * Treat a parser as one source token.\n *\n * The wrapped parser runs with trivia cleared, so its parts must be contiguous.\n * On success the token returns the matched source text and captures one CST leaf\n * for the full span, suppressing any internal terminal leaves.\n */\nexport function token(root: Combinator<unknown>): Combinator<string> {\n  const meta: ParserMeta = {\n    firstSet: root._meta.firstSet,\n    canMatchNewline: root._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'token',\n    _meta: meta,\n    _def: { tag: 'token', parser: root },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      const savedTrivia = ctx.trivia\n      const savedKinds = ctx.triviaKindLabels\n      const savedBuf = ctx._cstBuf\n      const savedChildren = ctx._cstChildren\n      const savedLeaves = ctx._cstLeaves\n      const savedRaw = ctx._cstRawChildren\n      const savedTriviaLog = ctx._cstTriviaLog\n      const savedOuterTriviaLog = ctx._triviaLog\n      const wasCapturing = cstCaptureActive(ctx)\n\n      ctx.trivia = undefined\n      ctx.triviaKindLabels = undefined\n      ctx._cstBuf = undefined\n      ctx._cstChildren = undefined\n      ctx._cstLeaves = undefined\n      ctx._cstRawChildren = undefined\n      ctx._cstTriviaLog = undefined\n      delete ctx._triviaLog\n\n      let result: ParseResult<unknown>\n      try {\n        result = root.parse(input, pos, ctx)\n      } finally {\n        ctx.trivia = savedTrivia\n        ctx.triviaKindLabels = savedKinds\n        ctx._cstBuf = savedBuf\n        ctx._cstChildren = savedChildren\n        ctx._cstLeaves = savedLeaves\n        ctx._cstRawChildren = savedRaw\n        ctx._cstTriviaLog = savedTriviaLog\n        if (savedOuterTriviaLog === undefined) delete ctx._triviaLog\n        else ctx._triviaLog = savedOuterTriviaLog\n      }\n\n      if (!result.ok) return result\n\n      const span = result.span\n      const value = input.slice(pos, span.end)\n      if (wasCapturing) pushCstLeaf(ctx, { _tag: 'leaf', value, span })\n      return { ok: true, value, span }\n    },\n  }\n}\n", "/**\n * Structural recognition of \"scannable\" parser arms \u2014 regex shapes that lower to\n * a tight character-scan loop instead of `regex.exec` / combinator dispatch. Each\n * shape is derived from the regex STRUCTURE, not from any hardcoded knowledge\n * that a given regex \"is whitespace\" or \"is a comment\":\n *\n *   [X]+ / [X]*            \u2192 run while the char \u2208 X                (chars)\n *   <lit>[^X]*             \u2192 consume <lit>, run until char \u2208 X     (until)\n *   <open>(?:\u2026)*<close>    \u2192 consume <open>, run to <close> literal (delimited)\n *   x?<lit><[X]*>\u2026         \u2192 a general linear chain of lit/run     (seq)\n *\n * `seq` is the CATEGORY generalization: any chain of literal segments (required\n * or optional `x?`) and char-class runs (positive/negated, `?`/`*`/`+`). It\n * subsumes CSS/Less `-?ident`, `--custom`, `@-?keyword`, `[^\u2026]+`, `::?`, etc.\n * without hardcoding a single byte \u2014 lowered only when a greedy one-pass scan\n * provably equals the engine's backtracking (see `seqIsUnambiguous`).\n *\n * A `oneOrMore(choice(a, b, \u2026))` where every arm is one of these compiles to a\n * single char-dispatch loop with one branch per arm \u2014 any count/order, because\n * the shapes dispatch on their first 1\u20132 chars and are checked in turn. Trivia\n * (whitespace + comments) is just the value-discarded instance of this; nothing\n * here is trivia-specific.\n */\n\n/**\n * One segment of a `seq` shape. A `seq` is the general category \"a fixed linear\n * chain of literals and char-class runs\" \u2014 no alternation, no groups, no\n * backtracking. It subsumes every CSS/Less token that is \"(optional prefix)?\n * literal* char-run* \u2026\" without hardcoding any particular byte:\n *\n *   lit   \u2014 a run of fixed code points, optionally present (`x?`) or required.\n *   run   \u2014 a char-class run: positive/negated ranges, min 0/1, bounded to one\n *           char (`[x]`, `[x]?`) or unbounded (`[x]*`, `[x]+`).\n *   group \u2014 a non-capturing sub-pattern `(?:\u2026)` (\u00A78f), quantified the same way\n *           as `run` (`min`/`unbounded`). `inner` is any already-recognized\n *           `ScanShape` for the group's body (so a group can itself contain\n *           `seq`/`chars`/`alt`/\u2026 \u2014 including a nested alternation via \u00A78e).\n *           Only used when `groupInnerSafe(inner)` holds (see that function).\n *\n * We only lower a `seq` when greedy left-to-right scanning provably equals the\n * regex engine's backtracking match (see `seqIsUnambiguous`).\n */\nexport type SeqPart =\n  | { part: 'lit'; cps: number[]; optional: boolean }\n  // A char-class run with a general counted quantifier: `min`..`max` occurrences.\n  // `max === Infinity` is unbounded (`+`/`*`/`{n,}`). The four legacy shapes map\n  // as `+`\u2192{1,\u221E} `*`\u2192{0,\u221E} `?`\u2192{0,1} bare\u2192{1,1}; `{n,m}` (\u00A78c) fills the rest.\n  // Greedy scanning has \"wiggle\" a backtracker could exploit iff `max > min`.\n  | { part: 'run'; ranges: Array<[number, number]>; negated: boolean; min: number; max: number }\n  | { part: 'group'; inner: ScanShape; min: 0 | 1; unbounded: boolean }\n\nexport type ScanShape =\n  | { kind: 'chars'; ranges: Array<[number, number]>; minOne: boolean }\n  | { kind: 'ident'; head: Array<[number, number]>; tail: Array<[number, number]> }\n  | { kind: 'until'; open: number[]; stop: Array<[number, number]> }\n  | { kind: 'delimited'; open: number[]; close: number[] }\n  // <q>(?:[^<q>\\\\]|\\\\.)*<q> \u2014 a quote-delimited string with backslash escapes.\n  // `excluded` = the body's negated class (always contains the quote + backslash,\n  // maybe a newline); `escLineTerm` = whether `\\\\` may be followed by a line\n  // terminator (`\\\\[\\s\\S]` \u2192 true, `\\\\.` \u2192 false, since `.` excludes them).\n  | { kind: 'string'; quote: number; excluded: Array<[number, number]>; escLineTerm: boolean }\n  // A linear chain of literal/char-run segments (optional prefixes, literal\n  // openers, negated runs, \u2026) \u2014 the general CSS/Less token category.\n  | { kind: 'seq'; parts: SeqPart[] }\n  // A pure literal matched case-insensitively (`/i`): the general \"ASCII\n  // case-fold literal\" category (CSS `url(`, `@media` keywords under `i`, \u2026).\n  | { kind: 'litFold'; open: number[] }\n  // `<inner>(?!class)` / `<inner>(?=class)` \u2014 a trailing lookahead boundary\n  // check on an already-lowered shape. Zero-width: `end` is `inner`'s end, never\n  // extended. `classNegated` is the bracket's OWN `[^\u2026]` negation (e.g.\n  // `(?![0-9a-fA-F])` vs `(?=[^0-9])`), independent of `negative` (`!` vs `=`).\n  | { kind: 'lookahead'; inner: ScanShape; ranges: Array<[number, number]>; classNegated: boolean; negative: boolean }\n  // `A|B|C` \u2014 top-level alternation (\u00A78e), split outside any `[]`/`()`, each arm\n  // independently lowered. `disjoint` is true iff every pair of arms has\n  // provably non-overlapping first-char sets (`firsts[i]` holds that arm's set,\n  // or `null` if it could start with any char \u2014 an unbounded-optional `chars`\n  // arm, or a non-disjoint mix). When `disjoint`, codegen dispatches straight to\n  // the one matching arm; otherwise it tries arms in order and takes the first\n  // that succeeds \u2014 the same ordered-choice semantics as regex `|` itself (see\n  // the ordered-vs-longest verification in PERF_IDEAS \u00A78e).\n  | { kind: 'alt'; arms: ScanShape[]; disjoint: boolean; firsts: Array<CharSet | null> }\n\n/** Backslash (`\\`) code point \u2014 the escape lead char in string shapes. */\nexport const BACKSLASH = 92\n\nconst META = new Set('()[]{}*+?|^$.'.split(''))\n\n// Regex char-class primitives are shared with the interpreter's first-set\n// analyzer and `regex()`'s scanner \u2014 see `../regex/classes.ts`. `SPACE_RANGES`\n// and `parseClassRanges` are re-exported here because codegen's boundary-class\n// lowering imports them from this module.\nimport { CLASS_ESCAPES, SPACE_RANGES, shorthandRanges, readUnicodeEscape, parseClassRanges } from '../regex/classes.ts'\nexport { SPACE_RANGES, parseClassRanges }\n\n/** A single class token (`[...]` or `\\d`/`\\w`) to ranges, or null. Rejects negation. */\nfunction classToRanges(cls: string): Array<[number, number]> | null {\n  if (cls === '\\\\d') return shorthandRanges('d')\n  if (cls === '\\\\w') return shorthandRanges('w')\n  if (cls === '\\\\s') return shorthandRanges('s')\n  const body = cls.slice(1, -1)\n  if (body.startsWith('^')) return null\n  return parseClassRanges(body)\n}\n\n/** ASCII case-insensitive letter check for `i`-flag literal lowering. */\n// ASCII case-insensitive char compare. For a letter, upper/lower differ only in\n// bit 0x20, and `(c | 32) === <lowercase>` is satisfied by EXACTLY that letter's\n// two cases (nothing else) \u2014 one OR + one compare, ~1.75\u00D7 faster than the\n// two-compare `(c===U || c===L)` form (measured). `(\u2026 | 32)` is parenthesized\n// because `===` binds tighter than `|`. Non-letters keep an exact compare.\n// Exported so the case-insensitive `literal()` emitter (codegen) shares the exact\n// same ASCII fold as `/i`-flag regex lowering \u2014 no `Intl.Collator` on any path.\nexport const foldEq = (cVar: string, cp: number): string => {\n  if (cp >= 65 && cp <= 90) return `(${cVar} | 32) === ${cp + 32}`\n  if (cp >= 97 && cp <= 122) return `(${cVar} | 32) === ${cp}`\n  return `${cVar} === ${cp}`\n}\n\n/** All-literal regex fragment (`\\/\\*`, `\\/\\/`, \u2026) \u2192 its code points, or null on an unescaped metachar. */\nfunction literalCodePoints(frag: string): number[] | null {\n  const out: number[] = []\n  let i = 0\n  while (i < frag.length) {\n    const ch = frag[i]!\n    if (ch === '\\\\') {\n      const e = frag[i + 1]\n      if (e === undefined) return null\n      out.push(e in CLASS_ESCAPES ? CLASS_ESCAPES[e]! : e.codePointAt(0)!)\n      i += 2\n      continue\n    }\n    if (META.has(ch)) return null\n    out.push(ch.codePointAt(0)!)\n    i += 1\n  }\n  return out.length ? out : null\n}\n\n/**\n * Recognize a quote-delimited string with backslash escapes:\n *   <q>(?:[^\u2026]|\\\\.)*<q>  or  <q>(?:\\\\.|[^\u2026])*<q>   (`?:` optional)\n * where the negated body class contains the quote and the backslash, and the\n * escape body is `.` (no line terminators) or `[\\s\\S]` (any char). Returns null\n * for anything else so the caller falls back to `regex.exec`.\n */\nfunction parseStringShape(source: string): ScanShape | null {\n  const q = source[0]\n  if (q === undefined || q === '\\\\' || META.has(q)) return null\n  if (source.length < 3 || source[source.length - 1] !== q) return null\n  const inner = source.slice(1, -1)\n  const CLS = String.raw`\\[\\^((?:\\\\.|[^\\]])+)\\]`\n  const ESC = String.raw`\\\\\\\\(\\.|\\[\\\\s\\\\S\\]|\\[\\\\S\\\\s\\])`\n  // Two arm orders; `?:` optional. Capture groups differ, so read both out.\n  let body: string | undefined\n  let esc: string | undefined\n  let m = new RegExp(`^\\\\((?:\\\\?:)?${CLS}\\\\|${ESC}\\\\)\\\\*$`).exec(inner)\n  if (m) { body = m[1]; esc = m[2] }\n  else {\n    m = new RegExp(`^\\\\((?:\\\\?:)?${ESC}\\\\|${CLS}\\\\)\\\\*$`).exec(inner)\n    if (m) { esc = m[1]; body = m[2] }\n  }\n  if (body === undefined || esc === undefined) return null\n  const excluded = parseClassRanges(body)\n  if (!excluded) return null\n  const qcp = q.codePointAt(0)!\n  const inSet = (cp: number) => excluded.some(([lo, hi]) => cp >= lo && cp <= hi)\n  if (!inSet(qcp) || !inSet(BACKSLASH)) return null\n  return { kind: 'string', quote: qcp, excluded, escLineTerm: esc !== '.' }\n}\n\n/**\n * Parse a regex source into a linear chain of literal / char-run segments, or\n * null if it uses any construct outside that category (alternation, groups,\n * `.`, `{n,m}`, lookaround, unknown escapes). This is the STRUCTURAL recognizer\n * for the `seq` shape \u2014 it encodes categories (optional prefix, literal opener,\n * negated run, \u2026), never any specific byte value.\n */\nfunction parseSeqParts(source: string): SeqPart[] | null {\n  const parts: SeqPart[] = []\n  let lit: number[] = []\n  const flush = () => {\n    if (lit.length) { parts.push({ part: 'lit', cps: lit, optional: false }); lit = [] }\n  }\n  // Parse a `{n}` / `{n,}` / `{n,m}` counted quantifier at `source[at]` (`'{'`).\n  // Returns the bounds and the token length, or null when it isn't a well-formed\n  // brace quantifier (then the `{` is left for the caller's metachar decline).\n  const braceQuant = (at: number): { min: number; max: number; len: number } | null => {\n    const close = source.indexOf('}', at)\n    if (close === -1) return null\n    const body = source.slice(at + 1, close)\n    const m = /^(\\d+)(,(\\d*)?)?$/.exec(body)\n    if (!m) return null\n    const min = Number(m[1])\n    const max = m[2] === undefined ? min : m[3] ? Number(m[3]!) : Infinity\n    // Decline degenerate/empty-capable or invalid bounds \u2014 RegExp handles them.\n    if (max < 1 || min > max) return null\n    return { min, max, len: close - at + 1 }\n  }\n  const runFrom = (ranges: Array<[number, number]>, negated: boolean, at: number) => {\n    const q = source[at]\n    if (q === '+') { parts.push({ part: 'run', ranges, negated, min: 1, max: Infinity }); return 1 }\n    if (q === '*') { parts.push({ part: 'run', ranges, negated, min: 0, max: Infinity }); return 1 }\n    if (q === '?') { parts.push({ part: 'run', ranges, negated, min: 0, max: 1 }); return 1 }\n    if (q === '{') {\n      const b = braceQuant(at)\n      if (b) { parts.push({ part: 'run', ranges, negated, min: b.min, max: b.max }); return b.len }\n    }\n    parts.push({ part: 'run', ranges, negated, min: 1, max: 1 })\n    return 0\n  }\n  let i = 0\n  while (i < source.length) {\n    const ch = source[i]!\n    if (ch === '[') {\n      // Read a char class, honoring `\\]`.\n      let k = i + 1\n      const neg = source[k] === '^'\n      if (neg) k++\n      let body = ''\n      while (k < source.length && source[k] !== ']') {\n        if (source[k] === '\\\\') { body += source[k]! + (source[k + 1] ?? ''); k += 2 }\n        else { body += source[k]!; k++ }\n      }\n      if (source[k] !== ']') return null\n      const ranges = parseClassRanges(body)\n      if (!ranges) return null\n      flush()\n      i = k + 1\n      i += runFrom(ranges, neg, i)\n      continue\n    }\n    if (ch === '\\\\') {\n      const e = source[i + 1]\n      if (e === 'd' || e === 'w' || e === 's') {\n        flush()\n        i += 2\n        i += runFrom(shorthandRanges(e), false, i)\n        continue\n      }\n      // Escaped literal code point (incl. `\\uXXXX`, `\\t`, `\\(`, \u2026).\n      const uni = readUnicodeEscape(source, i)\n      let cp: number\n      if (uni) { cp = uni.cp; i = uni.next }\n      else if (e === undefined) return null\n      else if (e in CLASS_ESCAPES) { cp = CLASS_ESCAPES[e]!; i += 2 }\n      else if ((e >= 'a' && e <= 'z') || (e >= 'A' && e <= 'Z')) return null\n      else { cp = e.codePointAt(0)!; i += 2 }\n      if (source[i] === '?') { flush(); parts.push({ part: 'lit', cps: [cp], optional: true }); i++ }\n      else lit.push(cp)\n      continue\n    }\n    if (ch === '(') {\n      // Only a non-capturing group `(?:\u2026)` is modeled (\u00A78f) \u2014 a bare capturing\n      // group, or a lookaround appearing mid-pattern (a TRAILING one is peeled\n      // off separately by `stripTrailingLookahead` before we ever get here), is\n      // declined outright rather than risk misreading it.\n      if (source[i + 1] !== '?' || source[i + 2] !== ':') return null\n      let k = i + 3\n      let depth = 1\n      while (k < source.length && depth > 0) {\n        const c2 = source[k]\n        if (c2 === '\\\\') { k += 2; continue }\n        if (c2 === '[') {\n          let j = k + 1\n          if (source[j] === '^') j++\n          while (j < source.length && source[j] !== ']') {\n            if (source[j] === '\\\\') j += 2\n            else j++\n          }\n          if (source[j] !== ']') return null\n          k = j + 1\n          continue\n        }\n        if (c2 === '(') depth++\n        else if (c2 === ')') depth--\n        k++\n      }\n      if (depth !== 0) return null\n      const body = source.slice(i + 3, k - 1)\n      const inner = parseScanShape(body)\n      if (!inner || !groupInnerSafe(inner)) return null\n      const q = source[k]\n      // `{n,m}` on a group is a \u00A78c/\u00A78f combination not modeled \u2014 decline.\n      if (q === '{') return null\n      flush()\n      if (q === '+') {\n        if (shapeCanBeEmpty(inner)) return null // would loop forever \u2014 decline\n        parts.push({ part: 'group', inner, min: 1, unbounded: true })\n        i = k + 1\n      } else if (q === '*') {\n        if (shapeCanBeEmpty(inner)) return null\n        parts.push({ part: 'group', inner, min: 0, unbounded: true })\n        i = k + 1\n      } else if (q === '?') {\n        parts.push({ part: 'group', inner, min: 0, unbounded: false })\n        i = k + 1\n      } else {\n        parts.push({ part: 'group', inner, min: 1, unbounded: false })\n        i = k\n      }\n      continue\n    }\n    // A bare metachar (`|`, `.`, `{`, stray `*`/`+`/`?`, \u2026) is outside the\n    // linear-chain category \u2014 bail to the RegExp fallback.\n    if (META.has(ch)) return null\n    const cp = ch.codePointAt(0)!\n    i += ch.length\n    if (source[i] === '?') { flush(); parts.push({ part: 'lit', cps: [cp], optional: true }); i++ }\n    else lit.push(cp)\n  }\n  flush()\n  return parts.length ? parts : null\n}\n\n/**\n * Only lower a `seq` when greedy left-to-right scanning matches EXACTLY what the\n * backtracking regex engine would. The dangerous cases are (a) an optional part\n * that could also be consumed by what follows, and (b) an unbounded/repeated\n * part whose accepted class overlaps what follows \u2014 both let the engine\n * backtrack to a different boundary than a one-pass scan. We also require at\n * least one mandatory segment (so the token can't match zero-width).\n *\n * A skippable/repeatable part `p` at index `k` is checked against\n * `seqFirstAccept(parts.slice(k + 1))` \u2014 the accept-set of EVERYTHING that\n * could start at the very next position, unioned through any further chain of\n * optionals up to the next mandatory part (the exact same computation\n * `seqFirstAccept` already does for a seq's OWN leading accept-set). This\n * subsumes the simpler \"check only the immediate neighbor\" rule as the\n * one-part-following case, while also correctly handling a CHAIN of several\n * consecutive optional parts (e.g. two independent optional groups in a row,\n * `(?:\\.\\d+)?(?:[eE][+-]?\\d+)?` \u2014 JSON/GraphQL's number tail, \u00A78f): each is\n * safe precisely when disjoint from everything that could follow it, however\n * many further optionals that spans. An empty tail (`p` is the last part)\n * naturally resolves to a trivially-disjoint empty set \u2014 nothing to check.\n *\n * Uniform across `lit`/`run`/`group`: each part's own \"first char it could\n * start with\" (`partFirstAccept`) is compared via `firstSetsDisjoint` \u2014 the\n * same subset/disjoint math used everywhere else in this file (\u00A78b's\n * lookahead guard, \u00A78e's alt-dispatch guard).\n */\nfunction seqIsUnambiguous(parts: SeqPart[]): boolean {\n  let hasMandatory = false\n  for (let k = 0; k < parts.length; k++) {\n    const p = parts[k]!\n    const mandatory = p.part === 'lit' ? !p.optional : p.min >= 1\n    if (mandatory) hasMandatory = true\n    // A `group` part has a right-edge exposure (`groupPartExposure`): the chars a\n    // backtracking engine could give back by shrinking the body's own trailing\n    // quantifier, dropping the group (if optional/repeated), or \u2014 for a\n    // non-disjoint alt body \u2014 switching arms. Ordered-choice greedy scanning\n    // matches the engine only when NONE of those relinquished chars could also\n    // start what follows the group (else the scan and the engine disagree on\n    // where the group ends). Two outcomes:\n    //   - a concrete class \u2192 must be disjoint from `seqFirstAccept(rest)`. This\n    //     is the general fix for a group whose body ends in an unbounded run\n    //     (`(?:\\d+)\\d` must NOT lower), and it lets a mutually-exclusive fixed\n    //     alt (\u00A78i, exposure `null`) lower at ANY position, not just trailing.\n    //   - `'unsupported'` \u2192 the exposure can't be bounded (e.g. a non-disjoint\n    //     alt like `(?:a|ab)` that genuinely needs arm-switching). Sound only\n    //     when nothing follows to force reconsideration \u2014 the group must be the\n    //     trailing, matched-exactly-once part (\u00A78h); otherwise decline.\n    if (p.part === 'group') {\n      const exposure = groupPartExposure(p)\n      if (exposure === 'unsupported') {\n        const trailingOnce = k === parts.length - 1 && p.min === 1 && !p.unbounded\n        if (!trailingOnce) return false\n      } else if (exposure !== null) {\n        if (!firstSetsDisjoint(exposure, seqFirstAccept(parts.slice(k + 1)))) return false\n      }\n    }\n    // A part needs the disjoint-from-continuation check when a greedy one-pass\n    // scan has freedom a backtracking engine could resolve differently: an\n    // optional `lit`, a `run` with wiggle (`max > min` \u2014 covers `?`/`*`/`+` and\n    // bounded `{n,m}` with `m > n`; a fixed `{n}` run has none), or an\n    // optional/repeated `group`. A fixed-length run (`max === min`) consumes an\n    // exact count with no boundary to shift, so it never needs the check.\n    const needsDisjoint =\n      p.part === 'lit' ? p.optional\n      : p.part === 'run' ? p.max > p.min\n      : (p.unbounded || p.min === 0)\n    if (needsDisjoint) {\n      const rest = seqFirstAccept(parts.slice(k + 1))\n      if (!firstSetsDisjoint(partFirstAccept(p), rest)) return false\n    }\n  }\n  return hasMandatory\n}\n\nfunction rangesOverlap(a: Array<[number, number]>, b: Array<[number, number]>): boolean {\n  return a.some(([lo, hi]) => b.some(([lo2, hi2]) => lo <= hi2 && lo2 <= hi))\n}\n\n/** Is every range in `sub` fully contained in some range of `sup`? */\nfunction rangesSubset(sub: Array<[number, number]>, sup: Array<[number, number]>): boolean {\n  return sub.every(([lo, hi]) => sup.some(([lo2, hi2]) => lo >= lo2 && hi <= hi2))\n}\n\n/**\n * A `(?!X)`/`(?=X)` operand: a char class (`[...]`, incl. `[^...]`), a\n * shorthand class (`\\d`/`\\w`/`\\s`), or a single literal/escaped char \u2014 never a\n * sub-pattern (no alternation, no nested groups). Returns the ranges to test\n * membership against, and whether the bracket itself was negated (`[^...]`) \u2014\n * independent of the lookahead's own `!`/`=` polarity.\n */\nfunction parseClassOperand(body: string): { ranges: Array<[number, number]>; negated: boolean } | null {\n  if (body === '\\\\d' || body === '\\\\w' || body === '\\\\s') {\n    return { ranges: shorthandRanges(body[1] as 'd' | 'w' | 's'), negated: false }\n  }\n  if (body.length >= 2 && body[0] === '[' && body[body.length - 1] === ']') {\n    let inner = body.slice(1, -1)\n    const negated = inner.startsWith('^')\n    if (negated) inner = inner.slice(1)\n    const ranges = parseClassRanges(inner)\n    return ranges ? { ranges, negated } : null\n  }\n  const cps = literalCodePoints(body)\n  if (cps && cps.length === 1) return { ranges: [[cps[0]!, cps[0]!]], negated: false }\n  return null\n}\n\ntype TrailingLookahead = {\n  base: string\n  ranges: Array<[number, number]>\n  classNegated: boolean\n  negative: boolean\n}\n\ntype CharSet = { ranges: Array<[number, number]>; negated: boolean }\n\n/** Is char-set `t` fully contained in char-set `u`? Handles all 4 sign combos. */\nfunction classSubset(t: CharSet, u: CharSet): boolean {\n  if (!t.negated && !u.negated) return rangesSubset(t.ranges, u.ranges)\n  if (!t.negated && u.negated) return !rangesOverlap(t.ranges, u.ranges) // t \u2286 \u00ACu \u27FA t \u2229 u = \u2205\n  if (t.negated && !u.negated) return false // \u00ACt \u2286 u is never true for finite ranges u\n  return rangesSubset(u.ranges, t.ranges) // \u00ACt \u2286 \u00ACu \u27FA u \u2286 t\n}\n\n/** Are char-sets `t` and `u` disjoint (no overlap)? Handles all 4 sign combos. */\nfunction classDisjoint(t: CharSet, u: CharSet): boolean {\n  if (!t.negated && !u.negated) return !rangesOverlap(t.ranges, u.ranges)\n  if (!t.negated && u.negated) return rangesSubset(t.ranges, u.ranges) // t \u2229 \u00ACu = \u2205 \u27FA t \u2286 u\n  if (t.negated && !u.negated) return rangesSubset(u.ranges, t.ranges) // symmetric\n  return false // \u00ACt \u2229 \u00ACu = \u2205 would require t \u222A u = every code point \u2014 can't prove with finite ranges\n}\n\n/** `classDisjoint`, `'any'`-aware: an empty-capable part's first-set degrades\n * to `'any'` (see `shapeFirstAccept`), and `'any'` is never disjoint from\n * anything (it could start with literally any char, including whatever the\n * other side accepts). */\nfunction firstSetsDisjoint(a: CharSet | 'any', b: CharSet | 'any'): boolean {\n  if (a === 'any' || b === 'any') return false\n  return classDisjoint(a, b)\n}\n\n/**\n * A shape's match as a fixed-length list of per-position char-sets, or `null`\n * if its match length is NOT fixed. Only a `seq` of mandatory `lit`s (each code\n * point is one fixed position) and mandatory single-char runs (`[x]`, min 1,\n * bounded) qualifies \u2014 anything with an optional part, an unbounded/optional\n * run, or a nested group has a variable length and returns `null`. Used to\n * decide when a non-disjoint alternation's arms are mutually exclusive (\u00A78i).\n */\nfunction fixedClassSeq(shape: ScanShape): CharSet[] | null {\n  // A case-fold literal is fixed-length: each code point becomes a single-char\n  // class holding BOTH ASCII cases (so mutual-exclusivity is judged on what the\n  // `/i` match actually accepts \u2014 `and` vs `or` are disjoint at position 0).\n  if (shape.kind === 'litFold') {\n    return shape.open.map(cp => {\n      const other = cp >= 65 && cp <= 90 ? cp + 32 : cp >= 97 && cp <= 122 ? cp - 32 : cp\n      return other === cp\n        ? { ranges: [[cp, cp]] as Array<[number, number]>, negated: false }\n        : { ranges: [[Math.min(cp, other), Math.min(cp, other)], [Math.max(cp, other), Math.max(cp, other)]] as Array<[number, number]>, negated: false }\n    })\n  }\n  if (shape.kind !== 'seq') return null\n  const out: CharSet[] = []\n  for (const p of shape.parts) {\n    if (p.part === 'lit') {\n      if (p.optional) return null\n      for (const cp of p.cps) out.push({ ranges: [[cp, cp]], negated: false })\n    } else if (p.part === 'run' && p.max === p.min && Number.isFinite(p.max)) {\n      // A fixed-count run `[x]{n}` (incl. the bare `[x]`, n=1) is n fixed\n      // positions of the same class. Variable-length runs return null below.\n      for (let c = 0; c < p.max; c++) out.push({ ranges: p.ranges, negated: p.negated })\n    } else {\n      return null // optional/variable/unbounded run, or a nested group \u2014 length not fixed\n    }\n  }\n  return out.length ? out : null\n}\n\n/**\n * \u00A78i \u2014 is a NON-disjoint `alt` shape one whose arms are pairwise MUTUALLY\n * EXCLUSIVE fixed-length token sets? Every arm must be a `fixedClassSeq`, and no\n * arm's match may ever be a prefix (proper, or an equal-length overlap) of\n * another arm's \u2014 i.e. for every ordered pair (A, B) with `A.length <= B.length`\n * there is a position within A where their classes are DISJOINT. That property\n * guarantees at most one arm matches at any input position, so ordered-choice\n * commit lands on the SAME arm (and the SAME fixed end) the engine would, with\n * no arm to switch to under backtracking \u2014 sound in ANY position, not just\n * trailing (unlike the general non-disjoint alt, which needs the trailing-once\n * gate in `seqIsUnambiguous`). `(?:ab|ac)` and `(?:foo|barn)` qualify;\n * `(?:a|ab)` (arm `a` is a prefix of `ab`) does NOT.\n */\nfunction altFixedMutuallyExclusive(shape: ScanShape): boolean {\n  if (shape.kind !== 'alt' || shape.disjoint) return false\n  const lists: CharSet[][] = []\n  for (const arm of shape.arms) {\n    const f = fixedClassSeq(arm)\n    if (!f) return false\n    lists.push(f)\n  }\n  for (let i = 0; i < lists.length; i++) {\n    for (let j = 0; j < lists.length; j++) {\n      if (i === j) continue\n      const a = lists[i]!\n      const b = lists[j]!\n      if (a.length > b.length) continue // only check the shorter (a) as a prefix of the longer (b)\n      let disjointAt = false\n      for (let p = 0; p < a.length; p++) {\n        if (classDisjoint(a[p]!, b[p]!)) { disjointAt = true; break }\n      }\n      if (!disjointAt) return false // `a` could be a prefix of `b` \u2014 not mutually exclusive\n    }\n  }\n  return true\n}\n\n/**\n * The char-set a backtracking engine could relinquish at a `group` PART's right\n * edge \u2014 its \"trailing exposure\". Combines two independent backtrack moves: the\n * group body's OWN trailing wiggle (`trailingBacktrackClass(inner)`, e.g. the\n * body ends in an unbounded run), and \u2014 if the group is optional (`min 0`) or\n * repeated (`unbounded`) \u2014 the \"drop the last occurrence\" move, which exposes\n * the body's own first-char set. A required-once group (`min 1`, bounded) has\n * only the first move. Returns `'unsupported'` if either component can't be\n * pinned to a concrete set. This is the single computation used everywhere a\n * group's right boundary matters: `trailingBacktrackClass` (a `seq` ending in a\n * group) and `seqIsUnambiguous` (a group at ANY position, followed by more).\n */\nfunction groupPartExposure(part: Extract<SeqPart, { part: 'group' }>): CharSet | null | 'unsupported' {\n  const innerWiggle = trailingBacktrackClass(part.inner)\n  if (innerWiggle === 'unsupported') return 'unsupported'\n  const requiredOnce = !part.unbounded && part.min === 1\n  if (requiredOnce) return innerWiggle // no \"drop it\" move possible \u2014 only inner's own wiggle matters\n  const dropExposed = shapeFirstAccept(part.inner)\n  if (dropExposed === 'any') return 'unsupported'\n  if (innerWiggle === null) return dropExposed\n  const unioned = unionCharSets([innerWiggle, dropExposed])\n  return unioned === 'any' ? 'unsupported' : unioned\n}\n\n/**\n * The char-class a backtracking engine could expose by shrinking `shape`'s\n * OWN trailing quantifier by one position \u2014 i.e. the \"wiggle room\" a trailing\n * lookahead could interact with. Returns `null` when `shape`'s matched length\n * is fully fixed once it succeeds (no quantifier to shrink), which makes\n * wrapping it in a lookahead unconditionally safe. Returns `'unsupported'` for\n * shape kinds whose backtracking semantics aren't modeled here (declines the\n * lookahead lowering rather than risking an unproven guard).\n *\n * Only the LAST quantifier matters: `seqIsUnambiguous` already proves every\n * EARLIER part of a `seq` has exactly one valid parse (no alternate length),\n * so the sole remaining freedom a backtracking engine has \u2014 once we attach an\n * external trailing lookahead \u2014 is in whatever quantifier sits at the very end.\n */\nfunction trailingBacktrackClass(shape: ScanShape): CharSet | null | 'unsupported' {\n  if (shape.kind === 'chars') return { ranges: shape.ranges, negated: false }\n  if (shape.kind === 'ident') return { ranges: shape.tail, negated: false }\n  if (shape.kind === 'litFold') return null // fixed-length literal \u2014 no quantifier at all\n  if (shape.kind === 'seq') {\n    const last = shape.parts[shape.parts.length - 1]!\n    if (last.part === 'lit') return null // fixed literal tail \u2014 no wiggle room\n    if (last.part === 'run') {\n      // Wiggle iff `max > min`: unbounded (`+`/`*`/`{n,}`), optional (`[x]?`),\n      // or bounded `{n,m}` with `m > n` all let a backtracker shrink the trailing\n      // run by \u22651 position. A fixed run (`[x]`, `{n}`, `max === min`) has no\n      // choice \u2014 no wiggle, hence no risk.\n      if (last.max > last.min) return { ranges: last.ranges, negated: last.negated }\n      return null\n    }\n    // A trailing `group` (\u00A78f): its trailing exposure combines its body's own\n    // wiggle and (if optional/repeated) the \"drop it\" move \u2014 see\n    // `groupPartExposure`, shared with `seqIsUnambiguous`.\n    return groupPartExposure(last)\n  }\n  if (shape.kind === 'alt') {\n    // Arm-switching hazard (see `groupInnerSafe`) applies here too: a\n    // non-disjoint alt can't be trusted to expose the right wiggle class,\n    // since which arm ultimately \"wins\" could itself change under backtrack.\n    // A disjoint alt has no such hazard \u2014 exactly one arm is ever reachable\n    // from a given starting char, so the union of every arm's OWN wiggle\n    // covers whichever one is actually taken. A non-disjoint alt whose arms are\n    // fixed-length and mutually exclusive (\u00A78i) also has no wiggle \u2014 exactly one\n    // arm matches at any position and its length is fixed, so `null`.\n    if (!shape.disjoint) return altFixedMutuallyExclusive(shape) ? null : 'unsupported'\n    const classes = shape.arms.map(trailingBacktrackClass)\n    if (classes.some(c => c === 'unsupported')) return 'unsupported'\n    const concrete = classes.filter((c): c is CharSet => c !== null)\n    if (concrete.length === 0) return null\n    const unioned = unionCharSets(concrete)\n    return unioned === 'any' ? 'unsupported' : unioned\n  }\n  // `until`/`delimited`/`string`/nested `lookahead` \u2014 not modeled; decline.\n  return 'unsupported'\n}\n\n/**\n * Is it safe to lower `inner(?!ranges)` / `inner(?=ranges)` to a one-shot\n * post-match check (vs. requiring real backtracking)? See PERF_IDEAS \u00A78b.\n */\nfunction lookaheadUnambiguous(inner: ScanShape, operand: CharSet, negative: boolean): boolean {\n  const tail = trailingBacktrackClass(inner)\n  if (tail === 'unsupported') return false\n  if (tail === null) return true // inner's length is fixed \u2014 no backtracking possible\n  // Negative `(?!op)`: safe iff every char the tail could expose is ALSO\n  // excluded by `op` (so shrinking never turns a failure into a pass).\n  // Positive `(?=op)`: safe iff the tail is disjoint from `op` (so shrinking\n  // could never expose a char that suddenly satisfies `op`).\n  return negative ? classSubset(tail, operand) : classDisjoint(tail, operand)\n}\n\n/**\n * Strip a trailing `(?!class)` / `(?=class)` boundary assertion, if present.\n * Only a TRAILING lookahead with a char-class/single-char operand is\n * recognized \u2014 no sub-patterns, no nested groups. Anything else containing an\n * unescaped `(` is left to the other recognizers, which reject it as a\n * metachar (`META`) and fall back to `RegExp.exec`, so a false read here can\n * only fail to lower, never mis-lower.\n */\nfunction stripTrailingLookahead(source: string): TrailingLookahead | null {\n  if (!source.endsWith(')')) return null\n  for (const negative of [true, false] as const) {\n    const lead = negative ? '(?!' : '(?='\n    const idx = source.lastIndexOf(lead)\n    if (idx === -1) continue\n    const body = source.slice(idx + lead.length, -1)\n    const operand = body.length ? parseClassOperand(body) : null\n    if (!operand) continue\n    return { base: source.slice(0, idx), ranges: operand.ranges, classNegated: operand.negated, negative }\n  }\n  return null\n}\n\n/**\n * Strip ONE redundant outer `(?:\u2026)` wrapper, if it spans the ENTIRE source\n * (nothing before it, nothing \u2014 not even a quantifier \u2014 after its matching\n * close). A non-capturing group with no trailing quantifier is semantically\n * identical to its bare contents, so this is always safe to unwrap; it's what\n * lets `(?:a|b|c)` (a whole-token alternation written as idiomatic regex\n * style, e.g. CSS `basicSel`) reach the top-level `|` split below. Bails\n * (leaves `source` untouched) on anything that isn't a clean whole-string\n * wrap: unbalanced parens, or a group that closes before the string ends\n * (which would mean a quantifier or trailing content follows it).\n */\nfunction unwrapOuterGroup(source: string): string {\n  while (source.startsWith('(?:')) {\n    let depth = 1\n    let i = 3\n    let ok = true\n    while (i < source.length && depth > 0) {\n      const ch = source[i]\n      if (ch === '\\\\') { i += 2; continue }\n      if (ch === '[') {\n        let j = i + 1\n        if (source[j] === '^') j++\n        while (j < source.length && source[j] !== ']') {\n          if (source[j] === '\\\\') j += 2\n          else j++\n        }\n        if (source[j] !== ']') { ok = false; break }\n        i = j + 1\n        continue\n      }\n      if (ch === '(') depth++\n      else if (ch === ')') depth--\n      i++\n    }\n    if (!ok || depth !== 0 || i !== source.length) break\n    source = source.slice(3, -1)\n  }\n  return source\n}\n\n/**\n * Split a regex source on top-level `|` \u2014 i.e. `|` outside any `[]` bracket\n * class and outside any `(...)` group (parens still count toward depth even\n * though we don't otherwise understand groups; a `|` nested in one is never a\n * split point). Returns null if there's no top-level `|` at all, if brackets/\n * parens are unbalanced, or if any resulting alternative is empty (a\n * zero-width arm \u2014 an unmodeled edge case, decline rather than mis-lower).\n * One redundant whole-string `(?:\u2026)` wrapper is stripped first (see\n * `unwrapOuterGroup`) so `(?:a|b)` splits the same as bare `a|b`.\n */\nfunction splitTopLevelAlternation(source: string): string[] | null {\n  const body = unwrapOuterGroup(source)\n  const parts: string[] = []\n  let depth = 0\n  let last = 0\n  let i = 0\n  while (i < body.length) {\n    const ch = body[i]\n    if (ch === '\\\\') { i += 2; continue }\n    if (ch === '[') {\n      let j = i + 1\n      if (body[j] === '^') j++\n      while (j < body.length && body[j] !== ']') {\n        if (body[j] === '\\\\') j += 2\n        else j++\n      }\n      if (body[j] !== ']') return null\n      i = j + 1\n      continue\n    }\n    if (ch === '(') { depth++; i++; continue }\n    if (ch === ')') { depth--; if (depth < 0) return null; i++; continue }\n    if (ch === '|' && depth === 0) {\n      parts.push(body.slice(last, i))\n      last = i + 1\n      i++\n      continue\n    }\n    i++\n  }\n  if (depth !== 0) return null\n  parts.push(body.slice(last))\n  if (parts.length < 2 || parts.some(p => p.length === 0)) return null\n  return parts\n}\n\n/** Can `shape` match the empty string? Only an unbounded `chars` run with no\n * `+` (`[x]*`) can \u2014 every other shape requires at least one fixed/mandatory\n * char (`seq` always has \u22651 mandatory part per `seqIsUnambiguous`; `ident`/\n * `until`/`delimited`/`string`/`litFold` all require a fixed opening char). A\n * `lookahead`/`alt` defer to what they wrap. */\nfunction shapeCanBeEmpty(shape: ScanShape): boolean {\n  if (shape.kind === 'chars') return !shape.minOne\n  if (shape.kind === 'lookahead') return shapeCanBeEmpty(shape.inner)\n  if (shape.kind === 'alt') return shape.arms.some(shapeCanBeEmpty)\n  return false\n}\n\n/** Exact union of char-sets when it's computable, else `'any'` (conservative:\n * forces ordered dispatch rather than guessing at a mixed-polarity union, or\n * when any input is already `'any'`). A single concrete-set list is returned\n * as-is (including if negated) \u2014 the ambiguity is only in combining \u22652 sets\n * of differing polarity. */\nfunction unionCharSets(sets: Array<CharSet | 'any'>): CharSet | 'any' {\n  if (sets.some(s => s === 'any')) return 'any'\n  const concrete = sets as CharSet[]\n  if (concrete.length === 1) return concrete[0]!\n  if (concrete.some(s => s.negated)) return 'any'\n  return { ranges: concrete.flatMap(s => s.ranges), negated: false }\n}\n\n/** A single seq part's own first-char set, ignoring whether it's skippable.\n * A `group` part delegates to its inner shape's own first-set (\u00A78f) \u2014\n * possibly `'any'` if the inner shape can match empty or is a non-disjoint\n * `alt` (see `shapeFirstAccept`). */\nfunction partFirstAccept(part: SeqPart): CharSet | 'any' {\n  if (part.part === 'lit') return { ranges: [[part.cps[0]!, part.cps[0]!]], negated: false }\n  if (part.part === 'run') return { ranges: part.ranges, negated: part.negated }\n  return shapeFirstAccept(part.inner)\n}\n\n/** The char-set a `seq` can start with: union of each leading skippable part's\n * own set up to and including the first mandatory part (after which later\n * parts can no longer be what the very first input char matches). */\nfunction seqFirstAccept(parts: SeqPart[]): CharSet | 'any' {\n  const sets: Array<CharSet | 'any'> = []\n  for (const p of parts) {\n    const mandatory = p.part === 'lit' ? !p.optional : p.min >= 1\n    sets.push(partFirstAccept(p))\n    if (mandatory) break\n  }\n  return unionCharSets(sets)\n}\n\n/**\n * Is `inner` safe to use as a group's body (\u00A78f)? `chars`/`ident`/`seq`/\n * `litFold` are always safe: each is only ever constructed after proving (via\n * `seqIsUnambiguous` or equivalent) that greedy resolution is the UNIQUE valid\n * match at a given position \u2014 there is no alternate length for a backtracker\n * to reconsider, so treating the group as an atomic, resolve-once unit is\n * sound regardless of what follows it. A `lookahead` defers to what it wraps\n * (zero-width, adds no new choice). An `alt` is safe ONLY when `disjoint`:\n * a NON-disjoint alt (`(?:a|ab)`) genuinely can need real backtracking into a\n * DIFFERENT arm if something after the group fails (verified: `/^(?:a|ab)c/`\n * matches \"abc\" via the SECOND arm, only because the first arm's match left\n * \"c\" unsatisfied) \u2014 our ordered-dispatch codegen resolves once and never\n * reconsiders, so that case must decline. `until`/`delimited`/`string` are\n * declined outright, same conservative call as `trailingBacktrackClass`.\n */\nfunction groupInnerSafe(shape: ScanShape): boolean {\n  if (shape.kind === 'chars' || shape.kind === 'ident' || shape.kind === 'seq' || shape.kind === 'litFold') return true\n  if (shape.kind === 'lookahead') return groupInnerSafe(shape.inner)\n  // A disjoint alt is safe anywhere. A NON-disjoint alt is admitted here too,\n  // but its ordered-choice-commit is only sound in the trailing-once position \u2014\n  // `seqIsUnambiguous` (\u00A78h) enforces that positional constraint; a non-trailing\n  // or optional/repeated non-disjoint-alt group is rejected there.\n  if (shape.kind === 'alt') return true\n  return false\n}\n\n/**\n * The set of first chars a NON-EMPTY match of `shape` could start with, or\n * `'any'` if that can't be pinned down to a single char-set (used to decide\n * whether `alt` arms have disjoint first-sets). A shape that can match empty\n * degrades to `'any'`: since it could succeed with zero chars regardless of\n * what follows, it would \"accept\" any first char by never actually needing one\n * \u2014 treating that as disjoint from anything else would be unsound.\n */\nfunction shapeFirstAccept(shape: ScanShape): CharSet | 'any' {\n  if (shapeCanBeEmpty(shape)) return 'any'\n  switch (shape.kind) {\n    case 'chars': return { ranges: shape.ranges, negated: false }\n    case 'ident': return { ranges: shape.head, negated: false }\n    case 'until': return { ranges: [[shape.open[0]!, shape.open[0]!]], negated: false }\n    case 'delimited': return { ranges: [[shape.open[0]!, shape.open[0]!]], negated: false }\n    case 'string': return { ranges: [[shape.quote, shape.quote]], negated: false }\n    case 'litFold': {\n      const cp = shape.open[0]!\n      if (cp >= 65 && cp <= 90) return { ranges: [[cp, cp], [cp + 32, cp + 32]], negated: false }\n      if (cp >= 97 && cp <= 122) return { ranges: [[cp, cp], [cp - 32, cp - 32]], negated: false }\n      return { ranges: [[cp, cp]], negated: false }\n    }\n    case 'seq': return seqFirstAccept(shape.parts)\n    case 'lookahead': return shapeFirstAccept(shape.inner) // zero-width \u2014 doesn't change first-char acceptance\n    case 'alt': {\n      // The set of first chars is the union of every arm's own first-set,\n      // independent of whether the arms are mutually disjoint (that flag only\n      // governs dispatch, not what the shape can start with). Any arm whose\n      // first-set is itself `'any'` (stored as `null`) makes the union `'any'`.\n      const sets = shape.firsts.map((f): CharSet | 'any' => (f === null ? 'any' : f))\n      return unionCharSets(sets)\n    }\n  }\n}\n\n/** True iff every pair of `sets` is provably disjoint; `'any'` is disjoint from nothing. */\nfunction allPairsDisjoint(sets: Array<CharSet | 'any'>): boolean {\n  for (let i = 0; i < sets.length; i++) {\n    const a = sets[i]!\n    if (a === 'any') return false\n    for (let j = i + 1; j < sets.length; j++) {\n      const b = sets[j]!\n      if (b === 'any' || !classDisjoint(a, b)) return false\n    }\n  }\n  return true\n}\n\n/**\n * Recognize top-level alternation `A|B|C` (\u00A78e): split on `|` outside any\n * `[]`/`()`, lower each arm independently (an arm may itself be a `seq`,\n * `chars`, `lookahead`, \u2026, or even nested alternation via one redundant\n * `(?:\u2026)` wrapper \u2014 see `unwrapOuterGroup`). Declines (null) unless EVERY arm\n * independently lowers \u2014 a single unsupported arm (e.g. one with a nested\n * capturing/non-capturing group, \u00A78f) falls the whole alternation back to\n * `RegExp.exec` rather than partially lowering.\n */\nfunction parseAlternation(source: string): ScanShape | null {\n  const parts = splitTopLevelAlternation(source)\n  if (!parts) return null\n  const arms: ScanShape[] = []\n  for (const p of parts) {\n    const arm = parseScanShape(p)\n    if (!arm) return null\n    arms.push(arm)\n  }\n  const firstSets = arms.map(shapeFirstAccept)\n  const disjoint = allPairsDisjoint(firstSets)\n  return { kind: 'alt', arms, disjoint, firsts: firstSets.map(f => (f === 'any' ? null : f)) }\n}\n\n/**\n * Recognize one scannable arm from its regex source, or null if it isn't one of\n * the structural shapes. Top-level alternation (\u00A78e) is tried FIRST \u2014 `|` has\n * the lowest precedence in regex, so splitting on it happens before anything\n * else, with each arm then recursively re-entering this same function (so an\n * arm's own trailing lookahead, or its own nested `(?:\u2026)`-wrapped alternation,\n * is still recognized). Failing that: char-class run, ident, string, then\n * open-until-terminator, delimited, and finally the general linear `seq` chain.\n * A trailing `(?!class)`/`(?=class)` is peeled off next (\u00A78b) and re-wraps\n * whatever shape the remaining base recognizes as.\n */\nexport function parseScanShape(source: string): ScanShape | null {\n  const alt = parseAlternation(source)\n  if (alt) return alt\n  const la = stripTrailingLookahead(source)\n  if (la) {\n    const inner = parseScanShapeCore(la.base)\n    if (!inner) return null\n    const operand: CharSet = { ranges: la.ranges, negated: la.classNegated }\n    if (!lookaheadUnambiguous(inner, operand, la.negative)) return null\n    return { kind: 'lookahead', inner, ranges: la.ranges, classNegated: la.classNegated, negative: la.negative }\n  }\n  return parseScanShapeCore(source)\n}\n\n/**\n * Split a regex fragment on top-level `|` (outside `[]`/`()`), escape-aware.\n * Unlike `splitTopLevelAlternation` this allows a SINGLE arm (no `|` at all) and\n * does not unwrap an outer group \u2014 it's used to enumerate the arms of a\n * `delimited` body, which may legitimately be one bare arm (`[^x]`). Returns\n * null on unbalanced brackets/parens.\n */\nfunction splitDelimArms(body: string): string[] | null {\n  const arms: string[] = []\n  let depth = 0\n  let last = 0\n  let i = 0\n  while (i < body.length) {\n    const ch = body[i]\n    if (ch === '\\\\') { i += 2; continue }\n    if (ch === '[') {\n      let j = i + 1\n      if (body[j] === '^') j++\n      while (j < body.length && body[j] !== ']') {\n        if (body[j] === '\\\\') j += 2\n        else j++\n      }\n      if (body[j] !== ']') return null\n      i = j + 1\n      continue\n    }\n    if (ch === '(') { depth++; i++; continue }\n    if (ch === ')') { depth--; if (depth < 0) return null; i++; continue }\n    if (ch === '|' && depth === 0) { arms.push(body.slice(last, i)); last = i + 1 }\n    i++\n  }\n  if (depth !== 0) return null\n  arms.push(body.slice(last))\n  return arms\n}\n\n/**\n * Prove that the `delimited` lowering \u2014 \"scan the raw input to the first full\n * `close` literal, ignoring the body entirely\" \u2014 is EQUIVALENT to the real regex\n * `<open>(?:body)*<close>`. That equivalence holds iff `(?:body)*` can never\n * match a string that contains the `close` literal: then greedy repetition stops\n * exactly before the first `close`, which is where the scan lands too.\n *\n * We only PROVE this for the block-comment idiom (the sole shape that expresses\n * \"any char that doesn't form the close\"):\n *\n *   n === 1 (`close` is one char l0):   body must be exactly `[^l0]`.\n *   n === 2 (`close` is `l0 l1`):       body must be exactly `[^l0] | l0(?!l1)`.\n *\n * In both the bulk arm `[^l0]` consumes every char except l0, and the guard arm\n * (n === 2) consumes l0 only when it is NOT followed by l1 \u2014 so the body admits\n * l0 but never the full `l0 l1`, and rejects NOTHING else (a body that excluded\n * some non-close char would stop early while the raw scan skipped ahead to the\n * next close, diverging). Anything outside this template \u2014 an alternation whose\n * arms can consume the close (`z(?:a|[0-2]+)*a`), a bulk class narrower/wider\n * than `[^l0]`, a longer close, extra arms \u2014 is declined, falling through to\n * `RegExp.exec`. Sound-by-construction: we only ever return true for a body we\n * can prove never contains `close`.\n */\nfunction delimitedBodySound(body: string, close: number[]): boolean {\n  const l0 = close[0]!\n  if (close.length > 2) return false\n  const arms = splitDelimArms(body)\n  if (!arms) return false\n  let bulkSeen = false\n  let guardSeen = false\n  for (const arm of arms) {\n    // Bulk arm: a bare negated class `[^l0]` \u2014 excluded set is exactly {l0}.\n    const bulk = /^\\[\\^((?:\\\\.|[^\\]])+)\\]$/.exec(arm)\n    if (bulk) {\n      if (bulkSeen) return false\n      const ranges = parseClassRanges(bulk[1]!)\n      if (!ranges || ranges.length !== 1 || ranges[0]![0] !== l0 || ranges[0]![1] !== l0) return false\n      bulkSeen = true\n      continue\n    }\n    // Guard arm (n === 2 only): `l0(?!l1)` \u2014 consume l0 unless it starts the close.\n    if (close.length === 2 && arm.endsWith(')')) {\n      const idx = arm.indexOf('(?!')\n      if (idx === -1) return false\n      const prefix = literalCodePoints(arm.slice(0, idx))\n      const op = parseClassOperand(arm.slice(idx + 3, -1))\n      const prefixIsL0 = prefix?.length === 1 && prefix[0] === l0\n      const forbidsL1 = op && !op.negated && op.ranges.length === 1 &&\n        op.ranges[0]![0] === close[1] && op.ranges[0]![1] === close[1]\n      if (!prefixIsL0 || !forbidsL1 || guardSeen) return false\n      guardSeen = true\n      continue\n    }\n    return false\n  }\n  // Require the exact arm set: bulk always; guard iff the close is two chars.\n  return bulkSeen && guardSeen === (close.length === 2)\n}\n\n/**\n * Structurally recognize `<openLit>(?:<body>)*<closeLit>` \u2014 literal opener, a\n * single non-capturing `*`-repeated group, literal closer \u2014 and lower it to a\n * `delimited` scan ONLY when `delimitedBodySound` proves the body can't contain\n * the close. Returns null (\u2192 fall through to `seq`/`RegExp.exec`) otherwise.\n */\nfunction parseDelimited(source: string): ScanShape | null {\n  // An escape-aware body (a literal `\\\\` in the source \u21D2 string-like) is handled\n  // by `parseStringShape`; here \"scan to first close\" would wrongly stop at an\n  // escaped delimiter, so decline.\n  if (source.includes('\\\\\\\\')) return null\n  // Opener: literal chars up to the first unescaped `(`, which must open `(?:`.\n  let i = 0\n  while (i < source.length && source[i] !== '(') {\n    i += source[i] === '\\\\' ? 2 : 1\n  }\n  if (source[i] !== '(' || source[i + 1] !== '?' || source[i + 2] !== ':') return null\n  const openFrag = source.slice(0, i)\n  // Balanced scan of the group body to its matching `)`.\n  let k = i + 3\n  let depth = 1\n  while (k < source.length && depth > 0) {\n    const ch = source[k]\n    if (ch === '\\\\') { k += 2; continue }\n    if (ch === '[') {\n      let j = k + 1\n      if (source[j] === '^') j++\n      while (j < source.length && source[j] !== ']') {\n        if (source[j] === '\\\\') j += 2\n        else j++\n      }\n      if (source[j] !== ']') return null\n      k = j + 1\n      continue\n    }\n    if (ch === '(') depth++\n    else if (ch === ')') depth--\n    k++\n  }\n  if (depth !== 0) return null\n  const body = source.slice(i + 3, k - 1)\n  if (source[k] !== '*') return null\n  const closeFrag = source.slice(k + 1)\n  const open = literalCodePoints(openFrag)\n  const close = literalCodePoints(closeFrag)\n  if (!open || !close || !delimitedBodySound(body, close)) return null\n  return { kind: 'delimited', open, close }\n}\n\nfunction parseScanShapeCore(source: string): ScanShape | null {\n  // [X]+ / [X]* \u2014 a positive char-class run. A negated `[^X]+`/`[^X]*` is left to\n  // the general `seq` path (which lowers `[^X]+` and declines zero-width `[^X]*`).\n  let m = /^\\[((?:\\\\.|[^\\]])+)\\]([+*])$/.exec(source)\n  if (m && !m[1]!.startsWith('^')) {\n    const ranges = parseClassRanges(m[1]!)\n    return ranges ? { kind: 'chars', ranges, minOne: m[2] === '+' } : null\n  }\n  // \\d+ / \\w+ / \\s+ / \\d* / \\w* / \\s* \u2014 a bare shorthand-class run.\n  m = /^\\\\([dws])([+*])$/.exec(source)\n  if (m) {\n    return { kind: 'chars', ranges: shorthandRanges(m[1] as 'd' | 'w' | 's'), minOne: m[2] === '+' }\n  }\n  // <head><tail>* \u2014 identifier run: one head char, then a run of tail chars.\n  m = /^(\\[(?:\\\\.|[^\\]])+\\]|\\\\[dws])(\\[(?:\\\\.|[^\\]])+\\]|\\\\[dws])\\*$/.exec(source)\n  if (m) {\n    const head = classToRanges(m[1]!)\n    const tail = classToRanges(m[2]!)\n    if (head && tail) return { kind: 'ident', head, tail }\n  }\n  // <q>(?:[^q\\\\]|\\\\.)*<q> \u2014 a quote-delimited string with escapes.\n  const str = parseStringShape(source)\n  if (str) return str\n  // <lit>[^X]* \u2014 consume a literal opener, then run until a terminator char.\n  m = /^(.*?)\\[\\^((?:\\\\.|[^\\]])+)\\]\\*$/.exec(source)\n  if (m) {\n    const open = literalCodePoints(m[1]!)\n    const stop = parseClassRanges(m[2]!)\n    if (open && stop) return { kind: 'until', open, stop }\n  }\n  // <open>(?:\u2026)*<close> \u2014 delimited token scanned to its first close literal.\n  // Only lowered when the body provably can't contain the close (see\n  // `parseDelimited` / `delimitedBodySound`); any other `X(?:\u2026)*Y` declines here\n  // and falls through to the `seq` path / `RegExp.exec`.\n  const delim = parseDelimited(source)\n  if (delim) return delim\n  // General category: a linear chain of literals + char runs (optional prefixes,\n  // literal openers, negated runs), lowered only when unambiguously greedy.\n  const parts = parseSeqParts(source)\n  if (parts && seqIsUnambiguous(parts)) return { kind: 'seq', parts }\n  return null\n}\n\n/**\n * Flag-aware wrapper around `parseScanShape`. Lowering to a raw code-point scan\n * assumes default regex semantics, so any flag that changes matching (`i` case\n * folding, `u` surrogate handling, `m`/`s` anchor/dot behavior) disables it.\n * `g`/`y` are stickiness-only and safe.\n */\nexport function scanShapeFromRegex(source: string, flags: string): ScanShape | null {\n  if (/[msu]/.test(flags)) return null\n  if (/i/.test(flags)) return caseFoldShape(source)\n  return parseScanShape(source)\n}\n\n/**\n * Case-insensitive (`/i`) scannable shapes. Beyond a pure case-fold literal\n * (`litFold`), this recognizes a top-level alternation of literals (an ordered\n * `alt` of litFolds \u2014 CSS `(?:and|or)`, `(?:media|container|supports)`), each\n * optionally wrapped in a trailing lookahead boundary (`(?![-\\w])`, `(?=\\()`).\n * That last form is the regex spelling of `makeWord` \u2014 a keyword plus a word\n * boundary \u2014 the common CSS at-rule/keyword dispatcher. Anything else declines\n * (\u2192 `RegExp.exec`); a false read here can only fail to lower, never mis-lower.\n */\nfunction caseFoldShape(source: string): ScanShape | null {\n  const la = stripTrailingLookahead(source)\n  if (la) {\n    const inner = caseFoldLiteralOrAlt(la.base)\n    if (!inner) return null\n    const operand: CharSet = { ranges: la.ranges, negated: la.classNegated }\n    if (!lookaheadUnambiguous(inner, operand, la.negative)) return null\n    return { kind: 'lookahead', inner, ranges: la.ranges, classNegated: la.classNegated, negative: la.negative }\n  }\n  return caseFoldLiteralOrAlt(source)\n}\n\n/** A case-fold literal, or a top-level `a|b|c` alternation of pure literals. */\nfunction caseFoldLiteralOrAlt(source: string): ScanShape | null {\n  // `foldEq` only folds ASCII letters (65\u201390 / 97\u2013122). A non-ASCII code point\n  // with a Unicode case pair (\u00E9/\u00C9, \u00E4/\u00C4, \u2026) would be emitted as an exact compare\n  // and silently miss its alternate case \u2014 a mis-lower, not just a failed lower.\n  // Decline those so they fall back to `RegExp.exec` (correct Unicode folding),\n  // preserving this file's \"a false read can only fail to lower, never mis-lower\".\n  const asciiOnly = (cps: number[]): boolean => cps.every(cp => cp <= 127)\n\n  const open = literalCodePoints(source)\n  if (open) return asciiOnly(open) ? { kind: 'litFold', open } : null\n  // `splitTopLevelAlternation` unwraps the outer group itself, so no pre-strip.\n  const arms = splitTopLevelAlternation(source)\n  if (!arms || arms.length < 2) return null\n  const litArms: ScanShape[] = []\n  for (const arm of arms) {\n    const cp = literalCodePoints(arm)\n    if (!cp || !asciiOnly(cp)) return null\n    litArms.push({ kind: 'litFold', open: cp })\n  }\n  // Ordered choice: each litFold arm case-folds on its own, so skipping the\n  // first-char dispatch guard (disjoint:false, firsts:null) is always correct \u2014\n  // it just tries arms in order, exactly like regex `|`.\n  return { kind: 'alt', arms: litArms, disjoint: false, firsts: litArms.map(() => null) }\n}\n\nexport const classCond = (cVar: string, ranges: Array<[number, number]>): string =>\n  ranges\n    .map(([lo, hi]) => (lo === hi ? `${cVar} === ${lo}` : `(${cVar} >= ${lo} && ${cVar} <= ${hi})`))\n    .join(' || ')\n\n/** Literal-match condition at `base + k` for each code point; uses `firstVar` at offset 0. */\nexport const litCond = (base: string, cps: number[], firstVar?: string): string =>\n  cps\n    .map((cp, k) =>\n      k === 0 && firstVar\n        ? `${firstVar} === ${cp}`\n        : `input.charCodeAt(${base}${k ? ` + ${k}` : ''}) === ${cp}`,\n    )\n    .join(' && ')\n\n/** Line-terminator code points `.` does not match (`\\n \\r \\u2028 \\u2029`). */\nexport const LINE_TERMINATORS = [10, 13, 8232, 8233] as const\n\n/** The body-stop chars that abort a string match (excluded set minus quote/backslash). */\nexport function stringHardStop(\n  shape: Extract<ScanShape, { kind: 'string' }>,\n): Array<[number, number]> {\n  return shape.excluded.filter(\n    ([lo, hi]) => !(lo === hi && (lo === shape.quote || lo === BACKSLASH)),\n  )\n}\n\n/** Mints a fresh, unique local variable name (`prefix` + counter). */\nexport type Mint = (prefix?: string) => string\n\n/**\n * The SINGLE source of truth for how a scannable shape matches at `start`. Both\n * the terminal emitter and the trivia scan loop consume this, so no context can\n * silently reinterpret an incomplete match (e.g. an unterminated string):\n *\n *   - `setup`   statements (indented by `ind`) that compute the match.\n *   - `ok`      a boolean expr: did a token match at `start`? (zero-width for\n *               `chars*` counts as a match \u2014 terminals allow it.)\n *   - `end`     the position AFTER the token. **Invariant:** `end === start`\n *               whenever there is no progress (match failed or matched empty),\n *               so the trivia loop can gate purely on `end > start`.\n *\n * `firstChar`, when supplied, is an expression already equal to\n * `charCodeAt(start)` (the trivia loop reads it once and shares it).\n */\nexport type ShapeMatch = { setup: string[]; ok: string; end: string }\n\nconst codeAt = (start: string, firstChar?: string): string =>\n  firstChar ?? `input.charCodeAt(${start})`\n\n// Dispatch-planning thresholds for a disjoint alt's first-char `switch` \u2014 same\n// tuning as codegen's `planDisjointDispatch` (kept local to avoid a scannable-run\n// \u2192 codegen import cycle): only worth a jump table when every arm keys off a few\n// DISCRETE points; a wide range (`[a-z]+`) would explode into dozens of cases.\nconst ALT_SWITCH_RANGE_LIMIT = 4\nconst ALT_SWITCH_MAX_CASES = 48\nconst ALT_SWITCH_MIN_CASES = 3\n\n/**\n * A `switch` jump table for a *disjoint* alt when every arm's first-set is a few\n * discrete code points (operator/keyword first chars); else `{ kind: 'if' }` to\n * keep the range-comparison `if/else if` chain. Arms are pairwise-disjoint, so\n * each code point maps to exactly one arm.\n */\nfunction planAltSwitch(firsts: Array<CharSet | null>): { kind: 'switch'; cases: number[][] } | { kind: 'if' } {\n  const cases: number[][] = []\n  let total = 0\n  for (const fs of firsts) {\n    if (!fs || fs.negated) return { kind: 'if' } // any / negated \u2192 no discrete keys\n    const pts: number[] = []\n    for (const [lo, hi] of fs.ranges) {\n      if (hi - lo + 1 > ALT_SWITCH_RANGE_LIMIT) return { kind: 'if' }\n      for (let cp = lo; cp <= hi; cp++) pts.push(cp)\n    }\n    total += pts.length\n    if (total > ALT_SWITCH_MAX_CASES) return { kind: 'if' }\n    cases.push(pts)\n  }\n  return total >= ALT_SWITCH_MIN_CASES ? { kind: 'switch', cases } : { kind: 'if' }\n}\n\nexport function emitShapeMatch(\n  shape: ScanShape,\n  start: string,\n  mint: Mint,\n  ind: string,\n  firstChar?: string,\n): ShapeMatch {\n  if (shape.kind === 'lookahead') {\n    const inner = emitShapeMatch(shape.inner, start, mint, ind, firstChar)\n    const okV = mint('_ok')\n    const endV = mint('_end')\n    // `charInClass` folds the operand's OWN `[^\u2026]` negation in; `guardFails`\n    // then applies the lookahead's `!`/`=` polarity on top. Zero-width: `end`\n    // is always `inner.end` (on success) or `start` (on failure) \u2014 never past\n    // where `inner` itself stopped.\n    const rawIn = classCond(`input.charCodeAt(${inner.end})`, shape.ranges)\n    const charInClass = shape.classNegated ? `!(${rawIn})` : `(${rawIn})`\n    const hasMatchingChar = `${inner.end} < input.length && ${charInClass}`\n    const guardFails = shape.negative ? hasMatchingChar : `!(${hasMatchingChar})`\n    return {\n      setup: [\n        ...inner.setup,\n        `${ind}let ${okV} = ${inner.ok}`,\n        `${ind}let ${endV} = ${inner.end}`,\n        `${ind}if (${okV} && (${guardFails})) { ${okV} = false; ${endV} = ${start} }`,\n      ],\n      ok: okV,\n      end: endV,\n    }\n  }\n\n  if (shape.kind === 'alt') {\n    const okV = mint('_ok')\n    const endV = mint('_end')\n    const lines: string[] = [`${ind}let ${okV} = false`, `${ind}let ${endV} = ${start}`]\n    // Fast path: an alternation of case-fold literals (CSS keyword lists like\n    // `@media|@container|@supports`, `even|odd`) \u2192 a `switch` on the first char\n    // that jumps straight to the matching group, tails compared with the bit-OR\n    // fold. Measured ~2.4x over the ordered if-chain / ~1.4x over per-arm bit-OR.\n    // Ordered-choice is preserved: arms are grouped by their FOLDED first code\n    // point and, within a group, emitted in source order (first match wins);\n    // arms in different groups can't both match a given first char.\n    if (shape.arms.length >= 2 && shape.arms.every(a => a.kind === 'litFold' && a.open.length >= 1)) {\n      const groups = new Map<number, number[][]>()\n      for (const a of shape.arms) {\n        const open = (a as Extract<ScanShape, { kind: 'litFold' }>).open\n        const f = open[0]!\n        const lower = f >= 65 && f <= 90 ? f + 32 : f\n        ;(groups.get(lower) ?? groups.set(lower, []).get(lower)!).push(open)\n      }\n      lines.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`)\n      for (const [lower, arms] of groups) {\n        const labels = lower >= 97 && lower <= 122 ? `case ${lower}: case ${lower - 32}:` : `case ${lower}:`\n        lines.push(`${ind}  ${labels} {`)\n        for (const open of arms) {\n          const tail = open.slice(1).map((cp, i) => foldEq(`input.charCodeAt(${start} + ${i + 1})`, cp))\n          const cond = tail.length ? ` && ${tail.join(' && ')}` : ''\n          lines.push(`${ind}    if (${start} + ${open.length} <= input.length${cond}) { ${okV} = true; ${endV} = ${start} + ${open.length}; break }`)\n        }\n        lines.push(`${ind}    break`)\n        lines.push(`${ind}  }`)\n      }\n      lines.push(`${ind}}`)\n      return { setup: lines, ok: okV, end: endV }\n    }\n    if (shape.disjoint) {\n      // Mutually exclusive first-sets: dispatch straight to the one matching\n      // arm, no ordering/backtracking concerns (\u00A77b-style disjoint dispatch). A\n      // `switch` jump table when arms key off discrete first chars, else the\n      // range-comparison `if/else if` chain (same plan as codegen's choice()).\n      const plan = planAltSwitch(shape.firsts)\n      if (plan.kind === 'switch') {\n        lines.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`)\n        shape.arms.forEach((arm, k) => {\n          const labels = plan.cases[k]!.map(cp => `case ${cp}:`).join(' ')\n          const m = emitShapeMatch(arm, start, mint, `${ind}    `, firstChar)\n          lines.push(`${ind}  ${labels} {`)\n          lines.push(...m.setup)\n          lines.push(`${ind}    ${okV} = ${m.ok}`)\n          lines.push(`${ind}    ${endV} = ${m.ok} ? ${m.end} : ${start}`)\n          lines.push(`${ind}    break`)\n          lines.push(`${ind}  }`)\n        })\n        lines.push(`${ind}}`)\n      } else {\n        const c0 = codeAt(start, firstChar)\n        shape.arms.forEach((arm, k) => {\n          const fs = shape.firsts[k]! // non-null whenever `disjoint` is true\n          const cond = fs.negated ? `!(${classCond(c0, fs.ranges)})` : `(${classCond(c0, fs.ranges)})`\n          const m = emitShapeMatch(arm, start, mint, `${ind}  `, firstChar)\n          lines.push(`${ind}${k === 0 ? 'if' : 'else if'} (${start} < input.length && ${cond}) {`)\n          lines.push(...m.setup)\n          lines.push(`${ind}  ${okV} = ${m.ok}`)\n          lines.push(`${ind}  ${endV} = ${m.ok} ? ${m.end} : ${start}`)\n          lines.push(`${ind}}`)\n        })\n      }\n    } else {\n      // Overlapping first-sets: ordered choice \u2014 try each arm in turn and take\n      // the first that succeeds. This is exactly regex `|`'s own semantics:\n      // first alternative to match AT ALL wins on ITS OWN greedy length, never\n      // compared against a later alternative's (possibly longer) match.\n      const lbl = mint('_alt')\n      lines.push(`${ind}${lbl}: {`)\n      for (const arm of shape.arms) {\n        const m = emitShapeMatch(arm, start, mint, `${ind}  `, firstChar)\n        lines.push(...m.setup)\n        lines.push(`${ind}  if (${m.ok}) { ${okV} = true; ${endV} = ${m.end}; break ${lbl} }`)\n      }\n      lines.push(`${ind}}`)\n    }\n    return { setup: lines, ok: okV, end: endV }\n  }\n\n  if (shape.kind === 'chars') {\n    const cur = mint('_e')\n    return {\n      setup: [\n        `${ind}let ${cur} = ${start}`,\n        `${ind}while (${cur} < input.length && (${classCond(`input.charCodeAt(${cur})`, shape.ranges)})) ${cur}++`,\n      ],\n      // `*` always matches (possibly empty); `+` needs at least one char.\n      ok: shape.minOne ? `${cur} > ${start}` : 'true',\n      end: cur,\n    }\n  }\n\n  if (shape.kind === 'ident') {\n    const cur = mint('_e')\n    return {\n      setup: [\n        `${ind}let ${cur} = ${start}`,\n        `${ind}if (${start} < input.length && (${classCond(codeAt(start, firstChar), shape.head)})) {`,\n        `${ind}  ${cur} = ${start} + 1`,\n        `${ind}  while (${cur} < input.length && (${classCond(`input.charCodeAt(${cur})`, shape.tail)})) ${cur}++`,\n        `${ind}}`,\n      ],\n      ok: `${cur} > ${start}`,\n      end: cur,\n    }\n  }\n\n  if (shape.kind === 'seq') {\n    const endV = mint('_e')\n    const okV = mint('_ok')\n    const runCond = (p: Extract<SeqPart, { part: 'run' }>, at: string) => {\n      const c = classCond(`input.charCodeAt(${at})`, p.ranges)\n      return p.negated ? `!(${c})` : `(${c})`\n    }\n    const lines = [`${ind}let ${endV} = ${start}`, `${ind}let ${okV} = false`, `${ind}do {`]\n    let first = true\n    for (const p of shape.parts) {\n      if (p.part === 'lit') {\n        const L = p.cps.length\n        const cond = litCond(endV, p.cps, first ? firstChar : undefined)\n        if (p.optional) {\n          lines.push(`${ind}  if (${endV} + ${L} <= input.length && (${cond})) ${endV} += ${L}`)\n        } else {\n          lines.push(`${ind}  if (!(${endV} + ${L} <= input.length && (${cond}))) break`)\n          lines.push(`${ind}  ${endV} += ${L}`)\n        }\n      } else if (p.part === 'run' && p.max === Infinity) {\n        // Unbounded run (`+`/`*`/`{n,}`): greedy scan, then enforce the minimum.\n        const s = mint('_s')\n        lines.push(`${ind}  const ${s} = ${endV}`)\n        lines.push(`${ind}  while (${endV} < input.length && ${runCond(p, endV)}) ${endV}++`)\n        if (p.min === 1) lines.push(`${ind}  if (${endV} === ${s}) break`)\n        else if (p.min > 1) lines.push(`${ind}  if (${endV} - ${s} < ${p.min}) break`)\n      } else if (p.part === 'run' && p.max === 1) {\n        // Exactly one char: required (min 1) or optional (min 0).\n        if (p.min === 1) {\n          lines.push(`${ind}  if (!(${endV} < input.length && ${runCond(p, endV)})) break`)\n          lines.push(`${ind}  ${endV}++`)\n        } else {\n          lines.push(`${ind}  if (${endV} < input.length && ${runCond(p, endV)}) ${endV}++`)\n        }\n      } else if (p.part === 'run') {\n        // Bounded counted run `[x]{min,max}` (\u00A78c), max \u2265 2: consume up to `max`\n        // occurrences, then require at least `min` (greedy \u2014 sound because\n        // `seqIsUnambiguous` proved any wiggle is disjoint from what follows).\n        const s = mint('_s')\n        lines.push(`${ind}  const ${s} = ${endV}`)\n        lines.push(`${ind}  while (${endV} - ${s} < ${p.max} && ${endV} < input.length && ${runCond(p, endV)}) ${endV}++`)\n        if (p.min > 0) lines.push(`${ind}  if (${endV} - ${s} < ${p.min}) break`)\n      } else {\n        // `group` (\u00A78f): the group's own body is just another `ScanShape` \u2014\n        // recurse via `emitShapeMatch`, then splice its setup in as the body\n        // of a required-once check, an optional take, or a repeat loop.\n        const inner = emitShapeMatch(p.inner, endV, mint, `${ind}  `, first ? firstChar : undefined)\n        if (!p.unbounded) {\n          lines.push(...inner.setup)\n          if (p.min === 1) {\n            lines.push(`${ind}  if (!(${inner.ok})) break`)\n            lines.push(`${ind}  ${endV} = ${inner.end}`)\n          } else {\n            lines.push(`${ind}  if (${inner.ok}) ${endV} = ${inner.end}`)\n          }\n        } else {\n          const progV = mint('_prog')\n          lines.push(`${ind}  let ${progV} = false`)\n          lines.push(`${ind}  while (true) {`)\n          lines.push(...inner.setup)\n          lines.push(`${ind}    if (!(${inner.ok})) break`)\n          lines.push(`${ind}    ${endV} = ${inner.end}`)\n          lines.push(`${ind}    ${progV} = true`)\n          lines.push(`${ind}  }`)\n          if (p.min === 1) lines.push(`${ind}  if (!${progV}) break`)\n        }\n      }\n      first = false\n    }\n    lines.push(`${ind}  ${okV} = true`)\n    lines.push(`${ind}} while (false)`)\n    lines.push(`${ind}if (!${okV}) ${endV} = ${start}`)\n    return { setup: lines, ok: okV, end: endV }\n  }\n\n  if (shape.kind === 'litFold') {\n    const openLen = shape.open.length\n    const endV = mint('_end')\n    const checks = shape.open.map((cp, k) => {\n      const cVar = k === 0 && firstChar ? firstChar : `input.charCodeAt(${start} + ${k})`\n      return foldEq(cVar, cp)\n    })\n    return {\n      setup: [\n        `${ind}let ${endV} = ${start}`,\n        `${ind}if (${start} + ${openLen} <= input.length && (${checks.join(' && ')})) ${endV} = ${start} + ${openLen}`,\n      ],\n      ok: `${endV} > ${start}`,\n      end: endV,\n    }\n  }\n\n  if (shape.kind === 'until') {\n    const j = mint('_j')\n    const openLen = shape.open.length\n    const openChk = openLen === 1\n      ? `${codeAt(start, firstChar)} === ${shape.open[0]}`\n      : litCond(start, shape.open, firstChar)\n    return {\n      setup: [\n        `${ind}let ${j} = ${start}`,\n        `${ind}if (${start} + ${openLen} <= input.length && (${openChk})) {`,\n        `${ind}  ${j} = ${start} + ${openLen}`,\n        `${ind}  while (${j} < input.length && !(${classCond(`input.charCodeAt(${j})`, shape.stop)})) ${j}++`,\n        `${ind}}`,\n      ],\n      // An open-until-terminator always completes (stop char or EOF), so a matched\n      // open literal is a full match; `end === start` iff the open didn't match.\n      ok: `${j} > ${start}`,\n      end: j,\n    }\n  }\n\n  if (shape.kind === 'string') {\n    const okV = mint('_ok')\n    const endV = mint('_end')\n    const i = mint('_i')\n    const c2 = mint('_c')\n    const hard = stringHardStop(shape)\n    const ltLines = shape.escLineTerm\n      ? []\n      : (() => {\n          const c3 = mint('_c')\n          return [\n            `${ind}      const ${c3} = input.charCodeAt(${i} + 1)`,\n            `${ind}      if (${LINE_TERMINATORS.map(t => `${c3} === ${t}`).join(' || ')}) break`,\n          ]\n        })()\n    return {\n      setup: [\n        `${ind}let ${okV} = false`,\n        `${ind}let ${endV} = ${start}`,\n        `${ind}if (${start} < input.length && (${codeAt(start, firstChar)}) === ${shape.quote}) {`,\n        `${ind}  let ${i} = ${start} + 1`,\n        `${ind}  while (${i} < input.length) {`,\n        `${ind}    const ${c2} = input.charCodeAt(${i})`,\n        `${ind}    if (${c2} === ${shape.quote}) { ${okV} = true; ${endV} = ${i} + 1; break }`,\n        `${ind}    if (${c2} === ${BACKSLASH}) {`,\n        `${ind}      if (${i} + 1 >= input.length) break`,\n        ...ltLines,\n        `${ind}      ${i} += 2`,\n        `${ind}      continue`,\n        `${ind}    }`,\n        ...(hard.length ? [`${ind}    if (${classCond(c2, hard)}) break`] : []),\n        `${ind}    ${i}++`,\n        `${ind}  }`,\n        `${ind}}`,\n      ],\n      ok: okV,\n      end: endV,\n    }\n  }\n\n  // delimited: <open>\u2026<close>, requires the close literal (unclosed \u21D2 no match).\n  const j = mint('_j')\n  const endV = mint('_end')\n  const openLen = shape.open.length\n  const closeLen = shape.close.length\n  const openChk = openLen === 1\n    ? `${codeAt(start, firstChar)} === ${shape.open[0]}`\n    : litCond(start, shape.open, firstChar)\n  const closeChk = litCond(j, shape.close)\n  return {\n    setup: [\n      `${ind}let ${j} = ${start}`,\n      `${ind}let ${endV} = ${start}`,\n      `${ind}if (${start} + ${openLen} <= input.length && (${openChk})) {`,\n      `${ind}  ${j} = ${start} + ${openLen}`,\n      `${ind}  while (${j} + ${closeLen - 1} < input.length && !(${closeChk})) ${j}++`,\n      `${ind}  if (${j} + ${closeLen} <= input.length && (${closeChk})) ${endV} = ${j} + ${closeLen}`,\n      `${ind}}`,\n    ],\n    ok: `${endV} > ${start}`,\n    end: endV,\n  }\n}\n\n/**\n * One trivia-loop branch for a shape, dispatched on the current char `c`\n * (= charCodeAt(_e)). Advances `_e` and `continue`s ONLY on real progress\n * (`end > _e`) \u2014 an unterminated delimited/string token leaves `end === _e`, so\n * the loop stops there exactly as the interpreter's `oneOrMore(choice(\u2026))` would.\n */\nexport function scanBranch(shape: ScanShape, mint: Mint): string {\n  const m = emitShapeMatch(shape, '_e', mint, '    ', 'c')\n  return [...m.setup, `    if (${m.end} > _e) { _e = ${m.end}; continue }`].join('\\n')\n}\n\n/**\n * A labeled branch: match one token and, on progress, log its [start, end,\n * kindIndex] trivia chunk. Same completion semantics as scanBranch.\n */\nexport function scanBranchLabeled(shape: ScanShape, kindIndex: number, mint: Mint): string {\n  const m = emitShapeMatch(shape, '_e', mint, '    ', 'c')\n  return [\n    ...m.setup,\n    `    if (${m.end} > _e) {`,\n    `      if (_cap) {`,\n    `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, ${m.end}, ${kindIndex})`,\n    `        if (_ctx._cstTriviaLog !== undefined && (_ctx._triviaCaptureMask === undefined || (_ctx._triviaCaptureMask & ${1 << kindIndex}))) _ctx._cstTriviaLog.push(_e, ${m.end}, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${kindIndex})`,\n    `      }`,\n    `      _e = ${m.end}`,\n    `      continue`,\n    `    }`,\n  ].join('\\n')\n}\n", "import type { Combinator } from '../types.ts'\nimport { getCoreRegexDef } from '../combinators/choice.ts'\nimport type { LabeledTriviaSpec } from '../cst/trivia-kinds.ts'\nimport { analyzeLabeledTrivia } from '../cst/trivia-kinds.ts'\nimport { type ScanShape, type Mint, scanShapeFromRegex, scanBranch, scanBranchLabeled } from './scannable-run.ts'\n\n/** Fresh, collision-free local names for one generated scan function. */\nfunction makeMint(): Mint {\n  let n = 0\n  return (prefix = '_v') => `${prefix}${n++}`\n}\n\nfunction unwrapTrivia(p: Combinator<unknown>): Combinator<unknown> {\n  let cur = p\n  while (cur._def.tag === 'trivia') cur = cur._def.parser\n  return cur\n}\n\nfunction oneOrMoreInner(p: Combinator<unknown>): Combinator<unknown> | null {\n  const d = p._def\n  if (d.tag === 'oneOrMore') return d.parser\n  if (d.tag === 'many' && d.min >= 1) return d.parser\n  return null\n}\n\nfunction choiceArms(p: Combinator<unknown>): Combinator<unknown>[] | null {\n  if (p._def.tag === 'choice') return p._def.parsers\n  return null\n}\n\n/** The scannable shape of one arm (a regex), or null if it isn't scannable. */\nfunction armShape(arm: Combinator<unknown>): ScanShape | null {\n  const d = getCoreRegexDef(arm)\n  return d ? scanShapeFromRegex(d.source, d.flags) : null\n}\n\n/**\n * A trivia parser that lowers to a hand-rolled char-scan loop: `oneOrMore(choice(\n * \u2026))` (or `many`, min\u22651) where EVERY arm is a scannable shape (a `[X]+` run, a\n * `<lit>[^X]*` open-until-terminator, or a `<open>(?:\u2026)*<close>` delimited token\n * \u2014 see scannable-run.ts). Returns the per-arm shapes, or a single-element list\n * for a bare scannable regex, or null (\u2192 caller falls back to the regex/generic\n * trivia path). A single alternation regex is NOT scannable (one exec matches one\n * arm per call, defeating the loop).\n */\nexport function analyzeTriviaFastPath(trivia: Combinator<unknown>): ScanShape[] | null {\n  const core = unwrapTrivia(trivia)\n\n  const directDef = getCoreRegexDef(core)\n  if (directDef) {\n    const shape = scanShapeFromRegex(directDef.source, directDef.flags)\n    return shape && shape.kind === 'chars' ? [shape] : null\n  }\n\n  const inner = oneOrMoreInner(core)\n  if (!inner) return null\n\n  const innerShape = armShape(inner)\n  if (innerShape) return innerShape.kind === 'chars' ? [innerShape] : null\n\n  const arms = choiceArms(inner)\n  if (!arms || arms.length < 2) return null\n\n  const shapes: ScanShape[] = []\n  for (const arm of arms) {\n    const shape = armShape(arm)\n    if (!shape) return null\n    shapes.push(shape)\n  }\n  return shapes\n}\n\nconst CAP_RECORD = [\n  `  if (_cap && _e > _pos) {`,\n  `    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,\n  `    if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,\n  `  }`,\n].join('\\n')\n\n/** One char-scan loop carrying a branch per scannable shape, dispatched on `c`. */\nfunction composeFastLoop(shapes: ScanShape[]): string {\n  const mint = makeMint()\n  return [\n    `  while (_e < input.length) {`,\n    `    const c = input.charCodeAt(_e)`,\n    ...shapes.map(s => scanBranch(s, mint)),\n    `    break`,\n    `  }`,\n  ].join('\\n')\n}\n\n/** Emit a specialized `_tfN` that skips (unlabeled) trivia via a char-scan loop. */\nexport function buildFastTriviaFnDecl(fnName: string, shapes: ScanShape[]): string {\n  return [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    composeFastLoop(shapes),\n    CAP_RECORD,\n    `  return _e`,\n    `}`,\n  ].join('\\n')\n}\n\n/**\n * A LABELED trivia parser whose every arm is scannable \u2192 per-arm shape + kind\n * index, or null. Same recognition as analyzeTriviaFastPath, but keyed by the\n * labeled arm kinds so the fast loop can log each chunk's kind. Generalizes what\n * used to be a hardcoded ws-run + block-comment special case to any scannable\n * shape set / arm count.\n */\nexport function analyzeLabeledScannableRun(\n  trivia: Combinator<unknown>,\n): Array<{ shape: ScanShape; kindIndex: number }> | null {\n  const spec = analyzeLabeledTrivia(trivia)\n  if (!spec) return null\n  const out: Array<{ shape: ScanShape; kindIndex: number }> = []\n  for (const arm of spec.arms) {\n    const d = getCoreRegexDef(arm.parser)\n    const shape = d ? scanShapeFromRegex(d.source, d.flags) : null\n    if (!shape) return null\n    out.push({ shape, kindIndex: arm.kindIndex })\n  }\n  return out\n}\n\n/** Emit a labeled scannable trivia `_tfN`: char-scan loop with per-chunk kind capture. */\nexport function buildLabeledScannableTriviaFnDecl(\n  fnName: string,\n  arms: ReadonlyArray<{ shape: ScanShape; kindIndex: number }>,\n): string {\n  const mint = makeMint()\n  return [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  while (_e < input.length) {`,\n    `    const c = input.charCodeAt(_e)`,\n    ...arms.map(a => scanBranchLabeled(a.shape, a.kindIndex, mint)),\n    `    break`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n')\n}\n\n/** Labeled trivia with regex arms \u2014 per-chunk kind capture in compiled output. */\nexport function buildLabeledRegexTriviaFnDecl(\n  fnName: string,\n  spec: LabeledTriviaSpec,\n  reNames: string[],\n): string {\n  const tryArms = spec.arms.map((arm, i) => {\n    const re = reNames[i]!\n    const k = arm.kindIndex\n    return [\n      `    ${re}.lastIndex = _e`,\n      `    const _m${i} = ${re}.exec(input)`,\n      `    if (_m${i} && _m${i}.index === _e) {`,\n      `      const _ce = _e + _m${i}[0].length`,\n      `      if (_cap) {`,\n      `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, _ce, ${k})`,\n      `        if (_ctx._cstTriviaLog !== undefined && (_ctx._triviaCaptureMask === undefined || (_ctx._triviaCaptureMask & ${1 << k}))) _ctx._cstTriviaLog.push(_e, _ce, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${k})`,\n      `      }`,\n      `      _e = _ce`,\n      `      _matched = true`,\n      `      continue`,\n      `    }`,\n    ].join('\\n')\n  }).join('\\n')\n\n  return [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  while (_e < input.length) {`,\n    `    let _matched = false`,\n    tryArms,\n    `    if (!_matched) break`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n')\n}\n\nexport function labeledTriviaRegexArms(trivia: Combinator<unknown>): LabeledTriviaSpec | null {\n  const spec = analyzeLabeledTrivia(trivia)\n  if (!spec) return null\n  for (const arm of spec.arms) {\n    if (!getCoreRegexDef(arm.parser)) return null\n  }\n  return spec\n}\n\n/** Labeled trivia via per-arm runtime parsers (non-regex or mixed arms). */\nexport function buildLabeledRuntimeTriviaFnDecl(\n  fnName: string,\n  spec: LabeledTriviaSpec,\n  rpStartIndex: number,\n): string {\n  const tryArms = spec.arms.map((arm, i) => {\n    const k = arm.kindIndex\n    const ri = rpStartIndex + i\n    return [\n      `    const _r${i} = _rp[${ri}].parse(input, _e, _ctx)`,\n      `    if (_r${i}.ok && _r${i}.span.end > _e) {`,\n      `      const _ce = _r${i}.span.end`,\n      `      if (_cap) {`,\n      `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, _ce, ${k})`,\n      `        if (_ctx._cstTriviaLog !== undefined && (_ctx._triviaCaptureMask === undefined || (_ctx._triviaCaptureMask & ${1 << k}))) _ctx._cstTriviaLog.push(_e, _ce, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${k})`,\n      `      }`,\n      `      _e = _ce`,\n      `      _matched = true`,\n      `      continue`,\n      `    }`,\n    ].join('\\n')\n  }).join('\\n')\n\n  return [\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  while (_e < input.length) {`,\n    `    let _matched = false`,\n    tryArms,\n    `    if (!_matched) break`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n')\n}\n", "/**\n * Lower scannable regex shapes to tight `charCodeAt` scan loops for terminal\n * `regex()` combinators (PERF_IDEAS \u00A78). Trivia uses the SAME match core via\n * `scannable-run.ts` (`emitShapeMatch`); this module is just the terminal\n * wrapper: run the shared match, fail when it doesn't match, then slice the\n * value. Keeping one match core means terminal and trivia can never disagree on\n * what an incomplete token (unclosed string/comment) means.\n */\nimport { type ScanShape, emitShapeMatch } from './scannable-run.ts'\n\nexport type ScanEmitCtx = {\n  ind: string\n  pos: string\n  valueVar: string\n  /** Emit `if (cond) { failLine }` lines (no trailing blank). */\n  failIf: (cond: string) => string[]\n  fresh: (prefix?: string) => string\n}\n\n/** Emit stmts for one terminal regex match, or null when the shape is unsupported. */\nexport function emitScannableTerminal(\n  shape: ScanShape,\n  c: ScanEmitCtx,\n): { stmts: string[]; endVar: string } | null {\n  const m = emitShapeMatch(shape, c.pos, c.fresh, c.ind)\n  const stmts = [...m.setup]\n  // `chars*` matches unconditionally (possibly empty) \u2014 no failure branch needed.\n  if (m.ok !== 'true') stmts.push(...c.failIf(`!(${m.ok})`))\n  stmts.push(`${c.ind}const ${c.valueVar} = input.slice(${c.pos}, ${m.end})`)\n  return { stmts, endVar: m.end }\n}\n", "import type { ParserDef } from '../types.ts'\n\n/** `(c, f, s, r, tl) => mk('Type', c, r, s, tl)` \u2014 CSS perf regression builder shape. */\nconst MK_BUILD_RE =\n  /^\\(\\s*(\\w+)\\s*,\\s*\\w+\\s*,\\s*(\\w+)\\s*,\\s*(\\w+)\\s*,\\s*(\\w+)\\s*\\)\\s*=>\\s*mk\\s*\\(\\s*(['\"])([^'\"]+)\\5\\s*,\\s*\\1\\s*,\\s*\\3\\s*,\\s*\\2\\s*,\\s*\\4\\s*\\)\\s*$/\n\nfunction escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/** Any callee \u2014 covers `mk`, `import_x.mk`, `__vite_ssr_import_0__.mk`, etc. */\nfunction looseMkBuildRe(type: string): RegExp {\n  return new RegExp(\n    String.raw`^\\(\\s*(\\w+)\\s*,\\s*\\w+\\s*,\\s*(\\w+)\\s*,\\s*(\\w+)\\s*,\\s*(\\w+)\\s*\\)\\s*=>\\s*.+\\(\\s*(['\"])${escapeRegExp(type)}\\5\\s*,\\s*\\1\\s*,\\s*\\3\\s*,\\s*\\2\\s*,\\s*\\4\\s*\\)\\s*$`,\n  )\n}\n\n/**\n * When a node() build is a thin `mk(type, \u2026)` wrapper, emit the object literal\n * at the call site instead of `_build[n](\u2026)`.\n */\nexport function analyzeMkInlineBuild(def: Extract<ParserDef, { tag: 'node' }>): string | null {\n  if (!def.build) return null // structural node \u2014 no own build to inline\n  if (def.type === undefined) return null\n  const src = (def.buildSrc ?? def.build.toString()).trim()\n  const strict = src.match(MK_BUILD_RE)\n  if (strict) {\n    const mkType = strict[6]!\n    return mkType === def.type ? def.type : null\n  }\n  if (looseMkBuildRe(def.type).test(src)) return def.type\n  return null\n}\n\n/** Object literal matching `stub-build.ts` `mk()` without the function call. */\nexport function emitInlineMkNodeExpr(\n  type: string,\n  chV: string,\n  rawV: string,\n  pos: string,\n  endVar: string,\n  tlV: string,\n): string {\n  return `{ _tag: 'node', type: ${JSON.stringify(type)}, span: { start: ${pos}, end: ${endVar} }, children: ${chV}, rawCount: ${rawV}.length, localTriviaLen: ${tlV}.length }`\n}\n", "/** Builtins allowed in inlined transform bodies (not treated as free closure refs). */\nconst INLINE_BUILTINS = new Set([\n  'parseInt', 'parseFloat', 'String', 'Number', 'Boolean', 'Object', 'Array', 'Math', 'JSON',\n  'undefined', 'null', 'true', 'false', 'NaN', 'Infinity',\n])\n\nfunction escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/** Source text for a transform callback \u2014 macro `fnSrc` or arrow `toString()`. */\nexport function transformFnSource(fn: Function, fnSrc?: string | null): string | null {\n  if (fnSrc) return fnSrc.trim()\n  const s = fn.toString().trim()\n  if (s.includes('[native code]')) return null\n  return s\n}\n\nfunction replaceParam(body: string, param: string, valueVar: string): string {\n  return body.replace(new RegExp(`\\\\b${escapeRegExp(param)}\\\\b`, 'g'), valueVar)\n}\n\nfunction stripForIdCheck(body: string): string {\n  return body\n    .replace(/'[^'\\\\]*(?:\\\\.[^'\\\\]*)*'|\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\"/g, '\"\"')\n    .replace(/\\bas\\s+const\\b/g, '')\n    .replace(/\\b[A-Za-z_$][\\w$]*\\s*:/g, ':')\n}\n\nfunction hasFreeIdentifiers(body: string, allowed: ReadonlySet<string>): boolean {\n  const stripped = stripForIdCheck(body)\n  const ids = stripped.match(/\\b[A-Za-z_$][\\w$]*\\b/g) ?? []\n  for (const id of ids) {\n    if (INLINE_BUILTINS.has(id)) continue\n    if (allowed.has(id)) continue\n    return true\n  }\n  return false\n}\n\n/** `s => expr` / `() => expr` when expr only uses the param (+ builtins). */\nexport function tryInlineUnaryTransform(src: string, valueVar: string): string | null {\n  const allowed = new Set([valueVar])\n  const nullary = src.match(/^\\(\\s*\\)\\s*=>\\s*(.+)$/)\n  if (nullary) {\n    const body = nullary[1]!.trim()\n    return hasFreeIdentifiers(body, allowed) ? null : body\n  }\n  const m = src.match(/^(\\w+)\\s*=>\\s*(.+)$/)\n  if (!m) return null\n  const body = replaceParam(m[2]!.trim(), m[1]!, valueVar)\n  return hasFreeIdentifiers(body, allowed) ? null : body\n}\n\n/** Parse `[a, , c]` destructuring slots (null = ignore). */\nexport function parseArrayDestructure(pattern: string, arity: number): (string | null)[] {\n  const slots: (string | null)[] = []\n  for (const part of pattern.split(',')) {\n    const name = part.trim()\n    slots.push(name === '' || name === '_' ? null : name)\n  }\n  while (slots.length < arity) slots.push(null)\n  return slots.slice(0, arity)\n}\n\n/**\n * `([x, y]) => body` \u2014 substitute destructure names with sequence value vars.\n * Caller must ensure body only references slotted params (+ builtins).\n */\nexport function tryInlineDestructureTransform(\n  src: string,\n  valueVars: string[],\n): string | null {\n  const m = src.match(/^\\(\\s*\\[([^\\]]*)\\]\\s*\\)\\s*=>\\s*(.+)$/s)\n  if (!m) return null\n  const slots = parseArrayDestructure(m[1]!, valueVars.length)\n  let body = m[2]!.trim()\n  const allowed = new Set(valueVars)\n  for (let i = 0; i < slots.length; i++) {\n    const name = slots[i]\n    if (name) body = replaceParam(body, name, valueVars[i]!)\n  }\n  return hasFreeIdentifiers(body, allowed) ? null : body\n}\n", "/**\n * Compile a Combinator<T> definition tree into an optimized JavaScript function.\n *\n * Design: every sub-emitter uses early-return on failure. Fallible contexts\n * (optional, sepBy loops, many loops) use labeled blocks so early-exit is a\n * `break <label>` rather than an IIFE return \u2014 no function call, no result\n * object allocation per node.\n */\nimport type { Combinator, ParserDef, FirstSet, ParseResult, ParseContext, ParseError, ChoiceStrategy, FieldMap } from '../types.ts'\nimport { getCoreLiteralValue, getCoreRegexDef } from '../combinators/choice.ts'\nimport { deriveExpected } from '../combinators/expect.ts'\nimport { firstSetOf, matchesEmpty, union } from '../combinators/first-set.ts'\nimport { markUnusedValues } from './value-usage.ts'\nimport { analyzeLabeledTrivia } from '../cst/trivia-kinds.ts'\nimport {\n  analyzeLabeledScannableRun,\n  analyzeTriviaFastPath,\n  buildFastTriviaFnDecl,\n  buildLabeledRegexTriviaFnDecl,\n  buildLabeledRuntimeTriviaFnDecl,\n  buildLabeledScannableTriviaFnDecl,\n  labeledTriviaRegexArms,\n} from './trivia-fast-path.ts'\nimport { scanShapeFromRegex, parseClassRanges, emitShapeMatch, foldEq, type ScanShape, type Mint } from './scannable-run.ts'\nimport { emitScannableTerminal } from './scannable-terminal.ts'\nimport { analyzeMkInlineBuild, emitInlineMkNodeExpr } from './inline-build.ts'\nimport { buildReadsTrivia, buildReadsState } from './build-arity.ts'\nimport { buildReadsFields, parserHasOwnFields, parserHasTriviaSite } from './fields.ts'\nimport {\n  transformFnSource,\n  tryInlineUnaryTransform,\n  tryInlineDestructureTransform,\n} from './inline-callback.ts'\n\n/**\n * Runtime prelude helper for the structural-node capture gate. Answers \"does the\n * injected `_ctx.build` host read its (n+1)th positional arg?\" \u2014 `.length` alone\n * under-counts with rest/default params and can't see through a bound fn, so a\n * rest/default param or an `arguments` reference forces full capture (output-safe).\n * Plain positional and bound-native hosts (the common case) trust `.length`.\n * Emitted (memoized on `_ctx._pmCapTL`/`_pmCapST`) wherever a structural node()\n * arity-gates host capture; shared, un-namespaced, mirrors `_EMPTY_TL` placement.\n */\nexport const HOST_READS_DECL =\n  'const _hostReads = (b, n) => { if (b === undefined) return false; let s; try { s = Function.prototype.toString.call(b) } catch (e) { return true } if (/\\\\barguments\\\\b/.test(s)) return true; const m = /^[^(]*\\\\(([\\\\s\\\\S]*?)\\\\)/.exec(s); if (m && /\\\\.\\\\.\\\\.|=/.test(m[1])) return true; return b.length > n }'\n\n// ---------------------------------------------------------------------------\n// Regex-lowering diagnostics\n//\n// A regex terminal \"lowers\" when `scanShapeFromRegex` recognizes it and it emits\n// a tight `charCodeAt` scan loop. When it can't, emitRegex falls back to a real\n// `RegExp.exec` call \u2014 correct, but slower. Compilation is single-module and\n// synchronous, so a module-level capture sink (opened per transform, drained\n// after) records the un-lowered patterns without threading a field through every\n// Ctx and compile*() return. Keyed by regex source \u2192 one entry per unique pattern.\n// ---------------------------------------------------------------------------\nlet _loweringSink: Set<string> | null = null\n\n/** Begin capturing regexes that fall back to `RegExp.exec` (didn't lower). */\nexport function beginLoweringCapture(): void {\n  _loweringSink = new Set()\n}\n\n/** Stop capturing and return the un-lowered regex sources seen since begin. */\nexport function endLoweringCapture(): string[] {\n  const misses = _loweringSink ? [..._loweringSink] : []\n  _loweringSink = null\n  return misses\n}\n\n// ---------------------------------------------------------------------------\n// Codegen context\n// ---------------------------------------------------------------------------\ntype Ctx = {\n  vars: number\n  indent: number\n  /**\n   * Compile-time recovery gate (opt-in via `compile(g, { recovery: true })`).\n   * When off (default) NO recovery code is emitted \u2014 byte-identical output, and\n   * `runtimeParsers` stays empty so macro-inlining is unaffected. When on, lists\n   * emit a `_ctx._tolerant`-gated recovery branch and sequences publish an inferred\n   * sync sentinel; the machinery is dormant unless the parse is run tolerant.\n   */\n  recovery?: boolean | undefined\n  /** Regex declarations hoisted to module scope */\n  regexDecls: string[]\n  /** Dedup map: \"source/flags\" \u2192 variable name (_re0 etc.) */\n  regexMap: Map<string, string>\n  /** Frozen constant expected-set arrays hoisted to module scope (_fx0 etc.) */\n  expectedDecls: string[]\n  /** Dedup map: array source \u2192 hoisted const name */\n  expectedMap: Map<string, string>\n  /** Map functions that need to be captured at compile time */\n  mapFns: Array<(v: unknown, span: { start: number; end: number }) => unknown>\n  /**\n   * Source text of each map function, captured in lockstep with `mapFns`\n   * (parallel array). Populated from `def.fnSrc` when present \u2014 lets the macro\n   * inline transform callbacks in codegen-traversal order without a fragile\n   * pre-accumulated positional array. `null` entries mean the source was not\n   * available (interpreter/compile() path with no macro source).\n   */\n  mapFnSrcs: Array<string | null>\n  /** Runtime parser fallbacks (for unknown/_def-less parsers) */\n  runtimeParsers: Array<Combinator<unknown>>\n  /** Whether any node() elided trivia capture and needs the shared frozen empty log. */\n  needsEmptyTl?: boolean | undefined\n  /** Whether any structural node() arity-gates host capture and needs the `_hostReads` helper. */\n  needsHostReads?: boolean | undefined\n  /** Lazy/ref parsers and trivia helpers: parser identity \u2192 generated function name */\n  namedParsers: Map<Combinator<unknown>, string>\n  /**\n   * Rule-map composition (linkable form): the `ref` placeholder for each named\n   * rule \u2192 its canonical `_r_<Name>` function name. When a `lazy`/`ref` in\n   * `emitLazy` is one of these, it is emitted once as `_r_<Name>` (never inlined,\n   * so it stays addressable/overridable by name) and siblings call it by that\n   * name \u2014 so the whole map fuses into one scope with direct local calls. Unset\n   * for single-combinator `compile()` (no rule map \u2192 today's `_pfN` naming).\n   */\n  ruleNames?: Map<Combinator<unknown>, string> | undefined\n  /**\n   * Namespace prefix for HOISTED closure-level names (`_re`, `_fx`, `_pf`, `_mf`,\n   * `_build`) so two independently-compiled rule maps fuse into one scope without\n   * colliding (the linkable form). Empty by default \u2192 byte-identical output.\n   * Function-local vars (`_v`/`_e`/\u2026) are per-scope and never namespaced; the\n   * sentinel protocol (`_NAMED_FN_*`), `_EMPTY_TL` are SHARED across\n   * fused packages (a namespaced sentinel would break cross-package calls) and so\n   * are also left un-prefixed; `_r_<Name>` is the composition surface (intended\n   * collision = override) and is never prefixed.\n   */\n  ns?: string | undefined\n  /**\n   * Linkable (compose) mode: a `choice` arm that is a named rule REF must not bake\n   * an inline first-set dispatch guard \u2014 the referenced rule can be overridden at\n   * fuse time, changing its first-set. Instead emit a `/*@FS:rule:codevar@*\u200B/true`\n   * placeholder that fusedBody() substitutes with the WINNING rule's first-set\n   * condition (or leaves `true` = always-try when unknown). Off for monolithic\n   * compile() / compileRuleMap where rules are final.\n   */\n  deferFirstSetRefs?: boolean | undefined\n  /** Generated function declaration strings, prepended before the main body */\n  namedFnDecls: string[]\n  /** Active trivia parser (set by grammar() wrappers, cleared on exit) */\n  activeTrivia?: Combinator<unknown> | undefined\n  /** Label table from grammar trivia for default ParseContext. */\n  triviaKindLabels?: readonly string[] | undefined\n  /**\n   * Whether this compile contains any node() rule. When true, terminals emit a\n   * `_ctx._cstLeaves` capture and trivia skips capture trivia tokens \u2014 flowing\n   * through `_ctx` so capture crosses named-function (ref) boundaries correctly.\n   * When false (no node() anywhere) NO capture code is emitted, so non-CST\n   * grammars compile byte-identically to before.\n   */\n  capturing?: boolean\n  /** Inside the trivia-capture fn: terminals emit CSTTrivia tokens, not leaves. */\n  capAsTrivia?: boolean | undefined\n  /**\n   * Set on a transient probe ctx (e.g. scanTo's `capturing: false` sentinel/skip\n   * probe) where emitted code must have NO capture side effects. Suppresses\n   * shared-combinator hoisting so a probe never defines \u2014 nor reuses \u2014 a named\n   * function compiled in the surrounding capturing context (whose runtime-gated\n   * `_cstLeaves` push would fire during the probe).\n   */\n  noHoist?: boolean | undefined\n  /** Trivia parser \u2192 name of its capturing variant fn (separate from namedParsers). */\n  triviaCaptureNames: Map<Combinator<unknown>, string>\n  /**\n   * Trivia parser \u2192 name of its fast number-returning variant fn (non-capturing\n   * mode). Returns the new position directly instead of a {ok,value,span} object,\n   * eliminating two object allocations per trivia skip.\n   */\n  triviaFnNames: Map<Combinator<unknown>, string>\n  /** node() build functions captured at compile time (parallel to buildSrcs). */\n  buildFns: Array<(children: ReadonlyArray<unknown>, fields: FieldMap | undefined, span: { start: number; end: number }, raw: ReadonlyArray<unknown>, triviaLog: readonly number[], state: unknown) => unknown>\n  /** Source text of each build fn (set from def.buildSrc; null when unavailable). */\n  buildSrcs: Array<string | null>\n  /**\n   * When set, `failStmt` emits `break <label>` instead of `return { ok: false }`.\n   * Used by emitFallible to let labeled blocks act as the failure boundary.\n   */\n  failLabel?: string | undefined\n  /**\n   * Whether a leaf failure should record its payload into `_ctx._fe`/`_ctx._fx`\n   * for an enclosing reader (node/choice/ref/withCtx/runtime) to propagate.\n   * Swallowers (optional, many/sepBy loop bodies, not) set this false around the\n   * sub-parse whose failure they discard, so the hot path pays nothing. Default\n   * true (safe: always record). Only meaningful together with `failLabel`.\n   */\n  recordFail: boolean\n  /**\n   * Precomputed by analyzeLazyUsage() before codegen starts. emitLazy consults\n   * this to inline a single-use, non-recursive ref directly at its call site\n   * instead of hoisting it into a named function. Undefined when compile()\n   * hasn't run the pre-pass (should not happen in practice \u2014 always set in\n   * compile() \u2014 but kept optional so emitLazy degrades to \"always named\" if\n   * ever invoked without it, e.g. future direct unit tests of emitLazy).\n   */\n  lazyUsage?: {\n    counts: Map<Combinator<unknown>, number>\n    recursive: Set<Combinator<unknown>>\n    /** Approx subtree node count (lazy refs counted as 1 leaf), memoized. Gates\n     * shared-combinator hoisting: only subtrees big enough that de-duplicating\n     * them beats the added call cost are hoisted; tiny shared wrappers stay inline. */\n    sizes: Map<Combinator<unknown>, number>\n  }\n}\n\nfunction v(ctx: Ctx, prefix = '_v'): string { return `${prefix}${ctx.vars++}` }\nfunction ind(ctx: Ctx): string { return '  '.repeat(ctx.indent) }\n\n/** Namespace prefix for hoisted closure-level names (empty unless linkable). */\nfunction nsp(ctx: Ctx): string { return ctx.ns ?? '' }\n/** Hoisted map-fn array name (`_mf`, namespaced in linkable mode). */\nfunction mfRef(ctx: Ctx): string { return `${nsp(ctx)}_mf` }\n/** Hoisted build-fn array name (`_build`, namespaced in linkable mode). */\nfunction buildRef(ctx: Ctx): string { return `${nsp(ctx)}_build` }\n\n/** Re-indent emitted lines to an absolute depth while preserving relative nesting. */\nfunction reindentStmts(stmts: string[], targetLevels: number): string[] {\n  const nonEmpty = stmts.filter(s => s.trim().length > 0)\n  if (nonEmpty.length === 0) return stmts\n  const minLeading = Math.min(...nonEmpty.map(s => s.length - s.trimStart().length))\n  const targetPrefix = '  '.repeat(targetLevels)\n  return stmts.map(s => (s.trim().length === 0 ? '' : targetPrefix + s.slice(minLeading)))\n}\n\nfunction failReturn(expected: string, posExpr: string): string {\n  return `return { ok: false, expected: [${expected}], span: { start: ${posExpr}, end: ${posExpr} } }`\n}\n\nfunction failReturnArr(expectedArr: string, posExpr: string): string {\n  return `return { ok: false, expected: ${expectedArr}, span: { start: ${posExpr}, end: ${posExpr} } }`\n}\n\n/**\n * Hoist a COMPILE-TIME-CONSTANT expected-set array to a shared module-level\n * const and return its variable name. Leaf failures (literal, regex, keyword,\n * not, \u2026) have a fixed expected set, so recording it on the hot failure path\n * must NOT allocate a fresh array every time \u2014 a choice arm that misses or a\n * many/sepBy loop that terminates hits this on essentially every token. We store\n * a reference to the shared array instead (one pointer write, zero allocation).\n *\n * The shared array is NEVER mutated in place by generated code, and every path\n * that surfaces `_ctx._fx` as a user-facing ParseResult copies it first (see\n * `resultFromRecorded` / the dynamic direct-return in `failArrBody`), so the\n * public `expected` array stays fresh & independent. (We deliberately do NOT\n * `Object.freeze` it: a user grammar may define a rule named `Object`, which \u2014\n * once inlined as a local \u2014 would shadow the global and break the freeze call.)\n */\nfunction hoistExpected(ctx: Ctx, constArrSource: string): string {\n  let name = ctx.expectedMap.get(constArrSource)\n  if (name === undefined) {\n    name = `${nsp(ctx)}_fx${ctx.expectedDecls.length}`\n    ctx.expectedDecls.push(`const ${name} = ${constArrSource}`)\n    ctx.expectedMap.set(constArrSource, name)\n  }\n  return name\n}\n\n/**\n * Compiled mirror of the interpreter's `failAt` (probe.ts): a `_ctx._probe`-gated\n * furthest-failure update emitted at leaf-fail sites when IDE support is compiled in\n * (`ctx.recovery`). A deeper failure replaces the best; a tie MERGES expected arrays\n * (so choice arms aggregate their alternatives). Fires even inside swallowers\n * (`recordFail` off) \u2014 a completion's deepest failure is often inside an optional/\n * many. Dormant unless `completionsAt` set `_ctx._probe`, so a normal/tolerant parse\n * pays one property read per leaf fail. Empty (no side effects) when recovery is off.\n */\nfunction probeUpdate(ctx: Ctx, expectedArr: string, posExpr: string, constant = true): string {\n  if (!ctx.recovery) return ''\n  const fx = constant ? hoistExpected(ctx, expectedArr) : expectedArr\n  const pb = v(ctx, '_pb')\n  return `if (_ctx._probe !== undefined && ${posExpr} <= _ctx._probe.offset) { const ${pb} = _ctx._probe.best; if (${pb} === null || ${posExpr} > ${pb}.span.start) _ctx._probe.best = { ok: false, expected: [...${fx}], span: { start: ${posExpr}, end: ${posExpr} } }; else if (${posExpr} === ${pb}.span.start) _ctx._probe.best = { ok: false, expected: [...${pb}.expected, ...${fx}], span: { start: ${posExpr}, end: ${posExpr} } } } `\n}\n\nfunction failBody(ctx: Ctx, expected: string, posExpr: string): string {\n  // Record the failure payload before breaking so an enclosing composite\n  // construct can propagate this (deepest) failure verbatim \u2014 parity with the\n  // interpreter, which returns the inner failure result. Recording is skipped\n  // when no consumer will read it (see `ctx.recordFail`): swallowers like\n  // optional/many/sepBy/not never inspect `_ctx._fx`, so a leaf failing inside\n  // them just breaks \u2014 the hot path (loop terminations, first-arm misses) pays\n  // nothing. The direct-return path is the final answer and needs no recording.\n  const probe = probeUpdate(ctx, `[${expected}]`, posExpr)\n  if (ctx.failLabel) {\n    if (!ctx.recordFail) return probe ? `{ ${probe}break ${ctx.failLabel} }` : `break ${ctx.failLabel}`\n    return `{ ${probe}_ctx._fe = ${posExpr}; _ctx._fx = ${hoistExpected(ctx, `[${expected}]`)}; break ${ctx.failLabel} }`\n  }\n  return probe + failReturn(expected, posExpr)\n}\n\n/**\n * Like {@link failBody} but the caller already has an array source. When\n * `constant` (the default), the array is hoisted+frozen (zero-alloc hot path).\n * Pass `constant: false` for dynamic sources (e.g. `_ctx._fx`, a runtime concat)\n * that must be assigned verbatim.\n */\nfunction failArrBody(ctx: Ctx, expectedArr: string, posExpr: string, constant = true): string {\n  const probe = probeUpdate(ctx, expectedArr, posExpr, constant)\n  if (ctx.failLabel) {\n    if (!ctx.recordFail) return probe ? `{ ${probe}break ${ctx.failLabel} }` : `break ${ctx.failLabel}`\n    const fx = constant ? hoistExpected(ctx, expectedArr) : expectedArr\n    return `{ ${probe}_ctx._fe = ${posExpr}; _ctx._fx = ${fx}; break ${ctx.failLabel} }`\n  }\n  // Direct-return (no enclosing fail label). A dynamic source may reference the\n  // shared frozen `_ctx._fx`; copy it so the (possibly frozen) constant never\n  // escapes into a user-facing result. Constant sources are inline literals.\n  if (!constant) return `${probe}return { ok: false, expected: [...${expectedArr}], span: { start: ${posExpr}, end: ${posExpr} } }`\n  return probe + failReturnArr(expectedArr, posExpr)\n}\n\n/** Build a ParseResult from the recorded deepest failure, copying `_fx` so the\n * shared frozen array never escapes into user-facing results. */\nfunction resultFromRecorded(feExpr = '_ctx._fe', fxExpr = '_ctx._fx'): string {\n  return `return { ok: false, expected: [...${fxExpr}], span: { start: ${feExpr}, end: ${feExpr} } }`\n}\n\n/**\n * Propagate the already-recorded deepest failure (`_ctx._fe`/`_ctx._fx`) rather\n * than synthesizing a coarse `[\"node\"]`-style placeholder. Used by composite\n * constructs whose interpreter counterpart returns the inner failure verbatim\n * (node, ref/lazy, withCtx, runtime fallback). `srcCtx` is the ctx var holding\n * the payload (`_ctx`, or a spread child ctx for withCtx).\n */\nfunction propagateFailBody(ctx: Ctx, srcCtx = '_ctx'): string {\n  if (srcCtx !== '_ctx') {\n    // withCtx ran on a spread child ctx; copy its recorded failure back (only\n    // when a consumer will read it) before propagating.\n    if (ctx.failLabel) {\n      if (!ctx.recordFail) return `break ${ctx.failLabel}`\n      return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; break ${ctx.failLabel} }`\n    }\n    return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; ${resultFromRecorded()} }`\n  }\n  // Same-ctx: `_ctx._fx` already holds the deepest failure \u2014 just break/return.\n  if (ctx.failLabel) return `break ${ctx.failLabel}`\n  return resultFromRecorded()\n}\n\nfunction emitIfFail(ctx: Ctx, cond: string, body: string): string[] {\n  return [\n    `${ind(ctx)}if (${cond}) {`,\n    `${ind(ctx)}  ${body}`,\n    `${ind(ctx)}}`,\n  ]\n}\n\nfunction emitElseFail(ctx: Ctx, body: string): string[] {\n  return [\n    `${ind(ctx)}else {`,\n    `${ind(ctx)}  ${body}`,\n    `${ind(ctx)}}`,\n  ]\n}\n\n/** Sentinel + end-position slot for compiled `rules()` / `withCtx` named fns. */\nconst NAMED_FN_FAIL = '_pfFail'\nconst NAMED_FN_END = '_pfEnd'\n\nfunction namedFnPrelude(): string[] {\n  return [`const ${NAMED_FN_FAIL} = {}`, `let ${NAMED_FN_END}`]\n}\n\nfunction pushNamedFnDecl(\n  ctx: Ctx,\n  fnName: string,\n  bodyStmts: string[],\n  valueVar: string,\n  endVar: string,\n): void {\n  // Success path returns the value DIRECTLY (setting the shared end slot first);\n  // failure breaks `_pfail` and falls through to the sentinel return. No `_pfok`\n  // flag / post-block check \u2014 fewer ops on the hot (matched) path, and smaller.\n  ctx.namedFnDecls.push([\n    `function ${fnName}(input, _pos, _ctx) {`,\n    `  _pfail: {`,\n    ...reindentStmts(bodyStmts, 2),\n    `    ${NAMED_FN_END} = ${endVar}`,\n    `    return ${valueVar}`,\n    `  }`,\n    `  return ${NAMED_FN_FAIL}`,\n    `}`,\n  ].join('\\n'))\n}\n\nfunction emitNamedFnCall(ctx: Ctx, fnName: string, pos: string): ER {\n  const vv = v(ctx, '_pfv')\n  const ev = v(ctx, '_pfe')\n  return {\n    stmts: [\n      `${ind(ctx)}const ${vv} = ${fnName}(input, ${pos}, _ctx)`,\n      // ref/lazy returns the inner failure verbatim \u2014 propagate the recorded\n      // deepest failure (shares _ctx with the named fn), not a \"parser\" label.\n      ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, propagateFailBody(ctx)),\n      `${ind(ctx)}const ${ev} = ${NAMED_FN_END}`,\n    ],\n    valueVar: vv,\n    endVar: ev,\n  }\n}\n\n/**\n * Emit a spanned-leaf capture into the active node()'s collectors (via _ctx,\n * matching the interpreter). Emitted only in a capturing compile; the runtime\n * `if (_ctx._cstLeaves)` guard means terminals outside a node() pay one\n * predictable branch and nothing else.\n */\nfunction emitLeafCapture(ctx: Ctx, valExpr: string, startExpr: string, endExpr: string): string[] {\n  if (!ctx.capturing) return []\n  if (ctx.capAsTrivia) return []\n  const i = ind(ctx)\n  const lf = v(ctx, '_lf')\n  return [\n    `${i}if (_ctx._cstLeaves) {`,\n    `${i}  const ${lf} = { _tag: 'leaf', value: ${valExpr}, span: { start: ${startExpr}, end: ${endExpr} } }`,\n    `${i}  _ctx._cstLeaves.push(${lf})`,\n    `${i}  if (_ctx._cstRawChildren) _ctx._cstRawChildren.push(${lf})`,\n    `${i}}`,\n  ]\n}\n\nfunction ensureRegexDecl(ctx: Ctx, source: string, flags: string): string {\n  const f = 'y' + flags.replace(/[gy]/g, '')\n  const key = `${source}/${f}`\n  let rName = ctx.regexMap.get(key)\n  if (rName === undefined) {\n    rName = `${nsp(ctx)}_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${rName} = /${source}/${f}`)\n    ctx.regexMap.set(key, rName)\n  }\n  return rName\n}\n\n/**\n * When `cap` is truthy, also records `[start, end]` (and optional insertIdx) into\n * `_ctx._triviaLog` / `_ctx._cstTriviaLog`. One emitted function serves both skip\n * and capture call sites \u2014 no duplicate trivia parser tree, no _tc wrapper call.\n */\nfunction ensureTriviaFn(ctx: Ctx): string {\n  const trivia = ctx.activeTrivia!\n  const existing = ctx.triviaFnNames.get(trivia)\n  if (existing) return existing\n  // Namespaced like every other hoisted name (`_re`/`_pf`/`_fx`): two fused pieces\n  // each define their own `_tf0` (e.g. CSS block-only vs Less block+line trivia),\n  // so without the ns prefix they collide in the fused scope and the wrong trivia\n  // skipper wins. `nsp(ctx)` is '' for standalone output (byte-identical).\n  const fnName = `${nsp(ctx)}_tf${ctx.triviaFnNames.size}`\n  ctx.triviaFnNames.set(trivia, fnName)\n  ctx.triviaCaptureNames.set(trivia, fnName)\n\n  const labeledSpec = analyzeLabeledTrivia(trivia)\n\n  // UNLABELED trivia: any scannable shape set \u2192 char-scan loop with a single\n  // whole-run [start,end] capture (no per-arm kinds needed).\n  if (!labeledSpec) {\n    const fastShapes = analyzeTriviaFastPath(trivia)\n    if (fastShapes) {\n      ctx.namedFnDecls.push(buildFastTriviaFnDecl(fnName, fastShapes))\n      return fnName\n    }\n  } else {\n    // LABELED trivia: if every arm is scannable, the same char-scan loop but with\n    // per-chunk kind capture (generalizes the old hardcoded ws-run + block-comment\n    // case to any shape set / arm count). Otherwise fall to the regex/runtime\n    // kind-tracking loops, which handle non-scannable arms.\n    const labeledShapes = analyzeLabeledScannableRun(trivia)\n    if (labeledShapes) {\n      ctx.namedFnDecls.push(buildLabeledScannableTriviaFnDecl(fnName, labeledShapes))\n      return fnName\n    }\n\n    const regexSpec = labeledTriviaRegexArms(trivia)\n    if (regexSpec) {\n      const reNames: string[] = []\n      for (const arm of regexSpec.arms) {\n        const def = arm.parser._def\n        if (def.tag !== 'regex') break\n        reNames.push(ensureRegexDecl(ctx, def.source, def.flags))\n      }\n      if (reNames.length === regexSpec.arms.length) {\n        ctx.namedFnDecls.push(buildLabeledRegexTriviaFnDecl(fnName, regexSpec, reNames))\n        return fnName\n      }\n    }\n\n    const rpStart = ctx.runtimeParsers.length\n    for (const arm of labeledSpec.arms) {\n      ctx.runtimeParsers.push(arm.parser)\n    }\n    ctx.namedFnDecls.push(buildLabeledRuntimeTriviaFnDecl(fnName, labeledSpec, rpStart))\n    return fnName\n  }\n\n  const savedIndent    = ctx.indent\n  const savedFailLabel = ctx.failLabel\n  const savedTrivia    = ctx.activeTrivia\n  const savedCapAsTrivia = ctx.capAsTrivia\n  ctx.indent    = 2\n  ctx.failLabel = '_triv'\n  ctx.capAsTrivia = true  // trivia terminals must not push into _cstLeaves\n  ctx.activeTrivia = undefined  // trivia parser must not skip trivia within itself\n  const r = emit(trivia, ctx, '_pos')\n  ctx.indent    = savedIndent\n  ctx.failLabel = savedFailLabel\n  ctx.capAsTrivia = savedCapAsTrivia\n  ctx.activeTrivia = savedTrivia\n\n  ctx.namedFnDecls.push([\n    `function ${fnName}(input, _pos, _ctx, _cap) {`,\n    `  let _e = _pos`,\n    `  _triv: {`,\n    ...reindentStmts(r.stmts, 2),\n    `    _e = ${r.endVar}`,\n    `  }`,\n    `  if (_cap && _e > _pos) {`,\n    `    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,\n    `    if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,\n    `  }`,\n    `  return _e`,\n    `}`,\n  ].join('\\n'))\n  return fnName\n}\n\n/** Capturing trivia skip \u2014 same compiled fn as ensureTriviaFn, pass `_cap = 1`. */\nfunction ensureTriviaCaptureFn(ctx: Ctx): string {\n  return ensureTriviaFn(ctx)\n}\n\n// ---------------------------------------------------------------------------\n// The result every emitter returns.\n// After the emitted stmts, `valueVar` holds the parsed value and `endVar`\n// holds the new position. On failure the emitter already emitted an early\n// `return failResult`.\n// ---------------------------------------------------------------------------\ntype ER = { stmts: string[]; valueVar: string; endVar: string }\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\nexport function firstSetCond(codeVar: string, fs: FirstSet): string {\n  if (fs.kind === 'any') return 'true'\n  if (fs.kind === 'empty') return 'false'\n  return fs.ranges.map(r =>\n    r.lo === r.hi\n      ? `${codeVar} === ${r.lo}`\n      : `(${codeVar} >= ${r.lo} && ${codeVar} <= ${r.hi})`\n  ).join(' || ')\n}\n\n// A first code point that keys a switch case is only worth enumerating when the\n// arm dispatches on a few DISCRETE points (keyword/operator first chars). A wide\n// range (a char-class arm like `[a-z]+`) would explode into dozens of `case`\n// labels, so those keep the if/else range-comparison form.\nconst SWITCH_RANGE_LIMIT = 4\nconst SWITCH_MAX_CASES = 48\nconst SWITCH_MIN_CASES = 3\n\n// Benchmark/test-only hook: force the `if/else if` disjoint-dispatch form so it\n// can be A/B'd against the `switch` jump table in the same process. Defaults to\n// off \u2014 production always uses planDisjointDispatch. See bench/codegen-ab.ts.\nlet _forceDisjointIf = false\nexport function __setForceDisjointIf(on: boolean): void { _forceDisjointIf = on }\n\n/**\n * Choose the dispatch form for a *disjoint* choice. Returns per-arm case code\n * points for a `switch` (jump table) when every arm keys off a small discrete\n * set, or `if` to keep the range-comparison `if/else if` chain. The arms are\n * pairwise-disjoint by construction, so each code point maps to exactly one arm.\n */\nfunction planDisjointDispatch(\n  parsers: ReadonlyArray<Combinator<unknown>>,\n): { kind: 'switch'; cases: number[][] } | { kind: 'if' } {\n  const cases: number[][] = []\n  let total = 0\n  for (const p of parsers) {\n    const fs = p._meta.firstSet\n    if (fs.kind !== 'ranges') return { kind: 'if' } // any/empty \u2192 no discrete keys\n    const pts: number[] = []\n    for (const r of fs.ranges) {\n      if (r.hi - r.lo + 1 > SWITCH_RANGE_LIMIT) return { kind: 'if' }\n      for (let cp = r.lo; cp <= r.hi; cp++) pts.push(cp)\n    }\n    total += pts.length\n    if (total > SWITCH_MAX_CASES) return { kind: 'if' }\n    cases.push(pts)\n  }\n  return total >= SWITCH_MIN_CASES ? { kind: 'switch', cases } : { kind: 'if' }\n}\n\n// \u2500\u2500 CST/trivia capture rollback: cheap when no buffer is active \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// The four capture buffers (`_cstLeaves`, `_cstRawChildren`, `_cstTriviaLog`,\n// `_triviaLog`) are usually all undefined on the hot path (a grammar with any\n// node() compiles with ctx.capturing=true, but at runtime most callers don't\n// request a CST \u2014 they only want the value). Reading `_x?.length ?? 0` four\n// times per fallible block \u2014 and emitFallible runs for every sequence term,\n// repeat item, optional, and choice arm \u2014 turned into a measurable de-opt\n// (compiled CSS regressed ~2.3\u00D7). We gate the whole save/restore on a single\n// boolean: when no buffer is live the marks are 0 and the restore is one test.\n/** Body of a capture restore \u2014 resets each live buffer to its saved length. */\nfunction captureRestoreBody(mL: string, mR: string, mTl: string, mLg: string | null, mF: string | null = null): string {\n  const fieldRestore = mF ? `; if (_ctx._fields) _ctx._fields.length = ${mF}` : ''\n  const base = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${mL}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${mR}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${mTl}${fieldRestore}`\n  // `_triviaLog` is the standalone diagnostic trivia log. The interpreter only\n  // rewinds it on a failed *choice* arm (choice.ts), NOT on a failed sequence\n  // term \u2014 a sequence returns the failure with earlier trivia still logged. To\n  // stay byte-for-byte at parity with the interpreter, only rewind it where the\n  // interpreter does (choice arms); sequence-term rollbacks (emitFallible) leave\n  // it intact.\n  return mLg ? `${base}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${mLg}` : base\n}\n\n/**\n * True when parsing `p` may push a capture (leaf/child/trivia) into the active\n * buffers and THEN fail, leaving partial state that an enclosing node() would\n * wrongly absorb. Used to decide whether a fallible block needs CST-rollback.\n *\n * Sound over-approximation: the ONLY constructs that capture-then-fail are\n *   - a sequence whose non-final term captures before a later term can fail\n *   - a sepBy/oneOrMore item-then-separator partial (handled by their own\n *     dedicated rollback, so still covered conservatively here)\n * Atomic terminals (literal/regex/keywords/charClass/guard/not) fail without\n * having captured. node() buffers into a private sub-scope and discards it on\n * failure, so it never leaks. choice/firstMatch roll back each failed arm\n * internally. optional/many never \"fail\" with partial output. Delegating\n * wrappers (transform/label/grammar/withCtx/expect/skip) pass through to inner.\n */\nfunction mayLeavePartialCapture(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  if (seen.has(p)) return false\n  seen.add(p)\n  const d = p._def\n  switch (d.tag) {\n    // Atomic / non-capturing-then-failing: a failure happens before any push.\n    case 'literal':\n    case 'regex':\n    case 'keywords':\n    case 'guard':\n    case 'not':\n    case 'trivia':\n    case 'token':\n    case 'scanTo':\n    case 'unknown':\n      return false\n    // node() captures into its own private buffers and rolls them back on\n    // failure (emitNode restores _ctx.* and never pushes on the !ok path).\n    case 'node':\n      return false\n    // choice/firstMatch already roll back each failed arm; on overall failure\n    // nothing committed remains.\n    case 'choice':\n      return false\n    // optional never fails; many/oneOrMore only \"fail\" with zero captured items.\n    case 'optional':\n    case 'many':\n    case 'oneOrMore':\n      return false\n    // sepBy emits its own per-iteration rollback in emitSepBy.\n    case 'sepBy':\n      return false\n    // A sequence is the real case: an earlier capturing term followed by a term\n    // that can fail leaves the earlier captures buffered.\n    case 'sequence': {\n      const parts = d.parsers\n      // Only risky if >=2 terms and some non-final term can capture.\n      if (parts.length < 2) return parts.some(x => mayLeavePartialCapture(x, seen))\n      for (let i = 0; i < parts.length - 1; i++) {\n        if (hasNodeDef(parts[i]!) || capturesLeaf(parts[i]!)) return true\n      }\n      return false\n    }\n    // Delegating wrappers: defer to the wrapped parser.\n    case 'transform':\n    case 'label':\n    case 'field':\n    case 'expect':\n    case 'withCtx':\n    case 'grammar':\n      return mayLeavePartialCapture(d.parser, seen)\n    case 'skip':\n      return mayLeavePartialCapture(d.main, seen)\n    case 'recover':\n      return mayLeavePartialCapture(d.parser, seen)\n    case 'lazy': {\n      try { return mayLeavePartialCapture(d.thunk(), seen) } catch { return true }\n    }\n    // Unknown shapes: be safe and keep the rollback.\n    default:\n      return true\n  }\n}\n\n/** True when `p` can push a leaf/node into the capture buffers on success. */\nfunction capturesLeaf(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  if (seen.has(p)) return false\n  seen.add(p)\n  const d = p._def\n  switch (d.tag) {\n    case 'literal':\n    case 'regex':\n    case 'keywords':\n    case 'node':\n    case 'token':\n      return true\n    case 'not':\n    case 'guard':\n    case 'trivia':\n    case 'unknown':\n      return false\n    case 'sequence':\n    case 'choice':\n      return d.parsers.some(x => capturesLeaf(x, seen))\n    case 'sepBy':\n      return capturesLeaf(d.parser, seen) || capturesLeaf(d.separator, seen)\n    case 'many':\n    case 'oneOrMore':\n    case 'optional':\n    case 'transform':\n    case 'label':\n    case 'field':\n    case 'expect':\n    case 'withCtx':\n    case 'grammar':\n    case 'recover':\n      return capturesLeaf(d.parser, seen)\n    case 'skip':\n      return capturesLeaf(d.main, seen)\n    case 'scanTo':\n      return true\n    case 'lazy': {\n      try { return capturesLeaf(d.thunk(), seen) } catch { return true }\n    }\n    default:\n      return true\n  }\n}\n\n/** Wrap stmts + success return in an IIFE. Returns the IIFE expression string. */\nfunction asIIFE(stmts: string[], valueVar: string, endVar: string, startPos: string, indent: string): string {\n  return [\n    `(() => {`,\n    ...stmts,\n    `${indent}  return { ok: true, value: ${valueVar}, span: { start: ${startPos}, end: ${endVar} } }`,\n    `${indent}})()`,\n  ].join('\\n')\n}\n\n/**\n * Emit `inner` as a labeled block with flat result variables \u2014 no IIFE call,\n * no `{ ok, value, span }` object allocation.  The returned stmts declare:\n *   let ${okVar} = false, ${valVar}, ${endVar} = ${pos}\n *   ${label}: { <inner stmts using break ${label} on failure>; capture success }\n * Callers read ${okVar} to branch on success/failure.\n */\nfunction emitFallible(\n  inner: Combinator<unknown>,\n  ctx: Ctx,\n  pos: string,\n  /**\n   * When true, the caller DISCARDS this failure (optional/many/sepBy/not) \u2014 the\n   * inner leaves need not record `_ctx._fx`, since nobody reads it. Suppresses\n   * the hot-path failure bookkeeping for the sub-parse.\n   */\n  swallow = false,\n): { stmts: string[]; okVar: string; valVar: string; endVar: string } {\n  const lbl  = v(ctx, '_lbl')\n  const okV  = `${lbl}ok`\n  const valV = `${lbl}v`\n  const endV = `${lbl}e`\n\n  const savedLabel  = ctx.failLabel\n  const savedIndent = ctx.indent\n  const savedRecord = ctx.recordFail\n  ctx.failLabel = lbl\n  ctx.indent    = savedIndent + 1\n  if (swallow) ctx.recordFail = false\n  const r = emit(inner, ctx, pos)\n  ctx.failLabel = savedLabel\n  ctx.indent    = savedIndent\n  ctx.recordFail = savedRecord\n\n  const ind0 = ind(ctx)\n  // In capturing mode, roll back any CST captures made by a FAILED attempt \u2014 a\n  // sub-parser may match terminals (e.g. a sequence that consumes '[') and then\n  // fail on a later term, breaking out with those leaves/trivia still buffered.\n  // Without this they leak into the enclosing node()'s children. (The non-disjoint\n  // choice path does the same per-arm; a disjoint choice commits to one arm and\n  // relies on this boundary to undo a failed commit.)\n  //\n  // The rollback is only needed when `inner` can push a capture and THEN fail\n  // (i.e. leave partial buffered state). Atomic terminals, self-contained nodes,\n  // choices/repeats that roll back internally, etc. never leave partial captures\n  // \u2014 emitting the save/restore around every fallible block (every sequence term)\n  // was a ~2.3\u00D7 compiled-CSS regression. Gate it on the structural predicate so\n  // hot grammars compile back to tight code while correctness is preserved.\n  // A failed sequence term does NOT rewind `_triviaLog` (the interpreter leaves\n  // earlier trivia logged) \u2014 only the CST child buffers are restored here.\n  const needsRollback = ctx.capturing && mayLeavePartialCapture(inner)\n  const needsFieldRollback = needsRollback && parserHasOwnFields(inner)\n  const mL  = needsRollback ? v(ctx, '_fcl')  : null\n  const mR  = needsRollback ? v(ctx, '_fcr')  : null\n  const mTl = needsRollback ? v(ctx, '_fctl') : null\n  const mF  = needsFieldRollback ? v(ctx, '_fcf')  : null\n  const stmts = [\n    `${ind0}let ${okV} = false, ${valV}, ${endV} = ${pos}`,\n    ...(mL ? [\n      `${ind0}const ${mL} = _ctx._cstLeaves?.length ?? 0`,\n      `${ind0}const ${mR} = _ctx._cstRawChildren?.length ?? 0`,\n      `${ind0}const ${mTl} = _ctx._cstTriviaLog?.length ?? 0`,\n      ...(mF ? [`${ind0}const ${mF} = _ctx._fields?.length ?? 0`] : []),\n    ] : []),\n    `${ind0}${lbl}: {`,\n    ...r.stmts,\n    `${ind0}  ${valV} = ${r.valueVar}; ${endV} = ${r.endVar}; ${okV} = true`,\n    `${ind0}}`,\n    ...(mL ? [\n      `${ind0}if (!${okV}) { ${captureRestoreBody(mL, mR!, mTl!, null, mF)} }`,\n    ] : []),\n  ]\n  return { stmts, okVar: okV, valVar: valV, endVar: endV }\n}\n\n\n// ---------------------------------------------------------------------------\n// Per-combinator emitters\n// ---------------------------------------------------------------------------\n\n/**\n * Above this length, an unrolled `charCodeAt` chain stops paying for itself:\n * measured crossover where native `startsWith` wins on runtime is ~256\u2013512\n * chars, but the unrolled chain's *generated source* grows ~4\u201330\u00D7 faster than\n * `startsWith`'s near-constant call site (see PERF_IDEAS.md). No literal in a\n * real grammar (keywords, punctuation) gets remotely close to this \u2014 the\n * longest in this repo's example grammars is `important` (9 chars) \u2014 so this\n * threshold exists to cap codegen bloat on a pathological literal, not because\n * `startsWith` is faster there.\n */\nconst CHARCODE_CHAIN_MAX = 16\n\nfunction emitLit(def: Extract<ParserDef, { tag: 'literal' }>, ctx: Ctx, pos: string): ER {\n  const { value, caseInsensitive } = def\n  const len = value.length\n  const vv = v(ctx)\n  const expectedStr = JSON.stringify(JSON.stringify(value))\n  const stmts: string[] = []\n\n  if (caseInsensitive && len > 0) {\n    // ASCII case fold, the same `(c | 32) === lower` bit-OR compare that `/i`-flag\n    // regex lowering uses (foldEq) \u2014 NOT Intl.Collator (measured ~9\u00D7 slower, and\n    // its Unicode accent-folding is the wrong semantic for a parser anyway). Folds\n    // ASCII letters, exact-matches everything else. The captured value is the\n    // input's own casing (slice), not the pattern's.\n    const match = Array.from({ length: len }, (_, i) =>\n      `(${foldEq(`input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ''})`, value.charCodeAt(i))})`\n    ).join(' && ')\n    stmts.push(\n      ...emitIfFail(ctx, `${pos} + ${len} > input.length || !(${match})`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = input.slice(${pos}, ${pos} + ${len})`,\n    )\n  } else if (len === 0) {\n    stmts.push(`${ind(ctx)}const ${vv} = ''`)\n  } else if (len === 1) {\n    const code = value.codePointAt(0)!\n    stmts.push(\n      ...emitIfFail(ctx, `${pos} >= input.length || input.charCodeAt(${pos}) !== ${code}`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`,\n    )\n  } else if (len <= CHARCODE_CHAIN_MAX) {\n    const checks = Array.from({ length: len }, (_, i) =>\n      `input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ''}) !== ${value.codePointAt(i)!}`\n    ).join(' || ')\n    stmts.push(\n      ...emitIfFail(ctx, `${pos} + ${len} > input.length || ${checks}`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`,\n    )\n  } else {\n    // startsWith(str, pos) avoids allocating a slice \u2014 it handles the bounds check\n    // internally and compares in-place. No first-char guard needed either.\n    stmts.push(\n      ...emitIfFail(ctx, `!input.startsWith(${JSON.stringify(value)}, ${pos})`, failBody(ctx, expectedStr, pos)),\n      `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`,\n    )\n  }\n\n  const endVar = len === 0 ? pos : `${pos} + ${len}`\n  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar))\n  return { stmts, valueVar: vv, endVar }\n}\n\nfunction escapeKeywordRe(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/**\n * Fast path for `keywords()`/`word()`/`makeWord()`: each word is a FIXED\n * literal (optionally wrapped in the shared boundary lookahead), so this\n * reuses the exact `seq`/`litFold`/`lookahead` `ScanShape` machinery from\n * `scannable-run.ts` (PERF_IDEAS \u00A78b) instead of one `RegExp.exec` alternation\n * per match. Unconditionally ambiguity-safe: `trailingBacktrackClass` treats a\n * single-literal `seq` and `litFold` as fixed-length (no quantifier to\n * backtrack), so wrapping either in a lookahead is safe for ANY boundary class\n * \u2014 no `seqIsUnambiguous`-style check is needed here.\n *\n * Declines (returns `null`, caller falls back to the regex alternation) for:\n *   - an empty-string keyword (degenerate; not worth special-casing)\n *   - a keyword containing an astral (surrogate-pair) code point \u2014 the `seq`/\n *     `litFold` codegen advances one `charCodeAt` UTF-16 unit per code POINT,\n *     which only holds for the BMP (same reason `scanShapeFromRegex` refuses\n *     the `u` flag entirely); real keyword sets are BMP identifiers, so this\n *     is a defensive, not a practical, limitation\n *   - a boundary class this file can't parse (defensive; `parseClassRanges`\n *     handles every realistic boundary string, e.g. `_0-9A-Za-z`)\n *   - `caseInsensitive` combined with a boundary \u2014 the boundary class would\n *     ALSO need ASCII case-folding to match the original regex's `/i` flag\n *     (the general \"`/i` on a char class\" problem, PERF_IDEAS \u00A78d, not yet\n *     built), so this combination is left on the safe, slower path rather\n *     than risk silently narrowing which chars the boundary excludes.\n */\nfunction emitKeywordsFast(def: Extract<ParserDef, { tag: 'keywords' }>, ctx: Ctx, pos: string): ER | null {\n  if (def.words.length === 0 || def.words.some(w => w.length === 0)) return null\n  if (def.words.some(w => Array.from(w).length !== w.length)) return null\n  if (def.caseInsensitive && def.boundary) return null\n\n  let boundary: { ranges: Array<[number, number]>; negated: boolean } | null = null\n  if (def.boundary) {\n    let body = def.boundary\n    const negated = body.startsWith('^')\n    if (negated) body = body.slice(1)\n    const ranges = parseClassRanges(body)\n    if (!ranges) return null\n    boundary = { ranges, negated }\n  }\n\n  const mint: Mint = (prefix = '_v') => v(ctx, prefix)\n  const lbl = v(ctx, '_kwLbl')\n  const valV = v(ctx, '_kwv')\n  const endV = v(ctx, '_kwe')\n  const bodyInd = ind(ctx) + '  '\n\n  const tries: string[] = []\n  for (const w of def.words) {\n    const cps = Array.from(w, ch => ch.codePointAt(0)!)\n    let shape: ScanShape = def.caseInsensitive\n      ? { kind: 'litFold', open: cps }\n      : { kind: 'seq', parts: [{ part: 'lit', cps, optional: false }] }\n    if (boundary) {\n      shape = { kind: 'lookahead', inner: shape, ranges: boundary.ranges, classNegated: boundary.negated, negative: true }\n    }\n    const m = emitShapeMatch(shape, pos, mint, bodyInd)\n    tries.push(\n      ...m.setup,\n      // Slice from input rather than reusing the literal word: `caseInsensitive`\n      // must return the text as it actually appeared (e.g. \"ABC\" for keyword\n      // \"abc\"), matching what the original `RegExp.exec()[0]` returned.\n      `${bodyInd}if (${m.ok}) { ${valV} = input.slice(${pos}, ${m.end}); ${endV} = ${m.end}; break ${lbl} }`,\n    )\n  }\n\n  const stmts = [\n    `${ind(ctx)}let ${valV} = '', ${endV} = ${pos}`,\n    `${ind(ctx)}${lbl}: {`,\n    ...tries,\n    `${ind(ctx)}}`,\n    // Every word has length >= 1 (checked above), so a real match always\n    // advances past `pos` \u2014 `endV === pos` only happens when no candidate matched.\n    ...emitIfFail(ctx, `${endV} === ${pos}`, failBody(ctx, '\"keyword\"', pos)),\n  ]\n  stmts.push(...emitLeafCapture(ctx, valV, pos, endV))\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\nfunction emitKeywords(def: Extract<ParserDef, { tag: 'keywords' }>, ctx: Ctx, pos: string): ER {\n  const fast = emitKeywordsFast(def, ctx, pos)\n  if (fast) return fast\n\n  const alt = def.words.map(escapeKeywordRe).join('|')\n  const boundary = def.boundary ? `(?![${def.boundary}])` : ''\n  const flags = def.caseInsensitive ? 'iuy' : 'uy'\n  const source = `(?:${alt})${boundary}`\n  const key = `${source}/${flags}`\n  let rName = ctx.regexMap.get(key)\n  if (rName === undefined) {\n    rName = `${nsp(ctx)}_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${rName} = /${source}/${flags}`)\n    ctx.regexMap.set(key, rName)\n  }\n\n  const mv = v(ctx, '_m')\n  const vv = v(ctx)\n  const stmts = [\n    `${ind(ctx)}${rName}.lastIndex = ${pos}`,\n    `${ind(ctx)}const ${mv} = ${rName}.exec(input)`,\n    ...emitIfFail(ctx, `${mv} === null`, failBody(ctx, '\"keyword\"', pos)),\n    `${ind(ctx)}const ${vv} = ${mv}[0]`,\n  ]\n  const endVar = `${pos} + ${vv}.length`\n  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar))\n  return { stmts, valueVar: vv, endVar }\n}\n\nfunction emitRegex(def: Extract<ParserDef, { tag: 'regex' }>, ctx: Ctx, pos: string): ER {\n  const expectedStr = JSON.stringify(`/${def.source}/`)\n  const shape = scanShapeFromRegex(def.source, def.flags)\n  if (shape) {\n    const vv = v(ctx)\n    const scanned = emitScannableTerminal(shape, {\n      ind: ind(ctx),\n      pos,\n      valueVar: vv,\n      failIf: (cond: string) => emitIfFail(ctx, cond, failBody(ctx, expectedStr, pos)),\n      fresh: (prefix?: string) => v(ctx, prefix),\n    })\n    if (scanned) {\n      const stmts = [...scanned.stmts, ...emitLeafCapture(ctx, vv, pos, scanned.endVar)]\n      return { stmts, valueVar: vv, endVar: scanned.endVar }\n    }\n  }\n\n  // Didn't lower to the fast charCodeAt scan \u2014 record it and fall back to RegExp.\n  _loweringSink?.add(`/${def.source}/${def.flags}`)\n\n  const flags = 'y' + def.flags.replace(/[gy]/g, '')\n  const key = `${def.source}/${flags}`\n  let rName = ctx.regexMap.get(key)\n  if (rName === undefined) {\n    rName = `${nsp(ctx)}_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${rName} = /${def.source}/${flags}`)\n    ctx.regexMap.set(key, rName)\n  }\n\n  const mv = v(ctx, '_m')\n  const vv = v(ctx)\n  const stmts = [\n    `${ind(ctx)}${rName}.lastIndex = ${pos}`,\n    `${ind(ctx)}const ${mv} = ${rName}.exec(input)`,\n    ...emitIfFail(ctx, `${mv} === null`, failBody(ctx, expectedStr, pos)),\n    `${ind(ctx)}const ${vv} = ${mv}[0]`,\n  ]\n  const endVar = `${pos} + ${vv}.length`\n  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar))\n  return { stmts, valueVar: vv, endVar }\n}\n\n/**\n * A JS expression that builds a zero-width follow-set sync sentinel for `fs` at\n * RUNTIME via `_ctx._rec.sentinel(...)` \u2014 never `_rp` \u2014 so a recovery-enabled\n * grammar keeps `runtimeParsers` empty and stays macro-inlinable. Returns null when\n * the first-set is `any`/`empty` (no usable sentinel). The build is only reached on\n * the tolerant path (the publish that uses it is `_ctx._tolerant`-gated), so a strict\n * parse of the shipped grammar allocates nothing.\n */\nfunction syncSentinelExpr(fs: FirstSet): string | null {\n  if (fs.kind !== 'ranges' || fs.ranges.length === 0) return null\n  return `_ctx._rec.sentinel({ kind: 'ranges', ranges: ${JSON.stringify(fs.ranges)} })`\n}\n\nfunction emitSeqValues(def: Extract<ParserDef, { tag: 'sequence' }>, ctx: Ctx, pos: string): ER & { valueVars: string[] } {\n  const startV = v(ctx, '_start')\n  const curV = v(ctx, '_cur')\n  const stmts: string[] = [\n    `${ind(ctx)}const ${startV} = ${pos}`,\n    `${ind(ctx)}let ${curV} = ${pos}`,\n  ]\n  const valueVars: string[] = []\n\n  // Recovery sync publish (compile-time gate): save the inherited sync at entry,\n  // then before each term set `_ctx._sync` to the inferred follow-set sentinel of\n  // the remaining terms (or the inherited sync when none is usable) so a nested\n  // list resyncs to the enclosing delimiter. Runtime-gated by `_ctx._tolerant`;\n  // strict parses never touch it.\n  const syncInV = ctx.recovery ? v(ctx, '_syncIn') : ''\n  if (ctx.recovery) stmts.push(`${ind(ctx)}const ${syncInV} = _ctx._sync`)\n  const publishSync = (i: number): string => {\n    if (!ctx.recovery) return ''\n    const fs = def.parsers.slice(i + 1).reduce<FirstSet>((acc, p) => union(acc, firstSetOf(p)), { kind: 'empty' })\n    const ref = syncSentinelExpr(fs)\n    return `${ind(ctx)}if (_ctx._tolerant) _ctx._sync = ${ref ?? syncInV}`\n  }\n\n  for (let i = 0; i < def.parsers.length; i++) {\n    const syncPub = publishSync(i)\n    if (syncPub) stmts.push(syncPub)\n    if (i > 0 && ctx.activeTrivia) {\n      if (ctx.capturing) {\n        const capFn = ensureTriviaCaptureFn(ctx)\n        const markV = v(ctx, '_mk')\n        const markTl = v(ctx, '_mktl')\n        const markLog = v(ctx, '_mklg')\n        const scanEndV = v(ctx, '_sne')\n        stmts.push(\n          `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n          `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,\n          `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,\n          `${ind(ctx)}const ${scanEndV} = ${capFn}(input, ${curV}, _ctx, 1)`,\n        )\n        const r = emit(def.parsers[i]!, ctx, scanEndV)\n        stmts.push(...r.stmts)\n        const endAfterV = v(ctx, '_sea')\n        stmts.push(\n          `${ind(ctx)}const ${endAfterV} = ${r.endVar}`,\n          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) { ${curV} = ${endAfterV} } else { if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; }`,\n        )\n        valueVars.push(r.valueVar)\n        continue\n      } else {\n        // Match the interpreter (sequence.ts): scan trivia to a temp position, but\n        // only *commit* it (advance cur) if the following term consumes content past\n        // it. A term matching empty (optional/many/lookahead) leaves cur pre-trivia,\n        // so trailing whitespace stays out of the sequence's span. The non-capturing\n        // trivFn has no side effects when called without `_cap`, so there is nothing\n        // to roll back \u2014 just keep cur unchanged.\n        const trivFn = ensureTriviaFn(ctx)\n        const scanEndV = v(ctx, '_sne')\n        stmts.push(`${ind(ctx)}const ${scanEndV} = ${trivFn}(input, ${curV}, _ctx)`)\n        const r = emit(def.parsers[i]!, ctx, scanEndV)\n        stmts.push(...r.stmts)\n        const endAfterV = v(ctx, '_sea')\n        stmts.push(\n          `${ind(ctx)}const ${endAfterV} = ${r.endVar}`,\n          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) ${curV} = ${endAfterV}`,\n        )\n        valueVars.push(r.valueVar)\n        continue\n      }\n    }\n    const r = emit(def.parsers[i]!, ctx, curV)\n    stmts.push(...r.stmts, `${ind(ctx)}${curV} = ${r.endVar}`)\n    valueVars.push(r.valueVar)\n  }\n\n  return { stmts, valueVar: valueVars[valueVars.length - 1] ?? 'null', endVar: curV, valueVars }\n}\n\nfunction emitSeq(def: Extract<ParserDef, { tag: 'sequence' }>, ctx: Ctx, pos: string): ER {\n  const { stmts, endVar, valueVars } = emitSeqValues(def, ctx, pos)\n  // The tuple is never observed (markUnusedValues) \u2014 terms still parse + capture;\n  // skip allocating `[v1, v2, \u2026]`.\n  if (def.valueUnused) return { stmts, valueVar: 'undefined', endVar }\n  const arrV = v(ctx, '_arr')\n  stmts.push(`${ind(ctx)}const ${arrV} = [${valueVars.join(', ')}]`)\n  return { stmts, valueVar: arrV, endVar }\n}\n\n/**\n * Deep-first `expected` labels for a choice's arms \u2014 the concatenation of each\n * arm's leftmost-leaf expected set, matching what the interpreter collects when\n * no arm's first-set matches (choice.ts) and what expect()'s deriveExpected()\n * reports. Falls back to the arm's tag only for arms with no static expectation\n * (e.g. runtime-fallback combinators), preserving the previous behaviour there.\n */\nfunction deriveExpectedArr(parsers: Combinator<unknown>[]): string {\n  return JSON.stringify(parsers.flatMap(p => {\n    const e = deriveExpected(p)\n    return e.length > 0 ? e : [p._tag]\n  }))\n}\n\n/**\n * True when `p` can only fail at its own start position (its failure span is\n * `{pos,pos}` and its expected set is a fixed label). Such disjoint-choice arms\n * can be emitted inline: their leaf failure already matches the interpreter's\n * `{expected: <label>, span: {pos,pos}}`. Composite arms (sequence, node, \u2026) can\n * fail deeper, so they must be wrapped to re-anchor the span at the choice pos.\n */\nfunction failsAtStart(p: Combinator<unknown>): boolean {\n  const d = p._def\n  switch (d.tag) {\n    case 'literal': case 'regex': case 'keywords': case 'guard': case 'not':\n      return true\n    case 'transform': case 'label': case 'field':\n      return failsAtStart(d.parser)\n    default:\n      return false\n  }\n}\n\n/** Hoisted module-level const for one arm's static `expected` labels. */\nfunction armStaticExpected(ctx: Ctx, p: Combinator<unknown>): string {\n  return hoistExpected(ctx, deriveExpectedArr([p]))\n}\n\n/**\n * True when `p` can succeed at `pos` without consuming input (e.g. a starred\n * regex, optional, many). Such arms must still be tried even when the current\n * code point is outside their first-set \u2014 skipping them would change semantics.\n */\nfunction canMatchEmptyAtStart(p: Combinator<unknown>): boolean {\n  const d = p._def\n  switch (d.tag) {\n    case 'regex':\n      return /(?:[*?]|\\{0,|\\{\\d*,)/.test(d.source)\n    case 'optional': return true\n    case 'many': return true\n    case 'transform': case 'label': case 'field':\n      return canMatchEmptyAtStart(d.parser)\n    case 'literal':\n      return d.value.length === 0\n    default:\n      return false\n  }\n}\n\n/** Emit a first-set guard when the arm cannot match empty and has a finite first-set. */\nfunction needsFirstSetGuard(p: Combinator<unknown>): boolean {\n  const fs = p._meta.firstSet\n  return fs.kind !== 'any' && !canMatchEmptyAtStart(p)\n}\n\n/**\n * Emit one arm of a disjoint choice, assigning its value/end to `valV`/`endV`.\n * Leaf arms (failsAtStart) are inlined \u2014 their leaf failure already matches the\n * interpreter. Composite arms are wrapped so that on failure the choice reports\n * the arm's deep `expected` (via _ctx._fx) but re-anchors the span at the choice\n * position `pos` \u2014 exactly what the interpreter's disjoint dispatch returns.\n */\nfunction emitDisjointArm(p: Combinator<unknown>, ctx: Ctx, pos: string, valV: string, endV: string): string[] {\n  if (failsAtStart(p)) {\n    const r = emit(p, ctx, pos)\n    return [...r.stmts, `${ind(ctx)}${valV} = ${r.valueVar}`, `${ind(ctx)}${endV} = ${r.endVar}`]\n  }\n  const { stmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos)\n  return [\n    ...stmts,\n    ...emitIfFail(ctx, `!${okVar}`, failArrBody(ctx, '_ctx._fx', pos, false)),\n    `${ind(ctx)}${valV} = ${valVar}`,\n    `${ind(ctx)}${endV} = ${endVar}`,\n  ]\n}\n\n/**\n * Register a disjoint-choice arm's gate predicate (if any) into `mapFns` and emit\n * the guarded arm body. Mirrors emitFirstMatch's gate handling: the gate closure\n * is pushed into `mapFns` (with its source into `mapFnSrcs` \u2014 `def.gateSrcs[i]`\n * for the macro, null for compile()) BEFORE the arm body is emitted, so the\n * per-arm push order (gate, then arm transforms) stays parallel with the macro's\n * pre-accumulated sources and the emitFirstMatch layout.\n *\n * A gated arm dispatches on its first char, then checks the gate INSIDE that\n * branch: gate true \u2192 run the arm; gate false \u2192 FAIL the choice at `pos` (sound\n * because disjoint + non-nullable arms guarantee no other arm matches this char).\n */\nfunction emitDisjointArmGated(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  i: number,\n  ctx: Ctx,\n  pos: string,\n  valV: string,\n  endV: string,\n): string[] {\n  const p = def.parsers[i]!\n  const gate = def.gates[i]\n  if (!gate) return emitDisjointArm(p, ctx, pos, valV, endV)\n\n  const gateIdx = ctx.mapFns.length\n  ctx.mapFns.push(gate as (v: unknown, span: unknown) => unknown)\n  // Macro path inlines the captured gate source; compile() has no source \u2192 null.\n  // Parallel-length invariant with mapFns preserved either way.\n  ctx.mapFnSrcs.push(def.gateSrcs?.[i] ?? null)\n  const gateCond = `${mfRef(ctx)}[${gateIdx}](_ctx.state)`\n\n  const stmts = [`${ind(ctx)}if (${gateCond}) {`]\n  ctx.indent++\n  stmts.push(...emitDisjointArm(p, ctx, pos, valV, endV))\n  ctx.indent--\n  stmts.push(`${ind(ctx)}} else { ${failArrBody(ctx, deriveExpectedArr([p]), pos)} }`)\n  return stmts\n}\n\nfunction emitChoice(def: Extract<ParserDef, { tag: 'choice' }>, ctx: Ctx, pos: string): ER {\n  const allExpected = deriveExpectedArr(def.parsers)\n\n  // \u2500\u2500 Disjoint: O(1) first-char dispatch (arms may be gated) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  if (def.disjoint) {\n    const codeV = v(ctx, '_code')\n    const valV = v(ctx, '_chv')\n    const endV = v(ctx, '_che')\n    const stmts: string[] = [\n      `${ind(ctx)}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,\n      `${ind(ctx)}let ${valV}, ${endV} = ${pos}`,\n    ]\n\n    const plan = _forceDisjointIf ? { kind: 'if' as const } : planDisjointDispatch(def.parsers)\n\n    // Switch (jump table) when arms key off a few discrete first code points.\n    if (plan.kind === 'switch') {\n      stmts.push(`${ind(ctx)}switch (${codeV}) {`)\n      ctx.indent++\n      for (let i = 0; i < def.parsers.length; i++) {\n        for (const cp of plan.cases[i]!) stmts.push(`${ind(ctx)}case ${cp}:`)\n        stmts.push(`${ind(ctx)}{`)\n        ctx.indent++\n        stmts.push(\n          ...emitDisjointArmGated(def, i, ctx, pos, valV, endV),\n          `${ind(ctx)}break`,\n        )\n        ctx.indent--\n        stmts.push(`${ind(ctx)}}`)\n      }\n      stmts.push(`${ind(ctx)}default: ${failArrBody(ctx, allExpected, pos)}`)\n      ctx.indent--\n      stmts.push(`${ind(ctx)}}`)\n      return { stmts, valueVar: valV, endVar: endV }\n    }\n\n    // Otherwise if/else if with range comparisons (cheaper for char-class arms).\n    let first = true\n    for (let i = 0; i < def.parsers.length; i++) {\n      const p = def.parsers[i]!\n      const cond = firstSetCond(codeV, p._meta.firstSet)\n      const kw = first ? 'if' : 'else if'\n      first = false\n      stmts.push(`${ind(ctx)}${kw} (${cond}) {`)\n      ctx.indent++\n      stmts.push(...emitDisjointArmGated(def, i, ctx, pos, valV, endV))\n      ctx.indent--\n      stmts.push(`${ind(ctx)}}`)\n    }\n    stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)))\n    return { stmts, valueVar: valV, endVar: endV }\n  }\n\n  return emitNonDisjoint(def, def.strategy, allExpected, ctx, pos)\n}\n\n// \u2500\u2500 greedyClassify: run the super-regex once, classify by string equality \u2500\u2500\u2500\u2500\n// Single regex exec + O(n_literals) string comparisons. Zero backtracking.\nfunction emitGreedyClassify(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  superIndex: number,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const superParser = def.parsers[superIndex]!\n  const regexDef = getCoreRegexDef(superParser)!\n\n  // Hoist the regex (same mechanism as emitRegex, with dedup)\n  const cleanFlags = 'y' + regexDef.flags.replace(/[gy]/g, '')\n  const reKey = `${regexDef.source}/${cleanFlags}`\n  let reVar = ctx.regexMap.get(reKey)\n  if (reVar === undefined) {\n    reVar = `${nsp(ctx)}_re${ctx.regexDecls.length}`\n    ctx.regexDecls.push(`const ${reVar} = /${regexDef.source}/${cleanFlags}`)\n    ctx.regexMap.set(reKey, reVar)\n  }\n\n  const matchV = v(ctx, '_gm')\n  const wordV  = v(ctx, '_gw')\n  const endV   = v(ctx, '_ge')\n  const valV   = v(ctx, '_gcv')\n\n  // On no-match the interpreter returns the super-regex arm's failure verbatim\n  // (choice.ts) \u2014 report only the regex's expected, not every classified literal.\n  const regexExpected = JSON.stringify(deriveExpected(superParser))\n  const stmts: string[] = [\n    `${ind(ctx)}${reVar}.lastIndex = ${pos}`,\n    `${ind(ctx)}const ${matchV} = ${reVar}.exec(input)`,\n    ...emitIfFail(ctx, `${matchV} === null`, failArrBody(ctx, regexExpected, pos)),\n    `${ind(ctx)}const ${wordV} = ${matchV}[0]`,\n    `${ind(ctx)}const ${endV} = ${pos} + ${wordV}.length`,\n    `${ind(ctx)}let ${valV}`,\n  ]\n\n  // For each literal arm: if word === literal, capture + transform chain\n  let first = true\n  for (let i = 0; i < def.parsers.length; i++) {\n    if (i === superIndex) continue\n    const p = def.parsers[i]!\n    const litVal = getCoreLiteralValue(p)\n    if (litVal === null) continue\n\n    const kw = first ? 'if' : 'else if'\n    first = false\n    stmts.push(`${ind(ctx)}${kw} (${wordV} === ${JSON.stringify(litVal)}) {`)\n    ctx.indent++\n    const tR = emitTransformChain(p, JSON.stringify(litVal), endV, pos, ctx)\n    stmts.push(...emitLeafCapture(ctx, JSON.stringify(litVal), pos, endV))\n    stmts.push(...tR.stmts, `${ind(ctx)}${valV} = ${tR.valueVar}`)\n    ctx.indent--\n    stmts.push(`${ind(ctx)}}`)\n  }\n\n  // Regex arm: capture + transform chain for the matched word\n  const rR = emitTransformChain(superParser, wordV, endV, pos, ctx)\n  const regexKw = first ? 'if' : 'else'\n  stmts.push(`${ind(ctx)}${regexKw} {`)\n  ctx.indent++\n  stmts.push(...emitLeafCapture(ctx, wordV, pos, endV), ...rR.stmts, `${ind(ctx)}${valV} = ${rR.valueVar}`)\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\n// \u2500\u2500 literalsLongestFirst: sorted startsWith checks, no backtracking \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfunction emitLiteralsLongestFirst(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  sortedIndices: number[],\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const valV = v(ctx, '_llv')\n  const endV = v(ctx, '_lle')\n  const stmts: string[] = [`${ind(ctx)}let ${valV}, ${endV} = ${pos}`]\n\n  let first = true\n  for (const idx of sortedIndices) {\n    const p = def.parsers[idx]!\n    const litVal = getCoreLiteralValue(p)!\n    const litLen = litVal.length\n\n    // Emit the literal check as a direct condition (no IIFE/try-catch \u2014 literals never throw)\n    const litCond = emitLiteralCondition(litVal, pos)\n    const kw = first ? 'if' : 'else if'\n    first = false\n\n    const litEnd = `${pos} + ${litLen}`\n    stmts.push(`${ind(ctx)}${kw} (${litCond}) {`)\n    ctx.indent++\n    const tR = emitTransformChain(p, JSON.stringify(litVal), litEnd, pos, ctx)\n    stmts.push(\n      ...emitLeafCapture(ctx, JSON.stringify(litVal), pos, litEnd),\n      ...tR.stmts,\n      `${ind(ctx)}${valV} = ${tR.valueVar}`,\n      `${ind(ctx)}${endV} = ${litEnd}`,\n    )\n    ctx.indent--\n    stmts.push(`${ind(ctx)}}`)\n  }\n  stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)))\n\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\n// \u2500\u2500 firstMatch fallback: PEG + auto-not inline rejection + per-arm gates \u2500\u2500\u2500\u2500\u2500\n// Uses labeled blocks (emitFallible) instead of IIFE+try/catch to avoid V8\n// deoptimization from exception-based control flow.\nfunction emitFirstMatch(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const resValV = v(ctx, '_crv')\n  const resEndV = v(ctx, '_cre')\n  const resOkV  = v(ctx, '_crok')\n  const codeV   = v(ctx, '_chcode')\n  // For a TOTAL failure we report the concatenation of each tried arm's deep\n  // `expected` (interpreter parity). To keep the hot success path allocation-free\n  // (a choice that ultimately matches must NOT pay for error bookkeeping), each\n  // failed arm snapshots its expected into a scalar slot (a pointer store, no\n  // array/spread). Leaf arms that fail-at-start use a hoisted static const;\n  // composite arms snapshot `_ctx._fx`. The concat array is materialized only in\n  // the rare all-arms-failed branch. Auto-not-rejected arms leave their slot\n  // unset \u2014 matching choice.ts.\n  const slots = def.parsers.map(() => v(ctx, '_cfx'))\n  const ind0 = ind(ctx)\n  const stmts: string[] = [\n    `${ind0}let ${resValV}, ${resEndV} = ${pos}, ${resOkV} = false`,\n    `${ind0}let ${slots.join(', ')}`,\n    `${ind0}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,\n  ]\n\n  for (let i = 0; i < def.parsers.length; i++) {\n    const p = def.parsers[i]!\n    const gate    = def.gates[i]\n    const autoNot = def.autoNot[i]\n    const atStart = failsAtStart(p)\n    const staticFx = armStaticExpected(ctx, p)\n    // A named rule REF in linkable mode: defer its first-char guard to fuse time\n    // (the rule can be overridden). Emit a placeholder that fusedBody() rewrites\n    // with the WINNING rule's first-set \u2014 `true` (always-try) if left unresolved.\n    const deferRuleName = ctx.deferFirstSetRefs\n      ? (p as unknown as { _ruleName?: string })._ruleName\n      : undefined\n    // Non-defer (monolithic, refs are final): if the arm's CACHED first-set is `any`\n    // only because it was built over `ref()`s (which cache `any()` at construction),\n    // recover a real guard from the DEEP, ref-resolving first-set. Sound here because\n    // refs can't be overridden; the compose path defers instead (above).\n    const fsGuard = deferRuleName !== undefined\n      ? `/*@FS:${deferRuleName}:${codeV}@*/true`\n      : needsFirstSetGuard(p)\n        ? firstSetCond(codeV, p._meta.firstSet)\n        : (() => {\n            if (p._meta.firstSet.kind !== 'any' || matchesEmpty(p)) return null\n            const deep = firstSetOf(p)\n            return deep.kind === 'ranges' ? firstSetCond(codeV, deep) : null\n          })()\n\n    // Gate: register predicate in mapFns; condition guards entire arm attempt\n    let gateCond: string | null = null\n    if (gate) {\n      const gateIdx = ctx.mapFns.length\n      ctx.mapFns.push(gate as (v: unknown, span: unknown) => unknown)\n      // Macro path: inline the captured gate source (def.gateSrcs[i]); runtime\n      // compile() has no source \u2192 null (closure in mapFns drives it). Parallel-\n      // length invariant preserved either way.\n      ctx.mapFnSrcs.push(def.gateSrcs?.[i] ?? null)\n      gateCond = `${mfRef(ctx)}[${gateIdx}](_ctx.state)`\n    }\n    const skipCond = gateCond ? `!${resOkV} && ${gateCond}` : `!${resOkV}`\n\n    const armHasAutoNot = !!(autoNot && autoNot.length > 0)\n    const armNeedsRollback = ctx.capturing &&\n      (mayLeavePartialCapture(p) || (armHasAutoNot && capturesLeaf(p)))\n    const armNeedsFieldRollback = armNeedsRollback && parserHasOwnFields(p)\n    const markLeaves = armNeedsRollback ? v(ctx, '_cml') : null\n    const markRaw    = armNeedsRollback ? v(ctx, '_cmr') : null\n    const markTl     = armNeedsRollback ? v(ctx, '_cmtl') : null\n    const markLog    = armNeedsRollback ? v(ctx, '_cmlg') : null\n    const markFields = armNeedsFieldRollback ? v(ctx, '_cmf') : null\n    const rollback   = markLeaves\n      ? captureRestoreBody(markLeaves, markRaw!, markTl!, markLog!, markFields)\n      : ''\n    const failSlot = atStart ? staticFx : '_ctx._fx'\n\n    stmts.push(`${ind0}if (${skipCond}) {`)\n    if (fsGuard) stmts.push(`${ind(ctx)}if (${fsGuard}) {`)\n    ctx.indent += fsGuard ? 2 : 1\n\n    if (markLeaves) {\n      stmts.push(\n        `${ind(ctx)}const ${markLeaves} = _ctx._cstLeaves?.length ?? 0`,\n        `${ind(ctx)}const ${markRaw} = _ctx._cstRawChildren?.length ?? 0`,\n        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog?.length ?? 0`,\n        `${ind(ctx)}const ${markLog} = _ctx._triviaLog?.length ?? 0`,\n        ...(markFields ? [`${ind(ctx)}const ${markFields} = _ctx._fields?.length ?? 0`] : []),\n      )\n    }\n    const { stmts: armStmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos, atStart)\n    stmts.push(...armStmts)\n\n    if (autoNot && autoNot.length > 0) {\n      const anCode = v(ctx, '_anc')\n      const rejectCond = autoNot.map(check =>\n        check.kind === 'firstSet'\n          ? firstSetCond(anCode, check.set)\n          : `input.startsWith(${JSON.stringify(check.value)}, ${endVar})`\n      ).join(' || ')\n      stmts.push(`${ind(ctx)}if (${okVar}) {`)\n      stmts.push(`${ind(ctx)}  const ${anCode} = ${endVar} < input.length ? input.charCodeAt(${endVar}) : -1`)\n      stmts.push(`${ind(ctx)}  if (!(${rejectCond})) {`)\n      stmts.push(`${ind(ctx)}    ${resValV} = ${valVar}`)\n      stmts.push(`${ind(ctx)}    ${resEndV} = ${endVar}`)\n      stmts.push(`${ind(ctx)}    ${resOkV} = true`)\n      stmts.push(`${ind(ctx)}  }`)\n      stmts.push(`${ind(ctx)}}`)\n      stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot} }`)\n      if (rollback) stmts.push(`${ind(ctx)}if (!${resOkV}) { ${rollback} }`)\n    } else {\n      stmts.push(`${ind(ctx)}if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true }`)\n      stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot}${rollback ? `; ${rollback}` : ''} }`)\n    }\n\n    ctx.indent -= fsGuard ? 2 : 1\n    if (fsGuard) stmts.push(`${ind(ctx)}} else { ${slots[i]} = ${staticFx} }`)\n    stmts.push(`${ind0}}`)\n  }\n  const concatExpr = `[${slots.map(s => `...(${s} || [])`).join(', ')}]`\n  stmts.push(...emitIfFail(ctx, `!${resOkV}`, failArrBody(ctx, concatExpr, pos, false)))\n  return { stmts, valueVar: resValV, endVar: resEndV }\n}\n\nfunction emitNonDisjoint(\n  def: Extract<ParserDef, { tag: 'choice' }>,\n  strategy: ChoiceStrategy,\n  allExpected: string,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  if (strategy.tag === 'greedyClassify')\n    return emitGreedyClassify(def, strategy.superIndex, ctx, pos)\n  if (strategy.tag === 'literalsLongestFirst')\n    return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos)\n  return emitFirstMatch(def, ctx, pos)\n}\n\n// \u2500\u2500 helpers for emitGreedyClassify / emitLiteralsLongestFirst \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/** Apply transform chain only \u2014 no parsing, value already known. */\n/** Register a map fn, INTERNING by source so identical callbacks (e.g. every\n * balanced()'s merge closure) share one `_mf` slot. Relies on `mapFns` and\n * `mapFnSrcs` staying parallel \u2014 gate/guard/withCtx push a `null` source alongside\n * their `mapFns` entry to preserve that invariant, so interning keeps firing after\n * one of them (a `null` never matches a real source, so their slots are never\n * aliased). */\nfunction pushMapFn(ctx: Ctx, fn: Ctx['mapFns'][number], src: string | null): number {\n  if (src !== null && ctx.mapFns.length === ctx.mapFnSrcs.length) {\n    const hit = ctx.mapFnSrcs.indexOf(src)\n    if (hit !== -1) return hit\n  }\n  const idx = ctx.mapFns.length\n  ctx.mapFns.push(fn)\n  ctx.mapFnSrcs.push(src)\n  return idx\n}\n\nfunction emitTransformChain(p: Combinator<unknown>, baseValue: string, endV: string, startPos: string, ctx: Ctx): ER {\n  const def = p._def\n  if (def.tag === 'transform') {\n    const innerR = emitTransformChain(def.parser, baseValue, endV, startPos, ctx)\n    const fnIdx = pushMapFn(ctx, def.fn, def.fnSrc ?? null)\n    const vv = v(ctx)\n    return {\n      stmts: [...innerR.stmts, `${ind(ctx)}const ${vv} = ${mfRef(ctx)}[${fnIdx}](${innerR.valueVar}, { start: ${startPos}, end: ${endV} })`],\n      valueVar: vv,\n      endVar: endV,\n    }\n  }\n  return { stmts: [], valueVar: baseValue, endVar: endV }\n}\n\n/** Emit a condition that is true iff input matches `litVal` at `pos`. No side effects. */\nfunction emitLiteralCondition(litVal: string, pos: string): string {\n  const len = litVal.length\n  if (len === 0) return 'true'\n  if (len > CHARCODE_CHAIN_MAX) return `input.startsWith(${JSON.stringify(litVal)}, ${pos})`\n  // Short string: charCodeAt checks (same as emitLit)\n  const checks = [`${pos} + ${len} <= input.length`]\n  for (let i = 0; i < len; i++) {\n    const code = litVal.codePointAt(i)!\n    checks.push(`input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ''}) === ${code}`)\n  }\n  return checks.join(' && ')\n}\n\nfunction emitMany(def: Extract<ParserDef, { tag: 'many' | 'oneOrMore' }>, ctx: Ctx, pos: string): ER {\n  // `valueUnused` (markUnusedValues): the array is never observed (this many sits\n  // under a node() that builds from captured children). Skip building it \u2014 the\n  // loop still runs and items self-capture. Value is `undefined` (unread).\n  const wantValue = !def.valueUnused\n  const arrV = v(ctx, '_arr')\n  const curV = v(ctx, '_cur')\n  const stmts: string[] = [\n    ...(wantValue ? [`${ind(ctx)}const ${arrV} = []`] : []),\n    `${ind(ctx)}let ${curV} = ${pos}`,\n  ]\n  // Capture this list's recovery sync at ENTRY: a nested element sequence will\n  // clobber `_ctx._sync` (and doesn't restore it, unlike the interpreter's\n  // finally), so the loop must read its own saved sync, not the live one.\n  const mySyncV = ctx.recovery ? v(ctx, '_mysy') : ''\n  if (ctx.recovery) stmts.push(`${ind(ctx)}const ${mySyncV} = _ctx._sync`)\n\n  if (def.min === 1) {\n    // Inline first mandatory match with early-return on failure\n    const firstR = emit(def.parser, ctx, curV)\n    stmts.push(...firstR.stmts)\n    if (wantValue) stmts.push(`${ind(ctx)}${arrV}.push(${firstR.valueVar})`)\n    stmts.push(`${ind(ctx)}${curV} = ${firstR.endVar}`)\n  }\n\n  stmts.push(`${ind(ctx)}while (${curV} < input.length) {`)\n  ctx.indent++\n\n  // Mirror interpreter repeat.ts \u2014 skip trivia before each iteration. In capture\n  // mode the trivia is committed to rawChildren immediately and rolled back\n  // (array truncation) if the following item doesn't materialize.\n  let itemPos = curV\n  let rollback = ''\n  if (ctx.activeTrivia) {\n    if (ctx.capturing) {\n      const capFn = ensureTriviaCaptureFn(ctx)\n      const markV = v(ctx, '_mk')\n      const markTl = v(ctx, '_mktl')\n      const markLog = v(ctx, '_mklg')\n      const npV = v(ctx, '_np')\n      stmts.push(\n        `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,\n        `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,\n        `${ind(ctx)}const ${npV} = ${capFn}(input, ${curV}, _ctx, 1)`,\n      )\n      itemPos = npV\n      rollback = `if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `\n    } else {\n      const trivFn = ensureTriviaFn(ctx)\n      const npV = v(ctx, '_np')\n      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${curV}, _ctx)`)\n      itemPos = npV\n    }\n  }\n\n  const { stmts: iterStmts, okVar: iterOk, valVar: iterVal, endVar: iterEnd } = emitFallible(def.parser, ctx, itemPos, true)\n  stmts.push(...iterStmts)\n  if (ctx.recovery) {\n    // Tolerant recovery (dormant unless `_ctx._tolerant`): an element that fails \u2014\n    // and isn't sitting on the inferred sync token \u2014 is skipped to that token via\n    // the SAME interpreter recoverScan (parity), emitted as a ParseError; the loop\n    // continues. Zero-width progress is still a clean stop.\n    const rrV = v(ctx, '_rr')\n    const exp = hoistExpected(ctx, deriveExpectedArr([def.parser]))\n    stmts.push(\n      `${ind(ctx)}if (!${iterOk}) {`,\n      `${ind(ctx)}  ${rollback}if (_ctx._tolerant && ${mySyncV} !== undefined && !_ctx._rec.at(${mySyncV}, input, ${itemPos}, _ctx)) {`,\n      `${ind(ctx)}    const ${rrV} = _ctx._rec.scan(input, ${itemPos}, _ctx, ${mySyncV}, ${exp})`,\n      ...(wantValue ? [`${ind(ctx)}    ${arrV}.push(${rrV}.error)`] : []),\n      `${ind(ctx)}    _ctx._rec.capture(_ctx, ${rrV}.error)`,\n      `${ind(ctx)}    ${curV} = ${rrV}.end`,\n      `${ind(ctx)}    continue`,\n      `${ind(ctx)}  }`,\n      `${ind(ctx)}  break`,\n      `${ind(ctx)}}`,\n      `${ind(ctx)}if (${iterEnd} <= ${itemPos}) { ${rollback}break }`,\n    )\n  } else {\n    stmts.push(`${ind(ctx)}if (!${iterOk} || ${iterEnd} <= ${itemPos}) { ${rollback}break }`)\n  }\n  if (wantValue) stmts.push(`${ind(ctx)}${arrV}.push(${iterVal})`)\n  stmts.push(`${ind(ctx)}${curV} = ${iterEnd}`)\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n\n  return { stmts, valueVar: wantValue ? arrV : 'undefined', endVar: curV }\n}\n\nfunction emitOptional(def: Extract<ParserDef, { tag: 'optional' }>, ctx: Ctx, pos: string): ER {\n  const valV = v(ctx, '_opt')\n  const endV = v(ctx, '_opte')\n\n  const { stmts: lblStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos, true)\n\n  const ind0 = ind(ctx)\n  const stmts = [\n    ...lblStmts,\n    `${ind0}const ${valV} = ${okVar} ? ${valVar} : null`,\n    `${ind0}const ${endV} = ${okVar} ? ${endVar} : ${pos}`,\n  ]\n  return { stmts, valueVar: valV, endVar: endV }\n}\n\nfunction emitSepBy(_p: Combinator<unknown>, def: Extract<ParserDef, { tag: 'sepBy' }>, ctx: Ctx, pos: string): ER {\n  const arrV = v(ctx, '_arr')\n  const curV = v(ctx, '_cur')\n  const rec = !!ctx.recovery\n  // Recovery sync = the separator's own follow (resync to the next separator) OR the\n  // enclosing delimiter published as _ctx._sync \u2014 captured at ENTRY (element parses\n  // clobber _ctx._sync). The separator sentinel is exact for single-char separators.\n  const mySyncV = rec ? v(ctx, '_mysy') : ''\n  const exp = rec ? hoistExpected(ctx, deriveExpectedArr([def.parser])) : ''\n  const sepSent = rec ? syncSentinelExpr(firstSetOf(def.separator)) : null\n  const scanSync = sepSent ? `_ctx._rec.or(${sepSent}, ${mySyncV})` : mySyncV\n\n  const { stmts: firstStmts, okVar: firstOk, valVar: firstVal, endVar: firstEnd } =\n    emitFallible(def.parser, ctx, pos, true)\n\n  const stmts: string[] = [\n    `${ind(ctx)}const ${arrV} = []`,\n    `${ind(ctx)}let ${curV} = ${pos}`,\n    ...(rec ? [`${ind(ctx)}const ${mySyncV} = _ctx._sync`] : []),\n    ...firstStmts,\n  ]\n\n  // A failed element after a real separator. Strict \u2192 the exact original break\n  // (byte-identical). Tolerant \u2192 skip to the sync, emit a ParseError, and continue\n  // (unless already sitting on the enclosing sync). `originalFail` is that site's\n  // exact strict string (the three sites differ \u2014 braces / rollback).\n  const failItem = (nextOkVar: string, itemPosVar: string, rb: string, originalFail: string): string[] => {\n    if (!rec) return [originalFail]\n    const rr = v(ctx, '_rr')\n    return [\n      `${ind(ctx)}if (!${nextOkVar}) {`,\n      `${ind(ctx)}  if (_ctx._tolerant && ${mySyncV} !== undefined && !_ctx._rec.at(${mySyncV}, input, ${itemPosVar}, _ctx)) {`,\n      `${ind(ctx)}    const ${rr} = _ctx._rec.scan(input, ${itemPosVar}, _ctx, ${scanSync}, ${exp})`,\n      `${ind(ctx)}    ${arrV}.push(${rr}.error); _ctx._rec.capture(_ctx, ${rr}.error); ${curV} = ${rr}.end; continue`,\n      `${ind(ctx)}  }`,\n      `${ind(ctx)}  ${rb}break`,\n      `${ind(ctx)}}`,\n    ]\n  }\n\n  // First element + loop entry. Strict keeps the exact `if (firstOk) { \u2026 while }`\n  // shape (byte-identical). Tolerant recovers a junk first element (unless sitting\n  // on the enclosing sync) and still enters the loop via a `did` flag.\n  if (rec) {\n    const rr0 = v(ctx, '_rr0')\n    const didV = v(ctx, '_did')\n    stmts.push(\n      `${ind(ctx)}let ${didV} = false`,\n      `${ind(ctx)}if (${firstOk}) { ${arrV}.push(${firstVal}); ${curV} = ${firstEnd}; ${didV} = true }`,\n      `${ind(ctx)}else if (_ctx._tolerant && ${mySyncV} !== undefined && !_ctx._rec.at(${mySyncV}, input, ${pos}, _ctx)) {`,\n      `${ind(ctx)}  const ${rr0} = _ctx._rec.scan(input, ${pos}, _ctx, ${scanSync}, ${exp})`,\n      `${ind(ctx)}  ${arrV}.push(${rr0}.error); _ctx._rec.capture(_ctx, ${rr0}.error); ${curV} = ${rr0}.end; ${didV} = true`,\n      `${ind(ctx)}}`,\n      `${ind(ctx)}if (${didV}) {`,\n    )\n    ctx.indent++\n    stmts.push(`${ind(ctx)}while (${curV} < input.length) {`)\n    ctx.indent++\n  } else {\n    stmts.push(`${ind(ctx)}if (${firstOk}) {`)\n    ctx.indent++\n    stmts.push(\n      `${ind(ctx)}${arrV}.push(${firstVal})`,\n      `${ind(ctx)}${curV} = ${firstEnd}`,\n      `${ind(ctx)}while (${curV} < input.length) {`,\n    )\n    ctx.indent++\n  }\n\n  // Mirror interpreter sepBy \u2014 separate rollback marks for pre-sep and post-sep trivia.\n  let sepAtPos = curV\n  if (ctx.activeTrivia) {\n    if (ctx.capturing) {\n      const capFn = ensureTriviaCaptureFn(ctx)\n      const markV = v(ctx, '_mk')\n      const markTl = v(ctx, '_mktl')\n      const markLog = v(ctx, '_mklg')\n      const markLv = v(ctx, '_mklv')\n      const spV = v(ctx, '_sp')\n      // Marks taken BEFORE the separator. If either the separator OR the following\n      // item fails, the whole iteration unwinds to here \u2014 crucially undoing the\n      // separator's own captured leaves (markLv) when the item after it fails.\n      stmts.push(\n        `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,\n        `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,\n        `${ind(ctx)}const ${markLv} = _ctx._cstLeaves ? _ctx._cstLeaves.length : 0`,\n        `${ind(ctx)}const ${spV} = ${capFn}(input, ${curV}, _ctx, 1)`,\n      )\n      sepAtPos = spV\n      const rollbackToSep = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `\n      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true)\n      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}break }`)\n\n      const npV = v(ctx, '_np')\n      stmts.push(`${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx, 1)`)\n      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } =\n        emitFallible(def.parser, ctx, npV, true)\n      stmts.push(\n        ...nextStmts,\n        // item failed \u2192 unwind the separator too, back to the end of the last item\n        ...failItem(nextOk, npV, rollbackToSep, `${ind(ctx)}if (!${nextOk}) { ${rollbackToSep}break }`),\n        `${ind(ctx)}${arrV}.push(${nextVal})`,\n        `${ind(ctx)}${curV} = ${nextEnd}`,\n      )\n    } else {\n      const trivFn = ensureTriviaFn(ctx)\n      const spV = v(ctx, '_sp')\n      stmts.push(`${ind(ctx)}const ${spV} = ${trivFn}(input, ${curV}, _ctx)`)\n      sepAtPos = spV\n      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true)\n      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`)\n\n      const npV = v(ctx, '_np')\n      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${sepEnd}, _ctx)`)\n      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } =\n        emitFallible(def.parser, ctx, npV, true)\n      stmts.push(\n        ...nextStmts,\n        ...failItem(nextOk, npV, '', `${ind(ctx)}if (!${nextOk}) break`),\n        `${ind(ctx)}${arrV}.push(${nextVal})`,\n        `${ind(ctx)}${curV} = ${nextEnd}`,\n      )\n    }\n  } else {\n    // No trivia. Still mark the leaf buffers before the separator so that an item\n    // failing after the separator unwinds the separator's captured leaves too.\n    const markLv = ctx.capturing ? v(ctx, '_mklv') : null\n    const markRw = ctx.capturing ? v(ctx, '_mkrw') : null\n    if (markLv) {\n      stmts.push(\n        `${ind(ctx)}const ${markLv} = _ctx._cstLeaves ? _ctx._cstLeaves.length : 0`,\n        `${ind(ctx)}const ${markRw} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,\n      )\n    }\n    const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true)\n    stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`)\n    const nextRb = markLv\n      ? `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markRw}; `\n      : ''\n    const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } =\n      emitFallible(def.parser, ctx, sepEnd, true)\n    stmts.push(\n      ...nextStmts,\n      ...failItem(nextOk, sepEnd, nextRb, `${ind(ctx)}if (!${nextOk}) { ${nextRb}break }`),\n      `${ind(ctx)}${arrV}.push(${nextVal})`,\n      `${ind(ctx)}${curV} = ${nextEnd}`,\n    )\n  }\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n\n  return { stmts, valueVar: arrV, endVar: curV }\n}\n\nfunction emitScanTo(\n  def: Extract<ParserDef, { tag: 'scanTo' }>,\n  ctx: Ctx,\n  pos: string,\n): ER {\n  const curV   = v(ctx, '_stcur')\n  const foundV = v(ctx, '_stfnd')\n  const stmts: string[] = [\n    `${ind(ctx)}let ${curV} = ${pos}`,\n    `${ind(ctx)}let ${foundV} = false`,\n    `${ind(ctx)}while (${curV} < input.length) {`,\n  ]\n  ctx.indent++\n\n  // Sentinel check and skippers must not emit CST leaves \u2014 they are pure position\n  // probes. Use a non-capturing ctx so their literal()/regex() don't push leaves.\n  const probeCtx: Ctx = { ...ctx, capturing: false, noHoist: true }\n\n  // Sentinel check \u2014 labeled block, no IIFE\n  const { stmts: sentStmts, okVar: sentOk } = emitFallible(def.sentinel, probeCtx, curV)\n  stmts.push(...sentStmts, `${ind(ctx)}if (${sentOk}) { ${foundV} = true; break }`)\n\n  // Skippers \u2014 labeled block per skipper; a failure just means \"not this one\"\n  if (def.skip.length > 0) {\n    const advV = v(ctx, '_stadv')\n    stmts.push(`${ind(ctx)}let ${advV} = false`)\n    for (const skipper of def.skip) {\n      const { stmts: skStmts, okVar: skOk, endVar: skEnd } = emitFallible(skipper, probeCtx, curV)\n      stmts.push(\n        `${ind(ctx)}if (!${advV}) {`,\n        ...skStmts,\n        `${ind(ctx)}  if (${skOk} && ${skEnd} > ${curV}) { ${curV} = ${skEnd}; ${advV} = true }`,\n        `${ind(ctx)}}`,\n      )\n    }\n    stmts.push(`${ind(ctx)}if (!${advV}) ${curV}++`)\n  } else {\n    stmts.push(`${ind(ctx)}${curV}++`)\n  }\n\n  ctx.indent--\n  stmts.push(`${ind(ctx)}}`)\n\n  // Fail if sentinel was never found (unless orEOF)\n  if (!def.orEOF) {\n    const sentDef = def.sentinel._def\n    const expectedStr = sentDef.tag === 'literal'\n      ? JSON.stringify([JSON.stringify(sentDef.value)])\n      : `[\"sentinel\"]`\n    stmts.push(...emitIfFail(ctx, `!${foundV}`, failArrBody(ctx, expectedStr, pos)))\n  }\n\n  const valV = v(ctx)\n  stmts.push(`${ind(ctx)}const ${valV} = input.slice(${pos}, ${curV})`)\n  // scanTo records its scanned span as one leaf (matching the interpreter), but\n  // only when it actually consumed something.\n  if (ctx.capturing) {\n    const cap = reindentStmts(emitLeafCapture(ctx, valV, pos, curV), ctx.indent + 1)\n    stmts.push(`${ind(ctx)}if (${curV} > ${pos}) {`, ...cap, `${ind(ctx)}}`)\n  }\n  return { stmts, valueVar: valV, endVar: curV }\n}\n\n/**\n * Negative lookahead. Run the inner parser in a labeled block; if it succeeds,\n * fail; if it fails, succeed consuming nothing (value null, end === pos).\n */\nfunction emitNot(def: Extract<ParserDef, { tag: 'not' }>, ctx: Ctx, pos: string): ER {\n  // not() discards the inner failure (inner failing = not succeeding), so the\n  // inner sub-parse need not record \u2014 swallow it.\n  const { stmts, okVar } = emitFallible(def.parser, ctx, pos, true)\n  // not() fails (at its own pos) when the inner parser SUCCEEDS; the interpreter\n  // reports `not(<innerTag>)` as the expected token \u2014 match that label exactly.\n  const label = JSON.stringify(`not(${def.parser._tag})`)\n  return {\n    stmts: [\n      ...stmts,\n      ...emitIfFail(ctx, okVar, failBody(ctx, label, pos)),\n    ],\n    valueVar: 'null',\n    endVar: pos,\n  }\n}\n\nfunction escapeTokenLiteral(value: string): string {\n  return value.replace(/[\\\\^$.*+?()[\\]{}|]/g, '\\\\$&')\n}\n\nfunction regexMatchesEmpty(source: string, flags: string): boolean {\n  try { return new RegExp(`^(?:${source})$`, flags).test('') }\n  catch { return true }\n}\n\nfunction tokenTerminalSource(p: Combinator<unknown>): { source: string; caseInsensitive: boolean; rawCaseSensitive: string } | null {\n  const def = p._def\n  switch (def.tag) {\n    case 'literal':\n      if (def.value.length === 0) return null\n      return {\n        source: escapeTokenLiteral(def.value),\n        caseInsensitive: def.caseInsensitive,\n        rawCaseSensitive: def.caseInsensitive ? '' : def.value,\n      }\n    case 'regex': {\n      if (def.flags.replace(/i/g, '') !== '') return null\n      if (regexMatchesEmpty(def.source, def.flags)) return null\n      return {\n        source: `(?:${def.source})`,\n        caseInsensitive: def.flags.includes('i'),\n        rawCaseSensitive: def.flags.includes('i') ? '' : def.source,\n      }\n    }\n    default:\n      return null\n  }\n}\n\nfunction tokenSequenceSource(p: Combinator<unknown>): { source: string; flags: string; hasCaseSensitiveLetters: boolean } | null {\n  const def = p._def\n  const parts = def.tag === 'sequence'\n    ? def.parsers.map(tokenTerminalSource)\n    : [tokenTerminalSource(p)]\n  if (parts.some(part => part === null)) return null\n  const typed = parts as Array<{ source: string; caseInsensitive: boolean; rawCaseSensitive: string }>\n  const flags = typed.some(part => part.caseInsensitive) ? 'i' : ''\n  if (flags.includes('i') && typed.some(part => /[A-Za-z]/.test(part.rawCaseSensitive))) return null\n  return {\n    source: typed.map(part => part.source).join(''),\n    flags,\n    hasCaseSensitiveLetters: typed.some(part => /[A-Za-z]/.test(part.rawCaseSensitive)),\n  }\n}\n\nfunction combineTokenRegexSources(parts: Array<{ source: string; flags: string; hasCaseSensitiveLetters: boolean }>): { source: string; flags: string } | null {\n  const flags = parts.some(part => part.flags.includes('i')) ? 'i' : ''\n  if (flags.includes('i') && parts.some(part => part.flags === '' && part.hasCaseSensitiveLetters)) return null\n  return { source: parts.map(part => part.source).join(''), flags }\n}\n\nfunction tokenNullableRegex(def: Extract<ParserDef, { tag: 'token' }>): Extract<ParserDef, { tag: 'regex' }> | null {\n  const inner = def.parser._def\n  if (inner.tag === 'many') {\n    const seq = tokenSequenceSource(inner.parser)\n    if (!seq) return null\n    return { tag: 'regex', source: `(?:${seq.source})*`, flags: seq.flags }\n  }\n  if (inner.tag === 'optional') {\n    const seq = tokenSequenceSource(inner.parser)\n    if (!seq) return null\n    return { tag: 'regex', source: `(?:${seq.source})?`, flags: seq.flags }\n  }\n  if (inner.tag === 'sepBy') {\n    const item = tokenSequenceSource(inner.parser)\n    const sep = tokenSequenceSource(inner.separator)\n    if (!item || !sep) return null\n    const combined = combineTokenRegexSources([item, sep])\n    if (!combined) return null\n    return { tag: 'regex', source: `(?:${item.source}(?:${sep.source}${item.source})*)?`, flags: combined.flags }\n  }\n  return null\n}\n\nfunction emitToken(def: Extract<ParserDef, { tag: 'token' }>, ctx: Ctx, pos: string): ER {\n  const lowered = tokenNullableRegex(def)\n  if (lowered) return emitRegex(lowered, ctx, pos)\n\n  const savedTrivia = ctx.activeTrivia\n  const savedKindLabels = ctx.triviaKindLabels\n  ctx.activeTrivia = undefined\n  ctx.triviaKindLabels = undefined\n  const inner = emitFallible(def.parser, ctx, pos)\n  ctx.activeTrivia = savedTrivia\n  ctx.triviaKindLabels = savedKindLabels\n\n  const i = ind(ctx)\n  const sc = v(ctx, '_tokCh')\n  const sl = v(ctx, '_tokLv')\n  const sr = v(ctx, '_tokRaw')\n  const sv = v(ctx, '_tokTr')\n  const sk = v(ctx, '_tokKinds')\n  const stl = v(ctx, '_tokTl')\n  const sol = v(ctx, '_tokLog')\n  const sb = v(ctx, '_tokBuf')\n  const valV = v(ctx, '_tok')\n\n  return {\n    stmts: [\n      `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${sv} = _ctx.trivia, ${sk} = _ctx.triviaKindLabels, ${stl} = _ctx._cstTriviaLog, ${sol} = _ctx._triviaLog, ${sb} = _ctx._cstBuf`,\n      `${i}_ctx.trivia = undefined; _ctx.triviaKindLabels = undefined; _ctx._cstChildren = undefined; _ctx._cstLeaves = undefined; _ctx._cstRawChildren = undefined; _ctx._cstTriviaLog = undefined; _ctx._triviaLog = undefined; _ctx._cstBuf = undefined`,\n      `${i}try {`,\n      ...reindentStmts(inner.stmts, ctx.indent + 1).map(stmt => stmt.replace(/^(\\s*)(?:const|let)\\s+/, '$1var ')),\n      `${i}} finally {`,\n      `${i}  _ctx.trivia = ${sv}; _ctx.triviaKindLabels = ${sk}; _ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx._cstTriviaLog = ${stl}; _ctx._triviaLog = ${sol}; _ctx._cstBuf = ${sb}`,\n      `${i}}`,\n      ...emitIfFail(ctx, `!${inner.okVar}`, propagateFailBody(ctx)),\n      `${i}const ${valV} = input.slice(${pos}, ${inner.endVar})`,\n      ...emitLeafCapture(ctx, valV, pos, inner.endVar),\n    ],\n    valueVar: valV,\n    endVar: inner.endVar,\n  }\n}\n\n/**\n * CST node rule. Collects the inner parse's terminals/trivia into fresh local\n * arrays (capture is emitted inline by the terminals while capChildren is set),\n * calls the build fn, then records the node in the enclosing node()'s collectors.\n */\nfunction emitNode(def: Extract<ParserDef, { tag: 'node' }>, ctx: Ctx, pos: string): ER {\n  if (def.type === undefined) {\n    throw new Error('node(): inferred node type requires a rules() key; pass node(\"Type\", parser) outside rules()')\n  }\n  // A STRUCTURAL node has no own build \u2014 it builds via the `ctx.build` host at\n  // parse time, else a default positioned CST. No build fn is captured.\n  const structural = def.build === undefined\n  const mkType = structural ? null : analyzeMkInlineBuild(def)\n  let buildIdx: number | null = null\n  if (!mkType && !structural) {\n    buildIdx = ctx.buildFns.length\n    ctx.buildFns.push(def.build!)\n    ctx.buildSrcs.push(def.buildSrc ?? null)\n  }\n  const i = ind(ctx)\n\n  // Arity-gated elision: when the build provably never reads the trivia (4th) or\n  // state (5th) arg, skip that capture entirely. The mk-inline path reads\n  // `tlV.length` for `localTriviaLen`, so it always keeps trivia capture.\n  //\n  // A STRUCTURAL node builds via the injected `_ctx.build` host, whose arity is\n  // only known at parse time \u2014 so instead of defensively capturing both (the old\n  // behaviour), gate on what the host reads via the `_hostReads` helper (memoized\n  // once per parse on `_ctx._pmCapTL`/`_pmCapST`). Host sig is\n  // `(type, children, fields, span, rawChildren, triviaLog, state)`: not reading arg 5\n  // (index) means no trivia log, arg 6 means no state (when no host, the default\n  // CST embeds `state` \u2192 keep the clone). `_hostReads` is conservative \u2014 a\n  // rest/default param or `arguments` forces full capture, so a spread host never\n  // silently loses data. jess hosts can ask for fields with arity 3 while trivia/state stay dead\n  // (the cstTriviaLog per-token push dominates \u2014 ~28% of a real jess parse).\n  const capturesTrivia = mkType !== null || (!structural && buildReadsTrivia(def))\n  const clonesState = !structural && buildReadsState(def)\n  const hasFields = parserHasOwnFields(def.parser)\n  const capturesFields = hasFields && !structural && buildReadsFields(def)\n\n  const chV = v(ctx, '_ch')\n  const rawV = v(ctx, '_raw')\n  const capTLv = structural ? v(ctx, '_ctl') : null\n  const capSTv = structural ? v(ctx, '_cst') : null\n  const capFv = structural && hasFields ? v(ctx, '_cf') : null\n  const tlV = capturesTrivia || structural ? v(ctx, '_tl') : '_EMPTY_TL'\n  if (!capturesTrivia) ctx.needsEmptyTl = true\n  const sc = v(ctx, '_sc'), sl = v(ctx, '_sl'), sr = v(ctx, '_sr'), st = v(ctx, '_st'), stl = v(ctx, '_stl')\n  // Per-node-type trivia-kind mask (structural/host nodes only): a host may want\n  // one node type captured comments-only and another whitespace-and-all. Scoped\n  // here and restored after the inner parse, exactly like captureTrivia/_cstTriviaLog.\n  const smk = structural ? v(ctx, '_smk') : null\n  if (structural) ctx.needsHostReads = true\n  const hostTriviaGate = `_ctx.build !== undefined && (_ctx.build._parsemanCaptureTrivia !== undefined ? _ctx.build._parsemanCaptureTrivia(${JSON.stringify(def.type)}) : (_ctx._pmCapTL ??= _hostReads(_ctx.build, 5)))`\n  // `run({ profile: true })` reuses the established recognition-only boundary\n  // (`transform(parser, () => undefined)`) for an already-compiled structural\n  // grammar: recognizer suppresses all node output, capture records structure\n  // but skips construction, and host is the unmodified normal path. This is\n  // profiling-only context state, not a public parser mode.\n  // Hoist the profiling-phase reads to ONE `_ctx._pmProfile` read + two boolean\n  // locals per node, instead of re-evaluating `_ctx._pmProfile?.phase === X` ~8\u00D7\n  // across the alloc/install lines. On the normal (non-profiling) path `_pm` is\n  // undefined, so both locals fall out of one read + two short-circuiting compares,\n  // and every downstream `${_rec} ? \u2026 : \u2026` becomes a cheap boolean-local ternary.\n  // Fixes the per-node overhead the profiling boundary added on tiny inputs (where\n  // it isn't amortized: ~+10\u201315% on 2\u20133\u00B5s cases, ~0% on bootstrap4).\n  const pmV = v(ctx, '_pm'), recV = v(ctx, '_rec'), capV = v(ctx, '_cap')\n  const profHoist = `${i}const ${pmV} = _ctx._pmProfile, ${recV} = ${pmV}?.phase === 'recognizer', ${capV} = ${pmV}?.phase === 'capture'`\n  const profileRecognizer = recV\n  const profileCapture = capV\n  const allocStmt = structural\n    ? `${i}const ${capTLv} = !(${profileRecognizer}) && (${profileCapture} || ${hostTriviaGate}), ${capSTv} = !(${profileRecognizer} || ${profileCapture}) && (_ctx._pmCapST ??= (_ctx.build === undefined || _hostReads(_ctx.build, 6)))${capFv ? `, ${capFv} = !(${profileRecognizer}) && (${profileCapture} || (_ctx.build !== undefined && _hostReads(_ctx.build, 2)))` : ''}\\n`\n      + `${i}const ${chV} = ${profileRecognizer} ? undefined : [], ${rawV} = ${profileRecognizer} ? undefined : [], ${tlV} = ${capTLv} ? [] : _EMPTY_TL`\n    : capturesTrivia\n      ? `${i}const ${chV} = ${profileRecognizer} ? undefined : [], ${rawV} = ${profileRecognizer} ? undefined : [], ${tlV} = ${profileRecognizer} ? undefined : []`\n      : `${i}const ${chV} = ${profileRecognizer} ? undefined : [], ${rawV} = ${profileRecognizer} ? undefined : []`\n  // When not capturing, set _ctx._cstTriviaLog = undefined so inner trivia terminals'\n  // `if (_ctx._cstTriviaLog !== undefined)` guard short-circuits (no per-token push).\n  const innerTl = structural ? `${capTLv} ? ${tlV} : undefined` : capturesTrivia ? tlV : 'undefined'\n  const fieldsOn = structural ? (capFv ?? 'false') : `${profileRecognizer} ? false : ${capturesFields ? 'true' : 'false'}`\n  const sf = hasFields ? v(ctx, '_sf') : null\n  const fArr = hasFields ? v(ctx, '_fa') : null\n  const fObj = hasFields ? v(ctx, '_fields') : 'undefined'\n  // Per-node trivia-frame elision: a node whose parser subtree has NO trivia-skip\n  // site (a bare terminal) can never log trivia into its own `_cstTriviaLog`, so\n  // its `captureTrivia`/`_cstTriviaLog`/`_triviaCaptureMask` save+install+restore is\n  // dead work \u2014 skip it. The parent's values stay untouched (nothing inside writes\n  // them) and the node's trivia is empty (build reads `tlV`, which is `_EMPTY_TL` /\n  // an unpopulated `_tl`). Sound because `parserHasTriviaSite` is conservative\n  // (only `false` when provably no site). Halves the per-node scope frame on the\n  // many bare value/token leaf nodes (Num, Color, Quoted, \u2026). See emitNode notes.\n  const needsTriviaFrame = parserHasTriviaSite(def.parser)\n  const saveTrivia = needsTriviaFrame\n    ? `, ${st} = _ctx.captureTrivia, ${stl} = _ctx._cstTriviaLog${smk ? `, ${smk} = _ctx._triviaCaptureMask` : ''}`\n    : ''\n  const installTrivia = needsTriviaFrame\n    ? `; _ctx.captureTrivia = true; _ctx._cstTriviaLog = ${innerTl}${smk ? `; _ctx._triviaCaptureMask = ${capTLv} && _ctx.build._parsemanTriviaKinds !== undefined ? _ctx.build._parsemanTriviaKinds(${JSON.stringify(def.type)}) : ${smk}` : ''}`\n    : ''\n  const restoreTrivia = needsTriviaFrame\n    ? `; _ctx.captureTrivia = ${st}; _ctx._cstTriviaLog = ${stl}${smk ? `; _ctx._triviaCaptureMask = ${smk}` : ''}`\n    : ''\n  const stmts: string[] = [\n    profHoist,\n    allocStmt,\n    `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren${saveTrivia}${sf ? `, ${sf} = _ctx._fields` : ''}`,\n    `${i}_ctx._cstChildren = ${chV}; _ctx._cstLeaves = ${chV}; _ctx._cstRawChildren = ${rawV}${installTrivia}${sf ? `; _ctx._fields = ${fieldsOn} ? [] : undefined` : ''}`,\n  ]\n  const { stmts: innerStmts, okVar, endVar } = emitFallible(def.parser, ctx, pos)\n  stmts.push(...innerStmts)\n  if (sf && fArr) {\n    stmts.push(`${i}const ${fArr} = _ctx._fields`)\n  }\n  stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}${restoreTrivia}${sf ? `; _ctx._fields = ${sf}` : ''}`)\n  // node() returns the inner failure verbatim (interpreter parity) \u2014 propagate\n  // the recorded deepest failure, not a coarse [\"node\"] at the node's start.\n  stmts.push(...emitIfFail(ctx, `!${okVar}`, propagateFailBody(ctx)))\n\n  stmts.push(\n    `${i}if (_ctx._pmProfile) {`,\n    `${i}  _ctx._pmProfile.nodes++`,\n    `${i}  if (${profileCapture}) {`,\n    `${i}    _ctx._pmProfile.childSlots += ${chV}.length; _ctx._pmProfile.rawSlots += ${rawV}.length; _ctx._pmProfile.triviaSlots += ${tlV}.length${fArr ? `; _ctx._pmProfile.fieldSlots += ${fArr} ? ${fArr}.length : 0` : ''}`,\n    `${i}  }`,\n    `${i}}`,\n  )\n\n  let stV = 'undefined'\n  if (structural) {\n    stV = v(ctx, '_nst')\n    stmts.push(`${i}const ${stV} = ${capSTv} && _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`)\n  } else if (clonesState) {\n    stV = v(ctx, '_nst')\n    stmts.push(`${i}const ${stV} = !(${profileRecognizer} || ${profileCapture}) && _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`)\n  }\n  if (sf && fArr) {\n    const fe = v(ctx, '_fe')\n    const cur = v(ctx, '_fc')\n    stmts.push(\n      `${i}let ${fObj} = undefined`,\n      `${i}if (${fArr} && ${fArr}.length) {`,\n      `${i}  ${fObj} = {}`,\n      `${i}  for (const ${fe} of ${fArr}) {`,\n      `${i}    const ${cur} = ${fObj}[${fe}.name], _entry = { value: ${fe}.value, span: ${fe}.span }`,\n      `${i}    if (${cur} === undefined) ${fObj}[${fe}.name] = _entry`,\n      `${i}    else if (Array.isArray(${cur})) ${cur}.push(_entry)`,\n      `${i}    else ${fObj}[${fe}.name] = [${cur}, _entry]`,\n      `${i}  }`,\n      `${i}}`,\n    )\n  }\n  const ndV = v(ctx, '_nd')\n  // A structural node's own \"builder\" is a default positioned CST; a built node's\n  // is its inline-mk expr or captured build fn.\n  const buildExpr = structural\n    ? `{ _tag: 'node', type: ${JSON.stringify(def.type)}, span: { start: ${pos}, end: ${endVar} }, state: ${stV} ?? null, children: ${chV} }`\n    : mkType\n      ? emitInlineMkNodeExpr(mkType, chV, rawV, pos, endVar, tlV)\n      : `${buildRef(ctx)}[${buildIdx!}](${chV}, ${fObj}, { start: ${pos}, end: ${endVar} }, ${rawV}, ${tlV}, ${stV})`\n  // Modes (RULE_ABI_PLAN \u00A77): a per-parse `_ctx.build` host (keyed by node type)\n  // may override construction \u2014 so ONE fused grammar serves eval-AST vs\n  // positioned-CST modes. Emitted when `ctx.ns` (linkable) OR for a structural\n  // node (whose whole point is the injected host). A built standalone node stays\n  // byte-identical (no `_ctx.build` branch).\n  const ndExpr = ctx.ns || structural\n    ? `_ctx.build !== undefined ? (_ctx._pmProfile?.phase === 'host' && _ctx._pmProfile.hostCalls++, _ctx.build(${JSON.stringify(def.type)}, ${chV}, ${fObj}, { start: ${pos}, end: ${endVar} }, ${rawV}, ${tlV}, ${stV})) : (${buildExpr})`\n    : buildExpr\n  // unwrap/collapse: a single captured child IS the value; unwrap turns a leaf\n  // into its string, collapse returns the child exactly. Mirrors node.ts.\n  const hostCollapseExpr = (ctx.ns || structural)\n    ? `_ctx.build !== undefined && _ctx.build._parsemanCstCollapse !== undefined && ${chV}.length === 1 && ${rawV}.length === 1 && _ctx.build._parsemanCstCollapse(${JSON.stringify(def.type)}, ${chV}[0], ${chV}, ${rawV}) ? ${chV}[0] : (${ndExpr})`\n    : ndExpr\n  const unwrapExpr = `${chV}.length === 1 ? (${chV}[0] !== null && typeof ${chV}[0] === 'object' && ${chV}[0]._tag === 'leaf' ? ${chV}[0].value : ${chV}[0]) : (${ndExpr})`\n  const collapseExpr = `${chV}.length === 1 ? ${chV}[0] : (${ndExpr})`\n  const finalExpr = def.unwrap\n    ? unwrapExpr\n    : def.collapse\n      ? collapseExpr\n    : hostCollapseExpr\n  stmts.push(\n    `${i}const ${ndV} = (${profileRecognizer} || ${profileCapture}) ? undefined : (${finalExpr})`,\n    `${i}if (!(${profileRecognizer})) {`,\n    `${i}  if (${sc}) ${sc}.push(${ndV})`,\n    `${i}  if (${sr}) ${sr}.push((typeof ${ndV} === 'object' && ${ndV} !== null && (${ndV}._tag === 'node' || ${ndV}._tag === 'leaf' || ${ndV}._tag === 'parseError')) ? ${ndV} : { _tag: 'leaf', value: typeof ${ndV} === 'string' ? ${ndV} : '', span: { start: ${pos}, end: ${endVar} } })`,\n    `${i}}`,\n  )\n\n  return { stmts, valueVar: ndV, endVar }\n}\n\nfunction emitRuntimeFallback(parser: Combinator<unknown>, ctx: Ctx, pos: string): ER {\n  const idx = ctx.runtimeParsers.length\n  ctx.runtimeParsers.push(parser)\n  const rv = v(ctx, '_rt')\n  const vv = v(ctx, '_rtv')\n  const ev = v(ctx, '_rte')\n  // The runtime parser IS the real combinator, so its result is exactly the\n  // interpreter's \u2014 record its failure payload and propagate it verbatim (only\n  // when a consumer will read it).\n  const failStmt = ctx.failLabel\n    ? (ctx.recordFail\n        ? `{ _ctx._fe = ${rv}.span.start; _ctx._fx = ${rv}.expected; break ${ctx.failLabel} }`\n        : `break ${ctx.failLabel}`)\n    : `return { ok: false, expected: ${rv}.expected, span: ${rv}.span }`\n  const stmts = [\n    `${ind(ctx)}const ${rv} = _rp[${idx}].parse(input, ${pos}, _ctx)`,\n    ...emitIfFail(ctx, `!${rv}.ok`, failStmt),\n    `${ind(ctx)}const ${vv} = ${rv}.value`,\n    `${ind(ctx)}const ${ev} = ${rv}.span.end`,\n  ]\n  return { stmts, valueVar: vv, endVar: ev }\n}\n\n/**\n * Compile a lazy/ref parser into a named function declaration.\n *\n * The named function is registered in ctx.namedParsers BEFORE its body is\n * emitted. This breaks the recursion cycle: when the body emitter encounters\n * the same ref again it finds it already registered and emits a call instead\n * of recursing infinitely.\n *\n * All named functions share the parent function's scope (via closure), so they\n * can read _rp, _mf, and all hoisted regex consts without extra args.\n *\n * JavaScript hoists function declarations within a function body, so the order\n * we push to namedFnDecls doesn't affect correctness.\n */\nfunction emitLazy(p: Combinator<unknown>, def: Extract<ParserDef, { tag: 'lazy' }>, ctx: Ctx, pos: string): ER {\n  // Single-use, non-recursive ref: inline its body at this call site instead\n  // of hoisting a named function nobody else calls. Uses the CURRENT ctx\n  // indent/failLabel (unlike the named-function path below, which resets\n  // both for a fresh function scope) \u2014 the resolved combinator is emitted\n  // exactly as if the grammar author had written it inline directly.\n  // A named rule (in the rule map) is NEVER inlined: it must stay a standalone\n  // `_r_<Name>` function so it's addressable and overridable by name (the\n  // linkable/fusable form). Only private (non-map) single-use refs inline.\n  const canonical = ctx.ruleNames?.get(p)\n  const usage = ctx.lazyUsage\n  if (!canonical && usage && (usage.counts.get(p) ?? 0) <= 1 && !usage.recursive.has(p)) {\n    let resolved: Combinator<unknown>\n    try {\n      resolved = def.thunk()\n    } catch {\n      return emitRuntimeFallback(p, ctx, pos)\n    }\n    return emit(resolved, ctx, pos)\n  }\n\n  if (!ctx.namedParsers.has(p)) {\n    const fnName = canonical ?? `${nsp(ctx)}_pf${ctx.namedParsers.size}`\n    ctx.namedParsers.set(p, fnName)   // register FIRST so recursive refs see it\n\n    let resolved: Combinator<unknown>\n    try {\n      resolved = def.thunk()\n    } catch {\n      // ref.define() not called yet \u2014 fall back to runtime\n      ctx.namedParsers.delete(p)\n      return emitRuntimeFallback(p, ctx, pos)\n    }\n\n    const savedIndent    = ctx.indent\n    const savedFailLabel = ctx.failLabel\n    const savedRecord    = ctx.recordFail\n    ctx.indent    = 1\n    ctx.failLabel = '_pfail'  // failures break _pfail (labeled block in fn body)\n    // A named fn is compiled ONCE but shared across every call site, so its body\n    // must always record `_ctx._fx` \u2014 the caller (emitNamedFnCall) decides via\n    // its own recordFail whether to propagate. Baking the first caller's\n    // (possibly swallowed) recordFail into the shared body would leave `_ctx._fx`\n    // unset for other callers that DO read it.\n    ctx.recordFail = true\n    const r = emit(resolved, ctx, '_pos')\n    ctx.indent    = savedIndent\n    ctx.failLabel = savedFailLabel\n    ctx.recordFail = savedRecord\n\n    pushNamedFnDecl(ctx, fnName, r.stmts, r.valueVar, r.endVar)\n  }\n\n  const fnName = ctx.namedParsers.get(p)!\n  return emitNamedFnCall(ctx, fnName, pos)\n}\n\n// \u2500\u2500 recover: try inner; on failure scan to sentinel, emit ParseError node \u2500\u2500\u2500\u2500\nfunction emitRecover(def: Extract<ParserDef, { tag: 'recover' }>, ctx: Ctx, pos: string): ER {\n  const { stmts: innerStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos)\n\n  const ind0  = ind(ctx)\n  const scanV = v(ctx, '_sc')\n  const errV  = v(ctx, '_err')\n\n  // Sentinel check runs inside the while loop.\n  const whileBodyLevels = ctx.indent + 2\n  const { stmts: sentStmts, okVar: sentOk } = emitFallible(def.sentinel, ctx, scanV)\n\n  const stmts: string[] = [\n    ...innerStmts,\n    `${ind0}if (!${okVar}) {`,\n    `${ind0}  let ${scanV} = ${pos}`,\n    `${ind0}  while (${scanV} < input.length) {`,\n    ...reindentStmts(sentStmts, whileBodyLevels),\n    `${ind0}    if (${sentOk}) break`,\n    `${ind0}    ${scanV}++`,\n    `${ind0}  }`,\n    `${ind0}  const ${errV} = { _tag: 'parseError', span: { start: ${pos}, end: ${scanV} }, expected: ${JSON.stringify(deriveExpected(def.parser))} }`,\n    `${ind0}  if (_ctx._errors) _ctx._errors.push(${errV})`,\n    `${ind0}  ${valVar} = ${errV}`,\n    `${ind0}  ${endVar} = ${scanV}`,\n    `${ind0}  ${okVar} = true`,\n    `${ind0}}`,\n  ]\n  return { stmts, valueVar: valVar, endVar }\n}\n\n// \u2500\u2500 expect: try inner; on failure record a ParseError + recover in place \u2500\u2500\u2500\u2500\u2500\nfunction emitExpect(def: Extract<ParserDef, { tag: 'expect' }>, ctx: Ctx, pos: string): ER {\n  const { stmts: innerStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos)\n  const ind0 = ind(ctx)\n  const errV = v(ctx, '_err')\n  const stmts: string[] = [\n    ...innerStmts,\n    `${ind0}if (!${okVar}) {`,\n    `${ind0}  const ${errV} = { _tag: 'parseError', span: { start: ${pos}, end: ${pos} }, expected: ${JSON.stringify(def.expected)} }`,\n    `${ind0}  if (_ctx._errors) _ctx._errors.push(${errV})`,\n    // Embed the missing-token error as a `parseError` CST child, mirroring the\n    // interpreter (expect.ts) and the list-recovery emit sites \u2014 guarded on\n    // `_ctx._tolerant`, under which the driver always installs `_ctx._rec`.\n    `${ind0}  if (_ctx._tolerant) _ctx._rec.capture(_ctx, ${errV})`,\n    `${ind0}  ${valVar} = ${errV}`,\n    `${ind0}  ${endVar} = ${pos}`,\n    `${ind0}  ${okVar} = true`,\n    `${ind0}}`,\n  ]\n  return { stmts, valueVar: valVar, endVar }\n}\n\n// ---------------------------------------------------------------------------\n// Main dispatch\n// ---------------------------------------------------------------------------\n\n/**\n * Object-identity de-duplication wrapper around `emitDispatch`. A COMPOUND\n * combinator referenced from more than one place (a shared `const value =\n * choice(...)`, or a sub-parser reached from two positions within one rule) is\n * emitted ONCE as a private named function and CALLED at every reference \u2014\n * instead of pasting its full lowered body at each site, which multiplies\n * combinatorially through nested `many`/`sepBy`/`sequence`. Mirrors emitLazy's\n * named-function path (same `_pf` naming, same recordFail/scope reset). Leaf\n * terminals and `lazy` refs are handled elsewhere; named rules keep their own\n * `_r_<Name>` path; probe/ trivia-capture contexts opt out (see `noHoist`).\n */\nfunction emit(p: Combinator<unknown>, ctx: Ctx, pos: string): ER {\n  const usage = ctx.lazyUsage\n  if (\n    usage &&\n    !ctx.noHoist &&\n    !ctx.capAsTrivia &&\n    !ctx.ruleNames?.has(p) &&\n    isHoistableTag(p._def.tag) &&\n    (usage.counts.get(p) ?? 0) > 1 &&\n    // Only hoist subtrees big enough that de-duplicating them beats the call\n    // overhead. A tiny shared wrapper (e.g. `optional(literal(';'))`) inlines\n    // faster than it calls and barely moves the byte count; the size explosion\n    // is all in LARGE choices/sequences referenced from many positions.\n    (usage.sizes.get(p) ?? 0) >= HOIST_MIN_SUBTREE\n  ) {\n    const existing = ctx.namedParsers.get(p)\n    if (existing !== undefined) return emitNamedFnCall(ctx, existing, pos)\n    const fnName = `${nsp(ctx)}_pf${ctx.namedParsers.size}`\n    ctx.namedParsers.set(p, fnName)   // register FIRST (defensive; a compound ref never self-recurses)\n    const savedIndent    = ctx.indent\n    const savedFailLabel = ctx.failLabel\n    const savedRecord    = ctx.recordFail\n    ctx.indent    = 1\n    ctx.failLabel = '_pfail'  // failures break _pfail (labeled block in the fn body)\n    ctx.recordFail = true     // shared body always records; each caller decides propagation\n    const r = emitDispatch(p, ctx, '_pos')\n    ctx.indent    = savedIndent\n    ctx.failLabel = savedFailLabel\n    ctx.recordFail = savedRecord\n    pushNamedFnDecl(ctx, fnName, r.stmts, r.valueVar, r.endVar)\n    return emitNamedFnCall(ctx, fnName, pos)\n  }\n  return emitDispatch(p, ctx, pos)\n}\n\nfunction emitDispatch(p: Combinator<unknown>, ctx: Ctx, pos: string): ER {\n  const def = p._def\n  switch (def.tag) {\n    case 'literal':   return emitLit(def, ctx, pos)\n    case 'regex':     return emitRegex(def, ctx, pos)\n    case 'keywords':  return emitKeywords(def, ctx, pos)\n    case 'sequence':  return emitSeq(def, ctx, pos)\n    case 'choice':    return emitChoice(def, ctx, pos)\n    case 'many':\n    case 'oneOrMore': return emitMany(def, ctx, pos)\n    case 'optional':  return emitOptional(def, ctx, pos)\n    case 'sepBy':     return emitSepBy(p, def, ctx, pos)\n    case 'transform': {\n      const fnSrc = transformFnSource(def.fn, def.fnSrc)\n      if (fnSrc && def.parser._def.tag === 'sequence') {\n        const seqR = emitSeqValues(def.parser._def, ctx, pos)\n        const inlined = tryInlineDestructureTransform(fnSrc, seqR.valueVars)\n        if (inlined) {\n          const mv = v(ctx, '_mapped')\n          return {\n            stmts: [...seqR.stmts, `${ind(ctx)}const ${mv} = ${inlined}`],\n            valueVar: mv,\n            endVar: seqR.endVar,\n          }\n        }\n      }\n      const inner = emit(def.parser, ctx, pos)\n      if (fnSrc) {\n        const unary = tryInlineUnaryTransform(fnSrc, inner.valueVar)\n        if (unary) {\n          const mv = v(ctx, '_mapped')\n          return {\n            stmts: [...inner.stmts, `${ind(ctx)}const ${mv} = ${unary}`],\n            valueVar: mv,\n            endVar: inner.endVar,\n          }\n        }\n      }\n      const fnIdx = pushMapFn(ctx, def.fn, def.fnSrc ?? null)\n      const mv = v(ctx, '_mapped')\n      return {\n        stmts: [\n          ...inner.stmts,\n          `${ind(ctx)}const ${mv} = ${mfRef(ctx)}[${fnIdx}](${inner.valueVar}, { start: ${pos}, end: ${inner.endVar} })`,\n        ],\n        valueVar: mv,\n        endVar: inner.endVar,\n      }\n    }\n    case 'skip': {\n      const mainR = emit(def.main, ctx, pos)\n      const skipR = emit(def.skipped, ctx, mainR.endVar)\n      // skipped is optional \u2014 if it fails we just keep main's end\n      const endV = v(ctx, '_skipe')\n      return {\n        stmts: [\n          ...mainR.stmts,\n          // try skipped; if fails, keep main end\n          `${ind(ctx)}let ${endV} = ${mainR.endVar}`,\n          `${ind(ctx)}try {`,\n          ...reindentStmts(skipR.stmts, ctx.indent + 1),\n          `${ind(ctx)}  ${endV} = ${skipR.endVar}`,\n          `${ind(ctx)}} catch {}`,\n        ],\n        valueVar: mainR.valueVar,\n        endVar: endV,\n      }\n    }\n    case 'lazy':     return emitLazy(p, def, ctx, pos)\n    case 'trivia':   return emit(def.parser, ctx, pos)\n    case 'token':    return emitToken(def, ctx, pos)\n    case 'label': {\n      const inner = emitFallible(def.parser, ctx, pos)\n      return {\n        stmts: [\n          ...inner.stmts,\n          ...emitIfFail(ctx, `!${inner.okVar}`, failBody(ctx, JSON.stringify(def.label), '_ctx._fe')),\n        ],\n        valueVar: inner.valVar,\n        endVar: inner.endVar,\n      }\n    }\n    case 'field': {\n      const inner = emit(def.parser, ctx, pos)\n      return {\n        stmts: [\n          ...inner.stmts,\n          `${ind(ctx)}if (_ctx._fields) _ctx._fields.push({ name: ${JSON.stringify(def.name)}, value: ${inner.valueVar}, span: { start: ${pos}, end: ${inner.endVar} } })`,\n        ],\n        valueVar: inner.valueVar,\n        endVar: inner.endVar,\n      }\n    }\n    case 'grammar': {\n      const savedTrivia = ctx.activeTrivia\n      const savedKindLabels = ctx.triviaKindLabels\n      if (def.clearTrivia) {\n        // noTrivia / parser({ trivia: null }): contiguous terms, no trivia skipped.\n        ctx.activeTrivia = undefined\n        ctx.triviaKindLabels = undefined\n      } else if (def.triviaParser) {\n        ctx.activeTrivia = def.triviaParser\n        if (def.triviaParser._meta.triviaKindLabels) {\n          ctx.triviaKindLabels = def.triviaParser._meta.triviaKindLabels\n        }\n      }\n      const r = emit(def.parser, ctx, pos)\n      ctx.activeTrivia = savedTrivia\n      ctx.triviaKindLabels = savedKindLabels\n      return r\n    }\n    case 'not':     return emitNot(def, ctx, pos)\n    case 'node':    return emitNode(def, ctx, pos)\n    case 'scanTo':  return emitScanTo(def, ctx, pos)\n    case 'recover': return emitRecover(def, ctx, pos)\n    case 'expect':  return emitExpect(def, ctx, pos)\n    case 'guard': {\n      const fnIdx = ctx.mapFns.length\n      ctx.mapFns.push(def.predicate as (v: unknown, span: unknown) => unknown)\n      // Macro path: inline the captured predicate source; runtime compile() \u2192 null.\n      ctx.mapFnSrcs.push(def.predSrc ?? null)\n      const vv = v(ctx)\n      return {\n        stmts: [\n          ...emitIfFail(ctx, `!${mfRef(ctx)}[${fnIdx}](_ctx.state)`, failBody(ctx, '\"gate\"', pos)),\n          `${ind(ctx)}const ${vv} = null`,\n        ],\n        valueVar: vv,\n        endVar: pos,\n      }\n    }\n    case 'withCtx': {\n      // Store getter for extra value \u2014 _mf[N]() returns the captured value.\n      const evIdx = ctx.mapFns.length\n      const extra = def.extra\n      ctx.mapFns.push((() => extra) as (v: unknown, span: unknown) => unknown)\n      // Macro path: inline the captured `extra` as a getter `() => (extra)` so\n      // `_mf[evIdx]()` returns the value; runtime compile() \u2192 null (closure above).\n      ctx.mapFnSrcs.push(def.extraSrc !== undefined ? `() => (${def.extraSrc})` : null)\n\n      // Wrap inner parser as a named function so it receives _ctx as a parameter.\n      // That lets us call it with a modified ctx (user changed) without polluting\n      // the outer _ctx variable for subsequent emits.\n      const innerParser = def.parser as Combinator<unknown>\n      if (!ctx.namedParsers.has(innerParser)) {\n        const fnName = `_wcf${ctx.namedParsers.size}`\n        ctx.namedParsers.set(innerParser, fnName)\n        const savedIndent    = ctx.indent\n        const savedFailLabel = ctx.failLabel\n        const savedRecord    = ctx.recordFail\n        ctx.indent    = 1\n        ctx.failLabel = '_pfail'  // failures break _pfail (same as emitLazy)\n        ctx.recordFail = true     // shared body always records (see emitLazy)\n        // Emit the inner BODY directly (emitDispatch), not through the hoist\n        // wrapper `emit()`. We just pre-registered `innerParser \u2192 _wcf` above so\n        // OTHER references reuse this named fn; re-entering `emit()` here would\n        // re-find that same registration and emit a SELF-CALL (`_wcf` calls\n        // `_wcf`) whenever the inner is multiply-reachable (`counts > 1`) and big\n        // enough to hoist \u2014 infinite recursion at parse time. Mirrors `emit()`'s\n        // own register-then-emitDispatch pattern (never emit-on-self).\n        const innerR = emitDispatch(innerParser, ctx, '_pos')\n        ctx.indent    = savedIndent\n        ctx.failLabel = savedFailLabel\n        ctx.recordFail = savedRecord\n        pushNamedFnDecl(ctx, fnName, innerR.stmts, innerR.valueVar, innerR.endVar)\n      }\n      const fn = ctx.namedParsers.get(innerParser)!\n\n      const rv = v(ctx, '_wcr')\n      const vv = v(ctx, '_wcv')\n      const ev = v(ctx, '_wce')\n      return {\n        stmts: [\n          `${ind(ctx)}const ${rv} = { ..._ctx, state: ${mfRef(ctx)}[${evIdx}]() }`,\n          `${ind(ctx)}const ${vv} = ${fn}(input, ${pos}, ${rv})`,\n          // withCtx runs on a spread child ctx \u2014 copy its recorded failure back\n          // and propagate the inner failure verbatim (interpreter parity).\n          ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, propagateFailBody(ctx, rv)),\n          `${ind(ctx)}const ${ev} = ${NAMED_FN_END}`,\n        ],\n        valueVar: vv,\n        endVar: ev,\n      }\n    }\n    default:         return emitRuntimeFallback(p, ctx, pos)\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\nexport type CompiledParser<T> = {\n  parse(input: string, pos?: number): ParseResult<T>\n  /** Like parse(), but with a caller-supplied ParseContext (e.g. `_triviaLog` for CST grammars). */\n  parseWithContext(input: string, ctx: ParseContext, pos?: number): ParseResult<T>\n  /**\n   * Like parse(), but activates the error-collection channel. Recovery points\n   * (expect()) collect their ParseErrors into result.errors instead of only\n   * embedding them as values. Always returns ParseOk \u2014 top-level failures are\n   * still ParseFail.\n   */\n  parseWithErrors(input: string, pos?: number): ParseResult<T> & { errors: ParseError[] }\n  /** The generated source (for inspection / future source maps) */\n  source: string\n  /**\n   * A self-contained JS expression (IIFE) that evaluates to a parse function.\n   * Safe to inline directly into transformed source \u2014 no external references\n   * except for runtime-fallback parsers embedded via closures.\n   * Returns null if the parser cannot be fully inlined (e.g. contains user\n   * closures that can't be serialized).\n   */\n  inlineExpression: string | null\n}\n\n/**\n * Does this combinator tree contain a node() anywhere (following ref/lazy\n * thunks)? Determines whether the compile emits CST capture \u2014 so non-node\n * grammars stay byte-identical. `seen` guards against recursion cycles.\n */\nfunction hasNodeDef(p: Combinator<unknown>, seen: Set<Combinator<unknown>> = new Set()): boolean {\n  if (seen.has(p)) return false\n  seen.add(p)\n  const d = p._def\n  switch (d.tag) {\n    case 'node':      return true\n    case 'lazy':      { try { return hasNodeDef(d.thunk(), seen) } catch { return false } }\n    case 'grammar':\n    case 'trivia':\n    case 'token':\n    case 'label':\n    case 'field':\n    case 'optional':\n    case 'many':\n    case 'oneOrMore':\n    case 'not':\n    case 'transform': return hasNodeDef(d.parser, seen)\n    case 'skip':      return hasNodeDef(d.main, seen) || hasNodeDef(d.skipped, seen)\n    case 'sequence':\n    case 'choice':    return d.parsers.some(x => hasNodeDef(x, seen))\n    case 'sepBy':     return hasNodeDef(d.parser, seen) || hasNodeDef(d.separator, seen)\n    case 'scanTo':    return hasNodeDef(d.sentinel, seen) || d.skip.some(x => hasNodeDef(x, seen))\n    case 'recover':   return hasNodeDef(d.parser, seen) || hasNodeDef(d.sentinel, seen)\n    case 'expect':    return hasNodeDef(d.parser, seen)\n    case 'withCtx':   return hasNodeDef(d.parser, seen)\n    default:          return false\n  }\n}\n\n/** Immediate child combinators of a def, for generic tree walks (childrenOf). */\nfunction childrenOf(def: ParserDef): Combinator<unknown>[] {\n  switch (def.tag) {\n    case 'sequence':\n    case 'choice':    return def.parsers\n    case 'many':\n    case 'optional':\n    case 'transform':\n    case 'trivia':\n    case 'token':\n    case 'label':\n    case 'field':\n    case 'grammar':\n    case 'not':\n    case 'node':\n    case 'withCtx':\n    case 'expect':    return [def.parser]\n    // emitMany's oneOrMore branch and emitSepBy both codegen `def.parser` TWICE\n    // (a mandatory first match, then again inside the repeat loop) \u2014 two real\n    // emit() call sites, so the usage analysis must see two edges here or it\n    // undercounts a single-use `parser` ref as inline-safe when it's actually\n    // referenced from two positions within this one compiled function.\n    case 'oneOrMore': return [def.parser, def.parser]\n    case 'sepBy':     return [def.parser, def.parser, def.separator]\n    case 'skip':      return [def.main, def.skipped]\n    case 'recover':   return [def.parser, def.sentinel]\n    case 'scanTo':    return [def.sentinel, ...def.skip]\n    case 'lazy':\n    case 'literal':\n    case 'regex':\n    case 'keywords':\n    case 'guard':\n    case 'unknown':   return []\n  }\n}\n\n/**\n * Compound combinators worth hoisting into a shared named function when the SAME\n * object is referenced more than once. Leaf terminals (`literal`/`regex`/\n * `keywords`/`guard`) aren't worth a call; `lazy` is owned by emitLazy; the\n * context-bearing wrappers (`grammar`/`trivia`/`label`/`withCtx`/`expect`/`skip`/\n * `recover`/`scanTo`) are excluded so no per-site context (active trivia, capture\n * mode) can be baked into a shared body.\n */\nconst HOISTABLE_TAGS: ReadonlySet<ParserDef['tag']> = new Set<ParserDef['tag']>([\n  'sequence', 'choice', 'many', 'oneOrMore', 'optional', 'sepBy', 'transform', 'node', 'not',\n])\nfunction isHoistableTag(tag: ParserDef['tag']): boolean {\n  return HOISTABLE_TAGS.has(tag)\n}\n\n/** Minimum approximate subtree size (see `subtreeSizes`) for a shared combinator\n * to be hoisted into a named function rather than inlined at each reference.\n * Small enough to catch every real explosion (a value `choice` is ~12+), large\n * enough that trivial shared wrappers stay inline and keep the hot path fast. */\nconst HOIST_MIN_SUBTREE = 3\n\n/**\n * Static-occurrence analysis for `lazy` (ref()) combinators, ahead of codegen.\n * `emitLazy` currently hoists EVERY lazy ref into its own named function\n * (_pfN), even when it's referenced from exactly one place \u2014 necessary for\n * genuinely recursive/shared rules, wasteful for the common case of a `g.foo`\n * helper rule used for grammar readability but only ever called once. On a\n * large mutually-referential grammar (many `g.xxx` helper rules, each used\n * from ~1 call site) this multiplies function count far past the number of\n * rules a grammar author actually wrote \u2014 observed on the Less grammar:\n * ~1700 compiled functions from ~150 source rules, vs a roughly 1:3 ratio on\n * a comparably-sized but flatter grammar.\n *\n * Returns, for every reachable `lazy` combinator: how many static call sites\n * reference it (`counts`), and whether it participates in a reference cycle\n * (`recursive` \u2014 must stay a named function; inlining a cycle would recurse\n * forever). A ref with count <= 1 and no cycle membership is safe to inline\n * directly at its single call site instead of becoming a named function.\n *\n * Traversal cost: each `lazy` ref's body is descended into at most once\n * (subsequent occurrences just bump the counter) \u2014 polynomial in the number\n * of distinct reachable combinators, matching emitLazy's own memoized\n * codegen cost. Non-lazy nodes are walked without memoization, same as\n * `emit()` itself (a directly-shared non-ref subtree \u2014 discouraged by the\n * `g.xxx` convention but not disallowed \u2014 is revisited per occurrence, same\n * cost class as compilation already pays for it today).\n */\ntype LazyUsage = {\n  counts: Map<Combinator<unknown>, number>\n  recursive: Set<Combinator<unknown>>\n  sizes: Map<Combinator<unknown>, number>\n}\n\nfunction analyzeLazyUsage(root: Combinator<unknown>): LazyUsage {\n  return analyzeLazyUsageMulti([root])\n}\n\n/**\n * Memoized approximate subtree size: number of combinator nodes reachable from\n * `p` WITHOUT crossing a `lazy` boundary (a ref counts as 1 leaf \u2014 it lowers to a\n * call, not an inline expansion). This is the size that would be DUPLICATED if the\n * subtree were pasted at another reference, so it's the right quantity to gate\n * hoisting on. Cycles (only possible through a `lazy`, which is a leaf here) can't\n * recur. */\nfunction subtreeSizes(roots: Iterable<Combinator<unknown>>): Map<Combinator<unknown>, number> {\n  const sizes = new Map<Combinator<unknown>, number>()\n  // A node's inline-expansion size: itself + each child's size, but a `lazy` child\n  // counts as 1 (it lowers to a call, so it isn't part of the duplicated bytes).\n  // Never crosses a lazy, so it can't cycle (compound nodes don't cycle alone).\n  const sz = (p: Combinator<unknown>): number => {\n    const cached = sizes.get(p)\n    if (cached !== undefined) return cached\n    const def = p._def\n    let s = 1\n    if (def.tag !== 'lazy') {\n      for (const child of childrenOf(def)) s += child._def.tag === 'lazy' ? 1 : sz(child)\n    }\n    sizes.set(p, s)\n    return s\n  }\n  // Visit crosses lazy boundaries (the roots ARE lazy rule-refs) so every reachable\n  // compound node gets a size entry; sz() then fills the whole non-lazy subtree.\n  const visitedLazy = new Set<Combinator<unknown>>()\n  const visit = (p: Combinator<unknown>): void => {\n    const def = p._def\n    if (def.tag === 'lazy') {\n      if (visitedLazy.has(p)) return\n      visitedLazy.add(p)\n      let resolved: Combinator<unknown>\n      try { resolved = def.thunk() } catch { return }\n      visit(resolved)\n      return\n    }\n    sz(p)\n    for (const child of childrenOf(def)) visit(child)\n  }\n  for (const root of roots) visit(root)\n  return sizes\n}\n\n/**\n * Multi-root variant, for compileRuleMap(): a `rules()` factory's returned\n * map has many top-level entries that legitimately share reachable sub-rules\n * (e.g. `Stylesheet` and `Declaration` both reach `g.valueList`). Walking each\n * entry as its own root into ONE shared counts/descended/active state means a\n * ref's count correctly reflects total usage across the WHOLE rule map \u2014 used\n * once as its own top-level entry AND referenced once internally elsewhere is\n * count 2 (stays a named function, shared correctly), not two independent 1s\n * from two unrelated single-root analyses.\n */\nfunction analyzeLazyUsageMulti(roots: Iterable<Combinator<unknown>>): LazyUsage {\n  const counts = new Map<Combinator<unknown>, number>()\n  const recursive = new Set<Combinator<unknown>>()\n  const descended = new Set<Combinator<unknown>>()\n  const active = new Set<Combinator<unknown>>()\n\n  function walk(p: Combinator<unknown>): void {\n    const def = p._def\n    if (def.tag === 'lazy') {\n      counts.set(p, (counts.get(p) ?? 0) + 1)\n      if (active.has(p)) {\n        recursive.add(p)\n        return\n      }\n      if (descended.has(p)) return\n      descended.add(p)\n      let resolved: Combinator<unknown>\n      try {\n        resolved = def.thunk()\n      } catch {\n        return // ref.define() not called yet \u2014 emitLazy's own try/catch handles this at codegen time\n      }\n      active.add(p)\n      walk(resolved)\n      active.delete(p)\n      return\n    }\n    // A non-lazy COMPOUND combinator shared by object identity (e.g. a\n    // `const value = choice(...)` referenced from several rules, or a sub-parser\n    // reached through nested `many`/`sepBy`) is counted per reference edge, so\n    // codegen can hoist a multiply-referenced subtree into ONE named function\n    // instead of pasting its full lowered body at every reference \u2014 the\n    // multiplication that makes nested value grammars explode. We intentionally do\n    // NOT memoize the descent here: cycle detection for `lazy` relies on fully\n    // traversing every active path (a compound `descended` short-circuit would let\n    // the walker return before re-reaching an active `self` ref and marking it\n    // recursive \u2192 emitLazy would then inline a recursive ref forever). Non-lazy\n    // nodes never form a cycle without passing through a `lazy` (which has its own\n    // active/descended guards), so the re-walk stays finite \u2014 same cost as before.\n    if (isHoistableTag(def.tag)) {\n      counts.set(p, (counts.get(p) ?? 0) + 1)\n    }\n    for (const child of childrenOf(def)) walk(child)\n  }\n\n  const rootsArr = [...roots]\n  for (const root of rootsArr) walk(root)\n  return { counts, recursive, sizes: subtreeSizes(rootsArr) }\n}\n\n/**\n * Dependency manifest for the linkable form: for each rule in the map, the set\n * of OTHER rule names its body references (by name). A referenced rule is a\n * boundary \u2014 we record the edge and do NOT descend into it (its own deps are its\n * own entry). Used by the linker for \u00E0 la carte dep-closure selection and the\n * compose-time name-closure check (every referenced name must resolve in the\n * final set). Self-references are included (a recursive rule depends on itself).\n */\nexport function ruleDependencies(\n  ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>,\n): Map<string, string[]> {\n  const nameOf = new Map<Combinator<unknown>, string>()\n  for (const [name, comb] of ruleMap) nameOf.set(comb, name)\n\n  const deps = new Map<string, string[]>()\n  for (const [name, comb] of ruleMap) {\n    const found = new Set<string>()\n    const seen = new Set<Combinator<unknown>>()\n    const walk = (p: Combinator<unknown>, isRoot: boolean): void => {\n      const def = p._def\n      // A named `ref` (local OR external) is a rule boundary: record the edge and\n      // don't descend. `_ruleName` (set by rules()) also catches EXTERNAL refs \u2014\n      // rules referenced by name but defined in another artifact.\n      const boundary = def.tag === 'lazy'\n        ? ((p as unknown as { _ruleName?: string })._ruleName ?? nameOf.get(p))\n        : nameOf.get(p)\n      if (!isRoot && boundary !== undefined) { found.add(boundary); return }\n      if (seen.has(p)) return\n      seen.add(p)\n      if (def.tag === 'lazy') {\n        let resolved: Combinator<unknown>\n        try { resolved = def.thunk() } catch { return }\n        walk(resolved, false)\n        return\n      }\n      for (const child of childrenOf(def)) walk(child, false)\n    }\n    walk(comb, true)\n    deps.set(name, [...found])\n  }\n  return deps\n}\n\n/**\n * Compile a combinator tree into an optimized parse function at runtime.\n *\n * Uses `new Function` internally, so it will fail in environments with a strict\n * Content Security Policy that omits `'unsafe-eval'`. Prefer the interpreter or\n * macro build plugin in those cases.\n *\n * @see https://www.greadme.com/blog/security/what-is-content-security-policy-complete-guide\n */\nexport function compile<T>(combinator: Combinator<T>, mapFnSources?: string[], opts?: { recovery?: boolean }): CompiledParser<T> {\n  markUnusedValues(combinator)\n  // Grammar-level ambient trivia declared via rules({ trivia }, factory): seed it\n  // as the default activeTrivia so every rule bakes it (unless a local\n  // parser({trivia}) / noTrivia overrides). This is the compiled mirror of the\n  // interpreter installing it as ctx.trivia at the entry.\n  const grammarTrivia = (combinator._meta as { grammarTrivia?: Combinator<unknown> }).grammarTrivia\n  const ctx: Ctx = {\n    vars: 0,\n    indent: 1,\n    regexDecls: [],\n    regexMap: new Map(),\n    expectedDecls: [],\n    expectedMap: new Map(),\n    recordFail: true,\n    mapFns: [],\n    mapFnSrcs: [],\n    buildFns: [],\n    buildSrcs: [],\n    runtimeParsers: [],\n    namedParsers: new Map(),\n    triviaCaptureNames: new Map(),\n    triviaFnNames: new Map(),\n    namedFnDecls: [],\n    capturing: hasNodeDef(combinator as Combinator<unknown>),\n    recovery: opts?.recovery ?? false,\n    lazyUsage: analyzeLazyUsage(combinator as Combinator<unknown>),\n    ...(grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {}),\n  }\n\n  const r = emit(combinator as Combinator<unknown>, ctx, '_pos')\n\n  const namedPrelude = ctx.namedFnDecls.length > 0 ? [...namedFnPrelude(), ''] : []\n  const emptyTlDecls = ctx.needsEmptyTl ? ['const _EMPTY_TL = Object.freeze([])'] : []\n  const hostReadsDecls = ctx.needsHostReads ? [HOST_READS_DECL] : []\n\n  const source = [\n    ...emptyTlDecls,\n    ...hostReadsDecls,\n    ...ctx.regexDecls,\n    ...ctx.expectedDecls,\n    '',\n    ...namedPrelude,\n    ctx.namedFnDecls.join('\\n\\n'),\n    `function _parse(input, _pos, _rp, _mf, _build, _ctx) {`,\n    `  let pos = _pos`,\n    ...r.stmts,\n    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n    `}`,\n  ].join('\\n')\n\n  const fn = new Function('input', '_pos', '_rp', '_mf', '_build', '_ctx', [\n    ...emptyTlDecls,\n    ...hostReadsDecls,\n    ...ctx.regexDecls,\n    ...ctx.expectedDecls,\n    ...namedPrelude,\n    ...ctx.namedFnDecls.flatMap((decl, i) => (i > 0 ? ['', decl] : [decl])),\n    `let pos = _pos`,\n    ...r.stmts,\n    `return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n  ].join('\\n')) as (\n    input: string,\n    pos: number,\n    rp: Array<Combinator<unknown>>,\n    mf: Array<(v: unknown, span: { start: number; end: number }) => unknown>,\n    build: Ctx['buildFns'],\n    ctx: ParseContext,\n  ) => ParseResult<T>\n\n  const defaultCtx: ParseContext = {\n    trackLines: false,\n    ...(ctx.triviaKindLabels ? { triviaKindLabels: ctx.triviaKindLabels } : {}),\n  }\n\n  // Prefer per-def sources captured in codegen-traversal order (set by the\n  // macro via def.fnSrc). Fall back to a caller-provided positional array.\n  // The derived array is only usable when every traversed transform carried a\n  // source \u2014 otherwise we can't inline the closures.\n  const derivedSrcs = ctx.mapFnSrcs.length === ctx.mapFns.length && ctx.mapFnSrcs.every((s): s is string => s !== null)\n    ? ctx.mapFnSrcs as string[]\n    : undefined\n  const effectiveSources = mapFnSources ?? derivedSrcs\n\n  // node() build fns inline the same way: every traversed node must carry its\n  // build source (set by the macro via def.buildSrc) or we can't inline.\n  const buildCovered = ctx.buildFns.length === 0 || ctx.buildSrcs.every((s): s is string => s !== null)\n  const buildSources = ctx.buildFns.length === 0 ? undefined : (ctx.buildSrcs as string[])\n\n  // Build an inline expression when there are no runtime fallbacks, and either\n  // no map-function closures or their source text has been provided for injection.\n  const mfCovered = ctx.mapFns.length === 0 || (effectiveSources !== undefined && effectiveSources.length === ctx.mapFns.length)\n  const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered\n  const inlineExpression: string | null = canInline ? buildInlineExpression(ctx, r, effectiveSources, buildSources) : null\n\n  return {\n    source,\n    inlineExpression,\n    parse(input: string, pos = 0): ParseResult<T> {\n      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, defaultCtx)\n    },\n    parseWithContext(input: string, parseCtx: ParseContext, pos = 0): ParseResult<T> {\n      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, parseCtx)\n    },\n    // Note: collects expect() errors via _errors. Unlike interpreter\n    // parse({recover:true}) it does NOT populate furthestFail \u2014 the compiled path\n    // inlines failures for throughput and deliberately skips _probe bookkeeping.\n    // Callers wanting a furthest-position diagnostic detect unconsumed input\n    // (span.end < input.length) instead, which is mode-agnostic.\n    parseWithErrors(input: string, pos = 0): ParseResult<T> & { errors: ParseError[] } {\n      const errors: ParseError[] = []\n      const result = fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, { ...defaultCtx, _errors: errors })\n      return { ...result, errors } as ParseResult<T> & { errors: ParseError[] }\n    },\n  }\n}\n\n/**\n * Compile every entry of a `rules(factory)` map's returned object using ONE\n * shared codegen Ctx (regexes, named functions, map/build-fn arrays) instead\n * of running `compile()` independently per entry.\n *\n * Why this exists: `compile()` per entry gives each entry its own namedParsers\n * cache, so a sub-rule reachable from N different top-level entries (e.g.\n * `valueList` reachable from `Declaration`, `CustomDeclaration`, `Guard`, \u2026)\n * gets fully re-compiled N times \u2014 on a richly cross-referential grammar\n * (Less: ~125 rule-map entries, deep mutual reference) this multiplies total\n * compiled size far past what the source grammar actually needs, independent\n * of the per-ref single-use inlining `analyzeLazyUsage` already handles\n * within one compile() call. Sharing one Ctx here means a sub-rule compiles\n * exactly once for the WHOLE rule map, however many entries reach it.\n *\n * Returns a single `replacement` \u2014 ONE shared IIFE, evaluated once, whose\n * result is the `{ key: fn, ... }` map \u2014 meant to replace the entire\n * `rules(factory)` call-expression (not one expression per key; splicing a\n * separate self-contained expression per key would either re-run the shared\n * prelude once per entry or duplicate its text per entry, undoing the win).\n * `keys` lists every entry compileRuleMap() saw, for the caller to validate\n * against the source's own key list.\n *\n * Returns null (same all-or-nothing contract the per-entry `compile()` +\n * `inlineExpression === null` check gave the plugin before) when the map\n * contains anything that can't be inlined \u2014 a runtime-fallback parser, or an\n * uncaptured transform/build closure source. The plugin's existing \"warn and\n * leave this rules() call interpreted\" fallback covers this case unchanged.\n */\n/**\n * Grammar rule names compile to `_r_<Name>` functions and `@FS:<name>` dispatch\n * placeholders, so they MUST be valid JS identifiers. A non-identifier name (e.g.\n * `'my-rule'`) is a grammar-authoring error \u2014 throw rather than silently mangle it\n * to `_r_my_rule`, which could collide with a real `my_rule` rule.\n */\nconst RULE_NAME_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/\nfunction assertRuleName(name: string): void {\n  if (!RULE_NAME_RE.test(name)) {\n    throw new Error(\n      `parseman: grammar rule name ${JSON.stringify(name)} is not a valid JS identifier. ` +\n      `Rule names compile to _r_<Name> functions and dispatch guards \u2014 use letters, digits, ` +\n      `_ or $ (and don't start with a digit).`,\n    )\n  }\n}\n\nfunction publicRuleWrapperSource(rule: Combinator<unknown>, fnSource: string): string {\n  const labels = rule._meta.triviaKindLabels\n  if (labels === undefined) return fnSource\n  return `Object.assign(${fnSource}, { _meta: { triviaKindLabels: ${JSON.stringify(labels)} } })`\n}\n\nexport function compileRuleMap(\n  ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>,\n  opts?: { trivia?: Combinator<unknown>; recovery?: boolean },\n): { keys: string[]; replacement: string } | null {\n  for (const [, rule] of ruleMap) markUnusedValues(rule)\n  // Grammar-level ambient trivia declared via rules({ trivia }, factory): seed it\n  // as the default activeTrivia so every rule in the map bakes it (unless a local\n  // parser({trivia}) / noTrivia overrides). Mirrors the interpreter installing it\n  // as ctx.trivia at the entry, and compile()'s single-entry seed.\n  const grammarTrivia = opts?.trivia\n  const ctx: Ctx = {\n    vars: 0,\n    indent: 1,\n    regexDecls: [],\n    regexMap: new Map(),\n    expectedDecls: [],\n    expectedMap: new Map(),\n    recordFail: true,\n    mapFns: [],\n    mapFnSrcs: [],\n    buildFns: [],\n    buildSrcs: [],\n    runtimeParsers: [],\n    namedParsers: new Map(),\n    triviaCaptureNames: new Map(),\n    triviaFnNames: new Map(),\n    namedFnDecls: [],\n    capturing: ruleMap.some(([, rule]) => hasNodeDef(rule)),\n    recovery: opts?.recovery ?? false,\n    lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),\n    ...(grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {}),\n  }\n\n  // Reverse map: each rule's `ref` placeholder \u2192 its canonical `_r_<Name>` fn\n  // name. `emitLazy` uses this so every reference to a named rule (sibling call\n  // OR the map entry itself) resolves to one shared `_r_<Name>` function \u2014 the\n  // linkable form that fuses into a single scope with direct local calls.\n  const seenNames = new Map<string, number>()\n  const ruleNames = new Map<Combinator<unknown>, string>()\n  for (const [key, rule] of ruleMap) {\n    assertRuleName(key)\n    const base = `_r_${key}`\n    const n = seenNames.get(base) ?? 0\n    seenNames.set(base, n + 1)\n    ruleNames.set(rule, n === 0 ? base : `${base}$${n}`)\n  }\n  ctx.ruleNames = ruleNames\n\n  // A trivia rule (e.g. the grammar's `rw`, returned from the factory so the\n  // driver can reach it as `g.rw`) must NOT bake the grammar-level ambient trivia\n  // into itself \u2014 it would recursively skip trivia between its own terms and stop\n  // short. Emit it with activeTrivia cleared, matching the inline-trivia guard.\n  const perEntry = ruleMap.map(([key, rule]) => {\n    const savedTrivia = ctx.activeTrivia\n    if (rule._meta.isTrivia) ctx.activeTrivia = undefined\n    const r = emit(rule, ctx, '_pos')\n    ctx.activeTrivia = savedTrivia\n    return { key, rule, r }\n  })\n\n  const derivedSrcs = ctx.mapFnSrcs.length === ctx.mapFns.length && ctx.mapFnSrcs.every((s): s is string => s !== null)\n    ? ctx.mapFnSrcs as string[]\n    : undefined\n  const buildCovered = ctx.buildFns.length === 0 || ctx.buildSrcs.every((s): s is string => s !== null)\n  const buildSources = ctx.buildFns.length === 0 ? undefined : (ctx.buildSrcs as string[])\n  const mfCovered = ctx.mapFns.length === 0 || derivedSrcs !== undefined\n  const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered\n  if (!canInline) return null\n\n  const mfDecl = derivedSrcs?.length ? `  const ${mfRef(ctx)} = [${derivedSrcs.join(', ')}]` : ''\n  const buildDecl = buildSources?.length ? `  const ${buildRef(ctx)} = [${buildSources.join(', ')}]` : ''\n  const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : []\n  const hoistedDecls = [\n    ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : '',\n    ctx.needsHostReads ? `  ${HOST_READS_DECL}` : '',\n    ...ctx.regexDecls.map(d => `  ${d}`),\n    ...ctx.expectedDecls.map(d => `  ${d}`),\n    mfDecl,\n    buildDecl,\n    ...namedPrelude.map(l => `  ${l}`),\n    ...ctx.namedFnDecls.flatMap((decl, i) => {\n      const lines = decl.split('\\n').map(l => `  ${l}`)\n      return i > 0 ? ['', ...lines] : lines\n    }),\n  ].filter(Boolean)\n\n  const entryFnText = (r: ER): string => [\n    `function(input, _pos, _ctx) {`,\n    `  let pos = _pos`,\n    ...r.stmts,\n    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n    `}`,\n  ].join('\\n')\n\n  // One shared IIFE, evaluated ONCE, returning the whole `{ key: fn, ... }`\n  // map \u2014 this whole string is the caller's replacement for the entire\n  // `rules(factory)` call-expression (NOT one expression per key spliced into\n  // a separately-built object literal, which would either re-run the shared\n  // prelude per entry or duplicate its text per entry \u2014 both defeat the point).\n  const objBody = perEntry\n    .map(({ key, rule, r }) => {\n      const src = publicRuleWrapperSource(rule, entryFnText(r))\n      return `    ${JSON.stringify(key)}: ${src.split('\\n').join('\\n    ')}`\n    })\n    .join(',\\n')\n  const replacement = [\n    `/* @__PURE__ */ (() => {`,\n    ...hoistedDecls,\n    `  return {`,\n    objBody,\n    `  }`,\n    `})()`,\n  ].join('\\n')\n\n  return { keys: perEntry.map(e => e.key), replacement }\n}\n\n/**\n * The linkable form of a rule map (RULE_ABI_PLAN \u00A73): the same compiled rule\n * bodies as `compileRuleMap`, but returned as **splice-able pieces** under a\n * namespace `ns` so multiple independently-compiled maps fuse into one scope\n * (see `fuseRules`). `ns` MUST be non-empty and unique per artifact (the caller\n * derives it \u2014 module identity in the macro, a counter in `compile()`).\n *\n *   prelude  \u2014 namespaced hoisted decls (regexes, expected, `_mf`/`_build`, and\n *              private `_pf` helper fns). Sentinels / `_EMPTY_TL`\n *              are NOT here \u2014 they are SHARED, emitted once by the linker.\n *   ruleFns  \u2014 name \u2192 `function _r_<Name>(\u2026) { \u2026 }` source (the composition\n *              surface; siblings call these by name).\n *   wrappers \u2014 name \u2192 public `(input,pos,ctx) => ParseResult` wrapper source.\n *   deps     \u2014 name \u2192 referenced rule names (from `ruleDependencies`).\n *\n * Returns null on the same \"can't inline\" conditions as `compileRuleMap`.\n */\nexport type LinkablePieces = {\n  ns: string\n  keys: string[]\n  prelude: string[]\n  ruleFns: Map<string, string>\n  wrappers: Map<string, string>\n  /**\n   * Per-rule first-set (this artifact's own rules). fusedBody() uses the WINNING\n   * artifact's entry to resolve `/*@FS:rule:codevar@*\u200B/true` dispatch placeholders\n   * emitted for rule-ref choice arms \u2014 sound under compose override.\n   */\n  firstSets: Map<string, FirstSet>\n  deps: Map<string, string[]>\n  needsEmptyTl: boolean\n  needsHostReads: boolean\n  /**\n   * Transform (`_mf`) / build (`_build`) callback FUNCTIONS, injected into the\n   * fused scope via `_env` when their SOURCE isn't available (runtime `compile()`\n   * mode). Empty when the callbacks were inlined from source (macro mode). Keyed\n   * for `_env` as `<ns>mf` / `<ns>build`.\n   */\n  mfFns: ReadonlyArray<(...args: unknown[]) => unknown>\n  buildFns: ReadonlyArray<(...args: unknown[]) => unknown>\n}\n\nexport function compileLinkable(\n  ruleMapArg: ReadonlyArray<readonly [string, Combinator<unknown>]>,\n  ns: string,\n  opts?: { trivia?: Combinator<unknown>; recovery?: boolean },\n): LinkablePieces | null {\n  if (!ns) throw new Error('compileLinkable: ns must be a non-empty namespace')\n  for (const [, rule] of ruleMapArg) markUnusedValues(rule)\n  // Grammar-level ambient trivia through compose(): a piece from rules({ trivia },\n  // \u2026) tags `grammarTrivia` on its rules (runtime path), or the macro threads it via\n  // `opts.trivia`. Seed it as the default activeTrivia so every fused rule bakes it \u2014\n  // the compose mirror of compileRuleMap's seed. `parser`/`noTrivia` still override.\n  const grammarTrivia = opts?.trivia\n    ?? ruleMapArg.map(([, r]) => (r._meta as { grammarTrivia?: Combinator<unknown> }).grammarTrivia).find(Boolean)\n  // Drop EXTERNAL entries: `rules(g => \u2026)` returns a cache that also holds every\n  // `g.X` that was ACCESSED, so an accessed-but-not-defined rule (defined in\n  // another artifact) leaks into `Object.entries` as an undefined `ref`. Those\n  // are not local rules \u2014 they're by-name references resolved at fuse time (the\n  // pre-scan below emits their calls). A rule is local iff its value is non-lazy\n  // or a `ref` that resolves.\n  const ruleMap = ruleMapArg.filter(([, val]) => {\n    const d = val._def\n    if (d.tag !== 'lazy') return true\n    try { d.thunk(); return true } catch { return false }\n  })\n  const ctx: Ctx = {\n    vars: 0, indent: 1, regexDecls: [], regexMap: new Map(),\n    expectedDecls: [], expectedMap: new Map(), recordFail: true,\n    mapFns: [], mapFnSrcs: [], buildFns: [], buildSrcs: [], runtimeParsers: [],\n    namedParsers: new Map(), triviaCaptureNames: new Map(),\n    triviaFnNames: new Map(), namedFnDecls: [],\n    capturing: ruleMap.some(([, rule]) => hasNodeDef(rule)),\n    recovery: opts?.recovery ?? false,\n    lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),\n    ns,\n    deferFirstSetRefs: true,\n    ...(grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {}),\n  }\n  // Canonical name per rule. Register in BOTH ruleNames (so sibling `emitLazy`\n  // refs resolve by name) AND namedParsers up-front (so a rule emitted before a\n  // recursive back-edge still finds itself). Unlike `compileRuleMap`, EVERY rule\n  // is force-emitted as a named fn \u2014 even one referenced by nobody but its own\n  // entry (its map value is the bare combinator, not a `ref`, so it would\n  // otherwise inline and never get a name).\n  const seen = new Map<string, number>()\n  const ruleNames = new Map<Combinator<unknown>, string>()\n  const fnNameToKey = new Map<string, string>()\n  for (const [key, rule] of ruleMap) {\n    assertRuleName(key)\n    const base = `_r_${key}`\n    const n = seen.get(base) ?? 0\n    seen.set(base, n + 1)\n    const fn = n === 0 ? base : `${base}$${n}`\n    ruleNames.set(rule, fn)\n    fnNameToKey.set(fn, key)\n  }\n  ctx.ruleNames = ruleNames\n\n  // Pre-register EXTERNAL rule references: a named `ref` placeholder that doesn't\n  // resolve locally (defined in ANOTHER artifact). Emit a by-name `_r_<Name>`\n  // call for it \u2014 no body here; it's provided at fuse time. This is what lets a\n  // fragment reference a consumer/base rule (`g.value`, `g.Digits`) without its\n  // source.\n  {\n    const scanned = new Set<Combinator<unknown>>()\n    const scanExternal = (p: Combinator<unknown>): void => {\n      if (scanned.has(p)) return\n      scanned.add(p)\n      const def = p._def\n      if (def.tag === 'lazy') {\n        let resolved: Combinator<unknown> | undefined\n        try { resolved = def.thunk() } catch { resolved = undefined }\n        if (resolved === undefined) {\n          const name = (p as unknown as { _ruleName?: string })._ruleName\n          if (name && !ctx.namedParsers.has(p)) {\n            assertRuleName(name)\n            const fn = `_r_${name}`\n            ruleNames.set(p, fn)\n            ctx.namedParsers.set(p, fn)\n          }\n          return\n        }\n        scanExternal(resolved)\n        return\n      }\n      for (const child of childrenOf(def)) scanExternal(child)\n    }\n    for (const [, rule] of ruleMap) scanExternal(rule)\n  }\n\n  // Emit each rule's body as its `_r_<Name>` fn (resolving a `ref` placeholder to\n  // its target), then build a public wrapper that calls it.\n  const perEntry: Array<{ key: string; rule: Combinator<unknown>; r: ER }> = []\n  for (const [key, rule] of ruleMap) {\n    const fn = ruleNames.get(rule)!\n    if (!ctx.namedParsers.has(rule)) {\n      ctx.namedParsers.set(rule, fn)\n      let resolved: Combinator<unknown> = rule\n      const def = rule._def\n      if (def.tag === 'lazy') {\n        try { resolved = def.thunk() } catch { return null }\n      }\n      const savedIndent = ctx.indent, savedFail = ctx.failLabel, savedRec = ctx.recordFail\n      ctx.indent = 1; ctx.failLabel = '_pfail'; ctx.recordFail = true\n      // A trivia rule must never carry the ambient trivia (it would recursively\n      // skip trivia within itself). Mirrors compileRuleMap's guard.\n      const savedTrivia = ctx.activeTrivia\n      if (rule._meta.isTrivia) ctx.activeTrivia = undefined\n      const body = emit(resolved, ctx, '_pos')\n      ctx.activeTrivia = savedTrivia\n      ctx.indent = savedIndent; ctx.failLabel = savedFail; ctx.recordFail = savedRec\n      pushNamedFnDecl(ctx, fn, body.stmts, body.valueVar, body.endVar)\n    }\n    // Public wrapper: call the named fn, adapt sentinel \u2192 ParseResult.\n    perEntry.push({ key, rule, r: emitNamedFnCall(ctx, fn, '_pos') })\n  }\n\n  // A runtime-parser fallback can't be fused (no source AND no stable identity to\n  // inject). Callback fns, by contrast, ARE fusable \u2014 inline their source when\n  // available (macro), else inject the fn objects via `_env` (runtime).\n  if (ctx.runtimeParsers.length !== 0) return null\n  const mfSrcs = ctx.mapFns.length > 0 && ctx.mapFnSrcs.every((s): s is string => s !== null)\n    ? ctx.mapFnSrcs as string[] : null\n  const buildSrcs = ctx.buildFns.length > 0 && ctx.buildSrcs.every((s): s is string => s !== null)\n    ? ctx.buildSrcs as string[] : null\n\n  // Split named fns: `_r_<Name>` are the composition surface (ruleFns), everything\n  // else (`_ns_pf\u2026` private helpers) is private prelude bundled with the artifact.\n  const ruleFns = new Map<string, string>()\n  const privateFns: string[] = []\n  for (const decl of ctx.namedFnDecls) {\n    const fnName = decl.match(/^function (\\S+?)\\(/)?.[1]\n    const key = fnName ? fnNameToKey.get(fnName) : undefined\n    if (key !== undefined) ruleFns.set(key, decl)\n    else privateFns.push(decl)\n  }\n\n  const mfDecl = ctx.mapFns.length === 0 ? ''\n    : mfSrcs ? `const ${mfRef(ctx)} = [${mfSrcs.join(', ')}]`\n    : `const ${mfRef(ctx)} = _env[${JSON.stringify(nsp(ctx) + 'mf')}]`\n  const buildDecl = ctx.buildFns.length === 0 ? ''\n    : buildSrcs ? `const ${buildRef(ctx)} = [${buildSrcs.join(', ')}]`\n    : `const ${buildRef(ctx)} = _env[${JSON.stringify(nsp(ctx) + 'build')}]`\n  const prelude = [\n    ...ctx.regexDecls,\n    ...ctx.expectedDecls,\n    mfDecl,\n    buildDecl,\n    ...privateFns,\n  ].filter(Boolean)\n\n  const wrappers = new Map<string, string>()\n  for (const { key, rule, r } of perEntry) {\n    wrappers.set(key, publicRuleWrapperSource(rule, [\n      `function(input, _pos, _ctx) {`,\n      `  let pos = _pos`,\n      ...r.stmts,\n      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n      `}`,\n    ].join('\\n')))\n  }\n\n  // Per-rule first-set table for fuse-time dispatch: fusedBody() substitutes each\n  // `/*@FS:rule:codevar@*\u200B/true` placeholder (emitted for rule-ref choice arms)\n  // with the WINNING rule's condition. Resolve each rule to its real first-set;\n  // a rule that can match empty at start gets `any` (\u2192 no guard, always try).\n  const firstSets = new Map<string, FirstSet>()\n  for (const [key, rule] of ruleMap) {\n    let resolved: Combinator<unknown> = rule\n    const d = rule._def\n    if (d.tag === 'lazy') { try { resolved = d.thunk() } catch { resolved = rule } }\n    firstSets.set(key, canMatchEmptyAtStart(resolved) ? { kind: 'any' } : resolved._meta.firstSet)\n  }\n\n  return {\n    ns,\n    keys: perEntry.map(e => e.key),\n    prelude,\n    ruleFns,\n    wrappers,\n    firstSets,\n    deps: ruleDependencies(ruleMap),\n    needsEmptyTl: !!ctx.needsEmptyTl,\n    needsHostReads: !!ctx.needsHostReads,\n    mfFns: mfSrcs ? [] : (ctx.mapFns as ReadonlyArray<(...a: unknown[]) => unknown>),\n    buildFns: buildSrcs ? [] : (ctx.buildFns as ReadonlyArray<(...a: unknown[]) => unknown>),\n  }\n}\n\nfunction buildInlineExpression(\n  ctx: Ctx,\n  r: ER,\n  mapFnSources?: string[],\n  buildSources?: string[],\n): string {\n  const bodyLines = [\n    `  let pos = _pos`,\n    ...r.stmts,\n    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,\n  ]\n\n  const innerFn = [\n    `function(input, _pos, _ctx) {`,\n    ...bodyLines,\n    `}`,\n  ].join('\\n')\n\n  // Declare _mf / _build inline so the emitted _mf[i] / _build[i] references\n  // resolve without runtime closure arrays.\n  const mfDecl = mapFnSources?.length ? `  const _mf = [${mapFnSources.join(', ')}]` : ''\n  const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(', ')}]` : ''\n\n  const emptyTlDecl = ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : ''\n  const hostReadsDecl = ctx.needsHostReads ? `  ${HOST_READS_DECL}` : ''\n  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl || !!hostReadsDecl\n  if (!needsWrapper) return innerFn\n\n  const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : []\n  const hoistedDecls = [\n    emptyTlDecl,\n    hostReadsDecl,\n    ...ctx.regexDecls.map(d => `  ${d}`),\n    ...ctx.expectedDecls.map(d => `  ${d}`),\n    mfDecl,\n    buildDecl,\n    ...namedPrelude.map(l => `  ${l}`),\n    ...ctx.namedFnDecls.flatMap((decl, i) => {\n      const lines = decl.split('\\n').map(l => `  ${l}`)\n      return i > 0 ? ['', ...lines] : lines\n    }),\n  ].filter(Boolean)\n  return [\n    `/* @__PURE__ */ (() => {`,\n    ...hoistedDecls,\n    `  return ${innerFn}`,\n    `})()`,\n  ].join('\\n')\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\nimport { literal } from './literal.ts'\nimport { regex } from './regex.ts'\nimport { sequence } from './sequence.ts'\nimport { choice } from './choice.ts'\nimport { many } from './repeat.ts'\nimport { transform } from './map.ts'\nimport { expect } from './expect.ts'\nimport { any } from './first-set.ts'\nimport { ref } from './ref.ts'\nimport { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'\n\nexport type ScanToOptions = {\n  /** Parsers that match \"container\" regions to skip over intact (balanced parens, strings, comments\u2026) */\n  skip?: Combinator<unknown>[]\n  /**\n   * If true, reaching EOF without finding the sentinel is a success \u2014 returns\n   * everything consumed so far. Default false (fail at EOF).\n   */\n  orEOF?: boolean\n}\n\n/**\n * Consume input up to (but not including) the sentinel, skipping over any\n * \"hole\" patterns in order so their contents are never mistaken for the sentinel.\n *\n * Returns the consumed text as a string. The sentinel is NOT consumed.\n * Fails if the sentinel is never found (unless orEOF is true).\n *\n *   const selector = scanTo(literal('{'), {\n *     skip: [cssComment, stringLit, balanced('(', ')'), balanced('[', ']')],\n *   })\n */\nexport function scanTo(\n  sentinel: Combinator<unknown>,\n  { skip = [], orEOF = false }: ScanToOptions = {},\n): Combinator<string> {\n  const meta: ParserMeta = {\n    firstSet: any(),\n    canMatchNewline: true,\n    isTrivia: false,\n  }\n\n  return {\n    _tag: 'scanTo',\n    _meta: meta,\n    _def: { tag: 'scanTo', sentinel, skip, orEOF },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {\n      let cur = pos\n\n      // Sentinel checks and skip scans must not emit CST children of their own \u2014\n      // scanTo represents the whole scanned span as one leaf. Probe them with a\n      // collector-free context so their internal literal()/regex() don't push.\n      // The error channel IS forwarded, so a committed skipper (e.g. balanced()\n      // whose open delimiter was consumed) can still report an unmatched close.\n      const probeCtx: ParseContext = {\n        trackLines: ctx.trackLines,\n        state: ctx.state,\n        ...(ctx._errors !== undefined ? { _errors: ctx._errors } : {}),\n      }\n\n      // Record the scanned text as a CSTLeaf so buildNode-driven grammars can\n      // see it in children/rawChildren (it would otherwise be lost \u2014 only the\n      // returned value carries it). Skipped when no collector is active.\n      const emit = (end: number) => {\n        if (end > pos && cstCaptureActive(ctx)) {\n          const leaf = { _tag: 'leaf', value: input.slice(pos, end), span: { start: pos, end } }\n          pushCstLeaf(ctx, leaf)\n        }\n      }\n\n      while (cur < input.length) {\n        // Check sentinel \u2014 if it matches here, stop and return consumed text.\n        const s = sentinel.parse(input, cur, probeCtx)\n        if (s.ok) {\n          emit(cur)\n          return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } }\n        }\n\n        // Try each skipper in order; take first that advances.\n        let advanced = false\n        for (const skipper of skip) {\n          const r = skipper.parse(input, cur, probeCtx)\n          if (r.ok && r.span.end > cur) {\n            cur = r.span.end\n            advanced = true\n            break\n          }\n        }\n\n        // Nothing matched \u2014 consume one character and continue.\n        if (!advanced) cur++\n      }\n\n      // Reached EOF without finding sentinel.\n      if (orEOF) {\n        emit(cur)\n        return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } }\n      }\n      const sentDef = sentinel._def\n      const expected = sentDef.tag === 'literal' ? [JSON.stringify(sentDef.value)] : ['sentinel']\n      return { ok: false, expected, span: { start: pos, end: cur } }\n    },\n  }\n}\n\n/**\n * Match a balanced open/close pair, skipping over any holes inside.\n * Returns the full matched text including delimiters.\n *\n *   const parenGroup = balanced('(', ')', { skip: [comment, stringLit] })\n */\nexport function balanced(\n  open: string,\n  close: string,\n  options: ScanToOptions = {},\n): Combinator<string> {\n  // The interior scan must skip NESTED same-delimiter pairs so depth is counted \u2014\n  // otherwise `{{x}}` stops at the first `}`. `self` references this balanced\n  // combinator; added to the interior scan's skip list, a nested `open` is\n  // consumed intact (recursively) before the scan looks for the matching `close`.\n  const self = ref<string>()\n  const skips = options.skip ?? []\n  // PREDICTIVE interior \u2014 no char-walk. The body is `many(choice(self, \u2026skips,\n  // contentRun))`, where contentRun is a regex of chars that are NOT this pair's\n  // delimiters and NOT the start of any skip (so a string/comment arm still wins\n  // its position). At any other character \u2014 a stray close, or a *different* bracket\n  // type \u2014 no arm matches, `many` stops, and the required close (expect()) reports\n  // \"expected <close>\". So an unmatched open, a cross-type close `(a]`, and a stray\n  // close all surface as errors; nothing is silently swallowed. Well-formed input\n  // is consumed identically.\n  const stop = new Set<string>([open, close])\n  let bounded = true\n  for (const sk of skips) {\n    const cs = firstSetClassChars(sk)\n    if (cs === null) { bounded = false; break }\n    for (const ch of cs) stop.add(ch)\n  }\n  const cls = [...stop].map(escapeClassChar).join('')\n  // A run when every skip's start is bounded (fast); else one char at a time so a\n  // skip arm always gets the chance to match at its position.\n  const content = bounded\n    ? regex(new RegExp(`[^${cls}]+`))\n    : regex(new RegExp(`[^${escapeClassChar(open)}${escapeClassChar(close)}]`))\n  const inner = many(choice(self, ...skips, content))\n  const combi = transform(\n    sequence(literal(open), inner, expect(literal(close))),\n    // parts: strings (content/self) or arrays (a sequence-shaped skip) or a\n    // ParseError (recovered close). `c` is the close string or a ParseError.\n    ([o, parts, c]) => o + (parts as unknown[]).map(p => typeof p === 'string' ? p : Array.isArray(p) ? p.join('') : '').join('') + (typeof c === 'string' ? c : ''),\n  )\n  // Provide the callback source so the macro can inline this library-internal\n  // transform (codegen derives map-fn sources from def.fnSrc).\n  if (combi._def.tag === 'transform') {\n    combi._def.fnSrc = '([o, parts, c]) => o + parts.map(p => typeof p === \"string\" ? p : Array.isArray(p) ? p.join(\"\") : \"\").join(\"\") + (typeof c === \"string\" ? c : \"\")'\n  }\n  self.define(combi as Combinator<string>)\n  return combi\n}\n\n/**\n * The characters a combinator can START with, as char-class members \u2014 or null if\n * its first set is unbounded ('any') or too broad to be a delimiter. Used by\n * balanced() to keep a content run from eating the start of a skip.\n */\nfunction firstSetClassChars(c: Combinator<unknown>): string[] | null {\n  const fs = c._meta.firstSet\n  if (fs.kind === 'empty') return []\n  if (fs.kind !== 'ranges') return null\n  const out: string[] = []\n  for (const { lo, hi } of fs.ranges) {\n    if (hi - lo > 8) return null\n    for (let cp = lo; cp <= hi; cp++) out.push(String.fromCodePoint(cp))\n  }\n  return out\n}\n\nfunction escapeClassChar(ch: string): string {\n  return ch.replace(/[\\\\\\]^-]/g, '\\\\$&')\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\n\n/**\n * Runs `combinator` with `ctx.state` set to `extra` for the duration of the parse.\n * The outer user context is restored on exit (lexical scoping).\n *\n *   const functionBody = withCtx({ inFn: true },\n *     sequence(literal('{'), many(statement), literal('}'))\n *   )\n *\n * Read back with guard() or from within a transform's span argument.\n */\nexport function withCtx<U, T>(extra: U, combinator: Combinator<T>): Combinator<T> {\n  const meta: ParserMeta = {\n    firstSet: combinator._meta.firstSet,\n    canMatchNewline: combinator._meta.canMatchNewline,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'withCtx',\n    _meta: meta,\n    _def: { tag: 'withCtx', extra, parser: combinator as Combinator<unknown> },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<T> {\n      return combinator.parse(input, pos, { ...ctx, state: extra })\n    },\n  }\n}\n", "/**\n * Serialize a compiled rule map BACK to a compact combinator-construction source\n * expression \u2014 the \"IR\" a composed grammar carries instead of ~1MB of fully\n * lowered `_r_<Name>` function source. At fuse time the expression is evaluated\n * (with the combinator constructors in scope) to reconstruct the rule map, then\n * re-lowered via `compileLinkable` \u2014 identical behaviour, a fraction of the bytes.\n *\n * The output mirrors how a grammar is WRITTEN, not how it lowers:\n *   - a rule reference (`g.Foo`, a `lazy` carrying `_ruleName`) \u2192 `g[\"Foo\"]`\n *   - a sub-combinator shared by identity (referenced \u22652\u00D7, e.g. a `balanced` const\n *     reused across rules) \u2192 a hoisted `const _s<N> = \u2026`, referenced by name, so it\n *     stays shared through the round trip (and `compileLinkable` re-hoists it)\n *   - a self-referential combinator (`balanced`'s internal `self = ref()`) \u2192 a\n *     `ref()` + `.define()` closure, the same shape the library combinator emits\n *   - `transform`/`node` callbacks \u2192 their captured source (`fnSrc`/`buildSrc`)\n *\n * Returns null if the map can't be faithfully serialized (a callback without\n * source, or an unsupported construct) \u2014 the caller then keeps the lowered source.\n */\nimport type { Combinator, ParserDef } from '../types.ts'\nimport { rules } from '../combinators/parser.ts'\nimport { ref } from '../combinators/ref.ts'\nimport { regex } from '../combinators/regex.ts'\nimport { literal } from '../combinators/literal.ts'\nimport { keywords } from '../combinators/keywords.ts'\nimport { sequence } from '../combinators/sequence.ts'\nimport { choice } from '../combinators/choice.ts'\nimport { many, oneOrMore, optional, sepBy } from '../combinators/repeat.ts'\nimport { not } from '../combinators/not.ts'\nimport { node } from '../combinators/node.ts'\nimport { parser } from '../combinators/grammar.ts'\nimport { scanTo } from '../combinators/scanTo.ts'\nimport { token } from '../combinators/token.ts'\nimport { transform, skip, trivia, label, field } from '../combinators/map.ts'\nimport { expect as expectC } from '../combinators/expect.ts'\nimport { withCtx } from '../combinators/withCtx.ts'\n\ntype Comb = Combinator<unknown>\n\n/** Child combinators of a def, in construction order (mirrors codegen's childrenOf). */\nfunction childrenOf(def: ParserDef): Comb[] {\n  switch (def.tag) {\n    case 'sequence':\n    case 'choice':    return def.parsers\n    case 'many':\n    case 'oneOrMore':\n    case 'optional':\n    case 'transform':\n    case 'trivia':\n    case 'token':\n    case 'label':\n    case 'field':\n    case 'not':\n    case 'node':\n    case 'withCtx':\n    case 'expect':    return [def.parser]\n    case 'grammar':   return def.triviaParser ? [def.parser, def.triviaParser] : [def.parser]\n    case 'sepBy':     return [def.parser, def.separator]\n    case 'skip':      return [def.main, def.skipped]\n    case 'scanTo':    return [def.sentinel, ...def.skip]\n    case 'lazy':\n    case 'literal':\n    case 'regex':\n    case 'keywords':\n    case 'guard':\n    case 'recover':\n    case 'unknown':   return []\n  }\n}\n\nconst ruleNameOf = (c: Comb): string | undefined =>\n  (c as unknown as { _ruleName?: string })._ruleName\n\n/** Resolve a lazy's target, or null if it isn't defined yet (external ref). */\nfunction lazyTarget(c: Comb): Comb | null {\n  if (c._def.tag !== 'lazy') return null\n  try { return c._def.thunk() } catch { return null }\n}\n\nclass Unserializable extends Error {}\n\nexport function serializeRuleMap(\n  ruleMap: ReadonlyArray<readonly [string, Comb]>,\n): string | null {\n  try {\n    return new Serializer(ruleMap).run()\n  } catch (e) {\n    if (e instanceof Unserializable) {\n      if (process.env.PARSEMAN_IR_DEBUG) console.error(`[ir] fallback: ${(e as Error).message}`)\n      return null\n    }\n    throw e\n  }\n}\n\n/** Reconstruct a rule map from serialized IR (the inverse of `serializeRuleMap`) \u2014\n * evaluate the combinator-construction expression with every constructor in scope.\n * Used at fuse time (runtime linker + build-time plugin) to re-lower carried IR. */\nexport function evalRuleMapIR(ir: string): Array<[string, Comb]> {\n  // `_tf`/`_nd` reconstruct a transform/node AND restore its captured callback\n  // source (`_def.fnSrc`/`buildSrc`) so re-lowering inlines it statically. The live\n  // fn is only needed for interpreted mode; a self-contained transform source is\n  // eval'd, a node build (which may reference imported AST classes) is left to its\n  // source only.\n  const _tf = (child: Comb, src: string): Comb => {\n    let fn: (...a: unknown[]) => unknown\n    // eslint-disable-next-line no-eval\n    try { fn = (0, eval)(`(${src})`) } catch { fn = () => { throw new Error('IR transform fn not materialized') } }\n    const t = transform(child as never, fn as never)\n    ;(t._def as { fnSrc?: string }).fnSrc = src\n    return t as Comb\n  }\n  const _nd = (type: string, child: Comb, src: string, opts?: unknown): Comb => {\n    const n = node(type, child as never, undefined, opts as never)\n    ;(n._def as { buildSrc?: string }).buildSrc = src\n    return n as Comb\n  }\n  // `_gch` rebuilds a GATED choice AND restores its `_def.gateSrcs` (parallel to the\n  // arms) \u2014 the gate mirror of `_tf`/`_nd`. Each item is either a plain arm or a\n  // `[gateSource, arm]` tuple: the source is eval'd to the live predicate (interpreted\n  // mode) and recorded as the arm's gateSrcs entry so re-lowering INLINES the gate\n  // statically (keeping the artifact fusible via `emitFusedSource`). A missing/failed\n  // source falls back to a throwing predicate \u2014 the same contract as `_tf`.\n  const _gch = (items: Array<Comb | [string, Comb]>): Comb => {\n    const gateSrcs: (string | null)[] = []\n    const arms = items.map(it => {\n      if (Array.isArray(it)) {\n        const [src, comb] = it\n        gateSrcs.push(src)\n        let gate: (s: unknown) => boolean\n        // eslint-disable-next-line no-eval\n        try { gate = (0, eval)(`(${src})`) } catch { gate = () => { throw new Error('IR gate fn not materialized') } }\n        return { gate, combinator: comb }\n      }\n      gateSrcs.push(null)\n      return it\n    })\n    const c = (choice as (...a: unknown[]) => Comb)(...arms)\n    // `choice` is the authority on gate alignment; `gateSrcs` must line up 1:1 with\n    // the constructed `_def.gates`. They always do on the normal path (both from the\n    // same `items.map`), but assert it so a future change in `choice` that coalesces\n    // or drops arms can't silently ship a mis-aligned gate-source array.\n    const gates = (c._def as { gates?: unknown[] }).gates\n    if (gates && gates.length !== gateSrcs.length) {\n      throw new Error(`_gch: gateSrcs length ${gateSrcs.length} != choice gates length ${gates.length}`)\n    }\n    ;(c._def as { gateSrcs?: (string | null)[] }).gateSrcs = gateSrcs\n    return c\n  }\n  // `_wc` rebuilds a `withCtx` AND restores its `_def.extraSrc` (the source of the\n  // `extra`/state value) \u2014 the withCtx mirror of `_tf`/`_nd`/`_gch`. The source is\n  // eval'd to the live `extra` value (interpreted mode) and recorded on the def so\n  // re-lowering INLINES the state getter statically (`() => (extraSrc)`), keeping the\n  // artifact fusible via `emitFusedSource`. A plain `withCtx(value, inner)` would\n  // leave `extraSrc` unset \u2192 codegen emits a source-less runtime closure (a non-static\n  // callback) \u2192 `emitFusedSource` fails and a downstream `compose()` silently falls\n  // back to a runtime fuse. A missing/failed source falls back to `undefined` state \u2014\n  // the same best-effort contract as `_tf`.\n  const _wc = (src: string, inner: Comb): Comb => {\n    let extra: unknown\n    // eslint-disable-next-line no-eval\n    try { extra = (0, eval)(`(${src})`) } catch { extra = undefined }\n    const w = (withCtx as (e: unknown, c: Comb) => Comb)(extra, inner)\n    ;(w._def as { extraSrc?: string }).extraSrc = src\n    return w\n  }\n  // eslint-disable-next-line no-new-func\n  const fn = new Function(\n    'rules', 'ref', 'regex', 'literal', 'keywords', 'sequence', 'choice',\n    'many', 'oneOrMore', 'optional', 'sepBy', 'not', 'node', 'parser',\n    'scanTo', 'token', 'transform', 'skip', 'trivia', 'label', 'field', 'expect', '_tf', '_nd', '_gch', '_wc',\n    `return (${ir})`,\n  )\n  const map = fn(\n    rules, ref, regex, literal, keywords, sequence, choice,\n    many, oneOrMore, optional, sepBy, not, node, parser,\n    scanTo, token, transform, skip, trivia, label, field, expectC, _tf, _nd, _gch, _wc,\n  ) as Record<string, Comb>\n  return Object.entries(map)\n}\n\nclass Serializer {\n  private counts = new Map<Comb, number>()\n  private selfRef = new Set<Comb>()       // combinators reached by an unnamed lazy pointing back into their own subtree\n  private constName = new Map<Comb, string>()\n  private emitted = new Set<string>()\n  private decls: string[] = []\n  private ruleValues = new Set<Comb>()\n  private ruleMap: ReadonlyArray<readonly [string, Comb]>\n\n  constructor(ruleMap: ReadonlyArray<readonly [string, Comb]>) {\n    this.ruleMap = ruleMap\n    for (const [, c] of ruleMap) this.ruleValues.add(this.body(c))\n  }\n\n  /** A `rules()` map wraps each rule value in a named `lazy` proxy; the real body is\n   * its target (compileLinkable unwraps the same way). A ref INSIDE a body stays a\n   * `g[name]` ref \u2014 only the top-level entry is unwrapped. */\n  private body(c: Comb): Comb {\n    return c._def.tag === 'lazy' && ruleNameOf(c) !== undefined ? (lazyTarget(c) ?? c) : c\n  }\n\n  run(): string {\n    for (const [, c] of this.ruleMap) this.analyze(this.body(c), new Set())\n    // A shared sub-combinator (count \u2265 2) or a self-ref target gets a const, EXCEPT\n    // a top-level rule value (it already lives under its rule name).\n    let n = 0\n    for (const [c, count] of this.counts) {\n      if (this.ruleValues.has(c)) continue\n      if (count >= 2 || this.selfRef.has(c)) this.constName.set(c, `_s${n++}`)\n    }\n    const body = this.ruleMap\n      .map(([name, c]) => `  ${JSON.stringify(name)}: ${this.wrap(this.body(c))}`)\n      .join(',\\n')\n    // Shared consts go INSIDE the factory: they can reference `g[name]` rule refs,\n    // and `g` only exists in the factory scope.\n    if (this.decls.length === 0) return `rules((g) => ({\\n${body}\\n}))`\n    return `rules((g) => {\\n${this.decls.map(d => '  ' + d).join('\\n')}\\n  return ({\\n${body}\\n})\\n})`\n  }\n\n  /** Count identity references and flag self-referential subtrees. `active` is the\n   * set of combinators on the current DFS path (to detect a lazy pointing back). */\n  private analyze(c: Comb, active: Set<Comb>): void {\n    const def = c._def\n    if (def.tag === 'lazy') {\n      if (ruleNameOf(c) !== undefined) return          // named rule ref \u2014 resolved by g[name]\n      const target = lazyTarget(c)\n      if (!target) throw new Unserializable('unresolved unnamed ref')\n      if (active.has(target)) { this.selfRef.add(target); return }  // recursion into an ancestor\n      this.analyze(target, active)                      // inline (unnamed, non-recursive) \u2014 rare\n      return\n    }\n    if (def.tag === 'guard' || def.tag === 'recover' || def.tag === 'unknown') {\n      throw new Unserializable(`unsupported tag ${def.tag}`)\n    }\n    this.counts.set(c, (this.counts.get(c) ?? 0) + 1)\n    if ((this.counts.get(c) ?? 0) > 1) return           // already descended\n    active.add(c)\n    for (const child of childrenOf(def)) this.analyze(child, active)\n    active.delete(c)\n  }\n\n  /** Reference `c`: a const var if it has one (emitting its decl first), else inline.\n   * `selfOf` is the const currently being wrapped in a ref()/define closure \u2014 an\n   * unnamed lazy back into it emits the local ref var instead of recursing. */\n  private ref(c: Comb, selfOf: { comb: Comb; var: string } | null): string {\n    const cn = this.constName.get(c)\n    if (cn) { this.emitDecl(c); return cn }\n    return this.expr(c, selfOf)\n  }\n\n  private emitDecl(c: Comb): void {\n    const name = this.constName.get(c)!\n    if (this.emitted.has(name)) return\n    this.emitted.add(name)                              // mark first (cycle-safe)\n    this.decls.push(`const ${name} = ${this.wrap(c)}`)\n  }\n\n  private selfN = 0\n\n  /** Emit `c`'s own constructor call, wrapping it in a `ref()`+`.define()` closure\n   * if it is self-referential (an unnamed lazy in its subtree points back to it) \u2014\n   * the shape `balanced()` and other recursive library combinators build. */\n  private wrap(c: Comb): string {\n    if (!this.selfRef.has(c)) return this.expr(c, null)\n    const rv = `_rr${this.selfN++}`\n    const bodyExpr = this.expr(c, { comb: c, var: rv })\n    return `(() => { const ${rv} = ref(); const _b = ${bodyExpr}; ${rv}.define(_b); return _b })()`\n  }\n\n  /** Emit the constructor-call source for `c` (never a const shortcut for `c` itself). */\n  private expr(c: Comb, selfOf: { comb: Comb; var: string } | null): string {\n    const def = c._def\n    const kid = (x: Comb) => this.ref(x, selfOf)\n    switch (def.tag) {\n      case 'lazy': {\n        if (ruleNameOf(c) !== undefined) return `g[${JSON.stringify(ruleNameOf(c))}]`\n        const target = lazyTarget(c)!\n        if (selfOf && target === selfOf.comb) return selfOf.var\n        return this.ref(target, selfOf)\n      }\n      case 'literal':\n        return `literal(${JSON.stringify(def.value)}${def.caseInsensitive ? ', { caseInsensitive: true }' : ''})`\n      case 'regex':\n        return `regex(${JSON.stringify(def.source)}, ${JSON.stringify(def.flags)})`\n      case 'keywords':\n        return `keywords(${JSON.stringify(def.words)}, { caseInsensitive: ${def.caseInsensitive}${def.boundary !== undefined ? `, boundary: ${JSON.stringify(def.boundary)}` : ''} })`\n      case 'sequence':\n        return `sequence(${def.parsers.map(kid).join(', ')})`\n      case 'choice': {\n        // Ungated choices stay `choice(a, b, \u2026)` byte-for-byte as before.\n        const gates = def.gates\n        if (gates.every(g => g === null)) return `choice(${def.parsers.map(kid).join(', ')})`\n        // A gated choice round-trips through `_gch`, which rebuilds the choice AND\n        // re-attaches `_def.gateSrcs` from each arm's captured gate SOURCE. Preserving\n        // gateSrcs is load-bearing: on re-lowering, codegen inlines the gate from its\n        // source (a static callback), so the re-lowered artifact stays STATICALLY\n        // FUSIBLE. A plain `choice({ gate: fn, \u2026 })` would rebuild the predicate as a\n        // source-less runtime closure \u2192 a non-static callback \u2192 `emitFusedSource`\n        // (macro static fusion) fails and `compose()` silently falls back to a runtime\n        // fuse. Without a captured source we cannot re-emit the gate \u2192 keep full pieces.\n        const gateSrcs = def.gateSrcs\n        const items = def.parsers.map((p, i) => {\n          if (gates[i] === null) return kid(p)\n          const src = gateSrcs?.[i]\n          if (src == null) throw new Unserializable('choice gate() has no captured source')\n          // `[gateSource, arm]` \u2014 `_gch` evals the source to the live predicate and\n          // records it as the arm's `gateSrcs` entry.\n          return `[${JSON.stringify(src)}, ${kid(p)}]`\n        })\n        return `_gch([${items.join(', ')}])`\n      }\n      case 'many':      return `many(${kid(def.parser)})`\n      case 'oneOrMore': return `oneOrMore(${kid(def.parser)})`\n      case 'optional':  return `optional(${kid(def.parser)})`\n      case 'sepBy':     return `sepBy(${kid(def.parser)}, ${kid(def.separator)})`\n      case 'not':       return `not(${kid(def.parser)})`\n      case 'trivia':    return `trivia(${kid(def.parser)})`\n      case 'token':     return `token(${kid(def.parser)})`\n      case 'label':     return `label(${JSON.stringify(def.label)}, ${kid(def.parser)})`\n      case 'field':     return `field(${JSON.stringify(def.name)}, ${kid(def.parser)})`\n      case 'expect':    return `expect(${kid(def.parser)}${def.label !== undefined ? `, ${JSON.stringify(def.label)}` : ''})`\n      case 'skip':      return `skip(${kid(def.main)}, ${kid(def.skipped)})`\n      case 'scanTo':\n        return `scanTo(${kid(def.sentinel)}, { skip: [${def.skip.map(kid).join(', ')}], orEOF: ${def.orEOF} })`\n      case 'transform': {\n        if (def.fnSrc === undefined) throw new Unserializable('transform without fnSrc')\n        // `_tf` sets `_def.fnSrc` so re-lowering INLINES the callback (a plain\n        // `transform(child, fn)` would leave fnSrc unset \u2192 a non-static runtime\n        // callback that emitFusedSource can't inline).\n        return `_tf(${kid(def.parser)}, ${JSON.stringify(def.fnSrc)})`\n      }\n      case 'node': {\n        if (def.build !== undefined && def.buildSrc === undefined) throw new Unserializable('node build without buildSrc')\n        const opts = def.unwrap || def.collapse\n          ? `, { ${def.unwrap ? 'unwrap: true' : 'collapse: true'} }`\n          : ''\n        // `_nd` sets `_def.buildSrc` (same reason as `_tf`). No build \u2192 plain node.\n        if (def.type === undefined) {\n          if (def.buildSrc !== undefined) throw new Unserializable('inferred node build without inferred type')\n          return opts ? `node(${kid(def.parser)}, undefined${opts})` : `node(${kid(def.parser)})`\n        }\n        if (def.buildSrc !== undefined) return `_nd(${JSON.stringify(def.type)}, ${kid(def.parser)}, ${JSON.stringify(def.buildSrc)}${opts})`\n        return opts ? `node(${JSON.stringify(def.type)}, ${kid(def.parser)}, undefined${opts})` : `node(${JSON.stringify(def.type)}, ${kid(def.parser)})`\n      }\n      case 'grammar': {\n        const trivia = def.clearTrivia ? 'null' : def.triviaParser ? kid(def.triviaParser) : 'undefined'\n        return `parser({ trivia: ${trivia}${def.trackLines ? ', trackLines: true' : ''} }, ${kid(def.parser)})`\n      }\n      case 'withCtx': {\n        // A `withCtx` round-trips through `_wc`, which rebuilds it AND re-attaches\n        // `_def.extraSrc` from the captured `extra` SOURCE. Preserving extraSrc is\n        // load-bearing for the same reason as `_tf`/`_gch`: on re-lowering, codegen\n        // inlines the state getter from source (a static callback), so the re-lowered\n        // artifact stays STATICALLY FUSIBLE. Without a captured source we cannot\n        // re-emit the state statically \u2192 keep full pieces (interpreter fallback).\n        if (def.extraSrc === undefined) throw new Unserializable('withCtx without extraSrc')\n        return `_wc(${JSON.stringify(def.extraSrc)}, ${kid(def.parser)})`\n      }\n      case 'guard':\n      case 'recover':\n      case 'unknown':\n        throw new Unserializable(`unsupported tag ${def.tag}`)\n    }\n  }\n}\n", "/**\n * The linker (RULE_ABI_PLAN \u00A74): fuse independently-compiled linkable artifacts\n * (`compileLinkable`) into ONE closure of parse functions.\n *\n * Every rule is a canonical `_r_<Name>` function and every sibling reference is a\n * call to that name; because fusion drops them all into one scope, those calls\n * are **direct local calls** (0% dispatch). Composition is by name:\n *   - **override** \u2014 later artifact wins per rule name; because references resolve\n *     by name in the shared scope, overriding a rule reroutes EVERY call to it,\n *     including calls inside a base artifact's own rules (open recursion).\n *   - **\u00E0 la carte** \u2014 `pick(artifact, names)` keeps only those rules + their\n *     transitive dependency closure.\n * Private per-artifact state (`_ns_re`, `_ns_pf`, \u2026) is namespaced so it can't\n * collide; the sentinel protocol / `_EMPTY_TL` are shared and\n * emitted once.\n *\n * Uses `new Function` (like `compile()`), so it needs `'unsafe-eval'` under a\n * strict CSP; a build-time variant that emits fused source instead is a later\n * addition. Fusion runs ONCE at parser construction \u2014 parsing is then full speed.\n */\nimport { compileLinkable, firstSetCond, HOST_READS_DECL } from './codegen.ts'\nimport { evalRuleMapIR, serializeRuleMap } from './ir-serialize.ts'\nimport type { LinkablePieces } from './codegen.ts'\nimport type { BuildHost, Combinator, CstCollapsePredicate, FirstSet } from '../types.ts'\n\n/**\n * Compile a `rules()` map to a **linkable artifact** \u2014 the composable, shippable\n * form (RULE_ABI_PLAN \u00A74). A package exports `linkable(rules(g => \u2026))`; consumers\n * import that artifact and `fuse([...])` it \u2014 **no source of the base grammar is\n * ever read**. Under the macro this is precompiled to static pieces; in the\n * interpreter it compiles here at load (like `compile()`).\n *\n * `ns` is a per-artifact namespace; omit it to auto-assign a process-unique one\n * (fine at runtime \u2014 the macro supplies a stable module-derived ns instead).\n */\nlet _nsCounter = 0\nexport function linkable(\n  rulesMap: Record<string, Combinator<unknown>>,\n  ns?: string,\n  trivia?: Combinator<unknown>,\n): LinkablePieces {\n  const pieces = compileLinkable(Object.entries(rulesMap), ns ?? `_lk${_nsCounter++}_`, trivia ? { trivia } : undefined)\n  if (!pieces) throw new Error('linkable(): this grammar cannot be compiled to a linkable artifact (contains a runtime-only parser fallback)')\n  return pieces\n}\n\nexport type CstBuildHostOptions = {\n  /**\n   * Collapse transparent one-child CST wrapper nodes at build time.\n   * - `true`: collapse any one-child node whose rawChildren also has exactly one\n   *   entry, so trivia/error boundaries are not silently dropped.\n   * - `string[]`: collapse only these grammar node types.\n   * - predicate: final policy hook for language-specific public CSTs.\n   */\n  collapse?: boolean | readonly string[] | CstCollapsePredicate\n}\n\nfunction normalizeCstCollapse(collapse: CstBuildHostOptions['collapse']): CstCollapsePredicate | undefined {\n  if (collapse === true) return () => true\n  if (Array.isArray(collapse)) {\n    const types = new Set(collapse)\n    return type => types.has(type)\n  }\n  return typeof collapse === 'function' ? collapse : undefined\n}\n\nfunction buildCstNode(\n  type: string,\n  children: ReadonlyArray<unknown>,\n  _fields: unknown,\n  span: { start: number; end: number },\n  _rawChildren?: ReadonlyArray<unknown>,\n  _triviaLog?: readonly number[],\n  state?: unknown,\n): unknown {\n  // Carry the grammar's `ctx.state` snapshot onto the node (null when unset) \u2014 the\n  // CST contract includes `state` and incremental re-parse replays it on edit.\n  return { _tag: 'node', type, span: { start: span.start, end: span.end }, state: state ?? null, children: [...children] }\n}\n\n/**\n * A generic positioned-CST build host (RULE_ABI_PLAN \u00A77). Pass as `ctx.build`\n * (or `parseDoc(..., { build: cstBuildHost })`) to make ANY linkable/fused\n * grammar produce a uniform CST \u2014 `{ _tag:'node', type, span, state, children }`\n * \u2014 instead of its own eval-AST builders. This is the host the linter and IDE\n * drivers use; the eval driver leaves `ctx.build` unset (grammar's own builders).\n *\n * For public syntax trees, call `cstBuildHost({ collapse })`: Parseman will skip\n * allocating wrapper CST nodes whose single child should stand in for the rule.\n */\nexport function cstBuildHost(options?: CstBuildHostOptions): BuildHost\nexport function cstBuildHost(\n  type: string,\n  children: ReadonlyArray<unknown>,\n  fields: unknown,\n  span: { start: number; end: number },\n  rawChildren?: ReadonlyArray<unknown>,\n  triviaLog?: readonly number[],\n  state?: unknown,\n): unknown\nexport function cstBuildHost(\n  typeOrOptions?: string | CstBuildHostOptions,\n  children?: ReadonlyArray<unknown>,\n  _fields?: unknown,\n  span?: { start: number; end: number },\n  rawChildren?: ReadonlyArray<unknown>,\n  triviaLog?: readonly number[],\n  state?: unknown,\n): unknown {\n  if (typeof typeOrOptions === 'string') {\n    return buildCstNode(typeOrOptions, children ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state)\n  }\n  const collapse = normalizeCstCollapse(typeOrOptions?.collapse)\n  const host: BuildHost = (\n    type: string,\n    children: ReadonlyArray<unknown>,\n    fields: unknown,\n    span: { start: number; end: number },\n    rawChildren: ReadonlyArray<unknown>,\n    triviaLog: readonly number[],\n    state: unknown,\n  ) => buildCstNode(type, children, fields, span, rawChildren, triviaLog, state)\n  if (collapse) host._parsemanCstCollapse = collapse\n  return host\n}\n\nexport type FusedRule = (\n  input: string,\n  pos: number,\n  ctx: Record<string, unknown>,\n) => { ok: boolean; value?: unknown; span: { start: number; end: number } }\n\n/**\n * Restrict a grammar/artifact to `names` plus their transitive rule-dependency\n * closure (\u00E0 la carte selection) \u2014 e.g. Jess taking parts of Less and parts of\n * Sass: `compose([pick(less, ['MixinCall']), pick(sass, ['EachFor']), css])`. A\n * picked rule pulls in every rule name it references, so the result is always\n * self-consistent within the artifact. Accepts a grammar (`rules()` result) or a\n * compiled artifact; returns an artifact for `compose()`.\n */\nexport function pick(\n  grammar: LinkablePieces | Record<string, Combinator<unknown>>,\n  names: string[],\n): LinkablePieces {\n  // A COMPOSED grammar (`compose([...])` result): it has no single rule map \u2014 its rules\n  // live across several carried pieces. Materialize them under the composing trivia it\n  // was built with (so the selection keeps composing-wins trivia), then filter across\n  // pieces to `names` + their transitive dep closure, keeping each rule in the piece\n  // that WINS it (compose override order = last wins). Return a composed-like value so a\n  // downstream `compose([pick(composed, \u2026)])` flattens it the same way.\n  const carried = (grammar as Record<symbol, unknown>)[COMPOSED_PIECES]\n  if (Array.isArray(carried)) {\n    const trivia = (grammar as Record<symbol, unknown>)[COMPOSED_TRIVIA] as Combinator<unknown> | undefined\n    const pieces = (carried as Array<LinkablePieces | IRPiece>).map(pc => materializePiece(pc, trivia))\n    const filtered = pickPieces(pieces, names)\n    // A composed-like value (carries COMPOSED_PIECES, no single rule map). It is only\n    // ever consumed through compose()'s COMPOSED_PIECES branch \u2014 which is checked before\n    // any LinkablePieces field \u2014 so this masquerades as LinkablePieces for the signature.\n    const out: Record<string, unknown> = {}\n    Object.defineProperty(out, COMPOSED_PIECES, { value: filtered, enumerable: false })\n    if (trivia) Object.defineProperty(out, COMPOSED_TRIVIA, { value: trivia, enumerable: false })\n    return out as unknown as LinkablePieces\n  }\n\n  const p = (grammar as LinkablePieces).ruleFns instanceof Map\n    ? (grammar as LinkablePieces)\n    : linkable(grammar as Record<string, Combinator<unknown>>)\n  return pickPieces([p], names)[0] ?? { ...p, keys: [], ruleFns: new Map(), wrappers: new Map(), deps: new Map() }\n}\n\n/** Restrict a set of linkable pieces to `names` + their transitive dep closure,\n * keeping each surviving rule in the piece that WINS it (later piece wins, matching\n * compose override order). Shared by `pick()` (runtime) and the macro's build-time\n * `pick(...)` handling, so \u00E0-la-carte selection is identical on both paths. */\nexport function pickPieces(pieces: LinkablePieces[], names: string[]): LinkablePieces[] {\n  const winner = new Map<string, LinkablePieces>()\n  for (const pc of pieces) for (const k of pc.keys) winner.set(k, pc)\n  // A requested name that isn't in the grammar is a typo \u2014 fail here, not later with a\n  // confusing name-closure error at compose() time.\n  for (const n of names) {\n    if (!winner.has(n)) throw new Error(`pick: rule \"${n}\" is not in this grammar (available: ${[...winner.keys()].join(', ')})`)\n  }\n  const keep = new Set<string>()\n  const visit = (n: string): void => {\n    // A missing winner is an EXTERNAL dep (a base-grammar rule) \u2014 it resolves at\n    // compose() time, not here. Top-level `names` were already validated above.\n    const w = winner.get(n)\n    if (keep.has(n) || !w) return\n    keep.add(n)\n    for (const d of w.deps.get(n) ?? []) visit(d)\n  }\n  for (const n of names) visit(n)\n  const filt = <V>(m: Map<string, V>, pc: LinkablePieces): Map<string, V> =>\n    new Map([...m].filter(([k]) => keep.has(k) && winner.get(k) === pc))\n  return pieces\n    .map(pc => ({ ...pc, keys: pc.keys.filter(k => keep.has(k) && winner.get(k) === pc), ruleFns: filt(pc.ruleFns, pc), wrappers: filt(pc.wrappers, pc), deps: filt(pc.deps, pc) }))\n    .filter(pc => pc.keys.length > 0)\n}\n\n/**\n * Build the fused-closure body (shared by the runtime `fuseRules` and the\n * build-time `emitFusedSource`). Returns the closure body (which reads `_env`\n * for any non-inlined callbacks) and the `_env` to bind. In macro mode callbacks\n * are inlined from source, so `_env` is empty and the body is fully static.\n */\nfunction fusedBody(pieces: LinkablePieces[]): { body: string; env: Record<string, unknown> } {\n  // Winner per rule name \u2014 later pieces override earlier ones.\n  const winner = new Map<string, LinkablePieces>()\n  for (const p of pieces) for (const k of p.keys) winner.set(k, p)\n\n  // Name-closure check: every referenced rule must resolve in the fused set.\n  for (const [k, p] of winner) {\n    for (const d of p.deps.get(k) ?? []) {\n      if (!winner.has(d)) throw new Error(`compose: rule \"${k}\" references missing rule \"${d}\"`)\n    }\n  }\n\n  const contributing = new Set(winner.values())\n  const contributingPieces = [...contributing]\n  const needsEmptyTl = contributingPieces.some(p => p.needsEmptyTl)\n  const needsHostReads = contributingPieces.some(p => p.needsHostReads)\n\n  const lines: string[] = [\n    // Shared sentinel protocol (must match NAMED_FN_FAIL / NAMED_FN_END in codegen).\n    'const _pfFail = {}',\n    'let _pfEnd',\n    ...(needsEmptyTl ? ['const _EMPTY_TL = Object.freeze([])'] : []),\n    ...(needsHostReads ? [HOST_READS_DECL] : []),\n    // Each contributing artifact's namespaced private prelude (regexes, _pf, \u2026).\n    ...new Set(contributingPieces.flatMap(p => p.prelude)),\n    // The winning `_r_<Name>` function for each rule (one per name \u2192 no redeclare).\n    ...[...winner].map(([k, p]) => p.ruleFns.get(k)!),\n  ]\n  const wrapperEntries = [...winner].map(([k, p]) => `${JSON.stringify(k)}: ${p.wrappers.get(k)!}`)\n  const rawBody = [...lines, 'return {', wrapperEntries.join(',\\n'), '}'].join('\\n')\n\n  // Fuse-time first-set dispatch: a rule-ref choice arm was emitted (in linkable\n  // mode) as `/*@FS:rule:codevar@*\u200B/true`. Resolve it now against the WINNING\n  // rule's first-set \u2014 sound under override, since we use the final rule, not the\n  // one visible when the referencing rule was compiled. Unknown / `any` /\n  // empty-matching rule \u2192 leave `true` (always try the arm; correctness over\n  // pruning). Non-composed callers with no `firstSets` table also fall through.\n  const finalFS = new Map<string, FirstSet>()\n  for (const [k, p] of winner) { const fs = p.firstSets?.get(k); if (fs) finalFS.set(k, fs) }\n  const body = rawBody.replace(\n    // Rule name + code-point var are both JS identifiers (rule names are validated\n    // at compile time \u2014 see assertRuleName in codegen), so an identifier class\n    // matches every well-formed placeholder.\n    /\\/\\*@FS:([A-Za-z0-9_$]+):([A-Za-z0-9_$]+)@\\*\\/true/g,\n    (_m, name: string, codevar: string) => {\n      const fs = finalFS.get(name)\n      if (!fs || fs.kind === 'any' || fs.kind === 'empty') return 'true'\n      return `(${firstSetCond(codevar, fs)})`\n    },\n  )\n\n  // Non-inlined callbacks (runtime compile() mode), keyed `<ns>mf` / `<ns>build`.\n  const env: Record<string, unknown> = {}\n  for (const p of contributingPieces) {\n    if (p.mfFns.length) env[`${p.ns}mf`] = p.mfFns\n    if (p.buildFns.length) env[`${p.ns}build`] = p.buildFns\n  }\n  return { body, env }\n}\n\n/** Fuse at RUNTIME (via `new Function`) \u2014 used by `compose()` when not compiled\n * by the macro (like `compile()`). The macro path uses `emitFusedSource` instead. */\nexport function fuseRules(pieces: LinkablePieces[]): Record<string, FusedRule> {\n  const { body, env } = fusedBody(pieces)\n  // eslint-disable-next-line no-new-func\n  return new Function('_env', body)(env) as Record<string, FusedRule>\n}\n\n/**\n * Fuse at BUILD time \u2014 emit the fused closure as a self-contained SOURCE\n * expression (`(() => { \u2026 })()`), with **no `new Function`**. This is what the\n * macro splices in for a `compose([...])` call, so macro output stays eval-free.\n * Requires every callback to be inlined from source (macro mode); throws if any\n * artifact carries runtime-only callback functions.\n */\nexport function emitFusedSource(pieces: LinkablePieces[]): string {\n  const { body, env } = fusedBody(pieces)\n  if (Object.keys(env).length > 0) {\n    throw new Error('emitFusedSource: artifact carries non-static callbacks (runtime-only); cannot emit static source')\n  }\n  return `/* @__PURE__ */ (() => {\\n${body}\\n})()`\n}\n\n/**\n * Compose grammars/artifacts into a runnable parser map \u2014 the ONLY public\n * composition entry point. `compose([base, ext, \u2026])`: later entries override\n * earlier ones by rule name, and because fusion re-binds every reference in one\n * shared scope, an override reroutes the base's OWN calls too (open recursion).\n *\n * Each entry may be a **grammar** (a `rules()` result \u2014 a map of combinators,\n * linkable-ified here) OR an already-compiled **linkable artifact** (what the\n * macro emits and a package ships). So a package needs no opt-in wrapper to be\n * composable \u2014 `compose([importedGrammar, myRules])` just works.\n *\n * The macro compiles `compose([...])` to STATIC fused source (no `new Function`).\n * Called at runtime (no macro, like `compile()`) it fuses via `new Function`.\n */\n/** A composed parser carries its flattened source pieces (non-enumerable) so it\n * can be composed AGAIN \u2014 `compose([lessGrammar, delta])` where `lessGrammar` is\n * itself a `compose([...])` result. */\nconst COMPOSED_PIECES = Symbol.for('parseman.composedPieces')\n\n/** The composing (outermost) trivia a runtime `compose()` applied \u2014 stored so a\n * later `pick(composedGrammar, \u2026)` can re-lower the selected rules under the SAME\n * trivia (composing-wins survives \u00E0-la-carte selection). The carried IR pieces hold\n * no trivia of their own, so it must be remembered separately. Not serialized by the\n * macro (which delegates pick to the runtime linker). */\nconst COMPOSED_TRIVIA = Symbol.for('parseman.composedTrivia')\n\n/** The compact IR form a grammar carries instead of its lowered rule source: the\n * combinator-construction expression, re-lowered here at fuse time. */\nexport type IRPiece = { ns: string; ir: string }\n\nfunction isIRPiece(p: unknown): p is IRPiece {\n  return !!p && typeof p === 'object'\n    && typeof (p as IRPiece).ir === 'string' && typeof (p as IRPiece).ns === 'string'\n    && !('ruleFns' in (p as object))\n}\n\n/** Materialize a carried item to full `LinkablePieces`: an IR piece is evaluated\n * back to a rule map and re-lowered; a full piece passes through. */\nexport function materializePiece(p: LinkablePieces | IRPiece, trivia?: Combinator<unknown>): LinkablePieces {\n  if (!isIRPiece(p)) return p\n  const pieces = compileLinkable(evalRuleMapIR(p.ir), p.ns, trivia ? { trivia } : undefined)\n  if (!pieces) throw new Error(`compose: carried IR for ns \"${p.ns}\" could not be re-lowered`)\n  return pieces\n}\n\n/** Flatten one `compose()` item to its pieces: a prior composed result \u2192 its\n * carried list; an artifact \u2192 itself; a grammar (`rules()` map) \u2192 linkable-ified. */\nfunction nextComposeNs(used: Set<string>): string {\n  let ns: string\n  do { ns = `_lk${_nsCounter++}_` } while (used.has(ns))\n  used.add(ns)\n  return ns\n}\n\n/** Flatten one `compose()` item to its RE-LOWERABLE carried items \u2014 the form stored\n * on the composed result so it can be composed AGAIN under a NEW composing trivia.\n * A grammar (`rules()` map) is carried as compact IR (`{ns, ir}`), NOT baked source,\n * so a later `compose([thisResult, delta])` re-lowers it with the delta's trivia\n * (multi-level composing-wins). A prior composed result contributes its OWN carried\n * items (already IR); a pre-compiled artifact has no source, so it stays baked. */\nfunction itemCarried(\n  item: LinkablePieces | Record<string, unknown>,\n  used: Set<string>,\n  trivia?: Combinator<unknown>,\n): Array<LinkablePieces | IRPiece> {\n  const carried = (item as Record<symbol, unknown>)[COMPOSED_PIECES]\n  // A prior composed result (runtime or macro-compiled): its carried list is already\n  // re-lowerable (IR pieces, plus any pre-compiled artifacts). Pass it through so THIS\n  // compose re-lowers it under its own composing trivia. Reserve its namespaces so a\n  // sibling grammar map can't collide with them.\n  if (Array.isArray(carried)) {\n    const items = carried as Array<LinkablePieces | IRPiece>\n    for (const p of items) used.add(p.ns)\n    return items\n  }\n  // A pre-compiled artifact (`linkable()`/`pick()`): no source to re-lower \u2014 its trivia\n  // was baked when it was compiled. Keep it as-is.\n  if ((item as LinkablePieces).ruleFns instanceof Map) {\n    const p = item as LinkablePieces\n    used.add(p.ns)\n    return [p]\n  }\n  // A grammar (`rules()` map): carry it as compact IR so a later compose re-lowers it\n  // under ITS trivia. Unserializable \u2192 bake now with this compose's trivia (can't\n  // re-lower later; acceptable fallback, mirrors the macro's full-pieces fallback).\n  const map = item as Record<string, Combinator<unknown>>\n  const ns = nextComposeNs(used)\n  // Drop EXTERNAL entries first (same filter as compileLinkable): a `rules()` cache\n  // also holds every ACCESSED-but-undefined `g.X` as an unresolved-lazy entry. Left in,\n  // serializeRuleMap would emit `X: g[\"X\"]` \u2014 a self-referential rule that shadows the\n  // sibling artifact defining X and recurses forever. They resolve by name at fuse time.\n  const entries = Object.entries(map).filter(([, val]) => {\n    const d = val._def\n    if (d.tag !== 'lazy') return true\n    try { d.thunk(); return true } catch { return false }\n  })\n  const ir = serializeRuleMap(entries)\n  return ir ? [{ ns, ir }] : [linkable(map, ns, trivia)]\n}\n\n/** The composed grammar's ambient trivia = the LAST composed item that declares a\n * grammar-level trivia (via `rules({ trivia }, \u2026)`, which tags `grammarTrivia` on its\n * rules). Outermost wins: the composing grammar's trivia applies to every fused rule,\n * including those inherited from a base \u2014 so e.g. an SCSS `rw` (which extends Less's)\n * governs the inherited Less/CSS rules too. `parser`/`noTrivia` still override locally. */\nfunction composingTriviaOf(items: Array<LinkablePieces | Record<string, unknown>>): Combinator<unknown> | undefined {\n  for (let i = items.length - 1; i >= 0; i--) {\n    const item = items[i] as Record<string, unknown> | undefined\n    if (!item || (item as LinkablePieces).ruleFns instanceof Map || (item as Record<symbol, unknown>)[COMPOSED_PIECES]) continue\n    for (const v of Object.values(item)) {\n      const t = (v as Combinator<unknown> | undefined)?._meta?.grammarTrivia\n      if (t) return t\n    }\n  }\n  return undefined\n}\n\nexport function compose(\n  items: Array<LinkablePieces | Record<string, unknown>>,\n): Record<string, FusedRule> {\n  const used = new Set<string>()\n  // The composed grammar's ambient trivia comes from the composing grammar itself \u2014\n  // whatever the last piece declared via rules({ trivia }, \u2026). No separate option:\n  // the trivia rides with the grammar that declared it.\n  const trivia = composingTriviaOf(items)\n  // Carried items are RE-LOWERABLE (IR); materialize them ONCE with this compose's\n  // trivia for the now-fuse, but STORE the un-materialized carried list so a later\n  // compose can re-lower it under a different trivia (multi-level composing-wins).\n  const carried = items.flatMap(item => itemCarried(item, used, trivia))\n  const pieces = carried.map(p => materializePiece(p, trivia))\n  const map = fuseRules(pieces)\n  Object.defineProperty(map, COMPOSED_PIECES, { value: carried, enumerable: false })\n  if (trivia) Object.defineProperty(map, COMPOSED_TRIVIA, { value: trivia, enumerable: false })\n  return map\n}\n", "import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'\n\n/**\n * Zero-width assertion: succeeds (consuming nothing) only when `predicate`\n * returns true for `ctx.state`. Fails otherwise.\n *\n * Intended for use inside sequence() to gate subsequent parsing on runtime\n * context set with withCtx().\n *\n *   const returnStmt = sequence(\n *     guard(ctx => (ctx as { inFn: boolean }).inFn),\n *     literal('return'), optional(expr)\n *   )\n */\nexport function guard(predicate: (state: unknown) => boolean): Combinator<null> {\n  const meta: ParserMeta = {\n    firstSet: { kind: 'any' },\n    canMatchNewline: false,\n    isTrivia: false,\n  }\n  return {\n    _tag: 'guard',\n    _meta: meta,\n    _def: { tag: 'guard', predicate },\n    parse(_input: string, pos: number, ctx: ParseContext): ParseResult<null> {\n      if (predicate(ctx.state))\n        return { ok: true, value: null, span: { start: pos, end: pos } }\n      return { ok: false, expected: ['guard'], span: { start: pos, end: pos } }\n    },\n  }\n}\n", "import type { Combinator, ParseFail, ParseContext, ParseResult } from '../types.ts'\nimport { REC } from '../recovery/scan.ts'\n\n/** Anything `completionsAt` can probe: an interpreter combinator OR a `compile()`d\n * grammar. A grammar compiled with `{ recovery: true }` records the probe on its fast\n * path, so completions work on the published compiled artifact \u2014 no interpreter needed. */\ntype CompletionsTarget =\n  | Combinator<unknown>\n  | { parseWithContext(input: string, ctx: ParseContext, pos?: number): ParseResult<unknown> }\n\n/**\n * Returns the set of expected tokens at the given cursor offset.\n * Useful for implementing IDE completions.\n *\n * Runs the parser on input truncated at `offset` with a probe that tracks the\n * highest-position failure seen, even when sepBy/many backtrack past the cursor.\n * Returns the expected tokens from that deepest failure.\n *\n * Works on the interpreter combinator OR a `compile(g, { recovery: true })` grammar\n * (the probe is recorded on the compiled fast path). Returns an empty array when the\n * input up to `offset` parses completely with no failures at or before the cursor.\n *\n * The returned strings use the same labels as ParseFail.expected:\n * quoted literals like `\"\\\"{\\\"\"` and regex patterns like `\"/[0-9]+/\"`.\n */\nexport function completionsAt(\n  target: CompletionsTarget,\n  input: string,\n  offset: number,\n  options: { tolerant?: boolean } = {},\n): string[] {\n  const probe: { offset: number; best: ParseFail | null } = { offset, best: null }\n  // In tolerant mode, list recovery keeps the enclosing node parsing past a bad\n  // element so the failure at the cursor is actually recorded \u2014 the completion set\n  // is otherwise empty when a permissive top rule \"succeeds\" with an unconsumed tail.\n  const ctx: ParseContext = { trackLines: false, _probe: probe, ...(options.tolerant ? { _tolerant: true, _rec: REC } : {}) }\n  const sliced = input.slice(0, offset)\n  const result = 'parseWithContext' in target\n    ? target.parseWithContext(sliced, ctx, 0)\n    : target.parse(sliced, 0, ctx)\n\n  // If the parser consumed everything up to offset successfully, there is nothing\n  // to complete \u2014 the input is already valid at this position. In tolerant mode the\n  // parse \"succeeds\" (list recovery swallowed the incomplete element at the cursor),\n  // so the meaningful expectation lives in the deepest failure the probe recorded\n  // while recovering: return that instead of an empty set.\n  if (result.ok) return options.tolerant ? (probe.best?.expected ?? []) : []\n\n  // Use whichever failure (probe or top-level) sits at the deeper position.\n  const best = deeperFail(probe.best, result)\n  return best?.expected ?? []\n}\n\nfunction deeperFail(a: ParseFail | null, b: ParseFail | null): ParseFail | null {\n  if (!a) return b\n  if (!b) return a\n  return a.span.start >= b.span.start ? a : b\n}\n", "/**\n * Relative span model for incremental edits.\n *\n * Absolute source offsets are simple but fragile: an insertion at offset `at`\n * shifts EVERY downstream offset, so a whole-tree renumber is O(nodes-after-edit).\n * Storing each node's span RELATIVE to its parent's start makes edits local: an\n * insertion inside child k of a node only changes\n *   (a) child k's relative end,\n *   (b) the relative start of siblings after k,\n * and leaves the *children* of those shifted siblings untouched \u2014 they move with\n * their parent for free. So the mutation count is O(depth + trailing siblings),\n * not O(all following nodes), and every unaffected subtree is shared by identity.\n *\n * An absolute view is recovered on query by accumulating the parent base as you\n * descend (the `absolutize` / `absoluteSpanAt` cursor) \u2014 one source of truth,\n * two manifestations.\n */\n\n/** A node with an ABSOLUTE source span and ordered children. */\nexport type AbsNode = {\n  readonly start: number\n  readonly end: number\n  readonly children: readonly AbsNode[]\n}\n\n/** A node whose `start`/`end` are RELATIVE to its parent's start (root base = 0). */\nexport type RelNode = {\n  readonly start: number\n  readonly end: number\n  readonly children: readonly RelNode[]\n}\n\n/** Convert an absolute tree to parent-relative spans. */\nexport function relativize(node: AbsNode, parentBase = 0): RelNode {\n  return {\n    start: node.start - parentBase,\n    end: node.end - parentBase,\n    children: node.children.map((c) => relativize(c, node.start)),\n  }\n}\n\n/** Reconstruct absolute spans from a relative tree. Inverse of `relativize`. */\nexport function absolutize(node: RelNode, parentBase = 0): AbsNode {\n  const start = parentBase + node.start\n  return {\n    start,\n    end: parentBase + node.end,\n    children: node.children.map((c) => absolutize(c, start)),\n  }\n}\n\n/**\n * Absolute span of the node at `path` (child indices from the root), accumulating\n * the base as it descends \u2014 O(path length), no full absolutize. The relative-form\n * cursor: query any node's absolute position without materializing the whole tree.\n */\nexport function absoluteSpanAt(root: RelNode, path: readonly number[]): { start: number; end: number } {\n  let base = 0\n  let node = root\n  for (const idx of path) {\n    base += node.start\n    const child = node.children[idx]\n    if (!child) throw new RangeError(`absoluteSpanAt: no child ${idx} on path ${path.join('.')}`)\n    node = child\n  }\n  return { start: base + node.start, end: base + node.end }\n}\n\n// ---------------------------------------------------------------------------\n// CST-shaped projection (parseDoc incremental trees)\n//\n// The bare Abs/RelNode helpers above are the reference model. The functions\n// below apply the same relative-span algebra to real CST children \u2014 nodes,\n// leaves, and error nodes \u2014 where the span is a nested `{ start, end }` and\n// children are heterogeneous (leaves carry a span but no `children`). Trivia\n// never appears in structural `children`, so every child has a span.\n// ---------------------------------------------------------------------------\n\n/**\n * A CST child as far as span projection cares: a nested span + optional children.\n * `children` is typed loosely (`unknown[]`) so the real heterogeneous CST unions\n * (nodes, leaves, error nodes \u2014 a leaf has no `children`) satisfy it directly.\n */\ntype Spanned = {\n  readonly span: { readonly start: number; readonly end: number }\n  readonly children?: readonly unknown[]\n}\n\n/**\n * Rewrite a CST subtree's spans to be RELATIVE to `parentBase` (the absolute\n * start of the node's parent; root base = 0). Each child's own children are\n * relativized against *this* node's absolute start. Preserves every other field\n * (`_tag`, `type`, `state`, leaf `value`, \u2026) by shallow spread.\n */\nexport function relativizeCST<T extends Spanned>(node: T, parentBase = 0): T {\n  const span = { start: node.span.start - parentBase, end: node.span.end - parentBase }\n  if (node.children) {\n    const base = node.span.start\n    return { ...node, span, children: node.children.map((c) => relativizeCST(c as Spanned, base)) } as T\n  }\n  return { ...node, span } as T\n}\n\n/** Reconstruct absolute CST spans from a relative subtree. Inverse of `relativizeCST`. */\nexport function absolutizeCST<T extends Spanned>(node: T, parentBase = 0): T {\n  const start = parentBase + node.span.start\n  const span = { start, end: parentBase + node.span.end }\n  if (node.children) {\n    return { ...node, span, children: node.children.map((c) => absolutizeCST(c as Spanned, start)) } as T\n  }\n  return { ...node, span } as T\n}\n\n/**\n * Absolute span of the CST node at `path` (child indices from the root),\n * accumulating the base as it descends \u2014 O(path length), no full absolutize.\n * The relative-form cursor for a positioned CST: query one node's absolute\n * position without materializing the whole tree.\n */\nexport function absoluteSpanCST(root: Spanned, path: readonly number[]): { start: number; end: number } {\n  let base = 0\n  let node: Spanned = root\n  for (const idx of path) {\n    base += node.span.start\n    const child = node.children?.[idx] as Spanned | undefined\n    if (!child) throw new RangeError(`absoluteSpanCST: no child ${idx} on path ${path.join('.')}`)\n    node = child\n  }\n  return { start: base + node.span.start, end: base + node.span.end }\n}\n\n/** Naive absolute reshift (baseline): shift every offset >= `at` by `delta`. */\nexport function shiftAbsolute(node: AbsNode, at: number, delta: number): AbsNode {\n  const s = node.start >= at ? node.start + delta : node.start\n  const e = node.end >= at ? node.end + delta : node.end\n  return {\n    start: s,\n    end: e,\n    children: node.children.map((c) => shiftAbsolute(c, at, delta)),\n  }\n}\n\n/**\n * Apply an edit of `delta` characters at absolute offset `at` to a RELATIVE tree.\n * Returns a new relative tree; every subtree that ends at/before `at` (in absolute\n * terms) is returned by IDENTITY (unchanged), so the result structurally shares\n * all unaffected subtrees with the input.\n *\n * `stats.allocated` counts nodes that had to be re-created \u2014 the incremental cost.\n */\nexport function applyEdit(\n  root: RelNode,\n  at: number,\n  delta: number,\n  stats?: { allocated: number },\n): RelNode {\n  // The root has no parent; its base never shifts (base 0).\n  return editNode(root, at, delta, 0, 0, stats)\n}\n\nfunction editNode(\n  node: RelNode,\n  at: number,\n  delta: number,\n  parentBase: number,\n  parentShift: number, // how much this node's parent base moved (0 or delta)\n  stats?: { allocated: number },\n): RelNode {\n  const absStart = parentBase + node.start\n  const absEnd = parentBase + node.end\n\n  // Strictly before the edit \u2192 unchanged (its parent base is also unshifted).\n  // Uses `< at` (not `<=`) to match the shift convention: offsets `>= at` move,\n  // so a node ending exactly at `at` grows and must be rewritten.\n  if (absEnd < at) return node\n\n  // Fully after the edit AND the parent moved by `delta` too \u2192 this node moves as\n  // one unit with its parent, so its parent-relative offsets are identical. Share\n  // the ENTIRE subtree by identity \u2014 this is the O(depth) locality win.\n  const startShifts = absStart >= at\n  if (startShifts && parentShift === delta) return node\n\n  if (stats) stats.allocated++\n\n  const newAbsStart = startShifts ? absStart + delta : absStart\n  const newAbsEnd = absEnd + delta // absEnd > at here (fully-before returned above)\n  const newParentBase = parentBase + parentShift\n  const newStart = newAbsStart - newParentBase\n  const newEnd = newAbsEnd - newParentBase\n\n  // Children are relative to this node's absolute start. Our own shift (0 or delta)\n  // becomes their parentShift.\n  const ownShift = newAbsStart - absStart\n  let changed = false\n  const newChildren: RelNode[] = []\n  for (const c of node.children) {\n    const nc = editNode(c, at, delta, absStart, ownShift, stats)\n    if (nc !== c) changed = true\n    newChildren.push(nc)\n  }\n\n  return {\n    start: newStart,\n    end: newEnd,\n    children: changed ? newChildren : node.children,\n  }\n}\n", "/**\n * Incremental parse document \u2014 incremental re-parse over a rules() registry.\n */\nimport type { Combinator, ParseContext, ParseError, ParseResult, ParserDef, Span } from '../types.ts'\nimport type { NodeLike, CSTLeaf, CSTError } from '../cst/types.ts'\nimport { relativizeCST, absoluteSpanCST } from '../cst/relative-spans.ts'\nimport { REC } from '../recovery/scan.ts'\n\n/**\n * Build the parse ctx for a (re)parse. In `tolerant` mode the same recovery bundle\n * the interpreter/`run` use is installed (`_tolerant` + `_rec`), so a broken edit\n * keeps producing a tree (with recovered `ParseError`s embedded) instead of\n * collapsing to `null`. Strict mode is byte-identical to before. Every reparse site\n * \u2014 root, localized rule reparse, list-splice middle, and the soundness probes \u2014\n * threads the SAME flag, so a probe's tolerance matches the parse it is checking\n * (a mismatch would spuriously diverge and forgo reuse, never miscompare).\n */\nfunction mkCtx(state: unknown, build: ParseContext['build'], tolerant: boolean): ParseContext {\n  return tolerant\n    ? { trackLines: false, state, build, _tolerant: true, _rec: REC, _errors: [] }\n    : { trackLines: false, state, build }\n}\n\n/** A single compiled (or interpreted) rule: parse from `pos`, producing node `N`. */\nexport type RuleFn<N> = (input: string, pos: number, ctx: ParseContext) => ParseResult<N>\n\n/**\n * Rule name \u2192 parser. Each entry is either a bare parse function or a\n * `Combinator` (what `rules()` returns). Passing the `rules()` combinators\n * directly lets `.edit()` inspect the grammar \u2014 required for **sound** structural\n * list-reuse (see `structuralReuse`): only a rule the grammar proves is a genuine\n * repetition is ever spliced. A bare-function registry still parses correctly; it\n * just can't be structurally reused (the splice is skipped, never guessed).\n */\nexport type Registry<N> = Record<string, RuleFn<N> | Combinator<N>>\n\n/** Normalize a registry entry to a callable parse function. */\nfunction asRuleFn<N>(entry: RuleFn<N> | Combinator<N>): RuleFn<N> {\n  return typeof entry === 'function' ? entry : (input, pos, ctx) => entry.parse(input, pos, ctx)\n}\n\n/** The combinator def behind a registry entry, if it carries one (bare functions don't). */\nfunction defOf(entry: unknown): ParserDef | undefined {\n  return typeof entry === 'object' && entry !== null && '_def' in entry\n    ? (entry as { _def: ParserDef })._def\n    : undefined\n}\n\n/**\n * Does this rule's grammar produce its element children via a genuine, unbounded\n * **repetition** (`sepBy` / `many` / `oneOrMore`) \u2014 as opposed to a fixed-arity\n * sequence of same-typed tokens (e.g. `Triple = Num ',' Num ',' Num`)? Only the\n * former is sound to structurally reuse: a full reparse accepts any element count,\n * so splicing one in or out matches it; a fixed-arity rule would not. We walk the\n * def, transparently unwrapping semantic wrappers (`node`, `transform`, \u2026) and\n * looking through a top-level `sequence` / `optional` (the `[ (sepBy)? ]` shape),\n * and return true iff a repetition combinator is reachable that way. Structurally\n * indistinguishable-from-the-CST cases (fixed sequences) return false and fall\n * back to a full, correct reparse. This is what makes `structuralReuse` sound\n * rather than a promise the caller has to keep.\n */\nfunction producesRepetition(def: ParserDef | undefined, depth = 0): boolean {\n  if (!def || depth > 24) return false\n  const d = def as ParserDef & Record<string, unknown>\n  switch (d.tag) {\n    case 'sepBy':\n    case 'many':\n    case 'oneOrMore':\n      return true\n    // Rule entries and `ref`s wrap their body in a `lazy` thunk \u2014 resolve it. The\n    // `depth` cap bounds any self-referential cycle (a repetition, if present, is\n    // found shallowly before recursion goes deep).\n    case 'lazy': {\n      const thunk = d.thunk as (() => { _def?: ParserDef }) | undefined\n      let inner: { _def?: ParserDef } | undefined\n      try { inner = typeof thunk === 'function' ? thunk() : undefined } catch { return false }\n      return producesRepetition(inner?._def, depth + 1)\n    }\n    // Transparent wrappers \u2014 look through to the inner parser.\n    case 'node':\n    case 'transform':\n    case 'token':\n    case 'label':\n    case 'field':\n    case 'expect':\n    case 'withCtx':\n    case 'grammar':\n    case 'optional':\n      return producesRepetition(defOf(d.parser), depth + 1)\n    case 'skip':\n      return producesRepetition(defOf(d.main), depth + 1)\n    // A bracketed/anchored list is a sequence whose element run is a repetition.\n    case 'sequence':\n      return (d.parsers as unknown[]).some(p => producesRepetition(defOf(p), depth + 1))\n    default:\n      return false\n  }\n}\n\nexport type ParseDocOptions<N extends NodeLike> = {\n  /** Initial grammar state threaded into ctx.state for the root parse. */\n  state?: unknown\n  /**\n   * Reconstruct a parent node with one child replaced (used when grafting a\n   * re-parsed subtree into its ancestors). Defaults to a shallow spread, which\n   * works for plain-object nodes; class-instance ASTs should supply their own.\n   */\n  rebuild?: (node: N, children: ReadonlyArray<N | CSTLeaf | CSTError>) => N\n  /**\n   * Mode host for a linkable/fused grammar (RULE_ABI_PLAN \u00A77): threaded into\n   * `ctx.build` on every (re)parse so `node()` rules build a positioned CST /\n   * language-service tree instead of their own eval-AST. Unset \u2192 the grammar's\n   * own builders (eval mode).\n   */\n  build?: ParseContext['build']\n  /**\n   * Enable structural list-reuse: on a length-changing *structural* edit (adding\n   * or removing a whole element in a collection) that would otherwise force a full\n   * reparse, reparse only the disturbed span and reuse the collection's untouched\n   * tail elements by identity \u2014 turning an insert near the top of a large list from\n   * O(list) into O(edit + trailing siblings).\n   *\n   * OFF by default because it is sound only when a rule whose CST children form a\n   * homogeneous, separator-delimited element list is a genuine REPETITION\n   * (`many` / `sepBy` / `oneOrMore`), not a fixed-arity sequence of same-typed\n   * tokens (e.g. `Triple = Num ',' Num ',' Num`) \u2014 the two are structurally\n   * indistinguishable without the grammar, and splicing the latter would accept an\n   * element count it shouldn't. Turn it on when your list rules are true\n   * repetitions (the common case: JSON arrays/objects, CSS value lists, argument\n   * lists). Every splice is still guarded (exact tiling + lookahead probe +\n   * stateless-tail check) and falls back to a full, correct reparse when unproven;\n   * the flag only authorises *attempting* the reuse.\n   */\n  structuralReuse?: boolean\n  /**\n   * Parse tolerantly: `many`/`sepBy`/`oneOrMore` recover from a failed element\n   * (skip to an inferred sync point, embed a `ParseError` over the skipped span),\n   * so a broken edit keeps producing a tree instead of collapsing to `null` \u2014 the\n   * editor-backend path. Off by default (strict, byte-identical). Recovery is a cold\n   * path: well-formed input never triggers it. Every reparse the doc does \u2014 root,\n   * localized rule, and list-splice \u2014 inherits this flag, and the reuse-soundness\n   * probes run at the same tolerance so incremental reuse stays valid under recovery\n   * (a scan that would cross a splice boundary just falls back to a full reparse).\n   */\n  tolerant?: boolean\n  /**\n   * The grammar's trivia rule, used ONLY to compute `unconsumedFrom`: a root rule\n   * consumes trivia BETWEEN terms but not after the last, so trailing\n   * whitespace/comments would otherwise read as leftover input. Given the trivia\n   * rule, the tail is skipped before reporting the first unconsumed offset \u2014\n   * matching `run()`'s semantics. Defaults to the root rule's own\n   * `_meta.grammarTrivia` (from `rules({ trivia })`); set it only to override.\n   */\n  trivia?: Combinator<unknown>\n}\n\nexport interface ParseDoc<N extends NodeLike> {\n  /**\n   * The parse tree with PARENT-RELATIVE spans \u2014 each node's `span` is relative to\n   * its parent's start (root base 0). This is the shareable representation: a\n   * length-changing `.edit()` keeps every untouched subtree shared by identity,\n   * and reading the tree is O(1) (no offset rewrite). For absolute positions use\n   * the O(depth) cursor `spanAt(path)`, or `absolutizeCST(doc.tree)` to\n   * materialize the whole absolute tree. A fresh non-incremental `node().parse()`\n   * result is unchanged \u2014 still absolute.\n   */\n  readonly tree: N | null\n  /**\n   * Recovery diagnostics collected during the (re)parse \u2014 the missing-token\n   * `expect()` errors and tolerant-list recovery errors that ride the tree as\n   * `parseError` nodes, surfaced here as a flat list too (spans ABSOLUTE). Empty\n   * in strict mode. On a hard (non-recovered) parse failure this holds the single\n   * top-level failure. This is what makes an editor document able to see syntax\n   * errors \u2014 a blank `errors: []` (the prior behaviour) hid every recovery.\n   */\n  readonly errors: ParseError[]\n  /**\n   * Offset where unparsed input begins \u2014 the first non-trivia character the parse\n   * left unconsumed (trailing trivia skipped when a trivia rule is available), or\n   * `null` if the whole input was consumed. This is how a document detects \"the\n   * grammar stopped short, there's junk here\"; computed exactly as `run()` does.\n   */\n  readonly unconsumedFrom: number | null\n  readonly input: string\n  /**\n   * Absolute span of the node at `path` (child indices from the root) \u2014 O(depth),\n   * without materializing the absolute tree. The projection cursor for the\n   * relative representation; use it for spot queries on a large incremental doc.\n   */\n  spanAt(path: readonly number[]): { start: number; end: number }\n  /**\n   * Incrementally re-parse after a text change. `from`/`to` are byte offsets in\n   * the OLD input; `replacement` fills that range (editor change-event shape).\n   * Sound: the result tree is always structurally identical to a fresh\n   * `parseDoc` of the edited text (the Stage-2 guard falls back to a full\n   * reparse whenever reuse can't be proven safe). Reuse/strategy is intentionally\n   * NOT reported here \u2014 an observer derives it by diffing this tree against the\n   * previous one (see the incremental tests); the runtime's job is to be fast,\n   * not to measure itself.\n   */\n  edit(from: number, to: number, replacement: string): ParseDoc<N>\n}\n\n// ---------------------------------------------------------------------------\n// Tree navigation (generic over NodeLike \u2014 no class, no CST assumptions)\n// ---------------------------------------------------------------------------\n\n/**\n * A reentry candidate is only worth reparsing if it's meaningfully smaller than\n * the whole document \u2014 reparsing a rule that spans (say) >half the input costs\n * about as much as a full reparse with none of the reuse. Above this fraction of\n * the input length, `.edit()` skips straight to a full reparse. Keeps the worst\n * case (a structural edit near the front) at ~1\u00D7 full reparse, never several.\n */\nconst REENTRY_MAX_SPAN_FRACTION = 0.5\n\ntype FoundNode<N extends NodeLike> = { node: N; path: number[] }\n\nfunction isNode(x: unknown): x is NodeLike {\n  return typeof x === 'object' && x !== null && (x as { _tag?: string })._tag === 'node'\n}\n\n/**\n * Locate the deepest node containing absolute offset `pos`. The tree stores\n * PARENT-RELATIVE spans (see relative-spans), so we thread each node's absolute\n * start down the descent: a child's absolute start is `nodeAbsStart +\n * child.span.start`.\n */\nfunction findContaining<N extends NodeLike>(\n  node: N,\n  nodeAbsStart: number,\n  pos: number,\n  path: number[] = [],\n): FoundNode<N> | null {\n  for (let i = 0; i < node.children.length; i++) {\n    const child = node.children[i]!\n    if (!isNode(child)) continue\n    const childAbsStart = nodeAbsStart + child.span.start\n    const childAbsEnd = nodeAbsStart + child.span.end\n    if (childAbsStart <= pos && pos < childAbsEnd) {\n      const inner = findContaining(child as N, childAbsStart, pos, [...path, i])\n      return inner ?? { node: child as N, path: [...path, i] }\n    }\n  }\n  return null\n}\n\nfunction ancestorsAt<N extends NodeLike>(root: N, path: number[]): N[] {\n  const ancestors: N[] = [root]\n  let cur: N = root\n  for (const idx of path.slice(0, -1)) {\n    const child = cur.children[idx]\n    if (!child || !isNode(child)) break\n    ancestors.push(child as N)\n    cur = child as N\n  }\n  return ancestors\n}\n\nfunction replaceAtPath<N extends NodeLike>(\n  rebuild: NonNullable<ParseDocOptions<N>['rebuild']>,\n  root: N,\n  path: number[],\n  newNode: N,\n): N {\n  if (path.length === 0) return newNode\n  const [idx, ...rest] = path as [number, ...number[]]\n  const newChildren = [...root.children] as Array<N | CSTLeaf | CSTError>\n  newChildren[idx] = rest.length === 0\n    ? newNode\n    : replaceAtPath(rebuild, root.children[idx] as N, rest, newNode)\n  return rebuild(root, newChildren)\n}\n\nfunction defaultRebuild<N extends NodeLike>(node: N, children: ReadonlyArray<N | CSTLeaf | CSTError>): N {\n  return { ...node, children } as N\n}\n\ntype SpanChild = { span: { start: number; end: number }; children?: readonly unknown[] }\n\n/**\n * Shift a node's PARENT-RELATIVE span by `delta`. Used for siblings that sit\n * *after* a length-changing edit inside the same parent: the node moved as a\n * unit, so both endpoints slide by `delta`, but its own children are relative to\n * *its* start and are unchanged \u2014 so `children` is shared by identity. That's the\n * relative-span win: O(1) per trailing sibling, not O(subtree). (Contrast the old\n * absolute model, which had to deep-rewrite every descendant.)\n */\nfunction shiftRelStart<T>(child: T, delta: number): T {\n  const c = child as unknown as SpanChild\n  return { ...(c as object), span: { start: c.span.start + delta, end: c.span.end + delta } } as unknown as T\n}\n\n/**\n * Graft `newNode` at `path` into a parent-relative tree for a length-changing\n * edit (`delta !== 0`): children before the edit are shared by reference, the\n * edited child is replaced, children *after* it have their relative start slid by\n * `delta` (one shallow alloc each \u2014 their subtrees are shared by identity), and\n * each ancestor's relative `span.end` grows by `delta` while its start is\n * untouched. Cost is O(depth + trailing siblings along the spine), independent of\n * how many nodes sit inside those trailing siblings.\n */\nfunction graftRelative<N extends NodeLike>(root: N, path: number[], newNode: N, delta: number): N {\n  if (path.length === 0) return newNode\n  const [idx, ...rest] = path as [number, ...number[]]\n  const oldChildren = root.children as ReadonlyArray<N | CSTLeaf | CSTError>\n  const newChildren = oldChildren.map((child, i) => {\n    if (i < idx) return child\n    if (i === idx) {\n      return rest.length === 0 ? newNode : graftRelative(child as N, rest, newNode, delta)\n    }\n    return shiftRelStart(child, delta)\n  })\n  return {\n    ...root,\n    span: { start: root.span.start, end: root.span.end + delta },\n    children: newChildren,\n  } as N\n}\n\n// ---------------------------------------------------------------------------\n// List-splice reuse (structural edits in a collection)\n//\n// A structural edit \u2014 inserting or deleting a whole element in a list \u2014 makes the\n// innermost-rule reparse fail to converge, and the containing collection is often\n// too big to reparse (that's the \"insert at the top of a large array\" case where\n// a whole-rule reparse costs ~a full reparse). Instead of reparsing the whole\n// collection, reparse ONLY the disturbed span between the last untouched element\n// before the edit and the first untouched element after it, then splice: the head\n// children are shared as-is, the freshly-parsed middle replaces the changed run,\n// and the tail children are reused with their relative start slid by `delta`\n// (O(1) each \u2014 their subtrees are shared by identity, the relative-span win).\n//\n// Soundness rests on: (1) the reparsed middle exactly fills [reStart, reEnd) and\n// lands on element/separator boundaries; (2) a lookahead probe proving the middle\n// read nothing at/after the splice point (else it peeked into the reused tail);\n// (3) a stateless-reentry precondition on the reused tail (its saved `state` is\n// null), so a forward, context-free grammar reproduces those subtrees unchanged.\n// Any failure \u21D2 `null` \u21D2 the caller falls back to a full, correct reparse. The\n// incremental oracle fuzz (edit() \u2261 full reparse, 400 seeds \u00D7 3 list grammars +\n// edge cases) is the end-to-end correctness net.\n// ---------------------------------------------------------------------------\n\ntype AnyChild = { readonly _tag: string; readonly span: { start: number; end: number }; readonly value?: string; readonly type?: string; readonly state?: unknown; readonly children?: readonly unknown[] }\n\n/**\n * Parse the collection's disturbed middle `[reStart, reEnd)` as an\n * `element (separator element)*` run (optionally with a trailing separator that\n * connects to the reused tail), C-relative. Alternation is STRICT: after an\n * element, if we're not yet at `reEnd`, the separator MUST match \u2014 element/element\n * juxtaposition is rejected (that's a `sepBy` violation). When the grammar has no\n * separator (`separator === null`, i.e. a bare repetition), consecutive elements\n * are allowed. Returns the C-relative children, or `null` if the run doesn't tile\n * `[reStart, reEnd)` exactly on token boundaries.\n */\nfunction parseMiddle(\n  input: string,\n  reStart: number,\n  reEnd: number,\n  cStart: number,\n  ruleFn: RuleFn<NodeLike>,\n  separator: string | null,\n  build: ParseContext['build'],\n  tolerant: boolean,\n): AnyChild[] | null {\n  const ctx: ParseContext = mkCtx(null, build, tolerant)\n  const out: AnyChild[] = []\n  let pos = reStart\n  let guard = 0\n  while (pos < reEnd) {\n    if (++guard > reEnd - reStart + 2) return null // no-progress backstop\n    // After an element, a separator is mandatory before the next element (unless\n    // the grammar is separator-free). This is what keeps `elem elem` \u2014 invalid in\n    // a `sepBy` \u2014 from being accepted as two elements.\n    if (separator && out.length > 0 && out[out.length - 1]!._tag === 'node') {\n      if (pos + separator.length > reEnd || !input.startsWith(separator, pos)) return null\n      out.push({ _tag: 'leaf', value: separator, span: { start: pos - cStart, end: pos + separator.length - cStart } })\n      pos += separator.length\n      continue\n    }\n    let r: ParseResult<NodeLike>\n    try {\n      r = ruleFn(input, pos, ctx)\n    } catch {\n      return null\n    }\n    if (!r.ok || r.span.end <= pos || r.span.end > reEnd) return null\n    out.push(relativizeCST(r.value as unknown as AnyChild, cStart))\n    pos = r.span.end\n  }\n  return pos === reEnd ? out : null\n}\n\n/**\n * Try to reuse the untouched tail of collection `C` (at `path`, absolute start\n * `cStart`) around a length-changing edit, reparsing only the disturbed middle.\n * Returns the new relative root, or `null` to fall back to a full reparse.\n */\nfunction tryListSplice<N extends NodeLike>(\n  root: N,\n  path: number[],\n  C: N,\n  cStart: number,\n  newInput: string,\n  from: number,\n  to: number,\n  delta: number,\n  registry: Record<string, RuleFn<N>>,\n  build: ParseContext['build'],\n  tolerant: boolean,\n): N | null {\n  const kids = C.children as ReadonlyArray<AnyChild>\n  if (kids.length === 0) return null\n\n  // head = maximal prefix ending before the edit, backed off so it ends at a\n  // leaf (open delimiter or separator) \u2014 i.e. where an ELEMENT is next expected.\n  let h = 0\n  while (h < kids.length && cStart + kids[h]!.span.end <= from) h++\n  while (h > 0 && kids[h - 1]!._tag === 'node') h--\n  // tail = maximal suffix starting after the edit, advanced so it BEGINS at an\n  // element (node) boundary \u2014 a self-contained element run to reuse.\n  let t = kids.length\n  while (t > h && cStart + kids[t - 1]!.span.start >= to) t--\n  while (t < kids.length && kids[t]!._tag !== 'node') t++\n  if (t >= kids.length) return null // nothing reusable after the edit\n\n  // Stateless-reentry precondition on the reused tail (see soundness note).\n  for (let i = t; i < kids.length; i++) {\n    if (kids[i]!._tag === 'node' && kids[i]!.state != null) return null\n  }\n\n  // C must look like a genuine homogeneous COLLECTION \u2014 a repetition of one\n  // element rule joined by one separator \u2014 not a fixed heterogeneous sequence\n  // (e.g. `Pair = Key ':' Val`, whose `:` is not a list separator). Require: all\n  // element (node) children share a type, and there are \u22652 elements joined by a\n  // consistent separator leaf. This rejects fixed sequences (their nodes differ\n  // in type, or there's only one) so we never treat them as splice-able lists.\n  let elemType: string | undefined\n  let elemCount = 0\n  for (const k of kids) {\n    if (k._tag !== 'node') continue\n    elemCount++\n    if (elemType === undefined) elemType = k.type\n    else if (k.type !== elemType) return null // heterogeneous \u2192 not a collection\n  }\n  if (elemType === undefined || elemCount < 2) return null\n  const ruleFn = registry[elemType]\n  if (!ruleFn) return null\n  // The separator is the leaf that appears between two elements; require it to be\n  // consistent everywhere two elements meet (a real list delimiter).\n  let separator: string | null = null\n  for (let i = 1; i < kids.length - 1; i++) {\n    if (kids[i - 1]!._tag === 'node' && kids[i + 1]!._tag === 'node') {\n      if (kids[i]!._tag !== 'leaf') return null\n      const sep = kids[i]!.value ?? null\n      if (separator === null) separator = sep\n      else if (sep !== separator) return null // inconsistent delimiter \u2192 not a plain list\n    }\n  }\n  if (separator === null) return null // \u22652 elements but no delimiter between any pair\n\n  // The disturbed middle must be pure elements + separators. If the collection is\n  // bracketed, its OPENING / CLOSING delimiter (a leaf whose value isn't the\n  // separator, sitting before the first / after the last element) must lie OUTSIDE\n  // the edit \u2014 otherwise the edit changed the collection's own framing and a\n  // whole-rule reparse (not a splice) is required.\n  const first = kids[0]!\n  const last = kids[kids.length - 1]!\n  if (first._tag === 'leaf' && first.value !== separator && from < cStart + first.span.end) return null\n  if (last._tag === 'leaf' && last.value !== separator && to > cStart + last.span.start) return null\n\n  const reStart = h > 0 ? cStart + kids[h - 1]!.span.end : cStart\n  const reEnd = cStart + kids[t]!.span.start + delta\n  if (reEnd < reStart) return null\n\n  const middle = parseMiddle(newInput, reStart, reEnd, cStart, ruleFn as RuleFn<NodeLike>, separator, build, tolerant)\n  if (!middle) return null\n\n  // Junction check: `tail` always begins with an ELEMENT (we advanced `t` to a\n  // node), so a non-empty middle must END with a SEPARATOR to connect validly \u2014\n  // otherwise the edit deleted the delimiter between the middle's last element and\n  // the tail's first, and splicing would fuse two elements with no separator (a\n  // `sepBy` violation the whole-collection reparse would never produce). When the\n  // middle is empty the tail is preceded by `head`'s last token, itself already a\n  // separator or the open delimiter (head was backed off to a leaf), so it's fine.\n  if (middle.length > 0) {\n    const last = middle[middle.length - 1]!\n    if (!(last._tag === 'leaf' && last.value === separator)) return null\n  }\n\n  // Lookahead guard: the middle must have read nothing at/after `reEnd`, else it\n  // peeked into the reused tail. Re-run over an input whose tail is overwritten\n  // with a sentinel and require an identical middle. Two sentinels so the real\n  // byte at `reEnd` can't accidentally match the probe.\n  if (reEnd < newInput.length) {\n    for (const sentinel of [' ', '\uFFFF']) {\n      if (newInput[reEnd] === sentinel) continue\n      const probed = newInput.slice(0, reEnd) + sentinel.repeat(newInput.length - reEnd)\n      const probe = parseMiddle(probed, reStart, reEnd, cStart, ruleFn as RuleFn<NodeLike>, separator, build, tolerant)\n      if (!probe || probe.length !== middle.length) return null\n      for (let i = 0; i < middle.length; i++) if (!structurallyEqual(probe[i], middle[i])) return null\n    }\n  }\n\n  const head = kids.slice(0, h)\n  const tail = kids.slice(t).map((k) => shiftRelStart(k, delta))\n  const newC = {\n    ...C,\n    span: { start: C.span.start, end: C.span.end + delta },\n    children: [...head, ...middle, ...tail],\n  } as N\n\n  // Replace C at `path` and slide C's own trailing siblings / ancestor ends.\n  return graftRelative(root, path, newC, delta)\n}\n\n// ---------------------------------------------------------------------------\n// Stage-2 soundness guard\n// ---------------------------------------------------------------------------\n\n/**\n * Deep structural equality on parse trees: `_tag`, `span`, node `type`, leaf\n * `value`, and children pairwise. This is the oracle relation `.edit()` must\n * preserve against a full reparse; it's also what the Stage-2 guard compares\n * probe results with.\n */\nexport function structurallyEqual(a: unknown, b: unknown): boolean {\n  if (a === b) return true\n  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) return false\n  const at = (a as { _tag?: string })._tag\n  const bt = (b as { _tag?: string })._tag\n  if (at !== bt) return false\n  const as = (a as { span?: { start: number; end: number } }).span\n  const bs = (b as { span?: { start: number; end: number } }).span\n  if (as || bs) {\n    if (!as || !bs || as.start !== bs.start || as.end !== bs.end) return false\n  }\n  if (at === 'leaf' || at === 'trivia') {\n    return (a as { value: string }).value === (b as { value: string }).value\n  }\n  if (at === 'parseError') {\n    // Embedded recovered error: span already compared above; also compare the\n    // expected-token set so two errors at the same span but different expectations\n    // are not conflated (the oracle must distinguish them).\n    const ae = (a as { expected?: readonly string[] }).expected ?? []\n    const be = (b as { expected?: readonly string[] }).expected ?? []\n    return ae.length === be.length && ae.every((x, i) => x === be[i])\n  }\n  if ((a as { type?: string }).type !== (b as { type?: string }).type) return false\n  const ac = (a as { children?: readonly unknown[] }).children\n  const bc = (b as { children?: readonly unknown[] }).children\n  if (ac || bc) {\n    if (!ac || !bc || ac.length !== bc.length) return false\n    for (let i = 0; i < ac.length; i++) if (!structurallyEqual(ac[i], bc[i])) return false\n  }\n  return true\n}\n\n/**\n * A reused suffix spliced at `boundary` (new-input coords) is sound only if the\n * re-parse of the containing rule did NOT read any input at or after `boundary`\n * \u2014 otherwise a lookahead or backtrack peeked across the splice and the reused\n * tail could be wrong. We prove independence by re-running the same rule at the\n * same start on an input whose entire tail from `boundary` is overwritten with a\n * sentinel: if the produced node is byte-for-byte structurally identical,\n * nothing past `boundary` was inspected. Two distinct sentinels are tried so the\n * real char at `boundary` can't accidentally equal the probe. Conservative by\n * construction \u2014 any probe difference, failure, or throw \u21D2 not safe \u21D2 the caller\n * widens toward a full reparse (correctness over reuse fraction).\n */\nfunction boundaryIsSafe<N extends NodeLike>(\n  ruleFn: RuleFn<N>,\n  newInput: string,\n  start: number,\n  boundary: number,\n  state: unknown,\n  build: ParseContext['build'],\n  produced: ParseResult<N>,\n  tolerant: boolean,\n): boolean {\n  if (!produced.ok) return false\n  if (boundary >= newInput.length) return true // nothing after the node to peek at\n  for (const sentinel of [' ', '\uFFFF']) {\n    if (newInput[boundary] === sentinel) continue\n    const probed = newInput.slice(0, boundary) + sentinel.repeat(newInput.length - boundary)\n    const ctx: ParseContext = mkCtx(state, build, tolerant)\n    let r: ParseResult<N>\n    try {\n      r = ruleFn(probed, start, ctx)\n    } catch {\n      return false\n    }\n    if (!r.ok || r.span.end !== produced.span.end) return false\n    if (!structurallyEqual(r.value, produced.value)) return false\n  }\n  return true\n}\n\n// ---------------------------------------------------------------------------\n// Document\n// ---------------------------------------------------------------------------\n\nclass ParseDocImpl<N extends NodeLike> implements ParseDoc<N> {\n  private readonly _registry: Registry<N>\n  /** Registry entries normalized to callable parse functions (memoized once). */\n  private readonly _fns: Record<string, RuleFn<N>>\n  /** Rule names the grammar proves are genuine repetitions \u2014 the ONLY splice-safe types. */\n  private readonly _reps: Set<string>\n  private readonly _rootRule: string\n  private readonly _opts: ParseDocOptions<N>\n  /**\n   * The tree, held in whichever coordinate system it arrived in. A fresh parse\n   * arrives ABSOLUTE (`_abs` set); an incremental graft arrives PARENT-RELATIVE\n   * (`_rel` set). The public `tree` is always the RELATIVE form (so untouched\n   * subtrees stay shared by identity across edits and reads are O(1)); it's\n   * materialized from `_abs` once, on demand, and memoized. `undefined` = not yet\n   * computed; `null` = failed parse. A fresh parse that's never edited nor\n   * tree-read pays no conversion \u2014 important for the full-reparse fallback path.\n   */\n  private _abs: N | null | undefined\n  private _rel: N | null | undefined\n  readonly errors: ParseError[]\n  readonly unconsumedFrom: number | null\n  readonly input: string\n\n  constructor(\n    registry: Registry<N>,\n    rootRule: string,\n    opts: ParseDocOptions<N>,\n    trees: { abs?: N | null; rel?: N | null },\n    errors: ParseError[],\n    unconsumedFrom: number | null,\n    input: string,\n  ) {\n    this._registry = registry\n    this._fns = {}\n    this._reps = new Set()\n    for (const [name, entry] of Object.entries(registry)) {\n      this._fns[name] = asRuleFn(entry)\n      if (producesRepetition(defOf(entry))) this._reps.add(name)\n    }\n    this._rootRule = rootRule\n    this._opts = opts\n    this._abs = trees.abs\n    this._rel = trees.rel\n    this.errors = errors\n    this.unconsumedFrom = unconsumedFrom\n    this.input = input\n  }\n\n  /**\n   * The parse tree with PARENT-RELATIVE spans \u2014 a node's `span` is relative to\n   * its parent's start (root base 0). This is the shareable representation:\n   * untouched subtrees keep the same identity across `.edit()`s, and reading the\n   * tree after a length-changing edit is O(1) (no offset rewrite). For absolute\n   * positions use the O(depth) cursor `spanAt(path)`, or `absolutizeCST(tree)` to\n   * materialize the whole absolute tree. (A fresh non-incremental `node().parse()`\n   * result is unchanged \u2014 still absolute.)\n   */\n  get tree(): N | null {\n    if (this._rel === undefined) {\n      this._rel = this._abs ? (relativizeCST(this._abs as unknown as N & { span: Span }, 0) as unknown as N) : null\n    }\n    return this._rel\n  }\n\n  spanAt(path: readonly number[]): { start: number; end: number } {\n    const rel = this.tree\n    if (!rel) throw new Error('spanAt on a failed parse (tree is null)')\n    return absoluteSpanCST(rel as unknown as { span: Span; children?: readonly unknown[] }, path)\n  }\n\n  /**\n   * Wrap a reused (grafted/spliced) RELATIVE tree, recomputing `errors` and\n   * `unconsumedFrom` from it so both stay consistent with the tree across the\n   * edit (the flat errors are recovered errors embedded in the reused subtrees;\n   * unconsumedFrom re-derives trailing junk over the new input).\n   */\n  private wrapReuse(newTree: N, newInput: string): ParseDoc<N> {\n    const trivia = triviaOf(this._registry[this._rootRule], this._opts)\n    const end = (newTree as unknown as { span: { end: number } }).span.end\n    const errors = collectEmbeddedErrors(newTree, 0, [])\n    const unconsumedFrom = unconsumedAfter(end, newInput, trivia)\n    return new ParseDocImpl(this._registry, this._rootRule, this._opts, { rel: newTree }, errors, unconsumedFrom, newInput)\n  }\n\n  edit(from: number, to: number, replacement: string): ParseDoc<N> {\n    const newInput = this.input.slice(0, from) + replacement + this.input.slice(to)\n    const reparse = () => parseDoc(this._registry, this._rootRule, newInput, this._opts)\n\n    const root = this.tree\n    if (!root) return reparse()\n\n    const delta = replacement.length - (to - from)\n    // When `from` sits on the root's own boundary (e.g. right after a top-level\n    // element, before its separator), no child node contains it and\n    // `findContaining` returns null \u2014 but the root still does. Fall back to the\n    // root as the container so the structural splice below still gets a shot\n    // (this is exactly the \"insert/delete a top-level list element\" position).\n    const found = findContaining(root, 0, from) ?? { node: root, path: [] as number[] }\n\n    // Try the innermost containing rule first, then widen outward.\n    const ancestors = ancestorsAt(root, found.path)\n    const candidates: FoundNode<N>[] = [found]\n    const pathCopy = [...found.path]\n    for (let i = ancestors.length - 2; i >= 0; i--) {\n      pathCopy.pop()\n      candidates.push({ node: ancestors[i + 1]!, path: [...pathCopy] })\n    }\n\n    const rebuild = this._opts.rebuild ?? defaultRebuild\n    for (const { node, path } of candidates) {\n      // Absolute span of this candidate, projected from the relative root (O(depth)).\n      const { start: absStart, end: absEnd } = absoluteSpanCST(root as unknown as { span: Span; children?: readonly unknown[] }, path)\n      // Reentry only pays off when the re-parsed rule is substantially smaller\n      // than the whole document. Candidates widen deepest\u2192root (monotonically\n      // growing span), so once one covers most of the input, reparsing it \u2014 and\n      // every larger ancestor after it \u2014 can't beat a full reparse and would just\n      // be wasted work before the fallback. Bail to the full reparse NOW. This\n      // caps `.edit()` at ~one full reparse in the worst case (e.g. a structural\n      // insert near the front) instead of stacking several near-full reparses.\n      if (absEnd - absStart > this.input.length * REENTRY_MAX_SPAN_FRACTION) break\n      const ruleFn = this._fns[node.type]\n      if (!ruleFn) continue\n      // The reused subtree must FULLY CONTAIN the edited range (old coords).\n      // `findContaining` only locates `from`; if the edit's end `to` spills past\n      // this node's end, the edit also changed a sibling/separator after it, and\n      // reusing the untouched suffix would be unsound \u2014 widen to an ancestor\n      // that does span the whole edit (ultimately a full reparse).\n      if (!(absStart <= from && to <= absEnd)) continue\n      const ctx: ParseContext = mkCtx(node.state, this._opts.build, !!this._opts.tolerant)\n      const r = ruleFn(newInput, absStart, ctx)\n      if (!r.ok) continue\n      if (r.span.end !== absEnd + delta) continue\n\n      // Stage-2 soundness guard: only reuse the untouched suffix if the re-parse\n      // provably read no input past its own end (else a lookahead/backtrack\n      // crossed the splice). Widen to the next candidate \u2014 ultimately a full\n      // reparse \u2014 when it can't be proven.\n      if (!boundaryIsSafe(ruleFn, newInput, absStart, absEnd + delta, node.state, this._opts.build, r, !!this._opts.tolerant)) {\n        continue\n      }\n\n      // The re-parse produced an ABSOLUTE subtree; rebase it to parent-relative\n      // for splicing into the relative tree. The parent's absolute start is\n      // `absStart - node.span.start` (node.span is already relative to it).\n      const parentBase = absStart - node.span.start\n      const newRel = relativizeCST(r.value as unknown as N & { span: Span }, parentBase) as unknown as N\n\n      // delta === 0: relative spans are unchanged, so the spine graft (sharing\n      // every untouched sibling by reference) is already correct.\n      if (delta === 0) {\n        const newTree = replaceAtPath(rebuild, root, path, newRel)\n        return this.wrapReuse(newTree, newInput)\n      }\n      // Length-changing edit: trailing siblings' relative starts slide by `delta`.\n      // A custom `rebuild` (possibly a class instance) can't have its span slid\n      // safely, so fall back to a full, correct reparse.\n      if (this._opts.rebuild) return reparse()\n      const newTree = graftRelative(root, path, newRel, delta)\n      return this.wrapReuse(newTree, newInput)\n    }\n\n    // No localized rule reparse converged \u2014 the edit is structural. Before paying\n    // a full reparse, try reusing the untouched tail of a containing collection\n    // (add/remove an element in a list). We only ever splice a rule the GRAMMAR\n    // proves is a genuine repetition (`this._reps`, from its combinator def) \u2014 a\n    // fixed-arity same-typed sequence is structurally indistinguishable from a list\n    // by its CST alone, so splicing it could accept a wrong element count; it's\n    // excluded here and falls back to a full, correct reparse. Innermost containing\n    // collection first; a candidate whose disturbed middle doesn't tile cleanly\n    // returns null and we widen. Correctness net is the incremental oracle fuzz.\n    if (this._opts.structuralReuse && delta !== 0 && !this._opts.rebuild) {\n      // Candidates run innermost\u2192ancestor but never include the root itself; the\n      // splice-able collection can BE the root (e.g. a top-level `sepBy` list), so\n      // consider it last.\n      const spliceCandidates: FoundNode<N>[] = [...candidates, { node: root, path: [] }]\n      for (const { node, path } of spliceCandidates) {\n        if (!this._reps.has(node.type)) continue // grammar didn't prove this rule a repetition\n        const { start: cStart, end: cEnd } = absoluteSpanCST(root as unknown as { span: Span; children?: readonly unknown[] }, path)\n        if (!(cStart <= from && to <= cEnd)) continue\n        const spliced = tryListSplice(root, path, node, cStart, newInput, from, to, delta, this._fns, this._opts.build, !!this._opts.tolerant)\n        if (spliced) return this.wrapReuse(spliced, newInput)\n      }\n    }\n\n    return reparse()\n  }\n}\n\n/**\n * The relative (parent-offset) tree backing a doc. Currently identical to the\n * public `doc.tree` (which is relative); kept as a named internal handle for the\n * reuse-metric tests, which assert on the shareable representation explicitly.\n */\nexport function relTreeOf<N extends NodeLike>(doc: ParseDoc<N>): N | null {\n  return doc.tree\n}\n\n/**\n * The grammar trivia rule to skip when computing `unconsumedFrom`: an explicit\n * `trivia` option wins; otherwise the root entry's ambient `grammarTrivia` (the\n * same source `run()` derives it from). A bare-function registry carries no meta,\n * so trailing trivia can't be inferred and the parse must reach the exact end.\n */\nfunction triviaOf<N extends NodeLike>(\n  entry: RuleFn<N> | Combinator<N> | undefined,\n  opts: ParseDocOptions<N>,\n): Combinator<unknown> | undefined {\n  if (opts.trivia) return opts.trivia\n  // Only an interpreter Combinator carries `_meta`; a bare parse function or a\n  // compiled-grammar object (which bakes its ambient trivia into codegen) does\n  // not, so there's nothing to derive and trailing trivia isn't skipped.\n  if (entry === undefined || typeof entry === 'function') return undefined\n  const meta = (entry as { _meta?: { grammarTrivia?: Combinator<unknown> } })._meta\n  return meta ? meta.grammarTrivia : undefined\n}\n\n/**\n * First unconsumed non-trivia offset after a parse that ended at `end` (trailing\n * trivia skipped when a trivia rule is available), or `null` when the whole input\n * was consumed \u2014 byte-for-byte the computation in `run()` (run.ts:117-129).\n */\nfunction unconsumedAfter(end: number, input: string, trivia: Combinator<unknown> | undefined): number | null {\n  let pos = end\n  if (trivia && pos < input.length) {\n    const t = trivia.parse(input, pos, { trackLines: false })\n    if (t.ok && t.span.end > pos) pos = t.span.end\n  }\n  return pos < input.length ? pos : null\n}\n\n/**\n * Collect embedded `parseError` recovery nodes from a PARENT-RELATIVE tree,\n * projecting each to an ABSOLUTE span (root base 0) \u2014 the flat mirror of the\n * errors that ride the tree, recomputed for a reuse-path (grafted/spliced) result\n * so `doc.errors` stays consistent with the tree across incremental edits.\n */\nfunction collectEmbeddedErrors(node: unknown, base: number, out: ParseError[]): ParseError[] {\n  const c = node as { _tag?: string; span?: { start: number; end: number }; expected?: string[]; children?: readonly unknown[] }\n  if (!c || typeof c !== 'object' || !c.span) return out\n  const start = base + c.span.start\n  if (c._tag === 'parseError') {\n    out.push({ _tag: 'parseError', span: { start, end: base + c.span.end }, expected: c.expected ?? [] })\n    return out\n  }\n  if (Array.isArray(c.children)) for (const k of c.children) collectEmbeddedErrors(k, start, out)\n  return out\n}\n\n/**\n * Parse `input` from `rootRule` and wrap the result in a ParseDoc that can\n * be incrementally re-parsed via `.edit()`.\n */\nexport function parseDoc<N extends NodeLike>(\n  registry: Registry<N>,\n  rootRule: string,\n  input: string,\n  opts: ParseDocOptions<N> = {},\n): ParseDoc<N> {\n  const entry = registry[rootRule]\n  if (!entry) throw new Error(`No rule '${rootRule}' in registry`)\n  const ctx: ParseContext = mkCtx(opts.state, opts.build, !!opts.tolerant)\n  const r: ParseResult<N> = asRuleFn(entry)(input, 0, ctx)\n  if (r.ok) {\n    // A fresh parse is ABSOLUTE; the relative form is materialized lazily on the\n    // first edit/spanAt, so a parse that's never edited pays no conversion. The\n    // recovery errors the tolerant parse collected into ctx._errors are surfaced\n    // flat too (like run()), and unconsumedFrom reports any trailing junk.\n    const errors = ctx._errors ? [...ctx._errors] : []\n    const unconsumedFrom = unconsumedAfter(r.span.end, input, triviaOf(entry, opts))\n    return new ParseDocImpl(registry, rootRule, opts, { abs: r.value }, errors, unconsumedFrom, input)\n  }\n  // Hard (non-recovered) failure: the single top-level failure, as a parseError.\n  const fail: ParseError = { _tag: 'parseError', span: r.span, expected: r.expected }\n  return new ParseDocImpl(registry, rootRule, opts, { abs: null }, [fail], null, input)\n}\n", "import type { Combinator, ParseContext, ParseError, ParseResult } from '../types.ts'\nimport { REC } from '../recovery/scan.ts'\n\n/**\n * Run a compiled/interpreted grammar entry against an input and collect the raw\n * outcome a tool needs to shape a parse result \u2014 WITHOUT the consumer having to\n * hand-build a `ctx`, branch on function-vs-combinator, or scan for leftover\n * input itself.\n *\n * A `compile()`/macro grammar hands you a map of bare parse FUNCTIONS; the\n * interpreter hands you COMBINATORS. `run()` invokes either, threads the standard\n * framework ctx (trivia log, recover/expect error sink, the `ctx.build` host,\n * grammar state), and \u2014 given the grammar's trivia parser \u2014 reports where\n * non-trivia input was left unconsumed. The consumer keeps only its own policy:\n * how to shape the tree and how to turn diagnostics into its error type.\n */\n\n/** A compiled rule (macro/`compile()` output) OR an interpreter combinator. */\nexport type Runnable =\n  | ((input: string, pos: number, ctx: ParseContext) => ParseResult<unknown>)\n  | Combinator<unknown>\n\nexport type RunOptions = {\n  /** `ctx.build` host \u2014 makes structural `node()` rules build a CST / AST via the\n   * host instead of their own eval builders. Omit for a grammar's own builders. */\n  build?: ParseContext['build']\n  /** Initial grammar state threaded into `ctx.state`. */\n  state?: unknown\n  /**\n   * The grammar's trivia rule. A root rule consumes trivia BETWEEN terms but not\n   * after the last one, so trailing whitespace/comments would otherwise look like\n   * unparsed input. Given the trivia rule, `run` skips that tail before computing\n   * `unconsumedFrom` \u2014 so only real leftover is reported. Also encodes dialect\n   * differences for free: pass the CSS trivia and a trailing `//` counts as\n   * leftover; pass the Less trivia (which treats `//` as a line comment) and it\n   * doesn't. An UNTERMINATED comment (which the trivia rule won't match) surfaces\n   * at its start. Omit to require the parse to reach the exact end itself.\n   */\n  trivia?: Runnable\n  /**\n   * Restrict PER-NODE CST trivia capture (the `triviaLog` a node's builder sees)\n   * to these trivia kinds \u2014 a bitmask over the grammar's `triviaKindLabels`\n   * indices (build it with `triviaKindMask(labels, ['comment', \u2026])`). Unlisted\n   * kinds (e.g. whitespace) are skipped over but not recorded per node, so a host\n   * that only reads comments doesn't pay to log every whitespace run. The global\n   * `triviaLog` returned by `run()` is unaffected. Omit to capture every kind.\n   */\n  triviaCaptureMask?: number\n  /**\n   * Activate automatic list recovery. When true, `many`/`sepBy`/`oneOrMore` recover\n   * from a failed element \u2014 skip to a sync point (a resume token inferred from the\n   * grammar's structure; the grammar carries no recovery config), emit a\n   * `ParseError` over the skipped span (collected in `errors`), and keep parsing the\n   * rest of the list \u2014 instead of stopping at the first bad element. Omit (the\n   * default) for the strict \"one clean error and stop\" behavior, byte-identical to a\n   * run with no recovery. Recovery is a cold path: on well-formed input nothing\n   * fails, so none of the machinery runs.\n   */\n  tolerant?: boolean\n  /**\n   * Run three compiled-parser-only profiling passes: recognizer (no global\n   * sinks), structural capture without the host, then the normal host path. This\n   * is a measurement boundary, not a parser mode; ordinary `run()` output is\n   * unchanged when omitted. The input is parsed THREE times \u2014 each pass gets its\n   * own shallow copy of `options.state`, so keep per-parse state shallow (only\n   * the top level is isolated between passes).\n   */\n  profile?: boolean\n}\n\nexport type RunProfilePass = {\n  ms: number\n  nodes: number\n  childSlots: number\n  rawSlots: number\n  triviaSlots: number\n  fieldSlots: number\n  hostCalls: number\n}\n\nexport type RunProfile = {\n  /** Existing `voidOf(transform(..., () => undefined))` semantics, generalized\n   * to compiled structural nodes: no `ch`/`raw`/`tl` capture or raw entries. */\n  recognizer: RunProfilePass\n  /** Captures children/raw/trivia/fields but suppresses node construction. */\n  structuralCapture: RunProfilePass\n  /** The ordinary parser path, including its injected build host. */\n  hostConstruction: RunProfilePass\n}\n\nexport type RunResult = {\n  ok: boolean\n  /** The entry's value on success; undefined on failure. */\n  value: unknown\n  span: { start: number; end: number }\n  /** Expected-token set when the TOP-LEVEL parse failed (empty on success). */\n  expected: string[]\n  /** Recovery diagnostics (tolerant lists / `expect()`) collected during the parse (in order). */\n  errors: ParseError[]\n  /**\n   * Flat trivia log for building a trivia map. Entry width depends on whether the\n   * grammar uses labeled trivia: 2 numbers per entry (`start, end`) for plain\n   * trivia, 3 numbers per entry (`start, end, kindIndex`) for labeled trivia\n   * (grammars with `label()` arms in their trivia choice). Use `buildTriviaIndex`\n   * / `triviaEntries` to consume it format-agnostically rather than iterating raw.\n   */\n  triviaLog: number[]\n  /** Offset where unparsed input begins \u2014 the first non-trivia character the parse\n   * left unconsumed (trailing trivia skipped when `trivia` is given), or null if\n   * the whole input was consumed. This is how you detect \"the grammar stopped short,\n   * there's junk here\". Only meaningful on success \u2014 a failed parse reports its own\n   * `span`/`expected`. */\n  unconsumedFrom: number | null\n  /** Present only when `RunOptions.profile` is true. */\n  profile?: RunProfile\n}\n\nconst invoke = (r: Runnable, input: string, pos: number, ctx: ParseContext): ParseResult<unknown> =>\n  typeof r === 'function' ? r(input, pos, ctx) : r.parse(input, pos, ctx)\n\ntype ProfilePhase = NonNullable<ParseContext['_pmProfile']>['phase']\ntype ProfileState = NonNullable<ParseContext['_pmProfile']>\n\nfunction runOnce(entry: Runnable, input: string, options: RunOptions, phase?: ProfilePhase, profileState?: ProfileState): RunResult {\n  if (typeof entry !== 'function' && typeof (entry as Combinator<unknown> | undefined)?.parse !== 'function') {\n    throw new TypeError(\n      `run(): start production is ${entry === null ? 'null' : typeof entry}, not a rule \u2014 the requested grammar rule does not exist (check the rule name).`,\n    )\n  }\n  const triviaLog: number[] = []\n  const errors: ParseError[] = []\n  const profile = profileState ?? (phase === undefined\n    ? undefined\n    : { phase, nodes: 0, childSlots: 0, rawSlots: 0, triviaSlots: 0, fieldSlots: 0, hostCalls: 0 })\n  // NOT \"no output\" \u2014 the `capture` phase still allocates per-node children/raw/\n  // trivia buffers and records slot counts. This flag only omits the two GLOBAL\n  // sinks (`_triviaLog`, `_errors`) from the context; hence `skipGlobalSinks`.\n  const skipGlobalSinks = phase === 'recognizer' || phase === 'capture'\n  // Grammar-level ambient trivia declared via rules({ trivia }, factory): install\n  // it as ctx.trivia so it's ambient for the whole parse (the interpreter path;\n  // a compiled entry has it baked in and carries no _meta). parser/noTrivia still\n  // override locally.\n  const grammarTrivia = typeof entry !== 'function' ? entry._meta.grammarTrivia : undefined\n  const ctx: ParseContext = {\n    trackLines: false,\n    ...(skipGlobalSinks\n      ? { _pmProfile: profile! }\n      : { _triviaLog: triviaLog, _errors: errors, ...(profile === undefined ? {} : { _pmProfile: profile }) }),\n    build: options.build,\n    state: options.state,\n    ...(grammarTrivia !== undefined\n      ? { trivia: grammarTrivia, ...(grammarTrivia._meta.triviaKindLabels ? { triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {}) }\n      : {}),\n    ...(options.triviaCaptureMask !== undefined ? { _triviaCaptureMask: options.triviaCaptureMask } : {}),\n    ...(options.tolerant ? { _tolerant: true, _rec: REC } : {}),\n  }\n  const r = invoke(entry, input, 0, ctx)\n\n  let unconsumedFrom: number | null = null\n  if (r.ok) {\n    let pos = r.span?.end ?? 0\n    if (options.trivia && pos < input.length) {\n      // Throwaway ctx: trailing trivia must NOT pollute the parse's trivia log.\n      const t = invoke(options.trivia, input, pos, { trackLines: false })\n      if (t.ok && t.span.end > pos) pos = t.span.end\n    }\n    unconsumedFrom = pos < input.length ? pos : null\n  }\n\n  return {\n    ok: r.ok,\n    value: r.ok ? (r as { value: unknown }).value : undefined,\n    span: r.span ?? { start: 0, end: 0 },\n    expected: r.ok ? [] : ((r as { expected?: string[] }).expected ?? []),\n    errors,\n    triviaLog,\n    unconsumedFrom,\n  }\n}\n\n/** Shallow copy of `options.state` per pass so an in-place mutation by one\n * profiling pass doesn't leak into the next (the parity check only compares\n * `ok`/`unconsumedFrom`, so a diverged structural output would go unnoticed).\n * Only the top level is isolated \u2014 deeply-nested mutable state is shared; a\n * profiled grammar should keep per-parse state shallow (see the `profile` docs). */\nfunction clonePassState(state: unknown): unknown {\n  if (state === null || typeof state !== 'object') return state\n  return Array.isArray(state) ? [...state] : { ...(state as Record<string, unknown>) }\n}\n\nfunction profilePass(entry: Runnable, input: string, options: RunOptions, phase: ProfilePhase): { result: RunResult; profile: RunProfilePass } {\n  const state: ProfileState = { phase, nodes: 0, childSlots: 0, rawSlots: 0, triviaSlots: 0, fieldSlots: 0, hostCalls: 0 }\n  const passOptions: RunOptions = options.state === undefined ? options : { ...options, state: clonePassState(options.state) }\n  const start = performance.now()\n  const result = runOnce(entry, input, passOptions, phase, state)\n  const { phase: _phase, ...counts } = state\n  return { result, profile: { ms: performance.now() - start, ...counts } }\n}\n\nexport function run(entry: Runnable, input: string, options: RunOptions = {}): RunResult {\n  if (!options.profile) return runOnce(entry, input, options)\n  if (typeof entry !== 'function') {\n    throw new TypeError('run({ profile: true }) requires a compiled parser entry')\n  }\n\n  const recognizer = profilePass(entry, input, options, 'recognizer')\n  const capture = profilePass(entry, input, options, 'capture')\n  const host = profilePass(entry, input, options, 'host')\n  if (recognizer.result.ok !== host.result.ok || capture.result.ok !== host.result.ok\n    || recognizer.result.unconsumedFrom !== host.result.unconsumedFrom\n    || capture.result.unconsumedFrom !== host.result.unconsumedFrom) {\n    throw new Error('run({ profile: true }) changed recognition; the grammar is not profile-safe')\n  }\n  return {\n    ...host.result,\n    profile: {\n      recognizer: recognizer.profile,\n      structuralCapture: capture.profile,\n      hostConstruction: host.profile,\n    },\n  }\n}\n", "import type { Span } from '../types.ts'\n\n/** One captured trivia token (a whitespace run or a comment) with its source span. */\nexport type TriviaToken = { readonly value: string; readonly span: Span }\n\n/**\n * Before/after offset index of captured trivia. Built from a tree whose nodes\n * carry a `triviaLog` property (the flat `[start, end, insertIdx, ...]` array\n * produced by parseman when `parser({ captureTrivia: true })` wraps a `node()` grammar).\n *\n *   index.before.get(node.span.start)  // trivia immediately before a node\n *   index.after.get(node.span.end)     // trivia immediately after a node\n *\n * A given trivia entry is registered under BOTH the following item's start\n * (`before`) and the preceding item's end (`after`), so either lookup finds it.\n */\nexport type TriviaIndex = {\n  readonly before: Map<number, TriviaToken[]>\n  readonly after: Map<number, TriviaToken[]>\n}\n\ntype Spanned = { readonly span: Span }\ntype NodeWithTrivia = {\n  readonly span?: Span\n  readonly children?: ReadonlyArray<unknown>\n  readonly rawChildren?: ReadonlyArray<Spanned>\n  readonly triviaLog?: readonly number[]\n}\n\nfunction merge(map: Map<number, TriviaToken[]>, key: number, run: TriviaToken[]): void {\n  if (run.length === 0) return\n  const existing = map.get(key)\n  if (existing) existing.push(...run)\n  else map.set(key, [...run])\n}\n\n/**\n * Options for trailing/leading trivia at the document boundary. A repeating root\n * (e.g. `many()`) rolls back the trivia after its last item \u2014 it's \"trailing\" and\n * belongs to the enclosing context, which at the document root is the document\n * itself. Pass `{ trivia }` to re-scan and register that boundary trivia,\n * so a round-trippable trivia map isn't missing the run before EOF.\n */\nexport type TriviaIndexOptions = {\n  /**\n   * A regex matching ONE trivia token (a whitespace run or a comment). Applied\n   * repeatedly to tokenize the boundary trivia. Each match becomes one token, so\n   * write it to match a maximal run, e.g.\n   * `/[ \\t\\n\\r\\f]+|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\//`.\n   */\n  trivia: RegExp\n}\n\n/**\n * Walk a tree whose nodes carry `triviaLog` (from `node()` + `captureTrivia`)\n * and build a before/after trivia index. Each node must have\n * `triviaLog: readonly number[]` (flat `[start, end, insertIdx, \u2026]` \u2014\n * three numbers per entry) and `rawChildren` (structural items with `.span`).\n * `input` is the source string used to materialize trivia values.\n *\n * With `opts`, also captures leading trivia (before the root's content) and\n * trailing trivia (after it, up to EOF) \u2014 the document boundaries a repeating\n * root rolls back.\n */\nexport function buildTriviaIndex(root: unknown, input = '', opts?: TriviaIndexOptions): TriviaIndex {\n  const before = new Map<number, TriviaToken[]>()\n  const after = new Map<number, TriviaToken[]>()\n\n  const visit = (node: NodeWithTrivia): void => {\n    const log = node.triviaLog\n    const raw = node.rawChildren\n\n    if (log && log.length && raw) {\n      for (let i = 0; i < log.length; i += 3) {\n        const tStart = log[i]!, tEnd = log[i + 1]!, insertIdx = log[i + 2]!\n        if (tEnd <= tStart) continue\n        const run: TriviaToken[] = [{ value: input.slice(tStart, tEnd), span: { start: tStart, end: tEnd } }]\n        const next = raw[insertIdx]\n        if (next) merge(before, next.span.start, run)\n        const prev = insertIdx > 0 ? raw[insertIdx - 1] : undefined\n        if (prev) merge(after, prev.span.end, run)\n      }\n    }\n\n    const ch = node.children\n    if (ch) {\n      for (const c of ch) {\n        if (typeof c === 'object' && c !== null && (c as NodeWithTrivia).children !== undefined) {\n          visit(c as NodeWithTrivia)\n        }\n      }\n    }\n  }\n\n  if (root) visit(root as NodeWithTrivia)\n\n  // Document-boundary trivia: re-scan leading (offset 0) and trailing (root end\n  // \u2192 EOF) trivia that a repeating root rolled back.\n  if (opts && input) {\n    const rootSpan = (root as NodeWithTrivia | null)?.span\n    const re = new RegExp(opts.trivia.source, opts.trivia.flags.replace(/[gy]/g, '') + 'y')\n    const scanFrom = (from: number): TriviaToken[] => {\n      const run: TriviaToken[] = []\n      let pos = from\n      re.lastIndex = pos\n      let m = re.exec(input)\n      while (m && m.index === pos && m[0].length > 0) {\n        run.push({ value: m[0], span: { start: pos, end: pos + m[0].length } })\n        pos += m[0].length\n        re.lastIndex = pos\n        m = re.exec(input)\n      }\n      return run\n    }\n\n    if (rootSpan && rootSpan.start > 0) {\n      const lead = scanFrom(0)\n      if (lead.length) merge(before, rootSpan.start, lead)\n    }\n    const end = rootSpan ? rootSpan.end : 0\n    if (end < input.length) {\n      const trail = scanFrom(end)\n      if (trail.length) {\n        merge(after, end, trail)\n        merge(before, end + trail.reduce((n, t) => n + (t.span.end - t.span.start), 0), trail)\n      }\n    }\n  }\n\n  return { before, after }\n}\n", "/**\n * Tree traversal for the CST/AST a grammar produces. Pars\u00E9man hands back a plain\n * object tree, so you *can* recurse it yourself \u2014 these helpers save you from\n * re-writing the same recursion for diagnostics, folding, or lowering a tree.\n *\n * Two entry points:\n *   - `walk`          \u2014 imperative depth-first traversal with enter/leave hooks.\n *   - `createVisitor` \u2014 Chevrotain-style dispatch keyed on each node's `type`.\n *\n * Both default to the built-in CST shape (`CSTChild` \u2014 the `node()` / leaf / error\n * union), so with no annotation you get precise typing out of the box. Parsing to\n * a custom AST? Pass your node type as a generic: `walk<MyNode>(root, \u2026)`.\n */\nimport type { CSTChild } from './types.ts'\n\n/**\n * The minimal shape these helpers traverse: a `_tag`, an optional rule `type`,\n * and optional structural `children`. The built-in `CSTChild` satisfies it, and\n * so does any custom AST node (that's what the generic override targets).\n */\nexport type Walkable = {\n  readonly _tag: string\n  readonly type?: string\n  readonly children?: ReadonlyArray<Walkable>\n}\n\nexport interface WalkVisitor<N extends Walkable = CSTChild, C = undefined> {\n  /**\n   * Called on entering a node, before its children. Return `false` to skip\n   * descending into this node's children (`leave` still runs).\n   */\n  enter?(node: N, parent: N | null, ctx: C): boolean | void\n  /** Called on leaving a node, after its children. */\n  leave?(node: N, parent: N | null, ctx: C): void\n}\n\n/**\n * Depth-first traversal. Visits `root`, then each structural child in order.\n * `ctx` is threaded to both hooks unchanged (use it as an accumulator).\n *\n * Defaults to the CST shape; override with `walk<MyNode>(root, \u2026)`:\n *\n *   const idents: string[] = []\n *   walk(tree, {\n *     enter(node) {\n *       if (node._tag === 'leaf') idents.push(node.value)\n *     },\n *   })\n */\nexport function walk<N extends Walkable = CSTChild, C = undefined>(\n  root: N,\n  visitor: WalkVisitor<N, C>,\n  ctx: C = undefined as C,\n): void {\n  const go = (node: N, parent: N | null): void => {\n    const descend = visitor.enter ? visitor.enter(node, parent, ctx) : undefined\n    const children = node.children as ReadonlyArray<N> | undefined\n    if (descend !== false && Array.isArray(children)) {\n      for (const child of children) go(child, node)\n    }\n    visitor.leave?.(node, parent, ctx)\n  }\n  go(root, null)\n}\n\nexport interface VisitApi<R, N extends Walkable = CSTChild> {\n  /** Dispatch a node to its handler (by `type`); returns the handler's result. */\n  visit(node: N): R | undefined\n  /** Visit every structural child, collecting the defined results in order. */\n  visitChildren(node: N): R[]\n}\n\nexport type VisitorHandlers<R, N extends Walkable = CSTChild> = Record<\n  string,\n  (node: N, api: VisitApi<R, N>) => R\n>\n\n/**\n * Build a visitor that dispatches on each node's `type` \u2014 the direct analog of a\n * generated CST-visitor base class. Handlers are keyed by rule name and receive\n * an `api` with `visit` / `visitChildren` to recurse:\n *\n *   const evalExpr = createVisitor<number>({\n *     Num: (n) => Number((n as NumNode).value),\n *     Add: (n, api) => api.visitChildren(n).reduce((a, b) => a + b, 0),\n *   })\n *   const total = evalExpr(tree)\n *\n * Defaults to the CST shape; override the return type and node type together with\n * `createVisitor<number, MyNode>({ \u2026 })`. A node whose `type` has no handler\n * falls through to visiting its children (results discarded), so partial visitors\n * work without listing every rule.\n */\nexport function createVisitor<R = void, N extends Walkable = CSTChild>(\n  handlers: VisitorHandlers<R, N>,\n): (node: N) => R | undefined {\n  const api: VisitApi<R, N> = {\n    visit(node) {\n      const handler = node.type !== undefined ? handlers[node.type] : undefined\n      if (handler) return handler(node, api)\n      api.visitChildren(node)\n      return undefined\n    },\n    visitChildren(node) {\n      const out: R[] = []\n      const children = node.children as ReadonlyArray<N> | undefined\n      if (Array.isArray(children)) {\n        for (const child of children) {\n          const r = api.visit(child)\n          if (r !== undefined) out.push(r)\n        }\n      }\n      return out\n    },\n  }\n  return (node) => api.visit(node)\n}\n", "/** View over a flat trivia log (`_triviaLog` or per-node `triviaLog`). */\nexport type TriviaEntriesView = {\n  readonly length: number\n  readonly labels: readonly string[] | undefined\n  readonly stride: number\n  start(i: number): number\n  end(i: number): number\n  kindIndex(i: number): number | undefined\n  kind(i: number): string | undefined\n  text(i: number, input: string): string\n}\n\nfunction entryOffset(i: number, stride: number): number {\n  return i * stride\n}\n\n/**\n * Wrap a flat trivia log. Stride is inferred from `labels`:\n * - root `_triviaLog`: 2 (start, end) or 3 (+ kindIndex)\n * - node `triviaLog`: 3 (start, end, insertIdx) or 4 (+ kindIndex)\n */\nexport function triviaEntries(\n  log: readonly number[],\n  labels?: readonly string[],\n  opts?: { nodeLog?: boolean },\n): TriviaEntriesView {\n  const baseStride = opts?.nodeLog ? 3 : 2\n  const stride = labels ? baseStride + 1 : baseStride\n  const length = Math.floor(log.length / stride)\n\n  return {\n    length,\n    labels,\n    stride,\n    start(i) {\n      return log[entryOffset(i, stride)]!\n    },\n    end(i) {\n      return log[entryOffset(i, stride) + 1]!\n    },\n    kindIndex(i) {\n      if (!labels) return undefined\n      return log[entryOffset(i, stride) + baseStride]\n    },\n    kind(i) {\n      const ki = labels ? log[entryOffset(i, stride) + baseStride] : undefined\n      return ki !== undefined ? labels![ki] : undefined\n    },\n    text(i, input) {\n      const s = log[entryOffset(i, stride)]!\n      const e = log[entryOffset(i, stride) + 1]!\n      return input.slice(s, e)\n    },\n  }\n}\n", "import type { Span } from '../types.ts'\n\n/**\n * Trivia-offset-inference model.\n *\n * The premise (see docs): most trivia carries nothing that isn't already implied\n * by the source offsets of the tokens around it. A gap between a slot ending at\n * 100 and the next starting at 103 IS three characters of trivia \u2014 known without\n * storing anything. So we store only the slot boundaries (which the tree already\n * has) and reconstruct trivia from them:\n *\n *   - exact printing: slice the source between two slots (`gapText`);\n *   - inference: widths / indents / alignment / blank-lines are subtraction;\n *   - positional queries: binary search over the sorted slot array (O(log n)),\n *     collapsing the old double-indexed before/after maps into one index.\n *\n * A \"slot\" is a leaf token's source span. Trivia lives in the GAPS between\n * consecutive slots (plus the leading gap before the first slot and the trailing\n * gap after the last). Gaps are fully determined by the sorted slot list, so\n * there is no separate trivia store for whitespace at all.\n */\n\n/** A leaf token's source span \u2014 the anchor points; trivia is between them. */\nexport type Slot = { readonly start: number; readonly end: number }\n\n/** A trivia region between two slots (or a document boundary). Half-open `[start, end)`. */\nexport type Gap = { readonly start: number; readonly end: number }\n\nconst { isFinite } = Number\n\n/** Binary search: greatest index `i` in `arr[0..len)` with `arr[i] <= x`, or -1. */\nfunction floorIndex(arr: readonly number[], len: number, x: number): number {\n  let lo = 0\n  let hi = len - 1\n  let ans = -1\n  while (lo <= hi) {\n    const mid = (lo + hi) >>> 1\n    if (arr[mid]! <= x) {\n      ans = mid\n      lo = mid + 1\n    } else {\n      hi = mid - 1\n    }\n  }\n  return ans\n}\n\n/**\n * A positional index over an ordered set of slots (leaf spans) within a source\n * of length `docEnd`. Answers \"what trivia is before/after/around this offset\"\n * by binary search, and reconstructs the exact trivia text by slicing `source`.\n *\n * Slots must be non-overlapping. They are sorted by `start` on construction;\n * out-of-order or overlapping input throws (the caller's spans are wrong).\n */\nexport class OffsetIndex {\n  /** Slot starts, sorted ascending. Parallel to `_ends`. */\n  private readonly _starts: number[]\n  private readonly _ends: number[]\n  readonly count: number\n  readonly docStart: number\n  readonly docEnd: number\n\n  constructor(slots: readonly Slot[], docStart = 0, docEnd?: number) {\n    const sorted = [...slots].sort((a, b) => a.start - b.start)\n    const starts: number[] = []\n    const ends: number[] = []\n    let prevEnd = docStart\n    for (const s of sorted) {\n      if (!isFinite(s.start) || !isFinite(s.end) || s.end < s.start) {\n        throw new RangeError(`OffsetIndex: invalid slot [${s.start}, ${s.end}]`)\n      }\n      if (s.start < prevEnd) {\n        throw new RangeError(`OffsetIndex: overlapping/out-of-order slot [${s.start}, ${s.end}] after end ${prevEnd}`)\n      }\n      starts.push(s.start)\n      ends.push(s.end)\n      prevEnd = s.end\n    }\n    this._starts = starts\n    this._ends = ends\n    this.count = starts.length\n    this.docStart = docStart\n    this.docEnd = docEnd ?? (this.count ? Math.max(prevEnd, ends[ends.length - 1]!) : docStart)\n  }\n\n  /** The slot at index `i` (0-based, source order), or undefined. */\n  slot(i: number): Slot | undefined {\n    if (i < 0 || i >= this.count) return undefined\n    return { start: this._starts[i]!, end: this._ends[i]! }\n  }\n\n  /**\n   * Index of the gap that CONTAINS `offset`, in `[0, count]`. Gap `i` spans\n   * `[endOf(i-1), startOf(i))` where `endOf(-1)=docStart` and `startOf(count)=docEnd`.\n   * An offset that lands inside a slot returns that slot's TRAILING gap index\n   * (i.e. the gap after it) \u2014 callers querying at slot boundaries get the\n   * intuitive answer via `gapBefore`/`gapAfter`.\n   */\n  gapIndexAt(offset: number): number {\n    // Find the last slot whose start <= offset.\n    const i = floorIndex(this._starts, this.count, offset)\n    if (i < 0) return 0 // before the first slot \u2192 leading gap\n    // offset is at or past slot i's start. If it's before slot i's end, it's\n    // inside slot i \u2192 the gap after slot i is index i+1.\n    if (offset < this._ends[i]!) return i + 1\n    // offset is at/after slot i's end \u2192 in the gap after slot i (index i+1),\n    // unless there's a later slot it precedes; either way that's gap i+1.\n    return i + 1\n  }\n\n  /** The gap at index `i` in `[0, count]`. */\n  gap(i: number): Gap | undefined {\n    if (i < 0 || i > this.count) return undefined\n    const start = i === 0 ? this.docStart : this._ends[i - 1]!\n    const end = i === this.count ? this.docEnd : this._starts[i]!\n    return { start, end }\n  }\n\n  /**\n   * The trivia gap immediately BEFORE `offset` (`[prevSlotEnd, offset)`), where\n   * `prevSlotEnd` is the end of the last slot ending at or before `offset` (or\n   * `docStart`). For a real slot start this is the gap preceding that slot; for an\n   * adjacent slot the gap is empty and agrees with `gapAfter` on the same seam.\n   */\n  gapBefore(offset: number): Gap | undefined {\n    const e = floorIndex(this._ends, this.count, offset) // last slot end <= offset\n    const start = e >= 0 ? this._ends[e]! : this.docStart\n    return { start, end: offset }\n  }\n\n  /**\n   * The trivia gap immediately AFTER `offset` (`[offset, nextSlotStart)`), where\n   * `nextSlotStart` is the least slot start at or after `offset` (or `docEnd`).\n   */\n  gapAfter(offset: number): Gap | undefined {\n    return { start: offset, end: this._ceilStart(offset) }\n  }\n\n  /** Least slot start `>= offset`, else `docEnd`. */\n  private _ceilStart(offset: number): number {\n    let lo = 0\n    let hi = this.count - 1\n    let ans = this.docEnd\n    while (lo <= hi) {\n      const mid = (lo + hi) >>> 1\n      if (this._starts[mid]! >= offset) {\n        ans = this._starts[mid]!\n        hi = mid - 1\n      } else {\n        lo = mid + 1\n      }\n    }\n    return ans\n  }\n\n  /** Is this gap empty (adjacent slots, no trivia)? */\n  isEmpty(gap: Gap): boolean {\n    return gap.end <= gap.start\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Reconstruction algebra: everything spatial is a subtraction over slot offsets\n// plus the source (for exact printing) or the sparse marks (for inference).\n// ---------------------------------------------------------------------------\n\nconst NL = 10 // '\\n'\nconst CR = 13 // '\\r'\nconst SP = 32 // ' '\nconst TAB = 9 // '\\t'\n\n/** Exact trivia text of a gap: `source.slice(gap.start, gap.end)`. */\nexport function gapText(source: string, gap: Gap): string {\n  return gap.end > gap.start ? source.slice(gap.start, gap.end) : ''\n}\n\n/** Count of line breaks (`\\n`, with `\\r\\n` counted once) within a gap. */\nexport function lineBreaksIn(source: string, gap: Gap): number {\n  let n = 0\n  for (let i = gap.start; i < gap.end; i++) {\n    const c = source.charCodeAt(i)\n    if (c === NL) n++\n    else if (c === CR && source.charCodeAt(i + 1) !== NL) n++ // lone CR\n  }\n  return n\n}\n\n/** Blank lines in a gap = breaks - 1 (a single break is just a line end, not a blank line). */\nexport function blankLinesIn(source: string, gap: Gap): number {\n  return Math.max(0, lineBreaksIn(source, gap) - 1)\n}\n\n/**\n * Offset just after the last line break in the gap (the start of the final\n * line's indent), or `gap.start` if the gap has no break. This is the ONE\n * non-inferable position; every indent quantity derives from it by subtraction.\n */\nexport function lineStartWithin(source: string, gap: Gap): number {\n  for (let i = gap.end - 1; i >= gap.start; i--) {\n    const c = source.charCodeAt(i)\n    if (c === NL || c === CR) return i + 1\n  }\n  return gap.start\n}\n\n/**\n * Indent width of the line the NEXT slot sits on: `nextStart - lineStart`.\n * `nextStart` is `gap.end` (the following slot's start). Zero if the gap has no\n * line break (the next slot is on the same line).\n */\nexport function indentWidth(source: string, gap: Gap): number {\n  const ls = lineStartWithin(source, gap)\n  if (ls === gap.start) return 0 // same line, no break\n  return gap.end - ls\n}\n\n/** True if the final line's indent mixes tabs and spaces (the one case width can't capture). */\nexport function indentMixed(source: string, gap: Gap): boolean {\n  const ls = lineStartWithin(source, gap)\n  let sawSpace = false\n  let sawTab = false\n  for (let i = ls; i < gap.end; i++) {\n    const c = source.charCodeAt(i)\n    if (c === SP) sawSpace = true\n    else if (c === TAB) sawTab = true\n  }\n  return sawSpace && sawTab\n}\n\n/** Comment spans within a gap (absolute offsets), tokenized by `comment`. */\nexport function commentsIn(source: string, gap: Gap, comment: RegExp): Span[] {\n  const re = new RegExp(comment.source, comment.flags.replace(/[gy]/g, '') + 'g')\n  re.lastIndex = gap.start\n  const out: Span[] = []\n  let m: RegExpExecArray | null\n  while ((m = re.exec(source)) && m.index < gap.end) {\n    if (m[0].length === 0) { re.lastIndex++; continue }\n    if (m.index + m[0].length > gap.end) break\n    out.push({ start: m.index, end: m.index + m[0].length })\n  }\n  return out\n}\n\n/**\n * Does the gap carry anything a normalizing printer must preserve? True if it\n * contains a comment or a line break; a pure inline-whitespace gap returns false\n * and needs no record at all (the printer re-derives canonical spacing).\n */\nexport function gapIsSignificant(source: string, gap: Gap, comment?: RegExp): boolean {\n  if (gap.end <= gap.start) return false\n  if (lineBreaksIn(source, gap) > 0) return true\n  if (comment && commentsIn(source, gap, comment).length > 0) return true\n  return false\n}\n\n// ---------------------------------------------------------------------------\n// CST adapter: the positioned tree IS the index. Flatten a parseman CST to its\n// leaf (terminal) slots in source order; the gaps between them are the trivia \u2014\n// no separate trivia store needed.\n// ---------------------------------------------------------------------------\n\ntype AnyCstChild = {\n  readonly _tag?: string\n  readonly span?: { readonly start: number; readonly end: number }\n  readonly children?: ReadonlyArray<unknown>\n}\n\n/**\n * Collect the leaf-token spans of a CST in source order. Nodes/errors (which\n * carry `children`) are descended into; only childless spanned items (terminals)\n * become slots. Node spans are skipped \u2014 they overlap their children and would\n * double-cover the gaps.\n */\nexport function collectLeafSlots(root: unknown): Slot[] {\n  const slots: Slot[] = []\n  const visit = (n: AnyCstChild): void => {\n    const kids = n.children\n    if (kids && kids.length) {\n      for (const c of kids) visit(c as AnyCstChild)\n    } else if (n.span) {\n      slots.push({ start: n.span.start, end: n.span.end })\n    }\n  }\n  if (root) visit(root as AnyCstChild)\n  return slots\n}\n\n/**\n * Build an `OffsetIndex` directly from a parseman CST root and its source. This\n * is the drop-in replacement for the double-indexed `buildTriviaIndex`: the same\n * before/after trivia is recovered by `gapBefore`/`gapAfter` + `gapText`, and it\n * additionally supports arbitrary positional queries and inference \u2014 with nothing\n * stored per whitespace gap.\n */\nexport function buildOffsetIndex(root: unknown, input = ''): OffsetIndex {\n  return new OffsetIndex(collectLeafSlots(root), 0, input.length)\n}\n"],
+  "mappings": "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",
   "names": ["firstSet", "parse", "firstSet", "span", "EMPTY", "node", "firstSet", "label", "trivia", "trivia", "tr", "trivia", "parser", "inRanges", "result", "guard", "parser", "cp", "ind", "endV", "openLen", "j", "openChk", "unwrapTrivia", "trivia", "escapeRegExp", "body", "trivia", "vv", "stmts", "ref", "r", "litCond", "label", "parser", "fnName", "mv", "walk", "skip", "emit", "childrenOf", "fn", "trivia", "trivia", "children", "span", "rawChildren", "triviaLog", "state", "trivia", "v", "node", "node", "guard", "last", "trivia", "newTree", "trivia", "node", "run", "node", "node"]
 }