parseman 0.46.0 → 0.47.1

package/dist/regex/classes.d.ts

@@ -28,6 +28,34 @@ export declare function readUnicodeEscape(body: string, i: number): {
     cp: number;
     next: number;
 } | null;
+/**
+ * A regex fragment that is a plain run of literal characters → its code points,
+ * or null when the fragment contains any operator (so a caller can never mistake
+ * `a*` for the two-char literal `a*`). An empty fragment returns null, because
+ * every caller wants "at least one char to match".
+ */
+export declare function literalCodePoints(frag: string): number[] | null;
+/**
+ * A single-character MATCHER fragment as a (possibly negated) range set: a
+ * bracketed class `[…]`/`[^…]`, a `\d`/`\w`/`\s` shorthand, or one literal char.
+ * Anything wider (a group, a multi-char literal, `.`) returns null.
+ *
+ * "Bracketed class" means the WHOLE fragment is ONE class. Testing only that it
+ * opens with `[` and ends with `]` is a different, weaker question, and
+ * `[ \t\n\r\f]*[\$(]` answers it while being a SEQUENCE — a whitespace run, then
+ * one of `$(`. Read as a single class its members become the garbage union of
+ * everything between the OUTER brackets, whitespace and `*` and `[` included, so
+ * scss's `\+(?=[ \t\n\r\f]*[\$(])` matched a `+` before a space; the shape oracle
+ * caught it at 203 positions of the scss corpus. Every caller here asks "is this
+ * ONE char matcher", so a fragment that is not gets null — declining costs a
+ * lowering or widens a first-set to `any()`, both of which only forgo a fast
+ * path, whereas accepting yields a wrong member set, which is a wrong scan or a
+ * wrong dispatch.
+ */
+export declare function parseClassOperand(body: string): {
+    ranges: Array<[number, number]>;
+    negated: boolean;
+} | null;
 /**
  * Parse a regex char-class body (the chars BETWEEN `[` and `]`, negation `^`
  * already stripped by the caller) to code-point ranges. `\d`/`\w`/`\s` expand to

package/dist/regex/classes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"classes.d.ts","sourceRoot":"","sources":["../../src/regex/classes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAgD,CAAA;AAEjG;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAGhD,CAAA;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAQ5E;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAK9F;AAID;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAyC7E"}
+{"version":3,"file":"classes.d.ts","sourceRoot":"","sources":["../../src/regex/classes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAgD,CAAA;AAEjG;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAGhD,CAAA;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAQ5E;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAK9F;AAKD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAiB/D;AAqBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAiB5G;AAID;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAyC7E"}

package/dist/regex/first-set.d.ts

@@ -28,6 +28,20 @@ import type { FirstSet } from '../types.ts';
  * to `{ any, canMatchNewline: true }` — the same conservative value the prior
  * `regexp-tree` seam returned on a parse failure.
  */
+/**
+ * Can `source` match ZERO characters?
+ *
+ * Structural, over the same AST `firstSetFromRegex` uses — which already models
+ * every zero-width construct as `EMPTY`: anchors (`^`/`$`), lookaround
+ * (`(?=…)`/`(?!…)`/`(?<=…)`/`(?<!…)`) and word boundaries. That is what makes
+ * this usable as a proof of consumption: a pattern is zero-width exactly when
+ * the AST says it is nullable, so a lookaround BURIED inside an otherwise
+ * mandatory pattern no longer taints the whole answer.
+ *
+ * Errs toward `true` (nullable) — an unparseable pattern is assumed able to
+ * match empty, so callers that delete code on a `false` keep their proof.
+ */
+export declare function regexCanMatchEmpty(source: string): boolean;
 export declare function firstSetFromRegex(source: string): {
     firstSet: FirstSet;
     canMatchNewline: boolean;

package/dist/regex/first-set.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"first-set.d.ts","sourceRoot":"","sources":["../../src/regex/first-set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAgQ3C;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,CAalG"}
+{"version":3,"file":"first-set.d.ts","sourceRoot":"","sources":["../../src/regex/first-set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAgQ3C;;;;;GAKG;AACH;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,CAalG"}

package/dist/run/index.cjs

@@ -224,11 +224,13 @@ function cstCaptureActive(ctx) {
 function pushCstChild(ctx, built, rawEntry) {
   const b = ctx._cstBuf;
   if (b) {
-    if (b.ch) b.ch.push(built);
-    else if (b.single !== void 0) {
-      b.ch = [b.single, built];
-      b.single = void 0;
-    } else b.single = built;
+    if (b.rawOnly !== true) {
+      if (b.ch) b.ch.push(built);
+      else if (b.single !== void 0) {
+        b.ch = [b.single, built];
+        b.single = void 0;
+      } else b.single = built;
+    }
     if (b.raw) b.raw.push(rawEntry);
     else if (b.rawSingle !== void 0) {
       b.raw = [b.rawSingle, rawEntry];
@@ -334,6 +336,45 @@ function captureError(ctx, error) {
 }
 var REC = { scan: recoverScan, at: matchesAt, or: orSentinel, sentinel: firstSetSentinel, capture: captureError };
 
+// src/parse-context.ts
+function createParseContext() {
+  return {
+    trivia: void 0,
+    scanSkip: void 0,
+    triviaKindLabels: void 0,
+    captureTrivia: void 0,
+    _triviaCaptureMask: void 0,
+    trackLines: false,
+    state: void 0,
+    build: void 0,
+    _errors: void 0,
+    _tolerant: void 0,
+    _sync: void 0,
+    _rec: void 0,
+    _fe: void 0,
+    _fx: void 0,
+    _fc: void 0,
+    _probe: void 0,
+    _cstChildren: void 0,
+    _cstLeaves: void 0,
+    _cstRawChildren: void 0,
+    _triviaLog: void 0,
+    _rootTriviaLog: void 0,
+    _rootTriviaKindIndex: void 0,
+    _rootTriviaStrictScopes: void 0,
+    _rootTriviaCapture: void 0,
+    _cstTriviaLog: void 0,
+    _fields: void 0,
+    _cstBuf: void 0,
+    _routed: void 0,
+    _lineStarts: void 0,
+    _lineIndex: void 0,
+    _lineScannedTo: void 0,
+    _grammarCoverage: void 0,
+    _grammarTrace: void 0
+  };
+}
+
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
 var FUSED_HOST_ELIDED = /* @__PURE__ */ Symbol.for("parseman.fusedHostElided");
@@ -367,9 +408,30 @@ var REMOVED_RUN_RESULT_FIELDS = [
     `It was already optional, so nothing ever flagged its disappearance \u2014 and \`triviaKindMask(undefined, \u2026)\` means "capture everything", so reading it now silently WIDENS capture instead of erroring. Migration: request labels \u2014 ${SELECT_EXAMPLE} \u2014 then the set you asked for is \`RunResult.rootTrivia.select\` and the resolved table is \`RunResult.rootTrivia.index.labels\`.`
   ]
 ];
-function guardRemovedFields(result) {
+var RunResultRecord = class {
+  constructor(ok, value, span, expected, errors, unconsumedFrom) {
+    this.ok = ok;
+    this.value = value;
+    this.span = span;
+    this.expected = expected;
+    this.errors = errors;
+    this.unconsumedFrom = unconsumedFrom;
+  }
+};
+var RunResultWithRootTrivia = class {
+  constructor(ok, value, span, expected, errors, rootTrivia, unconsumedFrom) {
+    this.ok = ok;
+    this.value = value;
+    this.span = span;
+    this.expected = expected;
+    this.errors = errors;
+    this.rootTrivia = rootTrivia;
+    this.unconsumedFrom = unconsumedFrom;
+  }
+};
+for (const proto of [RunResultRecord.prototype, RunResultWithRootTrivia.prototype]) {
   for (const [name, detail] of REMOVED_RUN_RESULT_FIELDS) {
-    Object.defineProperty(result, name, {
+    Object.defineProperty(proto, name, {
       configurable: true,
       enumerable: false,
       get() {
@@ -379,9 +441,14 @@ function guardRemovedFields(result) {
       }
     });
   }
-  return result;
 }
 var invoke = (r, input, pos, ctx) => typeof r === "function" ? r(input, pos, ctx) : r.parse(input, pos, ctx);
+function ambientTriviaFromRunnable(r) {
+  if (!r) return void 0;
+  if (typeof r === "function") return r._meta?.grammarTrivia;
+  if (r._meta.isTrivia) return void 0;
+  return r._meta.grammarTrivia ?? (r._def.tag === "grammar" ? r._def.triviaParser : void 0);
+}
 function triviaKindLabelsFromRunnable(r) {
   if (!r) return void 0;
   if (typeof r === "function") return r._meta?.triviaKindLabels;
@@ -401,7 +468,23 @@ function makeSelectedRootLabelIndex(labels) {
   }
   return index;
 }
-function runOnce(entry, input, options, phase, profileState) {
+function growSpanEnd(span, input, end) {
+  if (span.endLine === void 0 || span.endColumn === void 0) {
+    return { start: span.start, end };
+  }
+  let line = span.endLine;
+  let column = span.endColumn;
+  for (let i = span.end; i < end; i++) {
+    if (input.charCodeAt(i) === 10) {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return { ...span, end, endLine: line, endColumn: column };
+}
+function runOnce(entry, input, options) {
   if (typeof entry !== "function" && typeof entry?.parse !== "function") {
     throw new TypeError(
       `run(): start production is ${entry === null ? "null" : typeof entry}, not a rule \u2014 the requested grammar rule does not exist (check the rule name).`
@@ -412,8 +495,6 @@ function runOnce(entry, input, options, phase, profileState) {
   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);
@@ -438,55 +519,59 @@ function runOnce(entry, input, options, phase, profileState) {
     options.build,
     typeof entry === "function" && stamped[FUSED_HOST_ELIDED] === true
   );
-  const ctx = {
-    trackLines: false,
-    ...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 } : {},
-    ...grammarScanSkip !== void 0 ? { scanSkip: grammarScanSkip } : {},
-    ...options.triviaCaptureMask !== void 0 ? { _triviaCaptureMask: options.triviaCaptureMask } : {},
-    ...options.tolerant ? { _tolerant: true, _rec: REC } : {},
-    ...options.instrumentation === void 0 ? {} : options.instrumentation
-  };
+  const ctx = createParseContext();
+  if (captureRootTrivia) {
+    ctx._rootTriviaLog = selectedRootLog;
+    ctx._rootTriviaKindIndex = selectedRootLabelIndex;
+    ctx._rootTriviaStrictScopes = true;
+  }
+  ctx._errors = errors;
+  ctx.build = options.build;
+  ctx.state = options.state;
+  if (grammarTrivia !== void 0) ctx.trivia = grammarTrivia;
+  if (triviaKindLabels) ctx.triviaKindLabels = triviaKindLabels;
+  if (grammarScanSkip !== void 0) ctx.scanSkip = grammarScanSkip;
+  if (options.triviaCaptureMask !== void 0) ctx._triviaCaptureMask = options.triviaCaptureMask;
+  if (options.tolerant) {
+    ctx._tolerant = true;
+    ctx._rec = REC;
+  }
+  if (options.instrumentation !== void 0) {
+    ctx._grammarCoverage = options.instrumentation._grammarCoverage;
+    ctx._grammarTrace = options.instrumentation._grammarTrace;
+  }
   const r = invoke(entry, input, 0, ctx);
+  const value = r.ok ? r.value : void 0;
+  let span = r.span ?? { start: 0, end: 0 };
+  const expected = r.ok ? [] : r.expected ?? [];
   let unconsumedFrom = null;
   if (r.ok) {
-    let pos = r.span?.end ?? 0;
-    if (options.trivia && pos < input.length) {
-      const t = invoke(options.trivia, input, pos, { trackLines: false });
-      if (t.ok && t.span.end > pos) pos = t.span.end;
+    let pos = span.end;
+    const tail = options.trivia ?? ambientTriviaFromRunnable(entry);
+    if (tail !== void 0 && pos < input.length) {
+      const t = invoke(tail, input, pos, createParseContext());
+      if (t.ok && t.span.end > pos) {
+        span = growSpanEnd(span, input, t.span.end);
+        pos = t.span.end;
+      }
     }
     unconsumedFrom = pos < input.length ? pos : null;
   }
-  return {
-    ok: r.ok,
-    value: r.ok ? r.value : void 0,
-    span: r.span ?? { start: 0, end: 0 },
-    expected: r.ok ? [] : r.expected ?? [],
+  return selectedRootLog !== void 0 && selectedRootLog.length > 0 ? new RunResultWithRootTrivia(
+    r.ok,
+    value,
+    span,
+    expected,
     errors,
-    ...selectedRootLog !== void 0 && selectedRootLog.length > 0 ? {
-      rootTrivia: {
-        rows: selectedRootLog,
-        select: rootTriviaSelection,
-        index: buildRootTriviaIndex(selectedRootLog, rootTriviaSelection)
-      }
-    } : {},
+    {
+      rows: selectedRootLog,
+      select: rootTriviaSelection,
+      index: buildRootTriviaIndex(selectedRootLog, rootTriviaSelection)
+    },
     unconsumedFrom
-  };
+  ) : new RunResultRecord(r.ok, value, span, expected, errors, unconsumedFrom);
 }
 function run(entry, input, options = {}) {
-  if (!options.profile) return guardRemovedFields(runOnce(entry, input, options));
-  throw new TypeError(
-    "run({ profile: true }) is unavailable: profiling counters are no longer compiled into parser artifacts, and the interpreter does not implement them yet. Profiling is moving to interpreted mode."
-  );
+  return runOnce(entry, input, options);
 }
 //# sourceMappingURL=index.cjs.map

package/dist/run/index.cjs.map

@@ -1,7 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../src/run/index.ts", "../../src/cst/trivia-entries.ts", "../../src/line-index.ts", "../../src/cst/capture-buffer.ts", "../../src/recovery/scan.ts", "../../src/cst/host-mode.ts", "../../src/functional/run.ts"],
-  "sourcesContent": ["/**\n * `parseman/run` \u2014 the minimal entry for EXECUTING an already-compiled grammar.\n *\n * The macro removes the combinators, the compiler and the codegen from your\n * bundle, but not the driver: running a compiled grammar is still a `run()` call,\n * so a package that SHIPS a parser keeps a runtime import of parseman. Importing\n * that driver from the main entry drags the whole library along \u2014 the combinator\n * set, `compile()`, the first-set analysis, the CST builders \u2014 none of which a\n * compiled parser touches.\n *\n * This entry exists so it doesn't have to. `run()`'s complete module closure is\n * intentionally tiny (this, `functional/run.ts`, recovery helpers, CST capture /\n * trivia views, host-mode checks, and the line-index helper) \u2014 a fraction of the\n * main entry.\n * `test/unit/run-entry-closure.test.ts` asserts that stays true, so a future\n * import into `functional/run.ts` that widens the closure fails the suite rather\n * than quietly re-inflating everyone's bundle.\n *\n * Use the main entry when you BUILD grammars; use this one when you only run\n * output the macro (or `compile()`) already produced.\n *\n *   import { run } from 'parseman/run'\n *   import { myGrammar } from './grammar.js'   // macro-compiled\n *\n *   const result = run(myGrammar, source, { trivia })\n */\nexport { buildRootTriviaIndex } from '../cst/trivia-entries.ts'\nexport { run } from '../functional/run.ts'\nexport type { RootTriviaCapture, Runnable, RunOptions, RunResult } from '../functional/run.ts'\nexport type { RootTriviaGap, RootTriviaIndex, TriviaEntriesView } from '../cst/trivia-entries.ts'\nexport type { ParseContext, ParseError, ParseResult } from '../types.ts'\n", "/** View over a flat trivia log (`_triviaLog` or per-node `triviaLog`). */\nexport type TriviaEntriesView = {\n  readonly length: number\n  readonly labels: readonly string[] | undefined\n  readonly stride: number\n  start(i: number): number\n  end(i: number): number\n  /** Raw-child insertion boundary; defined only for a per-node trivia log. */\n  insertIndex(i: number): number | undefined\n  kindIndex(i: number): number | undefined\n  kind(i: number): string | undefined\n  text(i: number, input: string): string\n}\n\nexport type RootTriviaGap = {\n  /** Start offset of the contiguous trivia gap. */\n  readonly start: number\n  /** End offset of the contiguous trivia gap. */\n  readonly end: number\n  /** Entry indices into `entries` that make up this gap. */\n  readonly entryIndices: readonly number[]\n  /** True when any entry in the gap has the requested labeled trivia kind. */\n  hasKind(kind: string): boolean\n  /** Slice the full contiguous gap text from the original input. */\n  text(input: string): string\n}\n\nexport type RootTriviaIndex = {\n  /** Lazy entry-level view over sparse selected-root rows. */\n  readonly entries: TriviaEntriesView\n  /** Selected-root label table; entry kind indices refer to this array. */\n  readonly labels: readonly string[]\n  /**\n   * Contiguous trivia gaps keyed by the following content offset. Values are\n   * entry indices into `entries`, not materialized `{ value, span }` objects.\n   */\n  readonly before: ReadonlyMap<number, readonly number[]>\n  /**\n   * Contiguous trivia gaps keyed by the preceding content offset. Values are\n   * entry indices into `entries`, not materialized `{ value, span }` objects.\n   */\n  readonly after: ReadonlyMap<number, readonly number[]>\n  entryIndicesBefore(offset: number): readonly number[]\n  entryIndicesAfter(offset: number): readonly number[]\n  /**\n   * Contiguous trivia gap immediately before `offset`, keyed by the following\n   * content offset. Returns undefined when no gap sits at that boundary.\n   */\n  gapBefore(offset: number): RootTriviaGap | undefined\n  /**\n   * Contiguous trivia gap immediately after `offset`, keyed by the preceding\n   * content offset. Returns undefined when no gap sits at that boundary.\n   */\n  gapAfter(offset: number): RootTriviaGap | undefined\n  /** All contiguous trivia gaps in source order. */\n  gaps(): readonly RootTriviaGap[]\n  /** Source-ordered gaps containing at least one entry with the given label. */\n  gapsWithKind(kind: string | readonly string[]): readonly RootTriviaGap[]\n}\n\nconst EMPTY_INDICES: readonly number[] = Object.freeze([])\nconst EMPTY_GAPS: readonly RootTriviaGap[] = Object.freeze([])\n/** Number of packed fields in one selected-root trivia row. */\nexport const SELECTED_ROOT_STRIDE = 5\n\ntype RootTriviaMaps = {\n  before: Map<number, number[]>\n  after: Map<number, number[]>\n  beforeGaps: Map<number, RootTriviaGap>\n  afterGaps: Map<number, RootTriviaGap>\n  gaps: RootTriviaGap[]\n}\n\nfunction entryOffset(i: number, stride: number): number {\n  return i * stride\n}\n\n/**\n * Wrap a flat trivia log. Stride is inferred from `labels`:\n * - root `_triviaLog`: 2 (start, end) or 3 (+ kindIndex)\n * - node `triviaLog`: 3 (start, end, insertIdx) or 4 (+ kindIndex)\n */\nexport function triviaEntries(\n  log: readonly number[],\n  labels?: readonly string[],\n  opts?: { nodeLog?: boolean },\n): TriviaEntriesView {\n  const baseStride = opts?.nodeLog ? 3 : 2\n  const stride = labels ? baseStride + 1 : baseStride\n  const length = Math.floor(log.length / stride)\n\n  return {\n    length,\n    labels,\n    stride,\n    start(i) {\n      return log[entryOffset(i, stride)]!\n    },\n    end(i) {\n      return log[entryOffset(i, stride) + 1]!\n    },\n    insertIndex(i) {\n      return opts?.nodeLog ? log[entryOffset(i, stride) + 2] : undefined\n    },\n    kindIndex(i) {\n      if (!labels) return undefined\n      return log[entryOffset(i, stride) + baseStride]\n    },\n    kind(i) {\n      const ki = labels ? log[entryOffset(i, stride) + baseStride] : undefined\n      return ki !== undefined ? labels![ki] : undefined\n    },\n    text(i, input) {\n      const s = log[entryOffset(i, stride)]!\n      const e = log[entryOffset(i, stride) + 1]!\n      return input.slice(s, e)\n    },\n  }\n}\n\n/**\n * Build a root view over the sparse selected-label rows captured as\n * `[ownedRangeStart, ownedRangeEnd, markerStart, markerEnd, kindIndex]`.\n *\n * This is intentionally a different input shape from `triviaLog`: each row is\n * one selected marker, while the first pair names the complete committed trivia\n * range around it. Thus a mixed trivia run costs one five-number row, not three\n * legacy trivia entries. Rows are source ordered and equal gap pairs are\n * contiguous, which lets singleton boundary lookups binary-search the sparse\n * rows without constructing document-wide maps.\n */\nexport function buildRootTriviaIndex(\n  log: readonly number[],\n  labels: readonly string[],\n): RootTriviaIndex {\n  const length = Math.floor(log.length / SELECTED_ROOT_STRIDE)\n  const markerOffset = (i: number) => i * SELECTED_ROOT_STRIDE\n  const ownedRangeStart = (i: number) => log[markerOffset(i)]!\n  const ownedRangeEnd = (i: number) => log[markerOffset(i) + 1]!\n  const markerStart = (i: number) => log[markerOffset(i) + 2]!\n  const markerEnd = (i: number) => log[markerOffset(i) + 3]!\n  const markerKind = (i: number) => log[markerOffset(i) + 4]!\n\n  const entries: TriviaEntriesView = {\n    length,\n    labels,\n    stride: SELECTED_ROOT_STRIDE,\n    start: markerStart,\n    end: markerEnd,\n    insertIndex: () => undefined,\n    kindIndex: markerKind,\n    kind(i) {\n      return labels[markerKind(i)]\n    },\n    text(i, input) {\n      return input.slice(markerStart(i), markerEnd(i))\n    },\n  }\n\n  const lowerBound = (offset: number, by: (i: number) => number): number => {\n    let lo = 0\n    let hi = length\n    while (lo < hi) {\n      const mid = (lo + hi) >>> 1\n      if (by(mid) < offset) lo = mid + 1\n      else hi = mid\n    }\n    return lo\n  }\n\n  const gapRowsAt = (offset: number, direction: 'before' | 'after'): [number, number] | undefined => {\n    const edge = direction === 'before' ? ownedRangeEnd : ownedRangeStart\n    let first = lowerBound(offset, edge)\n    if (first === length || edge(first) !== offset) return undefined\n    const start = ownedRangeStart(first)\n    const end = ownedRangeEnd(first)\n    while (first > 0 && ownedRangeStart(first - 1) === start && ownedRangeEnd(first - 1) === end) first--\n    let last = first + 1\n    while (last < length && ownedRangeStart(last) === start && ownedRangeEnd(last) === end) last++\n    return [first, last]\n  }\n\n  const indices = (first: number, last: number): readonly number[] => {\n    const out: number[] = []\n    for (let i = first; i < last; i++) out.push(i)\n    return out\n  }\n\n  const makeGap = (first: number, last: number): RootTriviaGap => {\n    const start = ownedRangeStart(first)\n    const end = ownedRangeEnd(first)\n    let entryIndices: readonly number[] | undefined\n    return {\n      start,\n      end,\n      get entryIndices() {\n        return entryIndices ??= indices(first, last)\n      },\n      hasKind(kind) {\n        for (let i = first; i < last; i++) {\n          if (labels[markerKind(i)] === kind) return true\n        }\n        return false\n      },\n      text(input) {\n        return input.slice(start, end)\n      },\n    }\n  }\n\n  let maps: RootTriviaMaps | undefined\n  const getMaps = () => {\n    if (maps !== undefined) return maps\n    const before = new Map<number, number[]>()\n    const after = new Map<number, number[]>()\n    const beforeGaps = new Map<number, RootTriviaGap>()\n    const afterGaps = new Map<number, RootTriviaGap>()\n    const gaps: RootTriviaGap[] = []\n    for (let first = 0; first < length;) {\n      let last = first + 1\n      while (last < length && ownedRangeStart(last) === ownedRangeStart(first) && ownedRangeEnd(last) === ownedRangeEnd(first)) last++\n      const gap = makeGap(first, last)\n      gaps.push(gap)\n      afterGaps.set(gap.start, gap)\n      beforeGaps.set(gap.end, gap)\n      after.set(gap.start, [...gap.entryIndices])\n      before.set(gap.end, [...gap.entryIndices])\n      first = last\n    }\n    maps = { before, after, beforeGaps, afterGaps, gaps }\n    return maps\n  }\n\n  return {\n    entries,\n    labels,\n    get before() { return getMaps().before },\n    get after() { return getMaps().after },\n    entryIndicesBefore(offset) {\n      const rows = gapRowsAt(offset, 'before')\n      return rows ? indices(rows[0], rows[1]) : EMPTY_INDICES\n    },\n    entryIndicesAfter(offset) {\n      const rows = gapRowsAt(offset, 'after')\n      return rows ? indices(rows[0], rows[1]) : EMPTY_INDICES\n    },\n    gapBefore(offset) {\n      const rows = gapRowsAt(offset, 'before')\n      return rows ? makeGap(rows[0], rows[1]) : undefined\n    },\n    gapAfter(offset) {\n      const rows = gapRowsAt(offset, 'after')\n      return rows ? makeGap(rows[0], rows[1]) : undefined\n    },\n    gaps() {\n      return getMaps().gaps\n    },\n    gapsWithKind(kind) {\n      const kinds = typeof kind === 'string' ? [kind] : kind\n      const matches: RootTriviaGap[] = []\n      // Do not materialize the document-wide boundary maps for a sparse query.\n      // The primary consumer selects comments: it needs only comment-bearing gaps,\n      // not an object/Map for every whitespace-owned boundary in the document.\n      for (let first = 0; first < length;) {\n        let last = first + 1\n        while (last < length\n          && ownedRangeStart(last) === ownedRangeStart(first)\n          && ownedRangeEnd(last) === ownedRangeEnd(first)) last++\n        let matched = false\n        for (let i = first; i < last && !matched; i++) {\n          const label = labels[markerKind(i)]\n          for (const kind of kinds) {\n            if (label === kind) {\n              matched = true\n              break\n            }\n          }\n        }\n        if (matched) matches.push(makeGap(first, last))\n        first = last\n      }\n      return matches.length === 0 ? EMPTY_GAPS : matches\n    },\n  }\n}\n", "import type { Span } from './types.ts'\n\n/**\n * Precomputed index of newline positions for O(log n) offset->line/col lookup.\n * lineStarts[i] is the byte offset of the first character on line i+1.\n */\nexport type LineIndex = { lineStarts: number[] }\ntype LineTrackingContext = {\n  trackLines?: boolean | undefined\n  _lineIndex?: LineIndex | undefined\n  _lineStarts?: number[] | undefined\n  _lineScannedTo?: number | undefined\n}\n\nexport function createLineIndex(): LineIndex {\n  return { lineStarts: [0] }\n}\n\nexport function buildLineIndex(input: string): LineIndex {\n  const lineStarts = [0]\n  for (let i = 0; i < input.length; i++) {\n    if (input.charCodeAt(i) === 10) lineStarts.push(i + 1)\n  }\n  return { lineStarts }\n}\n\n/**\n * Record newline offsets for a matched range. Intended for optional parsers that\n * collect line starts while they consume terminals. The collector is deliberately\n * append-only: speculative parses never roll it back. Normalize once at the\n * driver boundary before doing offset->line/column lookup.\n */\nexport function recordLineRange(index: LineIndex, input: string, start: number, end: number): void {\n  const lineStarts = index.lineStarts\n  for (let i = start; i < end; i++) {\n    if (input.charCodeAt(i) === 10) lineStarts.push(i + 1)\n  }\n}\n\n/**\n * Records newlines from the context high-water mark through `end`. The start\n * argument is only a caller hint: append-only tracking uses `_lineScannedTo` so\n * overlapping calls can backfill gaps without double-scanning committed ranges.\n */\nexport function recordLineRangeFromContext(\n  ctx: LineTrackingContext,\n  input: string,\n  _startHint: number,\n  end: number,\n): void {\n  if (!ctx.trackLines) return\n  const from = ctx._lineScannedTo ?? 0\n  if (end <= from) return\n  const index = ctx._lineIndex ?? (ctx._lineStarts ? { lineStarts: ctx._lineStarts } : undefined)\n  if (!index) return\n  recordLineRange(index, input, from, end)\n  ctx._lineScannedTo = end\n}\n\nexport function normalizeLineIndex(index: LineIndex): LineIndex {\n  const starts = index.lineStarts\n  starts.sort((a, b) => a - b)\n  let write = 0\n  for (let read = 0; read < starts.length; read++) {\n    const value = starts[read]!\n    if (write === 0 || starts[write - 1] !== value) starts[write++] = value\n  }\n  starts.length = write\n  if (starts.length === 0 || starts[0] !== 0) starts.unshift(0)\n  return index\n}\n\nexport function offsetToLineCol(\n  index: LineIndex,\n  offset: number\n): { line: number; col: number } {\n  const { lineStarts } = index\n  let lo = 0\n  let hi = lineStarts.length - 1\n  while (lo < hi) {\n    const mid = (lo + hi + 1) >> 1\n    if (lineStarts[mid]! <= offset) lo = mid\n    else hi = mid - 1\n  }\n  return { line: lo + 1, col: offset - lineStarts[lo]! + 1 }\n}\n\n/** Fills startLine/startColumn/endLine/endColumn on a span in-place. */\nexport function annotateSpan(span: Span, index: LineIndex): Span {\n  const s = offsetToLineCol(index, span.start)\n  const e = offsetToLineCol(index, span.end)\n  return {\n    ...span,\n    startLine: s.line,\n    startColumn: s.col,\n    endLine: e.line,\n    endColumn: e.col,\n  }\n}\n\nexport function annotateSpanFromLineContext(\n  span: Span,\n  ctx: LineTrackingContext,\n): Span {\n  if (!ctx.trackLines) return span\n  const index = ctx._lineIndex ?? (ctx._lineStarts ? { lineStarts: ctx._lineStarts } : undefined)\n  return index ? annotateSpan(span, index) : span\n}\n\nfunction isSpan(value: unknown): value is Span {\n  return !!value\n    && typeof value === 'object'\n    && typeof (value as { start?: unknown }).start === 'number'\n    && typeof (value as { end?: unknown }).end === 'number'\n}\n\n/** Annotate every span-shaped object reachable from a parse result value. */\nexport function annotateTreeSpans<T>(value: T, index: LineIndex, seen: WeakSet<object> = new WeakSet()): T {\n  if (!value || typeof value !== 'object') return value\n  if (seen.has(value)) return value\n  seen.add(value)\n\n  const obj = value as Record<string, unknown>\n  if (isSpan(obj.span)) obj.span = annotateSpan(obj.span, index)\n\n  for (const key of Object.keys(obj)) {\n    const child = obj[key]\n    if (child && typeof child === 'object') annotateTreeSpans(child, index, seen)\n  }\n  return value\n}\n", "import type { ParseContext, Span } from '../types.ts'\nimport { annotateSpanFromLineContext } from '../line-index.ts'\n\n/** Lazy per-node capture state \u2014 arrays materialized on first push. */\nexport type CstCaptureBuf = {\n  single?: unknown | undefined\n  ch?: unknown[] | undefined\n  rawSingle?: unknown | undefined\n  raw?: unknown[] | undefined\n  tl?: number[] | undefined\n}\n\nconst EMPTY: unknown[] = []\nconst EMPTY_TL: number[] = []\n\nexport function cstCaptureActive(ctx: ParseContext): boolean {\n  return ctx._cstBuf !== undefined || ctx._cstLeaves !== undefined\n}\n\nexport type CstNodeCaptureSaved = {\n  ch: ParseContext['_cstChildren']\n  lv: ParseContext['_cstLeaves']\n  raw: ParseContext['_cstRawChildren']\n  tl: ParseContext['_cstTriviaLog']\n  cap: boolean | undefined\n  buf: CstCaptureBuf | undefined\n}\n\nexport function beginCstNodeCapture(ctx: ParseContext): CstNodeCaptureSaved {\n  const saved: CstNodeCaptureSaved = {\n    ch: ctx._cstChildren,\n    lv: ctx._cstLeaves,\n    raw: ctx._cstRawChildren,\n    tl: ctx._cstTriviaLog,\n    cap: ctx.captureTrivia,\n    buf: ctx._cstBuf,\n  }\n  ctx._cstBuf = {}\n  ctx._cstChildren = undefined\n  ctx._cstLeaves = undefined\n  ctx._cstRawChildren = undefined\n  ctx._cstTriviaLog = undefined\n  ctx.captureTrivia = true\n  return saved\n}\n\nexport function finishCstBuf(buf: CstCaptureBuf | undefined): {\n  children: unknown[]\n  rawChildren: unknown[]\n  triviaLog: number[]\n} {\n  if (!buf) return { children: EMPTY, rawChildren: EMPTY, triviaLog: EMPTY_TL }\n  const children = buf.ch ?? (buf.single !== undefined ? [buf.single] : EMPTY)\n  const rawChildren = buf.raw ?? (buf.rawSingle !== undefined ? [buf.rawSingle] : EMPTY)\n  const triviaLog = buf.tl ?? EMPTY_TL\n  return { children, rawChildren, triviaLog }\n}\n\nexport function endCstNodeCapture(\n  ctx: ParseContext,\n  saved: CstNodeCaptureSaved,\n): { children: unknown[]; rawChildren: unknown[]; triviaLog: number[] } {\n  const materialized = finishCstBuf(ctx._cstBuf)\n  ctx._cstBuf = saved.buf\n  ctx._cstChildren = saved.ch\n  ctx._cstLeaves = saved.lv\n  ctx._cstRawChildren = saved.raw\n  ctx._cstTriviaLog = saved.tl\n  ctx.captureTrivia = saved.cap\n  return materialized\n}\n\nexport function pushCstLeaf(ctx: ParseContext, leaf: unknown): void {\n  if (!ctx.trackLines) {\n    pushCstChild(ctx, leaf, leaf)\n    return\n  }\n  const annotated = leaf && typeof leaf === 'object' && (leaf as { span?: unknown }).span\n    ? { ...(leaf as Record<string, unknown>), span: annotateSpanFromLineContext((leaf as { span: Span }).span, ctx) }\n    : leaf\n  pushCstChild(ctx, annotated, annotated)\n}\n\n/** Record a built sub-node into the active collector (children vs rawChildren may differ). */\nexport function pushCstChild(ctx: ParseContext, built: unknown, rawEntry: unknown): void {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.ch) b.ch.push(built)\n    else if (b.single !== undefined) { b.ch = [b.single, built]; b.single = undefined }\n    else b.single = built\n\n    if (b.raw) b.raw.push(rawEntry)\n    else if (b.rawSingle !== undefined) { b.raw = [b.rawSingle, rawEntry]; b.rawSingle = undefined }\n    else b.rawSingle = rawEntry\n    return\n  }\n  if (ctx._cstChildren) ctx._cstChildren.push(built)\n  else if (ctx._cstLeaves) ctx._cstLeaves.push(built)\n  if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry)\n}\n\nexport function cstRawLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.raw) return b.raw.length\n    return b.rawSingle !== undefined ? 1 : 0\n  }\n  return ctx._cstRawChildren?.length ?? 0\n}\n\nexport function cstLeavesLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) {\n    if (b.ch) return b.ch.length\n    return b.single !== undefined ? 1 : 0\n  }\n  return ctx._cstLeaves?.length ?? 0\n}\n\nexport function cstTlLen(ctx: ParseContext): number {\n  const b = ctx._cstBuf\n  if (b) return b.tl?.length ?? 0\n  return ctx._cstTriviaLog?.length ?? 0\n}\n\nexport type CstRollbackMark = { raw: number; tlog: number; leaves: number; fields: number; errors: number }\n\nexport function saveCstMark(ctx: ParseContext): CstRollbackMark {\n  return {\n    raw: cstRawLen(ctx),\n    tlog: cstTlLen(ctx),\n    leaves: cstLeavesLen(ctx),\n    fields: ctx._fields?.length ?? 0,\n    // Speculative rollback must truncate the flat recovery-error sink in lockstep\n    // with the CST leaves: a branch that recovered (pushing a ParseError to\n    // ctx._errors AND embedding it as a CST child via captureError) then failed\n    // must remove BOTH, or the flat error survives as a GHOST that a tree walk\n    // can't see (flat run().errors would disagree with the embedded set).\n    errors: ctx._errors?.length ?? 0,\n  }\n}\n\nfunction rollbackBufList(\n  b: CstCaptureBuf,\n  keyMulti: 'ch' | 'raw',\n  keySingle: 'single' | 'rawSingle',\n  len: number,\n): void {\n  const arr = b[keyMulti]\n  if (arr) {\n    if (len === 0) b[keyMulti] = undefined\n    else if (len === 1) { b[keySingle] = arr[0]; b[keyMulti] = undefined }\n    // Guarded like every other truncation \u2014 see rollbackCstCapture. This is the\n    // buffered node-capture path, so it is reached only by the INTERPRETER (the\n    // compiled engine inlines its own capture and never calls here), and it is\n    // where the redundant-store rate is highest: over a backtracking fixture\n    // this branch ran 32,800 times and 31,198 of those \u2014 95% \u2014 restored a\n    // length that had not moved.\n    else if (arr.length !== len) arr.length = len\n    return\n  }\n  if (len === 0) b[keySingle] = undefined\n}\n\nexport function rollbackCstCapture(ctx: ParseContext, mark: CstRollbackMark): void {\n  // Truncate the flat recovery-error sink alongside the CST, so a rolled-back\n  // speculative branch leaves no ghost error (see saveCstMark). Guarded on a\n  // present sink + a defined mark (rollbackTrivia forwards the same field).\n  //\n  // Each truncation is guarded on `length !== mark`, mirroring the compiled\n  // engine (codegen.ts `captureRestoreBody`). Assigning `array.length` runs V8's\n  // length setter \u2014 a backing-store trim decision \u2014 and costs the same when the\n  // value is unchanged, which is the overwhelmingly common case here: a\n  // speculative branch that captured nothing still pays for every store. The\n  // compare is an in-object load. Both engines must carry the guard or the\n  // interpreted path silently keeps the cost the compiled path shed.\n  if (ctx._errors && mark.errors !== undefined && ctx._errors.length !== mark.errors) ctx._errors.length = mark.errors\n  const b = ctx._cstBuf\n  if (b) {\n    rollbackBufList(b, 'raw', 'rawSingle', mark.raw)\n    rollbackBufList(b, 'ch', 'single', mark.leaves)\n    if (b.tl) {\n      if (mark.tlog === 0) b.tl = undefined\n      else if (b.tl.length !== mark.tlog) b.tl.length = mark.tlog\n    }\n    if (ctx._fields && ctx._fields.length !== mark.fields) ctx._fields.length = mark.fields\n    return\n  }\n  if (ctx._cstRawChildren && ctx._cstRawChildren.length !== mark.raw) ctx._cstRawChildren.length = mark.raw\n  if (ctx._cstTriviaLog && ctx._cstTriviaLog.length !== mark.tlog) ctx._cstTriviaLog.length = mark.tlog\n  if (ctx._cstLeaves && ctx._cstLeaves.length !== mark.leaves) ctx._cstLeaves.length = mark.leaves\n  if (ctx._fields && ctx._fields.length !== mark.fields) ctx._fields.length = mark.fields\n}\n\nexport function pushCstTriviaEntry(\n  ctx: ParseContext,\n  start: number,\n  end: number,\n  kindIndex?: number,\n): void {\n  const insertIdx = cstRawLen(ctx)\n  const b = ctx._cstBuf\n  const withKind = ctx.triviaKindLabels !== undefined && kindIndex !== undefined\n  if (b) {\n    if (!b.tl) {\n      b.tl = withKind ? [start, end, insertIdx, kindIndex] : [start, end, insertIdx]\n    } else if (withKind) {\n      b.tl.push(start, end, insertIdx, kindIndex)\n    } else {\n      b.tl.push(start, end, insertIdx)\n    }\n    return\n  }\n  if (ctx._cstTriviaLog) {\n    if (withKind) ctx._cstTriviaLog.push(start, end, insertIdx, kindIndex)\n    else ctx._cstTriviaLog.push(start, end, insertIdx)\n  }\n}\n\nexport function pushTriviaLogEntry(\n  ctx: ParseContext,\n  start: number,\n  end: number,\n  kindIndex?: number,\n): void {\n  if (!ctx._triviaLog) return\n  if (ctx.triviaKindLabels !== undefined && kindIndex !== undefined) {\n    ctx._triviaLog.push(start, end, kindIndex)\n  } else {\n    ctx._triviaLog.push(start, end)\n  }\n}\n\nexport function cstDeferredTriviaActive(ctx: ParseContext): boolean {\n  return ctx._triviaLog !== undefined || ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined\n}\n", "import type { Combinator, FirstSet, ParseContext, ParseError, ParseResult, RecoveryHelpers } from '../types.ts'\nimport { cstCaptureActive, pushCstChild } from '../cst/capture-buffer.ts'\nimport { annotateSpanFromLineContext, recordLineRangeFromContext } from '../line-index.ts'\n\n/**\n * Recovery MECHANISM \u2014 sync-source-agnostic. These primitives implement \"scan\n * forward to a sync token and emit a ParseError\" and \"is the sync token here?\".\n * They are deliberately independent of WHERE the sync sentinel comes from: the\n * grammar never carries recovery config. Sync points are inferred automatically\n * from grammar structure (see `infer.ts`) and may be overridden externally by the\n * language service via `ctx._listSync`. This is the salvaged core of the old\n * `combinators/recover-scan.ts`.\n */\n\n/**\n * Run `sentinel` at `pos` as PURE lookahead: succeed/fail only, with every\n * side-effecting sink suppressed (CST leaves/children/trivia, the trivia log,\n * the recovery error sink, and the completions probe). A recovery scan probes the\n * sentinel at many positions and must not capture leaves, log trivia, or pollute\n * `completionsAt`'s furthest-failure set as a byproduct of looking ahead.\n */\nfunction probeAt(sentinel: Combinator<unknown>, input: string, pos: number, ctx: ParseContext): boolean {\n  const s = {\n    _probe: ctx._probe, _errors: ctx._errors,\n    _cstLeaves: ctx._cstLeaves, _cstChildren: ctx._cstChildren, _cstRawChildren: ctx._cstRawChildren,\n    _cstTriviaLog: ctx._cstTriviaLog, _triviaLog: ctx._triviaLog, _rootTriviaLog: ctx._rootTriviaLog, _fields: ctx._fields, _cstBuf: ctx._cstBuf,\n    _tolerant: ctx._tolerant, _sync: ctx._sync,\n  }\n  ctx._probe = undefined; ctx._errors = undefined\n  ctx._cstLeaves = undefined; ctx._cstChildren = undefined; ctx._cstRawChildren = undefined\n  ctx._cstTriviaLog = undefined; ctx._triviaLog = undefined; ctx._rootTriviaLog = undefined; ctx._fields = undefined; ctx._cstBuf = undefined\n  // A sentinel is pure lookahead: it must not itself enter tolerant recovery (nor\n  // read a stale outer `_sync`). Otherwise a sentinel that composes many/sepBy would\n  // run recovery on every probed position \u2014 wasted work, and it could resync to the\n  // enclosing list's sync token. Cleared here and restored in `finally`.\n  ctx._tolerant = undefined; ctx._sync = undefined\n  try {\n    return sentinel.parse(input, pos, ctx).ok\n  } finally {\n    ctx._probe = s._probe; ctx._errors = s._errors\n    ctx._cstLeaves = s._cstLeaves; ctx._cstChildren = s._cstChildren; ctx._cstRawChildren = s._cstRawChildren\n    ctx._cstTriviaLog = s._cstTriviaLog; ctx._triviaLog = s._triviaLog; ctx._rootTriviaLog = s._rootTriviaLog; ctx._fields = s._fields; ctx._cstBuf = s._cstBuf\n    ctx._tolerant = s._tolerant; ctx._sync = s._sync\n  }\n}\n\n/**\n * Combine two recovery sentinels into one that matches when either does \u2014 used by\n * tolerant `sepBy` to resync to its own separator OR the enclosing delimiter. Cold\n * path only; a bare wrapper so we don't pull `choice()` (and its analysis) in.\n */\nexport function orSentinel(\n  a: Combinator<unknown>,\n  b: Combinator<unknown> | undefined,\n): Combinator<unknown> {\n  if (b === undefined) return a\n  return {\n    _tag: 'orSentinel',\n    _meta: { firstSet: { kind: 'any' }, canMatchNewline: false, isTrivia: false },\n    _def: { tag: 'unknown' },\n    parse(input: string, pos: number, ctx: ParseContext): ParseResult<unknown> {\n      const ra = a.parse(input, pos, ctx)\n      if (ra.ok) return ra\n      return b.parse(input, pos, ctx)\n    },\n  }\n}\n\n/**\n * A lightweight zero-width sentinel that \"matches\" (succeeds, consuming nothing)\n * when the input code point at `pos` starts the given first set. Sync inference\n * builds one from a list's follow set so a nested list can resync to the enclosing\n * delimiter with no grammar annotation. Returns `null` when the first set is `any`\n * or `empty` (no usable inference).\n */\nexport function firstSetSentinel(fs: FirstSet): Combinator<null> | null {\n  if (fs.kind !== 'ranges' || fs.ranges.length === 0) return null\n  const ranges = fs.ranges\n  return {\n    _tag: 'firstSetSentinel',\n    _meta: { firstSet: fs, canMatchNewline: false, isTrivia: false },\n    _def: { tag: 'unknown' },\n    parse(input: string, pos: number): ParseResult<null> {\n      const code = pos < input.length ? input.codePointAt(pos) : undefined\n      if (code !== undefined) {\n        for (const r of ranges) {\n          if (code >= r.lo && code <= r.hi) return { ok: true, value: null, span: { start: pos, end: pos } }\n        }\n      }\n      return { ok: false, expected: [], span: { start: pos, end: pos } }\n    },\n  }\n}\n\n/**\n * Cold-path recovery scan shared by tolerant `many()` / `sepBy()`. Scans forward\n * from `from` until `sync` matches (or EOF) \u2014 probing the sentinel as pure\n * lookahead \u2014 emits a {@link ParseError} spanning the skipped range, and pushes it\n * to `ctx._errors`. The sync token is NOT consumed; the caller's loop resumes from\n * `end`. Only ever reached after an element has failed, so entirely off the hot path.\n *\n * The caller owns the loop guard: `sepBy` progress is driven by its separator (a\n * zero-width error for a missing element is fine); `many` checks `matchesAt(sync)`\n * itself and breaks when sitting on the terminator, so a zero-width failure can\n * never spin.\n */\nexport function recoverScan(\n  input: string,\n  from: number,\n  ctx: ParseContext,\n  sync: Combinator<unknown>,\n  expected: string[],\n): { error: ParseError; end: number } {\n  let scanPos = from\n  while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++\n  const span = { start: from, end: scanPos }\n  if (ctx.trackLines) recordLineRangeFromContext(ctx, input, from, scanPos)\n  const error: ParseError = { _tag: 'parseError', span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected }\n  ctx._errors?.push(error)\n  return { error, end: scanPos }\n}\n\n/**\n * Does `sentinel` match at `pos` (pure lookahead)? Used by the tolerant list loops\n * to detect \"we are sitting on the sync/terminator token\" without consuming it or\n * capturing anything.\n */\nexport function matchesAt(\n  sentinel: Combinator<unknown>,\n  input: string,\n  pos: number,\n  ctx: ParseContext,\n): boolean {\n  return probeAt(sentinel, input, pos, ctx)\n}\n\n/**\n * Embed a recovered error as a `parseError` CST child at the recovery point, so the\n * error lives IN the tree (rides reused subtrees across incremental edits; a tree\n * walk finds every diagnostic) \u2014 not only in the flat `ctx._errors` side-channel.\n * No-op when CST capture is off (value/AST mode). Both the interpreter list loops\n * and the compiled recovery branches call this (the latter via `_ctx._rec.capture`),\n * so the embedded node is identical on both paths.\n */\nexport function captureError(ctx: ParseContext, error: ParseError): void {\n  if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error)\n}\n\n/**\n * The recovery-helper bundle handed to a tolerant parse via `ctx._rec`. A COMPILED\n * grammar can't import these, so the driver (`run`, `parseDoc`) injects them; the\n * interpreter list loops read the same bundle, guaranteeing byte-identical recovery\n * across paths. Shared here so every driver installs the exact same instance.\n */\nexport const REC: RecoveryHelpers = { scan: recoverScan, at: matchesAt, or: orSentinel, sentinel: firstSetSentinel, capture: captureError }\n", "/**\n * The compiled-artifact \u2194 host contract, in ONE place.\n *\n * This lives on its own \u2014 rather than in `compiler/codegen.ts` where it started \u2014\n * because the DRIVER has to enforce it too. `functional/run.ts` is the `parseman/run`\n * entry, whose whole purpose is to stay small (see `test/unit/run-entry-closure.test.ts`),\n * so it cannot import the compiler to reach an assertion. Neither can it carry its own\n * copy: two spellings of one contract is how the two engines drift, and this contract\n * exists precisely because the failure it prevents is silent.\n *\n * No imports, by design \u2014 that is what keeps it free for both sides to depend on.\n */\n\n/**\n * Which consumer a compiled artifact was lowered FOR.\n *\n * - `'ast'` \u2014 the grammar's own `build` callbacks produce the result (the eval consumer).\n * - `'cst'` \u2014 a positioned-CST `ctx.build` host produces it (linter / IDE / language\n *   service), and every node's capture is sized for that host.\n *\n * ONE grammar source serves both; they are two COMPILATIONS of it, not two grammars.\n * Deciding at compile time is what keeps the eval-AST artifact free of per-node host\n * probing \u2014 see the `hostMode` note on the codegen Ctx.\n */\nexport type HostMode = 'ast' | 'cst'\n\n/** Host mode a fused rule map (and each of its rule functions) was lowered for;\n * absent on hand-built maps \u2192 'ast'. */\nexport const FUSED_HOST_MODE = Symbol.for('parseman.fusedHostMode')\n\n/** Whether any fused piece omitted a direct builder's positioned-CST branch. */\nexport const FUSED_HOST_ELIDED = Symbol.for('parseman.fusedHostElided')\n\n/**\n * A compiled artifact and the host it is driven with must agree \u2014 and when they do not,\n * that has to be an ERROR, never a quietly-degraded tree.\n *\n * An `'ast'` artifact does not emit the positioned-CST branch at all, so attaching a\n * `_parsemanCstOutput` host to one would silently get the grammar's own AST objects\n * where the caller asked for a CST. A `'cst'` artifact builds every node through the\n * host, so running one without a host would call `undefined`. Both are compile/run\n * mismatches with an obvious fix, so both say so.\n *\n * Called once per parse from the TypeScript entry points, never from generated code.\n */\nexport function assertHostModeCompatible(mode: HostMode, build: unknown, hostBranchElided = true): void {\n  const isCstHost = (build as { _parsemanCstOutput?: true } | undefined)?._parsemanCstOutput === true\n  // A purely STRUCTURAL artifact never had a direct-builder host branch to drop, so it\n  // serves a CST host in either mode \u2014 that is the long-standing `node(parser)` contract\n  // and this change does not touch it. The INTERPRETER passes `false` for the same\n  // reason from the other direction: it re-decides per parse and never elides anything.\n  if (mode === 'ast' && isCstHost && hostBranchElided) {\n    throw new Error(\n      'parseman: this parser was compiled for host mode \"ast\" (the default), so its nodes '\n        + 'build through their own `build` callbacks and no positioned-CST branch was emitted. '\n        + 'It cannot be driven with a positioned-CST host (cstBuildHost / a language-service '\n        + 'host). Compile a second artifact from the SAME grammar with '\n        + \"`compile(grammar, { hostMode: 'cst' })` \u2014 or, under the macro, a second \"\n        + \"`rules({ hostMode: 'cst' }, factory)` call site \u2014 and drive that one instead.\",\n    )\n  }\n  if (mode === 'cst' && !isCstHost) {\n    throw new Error(\n      'parseman: this parser was compiled for host mode \"cst\", so every node builds through '\n        + 'a positioned-CST `ctx.build` host. Pass one (e.g. `{ build: cstBuildHost }`), or use '\n        + 'an artifact compiled with the default `hostMode: \"ast\"` to get the grammar\\'s own AST.',\n    )\n  }\n}\n", "import type { Combinator, ParseContext, ParseError, ParseResult } from '../types.ts'\nimport { REC } from '../recovery/scan.ts'\nimport { buildRootTriviaIndex, type RootTriviaIndex } from '../cst/trivia-entries.ts'\n/* `cst/host-mode.ts` and `cst/trivia-entries.ts` are import-free by design, so\n * this keeps the `parseman/run` closure minimal \u2014 see\n * test/unit/run-entry-closure.test.ts. */\nimport { assertHostModeCompatible, FUSED_HOST_MODE, FUSED_HOST_ELIDED, type HostMode } from '../cst/host-mode.ts'\n\n/**\n * Run a compiled/interpreted grammar entry against an input and collect the raw\n * outcome a tool needs to shape a parse result \u2014 WITHOUT the consumer having to\n * hand-build a `ctx`, branch on function-vs-combinator, or scan for leftover\n * input itself.\n *\n * A `compile()`/macro grammar hands you a map of bare parse FUNCTIONS; the\n * interpreter hands you COMBINATORS. `run()` invokes either, threads the standard\n * framework ctx (trivia log, recover/expect error sink, the `ctx.build` host,\n * grammar state), and \u2014 given the grammar's trivia parser \u2014 reports where\n * non-trivia input was left unconsumed. The consumer keeps only its own policy:\n * how to shape the tree and how to turn diagnostics into its error type.\n */\n\n/** A compiled rule (macro/`compile()` output) OR an interpreter combinator. */\nexport type Runnable =\n  | ((input: string, pos: number, ctx: ParseContext) => ParseResult<unknown>)\n  | Combinator<unknown>\n\nexport type RunOptions = {\n  /** Optional hooks for a coverage-enabled compiled or macro parser. Ordinary\n   * parses omit this completely, so instrumentation has no normal-path cost. */\n  instrumentation?: {\n    _grammarCoverage?: (id: string) => void\n    _grammarTrace?: { write(event: { id: string; phase: 'enter' | 'attempt' | 'selected' | 'success' | 'failure' | 'backtrack' | 'rollback'; offset: number; end?: number }): void }\n  }\n  /** `ctx.build` host \u2014 makes structural `node()` rules build a CST / AST via the\n   * host instead of their own eval builders. Omit for a grammar's own builders. */\n  build?: ParseContext['build']\n  /** Initial grammar state threaded into `ctx.state`. */\n  state?: unknown\n  /**\n   * The grammar's trivia rule. A root rule consumes trivia BETWEEN terms but not\n   * after the last one, so trailing whitespace/comments would otherwise look like\n   * unparsed input. Given the trivia rule, `run` skips that tail before computing\n   * `unconsumedFrom` \u2014 so only real leftover is reported. Also encodes dialect\n   * differences for free: pass the CSS trivia and a trailing `//` counts as\n   * leftover; pass the Less trivia (which treats `//` as a line comment) and it\n   * doesn't. An UNTERMINATED comment (which the trivia rule won't match) surfaces\n   * at its start. Omit to require the parse to reach the exact end itself.\n   */\n  trivia?: Runnable\n  /**\n   * Restrict PER-NODE CST trivia capture (the `triviaLog` a node's builder sees)\n   * to these trivia kinds \u2014 a bitmask over the grammar's `triviaKindLabels`\n   * indices (build it with `triviaKindMask(labels, ['comment', \u2026])`). Unlisted\n   * kinds (e.g. whitespace) are skipped over but not recorded per node, so a host\n   * that only reads comments doesn't pay to log every whitespace run. Omit to\n   * capture every kind.\n   */\n  triviaCaptureMask?: number\n  /**\n   * Opt into sparse root trivia capture. `run()` retains no root trivia unless\n   * this is supplied. Capture records only the named labels, each with the one\n   * complete authored gap that owns it; ordinary whitespace has no root entry.\n   */\n  rootTrivia?: {\n    readonly select: readonly string[]\n  }\n  /**\n   * Activate automatic list recovery. When true, `many`/`sepBy`/`oneOrMore` recover\n   * from a failed element \u2014 skip to a sync point (a resume token inferred from the\n   * grammar's structure; the grammar carries no recovery config), emit a\n   * `ParseError` over the skipped span (collected in `errors`), and keep parsing the\n   * rest of the list \u2014 instead of stopping at the first bad element. Omit (the\n   * default) for the strict \"one clean error and stop\" behavior, byte-identical to a\n   * run with no recovery. Recovery is a cold path: on well-formed input nothing\n   * fails, so none of the machinery runs.\n   */\n  tolerant?: boolean\n  /**\n   * Run three compiled-parser-only profiling passes: recognizer (no global\n   * sinks), structural capture without the host, then the normal host path. This\n   * is a measurement boundary, not a parser mode; ordinary `run()` output is\n   * unchanged when omitted. The input is parsed THREE times \u2014 each pass gets its\n   * own shallow copy of `options.state`, so keep per-parse state shallow (only\n   * the top level is isolated between passes).\n   */\n  profile?: boolean\n}\n\nexport type RootTriviaCapture = {\n  /** Packed `[gapStart, gapEnd, markerStart, markerEnd, selectedKindIndex]` rows. */\n  readonly rows: readonly number[]\n  /** Labels requested by this caller; row kind indices refer to this array. */\n  readonly select: readonly string[]\n  /** Lazy lookup over `rows`; no tokens or strings are materialized. */\n  readonly index: RootTriviaIndex\n}\n\nexport type RunProfilePass = {\n  ms: number\n  nodes: number\n  childSlots: number\n  rawSlots: number\n  triviaSlots: number\n  fieldSlots: number\n  hostCalls: number\n}\n\nexport type RunProfile = {\n  /** Existing `voidOf(transform(..., () => undefined))` semantics, generalized\n   * to compiled structural nodes: no `ch`/`raw`/`tl` capture or raw entries. */\n  recognizer: RunProfilePass\n  /** Captures children/raw/trivia/fields but suppresses node construction. */\n  structuralCapture: RunProfilePass\n  /** The ordinary parser path, including its injected build host. */\n  hostConstruction: RunProfilePass\n}\n\nexport type RunResult = {\n  ok: boolean\n  /** The entry's value on success; undefined on failure. */\n  value: unknown\n  span: { start: number; end: number }\n  /** Expected-token set when the TOP-LEVEL parse failed (empty on success). */\n  expected: string[]\n  /** Recovery diagnostics (tolerant lists / `expect()`) collected during the parse (in order). */\n  errors: ParseError[]\n  /**\n   * Sparse selected root trivia. This is present only when at least one requested\n   * category was actually retained; omitted means the parse retained no root\n   * trivia at all.\n   */\n  rootTrivia?: RootTriviaCapture\n  /** Offset where unparsed input begins \u2014 the first non-trivia character the parse\n   * left unconsumed (trailing trivia skipped when `trivia` is given), or null if\n   * the whole input was consumed. This is how you detect \"the grammar stopped short,\n   * there's junk here\". Only meaningful on success \u2014 a failed parse reports its own\n   * `span`/`expected`. */\n  unconsumedFrom: number | null\n  /** Present only when `RunOptions.profile` is true. */\n  profile?: RunProfile\n}\n\n/**\n * 0.44 dropped three `RunResult` fields \u2014 `triviaMap` and `triviaLog`, both\n * MANDATORY in 0.43, and the optional `triviaKindLabels`. Removing them without\n * a signal makes each read `undefined`, and `undefined` travels: it surfaces as\n * a property access on nothing somewhere inside the CONSUMER's code, in a\n * message naming neither parseman, the field, nor the replacement. That is the\n * same defect as a diagnostic that reports a number when it means \"I could not\n * run\" \u2014 the tool's inability wearing the costume of a result.\n *\n * `triviaKindLabels` is the worst of the three despite being optional: it fed\n * `triviaKindMask`, which treats `undefined` as \"capture everything\", so its\n * removal silently changes behaviour rather than producing so much as a crash.\n *\n * So the names are kept as accessors that throw the migration. They are\n * NON-ENUMERABLE deliberately: absent from `Object.keys`, spreads,\n * `JSON.stringify` and identity digests, so restoring them moves no output and\n * costs nothing on the parse path \u2014 they exist only to answer a read.\n */\nconst SELECT_EXAMPLE = \"run(entry, input, { rootTrivia: { select: ['blockComment', 'lineComment'] } })\"\n\nconst REMOVED_RUN_RESULT_FIELDS: ReadonlyArray<readonly [string, string]> = [\n  [\n    'triviaMap',\n    'It was a dense root-trivia index built on every parse; root trivia is now an OPT-IN sparse '\n    + 'capture, because most grammars paid for an index they never read. Migration: name the trivia '\n    + `labels your grammar defines \u2014 ${SELECT_EXAMPLE} \u2014 and read \\`RunResult.rootTrivia\\`, whose `\n    + '`.index` carries the labels and gap lookups `triviaMap` exposed.',\n  ],\n  [\n    'triviaLog',\n    'It was the flat `start, end[, kindIndex]` log every other trivia view was derived from, and it '\n    + 'is no longer allocated at all \u2014 not empty, absent. Migration: request the labels you need '\n    + `\u2014 ${SELECT_EXAMPLE} \u2014 and read \\`RunResult.rootTrivia.rows\\`. Do NOT reuse a stride-2/3 reader: `\n    + 'rows are a different width and a different unit (one row per SELECTED marker, not one per '\n    + 'trivia chunk), so an old loop reads confidently wrong offsets rather than failing.',\n  ],\n  [\n    'triviaKindLabels',\n    'It was already optional, so nothing ever flagged its disappearance \u2014 and `triviaKindMask(undefined, '\n    + '\u2026)` means \"capture everything\", so reading it now silently WIDENS capture instead of erroring. '\n    + `Migration: request labels \u2014 ${SELECT_EXAMPLE} \u2014 then the set you asked for is `\n    + '`RunResult.rootTrivia.select` and the resolved table is `RunResult.rootTrivia.index.labels`.',\n  ],\n]\n\n/**\n * `rootTrivia` is ABSENT rather than empty when no requested category was\n * retained, so branch on it \u2014 do not index into it.\n */\nfunction guardRemovedFields(result: RunResult): RunResult {\n  for (const [name, detail] of REMOVED_RUN_RESULT_FIELDS) {\n    Object.defineProperty(result, name, {\n      configurable: true,\n      enumerable: false,\n      get(): never {\n        throw new TypeError(\n          `RunResult.${name} was REMOVED in parseman 0.44.0 and has no default replacement. ${detail}`,\n        )\n      },\n    })\n  }\n  return result\n}\n\nconst invoke = (r: Runnable, input: string, pos: number, ctx: ParseContext): ParseResult<unknown> =>\n  typeof r === 'function' ? r(input, pos, ctx) : r.parse(input, pos, ctx)\n\ntype ProfilePhase = NonNullable<ParseContext['_pmProfile']>['phase']\ntype ProfileState = NonNullable<ParseContext['_pmProfile']>\ntype RunnableMeta = {\n  readonly _meta?: {\n    readonly triviaKindLabels?: readonly string[]\n    readonly rootTriviaClassified?: true\n  }\n}\n\nfunction triviaKindLabelsFromRunnable(r: Runnable | undefined): readonly string[] | undefined {\n  if (!r) return undefined\n  if (typeof r === 'function') return (r as RunnableMeta)._meta?.triviaKindLabels\n  const grammarTrivia = (r._meta as { grammarTrivia?: Combinator<unknown> }).grammarTrivia\n  return grammarTrivia?._meta.triviaKindLabels\n    ?? r._meta.triviaKindLabels\n    ?? (r._def.tag === 'grammar' ? r._def.triviaParser?._meta.triviaKindLabels : undefined)\n}\n\nfunction rootTriviaClassifiedFromRunnable(r: Runnable | undefined): boolean {\n  if (!r) return false\n  if (typeof r === 'function') return (r as RunnableMeta)._meta?.rootTriviaClassified === true\n  const grammarTrivia = (r._meta as { grammarTrivia?: Combinator<unknown> }).grammarTrivia\n  return grammarTrivia?._meta.rootTriviaClassified === true || r._meta.rootTriviaClassified === true\n}\n\nfunction makeSelectedRootLabelIndex(labels: readonly string[]): Readonly<Record<string, number>> {\n  const index: Record<string, number> = Object.create(null) as Record<string, number>\n  for (let i = 0; i < labels.length; i++) {\n    if (index[labels[i]!] === undefined) index[labels[i]!] = i\n  }\n  return index\n}\n\n/** Keep the run-entry closure independent from grammar-construction helpers. */\nfunction runOnce(entry: Runnable, input: string, options: RunOptions, phase?: ProfilePhase, profileState?: ProfileState): RunResult {\n  if (typeof entry !== 'function' && typeof (entry as Combinator<unknown> | undefined)?.parse !== 'function') {\n    throw new TypeError(\n      `run(): start production is ${entry === null ? 'null' : typeof entry}, not a rule \u2014 the requested grammar rule does not exist (check the rule name).`,\n    )\n  }\n  const rootTriviaSelection = options.rootTrivia?.select\n  const captureRootTrivia = rootTriviaSelection !== undefined && rootTriviaSelection.length > 0\n  const selectedRootLog = captureRootTrivia ? [] as number[] : undefined\n  const selectedRootLabelIndex = captureRootTrivia\n    ? makeSelectedRootLabelIndex(rootTriviaSelection)\n    : undefined\n  const errors: ParseError[] = []\n  const profile = profileState ?? (phase === undefined\n    ? undefined\n    : { phase, nodes: 0, childSlots: 0, rawSlots: 0, triviaSlots: 0, fieldSlots: 0, hostCalls: 0 })\n  // NOT \"no output\" \u2014 the `capture` phase still allocates per-node children/raw/\n  // trivia buffers and records slot counts. This flag only omits the two GLOBAL\n  // sinks (`_triviaLog`, `_errors`) from the context; hence `skipGlobalSinks`.\n  const skipGlobalSinks = phase === 'recognizer' || phase === 'capture'\n  // Grammar-level ambient trivia declared via rules({ trivia }, factory): install\n  // it as ctx.trivia so it's ambient for the whole parse (the interpreter path;\n  // a compiled entry has it baked in and carries no _meta). parser/noTrivia still\n  // override locally.\n  const grammarTrivia = typeof entry !== 'function' ? entry._meta.grammarTrivia : undefined\n  const grammarScanSkip = typeof entry !== 'function' ? entry._meta.grammarScanSkip : undefined\n  const triviaKindLabels = triviaKindLabelsFromRunnable(entry) ?? triviaKindLabelsFromRunnable(options.trivia)\n  if (captureRootTrivia && triviaKindLabels === undefined) {\n    throw new TypeError('run(): rootTrivia.select requires labeled grammar trivia.')\n  }\n  if (captureRootTrivia) {\n    for (const label of rootTriviaSelection) {\n      if (!triviaKindLabels!.includes(label)) {\n        throw new TypeError(`run(): rootTrivia.select contains unknown trivia label ${JSON.stringify(label)}.`)\n      }\n    }\n  }\n  if (captureRootTrivia\n    && !rootTriviaClassifiedFromRunnable(entry)\n    && !rootTriviaClassifiedFromRunnable(options.trivia)) {\n    throw new TypeError(\n      'run(): rootTrivia.select requires classifiedTrivia() at the root.',\n    )\n  }\n  /*\n   * Refuse an artifact/host mismatch ONCE per parse, exactly as `parseDoc` and a\n   * compiled parser's `parseWithContext` already do. `run()` is handed a RULE, not the\n   * registry, so the fused rule functions carry the stamp themselves (see `fusedBody`);\n   * an interpreter entry carries it on `_meta`. Neither is on a hot path \u2014 this runs\n   * once, before `invoke`.\n   *\n   * Without this, `run()` was the one driver that could silently produce the wrong tree\n   * shape: an 'ast' artifact driven with a positioned-CST host returns its own AST\n   * objects where the caller asked for a CST, and a CST child filter then drops them\n   * and the node simply vanishes.\n   *\n   * The INTERPRETER passes `elided: false` unconditionally, and that is not a shortcut:\n   * it has no compile step, re-decides the host route per parse, and so has never\n   * dropped a branch. Only its `'cst'`-without-a-host half can be wrong.\n   */\n  const stamped = entry as Partial<Record<symbol, unknown>>\n  assertHostModeCompatible(\n    typeof entry === 'function'\n      ? ((stamped[FUSED_HOST_MODE] as HostMode | undefined) ?? 'ast')\n      : (entry._meta.grammarHostMode ?? 'ast'),\n    options.build,\n    typeof entry === 'function' && stamped[FUSED_HOST_ELIDED] === true,\n  )\n  const ctx: ParseContext = {\n    trackLines: false,\n    ...(skipGlobalSinks\n      ? { _pmProfile: profile! }\n      : {\n        ...(captureRootTrivia\n          ? {\n              _rootTriviaLog: selectedRootLog!,\n              _rootTriviaKindIndex: selectedRootLabelIndex!,\n              _rootTriviaStrictScopes: true,\n            }\n          : {}),\n        _errors: errors,\n        ...(profile === undefined ? {} : { _pmProfile: profile }),\n      }),\n    build: options.build,\n    state: options.state,\n    ...(grammarTrivia !== undefined\n      ? { trivia: grammarTrivia, ...(triviaKindLabels ? { triviaKindLabels } : {}) }\n      : triviaKindLabels ? { triviaKindLabels } : {}),\n    ...(grammarScanSkip !== undefined ? { scanSkip: grammarScanSkip } : {}),\n    ...(options.triviaCaptureMask !== undefined ? { _triviaCaptureMask: options.triviaCaptureMask } : {}),\n    ...(options.tolerant ? { _tolerant: true, _rec: REC } : {}),\n    ...(options.instrumentation === undefined ? {} : options.instrumentation),\n  }\n  const r = invoke(entry, input, 0, ctx)\n\n  let unconsumedFrom: number | null = null\n  if (r.ok) {\n    let pos = r.span?.end ?? 0\n    if (options.trivia && pos < input.length) {\n      // Throwaway ctx: trailing trivia must NOT pollute the parse's trivia log.\n      const t = invoke(options.trivia, input, pos, { trackLines: false })\n      if (t.ok && t.span.end > pos) pos = t.span.end\n    }\n    unconsumedFrom = pos < input.length ? pos : null\n  }\n\n  return {\n    ok: r.ok,\n    value: r.ok ? (r as { value: unknown }).value : undefined,\n    span: r.span ?? { start: 0, end: 0 },\n    expected: r.ok ? [] : ((r as { expected?: string[] }).expected ?? []),\n    errors,\n    ...(selectedRootLog !== undefined && selectedRootLog.length > 0\n      ? {\n          rootTrivia: {\n            rows: selectedRootLog!,\n            select: rootTriviaSelection!,\n            index: buildRootTriviaIndex(selectedRootLog!, rootTriviaSelection!),\n          },\n        }\n      : {}),\n    unconsumedFrom,\n  }\n}\n\n/* The three-pass profiling driver (`clonePassState` / `profilePass`) was removed\n * with the emitted counters it read. `runOnce` still accepts `phase`/`profileState`\n * and `RunProfile`/`RunProfilePass` are still exported, so the interpreted\n * reimplementation can restore the driver without reshaping the public result. */\n\nexport function run(entry: Runnable, input: string, options: RunOptions = {}): RunResult {\n  if (!options.profile) return guardRemovedFields(runOnce(entry, input, options))\n  // Profiling counters are no longer emitted into compiled artifacts \u2014 they cost a\n  // `_ctx._pmProfile` read plus ~15 threaded ternaries on EVERY node, which is the\n  // \"diagnostic machinery in codegen\" the compiled path must not pay for. The\n  // interpreter has never implemented `_pmProfile` either, so no route can answer\n  // this today. Fail LOUDLY: the passes below would otherwise all report zero, and\n  // an all-zero profile reads as a real measurement rather than as \"I could not\n  // run\" \u2014 the exact defect `guardRemovedFields` exists to prevent for the removed\n  // 0.44 fields. The pass machinery is retained, unmodified, for the interpreted\n  // reimplementation.\n  throw new TypeError(\n    'run({ profile: true }) is unavailable: profiling counters are no longer compiled into '\n    + 'parser artifacts, and the interpreter does not implement them yet. Profiling is moving '\n    + 'to interpreted mode.',\n  )\n}\n"],
-  "mappings": "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",
+  "sources": ["../../src/run/index.ts", "../../src/cst/trivia-entries.ts", "../../src/line-index.ts", "../../src/cst/capture-buffer.ts", "../../src/recovery/scan.ts", "../../src/parse-context.ts", "../../src/cst/host-mode.ts", "../../src/functional/run.ts"],
+  "mappings": "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",
   "names": ["kind"]
 }