parseman 0.43.0 → 0.44.0

package/dist/index.js

@@ -1053,1035 +1053,1099 @@ 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(fs) {
-  if (fs.kind !== "ranges" || fs.ranges.length === 0) return null;
-  const ranges = fs.ranges;
-  return {
-    _tag: "firstSetSentinel",
-    _meta: { firstSet: fs, 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 };
 }
-var REC = { scan: recoverScan, at: matchesAt, or: orSentinel, sentinel: firstSetSentinel, capture: captureError };
-
-// 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;
     }
-  };
-}
-function isParseError(value) {
-  return typeof value === "object" && value !== null && value._tag === "parseError";
+  }
 }
-
-// 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, fs) {
-  if (fs.kind === "any") return true;
-  if (fs.kind === "empty") return false;
-  for (const r of fs.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 fs = parsers[i]._meta.firstSet;
-    if (fs.kind !== "ranges") continue;
-    for (const { lo, hi } of fs.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;
+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;
       }
-      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 });
+      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(fs) {
+  if (fs.kind !== "ranges" || fs.ranges.length === 0) return null;
+  const ranges = fs.ranges;
+  return {
+    _tag: "firstSetSentinel",
+    _meta: { firstSet: fs, 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);
-      }
-    };
-  }
-  const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
-  return { end: tr.ok ? tr.span.end : cur, commit: NOOP_COMMIT };
+  };
 }
-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 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 fastTriviaScanner(trivia2) {
-  const cached = fastTriviaCache.get(trivia2);
-  if (cached !== void 0) return cached;
-  const scanner = buildFastTriviaScanner(trivia2);
-  fastTriviaCache.set(trivia2, scanner);
-  return scanner;
+function matchesAt(sentinel, input, pos, ctx) {
+  return probeAt(sentinel, input, pos, ctx);
 }
-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 captureError(ctx, error) {
+  if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error);
 }
-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;
+var REC = { scan: recoverScan, at: matchesAt, or: orSentinel, sentinel: firstSetSentinel, capture: captureError };
+
+// 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 fs = parsers.slice(i + 1).reduce(
+        (acc, p) => union(acc, firstSetOf(p)),
+        { kind: "empty" }
+      );
+      return firstSetSentinel(fs);
+    });
+    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;
       }
-      break;
+    } 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 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);
+
+// src/combinators/expect.ts
+function deriveExpected(c) {
+  return [...new Set(derive(c, /* @__PURE__ */ new Set()))];
 }
-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 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 [];
   }
-  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 expect(combinator, label2) {
+  const expected = label2 !== void 0 ? [label2] : deriveExpected(combinator);
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
   };
-}
-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 {
+    _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 } };
     }
-    return pos;
   };
 }
-function classRunSource(source) {
-  const m = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]$/.exec(source);
-  return m ? classScanner(m[1]) : null;
+function isParseError(value) {
+  return typeof value === "object" && value !== null && value._tag === "parseError";
 }
-function classifyTriviaArm(arm) {
-  const cls = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]?$/.exec(arm);
-  if (cls) {
-    const ranges = parseClassRanges(cls[1]);
-    return ranges ? { kind: "class", ranges } : null;
+
+// 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]);
   }
-  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) };
+  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 } };
+      }
+      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 } };
+    }
+  };
+}
+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 };
+  }
+  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);
-  }
-  const ranges = [];
-  const commentCodes = [];
-  for (const arm of arms) {
-    if (arm.kind === "class") ranges.push(...arm.ranges);
-    else commentCodes.push(arm.code);
-  }
-  if (commentCodes.some((code) => inRanges2(code, ranges))) {
-    return loopScanner(arms.map(armScanner));
-  }
-  if (commentCodes.length === 0) return armScanner({ kind: "class", ranges });
-  return fusedTriviaScanner(ranges, commentCodes);
+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 blockCommentSource(source) {
-  return source === "\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/" || source === "\\/\\*[^]*?\\*\\/";
+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);
+  }
+  return value;
 }
-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 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 (contCodes.length === 0) return null;
+  return codesToFirstSet(contCodes);
 }
-
-// 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 fs = parsers.slice(i + 1).reduce(
-        (acc, p) => union(acc, firstSetOf(p)),
-        { kind: "empty" }
-      );
-      return firstSetSentinel(fs);
-    });
-    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;
+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];
     }
-    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;
+  ranges.push({ lo, hi });
+  return { kind: "ranges", ranges };
+}
+function inFirstSet(code, fs) {
+  if (fs.kind === "any") return true;
+  if (fs.kind === "empty") return false;
+  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
+  return false;
+}
+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 buildAsciiDispatch(parsers) {
+  const table = Array(128).fill(-1);
+  for (let i = 0; i < parsers.length; i++) {
+    const fs = parsers[i]._meta.firstSet;
+    if (fs.kind !== "ranges") continue;
+    for (const { lo, hi } of fs.ranges) {
+      for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) {
+        table[code] = i;
       }
-      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
@@ -2344,10 +2408,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 } };
     }
@@ -2788,18 +2854,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;
@@ -2822,7 +2907,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) {
@@ -3505,6 +3594,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,
@@ -3551,6 +3659,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;
@@ -3560,6 +3669,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);
@@ -3573,6 +3683,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;
@@ -3627,7 +3739,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.43.0";
+var PARSEMAN_VERSION = "0.44.0";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -5525,9 +5637,196 @@ 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;
+function entryOffset(i, stride) {
+  return i * stride;
+}
+function triviaEntries(log, labels, opts) {
+  const baseStride = opts?.nodeLog ? 3 : 2;
+  const stride = labels ? baseStride + 1 : baseStride;
+  const length = Math.floor(log.length / stride);
+  return {
+    length,
+    labels,
+    stride,
+    start(i) {
+      return log[entryOffset(i, stride)];
+    },
+    end(i) {
+      return log[entryOffset(i, stride) + 1];
+    },
+    insertIndex(i) {
+      return opts?.nodeLog ? log[entryOffset(i, stride) + 2] : void 0;
+    },
+    kindIndex(i) {
+      if (!labels) return void 0;
+      return log[entryOffset(i, stride) + baseStride];
+    },
+    kind(i) {
+      const ki = labels ? log[entryOffset(i, stride) + baseStride] : void 0;
+      return ki !== void 0 ? labels[ki] : void 0;
+    },
+    text(i, input) {
+      const s = log[entryOffset(i, stride)];
+      const e = log[entryOffset(i, stride) + 1];
+      return input.slice(s, e);
+    }
+  };
+}
+function buildRootTriviaIndex(log, labels) {
+  const length = Math.floor(log.length / SELECTED_ROOT_STRIDE);
+  const markerOffset = (i) => i * SELECTED_ROOT_STRIDE;
+  const ownedRangeStart = (i) => log[markerOffset(i)];
+  const ownedRangeEnd = (i) => log[markerOffset(i) + 1];
+  const markerStart = (i) => log[markerOffset(i) + 2];
+  const markerEnd = (i) => log[markerOffset(i) + 3];
+  const markerKind = (i) => log[markerOffset(i) + 4];
+  const entries = {
+    length,
+    labels,
+    stride: SELECTED_ROOT_STRIDE,
+    start: markerStart,
+    end: markerEnd,
+    insertIndex: () => void 0,
+    kindIndex: markerKind,
+    kind(i) {
+      return labels[markerKind(i)];
+    },
+    text(i, input) {
+      return input.slice(markerStart(i), markerEnd(i));
+    }
+  };
+  const lowerBound = (offset, by) => {
+    let lo = 0;
+    let hi = length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (by(mid) < offset) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo;
+  };
+  const gapRowsAt = (offset, direction) => {
+    const edge = direction === "before" ? ownedRangeEnd : ownedRangeStart;
+    let first = lowerBound(offset, edge);
+    if (first === length || edge(first) !== offset) return void 0;
+    const start = ownedRangeStart(first);
+    const end = ownedRangeEnd(first);
+    while (first > 0 && ownedRangeStart(first - 1) === start && ownedRangeEnd(first - 1) === end) first--;
+    let last = first + 1;
+    while (last < length && ownedRangeStart(last) === start && ownedRangeEnd(last) === end) last++;
+    return [first, last];
+  };
+  const indices = (first, last) => {
+    const out = [];
+    for (let i = first; i < last; i++) out.push(i);
+    return out;
+  };
+  const makeGap = (first, last) => {
+    const start = ownedRangeStart(first);
+    const end = ownedRangeEnd(first);
+    let entryIndices;
+    return {
+      start,
+      end,
+      get entryIndices() {
+        return entryIndices ??= indices(first, last);
+      },
+      hasKind(kind) {
+        for (let i = first; i < last; i++) {
+          if (labels[markerKind(i)] === kind) return true;
+        }
+        return false;
+      },
+      text(input) {
+        return input.slice(start, end);
+      }
+    };
+  };
+  let maps;
+  const getMaps = () => {
+    if (maps !== void 0) return maps;
+    const before = /* @__PURE__ */ new Map();
+    const after = /* @__PURE__ */ new Map();
+    const beforeGaps = /* @__PURE__ */ new Map();
+    const afterGaps = /* @__PURE__ */ new Map();
+    const gaps = [];
+    for (let first = 0; first < length; ) {
+      let last = first + 1;
+      while (last < length && ownedRangeStart(last) === ownedRangeStart(first) && ownedRangeEnd(last) === ownedRangeEnd(first)) last++;
+      const gap = makeGap(first, last);
+      gaps.push(gap);
+      afterGaps.set(gap.start, gap);
+      beforeGaps.set(gap.end, gap);
+      after.set(gap.start, [...gap.entryIndices]);
+      before.set(gap.end, [...gap.entryIndices]);
+      first = last;
+    }
+    maps = { before, after, beforeGaps, afterGaps, gaps };
+    return maps;
+  };
+  return {
+    entries,
+    labels,
+    get before() {
+      return getMaps().before;
+    },
+    get after() {
+      return getMaps().after;
+    },
+    entryIndicesBefore(offset) {
+      const rows = gapRowsAt(offset, "before");
+      return rows ? indices(rows[0], rows[1]) : EMPTY_INDICES;
+    },
+    entryIndicesAfter(offset) {
+      const rows = gapRowsAt(offset, "after");
+      return rows ? indices(rows[0], rows[1]) : EMPTY_INDICES;
+    },
+    gapBefore(offset) {
+      const rows = gapRowsAt(offset, "before");
+      return rows ? makeGap(rows[0], rows[1]) : void 0;
+    },
+    gapAfter(offset) {
+      const rows = gapRowsAt(offset, "after");
+      return rows ? makeGap(rows[0], rows[1]) : void 0;
+    },
+    gaps() {
+      return getMaps().gaps;
+    },
+    gapsWithKind(kind) {
+      const kinds = typeof kind === "string" ? [kind] : kind;
+      const matches2 = [];
+      for (let first = 0; first < length; ) {
+        let last = first + 1;
+        while (last < length && ownedRangeStart(last) === ownedRangeStart(first) && ownedRangeEnd(last) === ownedRangeEnd(first)) last++;
+        let matched = false;
+        for (let i = first; i < last && !matched; i++) {
+          const label2 = labels[markerKind(i)];
+          for (const kind2 of kinds) {
+            if (label2 === kind2) {
+              matched = true;
+              break;
+            }
+          }
+        }
+        if (matched) matches2.push(makeGap(first, last));
+        first = last;
+      }
+      return matches2.length === 0 ? EMPTY_GAPS : matches2;
+    }
+  };
+}
+
 // 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");
@@ -6566,13 +6865,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}`,
@@ -6632,6 +6933,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 [
@@ -6660,7 +6966,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;
 }
@@ -6669,11 +6975,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");
@@ -6689,6 +6997,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`,
@@ -6700,11 +7010,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");
@@ -6727,6 +7039,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`,
@@ -6738,11 +7052,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");
@@ -6965,6 +7281,9 @@ var HOST_READS_DECL = "const _hostReads = (b, n) => { if (b === undefined) retur
 var LINE_TRACK_DECL = "const _trackLines = (_ctx, input, start, end) => { const from = _ctx._lineScannedTo ?? 0; if (end <= from) return; for (let i = from; i < end; i++) if (input.charCodeAt(i) === 10) _ctx._lineStarts.push(i + 1); _ctx._lineScannedTo = end }";
 var LINE_SPAN_DECL = "const _lineCol = (_ctx, offset) => { const starts = _ctx._lineStarts; let lo = 0, hi = starts.length - 1; while (lo < hi) { const mid = (lo + hi + 1) >> 1; if (starts[mid] <= offset) lo = mid; else hi = mid - 1 } return [lo + 1, offset - starts[lo] + 1] }\nconst _spanLines = (_ctx, start, end) => { const s = _lineCol(_ctx, start), e = _lineCol(_ctx, end); return { start, end, startLine: s[0], startColumn: s[1], endLine: e[0], endColumn: e[1] } }";
 var _loweringSink = null;
+function hasSelectedRootTrivia(ctx) {
+  return ctx.rootTriviaClassified === true;
+}
 function v(ctx, prefix = "_v") {
   return `${prefix}${ctx.vars++}`;
 }
@@ -7274,10 +7593,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;
@@ -7487,7 +7808,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 };
@@ -7684,11 +8005,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)
         );
@@ -7697,17 +8020,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)
         );
@@ -7716,7 +8041,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;
@@ -7958,6 +8283,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);
@@ -7970,6 +8296,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`
     ] : [],
@@ -7989,16 +8316,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) {
@@ -8013,11 +8342,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}`,
@@ -8198,11 +8528,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}) {`);
@@ -8217,6 +8549,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;
@@ -8404,21 +8737,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)) {
@@ -8478,9 +8819,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 = [];
@@ -8496,7 +8838,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)} }`)
     ],
@@ -8538,16 +8880,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) {
@@ -8585,6 +8928,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");
@@ -8592,13 +8936,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 sep = emitFallible(def.separator, ctx, sepAtPos, true);
       const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep;
       stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}${sep.mayCommit ? `if (_ctx._fc) ${committedFailBody(ctx)}; ` : ""}break }`);
@@ -8616,19 +8961,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 sep = emitFallible(def.separator, ctx, sepAtPos, true);
       const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep;
-      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${sep.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}${sep.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}`
       );
@@ -8723,6 +9079,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);
@@ -8730,11 +9087,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))
     ],
@@ -8870,16 +9227,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})`,
@@ -9358,6 +9716,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;
@@ -9368,13 +9728,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}`
@@ -9859,6 +10244,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;
@@ -9885,7 +10271,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");
@@ -10033,10 +10423,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 compileLinkable(ruleMapArg, ns, opts) {
   if (!ns) throw new Error("compileLinkable: ns must be a non-empty namespace");
@@ -10044,6 +10435,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);
@@ -10087,7 +10479,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();
@@ -10219,7 +10615,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();
@@ -10568,6 +10964,7 @@ function evalRuleMapIR(ir) {
     "transform",
     "skip",
     "trivia",
+    "classifiedTrivia",
     "label",
     "field",
     "expect",
@@ -10608,6 +11005,7 @@ function evalRuleMapIR(ir) {
     transform,
     skip,
     trivia,
+    classifiedTrivia,
     label,
     field,
     expect,
@@ -10854,8 +11252,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");
@@ -11752,157 +12153,26 @@ function parseDoc(registry, rootRule, input, opts = {}) {
   return new ParseDocImpl(registry, rootRule, opts, { abs: null }, [fail], null, input);
 }
 
-// src/cst/trivia-entries.ts
-var EMPTY_INDICES = Object.freeze([]);
-var EMPTY_GAPS = Object.freeze([]);
-function entryOffset(i, stride) {
-  return i * stride;
-}
-function triviaEntries(log, labels, opts) {
-  const baseStride = opts?.nodeLog ? 3 : 2;
-  const stride = labels ? baseStride + 1 : baseStride;
-  const length = Math.floor(log.length / stride);
-  return {
-    length,
-    labels,
-    stride,
-    start(i) {
-      return log[entryOffset(i, stride)];
-    },
-    end(i) {
-      return log[entryOffset(i, stride) + 1];
-    },
-    insertIndex(i) {
-      return opts?.nodeLog ? log[entryOffset(i, stride) + 2] : void 0;
-    },
-    kindIndex(i) {
-      if (!labels) return void 0;
-      return log[entryOffset(i, stride) + baseStride];
-    },
-    kind(i) {
-      const ki = labels ? log[entryOffset(i, stride) + baseStride] : void 0;
-      return ki !== void 0 ? labels[ki] : void 0;
-    },
-    text(i, input) {
-      const s = log[entryOffset(i, stride)];
-      const e = log[entryOffset(i, stride) + 1];
-      return input.slice(s, e);
-    }
-  };
-}
-function appendEntryRange(map, key, first, last) {
-  let indices = map.get(key);
-  if (!indices) {
-    indices = [];
-    map.set(key, indices);
-  }
-  for (let i = first; i <= last; i++) indices.push(i);
-}
-function buildGap(entries, start, end, first, last) {
-  const entryIndices = [];
-  for (let i = first; i <= last; i++) entryIndices.push(i);
-  return {
-    start,
-    end,
-    entryIndices,
-    hasKind(kind) {
-      for (const i of entryIndices) {
-        if (entries.kind(i) === kind) return true;
-      }
-      return false;
-    },
-    text(input) {
-      return input.slice(start, end);
-    }
-  };
-}
-function buildRootMaps(entries) {
-  const before = /* @__PURE__ */ new Map();
-  const after = /* @__PURE__ */ new Map();
-  const beforeGaps = /* @__PURE__ */ new Map();
-  const afterGaps = /* @__PURE__ */ new Map();
-  const gaps = [];
-  if (entries.length === 0) return { before, after, beforeGaps, afterGaps, gaps };
-  const appendGap = (first2, last, start2, end2) => {
-    const gap = buildGap(entries, start2, end2, first2, last);
-    gaps.push(gap);
-    afterGaps.set(start2, gap);
-    beforeGaps.set(end2, gap);
-    appendEntryRange(after, start2, first2, last);
-    appendEntryRange(before, end2, first2, last);
-  };
-  let first = 0;
-  let start = entries.start(0);
-  let end = entries.end(0);
-  for (let i = 1; i < entries.length; i++) {
-    const nextStart = entries.start(i);
-    const nextEnd = entries.end(i);
-    if (nextStart === end) {
-      end = nextEnd;
-      continue;
-    }
-    appendGap(first, i - 1, start, end);
-    first = i;
-    start = nextStart;
-    end = nextEnd;
-  }
-  appendGap(first, entries.length - 1, start, end);
-  return { before, after, beforeGaps, afterGaps, gaps };
-}
-function buildRootTriviaIndex(log, labels) {
-  const entries = triviaEntries(log, labels);
-  let maps;
-  const getMaps = () => {
-    maps ??= buildRootMaps(entries);
-    return maps;
-  };
-  return {
-    entries,
-    labels,
-    get before() {
-      return getMaps().before;
-    },
-    get after() {
-      return getMaps().after;
-    },
-    entryIndicesBefore(offset) {
-      return getMaps().before.get(offset) ?? EMPTY_INDICES;
-    },
-    entryIndicesAfter(offset) {
-      return getMaps().after.get(offset) ?? EMPTY_INDICES;
-    },
-    gapBefore(offset) {
-      return getMaps().beforeGaps.get(offset);
-    },
-    gapAfter(offset) {
-      return getMaps().afterGaps.get(offset);
-    },
-    gaps() {
-      return getMaps().gaps;
-    },
-    gapsWithKind(kind) {
-      const kinds = typeof kind === "string" ? [kind] : kind;
-      const matches2 = [];
-      for (const gap of getMaps().gaps) {
-        for (const k of kinds) {
-          if (gap.hasKind(k)) {
-            matches2.push(gap);
-            break;
-          }
-        }
-      }
-      return matches2.length === 0 ? EMPTY_GAPS : matches2;
-    }
-  };
-}
-
 // src/functional/run.ts
 var invoke = (r, input, pos, ctx) => typeof r === "function" ? r(input, pos, ctx) : r.parse(input, pos, ctx);
 function triviaKindLabelsFromRunnable(r) {
   if (!r) return void 0;
   if (typeof r === "function") return r._meta?.triviaKindLabels;
   const grammarTrivia = r._meta.grammarTrivia;
-  return r._meta.triviaKindLabels ?? grammarTrivia?._meta.triviaKindLabels ?? (r._def.tag === "grammar" ? r._def.triviaParser?._meta.triviaKindLabels : void 0);
+  return grammarTrivia?._meta.triviaKindLabels ?? r._meta.triviaKindLabels ?? (r._def.tag === "grammar" ? r._def.triviaParser?._meta.triviaKindLabels : void 0);
+}
+function rootTriviaClassifiedFromRunnable(r) {
+  if (!r) return false;
+  if (typeof r === "function") return r._meta?.rootTriviaClassified === true;
+  const grammarTrivia = r._meta.grammarTrivia;
+  return grammarTrivia?._meta.rootTriviaClassified === true || r._meta.rootTriviaClassified === true;
+}
+function makeSelectedRootLabelIndex(labels) {
+  const index = /* @__PURE__ */ Object.create(null);
+  for (let i = 0; i < labels.length; i++) {
+    if (index[labels[i]] === void 0) index[labels[i]] = i;
+  }
+  return index;
 }
 function runOnce(entry, input, options, phase, profileState) {
   if (typeof entry !== "function" && typeof entry?.parse !== "function") {
@@ -11910,13 +12180,31 @@ function runOnce(entry, input, options, phase, profileState) {
       `run(): start production is ${entry === null ? "null" : typeof entry}, not a rule \u2014 the requested grammar rule does not exist (check the rule name).`
     );
   }
-  const triviaLog = [];
+  const rootTriviaSelection = options.rootTrivia?.select;
+  const captureRootTrivia = rootTriviaSelection !== void 0 && rootTriviaSelection.length > 0;
+  const selectedRootLog = captureRootTrivia ? [] : void 0;
+  const selectedRootLabelIndex = captureRootTrivia ? makeSelectedRootLabelIndex(rootTriviaSelection) : void 0;
   const errors = [];
   const profile = profileState ?? (phase === void 0 ? void 0 : { phase, nodes: 0, childSlots: 0, rawSlots: 0, triviaSlots: 0, fieldSlots: 0, hostCalls: 0 });
   const skipGlobalSinks = phase === "recognizer" || phase === "capture";
   const grammarTrivia = typeof entry !== "function" ? entry._meta.grammarTrivia : void 0;
   const grammarScanSkip = typeof entry !== "function" ? entry._meta.grammarScanSkip : void 0;
   const triviaKindLabels = triviaKindLabelsFromRunnable(entry) ?? triviaKindLabelsFromRunnable(options.trivia);
+  if (captureRootTrivia && triviaKindLabels === void 0) {
+    throw new TypeError("run(): rootTrivia.select requires labeled grammar trivia.");
+  }
+  if (captureRootTrivia) {
+    for (const label2 of rootTriviaSelection) {
+      if (!triviaKindLabels.includes(label2)) {
+        throw new TypeError(`run(): rootTrivia.select contains unknown trivia label ${JSON.stringify(label2)}.`);
+      }
+    }
+  }
+  if (captureRootTrivia && !rootTriviaClassifiedFromRunnable(entry) && !rootTriviaClassifiedFromRunnable(options.trivia)) {
+    throw new TypeError(
+      "run(): rootTrivia.select requires classifiedTrivia() at the root."
+    );
+  }
   const stamped = entry;
   assertHostModeCompatible(
     typeof entry === "function" ? stamped[FUSED_HOST_MODE] ?? "ast" : entry._meta.grammarHostMode ?? "ast",
@@ -11925,7 +12213,15 @@ function runOnce(entry, input, options, phase, profileState) {
   );
   const ctx = {
     trackLines: false,
-    ...skipGlobalSinks ? { _pmProfile: profile } : { _triviaLog: triviaLog, _errors: errors, ...profile === void 0 ? {} : { _pmProfile: profile } },
+    ...skipGlobalSinks ? { _pmProfile: profile } : {
+      ...captureRootTrivia ? {
+        _rootTriviaLog: selectedRootLog,
+        _rootTriviaKindIndex: selectedRootLabelIndex,
+        _rootTriviaStrictScopes: true
+      } : {},
+      _errors: errors,
+      ...profile === void 0 ? {} : { _pmProfile: profile }
+    },
     build: options.build,
     state: options.state,
     ...grammarTrivia !== void 0 ? { trivia: grammarTrivia, ...triviaKindLabels ? { triviaKindLabels } : {} } : triviaKindLabels ? { triviaKindLabels } : {},
@@ -11950,9 +12246,13 @@ function runOnce(entry, input, options, phase, profileState) {
     span: r.span ?? { start: 0, end: 0 },
     expected: r.ok ? [] : r.expected ?? [],
     errors,
-    triviaLog,
-    ...triviaKindLabels === void 0 ? {} : { triviaKindLabels },
-    triviaMap: buildRootTriviaIndex(triviaLog, triviaKindLabels),
+    ...selectedRootLog !== void 0 && selectedRootLog.length > 0 ? {
+      rootTrivia: {
+        rows: selectedRootLog,
+        select: rootTriviaSelection,
+        index: buildRootTriviaIndex(selectedRootLog, rootTriviaSelection)
+      }
+    } : {},
     unconsumedFrom
   };
 }
@@ -12638,6 +12938,7 @@ export {
   buildTriviaIndex,
   charClassMembers,
   choice,
+  classifiedTrivia,
   collectLeafSlots,
   commentsIn,
   compile,