parseman 0.41.0 → 0.42.1

package/dist/index.cjs

@@ -33,6 +33,7 @@ __export(index_exports, {
   analyzeGatingRules: () => analyzeGatingRules,
   analyzeGrammarGating: () => analyzeGrammarGating,
   annotateSpan: () => annotateSpan,
+  annotateTreeSpans: () => annotateTreeSpans,
   applyEdit: () => applyEdit,
   attempt: () => attempt,
   balanced: () => balanced,
@@ -54,6 +55,7 @@ __export(index_exports, {
   createGrammarCoverageCollector: () => createGrammarCoverageCollector,
   createGrammarInstrumentationContext: () => createGrammarInstrumentationContext,
   createGrammarTraceSink: () => createGrammarTraceSink,
+  createLineIndex: () => createLineIndex,
   createVisitor: () => createVisitor,
   cstBuildHost: () => cstBuildHost,
   dispatch: () => dispatch,
@@ -87,6 +89,7 @@ __export(index_exports, {
   matches: () => matches,
   noTrivia: () => noTrivia,
   node: () => node,
+  normalizeLineIndex: () => normalizeLineIndex,
   not: () => not,
   offsetToLineCol: () => offsetToLineCol,
   oneOrMore: () => oneOrMore,
@@ -97,6 +100,7 @@ __export(index_exports, {
   parseDoc: () => parseDoc,
   parser: () => parser,
   peek: () => peek,
+  recordLineRange: () => recordLineRange,
   ref: () => ref,
   regex: () => regex,
   relativize: () => relativize,
@@ -363,6 +367,87 @@ function failAt(ctx, expected, pos) {
   return r;
 }
 
+// src/line-index.ts
+function createLineIndex() {
+  return { lineStarts: [0] };
+}
+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 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;
+}
+function isSpan(value) {
+  return !!value && typeof value === "object" && typeof value.start === "number" && typeof value.end === "number";
+}
+function annotateTreeSpans(value, index, seen = /* @__PURE__ */ new WeakSet()) {
+  if (!value || typeof value !== "object") return value;
+  if (seen.has(value)) return value;
+  seen.add(value);
+  const obj = value;
+  if (isSpan(obj.span)) obj.span = annotateSpan(obj.span, index);
+  for (const key of Object.keys(obj)) {
+    const child = obj[key];
+    if (child && typeof child === "object") annotateTreeSpans(child, index, seen);
+  }
+  return value;
+}
+
 // src/cst/capture-buffer.ts
 var EMPTY = [];
 var EMPTY_TL = [];
@@ -404,7 +489,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;
@@ -538,6 +628,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();
@@ -554,6 +645,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 };
       }
@@ -567,6 +659,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 };
     }
@@ -734,6 +827,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 };
       }
@@ -743,6 +837,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 };
     }
@@ -881,8 +976,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));
   };
@@ -978,7 +1073,7 @@ function firstSet(n) {
     }
   }
 }
-function firstCanBeNewline(n) {
+function canConsumeNewline(n) {
   switch (n.t) {
     case "char":
       return n.nl;
@@ -987,16 +1082,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) {
@@ -1006,8 +1096,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
@@ -1169,7 +1259,9 @@ function firstSetSentinel(fs) {
 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 };
 }
@@ -1272,7 +1364,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 } };
@@ -1720,6 +1813,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 };
 }
@@ -1742,13 +1847,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) {
@@ -1756,18 +1877,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 {
@@ -1778,7 +1927,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) {
@@ -2749,6 +2898,101 @@ function markUnusedValues(root) {
   visit(resolveRoot(root), true);
 }
 
+// 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 annotated;
+}
+function createParseLineContext(input, pos) {
+  const lineIndex = createLineIndex();
+  if (pos > 0) recordLineRange(lineIndex, input, 0, pos);
+  return { lineIndex, lineScannedTo: pos };
+}
+function parser(opts, root) {
+  const clearTrivia = opts.trivia === null;
+  return {
+    _tag: "grammar",
+    _meta: root._meta,
+    _def: {
+      tag: "grammar",
+      parser: root,
+      triviaParser: clearTrivia ? void 0 : opts.trivia ?? void 0,
+      clearTrivia,
+      ...opts.captureTrivia ? { captureTrivia: true } : {},
+      trackLines: opts.trackLines ?? false
+    },
+    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,
+          triviaKindLabels: void 0
+        } : opts.trivia != null ? {
+          trivia: opts.trivia,
+          ...opts.trivia._meta.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {}
+        } : {},
+        ...opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {},
+        // Kind-filter for per-node capture. Resolve against this scope's trivia
+        // labels — this parser's own trivia if it declares one, else the INHERITED
+        // labels (`_ctx.triviaKindLabels`), so captureTriviaKinds still applies when
+        // trivia is inherited rather than re-declared here. No labels → undefined
+        // (capture all).
+        ...opts.captureTriviaKinds && !clearTrivia ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) } : {}
+      };
+      const result = root.parse(input, pos ?? 0, ctx);
+      if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
+        _ctx._lineScannedTo = Math.max(_ctx._lineScannedTo ?? 0, ctx._lineScannedTo);
+      }
+      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+    }
+  };
+}
+function noTrivia(root) {
+  return parser({ trivia: null }, root);
+}
+var _analyzed = /* @__PURE__ */ new WeakSet();
+function parse(combinator, input, opts = {}) {
+  if (!_analyzed.has(combinator)) {
+    _analyzed.add(combinator);
+    markUnusedValues(combinator);
+  }
+  const trackLines = opts.trackLines ?? combinator._meta.grammarTrackLines ?? false;
+  const lineContext = trackLines ? createParseLineContext(input, 0) : void 0;
+  const lineIndex = lineContext?.lineIndex;
+  const _errors = opts.recover ? [] : void 0;
+  const _probe = opts.recover ? { offset: input.length, best: null } : void 0;
+  const grammarTrivia = combinator._meta.grammarTrivia;
+  const grammarScanSkip = combinator._meta.grammarScanSkip;
+  const ctx = {
+    trackLines,
+    ...lineIndex ? { _lineIndex: lineIndex } : {},
+    ...lineContext ? { _lineScannedTo: lineContext.lineScannedTo } : {},
+    ...grammarTrivia !== void 0 ? { trivia: grammarTrivia, ...grammarTrivia._meta.triviaKindLabels ? { triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {} } : {},
+    ...grammarScanSkip !== void 0 ? { scanSkip: grammarScanSkip } : {},
+    ..._errors !== void 0 ? { _errors } : {},
+    ..._probe !== void 0 ? { _probe } : {}
+  };
+  const result = combinator.parse(input, 0, ctx);
+  if (!result.ok) return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+  const withErrors = _errors !== void 0 ? { ...result, errors: _errors, furthestFail: _probe?.best ?? null } : result;
+  return lineIndex ? annotateResultLines(withErrors, normalizeLineIndex(lineIndex)) : withErrors;
+}
+
 // src/combinators/parser.ts
 var RULE_ORDER = "__parsemanRuleOrder";
 function tagRule(r, key) {
@@ -2824,6 +3068,21 @@ function rules(a, b) {
       if (rule && !rule._meta.isTrivia) rule._meta.grammarHostMode = "cst";
     }
   }
+  if (options?.trackLines === true) {
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia) rule._meta.grammarTrackLines = true;
+    }
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia && rule._def.tag !== "grammar") {
+        const wrapped = parser({ trackLines: true }, rule);
+        tagRule(wrapped, key);
+        wrapped._meta.grammarTrackLines = true;
+        cache[key] = wrapped;
+      }
+    }
+  }
   for (const key of Object.keys(definitions)) {
     markUnusedValues(cache[key]);
   }
@@ -3202,13 +3461,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 };
     }
   };
 }
@@ -3279,112 +3539,6 @@ 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;
-  }
-  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
-  };
-}
-
-// src/combinators/grammar.ts
-function parser(opts, root) {
-  const clearTrivia = opts.trivia === null;
-  return {
-    _tag: "grammar",
-    _meta: root._meta,
-    _def: {
-      tag: "grammar",
-      parser: root,
-      triviaParser: clearTrivia ? void 0 : opts.trivia ?? void 0,
-      clearTrivia,
-      ...opts.captureTrivia ? { captureTrivia: true } : {},
-      trackLines: opts.trackLines ?? false
-    },
-    parse(input, pos, _ctx) {
-      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false;
-      const ctx = {
-        ..._ctx,
-        trackLines,
-        // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.
-        ...clearTrivia ? {
-          trivia: void 0,
-          triviaKindLabels: void 0
-        } : opts.trivia != null ? {
-          trivia: opts.trivia,
-          ...opts.trivia._meta.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {}
-        } : {},
-        ...opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {},
-        // Kind-filter for per-node capture. Resolve against this scope's trivia
-        // labels — this parser's own trivia if it declares one, else the INHERITED
-        // labels (`_ctx.triviaKindLabels`), so captureTriviaKinds still applies when
-        // trivia is inherited rather than re-declared here. No labels → undefined
-        // (capture all).
-        ...opts.captureTriviaKinds && !clearTrivia ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) } : {}
-      };
-      const result = root.parse(input, pos ?? 0, ctx);
-      if (trackLines) {
-        const idx = buildLineIndex(input);
-        return { ...result, span: annotateSpan(result.span, idx) };
-      }
-      return result;
-    }
-  };
-}
-function noTrivia(root) {
-  return parser({ trivia: null }, root);
-}
-var _analyzed = /* @__PURE__ */ new WeakSet();
-function parse(combinator, input, opts = {}) {
-  if (!_analyzed.has(combinator)) {
-    _analyzed.add(combinator);
-    markUnusedValues(combinator);
-  }
-  const trackLines = opts.trackLines ?? false;
-  const _errors = opts.recover ? [] : void 0;
-  const _probe = opts.recover ? { offset: input.length, best: null } : void 0;
-  const grammarTrivia = combinator._meta.grammarTrivia;
-  const grammarScanSkip = combinator._meta.grammarScanSkip;
-  const ctx = {
-    trackLines,
-    ...grammarTrivia !== void 0 ? { trivia: grammarTrivia, ...grammarTrivia._meta.triviaKindLabels ? { triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {} } : {},
-    ...grammarScanSkip !== void 0 ? { scanSkip: grammarScanSkip } : {},
-    ..._errors !== void 0 ? { _errors } : {},
-    ..._probe !== void 0 ? { _probe } : {}
-  };
-  const result = combinator.parse(input, 0, ctx);
-  if (!result.ok) return result;
-  const withErrors = _errors !== void 0 ? { ...result, errors: _errors, furthestFail: _probe?.best ?? null } : result;
-  if (trackLines) {
-    const idx = buildLineIndex(input);
-    return { ...withErrors, span: annotateSpan(withErrors.span, idx) };
-  }
-  return withErrors;
-}
-
 // src/combinators/token.ts
 function token(root) {
   const meta = {
@@ -3481,7 +3635,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.41.0";
+var PARSEMAN_VERSION = "0.42.1";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -5165,7 +5319,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 } : {}
       };
@@ -5178,6 +5332,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 } };
         }
@@ -5193,6 +5348,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 } };
       }
@@ -6631,8 +6787,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
@@ -6814,6 +6970,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 v(ctx, prefix = "_v") {
   return `${prefix}${ctx.vars++}`;
@@ -6837,13 +6995,16 @@ function reindentStmts(stmts, targetLevels) {
   const targetPrefix = "  ".repeat(targetLevels);
   return stmts.map((s) => s.trim().length === 0 ? "" : targetPrefix + s.slice(minLeading));
 }
-function failReturn(expected, posExpr) {
+function failReturn(ctx, expected, posExpr) {
+  if (ctx.lineTracking) return `return { ok: false, expected: [${expected}], span: ${emitSpanExpr(ctx, posExpr, posExpr)} }`;
   return `return { ok: false, expected: [${expected}], span: { start: ${posExpr}, end: ${posExpr} } }`;
 }
-function failReturnArr(expectedArr, posExpr) {
+function failReturnArr(ctx, expectedArr, posExpr) {
+  if (ctx.lineTracking) return `return { ok: false, expected: ${expectedArr}, span: ${emitSpanExpr(ctx, posExpr, posExpr)} }`;
   return `return { ok: false, expected: ${expectedArr}, span: { start: ${posExpr}, end: ${posExpr} } }`;
 }
-function committedReturnArr(expectedArr, posExpr) {
+function committedReturnArr(ctx, expectedArr, posExpr) {
+  if (ctx.lineTracking) return `return { ok: false, expected: [...${expectedArr}], span: ${emitSpanExpr(ctx, posExpr, posExpr)}, committed: true }`;
   return `return { ok: false, expected: [...${expectedArr}], span: { start: ${posExpr}, end: ${posExpr} }, committed: true }`;
 }
 function hoistExpected(ctx, constArrSource) {
@@ -6868,7 +7029,7 @@ function failBody(ctx, expected, posExpr) {
     if (!ctx.recordFail) return probe ? `{ ${probe}${trace}break ${ctx.failLabel} }` : trace ? `{ ${trace}break ${ctx.failLabel} }` : `break ${ctx.failLabel}`;
     return `{ ${probe}_ctx._fe = ${posExpr}; _ctx._fx = ${hoistExpected(ctx, `[${expected}]`)}; ${trace}break ${ctx.failLabel} }`;
   }
-  return probe + trace + failReturn(expected, posExpr);
+  return probe + trace + failReturn(ctx, expected, posExpr);
 }
 function failArrBody(ctx, expectedArr, posExpr, constant = true) {
   const probe = probeUpdate(ctx, expectedArr, posExpr, constant);
@@ -6878,18 +7039,19 @@ function failArrBody(ctx, expectedArr, posExpr, constant = true) {
     const fx = constant ? hoistExpected(ctx, expectedArr) : expectedArr;
     return `{ ${probe}_ctx._fe = ${posExpr}; _ctx._fx = ${fx}; ${trace}break ${ctx.failLabel} }`;
   }
-  if (!constant) return `${probe}${trace}return { ok: false, expected: [...${expectedArr}], span: { start: ${posExpr}, end: ${posExpr} } }`;
-  return probe + trace + failReturnArr(expectedArr, posExpr);
+  if (!constant) return `${probe}${trace}return { ok: false, expected: [...${expectedArr}], span: ${ctx.lineTracking ? emitSpanExpr(ctx, posExpr, posExpr) : `{ start: ${posExpr}, end: ${posExpr} }`} }`;
+  return probe + trace + failReturnArr(ctx, expectedArr, posExpr);
 }
-function resultFromRecorded(feExpr = "_ctx._fe", fxExpr = "_ctx._fx") {
-  return `return { ok: false, expected: [...${fxExpr}], span: { start: ${feExpr}, end: ${feExpr} }, ...(_ctx._fc ? { committed: true } : {}) }`;
+function resultFromRecorded(ctx, feExpr = "_ctx._fe", fxExpr = "_ctx._fx") {
+  const spanExpr = ctx.lineTracking ? emitSpanExpr(ctx, feExpr, feExpr) : `{ start: ${feExpr}, end: ${feExpr} }`;
+  return `return { ok: false, expected: [...${fxExpr}], span: ${spanExpr}, ...(_ctx._fc ? { committed: true } : {}) }`;
 }
 function committedFailBody(ctx, expectedArr = "_ctx._fx", posExpr = "_ctx._fe") {
   if (ctx.failLabel) {
     if (!ctx.recordFail) return `{ _ctx._fc = true; break ${ctx.failLabel} }`;
     return `{ _ctx._fc = true; _ctx._fe = ${posExpr}; _ctx._fx = ${expectedArr}; break ${ctx.failLabel} }`;
   }
-  return committedReturnArr(expectedArr, posExpr);
+  return committedReturnArr(ctx, expectedArr, posExpr);
 }
 function propagateFailBody(ctx, srcCtx = "_ctx") {
   if (srcCtx !== "_ctx") {
@@ -6897,10 +7059,10 @@ function propagateFailBody(ctx, srcCtx = "_ctx") {
       if (!ctx.recordFail) return `break ${ctx.failLabel}`;
       return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; _ctx._fc = ${srcCtx}._fc; break ${ctx.failLabel} }`;
     }
-    return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; _ctx._fc = ${srcCtx}._fc; ${resultFromRecorded()} }`;
+    return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; _ctx._fc = ${srcCtx}._fc; ${resultFromRecorded(ctx)} }`;
   }
   if (ctx.failLabel) return `break ${ctx.failLabel}`;
-  return resultFromRecorded();
+  return resultFromRecorded(ctx);
 }
 function emitIfFail(ctx, cond, body) {
   return [
@@ -6954,14 +7116,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}`;
@@ -7346,6 +7540,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 };
 }
@@ -7425,7 +7620,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) {
@@ -7438,7 +7633,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 };
     }
   }
@@ -7460,6 +7659,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 };
 }
@@ -7497,7 +7697,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);
@@ -7515,7 +7716,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);
@@ -8215,14 +8417,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;
     }
   }
@@ -8292,7 +8495,7 @@ function emitAttempt(p, def, ctx, pos) {
   if (!ctx.recovery && !ctx.coverage && needsFirstSetGuard(def.parser)) {
     const gcV = v(ctx, "_agc");
     const gExp = armStaticExpected(ctx, def.parser);
-    const gFail = ctx.failLabel ? `{ _ctx._fe = ${pos};${ctx.recordFail ? ` _ctx._fx = ${gExp};` : ""} break ${ctx.failLabel} }` : `{ _ctx._fe = ${pos}; ${failReturnArr(gExp, pos)} }`;
+    const gFail = ctx.failLabel ? `{ _ctx._fe = ${pos};${ctx.recordFail ? ` _ctx._fx = ${gExp};` : ""} break ${ctx.failLabel} }` : `{ _ctx._fe = ${pos}; ${failReturnArr(ctx, gExp, pos)} }`;
     preGuard.push(
       `${ind(ctx)}const ${gcV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,
       `${ind(ctx)}if (!(${firstSetCond(gcV, def.parser._meta.firstSet)})) ${gFail}`
@@ -8399,7 +8602,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}; `;
@@ -8409,7 +8613,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(
@@ -8421,13 +8625,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 sep = emitFallible(def.separator, ctx, sepAtPos, true);
       const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep;
       stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${sep.mayCommit ? `if (_ctx._fc) ${committedFailBody(ctx)}; ` : ""}break }`);
       const 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(
@@ -8514,6 +8718,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)}}`);
@@ -8657,7 +8862,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;
@@ -8789,7 +8994,7 @@ ${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [],
   if (!ctx.recovery && !ctx.coverage && (capturesChildren || structural) && needsFirstSetGuard(def.parser)) {
     const gcV = v(ctx, "_ngc");
     const gExp = armStaticExpected(ctx, def.parser);
-    const gFail = ctx.failLabel ? ctx.recordFail ? `{ _ctx._fe = ${pos}; _ctx._fx = ${gExp}; break ${ctx.failLabel} }` : `break ${ctx.failLabel}` : failReturnArr(gExp, pos);
+    const gFail = ctx.failLabel ? ctx.recordFail ? `{ _ctx._fe = ${pos}; _ctx._fx = ${gExp}; break ${ctx.failLabel} }` : `break ${ctx.failLabel}` : failReturnArr(ctx, gExp, pos);
     preGuard.push(
       `${i}const ${gcV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,
       `${i}if (!(${firstSetCond(gcV, def.parser._meta.firstSet)})) ${gFail}`
@@ -8807,7 +9012,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`);
@@ -8847,8 +9052,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})`;
@@ -8858,7 +9066,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 };
@@ -8874,7 +9082,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 };
 }
@@ -8940,7 +9149,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}`,
@@ -8956,7 +9166,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
@@ -9046,7 +9256,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":
@@ -9296,6 +9506,21 @@ 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 (p._meta.grammarTrackLines) return true;
+  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);
@@ -9643,6 +9868,7 @@ function compile(combinator, mapFnSources, opts) {
   const grammarTrivia = combinator._meta.grammarTrivia;
   const grammarScanSkip = combinator._meta.grammarScanSkip;
   const grammarHostMode = combinator._meta.grammarHostMode;
+  const grammarTrackLines = combinator._meta.grammarTrackLines;
   const ctx = {
     vars: 0,
     indent: 1,
@@ -9663,6 +9889,7 @@ function compile(combinator, mapFnSources, opts) {
     capturing: hasNodeDef(combinator),
     recovery: opts?.recovery ?? false,
     hostMode: opts?.hostMode ?? grammarHostMode ?? "ast",
+    lineTracking: opts?.trackLines === true || grammarTrackLines === true || hasLineTrackingDef(combinator),
     ...opts?.coverage ? { coverage: { plan: buildGrammarPlan(combinator), entry: combinator } } : {},
     lazyUsage: analyzeLazyUsage(combinator),
     ...grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {},
@@ -9686,9 +9913,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,
     "",
@@ -9701,6 +9932,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,
@@ -9719,6 +9952,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);
@@ -9726,17 +9978,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
@@ -9745,8 +10026,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);
     }
   };
 }
@@ -9771,6 +10053,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
   const grammarTrivia = opts?.trivia ?? ruleMapArg.map(([, r]) => r._meta.grammarTrivia).find(Boolean);
   const grammarScanSkip = opts?.scanSkip ?? ruleMapArg.map(([, r]) => r._meta.grammarScanSkip).find(Boolean);
   const grammarHostMode = opts?.hostMode ?? ruleMapArg.map(([, r]) => r._meta.grammarHostMode).find(Boolean);
+  const grammarTrackLines = opts?.trackLines === true || ruleMapArg.some(([, r]) => r._meta.grammarTrackLines === true);
   const ruleMap = ruleMapArg.filter(([, val]) => {
     const d = val._def;
     if (d.tag !== "lazy") return true;
@@ -9805,6 +10088,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
     capturing: opts?.captureTerminals === true || ruleMap.some(([, rule]) => hasNodeDef(rule)),
     recovery: opts?.recovery ?? false,
     hostMode: grammarHostMode ?? "ast",
+    lineTracking: grammarTrackLines,
     ...opts?.coverage ? { coverage: { plan: opts.coverage } } : {},
     lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),
     ns,
@@ -9901,6 +10185,10 @@ function compileLinkable(ruleMapArg, ns, opts) {
     perEntry.push({ key, rule, r: emitNamedFnCall(ctx, fn, "_pos") });
   }
   if (ctx.runtimeParsers.length !== 0) return null;
+  if (ctx.lineTracking) {
+    ctx.needsLineTrack = true;
+    ctx.needsLineSpan = true;
+  }
   const mfSrcs = ctx.mapFns.length > 0 && ctx.mapFnSrcs.every((s) => s !== null) ? ctx.mapFnSrcs : null;
   const buildSrcs = ctx.buildFns.length > 0 && ctx.buildSrcs.every((s) => s !== null) ? ctx.buildSrcs : null;
   const ruleFns = /* @__PURE__ */ new Map();
@@ -9914,6 +10202,8 @@ function compileLinkable(ruleMapArg, ns, opts) {
   const mfDecl = ctx.mapFns.length === 0 ? "" : mfSrcs ? `const ${mfRef(ctx)} = [${mfSrcs.join(", ")}]` : `const ${mfRef(ctx)} = _env[${JSON.stringify(nsp(ctx) + "mf")}]`;
   const buildDecl = ctx.buildFns.length === 0 ? "" : buildSrcs ? `const ${buildRef(ctx)} = [${buildSrcs.join(", ")}]` : `const ${buildRef(ctx)} = _env[${JSON.stringify(nsp(ctx) + "build")}]`;
   const prelude = [
+    ctx.needsLineTrack ? LINE_TRACK_DECL : "",
+    ctx.needsLineSpan ? LINE_SPAN_DECL : "",
     ...ctx.regexDecls,
     ...ctx.expectedDecls,
     mfDecl,
@@ -9922,11 +10212,18 @@ function compileLinkable(ruleMapArg, ns, opts) {
   ].filter(Boolean);
   const wrappers = /* @__PURE__ */ new Map();
   for (const { key, rule, r } of perEntry) {
+    const linePreamble = ctx.lineTracking ? [
+      `  if (_ctx._lineStarts === undefined) _ctx = { ..._ctx, trackLines: true, _lineStarts: [0], _lineScannedTo: 0 }`,
+      `  else _ctx.trackLines = true`,
+      `  if (_pos > (_ctx._lineScannedTo ?? 0)) _trackLines(_ctx, input, 0, _pos)`
+    ] : [];
+    const resultSpan = ctx.lineTracking ? `_spanLines(_ctx, _pos, ${r.endVar})` : `{ start: _pos, end: ${r.endVar} }`;
     wrappers.set(key, publicRuleWrapperSource(rule, [
       `function(input, _pos, _ctx) {`,
+      ...linePreamble,
       `  let pos = _pos`,
       ...r.stmts,
-      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+      `  return { ok: true, value: ${r.valueVar}, span: ${resultSpan} }`,
       `}`
     ].join("\n"), ctx.triviaKindLabels));
   }
@@ -10033,12 +10330,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,
@@ -10587,7 +10888,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") {
@@ -10810,7 +11111,8 @@ function materializePiece(p, trivia2, captureTerminals = false, hostMode) {
   const pieces = compileLinkable(evalRuleMapIR(p.ir), p.ns, {
     ...trivia2 ? { trivia: trivia2 } : {},
     ...captureTerminals ? { captureTerminals: true } : {},
-    ...hostMode ? { hostMode } : {}
+    ...hostMode ? { hostMode } : {},
+    ...p.trackLines ? { trackLines: true } : {}
   });
   if (!pieces) throw new Error(`compose: carried IR for ns "${p.ns}" could not be re-lowered`);
   return pieces;