parseman 0.42.1 → 0.44.0

package/dist/plugin/index.cjs

@@ -1106,1031 +1106,1095 @@ function keywords(words, opts = {}) {
   };
 }
 
-// src/recovery/scan.ts
-function probeAt(sentinel, input, pos, ctx) {
-  const s = {
-    _probe: ctx._probe,
-    _errors: ctx._errors,
-    _cstLeaves: ctx._cstLeaves,
-    _cstChildren: ctx._cstChildren,
-    _cstRawChildren: ctx._cstRawChildren,
-    _cstTriviaLog: ctx._cstTriviaLog,
-    _triviaLog: ctx._triviaLog,
-    _fields: ctx._fields,
-    _cstBuf: ctx._cstBuf,
-    _tolerant: ctx._tolerant,
-    _sync: ctx._sync
-  };
-  ctx._probe = void 0;
-  ctx._errors = void 0;
-  ctx._cstLeaves = void 0;
-  ctx._cstChildren = void 0;
-  ctx._cstRawChildren = void 0;
-  ctx._cstTriviaLog = void 0;
-  ctx._triviaLog = void 0;
-  ctx._fields = void 0;
-  ctx._cstBuf = void 0;
-  ctx._tolerant = void 0;
-  ctx._sync = void 0;
-  try {
-    return sentinel.parse(input, pos, ctx).ok;
-  } finally {
-    ctx._probe = s._probe;
-    ctx._errors = s._errors;
-    ctx._cstLeaves = s._cstLeaves;
-    ctx._cstChildren = s._cstChildren;
-    ctx._cstRawChildren = s._cstRawChildren;
-    ctx._cstTriviaLog = s._cstTriviaLog;
-    ctx._triviaLog = s._triviaLog;
-    ctx._fields = s._fields;
-    ctx._cstBuf = s._cstBuf;
-    ctx._tolerant = s._tolerant;
-    ctx._sync = s._sync;
-  }
+// src/cst/trivia-kinds.ts
+var labeledTriviaSpecs = /* @__PURE__ */ new WeakMap();
+function unwrapTrivia(p) {
+  let cur = p;
+  while (cur._def.tag === "trivia") cur = cur._def.parser;
+  return cur;
 }
-function orSentinel(a, b) {
-  if (b === void 0) return a;
-  return {
-    _tag: "orSentinel",
-    _meta: { firstSet: { kind: "any" }, canMatchNewline: false, isTrivia: false },
-    _def: { tag: "unknown" },
-    parse(input, pos, ctx) {
-      const ra = a.parse(input, pos, ctx);
-      if (ra.ok) return ra;
-      return b.parse(input, pos, ctx);
-    }
-  };
+function peelLabel(p) {
+  if (p._def.tag === "label") return { label: p._def.label, parser: p._def.parser };
+  return null;
 }
-function firstSetSentinel(fs2) {
-  if (fs2.kind !== "ranges" || fs2.ranges.length === 0) return null;
-  const ranges = fs2.ranges;
-  return {
-    _tag: "firstSetSentinel",
-    _meta: { firstSet: fs2, canMatchNewline: false, isTrivia: false },
-    _def: { tag: "unknown" },
-    parse(input, pos) {
-      const code = pos < input.length ? input.codePointAt(pos) : void 0;
-      if (code !== void 0) {
-        for (const r of ranges) {
-          if (code >= r.lo && code <= r.hi) return { ok: true, value: null, span: { start: pos, end: pos } };
-        }
+function analyzeLabeledTrivia(trivia2) {
+  const cached = labeledTriviaSpecs.get(trivia2);
+  if (cached !== void 0) return cached;
+  let core = unwrapTrivia(trivia2);
+  let minRepeats = 1;
+  if (core._def.tag === "oneOrMore") {
+    core = core._def.parser;
+    minRepeats = 1;
+  } else if (core._def.tag === "many") {
+    core = core._def.parser;
+    minRepeats = 0;
+  }
+  const arms = [];
+  if (core._def.tag === "choice") {
+    for (let i = 0; i < core._def.parsers.length; i++) {
+      const peeled = peelLabel(core._def.parsers[i]);
+      if (!peeled) {
+        labeledTriviaSpecs.set(trivia2, null);
+        return null;
       }
-      return { ok: false, expected: [], span: { start: pos, end: pos } };
+      arms.push({ label: peeled.label, kindIndex: i, parser: peeled.parser });
+    }
+  } else {
+    const peeled = peelLabel(core);
+    if (!peeled) {
+      labeledTriviaSpecs.set(trivia2, null);
+      return null;
     }
+    arms.push({ label: peeled.label, kindIndex: 0, parser: peeled.parser });
+  }
+  const spec = {
+    labels: arms.map((a) => a.label),
+    arms,
+    minRepeats
   };
+  labeledTriviaSpecs.set(trivia2, spec);
+  return spec;
 }
-function recoverScan(input, from, ctx, sync, expected) {
-  let scanPos = from;
-  while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++;
-  const span = { start: from, end: scanPos };
-  if (ctx.trackLines) recordLineRangeFromContext(ctx, input, from, scanPos);
-  const error = { _tag: "parseError", span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected };
-  ctx._errors?.push(error);
-  return { error, end: scanPos };
-}
-function matchesAt(sentinel, input, pos, ctx) {
-  return probeAt(sentinel, input, pos, ctx);
+function matchArmAt(input, pos, arm, state) {
+  if (!startsFirstSet(arm, input, pos)) return null;
+  const r = arm.parse(input, pos, { trackLines: false, state });
+  if (!r.ok || r.span.end <= pos) return null;
+  return { end: r.span.end };
 }
-function captureError(ctx, error) {
-  if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error);
+function scanLabeledTriviaChunks(input, cur, spec, state) {
+  const chunks = [];
+  let pos = cur;
+  while (pos < input.length) {
+    let matched = null;
+    for (const arm of spec.arms) {
+      const m = matchArmAt(input, pos, arm.parser, state);
+      if (m) {
+        matched = { end: m.end, kindIndex: arm.kindIndex };
+        break;
+      }
+    }
+    if (!matched) break;
+    chunks.push({ start: pos, end: matched.end, kindIndex: matched.kindIndex });
+    pos = matched.end;
+  }
+  if (chunks.length < spec.minRepeats) {
+    return { end: cur, chunks: [] };
+  }
+  return { end: pos, chunks };
 }
-
-// src/combinators/expect.ts
-function deriveExpected(c) {
-  return [...new Set(derive(c, /* @__PURE__ */ new Set()))];
+function scanLabeledTriviaEnd(input, cur, spec, state) {
+  let pos = cur;
+  let count = 0;
+  while (pos < input.length) {
+    let matched = null;
+    for (const arm of spec.arms) {
+      matched = matchArmAt(input, pos, arm.parser, state);
+      if (matched) break;
+    }
+    if (!matched) break;
+    pos = matched.end;
+    count++;
+  }
+  return count < spec.minRepeats ? cur : pos;
 }
-function derive(c, seen) {
-  const deriveExpected2 = (p) => derive(p, seen);
-  const def = c._def;
-  switch (def.tag) {
-    case "literal":
-      return [JSON.stringify(def.value)];
-    case "regex":
-      return [`/${def.source}/`];
-    case "keywords":
-      return def.words.map((w) => JSON.stringify(w));
-    case "label":
-      return [def.label];
-    case "choice":
-      return def.parsers.flatMap(deriveExpected2);
-    case "dispatch":
-      return deriveExpected2(def.selector);
-    // Union through the NULLABLE prefix, mirroring `sequenceFirstSet`. A leading
-    // `optional(…)`/`many(…)` can match nothing, so the term after it is equally
-    // able to fail first — deriving from term 0 alone named a token the parse
-    // never actually required. A leading `not(…)` is zero-width and contributes
-    // nothing (its own expectation is about what must NOT be here), but it is
-    // nullable, so keep scanning past it. Stop at the first term that must match.
-    case "sequence": {
-      const out = [];
-      for (const term of def.parsers) {
-        if (!isZeroWidthAssertion(term)) out.push(...deriveExpected2(term));
-        if (!matchesEmpty(term)) break;
+function visitLabeledTrivia(input, cur, spec, state, visit) {
+  if (spec.minRepeats > 1) return void 0;
+  let pos = cur;
+  let count = 0;
+  while (pos < input.length) {
+    let matched = null;
+    for (const arm of spec.arms) {
+      const match = matchArmAt(input, pos, arm.parser, state);
+      if (match) {
+        matched = { end: match.end, kindIndex: arm.kindIndex };
+        break;
       }
-      return out;
     }
-    case "attempt":
-      return deriveExpected2(def.parser);
-    // Delegating wrappers whose first-token failure is their inner parser's — must
-    // pass through so a start-failure (and the first-set-miss fast-path in attempt/
-    // node, which reads this) names the real expected token, not the wrapper tag.
-    case "field":
-    case "withCtx":
-    case "recover":
-      return deriveExpected2(def.parser);
-    case "skip":
-      return deriveExpected2(def.main);
-    case "expect":
-      return def.expected;
-    case "node":
-    case "grammar":
-    case "trivia":
-    case "token":
-    case "leaf":
-    case "optional":
-    case "many":
-    case "oneOrMore":
-    case "transform":
-    case "not":
-    case "peek":
-      return deriveExpected2(def.parser);
-    case "routed":
-      return ["routed()"];
-    case "lazy": {
-      const name = c._ruleName;
-      if (seen.has(c)) return name ? [name] : [];
-      seen.add(c);
-      try {
-        return deriveExpected2(def.thunk());
-      } catch {
-        return name ? [name] : [];
-      } finally {
-        seen.delete(c);
+    if (!matched) break;
+    visit(pos, matched.end, matched.kindIndex);
+    pos = matched.end;
+    count++;
+  }
+  return count < spec.minRepeats ? cur : pos;
+}
+function recordTriviaChunks(ctx, chunks) {
+  const kinds = ctx.triviaKindLabels;
+  const mask = ctx._triviaCaptureMask;
+  const rootLog = ctx._rootTriviaLog;
+  const rootKinds = ctx._rootTriviaKindIndex;
+  const rootMark = rootLog?.length ?? 0;
+  for (const ch2 of chunks) {
+    pushTriviaLogEntry(ctx, ch2.start, ch2.end, kinds ? ch2.kindIndex : void 0);
+    const rootKindIndex = ctx._rootTriviaCapture === false || rootLog === void 0 || rootKinds === void 0 || kinds === void 0 ? -1 : rootKinds[kinds[ch2.kindIndex] ?? ""] ?? -1;
+    if (rootKindIndex >= 0) {
+      rootLog.push(0, 0, ch2.start, ch2.end, rootKindIndex);
+    }
+    if (ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0)) {
+      if (mask === void 0 || kinds === void 0 || (mask & 1 << ch2.kindIndex) !== 0) {
+        pushCstTriviaEntry(ctx, ch2.start, ch2.end, kinds ? ch2.kindIndex : void 0);
       }
     }
-    default:
-      return [];
   }
-}
-function expect(combinator, label2) {
-  const expected = label2 !== void 0 ? [label2] : deriveExpected(combinator);
-  const meta = {
-    firstSet: combinator._meta.firstSet,
-    canMatchNewline: combinator._meta.canMatchNewline,
-    isTrivia: false
-  };
-  return {
-    _tag: "expect",
-    _meta: meta,
-    _def: { tag: "expect", parser: combinator, label: label2, expected },
-    parse(input, pos, ctx) {
-      const result = combinator.parse(input, pos, ctx);
-      if (result.ok) return result;
-      const span = { start: pos, end: pos };
-      const error = { _tag: "parseError", span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected };
-      ctx._errors?.push(error);
-      if (ctx._tolerant) captureError(ctx, error);
-      return { ok: true, value: error, span: { start: pos, end: pos } };
+  if (rootLog !== void 0 && rootLog.length !== rootMark && chunks.length > 0) {
+    const start = chunks[0].start;
+    const end = chunks[chunks.length - 1].end;
+    for (let offset = rootMark; offset < rootLog.length; offset += 5) {
+      rootLog[offset] = start;
+      rootLog[offset + 1] = end;
     }
-  };
+  }
 }
-
-// src/combinators/choice.ts
-function choice(...args) {
-  const parsers = args.map((a) => "gate" in a ? a.combinator : a);
-  const gates = args.map((a) => "gate" in a ? a.gate : null);
-  const hasGates = gates.some((g) => g !== null);
-  const disjoint = areDisjoint(parsers.map((p) => p._meta.firstSet)) && parsers.every((p) => !matchesEmpty(p));
-  let combined = { kind: "empty" };
-  for (const p of parsers) combined = union(combined, p._meta.firstSet);
-  const meta = {
-    firstSet: combined,
-    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
-    isTrivia: false,
-    disjoint
-  };
-  const strategy = disjoint || hasGates ? null : detectStrategy(parsers);
-  const autoNot = !disjoint && !hasGates && (strategy?.tag === "firstMatch" || strategy?.tag === "sharedPrefix") ? computeAutoNot(parsers) : parsers.map(() => null);
-  let greedyLitMap = null;
-  let sortedParsers = null;
-  const asciiDispatch = disjoint ? buildAsciiDispatch(parsers) : null;
-  if (strategy?.tag === "greedyClassify") {
-    greedyLitMap = /* @__PURE__ */ new Map();
-    for (let i = 0; i < parsers.length; i++) {
-      if (i === strategy.superIndex) continue;
-      const litVal = getCoreLiteralValue(parsers[i]);
-      if (litVal !== null) greedyLitMap.set(litVal, i);
-    }
-  } else if (strategy?.tag === "literalsLongestFirst") {
-    sortedParsers = strategy.sortedIndices.map((i) => parsers[i]);
+function triviaKindMask(labels, keep) {
+  if (!labels) return void 0;
+  let mask = 0;
+  for (const name of keep) {
+    const idx = labels.indexOf(name);
+    if (idx >= 0) mask |= 1 << idx;
   }
+  return mask;
+}
+
+// src/combinators/trivia-skip.ts
+var NOOP_COMMIT = () => {
+};
+var fastTriviaCache = /* @__PURE__ */ new WeakMap();
+function needsDeferredTriviaCommit(ctx) {
+  return ctx._triviaLog !== void 0 || ctx._rootTriviaLog !== void 0 || ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0;
+}
+function saveTriviaMark(ctx) {
+  const m = saveCstMark(ctx);
   return {
-    _tag: "choice",
-    _meta: meta,
-    _def: {
-      tag: "choice",
-      parsers,
-      gates,
-      disjoint,
-      strategy: strategy ?? { tag: "firstMatch" },
-      autoNot
-    },
-    parse(input, pos, ctx) {
-      const expected = [];
-      if (disjoint && pos < input.length) {
-        const code = input.codePointAt(pos);
-        let idx = code < 128 ? asciiDispatch[code] : -1;
-        if (idx < 0) {
-          for (let i = 0; i < parsers.length; i++) {
-            if (inFirstSet(code, parsers[i]._meta.firstSet)) {
-              idx = i;
-              break;
-            }
+    raw: m.raw,
+    tlog: m.tlog,
+    leaves: m.leaves,
+    fields: m.fields,
+    errors: m.errors,
+    log: ctx._triviaLog ? ctx._triviaLog.length : 0,
+    rootLog: ctx._rootTriviaLog ? ctx._rootTriviaLog.length : 0
+  };
+}
+function rollbackTrivia(ctx, mark) {
+  rollbackCstCapture(ctx, { raw: mark.raw, tlog: mark.tlog, leaves: mark.leaves, fields: mark.fields, errors: mark.errors });
+  if (ctx._triviaLog && ctx._triviaLog.length !== mark.log) ctx._triviaLog.length = mark.log;
+  if (ctx._rootTriviaLog && ctx._rootTriviaLog.length !== mark.rootLog) ctx._rootTriviaLog.length = mark.rootLog;
+}
+function parseTriviaNoCapture(triviaP, input, cur, ctx) {
+  const probeCtx = {
+    trackLines: ctx.trackLines,
+    state: ctx.state,
+    ...ctx._lineIndex ? { _lineIndex: ctx._lineIndex } : {},
+    ...ctx._lineStarts ? { _lineStarts: ctx._lineStarts } : {},
+    ...ctx._lineScannedTo !== void 0 ? { _lineScannedTo: ctx._lineScannedTo } : {}
+  };
+  const result = triviaP.parse(input, cur, probeCtx);
+  ctx._lineScannedTo = probeCtx._lineScannedTo;
+  return result;
+}
+function saveLookaheadMark(ctx) {
+  return { ...saveTriviaMark(ctx), probeBest: ctx._probe ? ctx._probe.best : null };
+}
+function rollbackLookahead(ctx, mark) {
+  rollbackTrivia(ctx, mark);
+  if (ctx._probe) ctx._probe.best = mark.probeBest;
+}
+function scanWithLabels(input, cur, ctx) {
+  const triviaP = ctx.trivia;
+  const spec = analyzeLabeledTrivia(triviaP);
+  if (!spec) return { end: cur, commit: NOOP_COMMIT };
+  const log = ctx._triviaLog;
+  const rootLog = ctx._rootTriviaLog;
+  const rootKinds = ctx._rootTriviaKindIndex;
+  const captureTl = ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0);
+  const mask = ctx._triviaCaptureMask;
+  let fullRows;
+  let rootRows;
+  let cstRows;
+  const visitedEnd = visitLabeledTrivia(input, cur, spec, ctx.state, (start, matchEnd, kindIndex) => {
+    if (log !== void 0) (fullRows ??= []).push(start, matchEnd, kindIndex);
+    const selectedKind = rootLog === void 0 || rootKinds === void 0 || ctx._rootTriviaCapture === false ? void 0 : rootKinds[spec.labels[kindIndex] ?? ""];
+    if (selectedKind !== void 0) (rootRows ??= []).push(start, matchEnd, selectedKind);
+    if (captureTl && (mask === void 0 || (mask & 1 << kindIndex) !== 0)) {
+      (cstRows ??= []).push(start, matchEnd, kindIndex);
+    }
+  });
+  if (visitedEnd !== void 0) {
+    if (visitedEnd === cur) return { end: cur, commit: NOOP_COMMIT };
+    return {
+      end: visitedEnd,
+      commit: () => {
+        if (fullRows !== void 0 && log !== void 0) log.push(...fullRows);
+        if (rootRows !== void 0 && rootLog !== void 0) {
+          for (let i = 0; i < rootRows.length; i += 3) {
+            rootLog.push(cur, visitedEnd, rootRows[i], rootRows[i + 1], rootRows[i + 2]);
           }
         }
-        if (idx >= 0) {
-          const gate2 = gates[idx];
-          if (gate2 && !gate2(ctx.state)) {
-            return { ok: false, expected: deriveExpected(parsers[idx]), span: { start: pos, end: pos } };
+        if (cstRows !== void 0) {
+          for (let i = 0; i < cstRows.length; i += 3) {
+            pushCstTriviaEntry(ctx, cstRows[i], cstRows[i + 1], cstRows[i + 2]);
           }
-          const result = parsers[idx].parse(input, pos, ctx);
-          if (result.ok) return result;
-          expected.push(...result.expected);
-          if (result.committed) return { ok: false, expected, span: { start: pos, end: pos }, committed: true };
-          return { ok: false, expected, span: { start: pos, end: pos } };
-        }
-        return {
-          ok: false,
-          expected: parsers.flatMap((p) => {
-            const r = p.parse(input, pos, ctx);
-            return r.ok ? [] : r.expected;
-          }),
-          span: { start: pos, end: pos }
-        };
-      }
-      if (strategy?.tag === "greedyClassify") {
-        const superResult = parsers[strategy.superIndex].parse(input, pos, ctx);
-        if (!superResult.ok) return superResult;
-        const end = superResult.span.end;
-        const litIdx = greedyLitMap.get(input.slice(pos, end));
-        if (litIdx !== void 0) {
-          const litVal = getCoreLiteralValue(parsers[litIdx]);
-          const value = applyTransforms(parsers[litIdx], litVal, { start: pos, end });
-          return { ok: true, value, span: { start: pos, end } };
-        }
-        return superResult;
-      }
-      if (strategy?.tag === "literalsLongestFirst") {
-        for (const p of sortedParsers) {
-          const r = p.parse(input, pos, ctx);
-          if (r.ok) return r;
-          expected.push(...r.expected);
-        }
-        return { ok: false, expected, span: { start: pos, end: pos } };
-      }
-      for (let i = 0; i < parsers.length; i++) {
-        if (gates[i] && !gates[i](ctx.state)) continue;
-        const mark = saveCstMark(ctx);
-        const logLen = ctx._triviaLog?.length;
-        const result = parsers[i].parse(input, pos, ctx);
-        if (!result.ok) {
-          rollbackCstCapture(ctx, mark);
-          if (logLen !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== logLen) ctx._triviaLog.length = logLen;
-          expected.push(...result.expected);
-          if (result.committed) return { ok: false, expected, span: result.span, committed: true };
-          continue;
         }
-        const checks = autoNot[i];
-        if (checks && autoNotFires(input, result.span.end, checks)) {
-          rollbackCstCapture(ctx, mark);
-          if (logLen !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== logLen) ctx._triviaLog.length = logLen;
-          continue;
-        }
-        return result;
       }
-      return { ok: false, expected, span: { start: pos, end: pos } };
-    }
+    };
+  }
+  const { end, chunks } = scanLabeledTriviaChunks(input, cur, spec, ctx.state);
+  if (end === cur) return { end: cur, commit: NOOP_COMMIT };
+  return {
+    end,
+    commit: () => recordTriviaChunks(ctx, chunks)
   };
 }
-function detectStrategy(parsers) {
-  const regexIndices = [];
-  const literalIndices = [];
-  for (let i = 0; i < parsers.length; i++) {
-    if (getCoreRegexDef(parsers[i]) !== null) regexIndices.push(i);
-    else if (getCoreLiteralValue(parsers[i]) !== null) literalIndices.push(i);
-  }
-  if (regexIndices.length === 1 && literalIndices.length === parsers.length - 1 && literalIndices.length > 0) {
-    const superIndex = regexIndices[0];
-    const regexDef = getCoreRegexDef(parsers[superIndex]);
-    const flags = "y" + regexDef.flags.replace(/[gy]/g, "");
-    const re = new RegExp(regexDef.source, flags);
-    const allSubsumed = literalIndices.every((i) => {
-      const litVal = getCoreLiteralValue(parsers[i]);
-      re.lastIndex = 0;
-      const m = re.exec(litVal);
-      return m !== null && m[0] === litVal;
-    });
-    if (allSubsumed) return { tag: "greedyClassify", superIndex };
+function skipWithLabels(input, cur, ctx) {
+  const spec = analyzeLabeledTrivia(ctx.trivia);
+  if (spec) return scanLabeledTriviaEnd(input, cur, spec, ctx.state);
+  const tr = parseTriviaNoCapture(ctx.trivia, input, cur, ctx);
+  return tr.ok && tr.span.end > cur ? tr.span.end : cur;
+}
+function advanceTrivia(input, cur, ctx) {
+  const triviaP = ctx.trivia;
+  if (!triviaP) return cur;
+  if (!ctx.trackLines) {
+    const fast2 = fastTriviaScanner(triviaP);
+    if (fast2) return fast2(input, cur);
+    if (ctx.triviaKindLabels) return skipWithLabels(input, cur, ctx);
+    const tr2 = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state });
+    return tr2.ok && tr2.span.end > cur ? tr2.span.end : cur;
   }
-  if (parsers.length === literalIndices.length) {
-    const sortedIndices = [...literalIndices].sort(
-      (a, b) => getCoreLiteralValue(parsers[b]).length - getCoreLiteralValue(parsers[a]).length
-    );
-    return { tag: "literalsLongestFirst", sortedIndices };
+  const trackTriviaLines = ctx.trackLines && triviaP._meta.canMatchNewline;
+  const fast = fastTriviaScanner(triviaP);
+  if (fast) {
+    const end = fast(input, cur);
+    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, end);
+    return end;
   }
-  const shared = detectSharedPrefix(parsers);
-  if (shared !== null) return shared;
-  return { tag: "firstMatch" };
-}
-function bareLeadingTermKey(term) {
-  const d = term._def;
-  if (d.tag === "literal" && !d.caseInsensitive) return `L:${d.value}`;
-  if (d.tag === "regex") return `R:${d.source}\0${d.flags}`;
-  return null;
-}
-function detectSharedPrefix(parsers) {
-  if (parsers.length < 2) return null;
-  let key = null;
-  let prefix = null;
-  const members = [];
-  for (let i = 0; i < parsers.length; i++) {
-    const term0 = leadingTermOfArm(parsers[i]);
-    if (term0 === null) return null;
-    const k = bareLeadingTermKey(term0);
-    if (k === null) return null;
-    if (key === null) {
-      key = k;
-      prefix = term0;
-    } else if (k !== key) return null;
-    members.push(i);
+  if (ctx.triviaKindLabels) {
+    const end = skipWithLabels(input, cur, ctx);
+    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, end);
+    return end;
   }
-  if (prefix === null || members.length < 2) return null;
-  return { tag: "sharedPrefix", prefix, members };
+  const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
+  return tr.ok && tr.span.end > cur ? tr.span.end : cur;
 }
-function leadingTermOfArm(arm) {
-  let d = arm._def;
-  for (; ; ) {
-    if (d.tag === "node" || d.tag === "grammar" || d.tag === "transform" || d.tag === "label") {
-      d = d.parser._def;
-      continue;
+function scanTrivia(input, cur, ctx) {
+  const triviaP = ctx.trivia;
+  if (!triviaP) return { end: cur, commit: NOOP_COMMIT };
+  const log = ctx._triviaLog;
+  const rootLog = ctx._rootTriviaLog;
+  const captureTl = ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0);
+  if (!ctx.trackLines) {
+    const fast2 = !ctx.triviaKindLabels ? fastTriviaScanner(triviaP) : null;
+    if (fast2 && log === void 0 && !captureTl) {
+      return { end: fast2(input, cur), commit: NOOP_COMMIT };
     }
-    break;
-  }
-  if (d.tag !== "sequence" || d.parsers.length < 2) return null;
-  return d.parsers[0];
-}
-function computeAutoNot(parsers) {
-  return parsers.map((p, i) => {
-    const litVal = getCoreLiteralValue(p);
-    if (litVal === null) return null;
-    const checks = [];
-    for (let j = i + 1; j < parsers.length; j++) {
-      const other = parsers[j];
-      const otherLit = getCoreLiteralValue(other);
-      if (otherLit !== null && otherLit.startsWith(litVal) && otherLit.length > litVal.length) {
-        checks.push({ kind: "startsWith", value: otherLit.slice(litVal.length) });
-        continue;
-      }
-      const regexDef = getCoreRegexDef(other);
-      if (regexDef !== null) {
-        const contSet = continuationFirstSet(litVal, regexDef.source, regexDef.flags);
-        if (contSet !== null) checks.push({ kind: "firstSet", set: contSet });
-      }
+    if (ctx.triviaKindLabels && (log !== void 0 || rootLog !== void 0 || captureTl)) {
+      return scanWithLabels(input, cur, ctx);
     }
-    return checks.length > 0 ? checks : null;
-  });
-}
-function autoNotFires(input, end, checks) {
-  for (const check of checks) {
-    if (check.kind === "firstSet") {
-      const code = end < input.length ? input.codePointAt(end) ?? -1 : -1;
-      if (inFirstSet(code, check.set)) return true;
-    } else {
-      if (input.startsWith(check.value, end)) return true;
+    if (ctx.triviaKindLabels) return { end: skipWithLabels(input, cur, ctx), commit: NOOP_COMMIT };
+    if (log !== void 0 || rootLog !== void 0 || captureTl) {
+      const tr3 = triviaP.parse(input, cur, {
+        trackLines: log !== void 0 ? false : ctx.trackLines,
+        state: ctx.state
+      });
+      if (!tr3.ok || tr3.span.end === cur) return { end: cur, commit: NOOP_COMMIT };
+      const end = tr3.span.end;
+      return {
+        end,
+        commit: () => {
+          pushTriviaLogEntry(ctx, cur, end);
+          if (captureTl) pushCstTriviaEntry(ctx, cur, end);
+        }
+      };
     }
+    const tr2 = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state });
+    return { end: tr2.ok ? tr2.span.end : cur, commit: NOOP_COMMIT };
   }
-  return false;
-}
-function getCoreLiteralValue(p) {
-  const def = p._def;
-  if (def.tag === "literal" && !def.caseInsensitive) return def.value;
-  if (def.tag === "transform") return getCoreLiteralValue(def.parser);
-  return null;
-}
-function getCoreRegexDef(p) {
-  const def = p._def;
-  if (def.tag === "regex") return { source: def.source, flags: def.flags };
-  if (def.tag === "transform") return getCoreRegexDef(def.parser);
-  if (def.tag === "label") return getCoreRegexDef(def.parser);
-  return null;
-}
-function applyTransforms(p, value, span) {
-  const def = p._def;
-  if (def.tag === "transform") {
-    const inner = applyTransforms(def.parser, value, span);
-    return def.fn(inner, span);
+  const trackTriviaLines = ctx.trackLines && triviaP._meta.canMatchNewline;
+  const fast = !ctx.triviaKindLabels ? fastTriviaScanner(triviaP) : null;
+  if (fast && log === void 0 && !captureTl) {
+    const end = fast(input, cur);
+    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, end);
+    return { end, commit: NOOP_COMMIT };
   }
-  return value;
-}
-function continuationFirstSet(lit, source, flags) {
-  const re = new RegExp(source, "y" + flags.replace(/[gy]/g, ""));
-  re.lastIndex = 0;
-  const base = re.exec(lit);
-  if (!base || base[0] !== lit) return null;
-  const contCodes = [];
-  for (let code = 1; code < 128; code++) {
-    re.lastIndex = 0;
-    const m = re.exec(lit + String.fromCharCode(code));
-    if (m && m[0].length > lit.length) contCodes.push(code);
+  if (ctx.triviaKindLabels && (log !== void 0 || rootLog !== void 0 || captureTl)) {
+    const scan = scanWithLabels(input, cur, ctx);
+    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, scan.end);
+    return scan;
   }
-  if (contCodes.length === 0) return null;
-  return codesToFirstSet(contCodes);
-}
-function codesToFirstSet(codes) {
-  codes.sort((a, b) => a - b);
-  const ranges = [];
-  let lo = codes[0], hi = codes[0];
-  for (let i = 1; i < codes.length; i++) {
-    if (codes[i] === hi + 1) {
-      hi = codes[i];
-    } else {
-      ranges.push({ lo, hi });
-      lo = hi = codes[i];
-    }
+  if (ctx.triviaKindLabels) {
+    const end = skipWithLabels(input, cur, ctx);
+    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, end);
+    return { end, commit: NOOP_COMMIT };
   }
-  ranges.push({ lo, hi });
-  return { kind: "ranges", ranges };
+  if (log !== void 0 || rootLog !== void 0 || captureTl) {
+    const tr2 = parseTriviaNoCapture(triviaP, input, cur, ctx);
+    if (!tr2.ok || tr2.span.end === cur) return { end: cur, commit: NOOP_COMMIT };
+    const end = tr2.span.end;
+    return {
+      end,
+      commit: () => {
+        pushTriviaLogEntry(ctx, cur, end);
+        if (captureTl) pushCstTriviaEntry(ctx, cur, end);
+      }
+    };
+  }
+  const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
+  return { end: tr.ok ? tr.span.end : cur, commit: NOOP_COMMIT };
 }
-function inFirstSet(code, fs2) {
-  if (fs2.kind === "any") return true;
-  if (fs2.kind === "empty") return false;
-  for (const r of fs2.ranges) if (code >= r.lo && code <= r.hi) return true;
-  return false;
+function consumeTrivia(input, cur, ctx) {
+  if (!needsDeferredTriviaCommit(ctx)) return advanceTrivia(input, cur, ctx);
+  const scan = scanTrivia(input, cur, ctx);
+  scan.commit();
+  return scan.end;
 }
-function areDisjoint(sets) {
-  if (sets.some((s) => s.kind === "any")) return false;
-  for (let i = 0; i < sets.length; i++)
-    for (let j = i + 1; j < sets.length; j++)
-      if (intersects(sets[i], sets[j])) return false;
-  return true;
+function fastTriviaScanner(trivia2) {
+  const cached = fastTriviaCache.get(trivia2);
+  if (cached !== void 0) return cached;
+  const scanner = buildFastTriviaScanner(trivia2);
+  fastTriviaCache.set(trivia2, scanner);
+  return scanner;
 }
-function buildAsciiDispatch(parsers) {
-  const table = Array(128).fill(-1);
-  for (let i = 0; i < parsers.length; i++) {
-    const fs2 = parsers[i]._meta.firstSet;
-    if (fs2.kind !== "ranges") continue;
-    for (const { lo, hi } of fs2.ranges) {
-      for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) {
-        table[code] = i;
+function buildFastTriviaScanner(trivia2) {
+  const core = trivia2._def.tag === "trivia" ? trivia2._def.parser : trivia2;
+  const direct = regexTriviaScanner(core);
+  if (direct) return direct;
+  const repeat = core._def.tag === "oneOrMore" || core._def.tag === "many" && core._def.min >= 1 ? core._def.parser : null;
+  if (!repeat) return null;
+  const one = regexTriviaScanner(repeat);
+  if (one) return loopScanner([one]);
+  if (repeat._def.tag !== "choice") return null;
+  const arms = repeat._def.parsers.map(regexTriviaScanner);
+  if (arms.some((s) => s === null)) return null;
+  return loopScanner(arms);
+}
+function loopScanner(arms) {
+  return (input, cur) => {
+    let pos = cur;
+    scan: while (pos < input.length) {
+      for (const arm of arms) {
+        const end = arm(input, pos);
+        if (end > pos) {
+          pos = end;
+          continue scan;
+        }
       }
+      break;
     }
-  }
-  return table;
-}
-
-// src/cst/trivia-kinds.ts
-function unwrapTrivia(p) {
-  let cur = p;
-  while (cur._def.tag === "trivia") cur = cur._def.parser;
-  return cur;
+    return pos;
+  };
 }
-function peelLabel(p) {
-  if (p._def.tag === "label") return { label: p._def.label, parser: p._def.parser };
-  return null;
+function regexTriviaScanner(parser2) {
+  if (parser2._def.tag !== "regex" || parser2._def.flags) return null;
+  const source = parser2._def.source;
+  return classRunSource(source) ?? altStarSource(source);
 }
-function analyzeLabeledTrivia(trivia2) {
-  let core = unwrapTrivia(trivia2);
-  let minRepeats = 1;
-  if (core._def.tag === "oneOrMore") {
-    core = core._def.parser;
-    minRepeats = 1;
-  } else if (core._def.tag === "many") {
-    core = core._def.parser;
-    minRepeats = 0;
-  }
-  const arms = [];
-  if (core._def.tag === "choice") {
-    for (let i = 0; i < core._def.parsers.length; i++) {
-      const peeled = peelLabel(core._def.parsers[i]);
-      if (!peeled) return null;
-      arms.push({ label: peeled.label, kindIndex: i, parser: peeled.parser });
-    }
-  } else {
-    const peeled = peelLabel(core);
-    if (!peeled) return null;
-    arms.push({ label: peeled.label, kindIndex: 0, parser: peeled.parser });
+function inRanges2(cp, ranges) {
+  for (let i = 0; i < ranges.length; i++) {
+    const r = ranges[i];
+    if (cp >= r[0] && cp <= r[1]) return true;
   }
-  return { labels: arms.map((a) => a.label), arms, minRepeats };
+  return false;
 }
-function matchArmAt(input, pos, arm) {
-  const r = arm.parse(input, pos, { trackLines: false });
-  if (!r.ok || r.span.end <= pos) return null;
-  return { end: r.span.end };
+function classScanner(classBody) {
+  const ranges = parseClassRanges(classBody);
+  if (!ranges) return null;
+  return (input, cur) => {
+    let pos = cur;
+    while (pos < input.length && inRanges2(input.charCodeAt(pos), ranges)) pos++;
+    return pos;
+  };
 }
-function scanLabeledTriviaChunks(input, cur, spec) {
-  const chunks = [];
-  let pos = cur;
-  while (pos < input.length) {
-    let matched = null;
-    for (const arm of spec.arms) {
-      const m = matchArmAt(input, pos, arm.parser);
-      if (m) {
-        matched = { end: m.end, kindIndex: arm.kindIndex };
-        break;
-      }
+function untilLineBreakScanner(leaderCode) {
+  return (input, cur) => {
+    if (input.charCodeAt(cur) !== leaderCode) return cur;
+    let pos = cur + 1;
+    while (pos < input.length) {
+      const cc = input.charCodeAt(pos);
+      if (cc === 10 || cc === 13) break;
+      pos++;
     }
-    if (!matched) break;
-    chunks.push({ start: pos, end: matched.end, kindIndex: matched.kindIndex });
-    pos = matched.end;
+    return pos;
+  };
+}
+function classRunSource(source) {
+  const m = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]$/.exec(source);
+  return m ? classScanner(m[1]) : null;
+}
+function classifyTriviaArm(arm) {
+  const cls = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]?$/.exec(arm);
+  if (cls) {
+    const ranges = parseClassRanges(cls[1]);
+    return ranges ? { kind: "class", ranges } : null;
   }
-  if (chunks.length < spec.minRepeats) {
-    return { end: cur, chunks: [] };
+  const lc = /^(\\?.)\[\^\\n\\r\]\*$/.exec(arm);
+  if (lc) {
+    const marker = lc[1];
+    return { kind: "untilLineBreak", code: (marker.length === 2 ? marker[1] : marker[0]).charCodeAt(0) };
   }
-  return { end: pos, chunks };
+  return null;
 }
-function scanFastWsCommentsChunks(input, cur, wsKind, commentKind) {
-  const chunks = [];
-  let pos = cur;
-  while (pos < input.length) {
-    const c = input.charCodeAt(pos);
-    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) {
-      const start = pos;
-      pos++;
-      while (pos < input.length) {
-        const c2 = input.charCodeAt(pos);
-        if (c2 === 32 || c2 === 9 || c2 === 10 || c2 === 13 || c2 === 12) pos++;
-        else break;
-      }
-      chunks.push({ start, end: pos, kindIndex: wsKind });
-      continue;
-    }
-    if (c === 47 && input.charCodeAt(pos + 1) === 42) {
-      let j = pos + 2;
-      while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++;
-      if (j + 1 < input.length && input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47) {
-        const start = pos;
-        pos = j + 2;
-        chunks.push({ start, end: pos, kindIndex: commentKind });
+function armScanner(arm) {
+  if (arm.kind === "untilLineBreak") return untilLineBreakScanner(arm.code);
+  const ranges = arm.ranges;
+  return (input, cur) => {
+    let pos = cur;
+    while (pos < input.length && inRanges2(input.charCodeAt(pos), ranges)) pos++;
+    return pos;
+  };
+}
+function fusedTriviaScanner(ranges, leaders) {
+  const c0 = leaders[0];
+  const single = leaders.length === 1;
+  return (input, cur) => {
+    let pos = cur;
+    const len = input.length;
+    for (; ; ) {
+      const c = input.charCodeAt(pos);
+      if (pos < len && inRanges2(c, ranges)) {
+        pos++;
+        continue;
+      }
+      if (single ? c === c0 : leaders.includes(c)) {
+        pos++;
+        while (pos < len) {
+          const cc = input.charCodeAt(pos);
+          if (cc === 10 || cc === 13) break;
+          pos++;
+        }
         continue;
       }
       break;
     }
-    break;
-  }
-  return { end: pos, chunks };
-}
-function tryFastLabeledScan(input, cur, trivia2) {
-  const spec = analyzeLabeledTrivia(trivia2);
-  if (!spec || spec.arms.length !== 2) return null;
-  const wsArm = spec.arms.find((a) => {
-    const src = getCoreRegexDef(a.parser)?.source;
-    return src != null && !src.includes("\\*");
-  });
-  const commentArm = spec.arms.find((a) => {
-    const src = getCoreRegexDef(a.parser)?.source;
-    return src != null && src.includes("\\*");
-  });
-  if (!wsArm || !commentArm) return null;
-  const { chunks } = scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex);
-  if (chunks.length < spec.minRepeats) return { end: cur, chunks: [] };
-  return scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex);
+    return pos;
+  };
 }
-function recordTriviaChunks(ctx, chunks) {
-  const kinds = ctx.triviaKindLabels;
-  const mask = ctx._triviaCaptureMask;
-  for (const ch2 of chunks) {
-    pushTriviaLogEntry(ctx, ch2.start, ch2.end, kinds ? ch2.kindIndex : void 0);
-    if (ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0)) {
-      if (mask === void 0 || kinds === void 0 || (mask & 1 << ch2.kindIndex) !== 0) {
-        pushCstTriviaEntry(ctx, ch2.start, ch2.end, kinds ? ch2.kindIndex : void 0);
-      }
+function splitTopLevelAlts(body) {
+  const arms = [];
+  let inClass = false;
+  let start = 0;
+  for (let i = 0; i < body.length; i++) {
+    const c = body[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (inClass) {
+      if (c === "]") inClass = false;
+      continue;
+    }
+    if (c === "[") inClass = true;
+    else if (c === "(") return null;
+    else if (c === "|") {
+      arms.push(body.slice(start, i));
+      start = i + 1;
     }
   }
+  arms.push(body.slice(start));
+  return arms;
 }
-function triviaKindMask(labels, keep) {
-  if (!labels) return void 0;
-  let mask = 0;
-  for (const name of keep) {
-    const idx = labels.indexOf(name);
-    if (idx >= 0) mask |= 1 << idx;
+function altStarSource(source) {
+  const m = /^\(\?:(.*)\)[*+]$/.exec(source);
+  if (!m) return null;
+  const armSrcs = splitTopLevelAlts(m[1]);
+  if (!armSrcs || armSrcs.length < 2) return null;
+  const arms = [];
+  for (const src of armSrcs) {
+    const arm = classifyTriviaArm(src);
+    if (!arm) return null;
+    arms.push(arm);
   }
-  return mask;
+  const ranges = [];
+  const leaders = [];
+  for (const arm of arms) {
+    if (arm.kind === "class") ranges.push(...arm.ranges);
+    else leaders.push(arm.code);
+  }
+  if (leaders.some((code) => inRanges2(code, ranges))) {
+    return loopScanner(arms.map(armScanner));
+  }
+  if (leaders.length === 0) return armScanner({ kind: "class", ranges });
+  return fusedTriviaScanner(ranges, leaders);
 }
 
-// src/combinators/trivia-skip.ts
-var NOOP_COMMIT = () => {
-};
-var fastTriviaCache = /* @__PURE__ */ new WeakMap();
-function needsDeferredTriviaCommit(ctx) {
-  return ctx._triviaLog !== void 0 || ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0;
-}
-function saveTriviaMark(ctx) {
-  const m = saveCstMark(ctx);
-  return { raw: m.raw, tlog: m.tlog, leaves: m.leaves, fields: m.fields, errors: m.errors, log: ctx._triviaLog ? ctx._triviaLog.length : 0 };
-}
-function rollbackTrivia(ctx, mark) {
-  rollbackCstCapture(ctx, { raw: mark.raw, tlog: mark.tlog, leaves: mark.leaves, fields: mark.fields, errors: mark.errors });
-  if (ctx._triviaLog && ctx._triviaLog.length !== mark.log) ctx._triviaLog.length = mark.log;
-}
-function parseTriviaNoCapture(triviaP, input, cur, ctx) {
-  const probeCtx = {
-    trackLines: ctx.trackLines,
-    state: ctx.state,
-    ...ctx._lineIndex ? { _lineIndex: ctx._lineIndex } : {},
-    ...ctx._lineStarts ? { _lineStarts: ctx._lineStarts } : {},
-    ...ctx._lineScannedTo !== void 0 ? { _lineScannedTo: ctx._lineScannedTo } : {}
+// src/recovery/scan.ts
+function probeAt(sentinel, input, pos, ctx) {
+  const s = {
+    _probe: ctx._probe,
+    _errors: ctx._errors,
+    _cstLeaves: ctx._cstLeaves,
+    _cstChildren: ctx._cstChildren,
+    _cstRawChildren: ctx._cstRawChildren,
+    _cstTriviaLog: ctx._cstTriviaLog,
+    _triviaLog: ctx._triviaLog,
+    _rootTriviaLog: ctx._rootTriviaLog,
+    _fields: ctx._fields,
+    _cstBuf: ctx._cstBuf,
+    _tolerant: ctx._tolerant,
+    _sync: ctx._sync
   };
-  const result = triviaP.parse(input, cur, probeCtx);
-  ctx._lineScannedTo = probeCtx._lineScannedTo;
-  return result;
-}
-function saveLookaheadMark(ctx) {
-  return { ...saveTriviaMark(ctx), probeBest: ctx._probe ? ctx._probe.best : null };
-}
-function rollbackLookahead(ctx, mark) {
-  rollbackTrivia(ctx, mark);
-  if (ctx._probe) ctx._probe.best = mark.probeBest;
+  ctx._probe = void 0;
+  ctx._errors = void 0;
+  ctx._cstLeaves = void 0;
+  ctx._cstChildren = void 0;
+  ctx._cstRawChildren = void 0;
+  ctx._cstTriviaLog = void 0;
+  ctx._triviaLog = void 0;
+  ctx._rootTriviaLog = void 0;
+  ctx._fields = void 0;
+  ctx._cstBuf = void 0;
+  ctx._tolerant = void 0;
+  ctx._sync = void 0;
+  try {
+    return sentinel.parse(input, pos, ctx).ok;
+  } finally {
+    ctx._probe = s._probe;
+    ctx._errors = s._errors;
+    ctx._cstLeaves = s._cstLeaves;
+    ctx._cstChildren = s._cstChildren;
+    ctx._cstRawChildren = s._cstRawChildren;
+    ctx._cstTriviaLog = s._cstTriviaLog;
+    ctx._triviaLog = s._triviaLog;
+    ctx._rootTriviaLog = s._rootTriviaLog;
+    ctx._fields = s._fields;
+    ctx._cstBuf = s._cstBuf;
+    ctx._tolerant = s._tolerant;
+    ctx._sync = s._sync;
+  }
 }
-function scanWithLabels(input, cur, ctx) {
-  const triviaP = ctx.trivia;
-  const spec = analyzeLabeledTrivia(triviaP);
-  if (!spec) return { end: cur, commit: NOOP_COMMIT };
-  const fast = tryFastLabeledScan(input, cur, triviaP);
-  const { end, chunks } = fast ?? scanLabeledTriviaChunks(input, cur, spec);
-  if (end === cur) return { end: cur, commit: NOOP_COMMIT };
+function orSentinel(a, b) {
+  if (b === void 0) return a;
   return {
-    end,
-    commit: () => recordTriviaChunks(ctx, chunks)
-  };
-}
-function advanceTrivia(input, cur, ctx) {
-  const triviaP = ctx.trivia;
-  if (!triviaP) return cur;
-  if (!ctx.trackLines) {
-    const fast2 = fastTriviaScanner(triviaP);
-    if (fast2) return fast2(input, cur);
-    if (ctx.triviaKindLabels) {
-      const scan = scanWithLabels(input, cur, ctx);
-      return scan.end;
+    _tag: "orSentinel",
+    _meta: { firstSet: { kind: "any" }, canMatchNewline: false, isTrivia: false },
+    _def: { tag: "unknown" },
+    parse(input, pos, ctx) {
+      const ra = a.parse(input, pos, ctx);
+      if (ra.ok) return ra;
+      return b.parse(input, pos, ctx);
     }
-    const tr2 = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state });
-    return tr2.ok && tr2.span.end > cur ? tr2.span.end : cur;
-  }
-  const trackTriviaLines = ctx.trackLines && triviaP._meta.canMatchNewline;
-  const fast = fastTriviaScanner(triviaP);
-  if (fast) {
-    const end = fast(input, cur);
-    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, end);
-    return end;
-  }
-  if (ctx.triviaKindLabels) {
-    const scan = scanWithLabels(input, cur, ctx);
-    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, scan.end);
-    return scan.end;
-  }
-  const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
-  return tr.ok && tr.span.end > cur ? tr.span.end : cur;
+  };
 }
-function scanTrivia(input, cur, ctx) {
-  const triviaP = ctx.trivia;
-  if (!triviaP) return { end: cur, commit: NOOP_COMMIT };
-  const log = ctx._triviaLog;
-  const captureTl = ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0);
-  if (!ctx.trackLines) {
-    const fast2 = !ctx.triviaKindLabels ? fastTriviaScanner(triviaP) : null;
-    if (fast2 && log === void 0 && !captureTl) {
-      return { end: fast2(input, cur), commit: NOOP_COMMIT };
-    }
-    if (ctx.triviaKindLabels && (log !== void 0 || captureTl)) {
-      return scanWithLabels(input, cur, ctx);
-    }
-    if (log !== void 0 || captureTl) {
-      const tr3 = triviaP.parse(input, cur, {
-        trackLines: log !== void 0 ? false : ctx.trackLines,
-        state: ctx.state
-      });
-      if (!tr3.ok || tr3.span.end === cur) return { end: cur, commit: NOOP_COMMIT };
-      const end = tr3.span.end;
-      return {
-        end,
-        commit: () => {
-          pushTriviaLogEntry(ctx, cur, end);
-          if (captureTl) pushCstTriviaEntry(ctx, cur, end);
+function firstSetSentinel(fs2) {
+  if (fs2.kind !== "ranges" || fs2.ranges.length === 0) return null;
+  const ranges = fs2.ranges;
+  return {
+    _tag: "firstSetSentinel",
+    _meta: { firstSet: fs2, canMatchNewline: false, isTrivia: false },
+    _def: { tag: "unknown" },
+    parse(input, pos) {
+      const code = pos < input.length ? input.codePointAt(pos) : void 0;
+      if (code !== void 0) {
+        for (const r of ranges) {
+          if (code >= r.lo && code <= r.hi) return { ok: true, value: null, span: { start: pos, end: pos } };
         }
-      };
+      }
+      return { ok: false, expected: [], span: { start: pos, end: pos } };
     }
-    const tr2 = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state });
-    return { end: tr2.ok ? tr2.span.end : cur, commit: NOOP_COMMIT };
-  }
-  const trackTriviaLines = ctx.trackLines && triviaP._meta.canMatchNewline;
-  const fast = !ctx.triviaKindLabels ? fastTriviaScanner(triviaP) : null;
-  if (fast && log === void 0 && !captureTl) {
-    const end = fast(input, cur);
-    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, end);
-    return { end, commit: NOOP_COMMIT };
-  }
-  if (ctx.triviaKindLabels && (log !== void 0 || captureTl)) {
-    const scan = scanWithLabels(input, cur, ctx);
-    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, scan.end);
-    return scan;
-  }
-  if (log !== void 0 || captureTl) {
-    const tr2 = parseTriviaNoCapture(triviaP, input, cur, ctx);
-    if (!tr2.ok || tr2.span.end === cur) return { end: cur, commit: NOOP_COMMIT };
-    const end = tr2.span.end;
-    return {
-      end,
-      commit: () => {
-        pushTriviaLogEntry(ctx, cur, end);
-        if (captureTl) pushCstTriviaEntry(ctx, cur, end);
+  };
+}
+function recoverScan(input, from, ctx, sync, expected) {
+  let scanPos = from;
+  while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++;
+  const span = { start: from, end: scanPos };
+  if (ctx.trackLines) recordLineRangeFromContext(ctx, input, from, scanPos);
+  const error = { _tag: "parseError", span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected };
+  ctx._errors?.push(error);
+  return { error, end: scanPos };
+}
+function matchesAt(sentinel, input, pos, ctx) {
+  return probeAt(sentinel, input, pos, ctx);
+}
+function captureError(ctx, error) {
+  if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error);
+}
+
+// src/combinators/sequence.ts
+function sequence(...parsers) {
+  const meta = {
+    // Union through the nullable prefix — a leading optional()/many() lets a later
+    // term's first char start the sequence. Just `parsers[0]` under-approximates.
+    firstSet: sequenceFirstSet(parsers),
+    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
+    isTrivia: false
+  };
+  const def = { tag: "sequence", parsers };
+  let followSentinels;
+  function parseTolerant(input, pos, ctx) {
+    followSentinels ??= parsers.map((_, i) => {
+      const fs2 = parsers.slice(i + 1).reduce(
+        (acc, p) => union(acc, firstSetOf(p)),
+        { kind: "empty" }
+      );
+      return firstSetSentinel(fs2);
+    });
+    const values = def.valueUnused ? void 0 : [];
+    let cur = pos;
+    const inheritedSync = ctx._sync;
+    try {
+      for (let i = 0; i < parsers.length; i++) {
+        ctx._sync = followSentinels[i] ?? inheritedSync;
+        if (ctx.trivia && i > 0) {
+          const mark = saveTriviaMark(ctx);
+          let scanEnd;
+          if (needsDeferredTriviaCommit(ctx)) {
+            const scan = scanTrivia(input, cur, ctx);
+            scan.commit();
+            scanEnd = scan.end;
+          } else {
+            scanEnd = advanceTrivia(input, cur, ctx);
+          }
+          const result2 = parsers[i].parse(input, scanEnd, ctx);
+          if (!result2.ok) return result2;
+          if (result2.span.end > scanEnd) cur = result2.span.end;
+          else rollbackTrivia(ctx, mark);
+          if (values !== void 0) values.push(result2.value);
+          continue;
+        }
+        const result = parsers[i].parse(input, cur, ctx);
+        if (!result.ok) return result;
+        if (values !== void 0) values.push(result.value);
+        cur = result.span.end;
       }
+    } finally {
+      ctx._sync = inheritedSync;
+    }
+    return {
+      ok: true,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      value: values ?? void 0,
+      span: { start: pos, end: cur }
     };
   }
-  const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
-  return { end: tr.ok ? tr.span.end : cur, commit: NOOP_COMMIT };
+  return {
+    _tag: "sequence",
+    _meta: meta,
+    _def: def,
+    parse(input, pos, ctx) {
+      if (ctx._tolerant) return parseTolerant(input, pos, ctx);
+      const values = def.valueUnused ? void 0 : [];
+      let cur = pos;
+      for (let i = 0; i < parsers.length; i++) {
+        if (ctx.trivia && i > 0) {
+          let scanEnd;
+          let mark = saveTriviaMark(ctx);
+          if (needsDeferredTriviaCommit(ctx)) {
+            const scan = scanTrivia(input, cur, ctx);
+            scan.commit();
+            scanEnd = scan.end;
+          } else {
+            scanEnd = advanceTrivia(input, cur, ctx);
+          }
+          const result2 = parsers[i].parse(input, scanEnd, ctx);
+          if (!result2.ok) return result2;
+          if (result2.span.end > scanEnd) {
+            cur = result2.span.end;
+          } else {
+            rollbackTrivia(ctx, mark);
+          }
+          if (values !== void 0) values.push(result2.value);
+          continue;
+        }
+        const result = parsers[i].parse(input, cur, ctx);
+        if (!result.ok) return result;
+        if (values !== void 0) values.push(result.value);
+        cur = result.span.end;
+      }
+      return {
+        ok: true,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        value: values ?? void 0,
+        span: { start: pos, end: cur }
+      };
+    }
+  };
 }
-function consumeTrivia(input, cur, ctx) {
-  if (!needsDeferredTriviaCommit(ctx)) return advanceTrivia(input, cur, ctx);
-  const scan = scanTrivia(input, cur, ctx);
-  scan.commit();
-  return scan.end;
+
+// src/combinators/expect.ts
+function deriveExpected(c) {
+  return [...new Set(derive(c, /* @__PURE__ */ new Set()))];
 }
-function fastTriviaScanner(trivia2) {
-  const cached = fastTriviaCache.get(trivia2);
-  if (cached !== void 0) return cached;
-  const scanner = buildFastTriviaScanner(trivia2);
-  fastTriviaCache.set(trivia2, scanner);
-  return scanner;
+function derive(c, seen) {
+  const deriveExpected2 = (p) => derive(p, seen);
+  const def = c._def;
+  switch (def.tag) {
+    case "literal":
+      return [JSON.stringify(def.value)];
+    case "regex":
+      return [`/${def.source}/`];
+    case "keywords":
+      return def.words.map((w) => JSON.stringify(w));
+    case "label":
+      return [def.label];
+    case "choice":
+      return def.parsers.flatMap(deriveExpected2);
+    case "dispatch":
+      return deriveExpected2(def.selector);
+    // Union through the NULLABLE prefix, mirroring `sequenceFirstSet`. A leading
+    // `optional(…)`/`many(…)` can match nothing, so the term after it is equally
+    // able to fail first — deriving from term 0 alone named a token the parse
+    // never actually required. A leading `not(…)` is zero-width and contributes
+    // nothing (its own expectation is about what must NOT be here), but it is
+    // nullable, so keep scanning past it. Stop at the first term that must match.
+    case "sequence": {
+      const out = [];
+      for (const term of def.parsers) {
+        if (!isZeroWidthAssertion(term)) out.push(...deriveExpected2(term));
+        if (!matchesEmpty(term)) break;
+      }
+      return out;
+    }
+    case "attempt":
+      return deriveExpected2(def.parser);
+    // Delegating wrappers whose first-token failure is their inner parser's — must
+    // pass through so a start-failure (and the first-set-miss fast-path in attempt/
+    // node, which reads this) names the real expected token, not the wrapper tag.
+    case "field":
+    case "withCtx":
+    case "recover":
+      return deriveExpected2(def.parser);
+    case "skip":
+      return deriveExpected2(def.main);
+    case "expect":
+      return def.expected;
+    case "node":
+    case "grammar":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "transform":
+    case "not":
+    case "peek":
+      return deriveExpected2(def.parser);
+    case "routed":
+      return ["routed()"];
+    case "lazy": {
+      const name = c._ruleName;
+      if (seen.has(c)) return name ? [name] : [];
+      seen.add(c);
+      try {
+        return deriveExpected2(def.thunk());
+      } catch {
+        return name ? [name] : [];
+      } finally {
+        seen.delete(c);
+      }
+    }
+    default:
+      return [];
+  }
 }
-function buildFastTriviaScanner(trivia2) {
-  const core = trivia2._def.tag === "trivia" ? trivia2._def.parser : trivia2;
-  const direct = regexTriviaScanner(core);
-  if (direct) return direct;
-  const repeat = core._def.tag === "oneOrMore" || core._def.tag === "many" && core._def.min >= 1 ? core._def.parser : null;
-  if (!repeat) return null;
-  const one = regexTriviaScanner(repeat);
-  if (one) return loopScanner([one]);
-  if (repeat._def.tag !== "choice") return null;
-  const arms = repeat._def.parsers.map(regexTriviaScanner);
-  if (arms.some((s) => s === null)) return null;
-  return loopScanner(arms);
+function expect(combinator, label2) {
+  const expected = label2 !== void 0 ? [label2] : deriveExpected(combinator);
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "expect",
+    _meta: meta,
+    _def: { tag: "expect", parser: combinator, label: label2, expected },
+    parse(input, pos, ctx) {
+      const result = combinator.parse(input, pos, ctx);
+      if (result.ok) return result;
+      const span = { start: pos, end: pos };
+      const error = { _tag: "parseError", span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected };
+      ctx._errors?.push(error);
+      if (ctx._tolerant) captureError(ctx, error);
+      return { ok: true, value: error, span: { start: pos, end: pos } };
+    }
+  };
 }
-function loopScanner(arms) {
-  return (input, cur) => {
-    let pos = cur;
-    scan: while (pos < input.length) {
-      for (const arm of arms) {
-        const end = arm(input, pos);
-        if (end > pos) {
-          pos = end;
-          continue scan;
+
+// src/combinators/choice.ts
+function choice(...args) {
+  const parsers = args.map((a) => "gate" in a ? a.combinator : a);
+  const gates = args.map((a) => "gate" in a ? a.gate : null);
+  const hasGates = gates.some((g) => g !== null);
+  const disjoint = areDisjoint(parsers.map((p) => p._meta.firstSet)) && parsers.every((p) => !matchesEmpty(p));
+  let combined = { kind: "empty" };
+  for (const p of parsers) combined = union(combined, p._meta.firstSet);
+  const meta = {
+    firstSet: combined,
+    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
+    isTrivia: false,
+    disjoint
+  };
+  const strategy = disjoint || hasGates ? null : detectStrategy(parsers);
+  const autoNot = !disjoint && !hasGates && (strategy?.tag === "firstMatch" || strategy?.tag === "sharedPrefix") ? computeAutoNot(parsers) : parsers.map(() => null);
+  let greedyLitMap = null;
+  let sortedParsers = null;
+  const asciiDispatch = disjoint ? buildAsciiDispatch(parsers) : null;
+  if (strategy?.tag === "greedyClassify") {
+    greedyLitMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < parsers.length; i++) {
+      if (i === strategy.superIndex) continue;
+      const litVal = getCoreLiteralValue(parsers[i]);
+      if (litVal !== null) greedyLitMap.set(litVal, i);
+    }
+  } else if (strategy?.tag === "literalsLongestFirst") {
+    sortedParsers = strategy.sortedIndices.map((i) => parsers[i]);
+  }
+  return {
+    _tag: "choice",
+    _meta: meta,
+    _def: {
+      tag: "choice",
+      parsers,
+      gates,
+      disjoint,
+      strategy: strategy ?? { tag: "firstMatch" },
+      autoNot
+    },
+    parse(input, pos, ctx) {
+      const expected = [];
+      if (disjoint && pos < input.length) {
+        const code = input.codePointAt(pos);
+        let idx = code < 128 ? asciiDispatch[code] : -1;
+        if (idx < 0) {
+          for (let i = 0; i < parsers.length; i++) {
+            if (inFirstSet(code, parsers[i]._meta.firstSet)) {
+              idx = i;
+              break;
+            }
+          }
+        }
+        if (idx >= 0) {
+          const gate2 = gates[idx];
+          if (gate2 && !gate2(ctx.state)) {
+            return { ok: false, expected: deriveExpected(parsers[idx]), span: { start: pos, end: pos } };
+          }
+          const result = parsers[idx].parse(input, pos, ctx);
+          if (result.ok) return result;
+          expected.push(...result.expected);
+          if (result.committed) return { ok: false, expected, span: { start: pos, end: pos }, committed: true };
+          return { ok: false, expected, span: { start: pos, end: pos } };
+        }
+        return {
+          ok: false,
+          expected: parsers.flatMap((p) => {
+            const r = p.parse(input, pos, ctx);
+            return r.ok ? [] : r.expected;
+          }),
+          span: { start: pos, end: pos }
+        };
+      }
+      if (strategy?.tag === "greedyClassify") {
+        const superResult = parsers[strategy.superIndex].parse(input, pos, ctx);
+        if (!superResult.ok) return superResult;
+        const end = superResult.span.end;
+        const litIdx = greedyLitMap.get(input.slice(pos, end));
+        if (litIdx !== void 0) {
+          const litVal = getCoreLiteralValue(parsers[litIdx]);
+          const value = applyTransforms(parsers[litIdx], litVal, { start: pos, end });
+          return { ok: true, value, span: { start: pos, end } };
+        }
+        return superResult;
+      }
+      if (strategy?.tag === "literalsLongestFirst") {
+        for (const p of sortedParsers) {
+          const r = p.parse(input, pos, ctx);
+          if (r.ok) return r;
+          expected.push(...r.expected);
         }
+        return { ok: false, expected, span: { start: pos, end: pos } };
       }
-      break;
+      for (let i = 0; i < parsers.length; i++) {
+        if (gates[i] && !gates[i](ctx.state)) continue;
+        const mark = saveTriviaMark(ctx);
+        const result = parsers[i].parse(input, pos, ctx);
+        if (!result.ok) {
+          rollbackTrivia(ctx, mark);
+          expected.push(...result.expected);
+          if (result.committed) return { ok: false, expected, span: result.span, committed: true };
+          continue;
+        }
+        const checks = autoNot[i];
+        if (checks && autoNotFires(input, result.span.end, checks)) {
+          rollbackTrivia(ctx, mark);
+          continue;
+        }
+        return result;
+      }
+      return { ok: false, expected, span: { start: pos, end: pos } };
     }
-    return pos;
   };
 }
-function regexTriviaScanner(parser2) {
-  if (parser2._def.tag !== "regex" || parser2._def.flags) return null;
-  const source = parser2._def.source;
-  return classRunSource(source) ?? altStarSource(source) ?? (blockCommentSource(source) ? scanBlockComment : null);
-}
-function inRanges2(cp, ranges) {
-  for (let i = 0; i < ranges.length; i++) {
-    const r = ranges[i];
-    if (cp >= r[0] && cp <= r[1]) return true;
+function detectStrategy(parsers) {
+  const regexIndices = [];
+  const literalIndices = [];
+  for (let i = 0; i < parsers.length; i++) {
+    if (getCoreRegexDef(parsers[i]) !== null) regexIndices.push(i);
+    else if (getCoreLiteralValue(parsers[i]) !== null) literalIndices.push(i);
   }
-  return false;
-}
-function classScanner(classBody) {
-  const ranges = parseClassRanges(classBody);
-  if (!ranges) return null;
-  return (input, cur) => {
-    let pos = cur;
-    while (pos < input.length && inRanges2(input.charCodeAt(pos), ranges)) pos++;
-    return pos;
-  };
-}
-function lineCommentScanner(commentCode) {
-  return (input, cur) => {
-    if (input.charCodeAt(cur) !== commentCode) return cur;
-    let pos = cur + 1;
-    while (pos < input.length) {
-      const cc = input.charCodeAt(pos);
-      if (cc === 10 || cc === 13) break;
-      pos++;
-    }
-    return pos;
-  };
-}
-function classRunSource(source) {
-  const m = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]$/.exec(source);
-  return m ? classScanner(m[1]) : null;
-}
-function classifyTriviaArm(arm) {
-  const cls = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]?$/.exec(arm);
-  if (cls) {
-    const ranges = parseClassRanges(cls[1]);
-    return ranges ? { kind: "class", ranges } : null;
+  if (regexIndices.length === 1 && literalIndices.length === parsers.length - 1 && literalIndices.length > 0) {
+    const superIndex = regexIndices[0];
+    const regexDef = getCoreRegexDef(parsers[superIndex]);
+    const flags = "y" + regexDef.flags.replace(/[gy]/g, "");
+    const re = new RegExp(regexDef.source, flags);
+    const allSubsumed = literalIndices.every((i) => {
+      const litVal = getCoreLiteralValue(parsers[i]);
+      re.lastIndex = 0;
+      const m = re.exec(litVal);
+      return m !== null && m[0] === litVal;
+    });
+    if (allSubsumed) return { tag: "greedyClassify", superIndex };
   }
-  const lc = /^(\\?.)\[\^\\n\\r\]\*$/.exec(arm);
-  if (lc) {
-    const marker = lc[1];
-    return { kind: "comment", code: (marker.length === 2 ? marker[1] : marker[0]).charCodeAt(0) };
+  if (parsers.length === literalIndices.length) {
+    const sortedIndices = [...literalIndices].sort(
+      (a, b) => getCoreLiteralValue(parsers[b]).length - getCoreLiteralValue(parsers[a]).length
+    );
+    return { tag: "literalsLongestFirst", sortedIndices };
   }
+  const shared = detectSharedPrefix(parsers);
+  if (shared !== null) return shared;
+  return { tag: "firstMatch" };
+}
+function bareLeadingTermKey(term) {
+  const d = term._def;
+  if (d.tag === "literal" && !d.caseInsensitive) return `L:${d.value}`;
+  if (d.tag === "regex") return `R:${d.source}\0${d.flags}`;
   return null;
 }
-function armScanner(arm) {
-  if (arm.kind === "comment") return lineCommentScanner(arm.code);
-  const ranges = arm.ranges;
-  return (input, cur) => {
-    let pos = cur;
-    while (pos < input.length && inRanges2(input.charCodeAt(pos), ranges)) pos++;
-    return pos;
-  };
+function detectSharedPrefix(parsers) {
+  if (parsers.length < 2) return null;
+  let key = null;
+  let prefix = null;
+  const members = [];
+  for (let i = 0; i < parsers.length; i++) {
+    const term0 = leadingTermOfArm(parsers[i]);
+    if (term0 === null) return null;
+    const k = bareLeadingTermKey(term0);
+    if (k === null) return null;
+    if (key === null) {
+      key = k;
+      prefix = term0;
+    } else if (k !== key) return null;
+    members.push(i);
+  }
+  if (prefix === null || members.length < 2) return null;
+  return { tag: "sharedPrefix", prefix, members };
 }
-function fusedTriviaScanner(ranges, commentCodes) {
-  const c0 = commentCodes[0];
-  const single = commentCodes.length === 1;
-  return (input, cur) => {
-    let pos = cur;
-    const len = input.length;
-    for (; ; ) {
-      const c = input.charCodeAt(pos);
-      if (pos < len && inRanges2(c, ranges)) {
-        pos++;
+function leadingTermOfArm(arm) {
+  let d = arm._def;
+  for (; ; ) {
+    if (d.tag === "node" || d.tag === "grammar" || d.tag === "transform" || d.tag === "label") {
+      d = d.parser._def;
+      continue;
+    }
+    break;
+  }
+  if (d.tag !== "sequence" || d.parsers.length < 2) return null;
+  return d.parsers[0];
+}
+function computeAutoNot(parsers) {
+  return parsers.map((p, i) => {
+    const litVal = getCoreLiteralValue(p);
+    if (litVal === null) return null;
+    const checks = [];
+    for (let j = i + 1; j < parsers.length; j++) {
+      const other = parsers[j];
+      const otherLit = getCoreLiteralValue(other);
+      if (otherLit !== null && otherLit.startsWith(litVal) && otherLit.length > litVal.length) {
+        checks.push({ kind: "startsWith", value: otherLit.slice(litVal.length) });
         continue;
       }
-      if (single ? c === c0 : commentCodes.includes(c)) {
-        pos++;
-        while (pos < len) {
-          const cc = input.charCodeAt(pos);
-          if (cc === 10 || cc === 13) break;
-          pos++;
-        }
-        continue;
+      const regexDef = getCoreRegexDef(other);
+      if (regexDef !== null) {
+        const contSet = continuationFirstSet(litVal, regexDef.source, regexDef.flags);
+        if (contSet !== null) checks.push({ kind: "firstSet", set: contSet });
       }
-      break;
     }
-    return pos;
-  };
+    return checks.length > 0 ? checks : null;
+  });
 }
-function splitTopLevelAlts(body) {
-  const arms = [];
-  let inClass = false;
-  let start = 0;
-  for (let i = 0; i < body.length; i++) {
-    const c = body[i];
-    if (c === "\\") {
-      i++;
-      continue;
-    }
-    if (inClass) {
-      if (c === "]") inClass = false;
-      continue;
-    }
-    if (c === "[") inClass = true;
-    else if (c === "(") return null;
-    else if (c === "|") {
-      arms.push(body.slice(start, i));
-      start = i + 1;
+function autoNotFires(input, end, checks) {
+  for (const check of checks) {
+    if (check.kind === "firstSet") {
+      const code = end < input.length ? input.codePointAt(end) ?? -1 : -1;
+      if (inFirstSet(code, check.set)) return true;
+    } else {
+      if (input.startsWith(check.value, end)) return true;
     }
   }
-  arms.push(body.slice(start));
-  return arms;
+  return false;
 }
-function altStarSource(source) {
-  const m = /^\(\?:(.*)\)[*+]$/.exec(source);
-  if (!m) return null;
-  const armSrcs = splitTopLevelAlts(m[1]);
-  if (!armSrcs || armSrcs.length < 2) return null;
-  const arms = [];
-  for (const src of armSrcs) {
-    const arm = classifyTriviaArm(src);
-    if (!arm) return null;
-    arms.push(arm);
+function getCoreLiteralValue(p) {
+  const def = p._def;
+  if (def.tag === "literal" && !def.caseInsensitive) return def.value;
+  if (def.tag === "transform") return getCoreLiteralValue(def.parser);
+  return null;
+}
+function getCoreRegexDef(p) {
+  const def = p._def;
+  if (def.tag === "regex") return { source: def.source, flags: def.flags };
+  if (def.tag === "transform") return getCoreRegexDef(def.parser);
+  if (def.tag === "label") return getCoreRegexDef(def.parser);
+  return null;
+}
+function applyTransforms(p, value, span) {
+  const def = p._def;
+  if (def.tag === "transform") {
+    const inner = applyTransforms(def.parser, value, span);
+    return def.fn(inner, span);
   }
-  const ranges = [];
-  const commentCodes = [];
-  for (const arm of arms) {
-    if (arm.kind === "class") ranges.push(...arm.ranges);
-    else commentCodes.push(arm.code);
+  return value;
+}
+function continuationFirstSet(lit, source, flags) {
+  const re = new RegExp(source, "y" + flags.replace(/[gy]/g, ""));
+  re.lastIndex = 0;
+  const base = re.exec(lit);
+  if (!base || base[0] !== lit) return null;
+  const contCodes = [];
+  for (let code = 1; code < 128; code++) {
+    re.lastIndex = 0;
+    const m = re.exec(lit + String.fromCharCode(code));
+    if (m && m[0].length > lit.length) contCodes.push(code);
   }
-  if (commentCodes.some((code) => inRanges2(code, ranges))) {
-    return loopScanner(arms.map(armScanner));
+  if (contCodes.length === 0) return null;
+  return codesToFirstSet(contCodes);
+}
+function codesToFirstSet(codes) {
+  codes.sort((a, b) => a - b);
+  const ranges = [];
+  let lo = codes[0], hi = codes[0];
+  for (let i = 1; i < codes.length; i++) {
+    if (codes[i] === hi + 1) {
+      hi = codes[i];
+    } else {
+      ranges.push({ lo, hi });
+      lo = hi = codes[i];
+    }
   }
-  if (commentCodes.length === 0) return armScanner({ kind: "class", ranges });
-  return fusedTriviaScanner(ranges, commentCodes);
+  ranges.push({ lo, hi });
+  return { kind: "ranges", ranges };
 }
-function blockCommentSource(source) {
-  return source === "\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/" || source === "\\/\\*[^]*?\\*\\/";
+function inFirstSet(code, fs2) {
+  if (fs2.kind === "any") return true;
+  if (fs2.kind === "empty") return false;
+  for (const r of fs2.ranges) if (code >= r.lo && code <= r.hi) return true;
+  return false;
 }
-function scanBlockComment(input, cur) {
-  if (input.charCodeAt(cur) !== 47 || input.charCodeAt(cur + 1) !== 42) return cur;
-  const close = input.indexOf("*/", cur + 2);
-  return close === -1 ? cur : close + 2;
+function areDisjoint(sets) {
+  if (sets.some((s) => s.kind === "any")) return false;
+  for (let i = 0; i < sets.length; i++)
+    for (let j = i + 1; j < sets.length; j++)
+      if (intersects(sets[i], sets[j])) return false;
+  return true;
 }
-
-// src/combinators/sequence.ts
-function sequence(...parsers) {
-  const meta = {
-    // Union through the nullable prefix — a leading optional()/many() lets a later
-    // term's first char start the sequence. Just `parsers[0]` under-approximates.
-    firstSet: sequenceFirstSet(parsers),
-    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
-    isTrivia: false
-  };
-  const def = { tag: "sequence", parsers };
-  let followSentinels;
-  function parseTolerant(input, pos, ctx) {
-    followSentinels ??= parsers.map((_, i) => {
-      const fs2 = parsers.slice(i + 1).reduce(
-        (acc, p) => union(acc, firstSetOf(p)),
-        { kind: "empty" }
-      );
-      return firstSetSentinel(fs2);
-    });
-    const values = def.valueUnused ? void 0 : [];
-    let cur = pos;
-    const inheritedSync = ctx._sync;
-    try {
-      for (let i = 0; i < parsers.length; i++) {
-        ctx._sync = followSentinels[i] ?? inheritedSync;
-        if (ctx.trivia && i > 0) {
-          const mark = saveTriviaMark(ctx);
-          let scanEnd;
-          if (needsDeferredTriviaCommit(ctx)) {
-            const scan = scanTrivia(input, cur, ctx);
-            scan.commit();
-            scanEnd = scan.end;
-          } else {
-            scanEnd = advanceTrivia(input, cur, ctx);
-          }
-          const result2 = parsers[i].parse(input, scanEnd, ctx);
-          if (!result2.ok) return result2;
-          if (result2.span.end > scanEnd) cur = result2.span.end;
-          else rollbackTrivia(ctx, mark);
-          if (values !== void 0) values.push(result2.value);
-          continue;
-        }
-        const result = parsers[i].parse(input, cur, ctx);
-        if (!result.ok) return result;
-        if (values !== void 0) values.push(result.value);
-        cur = result.span.end;
+function buildAsciiDispatch(parsers) {
+  const table = Array(128).fill(-1);
+  for (let i = 0; i < parsers.length; i++) {
+    const fs2 = parsers[i]._meta.firstSet;
+    if (fs2.kind !== "ranges") continue;
+    for (const { lo, hi } of fs2.ranges) {
+      for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) {
+        table[code] = i;
       }
-    } finally {
-      ctx._sync = inheritedSync;
     }
-    return {
-      ok: true,
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      value: values ?? void 0,
-      span: { start: pos, end: cur }
-    };
   }
-  return {
-    _tag: "sequence",
-    _meta: meta,
-    _def: def,
-    parse(input, pos, ctx) {
-      if (ctx._tolerant) return parseTolerant(input, pos, ctx);
-      const values = def.valueUnused ? void 0 : [];
-      let cur = pos;
-      for (let i = 0; i < parsers.length; i++) {
-        if (ctx.trivia && i > 0) {
-          let scanEnd;
-          let mark = saveTriviaMark(ctx);
-          if (needsDeferredTriviaCommit(ctx)) {
-            const scan = scanTrivia(input, cur, ctx);
-            scan.commit();
-            scanEnd = scan.end;
-          } else {
-            scanEnd = advanceTrivia(input, cur, ctx);
-          }
-          const result2 = parsers[i].parse(input, scanEnd, ctx);
-          if (!result2.ok) return result2;
-          if (result2.span.end > scanEnd) {
-            cur = result2.span.end;
-          } else {
-            rollbackTrivia(ctx, mark);
-          }
-          if (values !== void 0) values.push(result2.value);
-          continue;
-        }
-        const result = parsers[i].parse(input, cur, ctx);
-        if (!result.ok) return result;
-        if (values !== void 0) values.push(result.value);
-        cur = result.span.end;
-      }
-      return {
-        ok: true,
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        value: values ?? void 0,
-        span: { start: pos, end: cur }
-      };
-    }
-  };
+  return table;
 }
 
 // src/combinators/dispatch.ts
@@ -2390,10 +2454,12 @@ function attempt(parser2) {
       }
       const mark = saveCstMark(ctx);
       const log = ctx._triviaLog?.length;
+      const rootLog = ctx._rootTriviaLog?.length;
       const result = parser2.parse(input, pos, ctx);
       if (result.ok) return result;
       rollbackCstCapture(ctx, mark);
       if (log !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== log) ctx._triviaLog.length = log;
+      if (rootLog !== void 0 && ctx._rootTriviaLog && ctx._rootTriviaLog.length !== rootLog) ctx._rootTriviaLog.length = rootLog;
       if (result.committed) return result;
       return { ok: false, expected: result.expected, span: { start: pos, end: pos } };
     }
@@ -2797,18 +2863,37 @@ function createParseLineContext(input, pos) {
 }
 function parser(opts, root) {
   const clearTrivia = opts.trivia === null;
+  const opaqueRootCapture = opts.rootCapture === "opaque";
+  if (opaqueRootCapture && opts.trivia === void 0) {
+    throw new TypeError("parser({ rootCapture: 'opaque' }) requires an explicit trivia scope.");
+  }
   return {
     _tag: "grammar",
-    _meta: root._meta,
+    _meta: {
+      ...root._meta,
+      // Trivia classification describes this grammar's own active trivia
+      // scope. A directly nested grammar may have classified trivia of its
+      // own, but that must not advertise classification for this wrapper.
+      triviaKindLabels: void 0,
+      rootTriviaClassified: void 0,
+      ...opts.trivia?._meta?.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {},
+      ...opts.trivia?._meta?.rootTriviaClassified ? { rootTriviaClassified: true } : {}
+    },
     _def: {
       tag: "grammar",
       parser: root,
       triviaParser: clearTrivia ? void 0 : opts.trivia ?? void 0,
       clearTrivia,
+      ...opaqueRootCapture ? { rootCapture: "opaque" } : {},
       ...opts.captureTrivia ? { captureTrivia: true } : {},
       trackLines: opts.trackLines ?? false
     },
     parse(input, pos, _ctx) {
+      if (_ctx?._rootTriviaStrictScopes && opts.trivia !== void 0 && opts.trivia !== null && !opts.trivia._meta.rootTriviaClassified && !opaqueRootCapture) {
+        throw new TypeError(
+          "parser(): selected root trivia requires classifiedTrivia() for every local trivia scope, or rootCapture: 'opaque'."
+        );
+      }
       const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false;
       const lineContext = trackLines && _ctx?._lineIndex === void 0 && _ctx?._lineStarts === void 0 ? createParseLineContext(input, pos ?? 0) : void 0;
       const lineIndex = trackLines ? _ctx?._lineIndex ?? (_ctx?._lineStarts ? { lineStarts: _ctx._lineStarts } : lineContext.lineIndex) : void 0;
@@ -2831,7 +2916,11 @@ function parser(opts, root) {
         // labels (`_ctx.triviaKindLabels`), so captureTriviaKinds still applies when
         // trivia is inherited rather than re-declared here. No labels → undefined
         // (capture all).
-        ...opts.captureTriviaKinds && !clearTrivia ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) } : {}
+        ...opts.captureTriviaKinds && !clearTrivia ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) } : {},
+        // This is a property of the local trivia scope, not a post-parse filter:
+        // nested recognition can still skip its trivia, but selected root rows
+        // must never be written for an explicitly opaque region.
+        ...opaqueRootCapture ? { _rootTriviaCapture: false } : {}
       };
       const result = root.parse(input, pos ?? 0, ctx);
       if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
@@ -2845,6 +2934,123 @@ function noTrivia(root) {
   return parser({ trivia: null }, root);
 }
 
+// src/cst/reflection.ts
+var GRAMMAR_REFLECTION = /* @__PURE__ */ Symbol.for("parseman.grammarReflection");
+function childrenOf(def) {
+  switch (def.tag) {
+    case "sequence":
+    case "choice":
+      return def.parsers;
+    case "dispatch":
+      return [
+        def.selector,
+        ...def.cases.map((c) => c.parser),
+        ...def.matchers ? def.matchers.map((c) => c.parser) : [],
+        ...def.otherwise ? [def.otherwise] : []
+      ];
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "not":
+    case "peek":
+    case "node":
+    case "withCtx":
+    case "recover":
+    case "expect":
+      return [def.parser];
+    case "grammar":
+      return def.triviaParser ? [def.parser, def.triviaParser] : [def.parser];
+    case "sepBy":
+      return [def.parser, def.separator];
+    case "skip":
+      return [def.main, def.skipped];
+    case "scanTo":
+      return [def.sentinel, ...def.skip];
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "routed":
+    case "guard":
+    case "lazy":
+    case "unknown":
+      return [];
+  }
+}
+function addNode(out, def) {
+  if (def.type === void 0) return;
+  const existing = out.get(def.type);
+  if (existing === void 0) {
+    out.set(def.type, def.tags === void 0 ? [] : [...def.tags]);
+    return;
+  }
+  if (def.tags === void 0) return;
+  for (const tag of def.tags) {
+    if (!existing.includes(tag)) existing.push(tag);
+  }
+}
+function collectFromCombinator(parser2, out, seen, followLazy = true) {
+  if (seen.has(parser2)) return;
+  seen.add(parser2);
+  const def = parser2._def;
+  if (def.tag === "lazy") {
+    if (followLazy) {
+      try {
+        collectFromCombinator(def.thunk(), out, seen, followLazy);
+      } catch {
+      }
+    }
+    return;
+  }
+  if (def.tag === "node") addNode(out, def);
+  for (const child of childrenOf(def)) collectFromCombinator(child, out, seen, followLazy);
+}
+function collectGrammarReflection(ruleMap, opts) {
+  const byType = /* @__PURE__ */ new Map();
+  const followLazy = opts?.followLazy !== false;
+  for (const [, rule] of ruleMap) {
+    if (!followLazy && rule._def.tag === "lazy") {
+      try {
+        const resolved = rule._def.thunk();
+        if (resolved._def.tag !== "lazy") collectFromCombinator(resolved, byType, /* @__PURE__ */ new Set(), false);
+      } catch {
+      }
+      continue;
+    }
+    collectFromCombinator(rule, byType, /* @__PURE__ */ new Set(), followLazy);
+  }
+  return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
+}
+function mergeGrammarReflections(reflections) {
+  const byType = /* @__PURE__ */ new Map();
+  for (const reflection of reflections) {
+    for (const node2 of reflection.nodes) {
+      const tags = byType.get(node2.type);
+      if (tags === void 0) {
+        byType.set(node2.type, [...node2.tags]);
+        continue;
+      }
+      for (const tag of node2.tags) {
+        if (!tags.includes(tag)) tags.push(tag);
+      }
+    }
+  }
+  return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
+}
+function attachGrammarReflection(grammar, reflection) {
+  Object.defineProperty(grammar, GRAMMAR_REFLECTION, { value: reflection, enumerable: false, configurable: true });
+  return grammar;
+}
+function grammarReflectionSource(reflection) {
+  return `{ nodes: ${JSON.stringify(reflection.nodes)} }`;
+}
+
 // src/combinators/parser.ts
 var RULE_ORDER = "__parsemanRuleOrder";
 function tagRule(r, key) {
@@ -2943,6 +3149,7 @@ function rules(a, b) {
     enumerable: false,
     configurable: true
   });
+  attachGrammarReflection(cache, collectGrammarReflection(Object.keys(definitions).map((key) => [key, cache[key]])));
   return cache;
 }
 
@@ -3263,13 +3470,14 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   const collapse = opts?.collapse === true;
   const captureTrivia = opts?.captureTrivia === true;
   const trailingTrivia = opts?.trailingTrivia === true;
+  const tags = opts?.tags;
   if (unwrap && collapse) {
     throw new Error("node() options cannot set both unwrap and collapse");
   }
   if (project !== void 0 && (unwrap || collapse)) {
     throw new Error("node() options cannot combine project with unwrap or collapse");
   }
-  const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {} } : baseDef;
+  const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia || tags !== void 0 && tags.length > 0 ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {}, ...tags !== void 0 && tags.length > 0 ? { tags } : {} } : baseDef;
   const capturesTrivia = captureTrivia || trailingTrivia || (build ? buildReadsTrivia(def) : project === void 0);
   const clonesState = build ? buildReadsState(def) : project === void 0;
   const hasOwnFields = parserHasOwnFields(combinator);
@@ -3315,7 +3523,7 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
       const cstOutput = cstOutputHost(ctx.build);
       const span = ctx.trackLines ? annotateSpanFromLineContext(r.span, ctx) : r.span;
       const hostState = clonesState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
-      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : !build && project === void 0 && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState) : build(children2, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, st) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
+      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : !build && project === void 0 && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : build(children2, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
       const rawEntry = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
         pushCstChild(ctx, built, rawEntry);
@@ -3365,6 +3573,25 @@ function trivia(combinator) {
     parse: combinator.parse.bind(combinator)
   };
 }
+function classifiedTrivia(arms) {
+  const entries = Object.entries(arms);
+  if (entries.length === 0) {
+    throw new TypeError("classifiedTrivia() requires at least one named trivia arm.");
+  }
+  for (let i = 0; i < entries.length; i++) {
+    const [name, arm] = entries[i];
+    const first = arm._meta.firstSet;
+    if (matchesEmpty(arm) || first.kind !== "ranges" || first.ranges.length === 0) {
+      throw new TypeError(
+        `classifiedTrivia(): ${JSON.stringify(name)} must be non-nullable with a concrete finite first set.`
+      );
+    }
+  }
+  const labeledArms = entries.map(([name, arm]) => label(name, arm));
+  const result = trivia(oneOrMore(choice(...labeledArms)));
+  result._meta.rootTriviaClassified = true;
+  return result;
+}
 function label(name, combinator) {
   return {
     _tag: combinator._tag,
@@ -3411,6 +3638,7 @@ function token(root) {
       const savedRaw = ctx._cstRawChildren;
       const savedTriviaLog = ctx._cstTriviaLog;
       const savedOuterTriviaLog = ctx._triviaLog;
+      const savedRootTriviaLog = ctx._rootTriviaLog;
       const wasCapturing = cstCaptureActive(ctx);
       ctx.trivia = void 0;
       ctx.triviaKindLabels = void 0;
@@ -3420,6 +3648,7 @@ function token(root) {
       ctx._cstRawChildren = void 0;
       ctx._cstTriviaLog = void 0;
       delete ctx._triviaLog;
+      delete ctx._rootTriviaLog;
       let result;
       try {
         result = root.parse(input, pos, ctx);
@@ -3433,6 +3662,8 @@ function token(root) {
         ctx._cstTriviaLog = savedTriviaLog;
         if (savedOuterTriviaLog === void 0) delete ctx._triviaLog;
         else ctx._triviaLog = savedOuterTriviaLog;
+        if (savedRootTriviaLog === void 0) delete ctx._rootTriviaLog;
+        else ctx._rootTriviaLog = savedRootTriviaLog;
       }
       if (!result.ok) return result;
       const span = result.span;
@@ -3487,7 +3718,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.42.1";
+var PARSEMAN_VERSION = "0.44.0";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -3553,7 +3784,7 @@ var SUGGESTIONS = {
 function classifyBroadArm(arm, resolve2) {
   const seen = /* @__PURE__ */ new Set();
   const relabel = (inner, cause, detail) => ({ cause, detail, ...inner?.unresolvedExternal ? { unresolvedExternal: true } : {} });
-  const walk2 = (p) => {
+  const walk = (p) => {
     if (seen.has(p)) return { cause: "ref-cycle", detail: "ref cycle" };
     seen.add(p);
     const d = p._def;
@@ -3567,7 +3798,7 @@ function classifyBroadArm(arm, resolve2) {
       // peek() CARRIES its body's first-set, so it is only broad when the body is
       // (or the body is nullable) — walk in for the real cause.
       case "peek":
-        return walk2(d.parser);
+        return walk(d.parser);
       case "scanTo":
         return { cause: "broad-recognizer", detail: "scanTo (any first char)" };
       // `guard` (the `gate()` state predicate) has a genuinely-`any` first-set of
@@ -3581,7 +3812,7 @@ function classifyBroadArm(arm, resolve2) {
       case "attempt":
       case "withCtx":
       case "recover":
-        return walk2(d.parser);
+        return walk(d.parser);
       case "lazy": {
         const name = p._ruleName;
         let target;
@@ -3593,13 +3824,13 @@ function classifyBroadArm(arm, resolve2) {
             return { cause: "cross-artifact-ref", detail: `unresolved ref${name ? ` g.${name}` : ""}`, unresolvedExternal: name !== void 0 };
           target = bound;
         }
-        const inner = walk2(target);
+        const inner = walk(target);
         if (name !== void 0) return inner ? relabel(inner, "cross-artifact-ref", `via ref g.${name} \u2192 ${inner.detail}`) : null;
         return inner;
       }
       case "optional":
       case "many": {
-        const inner = walk2(d.parser);
+        const inner = walk(d.parser);
         return relabel(inner, "nullable-prefix", inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term");
       }
       case "oneOrMore":
@@ -3612,9 +3843,9 @@ function classifyBroadArm(arm, resolve2) {
       case "node":
       case "grammar":
       case "expect":
-        return walk2(d.parser);
+        return walk(d.parser);
       case "skip":
-        return walk2(d.main);
+        return walk(d.main);
       case "sequence": {
         let sawNullablePrefix = false;
         for (const t of d.parsers) {
@@ -3623,7 +3854,7 @@ function classifyBroadArm(arm, resolve2) {
             continue;
           }
           if (isAny(firstSetOf(t, /* @__PURE__ */ new Set(), resolve2))) {
-            const inner = walk2(t);
+            const inner = walk(t);
             if (sawNullablePrefix)
               return relabel(inner, "nullable-prefix", inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term");
             return inner ?? { cause: "broad-recognizer", detail: "sequence leading term is broad" };
@@ -3638,18 +3869,18 @@ function classifyBroadArm(arm, resolve2) {
       }
       case "choice": {
         for (const a of d.parsers) {
-          const r = walk2(a);
+          const r = walk(a);
           if (r) return relabel(r, r.cause, `choice arm \u2192 ${r.detail}`);
         }
         return null;
       }
       case "dispatch":
-        return walk2(d.selector);
+        return walk(d.selector);
       default:
         return { cause: "broad-recognizer", detail: `unmodeled construct (${d.tag})` };
     }
   };
-  return walk2(arm) ?? { cause: "broad-recognizer", detail: "broad (cause not localized)" };
+  return walk(arm) ?? { cause: "broad-recognizer", detail: "broad (cause not localized)" };
 }
 function peelToLeading(arm) {
   let d = arm._def;
@@ -3851,7 +4082,7 @@ function formatGatingWarnings(report) {
 
 // src/analysis/duplication.ts
 var siteToString = (s) => s.path === "" ? s.rule : `${s.rule} \u203A ${s.path}`;
-function childrenOf(d) {
+function childrenOf2(d) {
   switch (d.tag) {
     case "sequence":
     case "choice":
@@ -3985,7 +4216,7 @@ function render(p, depth = 3) {
       break;
   }
   if (depth <= 0) return `${d.tag}(\u2026)`;
-  const kids = childrenOf(d).map((k) => render(k, depth - 1));
+  const kids = childrenOf2(d).map((k) => render(k, depth - 1));
   switch (d.tag) {
     case "sequence":
       return `sequence(${kids.join(", ")})`;
@@ -4180,7 +4411,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
     if (hit !== void 0) return hit;
     const d = p._def;
     shapeCache.set(p, interner.hole);
-    const kids = childrenOf(d);
+    const kids = childrenOf2(d);
     const id = interner.of(`${payloadKey(p, d)}|${kids.map(shapeOf).join(",")}`);
     shapeCache.set(p, id);
     return id;
@@ -4190,7 +4421,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
     if (hit !== void 0) return hit;
     sizeCache.set(p, 1);
     let n = 1;
-    for (const k of childrenOf(p._def)) n += sizeOf(k);
+    for (const k of childrenOf2(p._def)) n += sizeOf(k);
     sizeCache.set(p, n);
     return n;
   };
@@ -4203,7 +4434,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
     visited.set(p, { p, d, site: here, shape: shapeOf(p), size: sizeOf(p), enclosingNode, enclosingReducer });
     const inner = d.tag === "node" ? d.type ?? "(anonymous)" : enclosingNode;
     const innerReducer = enclosingReducer || d.tag === "node" && (d.build !== void 0 || d.buildSrc !== void 0) || d.tag === "transform" || d.tag === "leaf";
-    const kids = childrenOf(d);
+    const kids = childrenOf2(d);
     kids.forEach((k, i) => {
       const seg = segment(d, i);
       visit(k, here.rule, here.path === "" ? seg : `${here.path} \u203A ${seg}`, inner, innerReducer);
@@ -4263,7 +4494,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
 function markSubtree(p, into) {
   if (into.has(p)) return;
   into.add(p);
-  for (const k of childrenOf(p._def)) markSubtree(k, into);
+  for (const k of childrenOf2(p._def)) markSubtree(k, into);
 }
 var stripMembers = (f) => {
   const { _members, ...rest } = f;
@@ -4303,7 +4534,7 @@ function findNearDuplicates(visited, interner, shapeOf, minSize) {
     if (hit !== void 0) return hit;
     holeCache.set(p, []);
     const d = p._def;
-    const kids = childrenOf(d);
+    const kids = childrenOf2(d);
     const kidShapes = kids.map(shapeOf);
     const payload = payloadKey(p, d);
     const out2 = [];
@@ -4364,7 +4595,7 @@ function findDivergentSlot(members, shapeOf) {
   let cur = [...members];
   for (let guard2 = 0; guard2 < 64; guard2++) {
     const d0 = cur[0]._def;
-    const kidLists = cur.map((c) => childrenOf(c._def));
+    const kidLists = cur.map((c) => childrenOf2(c._def));
     const arity = kidLists[0].length;
     if (kidLists.some((k) => k.length !== arity) || arity === 0) break;
     const diff = [];
@@ -4377,7 +4608,7 @@ function findDivergentSlot(members, shapeOf) {
     path2.push(i);
     defs.push(d0);
     cur = kidLists.map((k) => k[i]);
-    const nextArity = childrenOf(cur[0]._def).length;
+    const nextArity = childrenOf2(cur[0]._def).length;
     const samePayload = cur.every((c) => payloadKey(c, c._def) === payloadKey(cur[0], cur[0]._def));
     if (!samePayload || nextArity === 0) break;
   }
@@ -4385,7 +4616,7 @@ function findDivergentSlot(members, shapeOf) {
   let slotSize = 0;
   const sizeOf = (p) => {
     let n = 1;
-    for (const k of childrenOf(p._def)) n += sizeOf(k);
+    for (const k of childrenOf2(p._def)) n += sizeOf(k);
     return n;
   };
   for (const c of cur) slotSize = Math.max(slotSize, sizeOf(c));
@@ -4394,7 +4625,7 @@ function findDivergentSlot(members, shapeOf) {
 function renderWithHole(p, path2, depth = 0) {
   if (depth === path2.length) return "\u2039slot\u203A";
   const d = p._def;
-  const kids = childrenOf(d);
+  const kids = childrenOf2(d);
   const idx = path2[depth];
   const parts = kids.map((k, i) => i === idx ? renderWithHole(k, path2, depth + 1) : render(k, 2));
   switch (d.tag) {
@@ -4852,7 +5083,7 @@ function capturesPositionally(p, seen = /* @__PURE__ */ new Set()) {
   seen.add(p);
   const d = p._def;
   if (d.tag === "field" || d.tag === "label") return true;
-  for (const k of childrenOf(d)) if (capturesPositionally(k, seen)) return true;
+  for (const k of childrenOf2(d)) if (capturesPositionally(k, seen)) return true;
   return false;
 }
 function detectHandRolledSepBy(terms, shapeOf) {
@@ -4958,7 +5189,7 @@ function nestedNodeTypes(root, out, seen, isRoot) {
     }
     return;
   }
-  for (const k of childrenOf(d)) nestedNodeTypes(k, out, seen, false);
+  for (const k of childrenOf2(d)) nestedNodeTypes(k, out, seen, false);
 }
 var MAX_LOST_TYPES = 8;
 function findStructureLoss(visited, resolve2) {
@@ -5385,9 +5616,18 @@ function buildGrammarPlan(entry, winners) {
   return { definitions: [...definitions.values()].sort((a, b) => a.id.localeCompare(b.id)), choices, dispatches, attempts, labels, rules: rules2 };
 }
 
+// src/cst/trivia-entries.ts
+var EMPTY_INDICES = Object.freeze([]);
+var EMPTY_GAPS = Object.freeze([]);
+var SELECTED_ROOT_STRIDE = 5;
+
 // src/compiler/scannable-run.ts
 var BACKSLASH = 92;
 var META = new Set("()[]{}*+?|^$.".split(""));
+var SELECTED_ROOT_OWNED_RANGE_PLACEHOLDER = Array.from(
+  { length: SELECTED_ROOT_STRIDE - 3 },
+  () => "0"
+).join(", ");
 function classToRanges(cls) {
   if (cls === "\\d") return shorthandRanges("d");
   if (cls === "\\w") return shorthandRanges("w");
@@ -6426,13 +6666,15 @@ function scanBranch(shape, mint) {
   const m = emitShapeMatch(shape, "_e", mint, "    ", "c");
   return [...m.setup, `    if (${m.end} > _e) { _e = ${m.end}; continue }`].join("\n");
 }
-function scanBranchLabeled(shape, kindIndex, mint) {
+function scanBranchLabeled(shape, kindIndex, label2, mint) {
   const m = emitShapeMatch(shape, "_e", mint, "    ", "c");
   return [
     ...m.setup,
     `    if (${m.end} > _e) {`,
     `      if (_cap) {`,
     `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, ${m.end}, ${kindIndex})`,
+    `        const _rk = _ctx._rootTriviaCapture === false || _ctx._rootTriviaLog === undefined ? -1 : (_ctx._rootTriviaKindIndex?.[${JSON.stringify(label2)}] ?? -1)`,
+    `        if (_rk >= 0) _ctx._rootTriviaLog.push(${SELECTED_ROOT_OWNED_RANGE_PLACEHOLDER}, _e, ${m.end}, _rk)`,
     `        if (_cap === 1 && _ctx._cstTriviaLog !== undefined && _ctx.captureTrivia && (_ctx._triviaCaptureMask === undefined || (_ctx._triviaCaptureMask & ${1 << kindIndex}))) _ctx._cstTriviaLog.push(_e, ${m.end}, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${kindIndex})`,
     `      }`,
     `      _e = ${m.end}`,
@@ -6492,6 +6734,11 @@ var CAP_RECORD = [
   `    if (_cap === 1 && _ctx._cstTriviaLog !== undefined && _ctx.captureTrivia) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,
   `  }`
 ].join("\n");
+var SELECTED_ROOT_FINISH = [
+  `  if (_cap && _ctx._rootTriviaCapture !== false && _ctx._rootTriviaLog !== undefined && _ctx._rootTriviaLog.length !== _rootMark) {`,
+  `    for (let _ri = _rootMark; _ri < _ctx._rootTriviaLog.length; _ri += ${SELECTED_ROOT_STRIDE}) { _ctx._rootTriviaLog[_ri] = _pos; _ctx._rootTriviaLog[_ri + 1] = _e }`,
+  `  }`
+].join("\n");
 function composeFastLoop(shapes) {
   const mint = makeMint();
   return [
@@ -6520,7 +6767,7 @@ function analyzeLabeledScannableRun(trivia2) {
     const d = getCoreRegexDef(arm.parser);
     const shape = d ? scanShapeFromRegex(d.source, d.flags) : null;
     if (!shape) return null;
-    out.push({ shape, kindIndex: arm.kindIndex });
+    out.push({ shape, kindIndex: arm.kindIndex, label: arm.label });
   }
   return out;
 }
@@ -6529,11 +6776,13 @@ function buildLabeledScannableTriviaFnDecl(fnName, arms) {
   return [
     `function ${fnName}(input, _pos, _ctx, _cap) {`,
     `  let _e = _pos`,
+    `  const _rootMark = _cap && _ctx._rootTriviaLog !== undefined ? _ctx._rootTriviaLog.length : 0`,
     `  while (_e < input.length) {`,
     `    const c = input.charCodeAt(_e)`,
-    ...arms.map((a) => scanBranchLabeled(a.shape, a.kindIndex, mint)),
+    ...arms.map((a) => scanBranchLabeled(a.shape, a.kindIndex, a.label, mint)),
     `    break`,
     `  }`,
+    SELECTED_ROOT_FINISH,
     `  return _e`,
     `}`
   ].join("\n");
@@ -6549,6 +6798,8 @@ function buildLabeledRegexTriviaFnDecl(fnName, spec, reNames) {
       `      const _ce = _e + _m${i}[0].length`,
       `      if (_cap) {`,
       `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, _ce, ${k})`,
+      `        const _rk${i} = _ctx._rootTriviaCapture === false || _ctx._rootTriviaLog === undefined ? -1 : (_ctx._rootTriviaKindIndex?.[${JSON.stringify(arm.label)}] ?? -1)`,
+      `        if (_rk${i} >= 0) _ctx._rootTriviaLog.push(0, 0, _e, _ce, _rk${i})`,
       `        if (_cap === 1 && _ctx._cstTriviaLog !== undefined && _ctx.captureTrivia && (_ctx._triviaCaptureMask === undefined || (_ctx._triviaCaptureMask & ${1 << k}))) _ctx._cstTriviaLog.push(_e, _ce, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${k})`,
       `      }`,
       `      _e = _ce`,
@@ -6560,11 +6811,13 @@ function buildLabeledRegexTriviaFnDecl(fnName, spec, reNames) {
   return [
     `function ${fnName}(input, _pos, _ctx, _cap) {`,
     `  let _e = _pos`,
+    `  const _rootMark = _cap && _ctx._rootTriviaLog !== undefined ? _ctx._rootTriviaLog.length : 0`,
     `  while (_e < input.length) {`,
     `    let _matched = false`,
     tryArms,
     `    if (!_matched) break`,
     `  }`,
+    SELECTED_ROOT_FINISH,
     `  return _e`,
     `}`
   ].join("\n");
@@ -6587,6 +6840,8 @@ function buildLabeledRuntimeTriviaFnDecl(fnName, spec, rpStartIndex) {
       `      const _ce = _r${i}.span.end`,
       `      if (_cap) {`,
       `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, _ce, ${k})`,
+      `        const _rk${i} = _ctx._rootTriviaCapture === false || _ctx._rootTriviaLog === undefined ? -1 : (_ctx._rootTriviaKindIndex?.[${JSON.stringify(arm.label)}] ?? -1)`,
+      `        if (_rk${i} >= 0) _ctx._rootTriviaLog.push(0, 0, _e, _ce, _rk${i})`,
       `        if (_cap === 1 && _ctx._cstTriviaLog !== undefined && _ctx.captureTrivia && (_ctx._triviaCaptureMask === undefined || (_ctx._triviaCaptureMask & ${1 << k}))) _ctx._cstTriviaLog.push(_e, _ce, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${k})`,
       `      }`,
       `      _e = _ce`,
@@ -6598,11 +6853,13 @@ function buildLabeledRuntimeTriviaFnDecl(fnName, spec, rpStartIndex) {
   return [
     `function ${fnName}(input, _pos, _ctx, _cap) {`,
     `  let _e = _pos`,
+    `  const _rootMark = _cap && _ctx._rootTriviaLog !== undefined ? _ctx._rootTriviaLog.length : 0`,
     `  while (_e < input.length) {`,
     `    let _matched = false`,
     tryArms,
     `    if (!_matched) break`,
     `  }`,
+    SELECTED_ROOT_FINISH,
     `  return _e`,
     `}`
   ].join("\n");
@@ -6833,6 +7090,9 @@ function endLoweringCapture() {
   _loweringSink = null;
   return misses;
 }
+function hasSelectedRootTrivia(ctx) {
+  return ctx.rootTriviaClassified === true;
+}
 function v(ctx, prefix = "_v") {
   return `${prefix}${ctx.vars++}`;
 }
@@ -7142,10 +7402,12 @@ function planDisjointDispatch(parsers) {
   }
   return total >= SWITCH_MIN_CASES ? { kind: "switch", cases } : { kind: "if" };
 }
-function captureRestoreBody(mL, mR, mTl, mLg, mF = null) {
+function captureRestoreBody(ctx, mL, mR, mTl, mLg, mF = null, mRootLg = null) {
   const fieldRestore = mF ? `; if (_ctx._fields && _ctx._fields.length !== ${mF}) _ctx._fields.length = ${mF}` : "";
   const base = `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${mL}) _ctx._cstLeaves.length = ${mL}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${mR}) _ctx._cstRawChildren.length = ${mR}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${mTl}) _ctx._cstTriviaLog.length = ${mTl}${fieldRestore}`;
-  return mLg ? `${base}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${mLg}) _ctx._triviaLog.length = ${mLg}` : base;
+  const logRestore = mLg ? `; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${mLg}) _ctx._triviaLog.length = ${mLg}` : "";
+  const rootLogRestore = hasSelectedRootTrivia(ctx) && mRootLg ? `; if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${mRootLg}) _ctx._rootTriviaLog.length = ${mRootLg}` : "";
+  return `${base}${logRestore}${rootLogRestore}`;
 }
 function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(p)) return false;
@@ -7355,7 +7617,7 @@ function emitFallible(inner, ctx, pos, swallow = false) {
     `${ind0}  ${valV} = ${r.valueVar}; ${endV} = ${r.endVar}; ${okV} = true`,
     `${ind0}}`,
     ...mL ? [
-      `${ind0}if (!${okV}) { ${captureRestoreBody(mL, mR, mTl, null, mF)} }`
+      `${ind0}if (!${okV}) { ${captureRestoreBody(ctx, mL, mR, mTl, null, mF)} }`
     ] : []
   ];
   return { stmts, okVar: okV, valVar: valV, endVar: endV, mayCommit };
@@ -7552,11 +7814,13 @@ function emitSeqValues(def, ctx, pos) {
         const markV = v(ctx, "_mk");
         const markTl = v(ctx, "_mktl");
         const markLog = v(ctx, "_mklg");
+        const markRootLog = hasSelectedRootTrivia(ctx) ? v(ctx, "_mkrlg") : null;
         const scanEndV = v(ctx, "_sne");
         stmts.push(
           `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,
           `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,
           `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,
+          ...markRootLog ? [`${ind(ctx)}const ${markRootLog} = _ctx._rootTriviaLog ? _ctx._rootTriviaLog.length : 0`] : [],
           `${ind(ctx)}const ${scanEndV} = ${capFn}(input, ${curV}, _ctx, 1)`,
           ...emitLineTrack(ctx, curV, scanEndV)
         );
@@ -7565,17 +7829,19 @@ function emitSeqValues(def, ctx, pos) {
         const endAfterV = v(ctx, "_sea");
         stmts.push(
           `${ind(ctx)}const ${endAfterV} = ${r2.endVar}`,
-          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) { ${curV} = ${endAfterV} } else { if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${markV}) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${markTl}) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${markLog}) _ctx._triviaLog.length = ${markLog}; }`
+          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) { ${curV} = ${endAfterV} } else { if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${markV}) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${markTl}) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${markLog}) _ctx._triviaLog.length = ${markLog};${markRootLog ? ` if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${markRootLog}) _ctx._rootTriviaLog.length = ${markRootLog};` : ""} }`
         );
         valueVars.push(r2.valueVar);
         continue;
       } else {
         const trivFn = ensureTriviaFn(ctx);
         const markLog = v(ctx, "_mklg");
+        const markRootLog = hasSelectedRootTrivia(ctx) ? v(ctx, "_mkrlg") : null;
         const scanEndV = v(ctx, "_sne");
-        const capArg = ctx.noHoist ? "0" : "_ctx._triviaLog !== undefined ? 2 : 0";
+        const capArg = ctx.noHoist ? "0" : hasSelectedRootTrivia(ctx) ? "(_ctx._triviaLog !== undefined || _ctx._rootTriviaLog !== undefined) ? 2 : 0" : "_ctx._triviaLog !== undefined ? 2 : 0";
         stmts.push(
           `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,
+          ...markRootLog ? [`${ind(ctx)}const ${markRootLog} = _ctx._rootTriviaLog ? _ctx._rootTriviaLog.length : 0`] : [],
           `${ind(ctx)}const ${scanEndV} = ${trivFn}(input, ${curV}, _ctx, ${capArg})`,
           ...emitLineTrack(ctx, curV, scanEndV)
         );
@@ -7584,7 +7850,7 @@ function emitSeqValues(def, ctx, pos) {
         const endAfterV = v(ctx, "_sea");
         stmts.push(
           `${ind(ctx)}const ${endAfterV} = ${r2.endVar}`,
-          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) ${curV} = ${endAfterV}; else if (_ctx._triviaLog && _ctx._triviaLog.length !== ${markLog}) _ctx._triviaLog.length = ${markLog}`
+          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) ${curV} = ${endAfterV}; else { if (_ctx._triviaLog && _ctx._triviaLog.length !== ${markLog}) _ctx._triviaLog.length = ${markLog};${markRootLog ? ` if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${markRootLog}) _ctx._rootTriviaLog.length = ${markRootLog};` : ""} }`
         );
         valueVars.push(r2.valueVar);
         continue;
@@ -7826,6 +8092,7 @@ function emitDispatchCombinator(parser2, def, ctx, pos, valueMode = "pair") {
   const selectorRawMark = selectorNeedsRollback ? v(ctx, "_dsr") : null;
   const selectorTriviaMark = selectorNeedsRollback ? v(ctx, "_dst") : null;
   const selectorLogMark = selectorNeedsRollback ? v(ctx, "_dsg") : null;
+  const selectorRootLogMark = selectorNeedsRollback && hasSelectedRootTrivia(ctx) ? v(ctx, "_dsrg") : null;
   const selectorFieldMark = selectorNeedsRollback ? v(ctx, "_dsf") : null;
   const selectorErrorMark = selectorNeedsRollback ? v(ctx, "_dse") : null;
   const selector = emit(def.selector, ctx, pos);
@@ -7838,6 +8105,7 @@ function emitDispatchCombinator(parser2, def, ctx, pos, valueMode = "pair") {
       `${ind(ctx)}const ${selectorRawMark} = _ctx._cstRawChildren?.length ?? 0`,
       `${ind(ctx)}const ${selectorTriviaMark} = _ctx._cstTriviaLog?.length ?? 0`,
       `${ind(ctx)}const ${selectorLogMark} = _ctx._triviaLog?.length ?? 0`,
+      ...selectorRootLogMark ? [`${ind(ctx)}const ${selectorRootLogMark} = _ctx._rootTriviaLog?.length ?? 0`] : [],
       `${ind(ctx)}const ${selectorFieldMark} = _ctx._fields?.length ?? 0`,
       `${ind(ctx)}const ${selectorErrorMark} = _ctx._errors?.length ?? 0`
     ] : [],
@@ -7857,16 +8125,18 @@ function emitDispatchCombinator(parser2, def, ctx, pos, valueMode = "pair") {
     const mayError = mayRecordRecoveryError(parser3, !!ctx.recovery);
     const errMark = mayError ? v(ctx, "_derr") : null;
     const logMark = ctx.activeTrivia ? v(ctx, "_dlog") : null;
+    const rootLogMark = ctx.activeTrivia && hasSelectedRootTrivia(ctx) ? v(ctx, "_drlog") : null;
     if (usesRouted) {
       stmts.push(
         ...routedV ? [`${ind(ctx)}const ${routedV} = _ctx._routed; _ctx._routed = { value: ${selector.valueVar}, span: { start: ${pos}, end: ${selector.endVar} } }`] : [],
         ...selectorLeafMark ? [
-          `${ind(ctx)}if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${selectorLeafMark}) _ctx._cstLeaves.length = ${selectorLeafMark}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${selectorRawMark}) _ctx._cstRawChildren.length = ${selectorRawMark}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${selectorTriviaMark}) _ctx._cstTriviaLog.length = ${selectorTriviaMark}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${selectorLogMark}) _ctx._triviaLog.length = ${selectorLogMark}; if (_ctx._fields && _ctx._fields.length !== ${selectorFieldMark}) _ctx._fields.length = ${selectorFieldMark}; if (_ctx._errors && _ctx._errors.length !== ${selectorErrorMark}) _ctx._errors.length = ${selectorErrorMark}`
+          `${ind(ctx)}if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${selectorLeafMark}) _ctx._cstLeaves.length = ${selectorLeafMark}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${selectorRawMark}) _ctx._cstRawChildren.length = ${selectorRawMark}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${selectorTriviaMark}) _ctx._cstTriviaLog.length = ${selectorTriviaMark}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${selectorLogMark}) _ctx._triviaLog.length = ${selectorLogMark};${selectorRootLogMark ? ` if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${selectorRootLogMark}) _ctx._rootTriviaLog.length = ${selectorRootLogMark};` : ""} if (_ctx._fields && _ctx._fields.length !== ${selectorFieldMark}) _ctx._fields.length = ${selectorFieldMark}; if (_ctx._errors && _ctx._errors.length !== ${selectorErrorMark}) _ctx._errors.length = ${selectorErrorMark}`
         ] : []
       );
     }
     if (errMark) stmts.push(`${ind(ctx)}const ${errMark} = _ctx._errors?.length ?? 0`);
     if (logMark) stmts.push(`${ind(ctx)}const ${logMark} = _ctx._triviaLog?.length ?? 0`);
+    if (rootLogMark) stmts.push(`${ind(ctx)}const ${rootLogMark} = _ctx._rootTriviaLog?.length ?? 0`);
     const savedRoutedLocal = ctx.routedLocal;
     const savedNoHoist = ctx.noHoist;
     if (usesRouted && !needsRoutedContext) {
@@ -7881,11 +8151,12 @@ function emitDispatchCombinator(parser2, def, ctx, pos, valueMode = "pair") {
     stmts.push(...coverageAttempt(ctx, coverageId, pos));
     const errorRollback = errMark ? `if (_ctx._errors && _ctx._errors.length !== ${errMark}) _ctx._errors.length = ${errMark}; ` : "";
     const logRollback = logMark ? `if (_ctx._triviaLog && _ctx._triviaLog.length !== ${logMark}) _ctx._triviaLog.length = ${logMark}; ` : "";
+    const rootLogRollback = rootLogMark ? `if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${rootLogMark}) _ctx._rootTriviaLog.length = ${rootLogMark}; ` : "";
     const routedRollback = routedV ? `_ctx._routed = ${routedV}; ` : "";
     const coverageFailure = coverageId === void 0 ? "" : `_ctx._grammarTrace?.write({ id: ${JSON.stringify(coverageId)}, phase: 'failure', offset: _ctx._fe }); `;
     stmts.push(
       ...tail.stmts,
-      `${ind(ctx)}if (!${tail.okVar}) { ${routedRollback}${errorRollback}${logRollback}${coverageFailure}${committedFailBody(ctx)} }`,
+      `${ind(ctx)}if (!${tail.okVar}) { ${routedRollback}${errorRollback}${logRollback}${rootLogRollback}${coverageFailure}${committedFailBody(ctx)} }`,
       ...routedV ? [`${ind(ctx)}_ctx._routed = ${routedV}`] : [],
       `${ind(ctx)}${outV} = ${valueMode === "tail" ? tail.valVar : `[${selector.valueVar}, ${tail.valVar}]`}`,
       `${ind(ctx)}${outE} = ${tail.endVar}`,
@@ -8066,11 +8337,13 @@ function emitFirstMatch(def, ctx, pos, coverageBase, preStmts, armGuardPrefix) {
     const markRaw = armNeedsRollback ? v(ctx, "_cmr") : null;
     const markTl = armNeedsRollback ? v(ctx, "_cmtl") : null;
     const markLog = armNeedsRollback ? v(ctx, "_cmlg") : null;
+    const markRootLog = ctx.activeTrivia && hasSelectedRootTrivia(ctx) ? v(ctx, "_cmlrg") : null;
     const markFields = armNeedsFieldRollback ? v(ctx, "_cmf") : null;
     const markErrors = armMayRecordError ? v(ctx, "_cme") : null;
-    const captureRollback = markLeaves ? captureRestoreBody(markLeaves, markRaw, markTl, markLog, markFields) : "";
+    const captureRollback = markLeaves ? captureRestoreBody(ctx, markLeaves, markRaw, markTl, markLog, markFields, markRootLog) : "";
+    const rootRollback = markRootLog && !markLeaves ? `if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${markRootLog}) _ctx._rootTriviaLog.length = ${markRootLog}` : "";
     const errorRollback = markErrors ? `if (_ctx._errors && _ctx._errors.length !== ${markErrors}) _ctx._errors.length = ${markErrors}` : "";
-    const rollback = [captureRollback, errorRollback].filter(Boolean).join("; ");
+    const rollback = [captureRollback, rootRollback, errorRollback].filter(Boolean).join("; ");
     const failSlot = atStart ? staticFx : "_ctx._fx";
     stmts.push(`${ind0}if (${skipCond}) {`);
     if (fsGuard) stmts.push(`${ind(ctx)}if (${fsGuard}) {`);
@@ -8085,6 +8358,7 @@ function emitFirstMatch(def, ctx, pos, coverageBase, preStmts, armGuardPrefix) {
         ...markFields ? [`${ind(ctx)}const ${markFields} = _ctx._fields?.length ?? 0`] : []
       );
     }
+    if (markRootLog) stmts.push(`${ind(ctx)}const ${markRootLog} = _ctx._rootTriviaLog?.length ?? 0`);
     if (markErrors) stmts.push(`${ind(ctx)}const ${markErrors} = _ctx._errors?.length ?? 0`);
     const arm = emitFallible(p, ctx, pos, atStart);
     const { stmts: armStmts, okVar, valVar, endVar } = arm;
@@ -8153,7 +8427,7 @@ function routedNeedsContextBridge(p, ctx, seen = /* @__PURE__ */ new Set()) {
   const d = p._def;
   if (d.tag === "dispatch") return false;
   if (d.tag === "withCtx") return parserUsesRouted2(d.parser);
-  return childrenOf2(d).some((child) => routedNeedsContextBridge(child, ctx, seen));
+  return childrenOf3(d).some((child) => routedNeedsContextBridge(child, ctx, seen));
 }
 function armReplayInScope(arm, ctx) {
   let p = arm;
@@ -8272,21 +8546,29 @@ function emitMany(def, ctx, pos) {
       const markV = v(ctx, "_mk");
       const markTl = v(ctx, "_mktl");
       const markLog = v(ctx, "_mklg");
+      const markRootLog = hasSelectedRootTrivia(ctx) ? v(ctx, "_mkrlg") : null;
       const npV = v(ctx, "_np");
       stmts.push(
         `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,
         `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,
         `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,
+        ...markRootLog ? [`${ind(ctx)}const ${markRootLog} = _ctx._rootTriviaLog ? _ctx._rootTriviaLog.length : 0`] : [],
         `${ind(ctx)}const ${npV} = ${capFn}(input, ${curV}, _ctx, 1)`,
         ...emitLineTrack(ctx, curV, npV)
       );
       itemPos = npV;
-      rollback = `if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${markV}) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${markTl}) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${markLog}) _ctx._triviaLog.length = ${markLog}; `;
+      rollback = `if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${markV}) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${markTl}) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${markLog}) _ctx._triviaLog.length = ${markLog};${markRootLog ? ` if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${markRootLog}) _ctx._rootTriviaLog.length = ${markRootLog};` : ""} `;
     } else {
       const trivFn = ensureTriviaFn(ctx);
+      const markRootLog = hasSelectedRootTrivia(ctx) ? v(ctx, "_mkrlg") : null;
       const npV = v(ctx, "_np");
-      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${curV}, _ctx)`, ...emitLineTrack(ctx, curV, npV));
+      stmts.push(
+        ...markRootLog ? [`${ind(ctx)}const ${markRootLog} = _ctx._rootTriviaLog ? _ctx._rootTriviaLog.length : 0`] : [],
+        `${ind(ctx)}const ${npV} = ${trivFn}(input, ${curV}, _ctx, ${hasSelectedRootTrivia(ctx) ? "_ctx._rootTriviaLog !== undefined ? 2 : 0" : "0"})`,
+        ...emitLineTrack(ctx, curV, npV)
+      );
       itemPos = npV;
+      rollback = markRootLog ? `if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${markRootLog}) _ctx._rootTriviaLog.length = ${markRootLog}; ` : "";
     }
   }
   if (!ctx.recovery && !ctx.coverage && !failsAtStart(def.parser) && needsFirstSetGuard(def.parser)) {
@@ -8346,9 +8628,10 @@ function emitAttempt(p, def, ctx, pos) {
   const raw = v(ctx, "_atr");
   const trivia2 = v(ctx, "_att");
   const log = v(ctx, "_atg");
+  const rootLog = hasSelectedRootTrivia(ctx) ? v(ctx, "_atrg") : null;
   const fields = v(ctx, "_atf");
   const errors = v(ctx, "_ate");
-  const rollback = `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${leaves}) _ctx._cstLeaves.length = ${leaves}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${raw}) _ctx._cstRawChildren.length = ${raw}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${trivia2}) _ctx._cstTriviaLog.length = ${trivia2}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${log}) _ctx._triviaLog.length = ${log}; if (_ctx._fields && _ctx._fields.length !== ${fields}) _ctx._fields.length = ${fields}; if (_ctx._errors && _ctx._errors.length !== ${errors}) _ctx._errors.length = ${errors}`;
+  const rollback = `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${leaves}) _ctx._cstLeaves.length = ${leaves}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${raw}) _ctx._cstRawChildren.length = ${raw}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${trivia2}) _ctx._cstTriviaLog.length = ${trivia2}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${log}) _ctx._triviaLog.length = ${log};${rootLog ? ` if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${rootLog}) _ctx._rootTriviaLog.length = ${rootLog};` : ""} if (_ctx._fields && _ctx._fields.length !== ${fields}) _ctx._fields.length = ${fields}; if (_ctx._errors && _ctx._errors.length !== ${errors}) _ctx._errors.length = ${errors}`;
   const traceId = ctx.coverage?.plan.attempts.get(p);
   const traceRollback = traceId === void 0 ? "" : ` _ctx._grammarTrace?.write({ id: ${JSON.stringify(traceId)}, phase: 'rollback', offset: ${pos} });`;
   const preGuard = [];
@@ -8364,7 +8647,7 @@ function emitAttempt(p, def, ctx, pos) {
   return {
     stmts: [
       ...preGuard,
-      `${ind(ctx)}const ${leaves} = _ctx._cstLeaves?.length ?? 0, ${raw} = _ctx._cstRawChildren?.length ?? 0, ${trivia2} = _ctx._cstTriviaLog?.length ?? 0, ${log} = _ctx._triviaLog?.length ?? 0, ${fields} = _ctx._fields?.length ?? 0, ${errors} = _ctx._errors?.length ?? 0`,
+      `${ind(ctx)}const ${leaves} = _ctx._cstLeaves?.length ?? 0, ${raw} = _ctx._cstRawChildren?.length ?? 0, ${trivia2} = _ctx._cstTriviaLog?.length ?? 0, ${log} = _ctx._triviaLog?.length ?? 0${rootLog ? `, ${rootLog} = _ctx._rootTriviaLog?.length ?? 0` : ""}, ${fields} = _ctx._fields?.length ?? 0, ${errors} = _ctx._errors?.length ?? 0`,
       ...inner.stmts,
       ...emitIfFail(ctx, `!${inner.okVar}`, `{ ${rollback};${traceRollback}${inner.mayCommit ? ` if (_ctx._fc) ${committedFailBody(ctx)};` : ""} _ctx._fe = ${pos}; ${propagateFailBody(ctx)} }`)
     ],
@@ -8406,16 +8689,17 @@ function emitSepBy(_p, def, ctx, pos) {
   const itemFailBreak = (sepEndVar, sepRb, postSepRb) => def.trailing === void 0 ? `${sepRb}break` : `${postSepRb}${curV} = ${sepEndVar}; break`;
   const postSepMarks = () => {
     if (def.trailing === void 0 || !ctx.capturing) return { decl: [], rb: "" };
-    const lv = v(ctx, "_tlv"), rw = v(ctx, "_trw"), tl = v(ctx, "_ttl"), lg = v(ctx, "_tlg"), fl = v(ctx, "_tlf");
+    const lv = v(ctx, "_tlv"), rw = v(ctx, "_trw"), tl = v(ctx, "_ttl"), lg = v(ctx, "_tlg"), rlg = hasSelectedRootTrivia(ctx) ? v(ctx, "_trlg") : null, fl = v(ctx, "_tlf");
     return {
       decl: [
         `${ind(ctx)}const ${lv} = _ctx._cstLeaves ? _ctx._cstLeaves.length : 0`,
         `${ind(ctx)}const ${rw} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,
         `${ind(ctx)}const ${tl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,
         `${ind(ctx)}const ${lg} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,
+        ...rlg ? [`${ind(ctx)}const ${rlg} = _ctx._rootTriviaLog ? _ctx._rootTriviaLog.length : 0`] : [],
         `${ind(ctx)}const ${fl} = _ctx._fields ? _ctx._fields.length : 0`
       ],
-      rb: `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${lv}) _ctx._cstLeaves.length = ${lv}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${rw}) _ctx._cstRawChildren.length = ${rw}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${tl}) _ctx._cstTriviaLog.length = ${tl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${lg}) _ctx._triviaLog.length = ${lg}; if (_ctx._fields && _ctx._fields.length !== ${fl}) _ctx._fields.length = ${fl}; `
+      rb: `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${lv}) _ctx._cstLeaves.length = ${lv}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${rw}) _ctx._cstRawChildren.length = ${rw}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${tl}) _ctx._cstTriviaLog.length = ${tl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${lg}) _ctx._triviaLog.length = ${lg};${rlg ? ` if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${rlg}) _ctx._rootTriviaLog.length = ${rlg};` : ""} if (_ctx._fields && _ctx._fields.length !== ${fl}) _ctx._fields.length = ${fl}; `
     };
   };
   if (rec) {
@@ -8453,6 +8737,7 @@ function emitSepBy(_p, def, ctx, pos) {
       const markV = v(ctx, "_mk");
       const markTl = v(ctx, "_mktl");
       const markLog = v(ctx, "_mklg");
+      const markRootLog = hasSelectedRootTrivia(ctx) ? v(ctx, "_mkrlg") : null;
       const markLv = v(ctx, "_mklv");
       const markFld = v(ctx, "_mkf");
       const spV = v(ctx, "_sp");
@@ -8460,13 +8745,14 @@ function emitSepBy(_p, def, ctx, pos) {
         `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,
         `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,
         `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,
+        ...markRootLog ? [`${ind(ctx)}const ${markRootLog} = _ctx._rootTriviaLog ? _ctx._rootTriviaLog.length : 0`] : [],
         `${ind(ctx)}const ${markLv} = _ctx._cstLeaves ? _ctx._cstLeaves.length : 0`,
         `${ind(ctx)}const ${markFld} = _ctx._fields ? _ctx._fields.length : 0`,
         `${ind(ctx)}const ${spV} = ${capFn}(input, ${curV}, _ctx, 1)`,
         ...emitLineTrack(ctx, curV, spV)
       );
       sepAtPos = spV;
-      const rollbackToSep = `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${markLv}) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${markV}) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${markTl}) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${markLog}) _ctx._triviaLog.length = ${markLog}; if (_ctx._fields && _ctx._fields.length !== ${markFld}) _ctx._fields.length = ${markFld}; `;
+      const rollbackToSep = `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${markLv}) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${markV}) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${markTl}) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${markLog}) _ctx._triviaLog.length = ${markLog};${markRootLog ? ` if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${markRootLog}) _ctx._rootTriviaLog.length = ${markRootLog};` : ""} if (_ctx._fields && _ctx._fields.length !== ${markFld}) _ctx._fields.length = ${markFld}; `;
       const sep2 = emitFallible(def.separator, ctx, sepAtPos, true);
       const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep2;
       stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}${sep2.mayCommit ? `if (_ctx._fc) ${committedFailBody(ctx)}; ` : ""}break }`);
@@ -8484,19 +8770,30 @@ function emitSepBy(_p, def, ctx, pos) {
       );
     } else {
       const trivFn = ensureTriviaFn(ctx);
+      const markRootLog = hasSelectedRootTrivia(ctx) ? v(ctx, "_mkrlg") : null;
       const spV = v(ctx, "_sp");
-      stmts.push(`${ind(ctx)}const ${spV} = ${trivFn}(input, ${curV}, _ctx)`, ...emitLineTrack(ctx, curV, spV));
+      stmts.push(
+        ...markRootLog ? [`${ind(ctx)}const ${markRootLog} = _ctx._rootTriviaLog ? _ctx._rootTriviaLog.length : 0`] : [],
+        `${ind(ctx)}const ${spV} = ${trivFn}(input, ${curV}, _ctx, ${hasSelectedRootTrivia(ctx) ? "_ctx._rootTriviaLog !== undefined ? 2 : 0" : "0"})`,
+        ...emitLineTrack(ctx, curV, spV)
+      );
       sepAtPos = spV;
       const sep2 = emitFallible(def.separator, ctx, sepAtPos, true);
       const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep2;
-      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${sep2.mayCommit ? `if (_ctx._fc) ${committedFailBody(ctx)}; ` : ""}break }`);
+      const rollbackToSep = markRootLog ? `if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${markRootLog}) _ctx._rootTriviaLog.length = ${markRootLog}; ` : "";
+      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}${sep2.mayCommit ? `if (_ctx._fc) ${committedFailBody(ctx)}; ` : ""}break }`);
+      const postRootLog = hasSelectedRootTrivia(ctx) ? v(ctx, "_psrlg") : null;
       const npV = v(ctx, "_np");
-      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${sepEnd}, _ctx)`, ...emitLineTrack(ctx, sepEnd, npV));
+      stmts.push(
+        ...postRootLog ? [`${ind(ctx)}const ${postRootLog} = _ctx._rootTriviaLog ? _ctx._rootTriviaLog.length : 0`] : [],
+        `${ind(ctx)}const ${npV} = ${trivFn}(input, ${sepEnd}, _ctx, ${hasSelectedRootTrivia(ctx) ? "_ctx._rootTriviaLog !== undefined ? 2 : 0" : "0"})`,
+        ...emitLineTrack(ctx, sepEnd, npV)
+      );
       const next = emitFallible(def.parser, ctx, npV, true);
       const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = next;
       stmts.push(
         ...nextStmts,
-        ...failItem(nextOk, next.mayCommit, npV, itemFailBreak(sepEnd, "", "")),
+        ...failItem(nextOk, next.mayCommit, npV, itemFailBreak(sepEnd, rollbackToSep, postRootLog ? `if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${postRootLog}) _ctx._rootTriviaLog.length = ${postRootLog}; ` : "")),
         `${ind(ctx)}${arrV}.push(${nextVal})`,
         `${ind(ctx)}${curV} = ${nextEnd}`
       );
@@ -8591,6 +8888,7 @@ function emitNot(def, ctx, pos) {
   const raw = sinksLive ? v(ctx, "_ntr") : null;
   const tl = sinksLive ? v(ctx, "_ntt") : null;
   const log = sinksLive ? v(ctx, "_ntg") : null;
+  const rootLog = sinksLive && hasSelectedRootTrivia(ctx) ? v(ctx, "_ntrg") : null;
   const fields = sinksLive ? v(ctx, "_ntf") : null;
   const errors = sinksLive ? v(ctx, "_nte") : null;
   const { stmts, okVar } = emitFallible(def.parser, ctx, pos, true);
@@ -8598,11 +8896,11 @@ function emitNot(def, ctx, pos) {
   return {
     stmts: [
       ...sinksLive ? [
-        `${ind(ctx)}const ${leaves} = _ctx._cstLeaves?.length ?? 0, ${raw} = _ctx._cstRawChildren?.length ?? 0, ${tl} = _ctx._cstTriviaLog?.length ?? 0, ${log} = _ctx._triviaLog?.length ?? 0, ${fields} = _ctx._fields?.length ?? 0, ${errors} = _ctx._errors?.length ?? 0`
+        `${ind(ctx)}const ${leaves} = _ctx._cstLeaves?.length ?? 0, ${raw} = _ctx._cstRawChildren?.length ?? 0, ${tl} = _ctx._cstTriviaLog?.length ?? 0, ${log} = _ctx._triviaLog?.length ?? 0${rootLog ? `, ${rootLog} = _ctx._rootTriviaLog?.length ?? 0` : ""}, ${fields} = _ctx._fields?.length ?? 0, ${errors} = _ctx._errors?.length ?? 0`
       ] : [],
       ...stmts,
       ...sinksLive ? [
-        `${ind(ctx)}if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${leaves}) _ctx._cstLeaves.length = ${leaves}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${raw}) _ctx._cstRawChildren.length = ${raw}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${tl}) _ctx._cstTriviaLog.length = ${tl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${log}) _ctx._triviaLog.length = ${log}; if (_ctx._fields && _ctx._fields.length !== ${fields}) _ctx._fields.length = ${fields}; if (_ctx._errors && _ctx._errors.length !== ${errors}) _ctx._errors.length = ${errors}`
+        `${ind(ctx)}if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${leaves}) _ctx._cstLeaves.length = ${leaves}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${raw}) _ctx._cstRawChildren.length = ${raw}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${tl}) _ctx._cstTriviaLog.length = ${tl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${log}) _ctx._triviaLog.length = ${log};${rootLog ? ` if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${rootLog}) _ctx._rootTriviaLog.length = ${rootLog};` : ""} if (_ctx._fields && _ctx._fields.length !== ${fields}) _ctx._fields.length = ${fields}; if (_ctx._errors && _ctx._errors.length !== ${errors}) _ctx._errors.length = ${errors}`
       ] : [],
       ...emitIfFail(ctx, okVar, failBody(ctx, label2, pos))
     ],
@@ -8738,16 +9036,17 @@ function emitToken(def, ctx, pos) {
   const sk = v(ctx, "_tokKinds");
   const stl = v(ctx, "_tokTl");
   const sol = v(ctx, "_tokLog");
+  const srl = hasSelectedRootTrivia(ctx) ? v(ctx, "_tokRootLog") : null;
   const sb = v(ctx, "_tokBuf");
   const valV = v(ctx, "_tok");
   return {
     stmts: [
-      `${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`,
-      `${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`,
+      `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${sv} = _ctx.trivia, ${sk} = _ctx.triviaKindLabels, ${stl} = _ctx._cstTriviaLog, ${sol} = _ctx._triviaLog${srl ? `, ${srl} = _ctx._rootTriviaLog` : ""}, ${sb} = _ctx._cstBuf`,
+      `${i}_ctx.trivia = undefined; _ctx.triviaKindLabels = undefined; _ctx._cstChildren = undefined; _ctx._cstLeaves = undefined; _ctx._cstRawChildren = undefined; _ctx._cstTriviaLog = undefined; _ctx._triviaLog = undefined;${srl ? " _ctx._rootTriviaLog = undefined;" : ""} _ctx._cstBuf = undefined`,
       `${i}try {`,
       ...reindentStmts(inner.stmts, ctx.indent + 1).map((stmt) => stmt.replace(/^(\s*)(?:const|let)\s+/, "$1var ")),
       `${i}} finally {`,
-      `${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}`,
+      `${i}  _ctx.trivia = ${sv}; _ctx.triviaKindLabels = ${sk}; _ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx._cstTriviaLog = ${stl}; _ctx._triviaLog = ${sol};${srl ? ` _ctx._rootTriviaLog = ${srl};` : ""} _ctx._cstBuf = ${sb}`,
       `${i}}`,
       ...emitIfFail(ctx, `!${inner.okVar}`, propagateFailBody(ctx)),
       `${i}const ${valV} = input.slice(${pos}, ${inner.endVar})`,
@@ -8916,7 +9215,8 @@ ${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [],
   const nodeSpanV = ctx.lineTracking ? v(ctx, "_nspan") : nodeSpanExpr;
   if (ctx.lineTracking) stmts.push(`${i}const ${nodeSpanV} = ${nodeSpanExpr}`);
   const buildExpr = structural ? `{ _tag: 'node', type: ${JSON.stringify(def.type)}, span: ${nodeSpanV}, state: ${stV} ?? null, children: ${chV} }` : mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, nodeSpanV, tlV) : def.project !== void 0 ? emitNodeProjectExpr(def.type, def.project, chV) : `${buildRef(ctx)}[${buildIdx}](${chV}, ${fObj}, ${nodeSpanV}, ${rawV}, ${tlV}, ${stV})`;
-  const hostBuildExpr = `_ctx._pmProfile?.phase === 'host' && _ctx._pmProfile.hostCalls++, _ctx.build(${JSON.stringify(def.type)}, ${chV}, ${fObj}, ${nodeSpanV}, ${rawV}, ${tlV}, ${stV})`;
+  const hostBuildArgs = `${JSON.stringify(def.type)}, ${chV}, ${fObj}, ${nodeSpanV}, ${rawV}, ${tlV}, ${stV}${def.tags !== void 0 && def.tags.length > 0 ? `, ${JSON.stringify(def.tags)}` : ""}`;
+  const hostBuildExpr = `_ctx._pmProfile?.phase === 'host' && _ctx._pmProfile.hostCalls++, _ctx.build(${hostBuildArgs})`;
   const ndExpr = structural ? `_ctx.build !== undefined ? (${hostBuildExpr}) : (${buildExpr})` : cstOut ? hostBuildExpr : buildExpr;
   const hostCollapseExpr = structural ? `_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})` : ndExpr;
   const unwrapExpr = `${chV}.length === 1 ? (${chV}[0] !== null && typeof ${chV}[0] === 'object' && ${chV}[0]._tag === 'leaf' ? ${chV}[0].value : ${chV}[0]) : (${ndExpr})`;
@@ -9225,6 +9525,8 @@ function emitDispatch(p, ctx, pos) {
     case "grammar": {
       const savedTrivia = ctx.activeTrivia;
       const savedKindLabels = ctx.triviaKindLabels;
+      const opaqueRootCapture = hasSelectedRootTrivia(ctx) && def.rootCapture === "opaque";
+      const strictScopeCheck = hasSelectedRootTrivia(ctx) && def.triviaParser !== void 0 && !def.triviaParser._meta.rootTriviaClassified && !opaqueRootCapture ? `${ind(ctx)}if (_ctx._rootTriviaStrictScopes) throw new TypeError(${JSON.stringify("parser(): selected root trivia requires classifiedTrivia() for every local trivia scope, or rootCapture: 'opaque'.")})` : void 0;
       if (def.clearTrivia) {
         ctx.activeTrivia = void 0;
         ctx.triviaKindLabels = void 0;
@@ -9235,13 +9537,38 @@ function emitDispatch(p, ctx, pos) {
         }
       }
       const savedCapture = def.captureTrivia ? v(ctx, "_gcap") : null;
+      const savedRootCapture = opaqueRootCapture ? v(ctx, "_grtc") : null;
+      const opaqueValue = opaqueRootCapture ? v(ctx, "_grtv") : null;
+      const opaqueEnd = opaqueRootCapture ? v(ctx, "_grte") : null;
+      if (opaqueRootCapture) ctx.indent++;
       const r = emit(def.parser, ctx, pos);
+      if (opaqueRootCapture) ctx.indent--;
       ctx.activeTrivia = savedTrivia;
       ctx.triviaKindLabels = savedKindLabels;
-      if (!savedCapture) return r;
+      if (!savedCapture && !opaqueRootCapture) return strictScopeCheck === void 0 ? r : {
+        ...r,
+        stmts: [strictScopeCheck, ...r.stmts]
+      };
+      if (opaqueRootCapture) {
+        return {
+          stmts: [
+            ...strictScopeCheck === void 0 ? [] : [strictScopeCheck],
+            `${ind(ctx)}let ${opaqueValue}, ${opaqueEnd}`,
+            `${ind(ctx)}${savedCapture ? `const ${savedCapture} = _ctx.captureTrivia; ` : ""}const ${savedRootCapture} = _ctx._rootTriviaCapture; _ctx._rootTriviaCapture = false`,
+            `${ind(ctx)}try {`,
+            ...savedCapture ? [`${ind(ctx)}  _ctx.captureTrivia = true`] : [],
+            ...r.stmts,
+            `${ind(ctx)}  ${opaqueValue} = ${r.valueVar}; ${opaqueEnd} = ${r.endVar}`,
+            `${ind(ctx)}} finally { ${savedCapture ? `_ctx.captureTrivia = ${savedCapture}; ` : ""}_ctx._rootTriviaCapture = ${savedRootCapture} }`
+          ],
+          valueVar: opaqueValue,
+          endVar: opaqueEnd
+        };
+      }
       return {
         ...r,
         stmts: [
+          ...strictScopeCheck === void 0 ? [] : [strictScopeCheck],
           `${ind(ctx)}const ${savedCapture} = _ctx.captureTrivia; _ctx.captureTrivia = true`,
           ...r.stmts,
           `${ind(ctx)}_ctx.captureTrivia = ${savedCapture}`
@@ -9379,7 +9706,7 @@ function hasLineTrackingDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
     }
   }
-  return childrenOf2(d).some((child) => hasLineTrackingDef(child, seen));
+  return childrenOf3(d).some((child) => hasLineTrackingDef(child, seen));
 }
 function parserUsesRouted2(p, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(p)) return false;
@@ -9398,7 +9725,7 @@ function parserUsesRouted2(p, seen = /* @__PURE__ */ new Set()) {
     case "dispatch":
       return false;
     default:
-      return childrenOf2(d).some((child) => parserUsesRouted2(child, seen));
+      return childrenOf3(d).some((child) => parserUsesRouted2(child, seen));
   }
 }
 function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
@@ -9413,9 +9740,9 @@ function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
     }
   }
-  return childrenOf2(d).some((child) => hasDirectBuildDef(child, seen));
+  return childrenOf3(d).some((child) => hasDirectBuildDef(child, seen));
 }
-function childrenOf2(def) {
+function childrenOf3(def) {
   switch (def.tag) {
     case "sequence":
     case "choice":
@@ -9490,7 +9817,7 @@ function subtreeSizes(roots) {
     const def = p._def;
     let s = 1;
     if (def.tag !== "lazy") {
-      for (const child of childrenOf2(def)) s += child._def.tag === "lazy" ? 1 : sz(child);
+      for (const child of childrenOf3(def)) s += child._def.tag === "lazy" ? 1 : sz(child);
     }
     sizes.set(p, s);
     return s;
@@ -9511,7 +9838,7 @@ function subtreeSizes(roots) {
       return;
     }
     sz(p);
-    for (const child of childrenOf2(def)) visit(child);
+    for (const child of childrenOf3(def)) visit(child);
   };
   for (const root of roots) visit(root);
   return sizes;
@@ -9521,7 +9848,7 @@ function analyzeLazyUsageMulti(roots) {
   const recursive = /* @__PURE__ */ new Set();
   const descended = /* @__PURE__ */ new Set();
   const active = /* @__PURE__ */ new Set();
-  function walk2(p) {
+  function walk(p) {
     const def = p._def;
     if (def.tag === "lazy") {
       counts.set(p, (counts.get(p) ?? 0) + 1);
@@ -9538,17 +9865,17 @@ function analyzeLazyUsageMulti(roots) {
         return;
       }
       active.add(p);
-      walk2(resolved);
+      walk(resolved);
       active.delete(p);
       return;
     }
     if (isHoistableTag(def.tag)) {
       counts.set(p, (counts.get(p) ?? 0) + 1);
     }
-    for (const child of childrenOf2(def)) walk2(child);
+    for (const child of childrenOf3(def)) walk(child);
   }
   const rootsArr = [...roots];
-  for (const root of rootsArr) walk2(root);
+  for (const root of rootsArr) walk(root);
   return { counts, recursive, sizes: subtreeSizes(rootsArr) };
 }
 function ruleDependencies(ruleMap) {
@@ -9558,7 +9885,7 @@ function ruleDependencies(ruleMap) {
   for (const [name, comb] of ruleMap) {
     const found = /* @__PURE__ */ new Set();
     const seen = /* @__PURE__ */ new Set();
-    const walk2 = (p, isRoot) => {
+    const walk = (p, isRoot) => {
       const def = p._def;
       const boundary = def.tag === "lazy" ? nameOf.get(p) ?? p._ruleName : nameOf.get(p);
       if (!isRoot && boundary !== void 0) {
@@ -9574,12 +9901,12 @@ function ruleDependencies(ruleMap) {
         } catch {
           return;
         }
-        walk2(resolved, false);
+        walk(resolved, false);
         return;
       }
-      for (const child of childrenOf2(def)) walk2(child, false);
+      for (const child of childrenOf3(def)) walk(child, false);
     };
-    walk2(comb, true);
+    walk(comb, true);
     deps.set(name, [...found]);
   }
   return deps;
@@ -9726,6 +10053,7 @@ function compile(combinator, mapFnSources, opts) {
   runDuplicationDiagnostic(combinator, opts?.duplication);
   markUnusedValues(combinator);
   const grammarTrivia = combinator._meta.grammarTrivia;
+  const rootTriviaClassified = grammarTrivia?._meta.rootTriviaClassified === true || combinator._meta.rootTriviaClassified === true;
   const grammarScanSkip = combinator._meta.grammarScanSkip;
   const grammarHostMode = combinator._meta.grammarHostMode;
   const grammarTrackLines = combinator._meta.grammarTrackLines;
@@ -9752,7 +10080,11 @@ function compile(combinator, mapFnSources, opts) {
     lineTracking: opts?.trackLines === true || grammarTrackLines === true || hasLineTrackingDef(combinator),
     ...opts?.coverage ? { coverage: { plan: buildGrammarPlan(combinator), entry: combinator } } : {},
     lazyUsage: analyzeLazyUsage(combinator),
-    ...grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {},
+    ...rootTriviaClassified ? { rootTriviaClassified: true } : {},
+    ...grammarTrivia ? {
+      activeTrivia: grammarTrivia,
+      triviaKindLabels: grammarTrivia._meta.triviaKindLabels
+    } : {},
     ...grammarScanSkip ? { activeScanSkip: grammarScanSkip } : {}
   };
   const r = emit(combinator, ctx, "_pos");
@@ -9900,10 +10232,11 @@ function assertRuleName(name) {
     );
   }
 }
-function publicRuleWrapperSource(rule, fnSource, ambientTriviaKindLabels) {
-  const labels = rule._meta.triviaKindLabels ?? ambientTriviaKindLabels;
-  if (labels === void 0) return fnSource;
-  return `Object.assign(${fnSource}, { _meta: { triviaKindLabels: ${JSON.stringify(labels)} } })`;
+function publicRuleWrapperSource(rule, fnSource, ambientTriviaKindLabels, ambientRootTriviaClassified) {
+  const labels = ambientTriviaKindLabels ?? rule._meta.triviaKindLabels;
+  const classified = ambientRootTriviaClassified ?? rule._meta.rootTriviaClassified;
+  if (labels === void 0 && classified === void 0) return fnSource;
+  return `Object.assign(${fnSource}, { _meta: {${labels === void 0 ? "" : ` triviaKindLabels: ${JSON.stringify(labels)},`}${classified === void 0 ? "" : " rootTriviaClassified: true,"} } })`;
 }
 function compileRuleMap(ruleMap, opts) {
   runGatingDiagnosticRules(ruleMap, opts?.gating);
@@ -9911,6 +10244,7 @@ function compileRuleMap(ruleMap, opts) {
   for (const [, rule] of ruleMap) markUnusedValues(rule);
   const coverageWinners = opts?.coverage ? Object.fromEntries(ruleMap.filter(([, rule]) => rule._def.tag !== "lazy")) : void 0;
   const grammarTrivia = opts?.trivia;
+  const rootTriviaClassified = grammarTrivia?._meta.rootTriviaClassified === true || ruleMap.some(([, rule]) => rule._meta.rootTriviaClassified === true);
   const grammarScanSkip = opts?.scanSkip ?? ruleMap.map(([, r]) => r._meta.grammarScanSkip).find(Boolean);
   const grammarHostMode = opts?.hostMode ?? ruleMap.map(([, r]) => r._meta.grammarHostMode).find(Boolean);
   const grammarTrackLines = opts?.trackLines === true || ruleMap.some(([, r]) => r._meta.grammarTrackLines === true);
@@ -9937,7 +10271,11 @@ function compileRuleMap(ruleMap, opts) {
     lineTracking: grammarTrackLines,
     ...opts?.coverage ? { coverage: { plan: buildGrammarPlan(ruleMap.map(([, rule]) => rule), coverageWinners) } } : {},
     lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),
-    ...grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {},
+    ...rootTriviaClassified ? { rootTriviaClassified: true } : {},
+    ...grammarTrivia ? {
+      activeTrivia: grammarTrivia,
+      triviaKindLabels: grammarTrivia._meta.triviaKindLabels
+    } : {},
     ...grammarScanSkip ? { activeScanSkip: grammarScanSkip } : {}
   };
   const seenNames = /* @__PURE__ */ new Map();
@@ -10025,7 +10363,7 @@ function compileRuleMap(ruleMap, opts) {
     return [`function(input, _pos, _ctx) {`, ...body, `}`].join("\n");
   };
   const objBody = perEntry.map(({ key, rule, r }) => {
-    const src = publicRuleWrapperSource(rule, entryFnText(r, rule), ctx.triviaKindLabels);
+    const src = publicRuleWrapperSource(rule, entryFnText(r, rule), ctx.triviaKindLabels, ctx.rootTriviaClassified);
     return `    ${JSON.stringify(key)}: ${src.split("\n").join("\n    ")}`;
   }).join(",\n");
   const replacement = [
@@ -10044,6 +10382,7 @@ function compileRuleMap(ruleMap, opts) {
     // host check passes vacuously — see `withHostMode` in the plugin.
     hostMode: ctx.hostMode ?? "ast",
     hostBranchElided: !!ctx.hostBranchElided,
+    reflection: collectGrammarReflection(ruleMap),
     ...ctx.coverage === void 0 ? {} : { coverageDefinitions: ctx.coverage.plan.definitions }
   };
 }
@@ -10053,6 +10392,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
   if (opts?.duplication !== void 0) runDuplicationDiagnosticRules(ruleMapArg, opts.duplication);
   for (const [, rule] of ruleMapArg) markUnusedValues(rule);
   const grammarTrivia = opts?.trivia ?? ruleMapArg.map(([, r]) => r._meta.grammarTrivia).find(Boolean);
+  const rootTriviaClassified = grammarTrivia?._meta.rootTriviaClassified === true || ruleMapArg.some(([, rule]) => rule._meta.rootTriviaClassified === true);
   const grammarScanSkip = opts?.scanSkip ?? ruleMapArg.map(([, r]) => r._meta.grammarScanSkip).find(Boolean);
   const grammarHostMode = opts?.hostMode ?? ruleMapArg.map(([, r]) => r._meta.grammarHostMode).find(Boolean);
   const grammarTrackLines = opts?.trackLines === true || ruleMapArg.some(([, r]) => r._meta.grammarTrackLines === true);
@@ -10066,6 +10406,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
       return false;
     }
   });
+  const nodeMeta = new Map(ruleMap.map(([name, rule]) => [name, collectGrammarReflection([[name, rule]], { followLazy: false })]));
   const ctx = {
     vars: 0,
     indent: 1,
@@ -10095,7 +10436,11 @@ function compileLinkable(ruleMapArg, ns, opts) {
     lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),
     ns,
     deferFirstSetRefs: true,
-    ...grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {},
+    ...rootTriviaClassified ? { rootTriviaClassified: true } : {},
+    ...grammarTrivia ? {
+      activeTrivia: grammarTrivia,
+      triviaKindLabels: grammarTrivia._meta.triviaKindLabels
+    } : {},
     ...grammarScanSkip ? { activeScanSkip: grammarScanSkip } : {}
   };
   const seen = /* @__PURE__ */ new Map();
@@ -10141,7 +10486,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
         scanExternal(resolved);
         return;
       }
-      for (const child of childrenOf2(def)) scanExternal(child);
+      for (const child of childrenOf3(def)) scanExternal(child);
     };
     for (const [, rule] of ruleMap) scanExternal(rule);
   }
@@ -10227,7 +10572,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
       ...r.stmts,
       `  return { ok: true, value: ${r.valueVar}, span: ${resultSpan} }`,
       `}`
-    ].join("\n"), ctx.triviaKindLabels));
+    ].join("\n"), ctx.triviaKindLabels, ctx.rootTriviaClassified));
   }
   const firstSets = /* @__PURE__ */ new Map();
   const firstSetRecipes = /* @__PURE__ */ new Map();
@@ -10263,6 +10608,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
     hostBranchElided: !!ctx.hostBranchElided,
     hasDirectBuilders: ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
     isRecognitionOnly: !hasSemanticReduction(ruleMap.map(([, rule]) => rule), externalRefs),
+    nodeMeta,
     mfFns: mfSrcs ? [] : ctx.mapFns,
     buildFns: buildSrcs ? [] : ctx.buildFns
   };
@@ -10283,7 +10629,7 @@ function hasExternalRuleRef(ruleMap) {
       if (resolved === void 0) return p._ruleName !== void 0;
       return visit(resolved);
     }
-    return childrenOf2(def).some(visit);
+    return childrenOf3(def).some(visit);
   };
   return ruleMap.some(([, rule]) => visit(rule));
 }
@@ -10305,7 +10651,7 @@ function hasSemanticReduction(roots, externalRefs) {
         return true;
       }
     }
-    return childrenOf2(def).some(visit);
+    return childrenOf3(def).some(visit);
   };
   return roots.some(visit);
 }
@@ -10378,7 +10724,7 @@ function withCtx(extra, combinator) {
 }
 
 // src/compiler/ir-serialize.ts
-function childrenOf3(def) {
+function childrenOf4(def) {
   switch (def.tag) {
     case "sequence":
     case "choice":
@@ -10442,6 +10788,10 @@ function projectOpt(project) {
   if (project === void 0) return void 0;
   return `project: ${project}`;
 }
+function tagsOpt(tags) {
+  if (tags === void 0 || tags.length === 0) return void 0;
+  return `tags: ${JSON.stringify(tags)}`;
+}
 function matcherExpr(entry) {
   switch (entry.kind) {
     case "startsWith":
@@ -10571,6 +10921,7 @@ function evalRuleMapIR(ir) {
     "transform",
     "skip",
     "trivia",
+    "classifiedTrivia",
     "label",
     "field",
     "expect",
@@ -10611,6 +10962,7 @@ function evalRuleMapIR(ir) {
     transform,
     skip,
     trivia,
+    classifiedTrivia,
     label,
     field,
     expect,
@@ -10655,7 +11007,7 @@ var Serializer = class {
       if (target) this.assertNoRuleRef(target, seen);
       return;
     }
-    for (const child of childrenOf3(c._def)) this.assertNoRuleRef(child, seen);
+    for (const child of childrenOf4(c._def)) this.assertNoRuleRef(child, seen);
   }
   /** A `rules()` map wraps each rule value in a named `lazy` proxy; the real body is
    * its target (compileLinkable unwraps the same way). A ref INSIDE a body stays a
@@ -10719,7 +11071,7 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
     this.counts.set(c, (this.counts.get(c) ?? 0) + 1);
     if ((this.counts.get(c) ?? 0) > 1) return;
     active.add(c);
-    for (const child of childrenOf3(def)) this.analyze(child, active);
+    for (const child of childrenOf4(def)) this.analyze(child, active);
     active.delete(c);
   }
   /** Reference `c`: a const var if it has one (emitting its decl first), else inline.
@@ -10836,12 +11188,14 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
       case "node": {
         if (def.build !== void 0 && def.buildSrc === void 0) throw new Unserializable("node build without buildSrc");
         const projectEntry = projectOpt(def.project);
+        const tagEntry = tagsOpt(def.tags);
         const optEntries = [
           ...def.unwrap ? ["unwrap: true"] : [],
           ...def.collapse ? ["collapse: true"] : [],
           ...projectEntry === void 0 ? [] : [projectEntry],
           ...def.captureTrivia ? ["captureTrivia: true"] : [],
-          ...def.trailingTrivia ? ["trailingTrivia: true"] : []
+          ...def.trailingTrivia ? ["trailingTrivia: true"] : [],
+          ...tagEntry === void 0 ? [] : [tagEntry]
         ];
         const opts = optEntries.length > 0 ? `, { ${optEntries.join(", ")} }` : "";
         if (def.type === void 0) {
@@ -10855,8 +11209,11 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
         return opts ? `node(${JSON.stringify(def.type)}, ${kid(def.parser)}, undefined${opts})` : `node(${JSON.stringify(def.type)}, ${kid(def.parser)})`;
       }
       case "grammar": {
-        const trivia2 = def.clearTrivia ? "null" : def.triviaParser ? kid(def.triviaParser) : "undefined";
-        return `parser({ trivia: ${trivia2}${def.captureTrivia ? ", captureTrivia: true" : ""}${def.trackLines ? ", trackLines: true" : ""} }, ${kid(def.parser)})`;
+        const classified = def.triviaParser?._meta.rootTriviaClassified === true;
+        const spec = classified && def.triviaParser ? analyzeLabeledTrivia(def.triviaParser) : null;
+        if (classified && !spec) throw new Unserializable("classified trivia without labeled arms");
+        const trivia2 = def.clearTrivia ? "null" : spec ? `classifiedTrivia({ ${spec.arms.map((arm) => `${JSON.stringify(arm.label)}: ${kid(arm.parser)}`).join(", ")} })` : def.triviaParser ? kid(def.triviaParser) : "undefined";
+        return `parser({ trivia: ${trivia2}${def.captureTrivia ? ", captureTrivia: true" : ""}${def.rootCapture ? `, rootCapture: ${JSON.stringify(def.rootCapture)}` : ""}${def.trackLines ? ", trackLines: true" : ""} }, ${kid(def.parser)})`;
       }
       case "withCtx": {
         if (def.extraSrc === void 0) throw new Unserializable("withCtx without extraSrc");
@@ -10879,15 +11236,16 @@ function normalizeCstCollapse(collapse) {
   }
   return typeof collapse === "function" ? collapse : void 0;
 }
-function buildCstNode(type, children2, _fields, span, _rawChildren, _triviaLog, state) {
-  return { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children2] };
+function buildCstNode(type, children2, _fields, span, _rawChildren, _triviaLog, state, tags) {
+  return tags !== void 0 && tags.length > 0 ? { _tag: "node", type, tags, span: { ...span }, state: state ?? null, children: [...children2] } : { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children2] };
 }
-function cstBuildHost(typeOrOptions, children2, _fields, span, rawChildren, triviaLog, state) {
+function cstBuildHost(typeOrOptions, children2, _fields, span, rawChildren, triviaLog, state, _tags) {
   if (typeof typeOrOptions === "string") {
     return buildCstNode(typeOrOptions, children2 ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state);
   }
   const collapse = normalizeCstCollapse(typeOrOptions?.collapse);
-  const host = (type, children3, fields, span2, rawChildren2, triviaLog2, state2) => buildCstNode(type, children3 ?? [], fields, span2, rawChildren2, triviaLog2, state2);
+  const materializeTags = typeOrOptions?.tags === true;
+  const host = (type, children3, fields, span2, rawChildren2, triviaLog2, state2, tags) => buildCstNode(type, children3 ?? [], fields, span2, rawChildren2, triviaLog2, state2, materializeTags ? tags : void 0);
   host._parsemanCstOutput = true;
   if (collapse) host._parsemanCstCollapse = collapse;
   return host;
@@ -10908,7 +11266,7 @@ function pickPieces(pieces, names) {
   };
   for (const n of names) visit(n);
   const filt = (m, pc) => new Map([...m].filter(([k]) => keep.has(k) && winner.get(k) === pc));
-  return pieces.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) })).filter((pc) => pc.keys.length > 0);
+  return pieces.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), nodeMeta: filt(pc.nodeMeta, pc) })).filter((pc) => pc.keys.length > 0);
 }
 function fusedBody(pieces) {
   for (const p of pieces) {
@@ -10946,6 +11304,7 @@ function fusedBody(pieces) {
     ...[...winner].map(([k, p]) => p.ruleFns.get(k))
   ];
   const wrapperEntries = [...winner].map(([k, p]) => `${JSON.stringify(k)}: ${p.wrappers.get(k)}`);
+  const reflection = mergeGrammarReflections([...winner].map(([k, p]) => p.nodeMeta.get(k) ?? { nodes: [] }));
   const { mode, elided } = hostModeOfPieces(pieces);
   const rawBody = [
     ...lines,
@@ -10954,6 +11313,7 @@ function fusedBody(pieces) {
     "}",
     `Object.defineProperty(_map, Symbol.for(${JSON.stringify(FUSED_HOST_MODE.description)}), { value: ${JSON.stringify(mode)}, enumerable: false })`,
     `Object.defineProperty(_map, Symbol.for(${JSON.stringify(FUSED_HOST_ELIDED.description)}), { value: ${JSON.stringify(elided)}, enumerable: false })`,
+    `Object.defineProperty(_map, Symbol.for('parseman.grammarReflection'), { value: ${grammarReflectionSource(reflection)}, enumerable: false })`,
     // …and on each rule FUNCTION, because `run(map.Rule, …)` is handed the rule, not the
     // map, and would otherwise have nothing to check against. Done once at fuse time,
     // before any rule has been called, so it costs nothing per parse.
@@ -11085,10 +11445,6 @@ function gate(predicate) {
   };
 }
 
-// src/cst/trivia-entries.ts
-var EMPTY_INDICES = Object.freeze([]);
-var EMPTY_GAPS = Object.freeze([]);
-
 // src/cst/offset-model.ts
 var { isFinite } = Number;
 
@@ -11244,19 +11600,19 @@ function directBuilderUnsupportedBindings(src) {
 // src/plugin/evaluator.ts
 function stripTsFromSource(node2, code) {
   const cuts = [];
-  const walk2 = (n) => {
+  const walk = (n) => {
     if (!n || typeof n !== "object") return;
     const rec = n;
     if (typeof rec.type === "string" && rec.type.startsWith("TS") && typeof rec.start === "number" && typeof rec.end === "number") {
       const ex = rec.expression;
       if ((rec.type === "TSAsExpression" || rec.type === "TSSatisfiesExpression" || rec.type === "TSNonNullExpression" || rec.type === "TSInstantiationExpression") && ex && typeof ex.end === "number") {
         cuts.push([ex.end, rec.end]);
-        walk2(rec.expression);
+        walk(rec.expression);
         return;
       }
       if (rec.type === "TSTypeAssertion" && ex && typeof ex.start === "number") {
         cuts.push([rec.start, ex.start]);
-        walk2(rec.expression);
+        walk(rec.expression);
         return;
       }
       cuts.push([rec.start, rec.end]);
@@ -11266,11 +11622,11 @@ function stripTsFromSource(node2, code) {
       if (key === "type" || key === "start" || key === "end") continue;
       const v2 = rec[key];
       if (Array.isArray(v2)) {
-        for (const item of v2) walk2(item);
-      } else if (v2 && typeof v2 === "object") walk2(v2);
+        for (const item of v2) walk(item);
+      } else if (v2 && typeof v2 === "object") walk(v2);
     }
   };
-  walk2(node2);
+  walk(node2);
   const start = node2.start;
   const end = node2.end;
   if (cuts.length === 0) return code.slice(start, end);
@@ -11340,6 +11696,9 @@ var SUPPORTED = {
   optional: (...a) => optional(a[0]),
   skip: (...a) => skip(a[0], a[1]),
   trivia: (...a) => trivia(a[0]),
+  classifiedTrivia: (...a) => classifiedTrivia(
+    a[0]
+  ),
   label: (...a) => label(a[0], a[1]),
   field: (...a) => field(a[0], a[1]),
   noTrivia: (...a) => noTrivia(a[0]),
@@ -11449,10 +11808,38 @@ function scopeGet(scope, name, mfs) {
   if (isCombinator(entry)) return entry;
   return null;
 }
+function unwrapStaticExpr(expr) {
+  let cur = expr;
+  while (cur.type === "TSAsExpression" || cur.type === "TSSatisfiesExpression" || cur.type === "TSNonNullExpression" || cur.type === "TSTypeAssertion" || cur.type === "TSInstantiationExpression" || cur.type === "ParenthesizedExpression") {
+    if (!cur.expression) break;
+    cur = cur.expression;
+  }
+  return cur;
+}
 function staticLiteralValue(expr) {
-  const val = expr;
+  const val = unwrapStaticExpr(expr);
   return val.type === "Literal" || val.type === "BooleanLiteral" || val.type === "NumericLiteral" ? val.value : void 0;
 }
+function staticStringArray(expr, scope) {
+  const id = unwrapStaticExpr(expr);
+  if (id.type === "Identifier" && scope !== void 0 && id.name !== void 0) {
+    const scoped = scope.get(id.name);
+    const value = isStaticValueEntry(scoped) ? scoped.value : scoped;
+    return Array.isArray(value) && value.every((v2) => typeof v2 === "string") ? value : void 0;
+  }
+  const arr = id;
+  if (arr.type !== "ArrayExpression" || !Array.isArray(arr.elements)) return void 0;
+  const out = [];
+  for (const el of arr.elements) {
+    if (!el || el.type === "SpreadElement") return void 0;
+    const value = staticLiteralValue(el);
+    if (typeof value !== "string") return void 0;
+    out.push(value);
+  }
+  return out;
+}
+var STATIC_NODE_OPTIONS_FAILED = /* @__PURE__ */ Symbol("parseman.staticNodeOptions.failed");
+var STATIC_NODE_OPTIONS_NOT_OPTIONS = /* @__PURE__ */ Symbol("parseman.staticNodeOptions.notOptions");
 function staticNodeProject(expr) {
   const literalValue = staticLiteralValue(expr);
   if (typeof literalValue === "number" && Number.isInteger(literalValue) && literalValue >= 0) {
@@ -11461,23 +11848,60 @@ function staticNodeProject(expr) {
   if (typeof literalValue === "number" || literalValue !== void 0) return { ok: false };
   return { ok: false };
 }
-function staticNodeOptions(expr) {
-  if (expr.type !== "ObjectExpression") return void 0;
+function scopedStaticValue(expr, scope) {
+  const unwrapped = unwrapStaticExpr(expr);
+  if (unwrapped.type !== "Identifier" || unwrapped.name === "undefined") return { found: false };
+  if (!scope.has(unwrapped.name)) return { found: false };
+  const scoped = scope.get(unwrapped.name);
+  const value = isStaticValueEntry(scoped) ? scoped.value : scoped;
+  return { found: true, value };
+}
+function staticNodeOptionsFromValue(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || isCombinator(value)) return STATIC_NODE_OPTIONS_NOT_OPTIONS;
+  const opts = {};
+  const rec = value;
+  for (const name of Object.keys(rec)) {
+    const v2 = rec[name];
+    if (name === "unwrap" || name === "collapse" || name === "captureTrivia" || name === "trailingTrivia") {
+      if (v2 === true) opts[name] = true;
+      else if (v2 !== false && v2 !== void 0) return STATIC_NODE_OPTIONS_FAILED;
+    } else if (name === "project") {
+      if (typeof v2 !== "number" || !Number.isInteger(v2) || v2 < 0) return STATIC_NODE_OPTIONS_FAILED;
+      opts.project = v2;
+    } else if (name === "tags") {
+      if (!Array.isArray(v2) || !v2.every((item) => typeof item === "string")) return STATIC_NODE_OPTIONS_FAILED;
+      opts.tags = v2;
+    }
+  }
+  return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia || opts.tags !== void 0 ? opts : void 0;
+}
+function staticNodeOptions(expr, scope) {
+  const unwrapped = unwrapStaticExpr(expr);
+  const scoped = scopedStaticValue(unwrapped, scope);
+  if (scoped.found) return staticNodeOptionsFromValue(scoped.value);
+  if (unwrapped.type !== "ObjectExpression") return STATIC_NODE_OPTIONS_NOT_OPTIONS;
   const opts = {};
-  for (const prop of expr.properties) {
+  for (const prop of unwrapped.properties) {
+    if (prop.type !== "Property") return STATIC_NODE_OPTIONS_FAILED;
     const p = prop;
-    if (p.computed) continue;
+    if (p.computed) return STATIC_NODE_OPTIONS_FAILED;
     const key = p.key;
     const name = key.type === "Identifier" ? key.name : key.type === "Literal" ? String(key.value) : void 0;
     if (name === "unwrap" || name === "collapse" || name === "captureTrivia" || name === "trailingTrivia") {
-      if (staticLiteralValue(p.value) === true) opts[name] = true;
+      const value = staticLiteralValue(p.value);
+      if (value === true) opts[name] = true;
+      else if (value !== false && value !== void 0) return STATIC_NODE_OPTIONS_FAILED;
     } else if (name === "project") {
       const project = staticNodeProject(p.value);
-      if (project?.ok === false) return { project: -1 };
+      if (project?.ok === false) return STATIC_NODE_OPTIONS_FAILED;
       if (project !== void 0) opts.project = project.value;
+    } else if (name === "tags") {
+      const tags = staticStringArray(p.value, scope);
+      if (tags === void 0) return STATIC_NODE_OPTIONS_FAILED;
+      opts.tags = tags;
     }
   }
-  return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia ? opts : void 0;
+  return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia || opts.tags !== void 0 ? opts : void 0;
 }
 function exprToCombi(node2, scope, code, mfs) {
   if (node2.type === "Identifier") return scopeGet(scope, node2.name, mfs);
@@ -11552,10 +11976,23 @@ function exprToCombi(node2, scope, code, mfs) {
     const inner = anyValue(parserArg, scope, code, mfs);
     if (!isCombinator(inner)) return null;
     const be = buildArg;
-    const hasBuild = be !== void 0 && be.type !== "SpreadElement" && be.type !== "ObjectExpression" && !(be.type === "Identifier" && be.name === "undefined");
+    const buildExpr = be === void 0 || be.type === "SpreadElement" ? void 0 : unwrapStaticExpr(be);
+    const buildArgOptions = be !== void 0 && be.type !== "SpreadElement" ? staticNodeOptions(buildArg, scope) : STATIC_NODE_OPTIONS_NOT_OPTIONS;
+    if (buildArgOptions === STATIC_NODE_OPTIONS_FAILED) return null;
+    const buildArgIsOptions = buildArgOptions !== STATIC_NODE_OPTIONS_NOT_OPTIONS;
+    const scopedBuild = buildExpr === void 0 ? { found: false } : scopedStaticValue(buildExpr, scope);
+    const absentBuild = buildExpr?.type === "Identifier" && buildExpr.name === "undefined" || buildExpr !== void 0 && staticLiteralValue(buildExpr) === null || scopedBuild.found && (scopedBuild.value === void 0 || scopedBuild.value === null);
+    const hasBuild = be !== void 0 && be.type !== "SpreadElement" && !buildArgIsOptions && !absentBuild;
     const buildSrc = hasBuild ? stripTsFromSource(be, code) : void 0;
-    const optionsArg = hasBuild ? optsArg : be?.type === "ObjectExpression" ? buildArg : optsArg;
-    const opts = optionsArg !== void 0 && optionsArg.type !== "SpreadElement" ? staticNodeOptions(optionsArg) : void 0;
+    let opts;
+    if (buildArgIsOptions) {
+      opts = buildArgOptions;
+    } else if (optsArg !== void 0) {
+      if (optsArg.type === "SpreadElement") return null;
+      const optsResult = staticNodeOptions(optsArg, scope);
+      if (optsResult === STATIC_NODE_OPTIONS_FAILED || optsResult === STATIC_NODE_OPTIONS_NOT_OPTIONS) return null;
+      opts = optsResult;
+    }
     try {
       const combi = explicitType !== void 0 ? node(explicitType, inner, hasBuild ? () => null : void 0, opts) : node(inner, hasBuild ? () => null : void 0, opts);
       if (combi._def.tag === "node" && buildSrc !== void 0) {
@@ -11778,6 +12215,10 @@ function exprToCombi(node2, scope, code, mfs) {
   }
 }
 function anyValue(node2, scope, code, mfs) {
+  if (node2.type === "TSAsExpression" || node2.type === "TSSatisfiesExpression" || node2.type === "TSNonNullExpression" || node2.type === "TSTypeAssertion" || node2.type === "TSInstantiationExpression" || node2.type === "ParenthesizedExpression") {
+    const inner = node2.expression;
+    return inner ? anyValue(inner, scope, code, mfs) : null;
+  }
   if (node2.type === "Literal") {
     if ("regex" in node2 && node2.regex !== null && node2.regex !== void 0) {
       return new RegExp(node2.regex.pattern, node2.regex.flags);
@@ -11901,6 +12342,9 @@ function collectRuleKeys(retObj) {
   }
   return out;
 }
+function evaluateStaticValue(node2, scope, code) {
+  return anyValue(node2, scope, code, []);
+}
 function flattenRuleEntries(retObj, scope, code) {
   const out = [];
   for (const prop of retObj.properties) {
@@ -12066,6 +12510,18 @@ function referencesAny(node2, names, scope) {
 // src/plugin/index.ts
 var import_node_crypto = require("node:crypto");
 var PARSEMAN_MODULE = "parseman";
+function unwrapStaticExpression(expr) {
+  let cur = expr;
+  while (cur.type === "TSAsExpression" || cur.type === "TSSatisfiesExpression" || cur.type === "TSNonNullExpression" || cur.type === "TSTypeAssertion" || cur.type === "TSInstantiationExpression" || cur.type === "ParenthesizedExpression") {
+    if (!cur.expression) break;
+    cur = cur.expression;
+  }
+  return cur;
+}
+function isStaticNullishExpression(expr) {
+  const unwrapped = unwrapStaticExpression(expr);
+  return unwrapped.type === "Identifier" && unwrapped.name === "undefined" || unwrapped.type === "Literal" && unwrapped.value === null;
+}
 var _compiledResolver = null;
 function getCompiledResolver() {
   return _compiledResolver ??= new import_oxc_resolver.ResolverFactory({
@@ -12548,6 +13004,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       ruleMap: evaluated.ruleMap,
       hostMode: compiled?.hostMode ?? "ast",
       hostBranchElided: compiled?.hostBranchElided ?? false,
+      reflection: compiled?.reflection ?? { nodes: [] },
       ...compiled?.coverageDefinitions ? { coverageDefinitions: compiled.coverageDefinitions } : {},
       ...evaluated.trivia ? { trivia: evaluated.trivia } : {},
       ...evaluated.scanSkip ? { scanSkip: evaluated.scanSkip } : {},
@@ -12568,7 +13025,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     const mapLit = (m, stripVals = false) => `new Map([${[...m].map(
       ([k, v2]) => `[${JSON.stringify(k)}, ${JSON.stringify(stripVals && typeof v2 === "string" ? stripIndent(v2) : v2)}]`
     ).join(", ")}])`;
-    return `{ v: ${JSON.stringify(p.v)}, ns: ${JSON.stringify(p.ns)}, keys: ${JSON.stringify(p.keys)}, prelude: ${JSON.stringify(p.prelude.map(stripIndent))}, ruleFns: ${mapLit(p.ruleFns, true)}, wrappers: ${mapLit(p.wrappers, true)}, firstSets: ${mapLit(p.firstSets)}, nullable: ${p.nullable ? mapLit(p.nullable) : "new Map()"}, firstSetRecipes: ${p.firstSetRecipes ? mapLit(p.firstSetRecipes) : "new Map()"}, deps: ${mapLit(p.deps)}, hostMode: ${JSON.stringify(p.hostMode ?? "ast")}, hostBranchElided: ${p.hostBranchElided === true}, needsEmptyTl: ${p.needsEmptyTl}, needsHostReads: ${p.needsHostReads}, hasDirectBuilders: ${p.hasDirectBuilders === true}, isRecognitionOnly: ${p.isRecognitionOnly === true}, mfFns: [], buildFns: [] }`;
+    return `{ v: ${JSON.stringify(p.v)}, ns: ${JSON.stringify(p.ns)}, keys: ${JSON.stringify(p.keys)}, prelude: ${JSON.stringify(p.prelude.map(stripIndent))}, ruleFns: ${mapLit(p.ruleFns, true)}, wrappers: ${mapLit(p.wrappers, true)}, firstSets: ${mapLit(p.firstSets)}, nullable: ${p.nullable ? mapLit(p.nullable) : "new Map()"}, firstSetRecipes: ${p.firstSetRecipes ? mapLit(p.firstSetRecipes) : "new Map()"}, deps: ${mapLit(p.deps)}, nodeMeta: ${mapLit(p.nodeMeta)}, hostMode: ${JSON.stringify(p.hostMode ?? "ast")}, hostBranchElided: ${p.hostBranchElided === true}, needsEmptyTl: ${p.needsEmptyTl}, needsHostReads: ${p.needsHostReads}, hasDirectBuilders: ${p.hasDirectBuilders === true}, isRecognitionOnly: ${p.isRecognitionOnly === true}, mfFns: [], buildFns: [] }`;
   };
   const isSpread = (it) => "__spreadLocal" in it;
   const isIR = (it) => "ir" in it && !("ruleFns" in it);
@@ -12577,6 +13034,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const withCarriedPieces = (grammarExpr, list) => `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.composedPieces'), { value: ${serializeList(list)}, enumerable: false })`;
   const withLeafMarker = (grammarExpr) => `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.leafComposed'), { value: true, enumerable: false })`;
   const withHostMode = (grammarExpr, mode, elided) => `/* @__PURE__ */ (m => { for (const k of Object.keys(m)) { Object.defineProperty(m[k], Symbol.for('parseman.fusedHostMode'), { value: ${JSON.stringify(mode)}, enumerable: false }); Object.defineProperty(m[k], Symbol.for('parseman.fusedHostElided'), { value: ${JSON.stringify(elided)}, enumerable: false }) } Object.defineProperty(m, Symbol.for('parseman.fusedHostMode'), { value: ${JSON.stringify(mode)}, enumerable: false }); Object.defineProperty(m, Symbol.for('parseman.fusedHostElided'), { value: ${JSON.stringify(elided)}, enumerable: false }); return m })(${grammarExpr})`;
+  const withGrammarReflection = (grammarExpr, reflection) => `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.grammarReflection'), { value: ${grammarReflectionSource(reflection)}, enumerable: false })`;
   const withCoverageDefinitions = (grammarExpr, definitions) => !grammarCoverage ? grammarExpr : `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.grammarCoverageDefinitions'), { value: Object.freeze(${JSON.stringify(definitions)}.map(Object.freeze)), enumerable: false })`;
   const emittedCoverageDefinitions = (source) => {
     const ids = /* @__PURE__ */ new Set();
@@ -12972,7 +13430,14 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       const kind = vd.kind ?? "const";
       if (d.id.type === "Identifier") {
         const varName = d.id.name;
-        if (!referencesAny(init, allNames, scope)) continue;
+        if (!referencesAny(init, allNames, scope)) {
+          const staticValue = evaluateStaticValue(init, scope, code);
+          if (staticValue !== null && staticValue !== void 0 || isStaticNullishExpression(init)) {
+            ;
+            scope.set(varName, staticValue);
+          }
+          continue;
+        }
         if (refNames.has(varName)) {
           const refEntry = scope.get(varName);
           const refCombi = refEntry?.combi ?? null;
@@ -13012,6 +13477,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           );
           if (compiledRules.replacement !== null) {
             replacement = withHostMode(replacement, compiledRules.hostMode, compiledRules.hostBranchElided);
+            replacement = withGrammarReflection(replacement, compiledRules.reflection);
           }
           if (exportPrefix && pieces && !pieces.mfFns.length && !pieces.buildFns.length) {
             const ir = serializeRuleMap([...compiledRules.ruleMap], compiledRules.scanSkip);
@@ -13039,7 +13505,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         if (isComposeLeafCall(init)) {
           const fused = compileComposeLeafCall(init);
           if (!fused) {
-            throw new Error(`${id}:${lineOf(init.start)} \u2014 composeLeaf() must macro-fuse; runtime composition is forbidden`);
+            const reasons = warnings.slice(-4);
+            throw new Error(
+              `${id}:${lineOf(init.start)} \u2014 composeLeaf() must macro-fuse; runtime composition is forbidden` + (reasons.length ? `
+  causes:
+  - ${reasons.join("\n  - ")}` : "")
+            );
           }
           replacements.push({ start: init.start, end: init.end, replacement: fused.replacement });
           markUsedImportedFactories(fused.importedFactories);
@@ -13068,6 +13539,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
             scope.set(varName, combiArray);
             continue;
           }
+          const staticValue = evaluateStaticValue(init, scope, code);
+          if (staticValue !== null && staticValue !== void 0 || isStaticNullishExpression(init)) {
+            ;
+            scope.set(varName, staticValue);
+            continue;
+          }
           if (factoryDecls.has(varName)) continue;
           warn(init.start, `"${varName}" references a parseman macro import but isn't a statically-evaluable combinator`);
           continue;
@@ -13143,7 +13620,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const replacementRanges = runtimeComposeFallback ? [] : replacements.map(({ start, end }) => ({ start, end }));
   const isInsideReplacement = (start, end) => replacementRanges.some((r) => start >= r.start && end <= r.end);
   const importedBindingStillReferenced = (local) => {
-    const walk2 = (node2, parent, parentKey) => {
+    const walk = (node2, parent, parentKey) => {
       if (!node2 || typeof node2 !== "object") return false;
       const rec = node2;
       if (rec.type === "ImportDeclaration") return false;
@@ -13158,14 +13635,14 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         if (key === "type" || key === "start" || key === "end") continue;
         const value = rec[key];
         if (Array.isArray(value)) {
-          if (value.some((child) => walk2(child, rec, key))) return true;
-        } else if (walk2(value, rec, key)) {
+          if (value.some((child) => walk(child, rec, key))) return true;
+        } else if (walk(value, rec, key)) {
           return true;
         }
       }
       return false;
     };
-    return body.some((stmt) => walk2(stmt));
+    return body.some((stmt) => walk(stmt));
   };
   for (const imp of ordinaryImports) {
     if (!runtimeComposeFallback && imp.specifiers.length > 0 && imp.specifiers.every(