parseman 0.41.0 → 0.42.1

package/dist/plugin/index.js

@@ -282,6 +282,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 = [];
@@ -323,7 +382,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;
@@ -457,6 +521,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();
@@ -473,6 +538,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 };
       }
@@ -486,6 +552,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 };
     }
@@ -653,6 +720,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 };
       }
@@ -662,6 +730,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 };
     }
@@ -800,8 +869,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));
   };
@@ -897,7 +966,7 @@ function firstSet(n) {
     }
   }
 }
-function firstCanBeNewline(n) {
+function canConsumeNewline(n) {
   switch (n.t) {
     case "char":
       return n.nl;
@@ -906,16 +975,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) {
@@ -925,8 +989,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
@@ -1083,7 +1147,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 };
 }
@@ -1185,7 +1251,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 } };
@@ -1630,6 +1697,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 };
 }
@@ -1652,13 +1731,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) {
@@ -1666,18 +1761,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 {
@@ -1688,7 +1811,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) {
@@ -2619,6 +2742,74 @@ 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);
+}
+
 // src/combinators/parser.ts
 var RULE_ORDER = "__parsemanRuleOrder";
 function tagRule(r, key) {
@@ -2694,6 +2885,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]);
   }
@@ -3072,13 +3278,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 };
     }
   };
 }
@@ -3149,85 +3356,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);
-}
-
 // src/combinators/token.ts
 function token(root) {
   const meta = {
@@ -3324,7 +3452,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");
@@ -5008,7 +5136,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 } : {}
       };
@@ -5021,6 +5149,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 } };
         }
@@ -5036,6 +5165,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 } };
       }
@@ -6474,8 +6604,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
@@ -6657,6 +6787,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();
@@ -6688,13 +6820,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) {
@@ -6719,7 +6854,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);
@@ -6729,18 +6864,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") {
@@ -6748,10 +6884,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 [
@@ -6805,14 +6941,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}`;
@@ -7197,6 +7365,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 };
 }
@@ -7276,7 +7445,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) {
@@ -7289,7 +7458,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 };
     }
   }
@@ -7311,6 +7484,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 };
 }
@@ -7348,7 +7522,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);
@@ -7366,7 +7541,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);
@@ -8066,14 +8242,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;
     }
   }
@@ -8143,7 +8320,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}`
@@ -8250,7 +8427,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}; `;
@@ -8260,7 +8438,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(
@@ -8272,13 +8450,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(
@@ -8365,6 +8543,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)}}`);
@@ -8508,7 +8687,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;
@@ -8640,7 +8819,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}`
@@ -8658,7 +8837,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`);
@@ -8698,8 +8877,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})`;
@@ -8709,7 +8891,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 };
@@ -8725,7 +8907,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 };
 }
@@ -8791,7 +8974,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}`,
@@ -8807,7 +8991,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
@@ -8897,7 +9081,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":
@@ -9147,6 +9331,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);
@@ -9494,6 +9693,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,
@@ -9514,6 +9714,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 } : {},
@@ -9537,9 +9738,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,
     "",
@@ -9552,6 +9757,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,
@@ -9570,6 +9777,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);
@@ -9577,17 +9803,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
@@ -9596,8 +9851,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);
     }
   };
 }
@@ -9622,6 +9878,7 @@ function compileRuleMap(ruleMap, opts) {
   const grammarTrivia = opts?.trivia;
   const grammarScanSkip = opts?.scanSkip ?? ruleMap.map(([, r]) => r._meta.grammarScanSkip).find(Boolean);
   const grammarHostMode = opts?.hostMode ?? ruleMap.map(([, r]) => r._meta.grammarHostMode).find(Boolean);
+  const grammarTrackLines = opts?.trackLines === true || ruleMap.some(([, r]) => r._meta.grammarTrackLines === true);
   const ctx = {
     vars: 0,
     indent: 1,
@@ -9642,6 +9899,7 @@ function compileRuleMap(ruleMap, opts) {
     capturing: ruleMap.some(([, rule]) => hasNodeDef(rule)),
     recovery: opts?.recovery ?? false,
     hostMode: grammarHostMode ?? "ast",
+    lineTracking: grammarTrackLines,
     ...opts?.coverage ? { coverage: { plan: buildGrammarPlan(ruleMap.map(([, rule]) => rule), coverageWinners) } } : {},
     lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),
     ...grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {},
@@ -9675,12 +9933,18 @@ function compileRuleMap(ruleMap, opts) {
   const mfCovered = ctx.mapFns.length === 0 || derivedSrcs !== void 0;
   const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered;
   if (!canInline) return null;
+  if (ctx.lineTracking) {
+    ctx.needsLineTrack = true;
+    ctx.needsLineSpan = true;
+  }
   const mfDecl = derivedSrcs?.length ? `  const ${mfRef(ctx)} = [${derivedSrcs.join(", ")}]` : "";
   const buildDecl = buildSources?.length ? `  const ${buildRef(ctx)} = [${buildSources.join(", ")}]` : "";
   const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : [];
   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,
@@ -9702,15 +9966,23 @@ function compileRuleMap(ruleMap, opts) {
   };
   const entryFnText = (r, rule) => {
     const ruleId = entryRuleId(rule);
+    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} }`;
     const body = ruleId === void 0 ? [
+      ...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} }`
     ] : [
+      ...linePreamble,
       `  const _coverageResult = (() => {`,
       `    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} }`,
       `  })()`,
       `  if (!_coverageResult.ok) _ctx._grammarTrace?.write({ id: ${JSON.stringify(ruleId)}, phase: 'failure', offset: _coverageResult.span.start })`,
       `  return _coverageResult`
@@ -9748,6 +10020,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;
@@ -9782,6 +10055,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,
@@ -9878,6 +10152,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();
@@ -9891,6 +10169,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,
@@ -9899,11 +10179,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));
   }
@@ -10010,12 +10297,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,
@@ -10554,7 +10845,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") {
@@ -10733,7 +11024,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;
@@ -11980,6 +12272,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const macroImports = [];
   const allNames = /* @__PURE__ */ new Set();
   const importBindings = /* @__PURE__ */ new Map();
+  const ordinaryImports = [];
   for (const stmt of body) {
     if (stmt.type !== "ImportDeclaration") continue;
     const s = stmt;
@@ -11988,12 +12281,17 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       return key === "type" && a.value.value === "macro";
     });
     if (!isMacro) {
+      const specifiers = [];
       for (const spec of s.specifiers) {
         if (spec.type === "ImportSpecifier") {
           const imported = spec.imported.name ?? spec.local.name;
           importBindings.set(spec.local.name, { source: s.source.value, imported });
+          specifiers.push({ type: spec.type, local: spec.local.name, start: spec.start, end: spec.end });
+        } else {
+          specifiers.push({ type: spec.type, local: spec.local.name, start: spec.start, end: spec.end });
         }
       }
+      ordinaryImports.push({ start: s.start, end: s.end, specifiers });
       continue;
     }
     const names = /* @__PURE__ */ new Set();
@@ -12004,6 +12302,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     for (const n of names) allNames.add(n);
   }
   if (macroImports.length === 0) return null;
+  const unwrapVd = (stmt) => stmt.type === "VariableDeclaration" ? stmt : stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "VariableDeclaration" ? stmt.declaration : null;
   const factoryDecls = /* @__PURE__ */ new Map();
   for (const stmt of body) {
     const decl = stmt.type === "ExportNamedDeclaration" ? stmt.declaration : stmt;
@@ -12021,6 +12320,101 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       }
     }
   }
+  const topLevelFunction = (moduleBody, name) => {
+    for (const st of moduleBody) {
+      const decl = st.type === "ExportNamedDeclaration" ? st.declaration : st;
+      const idn = decl?.type === "FunctionDeclaration" ? decl.id : void 0;
+      if (idn?.name === name) return decl ?? null;
+    }
+    return null;
+  };
+  const isParsemanMacroImport = (stmt) => {
+    if (stmt.type !== "ImportDeclaration") return false;
+    const s = stmt;
+    return moduleAliases.has(s.source.value) && s.attributes.some((a) => {
+      const key = a.key.type === "Identifier" ? a.key.name : String(a.key.value);
+      return key === "type" && a.value.value === "macro";
+    });
+  };
+  const sourceScopeUntil = (moduleBody, source, until) => {
+    const out = /* @__PURE__ */ new Map();
+    for (const stmt of moduleBody) {
+      if (stmt.type === "ImportDeclaration") {
+        if (!isParsemanMacroImport(stmt)) return null;
+        continue;
+      }
+      if (stmt.type === "FunctionDeclaration") continue;
+      if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "FunctionDeclaration") continue;
+      if (stmt.type === "ExportNamedDeclaration" && !stmt.declaration) {
+        if (stmt.source) return null;
+        continue;
+      }
+      const vd = unwrapVd(stmt);
+      if (!vd || vd.kind !== "const") return null;
+      for (const decl of vd.declarations) {
+        const d = decl;
+        const idn = d.id;
+        const init = d.init;
+        if (idn.type !== "Identifier" && idn.type !== "BindingIdentifier" || !idn.name || !init) return null;
+        if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") continue;
+        const mapFnSources = [];
+        const combi = evaluateExpr(init, out, source, mapFnSources);
+        if (combi) {
+          if (stmt.start < until) out.set(idn.name, { combi, mfSrcs: mapFnSources });
+          continue;
+        }
+        const wordFactory = evaluateWordFactory(init, out, source);
+        if (wordFactory) {
+          if (stmt.start < until) {
+            ;
+            out.set(idn.name, wordFactory);
+          }
+          continue;
+        }
+        const whenFactory = evaluateWhenFactory(init, out, source);
+        if (whenFactory) {
+          if (stmt.start < until) {
+            ;
+            out.set(idn.name, whenFactory);
+          }
+          continue;
+        }
+        const combiArray = evaluateCombinatorArray(init, out, source);
+        if (combiArray) {
+          if (stmt.start < until) {
+            ;
+            out.set(idn.name, combiArray);
+          }
+          continue;
+        }
+        return null;
+      }
+      continue;
+    }
+    return out;
+  };
+  const usedImportedFactories = /* @__PURE__ */ new Set();
+  const markUsedImportedFactories = (names) => {
+    for (const name of names ?? []) usedImportedFactories.add(name);
+  };
+  for (const [localName, binding] of importBindings) {
+    const file = resolvePrivateSourceModule(id, binding.source);
+    if (!file) continue;
+    const mod = parseModuleCached(file);
+    if (!mod) continue;
+    const localFor = exportLocalName(mod.body, binding.imported);
+    const init = localFor ? topLevelInit(mod.body, localFor) ?? topLevelFunction(mod.body, localFor) : null;
+    if (!init || init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression" && init.type !== "FunctionDeclaration") continue;
+    const factoryScope = sourceScopeUntil(mod.body, mod.src, init.start);
+    if (!factoryScope) continue;
+    factoryDecls.set(localName, {
+      fn: init,
+      declaredAt: -1,
+      code: mod.src,
+      scope: factoryScope,
+      imported: true
+    });
+  }
   const scope = /* @__PURE__ */ new Map();
   const replacements = [];
   const warnings = [];
@@ -12050,6 +12444,9 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     }
     const namedFactory = factoryArgRaw.type === "Identifier" ? factoryDecls.get(factoryArgRaw.name) : void 0;
     const factoryArg = namedFactory !== void 0 && namedFactory.declaredAt <= init.start ? namedFactory.fn : factoryArgRaw;
+    const factoryScope = namedFactory?.scope ?? scope;
+    const factoryCode = namedFactory?.code ?? code;
+    const importedFactory = namedFactory?.imported === true && factoryArg === namedFactory.fn ? factoryArgRaw.name : void 0;
     const optionsArg = optionsFirst ? arg0 : arg1;
     const optionValue = (name) => optionsArg?.type === "ObjectExpression" ? (optionsArg.properties ?? []).find(
       (p) => p.key?.name === name
@@ -12060,7 +12457,13 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       warn(init.start, `${label2}: rules({ hostMode }) must be the literal 'ast' or 'cst'`);
       return null;
     }
-    const ruleMap = evaluateParserFactory(factoryArg, scope, code, []);
+    const trackLinesValue = optionValue("trackLines");
+    const gTrackLines = trackLinesValue?.type === "Literal" ? trackLinesValue.value : void 0;
+    if (trackLinesValue !== void 0 && typeof gTrackLines !== "boolean") {
+      warn(init.start, `${label2}: rules({ trackLines }) must be a boolean literal`);
+      return null;
+    }
+    const ruleMap = evaluateParserFactory(factoryArg, factoryScope, factoryCode, []);
     if (!ruleMap) {
       warn(init.start, `${label2}: rules(...) factory isn't statically evaluable`);
       return null;
@@ -12085,12 +12488,26 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         }
       }
     }
-    return { ruleMap, ...gTrivia ? { trivia: gTrivia } : {}, ...gScanSkip ? { scanSkip: gScanSkip } : {} };
+    if (gTrackLines === true) {
+      for (const rule of ruleMap.values()) {
+        if (rule && !rule._meta.isTrivia) {
+          ;
+          rule._meta.grammarTrackLines = true;
+        }
+      }
+    }
+    return {
+      ruleMap,
+      ...gTrivia ? { trivia: gTrivia } : {},
+      ...gScanSkip ? { scanSkip: gScanSkip } : {},
+      ...gTrackLines === true ? { trackLines: true } : {},
+      ...importedFactory ? { importedFactory } : {}
+    };
   };
   const compileRulesFactory = (init, label2) => {
     const evaluated = evaluateRulesFactory(init, label2);
     if (!evaluated) return null;
-    const compiled = compileRuleMap([...evaluated.ruleMap], { ...evaluated.trivia ? { trivia: evaluated.trivia } : {}, ...evaluated.scanSkip ? { scanSkip: evaluated.scanSkip } : {}, recovery, coverage: grammarCoverage });
+    const compiled = compileRuleMap([...evaluated.ruleMap], { ...evaluated.trivia ? { trivia: evaluated.trivia } : {}, ...evaluated.scanSkip ? { scanSkip: evaluated.scanSkip } : {}, ...evaluated.trackLines ? { trackLines: true } : {}, recovery, coverage: grammarCoverage });
     return {
       replacement: compiled?.replacement ?? null,
       ruleMap: evaluated.ruleMap,
@@ -12098,7 +12515,9 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       hostBranchElided: compiled?.hostBranchElided ?? false,
       ...compiled?.coverageDefinitions ? { coverageDefinitions: compiled.coverageDefinitions } : {},
       ...evaluated.trivia ? { trivia: evaluated.trivia } : {},
-      ...evaluated.scanSkip ? { scanSkip: evaluated.scanSkip } : {}
+      ...evaluated.scanSkip ? { scanSkip: evaluated.scanSkip } : {},
+      ...evaluated.trackLines ? { trackLines: true } : {},
+      ...evaluated.importedFactory ? { importedFactory: evaluated.importedFactory } : {}
     };
   };
   const isRulesCall = (init) => init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "rules";
@@ -12118,7 +12537,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   };
   const isSpread = (it) => "__spreadLocal" in it;
   const isIR = (it) => "ir" in it && !("ruleFns" in it);
-  const serializeItem = (it) => isSpread(it) ? `...(${it.__spreadLocal}[Symbol.for('parseman.composedPieces')] ?? [])` : isIR(it) ? `{ ns: ${JSON.stringify(it.ns)}, ir: ${JSON.stringify(it.ir)} }` : serializePieces(it);
+  const serializeItem = (it) => isSpread(it) ? `...(${it.__spreadLocal}[Symbol.for('parseman.composedPieces')] ?? [])` : isIR(it) ? `{ ns: ${JSON.stringify(it.ns)}, ir: ${JSON.stringify(it.ir)}${it.trackLines ? ", trackLines: true" : ""} }` : serializePieces(it);
   const serializeList = (list) => `[${list.map(serializeItem).join(", ")}]`;
   const withCarriedPieces = (grammarExpr, list) => `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.composedPieces'), { value: ${serializeList(list)}, enumerable: false })`;
   const withLeafMarker = (grammarExpr) => `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.leafComposed'), { value: true, enumerable: false })`;
@@ -12249,10 +12668,11 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const localCarried = (rm, label2, composing, scanSkip) => {
     const entries = [...rm];
     const ns = nsFor(label2);
+    const trackLines = entries.some(([, rule]) => rule?._meta?.grammarTrackLines === true);
     const ir = serializeRuleMap(entries, scanSkip);
-    if (ir) return { carried: [{ ns, ir }] };
+    if (ir) return { carried: [{ ns, ir, ...trackLines ? { trackLines: true } : {} }] };
     warn(0, `${label2}: rule map could not be serialized to IR; carrying FULL pieces instead. The artifact is correct but larger, and a downstream compose cannot re-lower it. Re-run with PARSEMAN_IR_DEBUG=1 to print the exact combinator that blocked serialization.`);
-    const p = compileLinkable(entries, ns, { ...composing ? { trivia: composing } : {}, ...scanSkip ? { scanSkip } : {}, recovery });
+    const p = compileLinkable(entries, ns, { ...composing ? { trivia: composing } : {}, ...scanSkip ? { scanSkip } : {}, ...trackLines ? { trackLines: true } : {}, recovery });
     return p ? { carried: [p] } : null;
   };
   const argPieces = (arg, label2, composing) => {
@@ -12270,7 +12690,10 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       const innerArg = argPieces(inner, `${label2}_pick`);
       if (!innerArg) return null;
       try {
-        return { carried: pickPieces(materializeCarried(innerArg.carried, ownTrivia(inner)), names) };
+        return {
+          carried: pickPieces(materializeCarried(innerArg.carried, ownTrivia(inner)), names),
+          ...innerArg.importedFactories ? { importedFactories: innerArg.importedFactories } : {}
+        };
       } catch (e) {
         warn(arg.start, `pick(): ${e.message}`);
         return null;
@@ -12278,7 +12701,8 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     }
     if (isRulesCall(arg)) {
       const evaluated = evaluateRulesFactory(arg, label2);
-      return evaluated ? localCarried(evaluated.ruleMap, label2, composing, evaluated.scanSkip) : null;
+      const carried = evaluated ? localCarried(evaluated.ruleMap, label2, composing, evaluated.scanSkip) : null;
+      return carried ? { ...carried, ...evaluated?.importedFactory ? { importedFactories: [evaluated.importedFactory] } : {} } : null;
     }
     if (arg.type === "Identifier") {
       const name = arg.name;
@@ -12350,6 +12774,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     }
     const composing = composingTrivia(elements);
     const carried = [];
+    const importedFactories = [];
     for (let i = 0; i < elements.length; i++) {
       const r = argPieces(elements[i], `compose${init.start}_${i}`, composing);
       if (!r) {
@@ -12357,6 +12782,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         return null;
       }
       carried.push(...r.carried);
+      importedFactories.push(...r.importedFactories ?? []);
     }
     const detailed = once(() => carriedRuleMapsDetailed(carried));
     runFusedGatingDiagnostic(
@@ -12366,7 +12792,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     );
     const pieces = materializeCarried(carried, composing, false, cHostMode);
     try {
-      return { replacement: emitFusedSource(pieces), carried, ...composing ? { trivia: composing } : {} };
+      return {
+        replacement: emitFusedSource(pieces),
+        carried,
+        ...composing ? { trivia: composing } : {},
+        ...importedFactories.length ? { importedFactories } : {}
+      };
     } catch (e) {
       warn(init.start, `compose(): ${e.message}; falling back to runtime`);
       return null;
@@ -12387,10 +12818,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     const localArg = elements[elements.length - 1];
     let localRules = null;
     let localScanSkip;
+    const importedFactories = [];
     if (isRulesCall(localArg)) {
       const evaluated = evaluateRulesFactory(localArg, `composeLeaf${init.start}`);
       localRules = evaluated?.ruleMap ?? null;
       localScanSkip = evaluated?.scanSkip;
+      if (evaluated?.importedFactory) importedFactories.push(evaluated.importedFactory);
     } else if (localArg.type === "Identifier") {
       const name = localArg.name;
       localRules = localRuleMaps.get(name) ?? null;
@@ -12409,6 +12842,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         return null;
       }
       carried.push(...r.carried);
+      importedFactories.push(...r.importedFactories ?? []);
     }
     try {
       const localNs = nsFor(`composeLeaf${init.start}`);
@@ -12434,13 +12868,15 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         return null;
       }
       const replacement = withLeafMarker(emitFusedSource(grammarCoverage ? recognitionPieces : [...recognitionPieces, plainLocalPiece]));
-      return { replacement: withCoverageDefinitions(replacement, emittedCoverageDefinitions(replacement)) };
+      return {
+        replacement: withCoverageDefinitions(replacement, emittedCoverageDefinitions(replacement)),
+        ...importedFactories.length ? { importedFactories } : {}
+      };
     } catch (e) {
       warn(init.start, `composeLeaf(): ${e.message}`);
       return null;
     }
   };
-  const unwrapVd = (stmt) => stmt.type === "VariableDeclaration" ? stmt : stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "VariableDeclaration" ? stmt.declaration : null;
   const refNames = /* @__PURE__ */ new Set();
   for (const stmt of body) {
     const innerVd = unwrapVd(stmt);
@@ -12524,6 +12960,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           const ns = nsFor(varName);
           const pieces = exportPrefix || compiledRules.replacement === null ? compileLinkable([...compiledRules.ruleMap], ns, {
             ...compiledRules.scanSkip ? { scanSkip: compiledRules.scanSkip } : {},
+            ...compiledRules.trackLines ? { trackLines: true } : {},
             recovery
           }) : null;
           if (compiledRules.replacement === null) {
@@ -12543,9 +12980,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           }
           if (exportPrefix && pieces && !pieces.mfFns.length && !pieces.buildFns.length) {
             const ir = serializeRuleMap([...compiledRules.ruleMap], compiledRules.scanSkip);
-            replacement = withCarriedPieces(replacement, [ir ? { ns, ir } : pieces]);
+            replacement = withCarriedPieces(replacement, [ir ? { ns, ir, ...compiledRules.trackLines ? { trackLines: true } : {} } : pieces]);
           }
           replacements.push({ start: init.start, end: init.end, replacement });
+          if (compiledRules.replacement !== null) {
+            markUsedImportedFactories(compiledRules.importedFactory ? [compiledRules.importedFactory] : void 0);
+          }
           continue;
         }
         if (isComposeCall(init)) {
@@ -12558,6 +12998,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           if (fused.trivia) localComposedTrivia.set(varName, fused.trivia);
           const replacement = exportPrefix ? withCarriedPieces(fused.replacement, fused.carried) : fused.replacement;
           replacements.push({ start: init.start, end: init.end, replacement: withCoverageDefinitions(replacement, emittedCoverageDefinitions(replacement)) });
+          markUsedImportedFactories(fused.importedFactories);
           continue;
         }
         if (isComposeLeafCall(init)) {
@@ -12566,6 +13007,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
             throw new Error(`${id}:${lineOf(init.start)} \u2014 composeLeaf() must macro-fuse; runtime composition is forbidden`);
           }
           replacements.push({ start: init.start, end: init.end, replacement: fused.replacement });
+          markUsedImportedFactories(fused.importedFactories);
           continue;
         }
         const mapFnSources = [];
@@ -12654,6 +13096,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           end: stmtEnd,
           replacement: lines.join("\n")
         });
+        markUsedImportedFactories(compiledRules.importedFactory ? [compiledRules.importedFactory] : void 0);
       }
     }
   }
@@ -12662,6 +13105,40 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     imp.fullyResolved = !anyUnresolved && !keepMacroImport;
   }
   const ms = new MagicString(code);
+  const replacementRanges = runtimeComposeFallback ? [] : replacements.map(({ start, end }) => ({ start, end }));
+  const isInsideReplacement = (start, end) => replacementRanges.some((r) => start >= r.start && end <= r.end);
+  const importedBindingStillReferenced = (local) => {
+    const walk2 = (node2, parent, parentKey) => {
+      if (!node2 || typeof node2 !== "object") return false;
+      const rec = node2;
+      if (rec.type === "ImportDeclaration") return false;
+      if (typeof rec.start === "number" && typeof rec.end === "number" && isInsideReplacement(rec.start, rec.end)) return false;
+      if ((rec.type === "Identifier" || rec.type === "BindingIdentifier") && rec.name === local) {
+        if (parentKey === "key" && (parent?.type === "ObjectProperty" || parent?.type === "Property" || parent?.type === "PropertyDefinition") && parent.computed !== true) return false;
+        if (parentKey === "property" && parent?.type === "StaticMemberExpression") return false;
+        if (parentKey === "property" && parent?.type === "MemberExpression" && parent.computed !== true) return false;
+        return true;
+      }
+      for (const key of Object.keys(rec)) {
+        if (key === "type" || key === "start" || key === "end") continue;
+        const value = rec[key];
+        if (Array.isArray(value)) {
+          if (value.some((child) => walk2(child, rec, key))) return true;
+        } else if (walk2(value, rec, key)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    return body.some((stmt) => walk2(stmt));
+  };
+  for (const imp of ordinaryImports) {
+    if (!runtimeComposeFallback && imp.specifiers.length > 0 && imp.specifiers.every(
+      (spec) => spec.type === "ImportSpecifier" && usedImportedFactories.has(spec.local) && !importedBindingStillReferenced(spec.local)
+    )) {
+      ms.remove(imp.start, imp.end);
+    }
+  }
   if (!anyUnresolved) {
     for (const { start, end } of defineRemovals) ms.remove(start, end);
   }