parseman 0.41.0 → 0.42.0

package/dist/plugin/index.cjs

@@ -317,6 +317,65 @@ function failAt(ctx, expected, pos) {
   return r;
 }
 
+// src/line-index.ts
+function createLineIndex() {
+  return { lineStarts: [0] };
+}
+function recordLineRange(index, input, start, end) {
+  const lineStarts = index.lineStarts;
+  for (let i = start; i < end; i++) {
+    if (input.charCodeAt(i) === 10) lineStarts.push(i + 1);
+  }
+}
+function recordLineRangeFromContext(ctx, input, _startHint, end) {
+  if (!ctx.trackLines) return;
+  const from = ctx._lineScannedTo ?? 0;
+  if (end <= from) return;
+  const index = ctx._lineIndex ?? (ctx._lineStarts ? { lineStarts: ctx._lineStarts } : void 0);
+  if (!index) return;
+  recordLineRange(index, input, from, end);
+  ctx._lineScannedTo = end;
+}
+function normalizeLineIndex(index) {
+  const starts = index.lineStarts;
+  starts.sort((a, b) => a - b);
+  let write = 0;
+  for (let read = 0; read < starts.length; read++) {
+    const value = starts[read];
+    if (write === 0 || starts[write - 1] !== value) starts[write++] = value;
+  }
+  starts.length = write;
+  if (starts.length === 0 || starts[0] !== 0) starts.unshift(0);
+  return index;
+}
+function offsetToLineCol(index, offset) {
+  const { lineStarts } = index;
+  let lo = 0;
+  let hi = lineStarts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (lineStarts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return { line: lo + 1, col: offset - lineStarts[lo] + 1 };
+}
+function annotateSpan(span, index) {
+  const s = offsetToLineCol(index, span.start);
+  const e = offsetToLineCol(index, span.end);
+  return {
+    ...span,
+    startLine: s.line,
+    startColumn: s.col,
+    endLine: e.line,
+    endColumn: e.col
+  };
+}
+function annotateSpanFromLineContext(span, ctx) {
+  if (!ctx.trackLines) return span;
+  const index = ctx._lineIndex ?? (ctx._lineStarts ? { lineStarts: ctx._lineStarts } : void 0);
+  return index ? annotateSpan(span, index) : span;
+}
+
 // src/cst/capture-buffer.ts
 var EMPTY = [];
 var EMPTY_TL = [];
@@ -358,7 +417,12 @@ function endCstNodeCapture(ctx, saved) {
   return materialized;
 }
 function pushCstLeaf(ctx, leaf2) {
-  pushCstChild(ctx, leaf2, leaf2);
+  if (!ctx.trackLines) {
+    pushCstChild(ctx, leaf2, leaf2);
+    return;
+  }
+  const annotated = leaf2 && typeof leaf2 === "object" && leaf2.span ? { ...leaf2, span: annotateSpanFromLineContext(leaf2.span, ctx) } : leaf2;
+  pushCstChild(ctx, annotated, annotated);
 }
 function pushCstChild(ctx, built, rawEntry) {
   const b = ctx._cstBuf;
@@ -492,6 +556,7 @@ function literal(value, opts = {}) {
     canMatchNewline: value.includes("\n"),
     isTrivia: false
   };
+  const canMatchNewline = meta.canMatchNewline;
   if (caseInsensitive) {
     const upper = value.toUpperCase();
     const lower = value.toLowerCase();
@@ -508,6 +573,7 @@ function literal(value, opts = {}) {
     return function parse3(input, pos, ctx) {
       if (input.charCodeAt(pos) === code) {
         const span = { start: pos, end: pos + 1 };
+        if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, span.end);
         if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span });
         return { ok: true, value, span };
       }
@@ -521,6 +587,7 @@ function literal(value, opts = {}) {
     const matchedValue = caseInsensitive ? input.slice(pos, end) : value;
     if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {
       const span = { start: pos, end };
+      if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, end);
       if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: matchedValue, span });
       return { ok: true, value: matchedValue, span };
     }
@@ -688,6 +755,7 @@ function regex(pattern, flags = "") {
         if (scanEnd === null) return failAt(ctx, [`/${source}/`], pos);
         const value = input.slice(pos, scanEnd);
         const span2 = { start: pos, end: scanEnd };
+        if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, scanEnd);
         if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span: span2 });
         return { ok: true, value, span: span2 };
       }
@@ -697,6 +765,7 @@ function regex(pattern, flags = "") {
         return failAt(ctx, [`/${source}/`], pos);
       }
       const span = { start: pos, end: pos + m[0].length };
+      if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, span.end);
       if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: m[0], span });
       return { ok: true, value: m[0], span };
     }
@@ -835,8 +904,8 @@ function parseRegex(src) {
     }
     if (src[k] !== "]") throw BAIL;
     i = k + 1;
-    if (negated) return charNode(any(), true);
     const ranges = parseClassRanges(body);
+    if (negated) return charNode(any(), !ranges || !rangesHaveNewline(ranges));
     if (!ranges) return charNode(any(), true);
     return charNode(rangesToSet(ranges), rangesHaveNewline(ranges));
   };
@@ -932,7 +1001,7 @@ function firstSet(n) {
     }
   }
 }
-function firstCanBeNewline(n) {
+function canConsumeNewline(n) {
   switch (n.t) {
     case "char":
       return n.nl;
@@ -941,16 +1010,11 @@ function firstCanBeNewline(n) {
     case "empty":
       return false;
     case "rep":
-      return firstCanBeNewline(n.node);
+      return canConsumeNewline(n.node);
     case "alt":
-      return n.arms.some(firstCanBeNewline);
-    case "seq": {
-      for (const part of n.parts) {
-        if (firstCanBeNewline(part)) return true;
-        if (!nullable(part)) break;
-      }
-      return false;
-    }
+      return n.arms.some(canConsumeNewline);
+    case "seq":
+      return n.parts.some(canConsumeNewline);
   }
 }
 function firstSetFromRegex(source) {
@@ -960,8 +1024,8 @@ function firstSetFromRegex(source) {
   } catch {
     return { firstSet: any(), canMatchNewline: true };
   }
-  if (nullable(ast)) return { firstSet: any(), canMatchNewline: true };
-  return { firstSet: firstSet(ast), canMatchNewline: firstCanBeNewline(ast) };
+  if (nullable(ast)) return { firstSet: any(), canMatchNewline: canConsumeNewline(ast) };
+  return { firstSet: firstSet(ast), canMatchNewline: canConsumeNewline(ast) };
 }
 
 // src/combinators/case-fold.ts
@@ -1118,7 +1182,9 @@ function firstSetSentinel(fs2) {
 function recoverScan(input, from, ctx, sync, expected) {
   let scanPos = from;
   while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++;
-  const error = { _tag: "parseError", span: { start: from, end: scanPos }, expected };
+  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 };
 }
@@ -1220,7 +1286,8 @@ function expect(combinator, label2) {
     parse(input, pos, ctx) {
       const result = combinator.parse(input, pos, ctx);
       if (result.ok) return result;
-      const error = { _tag: "parseError", span: { start: pos, end: pos }, expected };
+      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 } };
@@ -1665,6 +1732,18 @@ 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 } : {}
+  };
+  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 };
 }
@@ -1687,13 +1766,29 @@ function scanWithLabels(input, cur, ctx) {
 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;
+    }
+    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) return fast(input, cur);
+  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 = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state });
+  const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
   return tr.ok && tr.span.end > cur ? tr.span.end : cur;
 }
 function scanTrivia(input, cur, ctx) {
@@ -1701,18 +1796,46 @@ function scanTrivia(input, cur, ctx) {
   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);
+        }
+      };
+    }
+    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) {
-    return { end: fast(input, cur), commit: NOOP_COMMIT };
+    const end = fast(input, cur);
+    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, end);
+    return { end, commit: NOOP_COMMIT };
   }
   if (ctx.triviaKindLabels && (log !== void 0 || captureTl)) {
-    return scanWithLabels(input, cur, ctx);
+    const scan = scanWithLabels(input, cur, ctx);
+    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, scan.end);
+    return scan;
   }
   if (log !== void 0 || captureTl) {
-    const tr2 = triviaP.parse(input, cur, {
-      trackLines: log !== void 0 ? false : ctx.trackLines,
-      state: ctx.state
-    });
+    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 {
@@ -1723,7 +1846,7 @@ function scanTrivia(input, cur, ctx) {
       }
     };
   }
-  const tr = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state });
+  const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
   return { end: tr.ok ? tr.span.end : cur, commit: NOOP_COMMIT };
 }
 function consumeTrivia(input, cur, ctx) {
@@ -3107,13 +3230,14 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
       const st = clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
       const nodeType = def.type ?? missingInferredType();
       const cstOutput = cstOutputHost(ctx.build);
+      const span = ctx.trackLines ? annotateSpanFromLineContext(r.span, ctx) : r.span;
       const hostState = clonesState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
-      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : !build && project === void 0 && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, r.span, rawChildren, triviaLog, hostState) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, r.span, rawChildren, triviaLog, hostState) : build(children2, fields, r.span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, r.span, rawChildren, triviaLog, st) : { _tag: "node", type: nodeType, span: { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
-      const rawEntry = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span: r.span };
+      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : !build && project === void 0 && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState) : build(children2, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, st) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
+      const rawEntry = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
         pushCstChild(ctx, built, rawEntry);
       }
-      return { ok: true, value: built, span: r.span };
+      return { ok: true, value: built, span };
     }
   };
 }
@@ -3184,38 +3308,24 @@ function field(name, combinator) {
   };
 }
 
-// src/compiler/line-index.ts
-function buildLineIndex(input) {
-  const lineStarts = [0];
-  for (let i = 0; i < input.length; i++) {
-    if (input.charCodeAt(i) === 10) lineStarts.push(i + 1);
-  }
-  return { lineStarts };
-}
-function offsetToLineCol(index, offset) {
-  const { lineStarts } = index;
-  let lo = 0;
-  let hi = lineStarts.length - 1;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >> 1;
-    if (lineStarts[mid] <= offset) lo = mid;
-    else hi = mid - 1;
+// src/combinators/grammar.ts
+function annotateResultLines(result, index) {
+  const annotated = { ...result, span: annotateSpan(result.span, index) };
+  const errors = annotated.errors;
+  if (errors) {
+    ;
+    annotated.errors = errors.map((error) => ({
+      ...error,
+      span: annotateSpan(error.span, index)
+    }));
   }
-  return { line: lo + 1, col: offset - lineStarts[lo] + 1 };
+  return annotated;
 }
-function annotateSpan(span, index) {
-  const s = offsetToLineCol(index, span.start);
-  const e = offsetToLineCol(index, span.end);
-  return {
-    ...span,
-    startLine: s.line,
-    startColumn: s.col,
-    endLine: e.line,
-    endColumn: e.col
-  };
+function createParseLineContext(input, pos) {
+  const lineIndex = createLineIndex();
+  if (pos > 0) recordLineRange(lineIndex, input, 0, pos);
+  return { lineIndex, lineScannedTo: pos };
 }
-
-// src/combinators/grammar.ts
 function parser(opts, root) {
   const clearTrivia = opts.trivia === null;
   return {
@@ -3231,9 +3341,13 @@ function parser(opts, root) {
     },
     parse(input, pos, _ctx) {
       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;
       const ctx = {
         ..._ctx,
         trackLines,
+        ...lineIndex ? { _lineIndex: lineIndex } : {},
+        ...lineContext ? { _lineScannedTo: lineContext.lineScannedTo } : {},
         // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.
         ...clearTrivia ? {
           trivia: void 0,
@@ -3251,11 +3365,10 @@ function parser(opts, root) {
         ...opts.captureTriviaKinds && !clearTrivia ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) } : {}
       };
       const result = root.parse(input, pos ?? 0, ctx);
-      if (trackLines) {
-        const idx = buildLineIndex(input);
-        return { ...result, span: annotateSpan(result.span, idx) };
+      if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
+        _ctx._lineScannedTo = Math.max(_ctx._lineScannedTo ?? 0, ctx._lineScannedTo);
       }
-      return result;
+      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
     }
   };
 }
@@ -3359,7 +3472,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.41.0";
+var PARSEMAN_VERSION = "0.42.0";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -5043,7 +5156,7 @@ function scanTo(sentinel, { skip: skip2, raw = false, orEOF = false } = {}) {
       let cur = pos;
       const skip3 = resolveScanSkip(explicitSkip, raw, ctx);
       const probeCtx = {
-        trackLines: ctx.trackLines,
+        trackLines: false,
         state: ctx.state,
         ...ctx._errors !== void 0 ? { _errors: ctx._errors } : {}
       };
@@ -5056,6 +5169,7 @@ function scanTo(sentinel, { skip: skip2, raw = false, orEOF = false } = {}) {
       while (cur < input.length) {
         const s = sentinel.parse(input, cur, probeCtx);
         if (s.ok) {
+          if (ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, cur);
           emit2(cur);
           return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } };
         }
@@ -5071,6 +5185,7 @@ function scanTo(sentinel, { skip: skip2, raw = false, orEOF = false } = {}) {
         if (!advanced) cur++;
       }
       if (orEOF) {
+        if (ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, cur);
         emit2(cur);
         return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } };
       }
@@ -6509,8 +6624,8 @@ function analyzeMkInlineBuild(def) {
   if (looseMkBuildRe(def.type).test(src)) return def.type;
   return null;
 }
-function emitInlineMkNodeExpr(type, chV, rawV, pos, endVar, tlV) {
-  return `{ _tag: 'node', type: ${JSON.stringify(type)}, span: { start: ${pos}, end: ${endVar} }, children: ${chV}, rawCount: ${rawV}.length, localTriviaLen: ${tlV}.length }`;
+function emitInlineMkNodeExpr(type, chV, rawV, spanExpr, tlV) {
+  return `{ _tag: 'node', type: ${JSON.stringify(type)}, span: ${spanExpr}, children: ${chV}, rawCount: ${rawV}.length, localTriviaLen: ${tlV}.length }`;
 }
 
 // src/compiler/inline-callback.ts
@@ -6692,6 +6807,8 @@ function leadingFirstSetRecipe(p, seen = /* @__PURE__ */ new Set()) {
   }
 }
 var HOST_READS_DECL = "const _hostReads = (b, n) => { if (b === undefined) return false; let s; try { s = Function.prototype.toString.call(b) } catch (e) { return true } if (/\\barguments\\b/.test(s)) return true; const m = /^[^(]*\\(([\\s\\S]*?)\\)/.exec(s); if (m && /\\.\\.\\.|=/.test(m[1])) return true; return b.length > n }";
+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 beginLoweringCapture() {
   _loweringSink = /* @__PURE__ */ new Set();
@@ -6840,14 +6957,46 @@ function emitLeafCapture(ctx, valExpr, startExpr, endExpr) {
   if (ctx.capAsTrivia) return [];
   const i = ind(ctx);
   const lf = v(ctx, "_lf");
+  const spanExpr = emitSpanExpr(ctx, startExpr, endExpr);
   return [
     `${i}if (_ctx._cstLeaves || _ctx._cstRawChildren) {`,
-    `${i}  const ${lf} = { _tag: 'leaf', value: ${valExpr}, span: { start: ${startExpr}, end: ${endExpr} } }`,
+    `${i}  const ${lf} = { _tag: 'leaf', value: ${valExpr}, span: ${spanExpr} }`,
     `${i}  if (_ctx._cstLeaves) _ctx._cstLeaves.push(${lf})`,
     `${i}  if (_ctx._cstRawChildren) _ctx._cstRawChildren.push(${lf})`,
     `${i}}`
   ];
 }
+function emitSpanExpr(ctx, startExpr, endExpr) {
+  if (!ctx.lineTracking) return `{ start: ${startExpr}, end: ${endExpr} }`;
+  ctx.needsLineSpan = true;
+  return `_spanLines(_ctx, ${startExpr}, ${endExpr})`;
+}
+function emitLineTrack(ctx, startExpr, endExpr) {
+  if (!ctx.lineTracking) return [];
+  ctx.needsLineTrack = true;
+  return [`${ind(ctx)}_trackLines(_ctx, input, ${startExpr}, ${endExpr})`];
+}
+function emitLiteralLineTrack(ctx, startExpr, value) {
+  if (!ctx.lineTracking) return [];
+  const lineDeltas = [];
+  for (let i = 0; i < value.length; i++) {
+    if (value.charCodeAt(i) === 10) lineDeltas.push(i + 1);
+  }
+  if (lineDeltas.length === 0) return [];
+  const fromV = v(ctx, "_ltFrom");
+  const endExpr = value.length === 0 ? startExpr : `${startExpr} + ${value.length}`;
+  return [
+    `${ind(ctx)}const ${fromV} = _ctx._lineScannedTo ?? 0`,
+    `${ind(ctx)}if (${endExpr} > ${fromV}) {`,
+    `${ind(ctx)}  for (let i = ${fromV}; i < ${startExpr}; i++) if (input.charCodeAt(i) === 10) _ctx._lineStarts.push(i + 1)`,
+    ...lineDeltas.map((delta) => {
+      const lineStart = `${startExpr} + ${delta}`;
+      return `${ind(ctx)}  if (${lineStart} > ${fromV}) _ctx._lineStarts.push(${lineStart})`;
+    }),
+    `${ind(ctx)}  _ctx._lineScannedTo = ${endExpr}`,
+    `${ind(ctx)}}`
+  ];
+}
 function ensureRegexDecl(ctx, source, flags) {
   const f = "y" + flags.replace(/[gy]/g, "");
   const key = `${source}/${f}`;
@@ -7232,6 +7381,7 @@ function emitLit(def, ctx, pos) {
     );
   }
   const endVar = len === 0 ? pos : `${pos} + ${len}`;
+  stmts.push(...emitLiteralLineTrack(ctx, pos, value));
   stmts.push(...emitLeafCapture(ctx, vv, pos, endVar));
   return { stmts, valueVar: vv, endVar };
 }
@@ -7311,7 +7461,7 @@ function emitKeywords(def, ctx, pos) {
   stmts.push(...emitLeafCapture(ctx, vv, pos, endVar));
   return { stmts, valueVar: vv, endVar };
 }
-function emitRegex(def, ctx, pos) {
+function emitRegex(def, ctx, pos, canMatchNewline = true) {
   const expectedStr = JSON.stringify(`/${def.source}/`);
   const shape = scanShapeFromRegex(def.source, def.flags);
   if (shape) {
@@ -7324,7 +7474,11 @@ function emitRegex(def, ctx, pos) {
       fresh: (prefix) => v(ctx, prefix)
     });
     if (scanned) {
-      const stmts2 = [...scanned.stmts, ...emitLeafCapture(ctx, vv2, pos, scanned.endVar)];
+      const stmts2 = [
+        ...scanned.stmts,
+        ...canMatchNewline ? emitLineTrack(ctx, pos, scanned.endVar) : [],
+        ...emitLeafCapture(ctx, vv2, pos, scanned.endVar)
+      ];
       return { stmts: stmts2, valueVar: vv2, endVar: scanned.endVar };
     }
   }
@@ -7346,6 +7500,7 @@ function emitRegex(def, ctx, pos) {
     `${ind(ctx)}const ${vv} = ${mv}[0]`
   ];
   const endVar = `${pos} + ${vv}.length`;
+  if (canMatchNewline) stmts.push(...emitLineTrack(ctx, pos, endVar));
   stmts.push(...emitLeafCapture(ctx, vv, pos, endVar));
   return { stmts, valueVar: vv, endVar };
 }
@@ -7383,7 +7538,8 @@ function emitSeqValues(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`,
-          `${ind(ctx)}const ${scanEndV} = ${capFn}(input, ${curV}, _ctx, 1)`
+          `${ind(ctx)}const ${scanEndV} = ${capFn}(input, ${curV}, _ctx, 1)`,
+          ...emitLineTrack(ctx, curV, scanEndV)
         );
         const r2 = emit(def.parsers[i], ctx, scanEndV);
         stmts.push(...r2.stmts);
@@ -7401,7 +7557,8 @@ function emitSeqValues(def, ctx, pos) {
         const capArg = ctx.noHoist ? "0" : "_ctx._triviaLog !== undefined ? 2 : 0";
         stmts.push(
           `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,
-          `${ind(ctx)}const ${scanEndV} = ${trivFn}(input, ${curV}, _ctx, ${capArg})`
+          `${ind(ctx)}const ${scanEndV} = ${trivFn}(input, ${curV}, _ctx, ${capArg})`,
+          ...emitLineTrack(ctx, curV, scanEndV)
         );
         const r2 = emit(def.parsers[i], ctx, scanEndV);
         stmts.push(...r2.stmts);
@@ -8101,14 +8258,15 @@ function emitMany(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`,
-        `${ind(ctx)}const ${npV} = ${capFn}(input, ${curV}, _ctx, 1)`
+        `${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}; `;
     } else {
       const trivFn = ensureTriviaFn(ctx);
       const npV = v(ctx, "_np");
-      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${curV}, _ctx)`);
+      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${curV}, _ctx)`, ...emitLineTrack(ctx, curV, npV));
       itemPos = npV;
     }
   }
@@ -8285,7 +8443,8 @@ function emitSepBy(_p, def, ctx, pos) {
         `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.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)`
+        `${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}; `;
@@ -8295,7 +8454,7 @@ function emitSepBy(_p, def, ctx, pos) {
       const post = postSepMarks();
       stmts.push(...post.decl);
       const npV = v(ctx, "_np");
-      stmts.push(`${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx, 1)`);
+      stmts.push(`${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx, 1)`, ...emitLineTrack(ctx, sepEnd, npV));
       const next = emitFallible(def.parser, ctx, npV, true);
       const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = next;
       stmts.push(
@@ -8307,13 +8466,13 @@ function emitSepBy(_p, def, ctx, pos) {
     } else {
       const trivFn = ensureTriviaFn(ctx);
       const spV = v(ctx, "_sp");
-      stmts.push(`${ind(ctx)}const ${spV} = ${trivFn}(input, ${curV}, _ctx)`);
+      stmts.push(`${ind(ctx)}const ${spV} = ${trivFn}(input, ${curV}, _ctx)`, ...emitLineTrack(ctx, curV, spV));
       sepAtPos = spV;
       const sep2 = emitFallible(def.separator, ctx, sepAtPos, true);
       const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep2;
       stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${sep2.mayCommit ? `if (_ctx._fc) ${committedFailBody(ctx)}; ` : ""}break }`);
       const npV = v(ctx, "_np");
-      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${sepEnd}, _ctx)`);
+      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${sepEnd}, _ctx)`, ...emitLineTrack(ctx, sepEnd, npV));
       const next = emitFallible(def.parser, ctx, npV, true);
       const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = next;
       stmts.push(
@@ -8400,6 +8559,7 @@ function emitScanTo(def, ctx, pos) {
   }
   const valV = v(ctx);
   stmts.push(`${ind(ctx)}const ${valV} = input.slice(${pos}, ${curV})`);
+  stmts.push(...emitLineTrack(ctx, pos, curV));
   if (ctx.capturing) {
     const cap = reindentStmts(emitLeafCapture(ctx, valV, pos, curV), ctx.indent + 1);
     stmts.push(`${ind(ctx)}if (${curV} > ${pos}) {`, ...cap, `${ind(ctx)}}`);
@@ -8543,7 +8703,7 @@ function tokenNullableRegex(def) {
 }
 function emitToken(def, ctx, pos) {
   const lowered = tokenNullableRegex(def);
-  if (lowered) return emitRegex(lowered, ctx, pos);
+  if (lowered) return emitRegex(lowered, ctx, pos, def.parser._meta.canMatchNewline);
   const savedTrivia = ctx.activeTrivia;
   const savedKindLabels = ctx.triviaKindLabels;
   ctx.activeTrivia = void 0;
@@ -8693,7 +8853,7 @@ ${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [],
   stmts.push(...innerStmts);
   if (def.trailingTrivia === true && ctx.activeTrivia) {
     const triviaFn = ensureTriviaFn(ctx);
-    stmts.push(`${i}const ${endVar} = ${okVar} ? ${triviaFn}(input, ${innerEndVar}, _ctx, 1) : ${innerEndVar}`);
+    stmts.push(`${i}const ${endVar} = ${okVar} ? ${triviaFn}(input, ${innerEndVar}, _ctx, 1) : ${innerEndVar}`, ...emitLineTrack(ctx, innerEndVar, endVar));
   }
   if (sf && fArr) {
     stmts.push(`${i}const ${fArr} = _ctx._fields`);
@@ -8733,8 +8893,11 @@ ${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [],
     );
   }
   const ndV = v(ctx, "_nd");
-  const buildExpr = structural ? `{ _tag: 'node', type: ${JSON.stringify(def.type)}, span: { start: ${pos}, end: ${endVar} }, state: ${stV} ?? null, children: ${chV} }` : mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, pos, endVar, tlV) : def.project !== void 0 ? emitNodeProjectExpr(def.type, def.project, chV) : `${buildRef(ctx)}[${buildIdx}](${chV}, ${fObj}, { start: ${pos}, end: ${endVar} }, ${rawV}, ${tlV}, ${stV})`;
-  const hostBuildExpr = `_ctx._pmProfile?.phase === 'host' && _ctx._pmProfile.hostCalls++, _ctx.build(${JSON.stringify(def.type)}, ${chV}, ${fObj}, { start: ${pos}, end: ${endVar} }, ${rawV}, ${tlV}, ${stV})`;
+  const nodeSpanExpr = emitSpanExpr(ctx, pos, endVar);
+  const nodeSpanV = ctx.lineTracking ? v(ctx, "_nspan") : nodeSpanExpr;
+  if (ctx.lineTracking) stmts.push(`${i}const ${nodeSpanV} = ${nodeSpanExpr}`);
+  const buildExpr = structural ? `{ _tag: 'node', type: ${JSON.stringify(def.type)}, span: ${nodeSpanV}, state: ${stV} ?? null, children: ${chV} }` : mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, nodeSpanV, tlV) : def.project !== void 0 ? emitNodeProjectExpr(def.type, def.project, chV) : `${buildRef(ctx)}[${buildIdx}](${chV}, ${fObj}, ${nodeSpanV}, ${rawV}, ${tlV}, ${stV})`;
+  const hostBuildExpr = `_ctx._pmProfile?.phase === 'host' && _ctx._pmProfile.hostCalls++, _ctx.build(${JSON.stringify(def.type)}, ${chV}, ${fObj}, ${nodeSpanV}, ${rawV}, ${tlV}, ${stV})`;
   const ndExpr = structural ? `_ctx.build !== undefined ? (${hostBuildExpr}) : (${buildExpr})` : cstOut ? hostBuildExpr : buildExpr;
   const hostCollapseExpr = structural ? `_ctx.build !== undefined && _ctx.build._parsemanCstCollapse !== undefined && ${chV}.length === 1 && ${rawV}.length === 1 && _ctx.build._parsemanCstCollapse(${JSON.stringify(def.type)}, ${chV}[0], ${chV}, ${rawV}) ? ${chV}[0] : (${ndExpr})` : ndExpr;
   const unwrapExpr = `${chV}.length === 1 ? (${chV}[0] !== null && typeof ${chV}[0] === 'object' && ${chV}[0]._tag === 'leaf' ? ${chV}[0].value : ${chV}[0]) : (${ndExpr})`;
@@ -8744,7 +8907,7 @@ ${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [],
     `${i}const ${ndV} = (${profileRecognizer} || ${profileCapture}) ? undefined : (${finalExpr})`,
     `${i}if (!(${profileRecognizer})) {`,
     `${i}  if (${sc}) ${sc}.push(${ndV})`,
-    `${i}  if (${sr}) ${sr}.push((typeof ${ndV} === 'object' && ${ndV} !== null && (${ndV}._tag === 'node' || ${ndV}._tag === 'leaf' || ${ndV}._tag === 'parseError')) ? ${ndV} : { _tag: 'leaf', value: typeof ${ndV} === 'string' ? ${ndV} : (typeof ${ndV} === 'object' && ${ndV} !== null ? input.slice(${pos}, ${endVar}) : ''), span: { start: ${pos}, end: ${endVar} } })`,
+    `${i}  if (${sr}) ${sr}.push((typeof ${ndV} === 'object' && ${ndV} !== null && (${ndV}._tag === 'node' || ${ndV}._tag === 'leaf' || ${ndV}._tag === 'parseError')) ? ${ndV} : { _tag: 'leaf', value: typeof ${ndV} === 'string' ? ${ndV} : (typeof ${ndV} === 'object' && ${ndV} !== null ? input.slice(${pos}, ${endVar}) : ''), span: ${nodeSpanV} })`,
     `${i}}`
   );
   return { stmts, valueVar: ndV, endVar };
@@ -8760,7 +8923,8 @@ function emitRuntimeFallback(parser2, ctx, pos) {
     `${ind(ctx)}const ${rv} = _rp[${idx}].parse(input, ${pos}, _ctx)`,
     ...emitIfFail(ctx, `!${rv}.ok`, failStmt),
     `${ind(ctx)}const ${vv} = ${rv}.value`,
-    `${ind(ctx)}const ${ev} = ${rv}.span.end`
+    `${ind(ctx)}const ${ev} = ${rv}.span.end`,
+    ...parser2._meta.canMatchNewline ? emitLineTrack(ctx, pos, ev) : []
   ];
   return { stmts, valueVar: vv, endVar: ev };
 }
@@ -8826,7 +8990,8 @@ function emitRecover(def, ctx, pos) {
     `${ind0}    if (${sentOk}) break`,
     `${ind0}    ${scanV}++`,
     `${ind0}  }`,
-    `${ind0}  const ${errV} = { _tag: 'parseError', span: { start: ${pos}, end: ${scanV} }, expected: ${JSON.stringify(deriveExpected(def.parser))} }`,
+    ...emitLineTrack(ctx, pos, scanV).map((s) => `${ind0}  ${s.trim()}`),
+    `${ind0}  const ${errV} = { _tag: 'parseError', span: ${emitSpanExpr(ctx, pos, scanV)}, expected: ${JSON.stringify(deriveExpected(def.parser))} }`,
     `${ind0}  if (_ctx._errors) _ctx._errors.push(${errV})`,
     `${ind0}  ${valVar} = ${errV}`,
     `${ind0}  ${endVar} = ${scanV}`,
@@ -8842,7 +9007,7 @@ function emitExpect(def, ctx, pos) {
   const stmts = [
     ...innerStmts,
     `${ind0}if (!${okVar}) {`,
-    `${ind0}  const ${errV} = { _tag: 'parseError', span: { start: ${pos}, end: ${pos} }, expected: ${JSON.stringify(def.expected)} }`,
+    `${ind0}  const ${errV} = { _tag: 'parseError', span: ${emitSpanExpr(ctx, pos, pos)}, expected: ${JSON.stringify(def.expected)} }`,
     `${ind0}  if (_ctx._errors) _ctx._errors.push(${errV})`,
     // Embed the missing-token error as a `parseError` CST child, mirroring the
     // interpreter (expect.ts) and the list-recovery emit sites — guarded on
@@ -8932,7 +9097,7 @@ function emitDispatch(p, ctx, pos) {
     case "literal":
       return emitLit(def, ctx, pos);
     case "regex":
-      return emitRegex(def, ctx, pos);
+      return emitRegex(def, ctx, pos, p._meta.canMatchNewline);
     case "keywords":
       return emitKeywords(def, ctx, pos);
     case "sequence":
@@ -9182,6 +9347,20 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
   }
 }
+function hasLineTrackingDef(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  if (d.tag === "grammar" && d.trackLines) return true;
+  if (d.tag === "lazy") {
+    try {
+      return hasLineTrackingDef(d.thunk(), seen);
+    } catch {
+      return false;
+    }
+  }
+  return childrenOf2(d).some((child) => hasLineTrackingDef(child, seen));
+}
 function parserUsesRouted2(p, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(p)) return false;
   seen.add(p);
@@ -9549,6 +9728,7 @@ function compile(combinator, mapFnSources, opts) {
     capturing: hasNodeDef(combinator),
     recovery: opts?.recovery ?? false,
     hostMode: opts?.hostMode ?? grammarHostMode ?? "ast",
+    lineTracking: opts?.trackLines === true || hasLineTrackingDef(combinator),
     ...opts?.coverage ? { coverage: { plan: buildGrammarPlan(combinator), entry: combinator } } : {},
     lazyUsage: analyzeLazyUsage(combinator),
     ...grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {},
@@ -9572,9 +9752,13 @@ function compile(combinator, mapFnSources, opts) {
   const namedPrelude = ctx.namedFnDecls.length > 0 ? [...namedFnPrelude(), ""] : [];
   const emptyTlDecls = ctx.needsEmptyTl ? ["const _EMPTY_TL = Object.freeze([])"] : [];
   const hostReadsDecls = ctx.needsHostReads ? [HOST_READS_DECL] : [];
+  const lineTrackDecls = ctx.needsLineTrack ? [LINE_TRACK_DECL] : [];
+  const lineSpanDecls = ctx.needsLineSpan ? [LINE_SPAN_DECL] : [];
   const source = [
     ...emptyTlDecls,
     ...hostReadsDecls,
+    ...lineTrackDecls,
+    ...lineSpanDecls,
     ...ctx.regexDecls,
     ...ctx.expectedDecls,
     "",
@@ -9587,6 +9771,8 @@ function compile(combinator, mapFnSources, opts) {
   const fn = new Function("input", "_pos", "_rp", "_mf", "_build", "_ctx", [
     ...emptyTlDecls,
     ...hostReadsDecls,
+    ...lineTrackDecls,
+    ...lineSpanDecls,
     ...ctx.regexDecls,
     ...ctx.expectedDecls,
     ...namedPrelude,
@@ -9605,6 +9791,25 @@ function compile(combinator, mapFnSources, opts) {
     trackLines: false,
     ...ctx.triviaKindLabels ? { triviaKindLabels: ctx.triviaKindLabels } : {}
   };
+  const annotateWithTrackedLines = (result, lineStarts) => {
+    const index = normalizeLineIndex({ lineStarts });
+    const annotated = { ...result, span: annotateSpan(result.span, index) };
+    const errors = annotated.errors;
+    if (errors) {
+      ;
+      annotated.errors = errors.map((error) => ({
+        ...error,
+        span: annotateSpan(error.span, index)
+      }));
+    }
+    return annotated;
+  };
+  const trackedCtx = (base, input, pos) => {
+    if (!ctx.lineTracking) return base;
+    const lineIndex = { lineStarts: [0] };
+    if (pos > 0) recordLineRange(lineIndex, input, 0, pos);
+    return { ...base, trackLines: true, _lineStarts: lineIndex.lineStarts, _lineScannedTo: pos };
+  };
   const derivedSrcs = ctx.mapFnSrcs.length === ctx.mapFns.length && ctx.mapFnSrcs.every((s) => s !== null) ? ctx.mapFnSrcs : void 0;
   const effectiveSources = mapFnSources ?? derivedSrcs;
   const buildCovered = ctx.buildFns.length === 0 || ctx.buildSrcs.every((s) => s !== null);
@@ -9612,17 +9817,46 @@ function compile(combinator, mapFnSources, opts) {
   const mfCovered = ctx.mapFns.length === 0 || effectiveSources !== void 0 && effectiveSources.length === ctx.mapFns.length;
   const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered;
   const inlineExpression = canInline ? buildInlineExpression(ctx, r, effectiveSources, buildSources, coverageRootRuleId) : null;
-  return {
+  const compiledMeta = {
     source,
     inlineExpression,
     ...ctx.coverage === void 0 ? {} : { coverageDefinitions: ctx.coverage.plan.definitions },
-    ...gatingReport === void 0 ? {} : { gating: gatingReport },
+    ...gatingReport === void 0 ? {} : { gating: gatingReport }
+  };
+  if (!ctx.lineTracking) {
+    return {
+      ...compiledMeta,
+      parse(input, pos = 0) {
+        return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, defaultCtx);
+      },
+      parseWithContext(input, parseCtx, pos = 0) {
+        assertHostModeCompatible(ctx.hostMode ?? "ast", parseCtx.build, !!ctx.hostBranchElided);
+        return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, parseCtx);
+      },
+      // Note: collects expect() errors via _errors. Unlike interpreter
+      // parse({recover:true}) it does NOT populate furthestFail — the compiled path
+      // inlines failures for throughput and deliberately skips _probe bookkeeping.
+      // Callers wanting a furthest-position diagnostic detect unconsumed input
+      // (span.end < input.length) instead, which is mode-agnostic.
+      parseWithErrors(input, pos = 0) {
+        const errors = [];
+        const result = fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, { ...defaultCtx, _errors: errors });
+        return { ...result, errors };
+      }
+    };
+  }
+  return {
+    ...compiledMeta,
     parse(input, pos = 0) {
-      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, defaultCtx);
+      const parseCtx = trackedCtx(defaultCtx, input, pos);
+      const result = fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, parseCtx);
+      return annotateWithTrackedLines(result, parseCtx._lineStarts);
     },
     parseWithContext(input, parseCtx, pos = 0) {
       assertHostModeCompatible(ctx.hostMode ?? "ast", parseCtx.build, !!ctx.hostBranchElided);
-      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, parseCtx);
+      const activeCtx = trackedCtx(parseCtx, input, pos);
+      const result = fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, activeCtx);
+      return activeCtx.trackLines ? annotateWithTrackedLines(result, activeCtx._lineStarts) : result;
     },
     // Note: collects expect() errors via _errors. Unlike interpreter
     // parse({recover:true}) it does NOT populate furthestFail — the compiled path
@@ -9631,8 +9865,9 @@ function compile(combinator, mapFnSources, opts) {
     // (span.end < input.length) instead, which is mode-agnostic.
     parseWithErrors(input, pos = 0) {
       const errors = [];
-      const result = fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, { ...defaultCtx, _errors: errors });
-      return { ...result, errors };
+      const parseCtx = trackedCtx({ ...defaultCtx, _errors: errors }, input, pos);
+      const result = { ...fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, parseCtx), errors };
+      return annotateWithTrackedLines(result, parseCtx._lineStarts);
     }
   };
 }
@@ -9716,6 +9951,8 @@ function compileRuleMap(ruleMap, opts) {
   const hoistedDecls = [
     ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : "",
     ctx.needsHostReads ? `  ${HOST_READS_DECL}` : "",
+    ctx.needsLineTrack ? `  ${LINE_TRACK_DECL}` : "",
+    ctx.needsLineSpan ? `  ${LINE_SPAN_DECL}` : "",
     ...ctx.regexDecls.map((d) => `  ${d}`),
     ...ctx.expectedDecls.map((d) => `  ${d}`),
     mfDecl,
@@ -10045,12 +10282,16 @@ function buildInlineExpression(ctx, r, mapFnSources, buildSources, coverageRootR
   const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(", ")}]` : "";
   const emptyTlDecl = ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : "";
   const hostReadsDecl = ctx.needsHostReads ? `  ${HOST_READS_DECL}` : "";
-  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl || !!hostReadsDecl;
+  const lineTrackDecl = ctx.needsLineTrack ? `  ${LINE_TRACK_DECL}` : "";
+  const lineSpanDecl = ctx.needsLineSpan ? `  ${LINE_SPAN_DECL}` : "";
+  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl || !!hostReadsDecl || !!lineTrackDecl || !!lineSpanDecl;
   if (!needsWrapper) return innerFn;
   const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : [];
   const hoistedDecls = [
     emptyTlDecl,
     hostReadsDecl,
+    lineTrackDecl,
+    lineSpanDecl,
     ...ctx.regexDecls.map((d) => `  ${d}`),
     ...ctx.expectedDecls.map((d) => `  ${d}`),
     mfDecl,
@@ -10589,7 +10830,7 @@ function normalizeCstCollapse(collapse) {
   return typeof collapse === "function" ? collapse : void 0;
 }
 function buildCstNode(type, children2, _fields, span, _rawChildren, _triviaLog, state) {
-  return { _tag: "node", type, span: { start: span.start, end: span.end }, state: state ?? null, children: [...children2] };
+  return { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children2] };
 }
 function cstBuildHost(typeOrOptions, children2, _fields, span, rawChildren, triviaLog, state) {
   if (typeof typeOrOptions === "string") {