parseman 0.27.1 → 0.28.0

package/dist/plugin/index.cjs

@@ -35,6 +35,7 @@ __export(plugin_exports, {
 });
 module.exports = __toCommonJS(plugin_exports);
 var fs = __toESM(require("node:fs"), 1);
+var path = __toESM(require("node:path"), 1);
 var import_unplugin = require("unplugin");
 var import_oxc_parser2 = require("oxc-parser");
 var import_oxc_resolver = require("oxc-resolver");
@@ -101,6 +102,7 @@ function matchesEmpty(p, seen = /* @__PURE__ */ new Set()) {
     case "label":
     case "trivia":
     case "token":
+    case "leaf":
     case "expect":
     case "withCtx":
     case "node":
@@ -164,6 +166,7 @@ function firstSetOf(p, seen = /* @__PURE__ */ new Set()) {
     case "label":
     case "trivia":
     case "token":
+    case "leaf":
     case "node":
     case "grammar":
     case "expect":
@@ -269,10 +272,10 @@ function beginCstNodeCapture(ctx) {
 }
 function finishCstBuf(buf) {
   if (!buf) return { children: EMPTY, rawChildren: EMPTY, triviaLog: EMPTY_TL };
-  const children = buf.ch ?? (buf.single !== void 0 ? [buf.single] : EMPTY);
+  const children2 = buf.ch ?? (buf.single !== void 0 ? [buf.single] : EMPTY);
   const rawChildren = buf.raw ?? (buf.rawSingle !== void 0 ? [buf.rawSingle] : EMPTY);
   const triviaLog = buf.tl ?? EMPTY_TL;
-  return { children, rawChildren, triviaLog };
+  return { children: children2, rawChildren, triviaLog };
 }
 function endCstNodeCapture(ctx, saved) {
   const materialized = finishCstBuf(ctx._cstBuf);
@@ -284,8 +287,8 @@ function endCstNodeCapture(ctx, saved) {
   ctx.captureTrivia = saved.cap;
   return materialized;
 }
-function pushCstLeaf(ctx, leaf) {
-  pushCstChild(ctx, leaf, leaf);
+function pushCstLeaf(ctx, leaf2) {
+  pushCstChild(ctx, leaf2, leaf2);
 }
 function pushCstChild(ctx, built, rawEntry) {
   const b = ctx._cstBuf;
@@ -1015,10 +1018,13 @@ function deriveExpected(c) {
       return def.parsers.flatMap(deriveExpected);
     case "sequence":
       return def.parsers.length > 0 ? deriveExpected(def.parsers[0]) : [];
+    case "attempt":
+      return deriveExpected(def.parser);
     case "node":
     case "grammar":
     case "trivia":
     case "token":
+    case "leaf":
     case "optional":
     case "many":
     case "oneOrMore":
@@ -1793,6 +1799,24 @@ function sequence(...parsers) {
   };
 }
 
+// src/combinators/attempt.ts
+function attempt(parser2) {
+  return {
+    _tag: "attempt",
+    _meta: parser2._meta,
+    _def: { tag: "attempt", parser: parser2 },
+    parse(input, pos, ctx) {
+      const mark = saveCstMark(ctx);
+      const log = ctx._triviaLog?.length;
+      const result = parser2.parse(input, pos, ctx);
+      if (result.ok) return result;
+      rollbackCstCapture(ctx, mark);
+      if (log !== void 0 && ctx._triviaLog) ctx._triviaLog.length = log;
+      return { ok: false, expected: result.expected, span: { start: pos, end: pos } };
+    }
+  };
+}
+
 // src/combinators/repeat.ts
 function repItem(combinator, input, cur, ctx) {
   const mark = saveTriviaMark(ctx);
@@ -1968,19 +1992,19 @@ function sepBy(combinator, separator) {
             sepPos = advanceTrivia(input, cur, ctx);
           }
         }
-        const sep = separator.parse(input, sepPos, ctx);
-        if (!sep.ok) {
+        const sep2 = separator.parse(input, sepPos, ctx);
+        if (!sep2.ok) {
           rollbackTrivia(ctx, loopMark);
           break;
         }
-        let nextPos = sep.span.end;
+        let nextPos = sep2.span.end;
         if (ctx.trivia) {
           if (needsDeferredTriviaCommit(ctx)) {
-            const scan = scanTrivia(input, sep.span.end, ctx);
+            const scan = scanTrivia(input, sep2.span.end, ctx);
             scan.commit();
             nextPos = scan.end;
           } else {
-            nextPos = advanceTrivia(input, sep.span.end, ctx);
+            nextPos = advanceTrivia(input, sep2.span.end, ctx);
           }
         }
         const next = combinator.parse(input, nextPos, ctx);
@@ -2065,10 +2089,14 @@ function markUnusedValues(root) {
       case "label":
       case "trivia":
       case "token":
+      case "attempt":
       case "withCtx":
       case "expect":
         visit(def.parser, consumed);
         return;
+      case "leaf":
+        visit(def.parser, true);
+        return;
       case "lazy":
         return;
       default:
@@ -2191,6 +2219,20 @@ function confirmedBuildArity(src) {
   if (/\barguments\b/.test(s)) return null;
   return parts.length;
 }
+function buildReadsChildren(def) {
+  if (!def.build) return true;
+  const src = def.buildSrc ?? def.build.toString();
+  const arity = confirmedBuildArity(src);
+  if (arity === null) return true;
+  return arity >= 1;
+}
+function buildReadsRaw(def) {
+  if (!def.build) return true;
+  const src = def.buildSrc ?? def.build.toString();
+  const arity = confirmedBuildArity(src);
+  if (arity === null) return true;
+  return arity >= 4;
+}
 function buildReadsTrivia(def) {
   if (!def.build) return true;
   const src = def.buildSrc ?? def.build.toString();
@@ -2246,9 +2288,11 @@ function parserHasOwnFields(p, seen = /* @__PURE__ */ new Set()) {
     case "many":
     case "oneOrMore":
     case "optional":
+    case "attempt":
     case "transform":
     case "trivia":
     case "token":
+    case "leaf":
     case "label":
     case "expect":
     case "withCtx":
@@ -2281,9 +2325,11 @@ function parserHasTriviaSite(p, seen = /* @__PURE__ */ new Set()) {
     case "keywords":
     case "guard":
     case "token":
+    case "leaf":
       return false;
     // Transparent single-child wrappers: recurse.
     case "optional":
+    case "attempt":
     case "transform":
     case "trivia":
     case "label":
@@ -2330,6 +2376,7 @@ function parserEnablesTriviaCapture(p, seen = /* @__PURE__ */ new Set()) {
     case "many":
     case "oneOrMore":
     case "optional":
+    case "attempt":
     case "transform":
     case "trivia":
     case "token":
@@ -2339,6 +2386,10 @@ function parserEnablesTriviaCapture(p, seen = /* @__PURE__ */ new Set()) {
     case "withCtx":
     case "not":
       return parserEnablesTriviaCapture(d.parser, seen);
+    // leaf() clears the inner CST/trivia collector and publishes only its own
+    // terminal result. An inner parser() capture cannot reach this node.
+    case "leaf":
+      return false;
     case "lazy": {
       try {
         return parserEnablesTriviaCapture(d.thunk(), seen);
@@ -2417,12 +2468,12 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
       const fields = capturesFields ? buildFieldMap(ctx._fields) : void 0;
       ctx._fields = savedFields;
       ctx._triviaCaptureMask = savedMask;
-      const { children, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
+      const { children: children2, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
       if (!r.ok) return r;
       const st = clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
       const nodeType = def.type ?? missingInferredType();
       const cstOutput = ctx.build?._parsemanCstOutput === true;
-      const built = unwrap && children.length === 1 ? unwrapChild(children[0]) : collapse && children.length === 1 ? children[0] : !build && ctx.build?._parsemanCstCollapse && children.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children[0], children, rawChildren) ? children[0] : build ? cstOutput && ctx.build ? ctx.build(nodeType, children, fields, r.span, rawChildren, triviaLog, st) : build(children, fields, r.span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children, fields, r.span, rawChildren, triviaLog, st) : { _tag: "node", type: nodeType, span: { start: r.span.start, end: r.span.end }, state: st ?? null, children };
+      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : !build && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, r.span, rawChildren, triviaLog, st) : 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 };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
         pushCstChild(ctx, built, rawEntry);
@@ -2628,6 +2679,141 @@ function token(root) {
     }
   };
 }
+function leaf(root, fn) {
+  const meta = {
+    firstSet: root._meta.firstSet,
+    canMatchNewline: root._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "leaf",
+    _meta: meta,
+    _def: { tag: "leaf", parser: root, fn },
+    parse(input, pos, ctx) {
+      const savedBuf = ctx._cstBuf;
+      const savedChildren = ctx._cstChildren;
+      const savedLeaves = ctx._cstLeaves;
+      const savedRaw = ctx._cstRawChildren;
+      const savedTriviaLog = ctx._cstTriviaLog;
+      const savedOuterTriviaLog = ctx._triviaLog;
+      const wasCapturing = cstCaptureActive(ctx);
+      ctx._cstBuf = void 0;
+      ctx._cstChildren = void 0;
+      ctx._cstLeaves = void 0;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      delete ctx._triviaLog;
+      let result;
+      try {
+        result = root.parse(input, pos, ctx);
+      } finally {
+        ctx._cstBuf = savedBuf;
+        ctx._cstChildren = savedChildren;
+        ctx._cstLeaves = savedLeaves;
+        ctx._cstRawChildren = savedRaw;
+        ctx._cstTriviaLog = savedTriviaLog;
+        if (savedOuterTriviaLog === void 0) delete ctx._triviaLog;
+        else ctx._triviaLog = savedOuterTriviaLog;
+      }
+      if (!result.ok) return result;
+      const value = fn(result.value, result.span);
+      if (wasCapturing) pushCstLeaf(ctx, { _tag: "leaf", value, span: result.span });
+      return { ok: true, value, span: result.span };
+    }
+  };
+}
+
+// src/compiler/grammar-coverage-ids.ts
+function children(def, winners) {
+  switch (def.tag) {
+    case "sequence":
+    case "choice":
+      return def.parsers;
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "grammar":
+    case "not":
+    case "node":
+    case "guard":
+    case "withCtx":
+    case "recover":
+    case "expect":
+      return "parser" in def ? [def.parser] : [];
+    case "sepBy":
+      return [def.parser, def.separator];
+    case "skip":
+      return [def.main, def.skipped];
+    case "scanTo":
+      return [def.sentinel, ...def.skip];
+    case "lazy": {
+      let resolved;
+      try {
+        resolved = def.thunk();
+      } catch {
+        return [];
+      }
+      const name = resolved._ruleName;
+      return name && winners?.[name] ? [winners[name]] : [resolved];
+    }
+    default:
+      return [];
+  }
+}
+function buildGrammarPlan(entry, winners) {
+  const definitions = /* @__PURE__ */ new Map();
+  const choices = /* @__PURE__ */ new WeakMap();
+  const attempts = /* @__PURE__ */ new WeakMap();
+  const labels = /* @__PURE__ */ new WeakMap();
+  const rules2 = /* @__PURE__ */ new WeakMap();
+  const winnerNames = /* @__PURE__ */ new Map();
+  if (winners) {
+    for (const [name, winner] of Object.entries(winners)) {
+      winnerNames.set(winner, name);
+      if (winner._def.tag === "lazy") {
+        try {
+          winnerNames.set(winner._def.thunk(), name);
+        } catch {
+        }
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (parser2, path2) => {
+    if (seen.has(parser2)) return;
+    seen.add(parser2);
+    const rule = winnerNames.get(parser2) ?? parser2._ruleName;
+    if (rule && (winnerNames.has(parser2) || parser2._def.tag !== "lazy")) {
+      const id = `rule:${rule}`;
+      definitions.set(id, { id, kind: "rule" });
+      rules2.set(parser2, id);
+    }
+    if (parser2._def.tag === "choice") {
+      const ids = parser2._def.parsers.map((_, index) => `choice:${path2}/arm:${index}`);
+      choices.set(parser2, ids);
+      ids.forEach((id) => definitions.set(id, { id, kind: "choice-arm" }));
+    }
+    if (parser2._def.tag === "attempt") attempts.set(parser2, `attempt:${path2}`);
+    if (parser2._def.tag === "label") {
+      const id = `label:${path2}`;
+      labels.set(parser2, [id]);
+      definitions.set(id, { id, kind: "label" });
+    }
+    children(parser2._def, winners).forEach((child, index) => visit(child, `${path2}/${parser2._def.tag}:${index}`));
+  };
+  const roots = Array.isArray(entry) ? entry : [entry];
+  for (const root of roots) {
+    visit(root, winnerNames.get(root) ?? root._ruleName ?? "entry");
+  }
+  return { definitions: [...definitions.values()].sort((a, b) => a.id.localeCompare(b.id)), choices, attempts, labels, rules: rules2 };
+}
 
 // src/compiler/scannable-run.ts
 var BACKSLASH = 92;
@@ -4020,21 +4206,23 @@ function probeUpdate(ctx, expectedArr, posExpr, constant = true) {
 }
 function failBody(ctx, expected, posExpr) {
   const probe = probeUpdate(ctx, `[${expected}]`, posExpr);
+  const trace = ctx.activeCoverageRuleId === void 0 ? "" : `_ctx._grammarTrace?.write({ id: ${JSON.stringify(ctx.activeCoverageRuleId)}, phase: 'failure', offset: ${posExpr} }); `;
   if (ctx.failLabel) {
-    if (!ctx.recordFail) return probe ? `{ ${probe}break ${ctx.failLabel} }` : `break ${ctx.failLabel}`;
-    return `{ ${probe}_ctx._fe = ${posExpr}; _ctx._fx = ${hoistExpected(ctx, `[${expected}]`)}; break ${ctx.failLabel} }`;
+    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 + failReturn(expected, posExpr);
+  return probe + trace + failReturn(expected, posExpr);
 }
 function failArrBody(ctx, expectedArr, posExpr, constant = true) {
   const probe = probeUpdate(ctx, expectedArr, posExpr, constant);
+  const trace = ctx.activeCoverageRuleId === void 0 ? "" : `_ctx._grammarTrace?.write({ id: ${JSON.stringify(ctx.activeCoverageRuleId)}, phase: 'failure', offset: ${posExpr} }); `;
   if (ctx.failLabel) {
-    if (!ctx.recordFail) return probe ? `{ ${probe}break ${ctx.failLabel} }` : `break ${ctx.failLabel}`;
+    if (!ctx.recordFail) return probe ? `{ ${probe}${trace}break ${ctx.failLabel} }` : trace ? `{ ${trace}break ${ctx.failLabel} }` : `break ${ctx.failLabel}`;
     const fx = constant ? hoistExpected(ctx, expectedArr) : expectedArr;
-    return `{ ${probe}_ctx._fe = ${posExpr}; _ctx._fx = ${fx}; break ${ctx.failLabel} }`;
+    return `{ ${probe}_ctx._fe = ${posExpr}; _ctx._fx = ${fx}; ${trace}break ${ctx.failLabel} }`;
   }
-  if (!constant) return `${probe}return { ok: false, expected: [...${expectedArr}], span: { start: ${posExpr}, end: ${posExpr} } }`;
-  return probe + failReturnArr(expectedArr, posExpr);
+  if (!constant) return `${probe}${trace}return { ok: false, expected: [...${expectedArr}], span: { start: ${posExpr}, end: ${posExpr} } }`;
+  return probe + trace + failReturnArr(expectedArr, posExpr);
 }
 function resultFromRecorded(feExpr = "_ctx._fe", fxExpr = "_ctx._fx") {
   return `return { ok: false, expected: [...${fxExpr}], span: { start: ${feExpr}, end: ${feExpr} } }`;
@@ -4069,7 +4257,7 @@ var NAMED_FN_END = "_pfEnd";
 function namedFnPrelude() {
   return [`const ${NAMED_FN_FAIL} = {}`, `let ${NAMED_FN_END}`];
 }
-function pushNamedFnDecl(ctx, fnName, bodyStmts, valueVar, endVar) {
+function pushNamedFnDecl(ctx, fnName, bodyStmts, valueVar, endVar, failureRuleId) {
   ctx.namedFnDecls.push([
     `function ${fnName}(input, _pos, _ctx) {`,
     `  _pfail: {`,
@@ -4077,6 +4265,7 @@ function pushNamedFnDecl(ctx, fnName, bodyStmts, valueVar, endVar) {
     `    ${NAMED_FN_END} = ${endVar}`,
     `    return ${valueVar}`,
     `  }`,
+    ...failureRuleId === void 0 ? [] : [`  _ctx._grammarTrace?.write({ id: ${JSON.stringify(failureRuleId)}, phase: 'failure', offset: _ctx._fe ?? _pos })`],
     `  return ${NAMED_FN_FAIL}`,
     `}`
   ].join("\n"));
@@ -4238,6 +4427,7 @@ function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set()) {
     case "not":
     case "trivia":
     case "token":
+    case "leaf":
     case "scanTo":
     case "unknown":
       return false;
@@ -4249,6 +4439,8 @@ function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set()) {
     // nothing committed remains.
     case "choice":
       return false;
+    case "attempt":
+      return false;
     // optional never fails; many/oneOrMore only "fail" with zero captured items.
     case "optional":
     case "many":
@@ -4301,6 +4493,7 @@ function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
     case "keywords":
     case "node":
     case "token":
+    case "leaf":
       return true;
     case "not":
     case "guard":
@@ -4315,6 +4508,7 @@ function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
     case "many":
     case "oneOrMore":
     case "optional":
+    case "attempt":
     case "transform":
     case "label":
     case "field":
@@ -4656,35 +4850,55 @@ function needsFirstSetGuard(p) {
   const fs2 = p._meta.firstSet;
   return fs2.kind !== "any" && !canMatchEmptyAtStart(p);
 }
-function emitDisjointArm(p, ctx, pos, valV, endV) {
-  if (failsAtStart(p)) {
+function coverageHit(ctx, id, offset = "_pos", end) {
+  return id === void 0 ? [] : [
+    `${ind(ctx)}_ctx._grammarCoverage?.(${JSON.stringify(id)})`,
+    `${ind(ctx)}_ctx._grammarTrace?.write({ id: ${JSON.stringify(id)}, phase: 'selected', offset: ${offset}${end === void 0 ? "" : `, end: ${end}`} })`,
+    `${ind(ctx)}_ctx._grammarTrace?.write({ id: ${JSON.stringify(id)}, phase: 'success', offset: ${offset}${end === void 0 ? "" : `, end: ${end}`} })`
+  ];
+}
+function coverageAttempt(ctx, id, offset) {
+  return id === void 0 ? [] : [`${ind(ctx)}_ctx._grammarTrace?.write({ id: ${JSON.stringify(id)}, phase: 'attempt', offset: ${offset} })`];
+}
+function coverageFailureBacktrack(ctx, id, failureOffset, startOffset) {
+  return id === void 0 ? [] : [
+    `${ind(ctx)}_ctx._grammarTrace?.write({ id: ${JSON.stringify(id)}, phase: 'failure', offset: ${failureOffset} })`,
+    `${ind(ctx)}_ctx._grammarTrace?.write({ id: ${JSON.stringify(id)}, phase: 'backtrack', offset: ${startOffset} })`
+  ];
+}
+function emitDisjointArm(p, ctx, pos, valV, endV, coverageId) {
+  if (failsAtStart(p) && coverageId === void 0) {
     const r = emit(p, ctx, pos);
-    return [...r.stmts, `${ind(ctx)}${valV} = ${r.valueVar}`, `${ind(ctx)}${endV} = ${r.endVar}`];
+    return [...coverageAttempt(ctx, coverageId, pos), ...r.stmts, `${ind(ctx)}${valV} = ${r.valueVar}`, `${ind(ctx)}${endV} = ${r.endVar}`, ...coverageHit(ctx, coverageId, pos, r.endVar)];
   }
   const { stmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos);
   return [
+    ...coverageAttempt(ctx, coverageId, pos),
     ...stmts,
-    ...emitIfFail(ctx, `!${okVar}`, failArrBody(ctx, "_ctx._fx", pos, false)),
+    ...emitIfFail(ctx, `!${okVar}`, `${coverageFailureBacktrack(ctx, coverageId, "_ctx._fe", pos).join("; ")}; ${failArrBody(ctx, "_ctx._fx", pos, false)}`),
     `${ind(ctx)}${valV} = ${valVar}`,
-    `${ind(ctx)}${endV} = ${endVar}`
+    `${ind(ctx)}${endV} = ${endVar}`,
+    ...coverageHit(ctx, coverageId, pos, endVar)
   ];
 }
-function emitDisjointArmGated(def, i, ctx, pos, valV, endV) {
+function emitDisjointArmGated(def, i, ctx, pos, valV, endV, coverageId) {
   const p = def.parsers[i];
   const gate = def.gates[i];
-  if (!gate) return emitDisjointArm(p, ctx, pos, valV, endV);
+  if (!gate) return emitDisjointArm(p, ctx, pos, valV, endV, coverageId);
   const gateIdx = ctx.mapFns.length;
   ctx.mapFns.push(gate);
   ctx.mapFnSrcs.push(def.gateSrcs?.[i] ?? null);
   const gateCond = `${mfRef(ctx)}[${gateIdx}](_ctx.state)`;
   const stmts = [`${ind(ctx)}if (${gateCond}) {`];
   ctx.indent++;
-  stmts.push(...emitDisjointArm(p, ctx, pos, valV, endV));
+  stmts.push(...emitDisjointArm(p, ctx, pos, valV, endV, coverageId));
   ctx.indent--;
   stmts.push(`${ind(ctx)}} else { ${failArrBody(ctx, deriveExpectedArr([p]), pos)} }`);
   return stmts;
 }
-function emitChoice(def, ctx, pos) {
+function emitChoice(parser2, def, ctx, pos) {
+  const coverageIds = ctx.coverage?.plan.choices.get(parser2);
+  const coverageBase = coverageIds?.[0]?.slice(0, -1);
   const allExpected = deriveExpectedArr(def.parsers);
   if (def.disjoint) {
     const codeV = v(ctx, "_code");
@@ -4703,7 +4917,7 @@ function emitChoice(def, ctx, pos) {
         stmts.push(`${ind(ctx)}{`);
         ctx.indent++;
         stmts.push(
-          ...emitDisjointArmGated(def, i, ctx, pos, valV, endV),
+          ...emitDisjointArmGated(def, i, ctx, pos, valV, endV, coverageIds?.[i]),
           `${ind(ctx)}break`
         );
         ctx.indent--;
@@ -4722,16 +4936,16 @@ function emitChoice(def, ctx, pos) {
       first = false;
       stmts.push(`${ind(ctx)}${kw} (${cond}) {`);
       ctx.indent++;
-      stmts.push(...emitDisjointArmGated(def, i, ctx, pos, valV, endV));
+      stmts.push(...emitDisjointArmGated(def, i, ctx, pos, valV, endV, coverageIds?.[i]));
       ctx.indent--;
       stmts.push(`${ind(ctx)}}`);
     }
     stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)));
     return { stmts, valueVar: valV, endVar: endV };
   }
-  return emitNonDisjoint(def, def.strategy, allExpected, ctx, pos);
+  return emitNonDisjoint(def, def.strategy, allExpected, ctx, pos, coverageBase);
 }
-function emitGreedyClassify(def, superIndex, ctx, pos) {
+function emitGreedyClassify(def, superIndex, ctx, pos, coverageBase) {
   const superParser = def.parsers[superIndex];
   const regexDef = getCoreRegexDef(superParser);
   const cleanFlags = "y" + regexDef.flags.replace(/[gy]/g, "");
@@ -4747,10 +4961,12 @@ function emitGreedyClassify(def, superIndex, ctx, pos) {
   const endV = v(ctx, "_ge");
   const valV = v(ctx, "_gcv");
   const regexExpected = JSON.stringify(deriveExpected(superParser));
+  const superCoverageId = coverageBase === void 0 ? void 0 : `${coverageBase}${superIndex}`;
   const stmts = [
+    ...coverageAttempt(ctx, superCoverageId, pos),
     `${ind(ctx)}${reVar}.lastIndex = ${pos}`,
     `${ind(ctx)}const ${matchV} = ${reVar}.exec(input)`,
-    ...emitIfFail(ctx, `${matchV} === null`, failArrBody(ctx, regexExpected, pos)),
+    ...emitIfFail(ctx, `${matchV} === null`, `${coverageFailureBacktrack(ctx, superCoverageId, pos, pos).join("; ")}; ${failArrBody(ctx, regexExpected, pos)}`),
     `${ind(ctx)}const ${wordV} = ${matchV}[0]`,
     `${ind(ctx)}const ${endV} = ${pos} + ${wordV}.length`,
     `${ind(ctx)}let ${valV}`
@@ -4766,8 +4982,9 @@ function emitGreedyClassify(def, superIndex, ctx, pos) {
     stmts.push(`${ind(ctx)}${kw} (${wordV} === ${JSON.stringify(litVal)}) {`);
     ctx.indent++;
     const tR = emitTransformChain(p, JSON.stringify(litVal), endV, pos, ctx);
+    stmts.push(...coverageFailureBacktrack(ctx, superCoverageId, pos, pos));
     stmts.push(...emitLeafCapture(ctx, JSON.stringify(litVal), pos, endV));
-    stmts.push(...tR.stmts, `${ind(ctx)}${valV} = ${tR.valueVar}`);
+    stmts.push(...tR.stmts, `${ind(ctx)}${valV} = ${tR.valueVar}`, ...coverageHit(ctx, coverageBase === void 0 ? void 0 : `${coverageBase}${i}`, pos, endV));
     ctx.indent--;
     stmts.push(`${ind(ctx)}}`);
   }
@@ -4775,12 +4992,12 @@ function emitGreedyClassify(def, superIndex, ctx, pos) {
   const regexKw = first ? "if" : "else";
   stmts.push(`${ind(ctx)}${regexKw} {`);
   ctx.indent++;
-  stmts.push(...emitLeafCapture(ctx, wordV, pos, endV), ...rR.stmts, `${ind(ctx)}${valV} = ${rR.valueVar}`);
+  stmts.push(...emitLeafCapture(ctx, wordV, pos, endV), ...rR.stmts, `${ind(ctx)}${valV} = ${rR.valueVar}`, ...coverageHit(ctx, coverageBase === void 0 ? void 0 : `${coverageBase}${superIndex}`, pos, endV));
   ctx.indent--;
   stmts.push(`${ind(ctx)}}`);
   return { stmts, valueVar: valV, endVar: endV };
 }
-function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos) {
+function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos, coverageBase) {
   const valV = v(ctx, "_llv");
   const endV = v(ctx, "_lle");
   const stmts = [`${ind(ctx)}let ${valV}, ${endV} = ${pos}`];
@@ -4797,10 +5014,12 @@ function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos) {
     ctx.indent++;
     const tR = emitTransformChain(p, JSON.stringify(litVal), litEnd, pos, ctx);
     stmts.push(
+      ...coverageAttempt(ctx, coverageBase === void 0 ? void 0 : `${coverageBase}${idx}`, pos),
       ...emitLeafCapture(ctx, JSON.stringify(litVal), pos, litEnd),
       ...tR.stmts,
       `${ind(ctx)}${valV} = ${tR.valueVar}`,
-      `${ind(ctx)}${endV} = ${litEnd}`
+      `${ind(ctx)}${endV} = ${litEnd}`,
+      ...coverageHit(ctx, coverageBase === void 0 ? void 0 : `${coverageBase}${idx}`, pos, litEnd)
     );
     ctx.indent--;
     stmts.push(`${ind(ctx)}}`);
@@ -4808,16 +5027,18 @@ function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos) {
   stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)));
   return { stmts, valueVar: valV, endVar: endV };
 }
-function emitFirstMatch(def, ctx, pos) {
+function emitFirstMatch(def, ctx, pos, coverageBase) {
   const resValV = v(ctx, "_crv");
   const resEndV = v(ctx, "_cre");
   const resOkV = v(ctx, "_crok");
   const codeV = v(ctx, "_chcode");
   const slots = def.parsers.map(() => v(ctx, "_cfx"));
+  const autoRejectedV = coverageBase === void 0 ? void 0 : v(ctx, "_carej");
   const ind0 = ind(ctx);
   const stmts = [
     `${ind0}let ${resValV}, ${resEndV} = ${pos}, ${resOkV} = false`,
     `${ind0}let ${slots.join(", ")}`,
+    ...autoRejectedV === void 0 ? [] : [`${ind0}const ${autoRejectedV} = []`],
     `${ind0}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`
   ];
   for (let i = 0; i < def.parsers.length; i++) {
@@ -4853,6 +5074,7 @@ function emitFirstMatch(def, ctx, pos) {
     stmts.push(`${ind0}if (${skipCond}) {`);
     if (fsGuard) stmts.push(`${ind(ctx)}if (${fsGuard}) {`);
     ctx.indent += fsGuard ? 2 : 1;
+    if (coverageBase !== void 0) stmts.push(`${ind(ctx)}_ctx._grammarTrace?.write({ id: ${JSON.stringify(`${coverageBase}${i}`)}, phase: 'attempt', offset: ${pos} })`);
     if (markLeaves) {
       stmts.push(
         `${ind(ctx)}const ${markLeaves} = _ctx._cstLeaves?.length ?? 0`,
@@ -4875,13 +5097,21 @@ function emitFirstMatch(def, ctx, pos) {
       stmts.push(`${ind(ctx)}    ${resValV} = ${valVar}`);
       stmts.push(`${ind(ctx)}    ${resEndV} = ${endVar}`);
       stmts.push(`${ind(ctx)}    ${resOkV} = true`);
+      if (autoRejectedV !== void 0) {
+        stmts.push(`${ind(ctx)}    for (const _rejectedId of ${autoRejectedV}) { _ctx._grammarTrace?.write({ id: _rejectedId, phase: 'failure', offset: ${pos} }); _ctx._grammarTrace?.write({ id: _rejectedId, phase: 'backtrack', offset: ${pos} }) }`);
+      }
+      stmts.push(...coverageHit(ctx, coverageBase === void 0 ? void 0 : `${coverageBase}${i}`, pos, endVar));
       stmts.push(`${ind(ctx)}  }`);
+      if (autoRejectedV !== void 0) {
+        stmts.push(`${ind(ctx)}  else { ${autoRejectedV}.push(${JSON.stringify(`${coverageBase}${i}`)}) }`);
+      }
       stmts.push(`${ind(ctx)}}`);
-      stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot} }`);
+      stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot}; ${coverageBase === void 0 ? "" : `_ctx._grammarTrace?.write({ id: ${JSON.stringify(`${coverageBase}${i}`)}, phase: 'failure', offset: ${atStart ? pos : "_ctx._fe"} }); _ctx._grammarTrace?.write({ id: ${JSON.stringify(`${coverageBase}${i}`)}, phase: 'backtrack', offset: ${pos} });`} }`);
       if (rollback) stmts.push(`${ind(ctx)}if (!${resOkV}) { ${rollback} }`);
     } else {
-      stmts.push(`${ind(ctx)}if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true }`);
-      stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot}${rollback ? `; ${rollback}` : ""} }`);
+      const rejectedFlush = autoRejectedV === void 0 ? "" : `; for (const _rejectedId of ${autoRejectedV}) { _ctx._grammarTrace?.write({ id: _rejectedId, phase: 'failure', offset: ${pos} }); _ctx._grammarTrace?.write({ id: _rejectedId, phase: 'backtrack', offset: ${pos} }) }`;
+      stmts.push(`${ind(ctx)}if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true${coverageBase === void 0 ? "" : `${rejectedFlush}; _ctx._grammarCoverage?.(${JSON.stringify(`${coverageBase}${i}`)}); _ctx._grammarTrace?.write({ id: ${JSON.stringify(`${coverageBase}${i}`)}, phase: 'selected', offset: ${pos}, end: ${endVar} }); _ctx._grammarTrace?.write({ id: ${JSON.stringify(`${coverageBase}${i}`)}, phase: 'success', offset: ${pos}, end: ${endVar} })`} }`);
+      stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot}${rollback ? `; ${rollback}` : ""}${coverageBase === void 0 ? "" : `; _ctx._grammarTrace?.write({ id: ${JSON.stringify(`${coverageBase}${i}`)}, phase: 'failure', offset: ${atStart ? pos : "_ctx._fe"} }); _ctx._grammarTrace?.write({ id: ${JSON.stringify(`${coverageBase}${i}`)}, phase: 'backtrack', offset: ${pos} })`} }`);
     }
     ctx.indent -= fsGuard ? 2 : 1;
     if (fsGuard) stmts.push(`${ind(ctx)}} else { ${slots[i]} = ${staticFx} }`);
@@ -4891,12 +5121,12 @@ function emitFirstMatch(def, ctx, pos) {
   stmts.push(...emitIfFail(ctx, `!${resOkV}`, failArrBody(ctx, concatExpr, pos, false)));
   return { stmts, valueVar: resValV, endVar: resEndV };
 }
-function emitNonDisjoint(def, strategy, allExpected, ctx, pos) {
+function emitNonDisjoint(def, strategy, allExpected, ctx, pos, coverageBase) {
   if (strategy.tag === "greedyClassify")
-    return emitGreedyClassify(def, strategy.superIndex, ctx, pos);
+    return emitGreedyClassify(def, strategy.superIndex, ctx, pos, coverageBase);
   if (strategy.tag === "literalsLongestFirst")
-    return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos);
-  return emitFirstMatch(def, ctx, pos);
+    return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos, coverageBase);
+  return emitFirstMatch(def, ctx, pos, coverageBase);
 }
 function pushMapFn(ctx, fn, src) {
   if (src !== null && ctx.mapFns.length === ctx.mapFnSrcs.length) {
@@ -5014,6 +5244,27 @@ function emitOptional(def, ctx, pos) {
   ];
   return { stmts, valueVar: valV, endVar: endV };
 }
+function emitAttempt(p, def, ctx, pos) {
+  const inner = emitFallible(def.parser, ctx, pos);
+  const leaves = v(ctx, "_atl");
+  const raw = v(ctx, "_atr");
+  const trivia2 = v(ctx, "_att");
+  const log = v(ctx, "_atg");
+  const fields = v(ctx, "_atf");
+  const errors = v(ctx, "_ate");
+  const rollback = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${leaves}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${raw}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${trivia2}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${log}; if (_ctx._fields) _ctx._fields.length = ${fields}; if (_ctx._errors) _ctx._errors.length = ${errors}`;
+  const traceId = ctx.coverage?.plan.attempts.get(p);
+  const traceRollback = traceId === void 0 ? "" : ` _ctx._grammarTrace?.write({ id: ${JSON.stringify(traceId)}, phase: 'rollback', offset: ${pos} });`;
+  return {
+    stmts: [
+      `${ind(ctx)}const ${leaves} = _ctx._cstLeaves?.length ?? 0, ${raw} = _ctx._cstRawChildren?.length ?? 0, ${trivia2} = _ctx._cstTriviaLog?.length ?? 0, ${log} = _ctx._triviaLog?.length ?? 0, ${fields} = _ctx._fields?.length ?? 0, ${errors} = _ctx._errors?.length ?? 0`,
+      ...inner.stmts,
+      ...emitIfFail(ctx, `!${inner.okVar}`, `{ ${rollback};${traceRollback} _ctx._fe = ${pos}; ${propagateFailBody(ctx)} }`)
+    ],
+    valueVar: inner.valVar,
+    endVar: inner.endVar
+  };
+}
 function emitSepBy(_p, def, ctx, pos) {
   const arrV = v(ctx, "_arr");
   const curV = v(ctx, "_cur");
@@ -5259,11 +5510,11 @@ function tokenNullableRegex(def) {
   }
   if (inner.tag === "sepBy") {
     const item = tokenSequenceSource(inner.parser);
-    const sep = tokenSequenceSource(inner.separator);
-    if (!item || !sep) return null;
-    const combined = combineTokenRegexSources([item, sep]);
+    const sep2 = tokenSequenceSource(inner.separator);
+    if (!item || !sep2) return null;
+    const combined = combineTokenRegexSources([item, sep2]);
     if (!combined) return null;
-    return { tag: "regex", source: `(?:${item.source}(?:${sep.source}${item.source})*)?`, flags: combined.flags };
+    return { tag: "regex", source: `(?:${item.source}(?:${sep2.source}${item.source})*)?`, flags: combined.flags };
   }
   return null;
 }
@@ -5304,6 +5555,36 @@ function emitToken(def, ctx, pos) {
     endVar: inner.endVar
   };
 }
+function emitLeaf(def, ctx, pos) {
+  const inner = emitFallible(def.parser, ctx, pos);
+  const i = ind(ctx);
+  const sc = v(ctx, "_leafCh");
+  const sl = v(ctx, "_leafLv");
+  const sr = v(ctx, "_leafRaw");
+  const stl = v(ctx, "_leafTl");
+  const sol = v(ctx, "_leafLog");
+  const sb = v(ctx, "_leafBuf");
+  const rawV = v(ctx, "_leafRawValue");
+  const valV = v(ctx, "_leaf");
+  const fnIdx = pushMapFn(ctx, def.fn, def.fnSrc ?? null);
+  return {
+    stmts: [
+      `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${stl} = _ctx._cstTriviaLog, ${sol} = _ctx._triviaLog, ${sb} = _ctx._cstBuf`,
+      `${i}_ctx._cstChildren = undefined; _ctx._cstLeaves = undefined; _ctx._cstRawChildren = undefined; _ctx._cstTriviaLog = undefined; _ctx._triviaLog = undefined; _ctx._cstBuf = undefined`,
+      `${i}try {`,
+      ...reindentStmts(inner.stmts, ctx.indent + 1).map((stmt) => stmt.replace(/^(\s*)(?:const|let)\s+/, "$1var ")),
+      `${i}} finally {`,
+      `${i}  _ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx._cstTriviaLog = ${stl}; _ctx._triviaLog = ${sol}; _ctx._cstBuf = ${sb}`,
+      `${i}}`,
+      ...emitIfFail(ctx, `!${inner.okVar}`, propagateFailBody(ctx)),
+      `${i}const ${rawV} = ${inner.valVar}`,
+      `${i}const ${valV} = ${mfRef(ctx)}[${fnIdx}](${rawV}, { start: ${pos}, end: ${inner.endVar} })`,
+      ...emitLeafCapture(ctx, valV, pos, inner.endVar)
+    ],
+    valueVar: valV,
+    endVar: inner.endVar
+  };
+}
 function emitNode(def, ctx, pos) {
   if (def.type === void 0) {
     throw new Error('node(): inferred node type requires a rules() key; pass node("Type", parser) outside rules()');
@@ -5319,6 +5600,8 @@ function emitNode(def, ctx, pos) {
   const i = ind(ctx);
   const capturesTrivia = mkType !== null || def.captureTrivia === true || def.trailingTrivia === true || !structural && buildReadsTrivia(def);
   const clonesState = !structural && buildReadsState(def);
+  const capturesChildren = !structural && (mkType !== null || def.unwrap || def.collapse || buildReadsChildren(def));
+  const capturesRaw = !structural && (mkType !== null || buildReadsRaw(def));
   const hasFields = parserHasOwnFields(def.parser);
   const capturesFields = hasFields && !structural && buildReadsFields(def);
   const innerEnablesTriviaCapture = parserEnablesTriviaCapture(def.parser);
@@ -5337,9 +5620,13 @@ function emitNode(def, ctx, pos) {
   const profHoist = `${i}const ${pmV} = _ctx._pmProfile, ${recV} = ${pmV}?.phase === 'recognizer', ${capV} = ${pmV}?.phase === 'capture'`;
   const profileRecognizer = recV;
   const profileCapture = capV;
+  const directCstV = !structural && (!capturesChildren || !capturesRaw) ? v(ctx, "_dcst") : null;
+  const directCstGate = directCstV === null ? "false" : `${profileCapture} || _ctx.build?._parsemanCstOutput === true`;
   const structuralCapturesTrivia = structural && (def.captureTrivia === true || def.trailingTrivia === true);
   const allocStmt = structural ? `${i}const ${capTLv} = !(${profileRecognizer}) && (${profileCapture} || ${structuralCapturesTrivia ? "true" : hostTriviaGate}), ${capSTv} = !(${profileRecognizer} || ${profileCapture}) && (_ctx._pmCapST ??= (_ctx.build === undefined || _hostReads(_ctx.build, 6)))${capFv ? `, ${capFv} = !(${profileRecognizer}) && (${profileCapture} || (_ctx.build !== undefined && _hostReads(_ctx.build, 2)))` : ""}
-${i}const ${chV} = ${profileRecognizer} ? undefined : [], ${rawV} = ${profileRecognizer} ? undefined : [], ${tlV} = ${profileRecognizer} ? undefined : ${innerEnablesTriviaCapture ? "[]" : `${capTLv} ? [] : _EMPTY_TL`}` : capturesTrivia ? `${i}const ${capTLv} = !(${profileRecognizer}), ${chV} = ${profileRecognizer} ? undefined : [], ${rawV} = ${profileRecognizer} ? undefined : [], ${tlV} = ${profileRecognizer} ? undefined : []` : `${i}const ${chV} = ${profileRecognizer} ? undefined : [], ${rawV} = ${profileRecognizer} ? undefined : []`;
+${i}const ${chV} = ${profileRecognizer} ? undefined : [], ${rawV} = ${profileRecognizer} ? undefined : [], ${tlV} = ${profileRecognizer} ? undefined : ${innerEnablesTriviaCapture ? "[]" : `${capTLv} ? [] : _EMPTY_TL`}` : capturesTrivia ? `${directCstV ? `${i}const ${directCstV} = ${directCstGate}
+` : ""}${i}const ${capTLv} = !(${profileRecognizer}), ${chV} = ${profileRecognizer} ? undefined : ${capturesChildren ? "[]" : `${directCstV} ? [] : undefined`}, ${rawV} = ${profileRecognizer} ? undefined : ${capturesRaw ? "[]" : `${directCstV} ? [] : undefined`}, ${tlV} = ${profileRecognizer} ? undefined : []` : `${directCstV ? `${i}const ${directCstV} = ${directCstGate}
+` : ""}${i}const ${chV} = ${profileRecognizer} ? undefined : ${capturesChildren ? "[]" : `${directCstV} ? [] : undefined`}, ${rawV} = ${profileRecognizer} ? undefined : ${capturesRaw ? "[]" : `${directCstV} ? [] : undefined`}`;
   const innerTl = structural || capturesTrivia ? structural && !innerEnablesTriviaCapture ? `${capTLv} ? ${tlV} : undefined` : tlV : "undefined";
   const fieldsOn = structural ? capFv ?? "false" : `${profileRecognizer} ? false : ${capturesFields ? "true" : "false"}`;
   const sf = hasFields ? v(ctx, "_sf") : null;
@@ -5456,14 +5743,23 @@ function emitLazy(p, def, ctx, pos) {
     const savedIndent = ctx.indent;
     const savedFailLabel = ctx.failLabel;
     const savedRecord = ctx.recordFail;
+    const failureRuleId = p === ctx.coverage?.entry ? void 0 : ctx.coverage?.plan.rules.get(p) ?? ctx.coverage?.plan.rules.get(resolved);
+    const savedActiveRule = ctx.activeCoverageRuleId;
+    const savedSuppressFailure = ctx.suppressCoverageFailure;
     ctx.indent = 1;
     ctx.failLabel = "_pfail";
     ctx.recordFail = true;
+    if (failureRuleId !== void 0) {
+      ctx.activeCoverageRuleId = void 0;
+      ctx.suppressCoverageFailure = true;
+    }
     const r = emit(resolved, ctx, "_pos");
     ctx.indent = savedIndent;
     ctx.failLabel = savedFailLabel;
     ctx.recordFail = savedRecord;
-    pushNamedFnDecl(ctx, fnName2, r.stmts, r.valueVar, r.endVar);
+    ctx.activeCoverageRuleId = savedActiveRule;
+    ctx.suppressCoverageFailure = savedSuppressFailure;
+    pushNamedFnDecl(ctx, fnName2, r.stmts, r.valueVar, r.endVar, failureRuleId);
   }
   const fnName = ctx.namedParsers.get(p);
   return emitNamedFnCall(ctx, fnName, pos);
@@ -5514,6 +5810,30 @@ function emitExpect(def, ctx, pos) {
   return { stmts, valueVar: valVar, endVar };
 }
 function emit(p, ctx, pos) {
+  const dispatch = (emissionPos = pos) => {
+    const savedRule = ctx.activeCoverageRuleId;
+    const rule = ctx.coverage?.plan.rules.get(p);
+    if (rule && p !== ctx.coverage?.entry && !ctx.suppressCoverageFailure) ctx.activeCoverageRuleId = rule;
+    const result = emitDispatch(p, ctx, emissionPos);
+    ctx.activeCoverageRuleId = savedRule;
+    return result;
+  };
+  const instrument = (r) => {
+    const ruleId = ctx.coverage?.plan.rules.get(p);
+    const labelIds = ctx.coverage?.plan.labels.get(p);
+    if (!ruleId && !labelIds) return r;
+    return {
+      ...r,
+      stmts: [
+        ...ruleId ? [`${ind(ctx)}_ctx._grammarCoverage?.(${JSON.stringify(ruleId)})`] : [],
+        ...ruleId ? [`${ind(ctx)}_ctx._grammarTrace?.write({ id: ${JSON.stringify(ruleId)}, phase: 'enter', offset: ${pos} })`] : [],
+        ...r.stmts,
+        ...ruleId ? [`${ind(ctx)}_ctx._grammarTrace?.write({ id: ${JSON.stringify(ruleId)}, phase: 'success', offset: ${pos}, end: ${r.endVar} })`] : [],
+        ...labelIds?.flatMap((id) => [`${ind(ctx)}_ctx._grammarCoverage?.(${JSON.stringify(id)})`]) ?? [],
+        ...labelIds?.flatMap((id) => [`${ind(ctx)}_ctx._grammarTrace?.write({ id: ${JSON.stringify(id)}, phase: 'success', offset: ${pos}, end: ${r.endVar} })`]) ?? []
+      ]
+    };
+  };
   const usage = ctx.lazyUsage;
   if (usage && !ctx.noHoist && !ctx.capAsTrivia && !ctx.ruleNames?.has(p) && isHoistableTag(p._def.tag) && (usage.counts.get(p) ?? 0) > 1 && // Only hoist subtrees big enough that de-duplicating them beats the call
   // overhead. A tiny shared wrapper (e.g. `optional(literal(';'))`) inlines
@@ -5530,14 +5850,14 @@ function emit(p, ctx, pos) {
     ctx.indent = 1;
     ctx.failLabel = "_pfail";
     ctx.recordFail = true;
-    const r = emitDispatch(p, ctx, "_pos");
+    const r = dispatch("_pos");
     ctx.indent = savedIndent;
     ctx.failLabel = savedFailLabel;
     ctx.recordFail = savedRecord;
     pushNamedFnDecl(ctx, fnName, r.stmts, r.valueVar, r.endVar);
-    return emitNamedFnCall(ctx, fnName, pos);
+    return instrument(emitNamedFnCall(ctx, fnName, pos));
   }
-  return emitDispatch(p, ctx, pos);
+  return instrument(dispatch());
 }
 function emitDispatch(p, ctx, pos) {
   const def = p._def;
@@ -5551,7 +5871,9 @@ function emitDispatch(p, ctx, pos) {
     case "sequence":
       return emitSeq(def, ctx, pos);
     case "choice":
-      return emitChoice(def, ctx, pos);
+      return emitChoice(p, def, ctx, pos);
+    case "attempt":
+      return emitAttempt(p, def, ctx, pos);
     case "many":
     case "oneOrMore":
       return emitMany(def, ctx, pos);
@@ -5620,6 +5942,8 @@ function emitDispatch(p, ctx, pos) {
       return emit(def.parser, ctx, pos);
     case "token":
       return emitToken(def, ctx, pos);
+    case "leaf":
+      return emitLeaf(def, ctx, pos);
     case "label": {
       const inner = emitFallible(def.parser, ctx, pos);
       return {
@@ -5751,6 +6075,7 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
     case "grammar":
     case "trivia":
     case "token":
+    case "leaf":
     case "label":
     case "field":
     case "optional":
@@ -5778,16 +6103,32 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
   }
 }
+function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  if (d.tag === "node" && d.build !== void 0) return true;
+  if (d.tag === "lazy") {
+    try {
+      return hasDirectBuildDef(d.thunk(), seen);
+    } catch {
+      return false;
+    }
+  }
+  return childrenOf(d).some((child) => hasDirectBuildDef(child, seen));
+}
 function childrenOf(def) {
   switch (def.tag) {
     case "sequence":
     case "choice":
       return def.parsers;
     case "many":
+    case "attempt":
     case "optional":
     case "transform":
     case "trivia":
     case "token":
+    case "leaf":
     case "label":
     case "field":
     case "grammar":
@@ -5962,10 +6303,25 @@ function compile(combinator, mapFnSources, opts) {
     namedFnDecls: [],
     capturing: hasNodeDef(combinator),
     recovery: opts?.recovery ?? false,
+    ...opts?.coverage ? { coverage: { plan: buildGrammarPlan(combinator), entry: combinator } } : {},
     lazyUsage: analyzeLazyUsage(combinator),
     ...grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {}
   };
   const r = emit(combinator, ctx, "_pos");
+  const coverageRootRuleId = ctx.coverage?.plan.rules.get(combinator);
+  const resultBody = coverageRootRuleId === void 0 ? [
+    `  let pos = _pos`,
+    ...r.stmts,
+    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`
+  ] : [
+    `  const _coverageResult = (() => {`,
+    `    let pos = _pos`,
+    ...r.stmts,
+    `    return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+    `  })()`,
+    `  if (!_coverageResult.ok) _ctx._grammarTrace?.write({ id: ${JSON.stringify(coverageRootRuleId)}, phase: 'failure', offset: _coverageResult.span.start })`,
+    `  return _coverageResult`
+  ];
   const namedPrelude = ctx.namedFnDecls.length > 0 ? [...namedFnPrelude(), ""] : [];
   const emptyTlDecls = ctx.needsEmptyTl ? ["const _EMPTY_TL = Object.freeze([])"] : [];
   const hostReadsDecls = ctx.needsHostReads ? [HOST_READS_DECL] : [];
@@ -5978,9 +6334,7 @@ function compile(combinator, mapFnSources, opts) {
     ...namedPrelude,
     ctx.namedFnDecls.join("\n\n"),
     `function _parse(input, _pos, _rp, _mf, _build, _ctx) {`,
-    `  let pos = _pos`,
-    ...r.stmts,
-    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+    ...resultBody,
     `}`
   ].join("\n");
   const fn = new Function("input", "_pos", "_rp", "_mf", "_build", "_ctx", [
@@ -5990,9 +6344,15 @@ function compile(combinator, mapFnSources, opts) {
     ...ctx.expectedDecls,
     ...namedPrelude,
     ...ctx.namedFnDecls.flatMap((decl, i) => i > 0 ? ["", decl] : [decl]),
-    `let pos = _pos`,
-    ...r.stmts,
-    `return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`
+    ...coverageRootRuleId === void 0 ? [`let pos = _pos`, ...r.stmts, `return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`] : [
+      `const _coverageResult = (() => {`,
+      `  let pos = _pos`,
+      ...r.stmts,
+      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+      `})()`,
+      `if (!_coverageResult.ok) _ctx._grammarTrace?.write({ id: ${JSON.stringify(coverageRootRuleId)}, phase: 'failure', offset: _coverageResult.span.start })`,
+      `return _coverageResult`
+    ]
   ].join("\n"));
   const defaultCtx = {
     trackLines: false,
@@ -6004,10 +6364,11 @@ function compile(combinator, mapFnSources, opts) {
   const buildSources = ctx.buildFns.length === 0 ? void 0 : ctx.buildSrcs;
   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) : null;
+  const inlineExpression = canInline ? buildInlineExpression(ctx, r, effectiveSources, buildSources, coverageRootRuleId) : null;
   return {
     source,
     inlineExpression,
+    ...ctx.coverage === void 0 ? {} : { coverageDefinitions: ctx.coverage.plan.definitions },
     parse(input, pos = 0) {
       return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, defaultCtx);
     },
@@ -6041,6 +6402,7 @@ function publicRuleWrapperSource(rule, fnSource) {
 }
 function compileRuleMap(ruleMap, opts) {
   for (const [, rule] of ruleMap) markUnusedValues(rule);
+  const coverageWinners = opts?.coverage ? Object.fromEntries(ruleMap.filter(([, rule]) => rule._def.tag !== "lazy")) : void 0;
   const grammarTrivia = opts?.trivia;
   const ctx = {
     vars: 0,
@@ -6061,6 +6423,7 @@ function compileRuleMap(ruleMap, opts) {
     namedFnDecls: [],
     capturing: ruleMap.some(([, rule]) => hasNodeDef(rule)),
     recovery: opts?.recovery ?? false,
+    ...opts?.coverage ? { coverage: { plan: buildGrammarPlan(ruleMap.map(([, rule]) => rule), coverageWinners) } } : {},
     lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),
     ...grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {}
   };
@@ -6103,15 +6466,34 @@ function compileRuleMap(ruleMap, opts) {
       return i > 0 ? ["", ...lines] : lines;
     })
   ].filter(Boolean);
-  const entryFnText = (r) => [
-    `function(input, _pos, _ctx) {`,
-    `  let pos = _pos`,
-    ...r.stmts,
-    `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
-    `}`
-  ].join("\n");
+  const entryRuleId = (rule) => {
+    const direct = ctx.coverage?.plan.rules.get(rule);
+    if (direct !== void 0 || rule._def.tag !== "lazy") return direct;
+    try {
+      return ctx.coverage?.plan.rules.get(rule._def.thunk());
+    } catch {
+      return void 0;
+    }
+  };
+  const entryFnText = (r, rule) => {
+    const ruleId = entryRuleId(rule);
+    const body = ruleId === void 0 ? [
+      `  let pos = _pos`,
+      ...r.stmts,
+      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`
+    ] : [
+      `  const _coverageResult = (() => {`,
+      `    let pos = _pos`,
+      ...r.stmts,
+      `    return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+      `  })()`,
+      `  if (!_coverageResult.ok) _ctx._grammarTrace?.write({ id: ${JSON.stringify(ruleId)}, phase: 'failure', offset: _coverageResult.span.start })`,
+      `  return _coverageResult`
+    ];
+    return [`function(input, _pos, _ctx) {`, ...body, `}`].join("\n");
+  };
   const objBody = perEntry.map(({ key, rule, r }) => {
-    const src = publicRuleWrapperSource(rule, entryFnText(r));
+    const src = publicRuleWrapperSource(rule, entryFnText(r, rule));
     return `    ${JSON.stringify(key)}: ${src.split("\n").join("\n    ")}`;
   }).join(",\n");
   const replacement = [
@@ -6122,7 +6504,11 @@ function compileRuleMap(ruleMap, opts) {
     `  }`,
     `})()`
   ].join("\n");
-  return { keys: perEntry.map((e) => e.key), replacement };
+  return {
+    keys: perEntry.map((e) => e.key),
+    replacement,
+    ...ctx.coverage === void 0 ? {} : { coverageDefinitions: ctx.coverage.plan.definitions }
+  };
 }
 function compileLinkable(ruleMapArg, ns, opts) {
   if (!ns) throw new Error("compileLinkable: ns must be a non-empty namespace");
@@ -6155,8 +6541,13 @@ function compileLinkable(ruleMapArg, ns, opts) {
     triviaCaptureNames: /* @__PURE__ */ new Map(),
     triviaFnNames: /* @__PURE__ */ new Map(),
     namedFnDecls: [],
-    capturing: ruleMap.some(([, rule]) => hasNodeDef(rule)),
+    // A recognition-only fragment normally has no node collector of its own.
+    // Leaf composition can re-lower it beneath a local semantic node, though;
+    // in that case its terminals must feed the caller's collector rather than
+    // merely returning their scalar parse values.
+    capturing: opts?.captureTerminals === true || ruleMap.some(([, rule]) => hasNodeDef(rule)),
     recovery: opts?.recovery ?? false,
+    ...opts?.coverage ? { coverage: { plan: opts.coverage } } : {},
     lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),
     ns,
     deferFirstSetRefs: true,
@@ -6230,7 +6621,14 @@ function compileLinkable(ruleMapArg, ns, opts) {
       ctx.indent = savedIndent;
       ctx.failLabel = savedFail;
       ctx.recordFail = savedRec;
-      pushNamedFnDecl(ctx, fn, body.stmts, body.valueVar, body.endVar);
+      const ruleId = ctx.coverage?.plan.rules.get(rule);
+      const stmts = ruleId === void 0 ? body.stmts : [
+        `${ind(ctx)}_ctx._grammarCoverage?.(${JSON.stringify(ruleId)})`,
+        `${ind(ctx)}_ctx._grammarTrace?.write({ id: ${JSON.stringify(ruleId)}, phase: 'enter', offset: _pos })`,
+        ...body.stmts,
+        `${ind(ctx)}_ctx._grammarTrace?.write({ id: ${JSON.stringify(ruleId)}, phase: 'success', offset: _pos, end: ${body.endVar} })`
+      ];
+      pushNamedFnDecl(ctx, fn, stmts, body.valueVar, body.endVar);
     }
     perEntry.push({ key, rule, r: emitNamedFnCall(ctx, fn, "_pos") });
   }
@@ -6287,15 +6685,46 @@ function compileLinkable(ruleMapArg, ns, opts) {
     deps: ruleDependencies(ruleMap),
     needsEmptyTl: !!ctx.needsEmptyTl,
     needsHostReads: !!ctx.needsHostReads,
+    hasDirectBuilders: ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
+    isRecognitionOnly: !hasSemanticReduction(ruleMap.map(([, rule]) => rule)),
     mfFns: mfSrcs ? [] : ctx.mapFns,
     buildFns: buildSrcs ? [] : ctx.buildFns
   };
 }
-function buildInlineExpression(ctx, r, mapFnSources, buildSources) {
-  const bodyLines = [
+function hasSemanticReduction(roots) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (parser2) => {
+    if (seen.has(parser2)) return false;
+    seen.add(parser2);
+    const def = parser2._def;
+    if (def.tag === "transform" && !def.recognitionOnly) return true;
+    if (def.tag === "choice" && def.gates.some(Boolean)) return true;
+    if (def.tag === "guard" || def.tag === "withCtx") return true;
+    if (def.tag === "node" && def.build !== void 0) return true;
+    if (def.tag === "lazy") {
+      try {
+        return visit(def.thunk());
+      } catch {
+        return true;
+      }
+    }
+    return childrenOf(def).some(visit);
+  };
+  return roots.some(visit);
+}
+function buildInlineExpression(ctx, r, mapFnSources, buildSources, coverageRootRuleId) {
+  const bodyLines = coverageRootRuleId === void 0 ? [
     `  let pos = _pos`,
     ...r.stmts,
     `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`
+  ] : [
+    `  const _coverageResult = (() => {`,
+    `    let pos = _pos`,
+    ...r.stmts,
+    `    return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+    `  })()`,
+    `  if (!_coverageResult.ok) _ctx._grammarTrace?.write({ id: ${JSON.stringify(coverageRootRuleId)}, phase: 'failure', offset: _coverageResult.span.start })`,
+    `  return _coverageResult`
   ];
   const innerFn = [
     `function(input, _pos, _ctx) {`,
@@ -6350,8 +6779,8 @@ function scanTo(sentinel, { skip: skip2 = [], orEOF = false } = {}) {
       };
       const emit2 = (end) => {
         if (end > pos && cstCaptureActive(ctx)) {
-          const leaf = { _tag: "leaf", value: input.slice(pos, end), span: { start: pos, end } };
-          pushCstLeaf(ctx, leaf);
+          const leaf2 = { _tag: "leaf", value: input.slice(pos, end), span: { start: pos, end } };
+          pushCstLeaf(ctx, leaf2);
         }
       };
       while (cur < input.length) {
@@ -6405,6 +6834,7 @@ function balanced(open, close, options = {}) {
   );
   if (combi._def.tag === "transform") {
     combi._def.fnSrc = '([o, parts, c]) => o + parts.map(p => typeof p === "string" ? p : Array.isArray(p) ? p.join("") : "").join("") + (typeof c === "string" ? c : "")';
+    combi._def.recognitionOnly = true;
   }
   self.define(combi);
   return combi;
@@ -6450,9 +6880,11 @@ function childrenOf2(def) {
     case "many":
     case "oneOrMore":
     case "optional":
+    case "attempt":
     case "transform":
     case "trivia":
     case "token":
+    case "leaf":
     case "label":
     case "field":
     case "not":
@@ -6501,7 +6933,7 @@ function serializeRuleMap(ruleMap) {
   }
 }
 function evalRuleMapIR(ir) {
-  const _tf = (child, src) => {
+  const _tf = (child, src, recognitionOnly = false) => {
     let fn2;
     try {
       fn2 = (0, eval)(`(${src})`);
@@ -6512,8 +6944,22 @@ function evalRuleMapIR(ir) {
     }
     const t = transform(child, fn2);
     t._def.fnSrc = src;
+    if (recognitionOnly) t._def.recognitionOnly = true;
     return t;
   };
+  const _lf = (child, src) => {
+    let fn2;
+    try {
+      fn2 = (0, eval)(`(${src})`);
+    } catch {
+      fn2 = () => {
+        throw new Error("IR leaf fn not materialized");
+      };
+    }
+    const l = leaf(child, fn2);
+    l._def.fnSrc = src;
+    return l;
+  };
   const _nd = (type, child, src, opts, staticError) => {
     if (staticError !== void 0 && staticError.length > 0) {
       throw new Error(`IR direct node builder for ${type} must be macro-static and self-contained; unsupported binding(s): ${staticError.join(", ")}`);
@@ -6572,6 +7018,7 @@ function evalRuleMapIR(ir) {
     "keywords",
     "sequence",
     "choice",
+    "attempt",
     "many",
     "oneOrMore",
     "optional",
@@ -6581,6 +7028,7 @@ function evalRuleMapIR(ir) {
     "parser",
     "scanTo",
     "token",
+    "leaf",
     "transform",
     "skip",
     "trivia",
@@ -6588,6 +7036,7 @@ function evalRuleMapIR(ir) {
     "field",
     "expect",
     "_tf",
+    "_lf",
     "_nd",
     "_gch",
     "_wc",
@@ -6601,6 +7050,7 @@ function evalRuleMapIR(ir) {
     keywords,
     sequence,
     choice,
+    attempt,
     many,
     oneOrMore,
     optional,
@@ -6610,6 +7060,7 @@ function evalRuleMapIR(ir) {
     parser,
     scanTo,
     token,
+    leaf,
     transform,
     skip,
     trivia,
@@ -6617,6 +7068,7 @@ function evalRuleMapIR(ir) {
     field,
     expect,
     _tf,
+    _lf,
     _nd,
     _gch,
     _wc
@@ -6748,6 +7200,8 @@ ${body}
         return `oneOrMore(${kid(def.parser)})`;
       case "optional":
         return `optional(${kid(def.parser)})`;
+      case "attempt":
+        return `attempt(${kid(def.parser)})`;
       case "sepBy":
         return `sepBy(${kid(def.parser)}, ${kid(def.separator)})`;
       case "not":
@@ -6756,6 +7210,10 @@ ${body}
         return `trivia(${kid(def.parser)})`;
       case "token":
         return `token(${kid(def.parser)})`;
+      case "leaf": {
+        if (def.fnSrc === void 0) throw new Unserializable("leaf without fnSrc");
+        return `_lf(${kid(def.parser)}, ${JSON.stringify(def.fnSrc)})`;
+      }
       case "label":
         return `label(${JSON.stringify(def.label)}, ${kid(def.parser)})`;
       case "field":
@@ -6768,7 +7226,7 @@ ${body}
         return `scanTo(${kid(def.sentinel)}, { skip: [${def.skip.map(kid).join(", ")}], orEOF: ${def.orEOF} })`;
       case "transform": {
         if (def.fnSrc === void 0) throw new Unserializable("transform without fnSrc");
-        return `_tf(${kid(def.parser)}, ${JSON.stringify(def.fnSrc)})`;
+        return `_tf(${kid(def.parser)}, ${JSON.stringify(def.fnSrc)}${def.recognitionOnly ? ", true" : ""})`;
       }
       case "node": {
         if (def.build !== void 0 && def.buildSrc === void 0) throw new Unserializable("node build without buildSrc");
@@ -6814,15 +7272,15 @@ function normalizeCstCollapse(collapse) {
   }
   return typeof collapse === "function" ? collapse : void 0;
 }
-function buildCstNode(type, children, _fields, span, _rawChildren, _triviaLog, state) {
-  return { _tag: "node", type, span: { start: span.start, end: span.end }, state: state ?? null, children: [...children] };
+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] };
 }
-function cstBuildHost(typeOrOptions, children, _fields, span, rawChildren, triviaLog, state) {
+function cstBuildHost(typeOrOptions, children2, _fields, span, rawChildren, triviaLog, state) {
   if (typeof typeOrOptions === "string") {
-    return buildCstNode(typeOrOptions, children ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state);
+    return buildCstNode(typeOrOptions, children2 ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state);
   }
   const collapse = normalizeCstCollapse(typeOrOptions?.collapse);
-  const host = (type, children2, fields, span2, rawChildren2, triviaLog2, state2) => buildCstNode(type, children2, fields, span2, rawChildren2, triviaLog2, state2);
+  const host = (type, children3, fields, span2, rawChildren2, triviaLog2, state2) => buildCstNode(type, children3, fields, span2, rawChildren2, triviaLog2, state2);
   host._parsemanCstOutput = true;
   if (collapse) host._parsemanCstCollapse = collapse;
   return host;
@@ -6905,9 +7363,12 @@ ${body}
 function isIRPiece(p) {
   return !!p && typeof p === "object" && typeof p.ir === "string" && typeof p.ns === "string" && !("ruleFns" in p);
 }
-function materializePiece(p, trivia2) {
+function materializePiece(p, trivia2, captureTerminals = false) {
   if (!isIRPiece(p)) return p;
-  const pieces = compileLinkable(evalRuleMapIR(p.ir), p.ns, trivia2 ? { trivia: trivia2 } : void 0);
+  const pieces = compileLinkable(evalRuleMapIR(p.ir), p.ns, {
+    ...trivia2 ? { trivia: trivia2 } : {},
+    ...captureTerminals ? { captureTerminals: true } : {}
+  });
   if (!pieces) throw new Error(`compose: carried IR for ns "${p.ns}" could not be re-lowered`);
   return pieces;
 }
@@ -7136,6 +7597,7 @@ var SUPPORTED = {
   word: (...a) => word(a[0], a[1]),
   sequence: (...a) => sequence(...a),
   choice: (...a) => choice(...a),
+  attempt: (...a) => attempt(a[0]),
   many: (...a) => many(a[0]),
   oneOrMore: (...a) => oneOrMore(a[0]),
   optional: (...a) => optional(a[0]),
@@ -7146,6 +7608,7 @@ var SUPPORTED = {
   field: (...a) => field(a[0], a[1]),
   noTrivia: (...a) => noTrivia(a[0]),
   token: (...a) => token(a[0]),
+  leaf: (...a) => leaf(a[0], a[1]),
   expect: (...a) => expect(a[0], a[1])
 };
 function isScopeEntry(v2) {
@@ -7245,7 +7708,7 @@ function exprToCombi(node2, scope, code, mfs) {
     if (!parserArg || !fnArg || parserArg.type === "SpreadElement" || fnArg.type === "SpreadElement") return null;
     const inner = anyValue(parserArg, scope, code, mfs);
     if (!isCombinator(inner)) return null;
-    const fnSrc = code.slice(fnArg.start, fnArg.end);
+    const fnSrc = stripTsFromSource(fnArg, code);
     mfs.push(fnSrc);
     try {
       const combi = transform(inner, (v2) => v2);
@@ -7255,6 +7718,21 @@ function exprToCombi(node2, scope, code, mfs) {
       return null;
     }
   }
+  if (callee.name === "leaf" && code !== void 0 && mfs !== void 0) {
+    const [parserArg, fnArg] = node2.arguments;
+    if (!parserArg || !fnArg || parserArg.type === "SpreadElement" || fnArg.type === "SpreadElement") return null;
+    const inner = anyValue(parserArg, scope, code, mfs);
+    if (!isCombinator(inner)) return null;
+    const fnSrc = stripTsFromSource(fnArg, code);
+    mfs.push(fnSrc);
+    try {
+      const combi = leaf(inner, (v2) => v2);
+      if (combi._def.tag === "leaf") combi._def.fnSrc = fnSrc;
+      return combi;
+    } catch {
+      return null;
+    }
+  }
   if (callee.name === "node" && code !== void 0) {
     const [firstArg, secondArg, thirdArg, fourthArg] = node2.arguments;
     if (!firstArg || firstArg.type === "SpreadElement") return null;
@@ -7707,6 +8185,63 @@ function getCompiledResolver() {
     mainFields: ["module", "main"]
   });
 }
+var PRIVATE_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts"]);
+function nearestPackageRoot(file) {
+  let dir = path.dirname(file);
+  for (; ; ) {
+    try {
+      if (fs.statSync(path.join(dir, "package.json")).isFile()) return fs.realpathSync(dir);
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function isWithinPackageRoot(file, root) {
+  const relative2 = path.relative(root, file);
+  return relative2 !== ".." && !relative2.startsWith(`..${path.sep}`) && !path.isAbsolute(relative2);
+}
+function resolvePrivateSourceModule(from, specifier) {
+  if (!specifier.startsWith(".") && !path.isAbsolute(specifier)) return null;
+  const packageRoot = nearestPackageRoot(from);
+  if (!packageRoot) return null;
+  const base = path.resolve(path.dirname(from), specifier);
+  const ext = path.extname(base);
+  const candidates = [
+    base,
+    ...ext ? [".ts", ".tsx", ".mts", ".cts"].map((next) => `${base.slice(0, -ext.length)}${next}`) : [],
+    ...!ext ? [".ts", ".tsx", ".mts", ".cts"].map((next) => `${base}${next}`) : [],
+    ...!ext ? ["index.ts", "index.tsx", "index.mts", "index.cts"].map((next) => path.join(base, next)) : []
+  ];
+  for (const candidate of candidates) {
+    try {
+      if (!fs.statSync(candidate).isFile()) continue;
+      const real = fs.realpathSync(candidate);
+      if (isWithinPackageRoot(real, packageRoot)) return real;
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveGrammarModule(from, specifier) {
+  if (PRIVATE_SOURCE_EXTENSIONS.has(path.extname(specifier))) {
+    const file2 = resolvePrivateSourceModule(from, specifier);
+    return file2 ? { file: file2, source: true } : null;
+  }
+  try {
+    const file2 = getCompiledResolver().resolveFileSync(from, specifier).path;
+    if (file2) return { file: file2, source: false };
+  } catch {
+  }
+  const file = resolvePrivateSourceModule(from, specifier);
+  return file ? { file, source: true } : null;
+}
+var _sourceLowering = /* @__PURE__ */ new Set();
+var _sourceLoweringCache = /* @__PURE__ */ new Map();
+function sourceLoweringCacheKey(file, moduleAliases, warnUnloweredRegex, recovery) {
+  return `${file}\0${[...moduleAliases].sort().join("\0")}\0${warnUnloweredRegex ? "warn" : ""}\0${recovery ? "recovery" : ""}`;
+}
 var _moduleParseCache = /* @__PURE__ */ new Map();
 function parseModuleCached(filePath) {
   let mtimeMs;
@@ -7740,7 +8275,7 @@ var plugin_default = (0, import_unplugin.createUnplugin)((opts = {}) => ({
     if (!code.includes("parseman")) return null;
     if (!code.includes("macro")) return null;
     const moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE, ...opts.moduleAliases ?? []]);
-    const result = transformMacro(code, id, moduleAliases, opts.warnUnloweredRegex === true, opts.recovery === true);
+    const result = transformMacro(code, id, moduleAliases, opts.warnUnloweredRegex === true, opts.recovery === true, opts.grammarCoverage === true);
     if (result?.warnings.length) {
       for (const w of result.warnings) {
         if (typeof this?.warn === "function") this.warn(`[parseman] ${w}`);
@@ -7844,7 +8379,34 @@ function extractImportBindings(body) {
   }
   return out;
 }
-function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE]), warnUnloweredRegex = false, recovery = false) {
+function lowerPrivateSourceModule(file, moduleAliases, warnUnloweredRegex, recovery) {
+  if (_sourceLowering.has(file)) return null;
+  let mtimeMs;
+  try {
+    mtimeMs = fs.statSync(file).mtimeMs;
+  } catch {
+    return null;
+  }
+  const cacheKey = sourceLoweringCacheKey(file, moduleAliases, warnUnloweredRegex, recovery);
+  const hit = _sourceLoweringCache.get(cacheKey);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.parsed;
+  _sourceLowering.add(file);
+  let parsedModule = null;
+  try {
+    const source = fs.readFileSync(file, "utf8");
+    const transformed = transformMacro(source, file, moduleAliases, warnUnloweredRegex, recovery);
+    if (!transformed || transformed.warnings.length > 0) return null;
+    const parsed = (0, import_oxc_parser2.parseSync)(file, transformed.code);
+    parsedModule = parsed.errors.length === 0 ? { body: parsed.program.body, src: transformed.code } : null;
+    return parsedModule;
+  } catch {
+    return null;
+  } finally {
+    _sourceLoweringCache.set(cacheKey, { mtimeMs, parsed: parsedModule });
+    _sourceLowering.delete(file);
+  }
+}
+function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE]), warnUnloweredRegex = false, recovery = false, grammarCoverage = false) {
   let result;
   try {
     result = (0, import_oxc_parser2.parseSync)(id, code);
@@ -7896,7 +8458,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     anyUnresolved = true;
     warnings.push(`${id}:${lineOf(pos)} \u2014 ${msg} (running via the interpreter; add the plugin or simplify the declaration to compile it)`);
   };
-  const compileRulesFactory = (init, label2) => {
+  const evaluateRulesFactory = (init, label2) => {
     const args = init.arguments;
     const arg0 = args[0];
     const arg1 = args[1];
@@ -7916,15 +8478,21 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       (p) => p.key?.name === "trivia"
     )?.value : void 0;
     const gTrivia = triviaValue ? evaluateExpr(triviaValue, scope, code, []) : void 0;
-    const compiled = compileRuleMap([...ruleMap], { ...gTrivia ? { trivia: gTrivia } : {}, recovery });
+    return { ruleMap, ...gTrivia ? { trivia: gTrivia } : {} };
+  };
+  const compileRulesFactory = (init, label2) => {
+    const evaluated = evaluateRulesFactory(init, label2);
+    if (!evaluated) return null;
+    const compiled = compileRuleMap([...evaluated.ruleMap], { ...evaluated.trivia ? { trivia: evaluated.trivia } : {}, recovery, coverage: grammarCoverage });
     if (!compiled) {
       warn(init.start, `${label2}: rule map couldn't be inlined`);
       return null;
     }
-    return { replacement: compiled.replacement, ruleMap, ...gTrivia ? { trivia: gTrivia } : {} };
+    return { replacement: compiled.replacement, ruleMap: evaluated.ruleMap, ...compiled.coverageDefinitions ? { coverageDefinitions: compiled.coverageDefinitions } : {}, ...evaluated.trivia ? { trivia: evaluated.trivia } : {} };
   };
   const isRulesCall = (init) => init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "rules";
   const isComposeCall = (init) => init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "compose";
+  const isComposeLeafCall = (init) => init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "composeLeaf";
   const isPickCall = (init) => init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "pick";
   const localRuleMaps = /* @__PURE__ */ new Map();
   const localGrammarTrivia = /* @__PURE__ */ new Map();
@@ -7934,18 +8502,29 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     const mapLit = (m, stripVals = false) => `new Map([${[...m].map(
       ([k, v2]) => `[${JSON.stringify(k)}, ${JSON.stringify(stripVals && typeof v2 === "string" ? stripIndent(v2) : v2)}]`
     ).join(", ")}])`;
-    return `{ ns: ${JSON.stringify(p.ns)}, keys: ${JSON.stringify(p.keys)}, prelude: ${JSON.stringify(p.prelude.map(stripIndent))}, ruleFns: ${mapLit(p.ruleFns, true)}, wrappers: ${mapLit(p.wrappers, true)}, firstSets: ${mapLit(p.firstSets)}, deps: ${mapLit(p.deps)}, needsEmptyTl: ${p.needsEmptyTl}, needsHostReads: ${p.needsHostReads}, mfFns: [], buildFns: [] }`;
+    return `{ ns: ${JSON.stringify(p.ns)}, keys: ${JSON.stringify(p.keys)}, prelude: ${JSON.stringify(p.prelude.map(stripIndent))}, ruleFns: ${mapLit(p.ruleFns, true)}, wrappers: ${mapLit(p.wrappers, true)}, firstSets: ${mapLit(p.firstSets)}, deps: ${mapLit(p.deps)}, needsEmptyTl: ${p.needsEmptyTl}, needsHostReads: ${p.needsHostReads}, hasDirectBuilders: ${p.hasDirectBuilders === true}, isRecognitionOnly: ${p.isRecognitionOnly === true}, mfFns: [], buildFns: [] }`;
   };
   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 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 })`;
+  const withCoverageDefinitions = (grammarExpr, definitions) => !grammarCoverage ? grammarExpr : `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.grammarCoverageDefinitions'), { value: Object.freeze(${JSON.stringify(definitions)}.map(Object.freeze)), enumerable: false })`;
+  const emittedCoverageDefinitions = (source) => {
+    const ids = /* @__PURE__ */ new Set();
+    for (const match of source.matchAll(/id:\s*"([^"]+)"/g)) ids.add(match[1]);
+    return [...ids].sort().map((id2) => ({
+      id: id2,
+      kind: id2.startsWith("rule:") ? "rule" : id2.startsWith("label:") ? "label" : "choice-arm"
+    }));
+  };
   const localComposedCarried = /* @__PURE__ */ new Map();
   const localComposedTrivia = /* @__PURE__ */ new Map();
   const importedPiecesCache = /* @__PURE__ */ new Map();
-  const resolveModulePieces = (file, exportName, seen) => {
-    const mod = parseModuleCached(file);
+  const resolveModulePieces = (module2, exportName, seen) => {
+    const { file } = module2;
+    const mod = module2.source ? lowerPrivateSourceModule(file, moduleAliases, warnUnloweredRegex, recovery) : parseModuleCached(file);
     if (!mod) return null;
     const localFor = exportLocalName(mod.body, exportName);
     const initNode = localFor ? topLevelInit(mod.body, localFor) : null;
@@ -7964,12 +8543,10 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       const b = imports.get(local);
       let subPieces = [];
       if (b) {
-        let subFile = null;
-        try {
-          subFile = getCompiledResolver().resolveFileSync(file, b.source).path ?? null;
-        } catch {
+        const subModule = resolveGrammarModule(file, b.source);
+        if (subModule && !seen.has(subModule.file)) {
+          subPieces = resolveModulePieces(subModule, b.imported, new Set(seen).add(subModule.file)) ?? [];
         }
-        if (subFile && !seen.has(subFile)) subPieces = resolveModulePieces(subFile, b.imported, new Set(seen).add(subFile)) ?? [];
       }
       stubNames.push(local);
       stubVals.push({ [/* @__PURE__ */ Symbol.for("parseman.composedPieces")]: subPieces });
@@ -7986,29 +8563,56 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     let result2 = null;
     const binding = importBindings.get(localName);
     if (binding) {
-      let file = null;
-      try {
-        file = getCompiledResolver().resolveFileSync(id, binding.source).path ?? null;
-      } catch {
-      }
-      result2 = file ? resolveModulePieces(file, binding.imported, /* @__PURE__ */ new Set([file])) : null;
+      const module2 = resolveGrammarModule(id, binding.source);
+      result2 = module2 ? resolveModulePieces(module2, binding.imported, /* @__PURE__ */ new Set([module2.file])) : null;
     }
     importedPiecesCache.set(localName, result2);
     return result2;
   };
-  const materializeCarried = (items, composing) => {
+  const materializeCarried = (items, composing, captureTerminals = false) => {
     const out = [];
     for (const it of items) {
       if (isSpread(it)) {
-        for (const p of importedPieces(it.__spreadLocal) ?? []) out.push(materializePiece(p, composing));
+        for (const p of importedPieces(it.__spreadLocal) ?? []) out.push(materializePiece(p, composing, captureTerminals));
       } else if (isIR(it)) {
-        out.push(materializePiece(it, composing));
+        out.push(materializePiece(it, composing, captureTerminals));
       } else {
         out.push(it);
       }
     }
     return out;
   };
+  const materializeLeafCoverage = (items, localRules, localNs, composing, captureTerminals = false) => {
+    const sources = [];
+    const add = (item) => {
+      if (!isIR(item)) return false;
+      sources.push({ ns: item.ns, rules: evalRuleMapIR(item.ir) });
+      return true;
+    };
+    for (const item of items) {
+      if (isSpread(item)) {
+        const imported = importedPieces(item.__spreadLocal);
+        if (!imported || !imported.every(add)) return null;
+      } else if (!add(item)) return null;
+    }
+    sources.push({ ns: localNs, rules: [...localRules] });
+    const winners = {};
+    for (const source of sources) for (const [name, rule] of source.rules) winners[name] = rule;
+    const plan = buildGrammarPlan(Object.values(winners), winners);
+    const pieces = [];
+    for (let index = 0; index < sources.length; index++) {
+      const source = sources[index];
+      const piece = compileLinkable(source.rules, source.ns, {
+        ...composing ? { trivia: composing } : {},
+        recovery,
+        ...index < sources.length - 1 && captureTerminals ? { captureTerminals: true } : {},
+        coverage: plan
+      });
+      if (!piece) return null;
+      pieces.push(piece);
+    }
+    return pieces;
+  };
   const localCarried = (rm, label2, composing) => {
     const entries = [...rm];
     const ns = nsFor(label2);
@@ -8124,6 +8728,64 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       return null;
     }
   };
+  const compileComposeLeafCall = (init) => {
+    const args = init.arguments;
+    const arr = args[0];
+    if (!arr || arr.type !== "ArrayExpression") {
+      warn(init.start, "composeLeaf(): expected a static array of grammars");
+      return null;
+    }
+    const elements = arr.elements;
+    if (elements.length < 2) {
+      warn(init.start, "composeLeaf(): needs imported recognition grammar(s) and one local rules() map");
+      return null;
+    }
+    const localArg = elements[elements.length - 1];
+    let localRules = null;
+    if (isRulesCall(localArg)) {
+      const evaluated = evaluateRulesFactory(localArg, `composeLeaf${init.start}`);
+      localRules = evaluated?.ruleMap ?? null;
+    } else if (localArg.type === "Identifier") {
+      localRules = localRuleMaps.get(localArg.name) ?? null;
+    }
+    if (!localRules) {
+      warn(init.start, "composeLeaf(): final argument must be a local rules() map");
+      return null;
+    }
+    const composing = composingTrivia(elements);
+    const carried = [];
+    for (let i = 0; i < elements.length - 1; i++) {
+      const r = argPieces(elements[i], `composeLeaf${init.start}_${i}`, composing);
+      if (!r) {
+        warn(init.start, `composeLeaf(): argument ${i} isn't a build-resolvable recognition grammar`);
+        return null;
+      }
+      carried.push(...r.carried);
+    }
+    try {
+      const localNs = nsFor(`composeLeaf${init.start}`);
+      const plainLocalPiece = compileLinkable([...localRules], localNs, { ...composing ? { trivia: composing } : {}, recovery });
+      if (!plainLocalPiece) {
+        warn(init.start, "composeLeaf(): local rules could not be statically compiled");
+        return null;
+      }
+      const recognitionPieces = grammarCoverage ? materializeLeafCoverage(carried, localRules, localNs, composing, plainLocalPiece.hasDirectBuilders === true) : materializeCarried(carried, composing, plainLocalPiece.hasDirectBuilders === true);
+      if (!recognitionPieces) {
+        warn(init.start, "composeLeaf(): coverage needs re-lowerable recognition IR");
+        return null;
+      }
+      const importedRecognitionPieces = grammarCoverage ? recognitionPieces.slice(0, -1) : recognitionPieces;
+      if (importedRecognitionPieces.some((piece) => piece.hasDirectBuilders !== false || piece.isRecognitionOnly !== true)) {
+        warn(init.start, "composeLeaf(): every pre-final grammar must explicitly prove recognition-only");
+        return null;
+      }
+      const replacement = withLeafMarker(emitFusedSource(grammarCoverage ? recognitionPieces : [...recognitionPieces, plainLocalPiece]));
+      return { replacement: withCoverageDefinitions(replacement, emittedCoverageDefinitions(replacement)) };
+    } 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) {
@@ -8190,7 +8852,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           const refEntry = scope.get(varName);
           const refCombi = refEntry?.combi ?? null;
           if (refCombi) {
-            const compiled2 = compile(refCombi, void 0, { recovery });
+            const compiled2 = compile(refCombi, void 0, { recovery, coverage: grammarCoverage });
             if (compiled2.inlineExpression === null) {
               warn(init.start, `"${varName}" is a ref() that couldn't be inlined (was .define() called with a static combinator?)`);
               continue;
@@ -8204,7 +8866,10 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           if (!compiledRules) continue;
           localRuleMaps.set(varName, compiledRules.ruleMap);
           if (compiledRules.trivia) localGrammarTrivia.set(varName, compiledRules.trivia);
-          let replacement = compiledRules.replacement;
+          let replacement = withCoverageDefinitions(
+            compiledRules.replacement,
+            compiledRules.coverageDefinitions?.length ? compiledRules.coverageDefinitions : emittedCoverageDefinitions(compiledRules.replacement)
+          );
           if (exportPrefix) {
             const ns = nsFor(varName);
             const pieces = compileLinkable([...compiledRules.ruleMap], ns, { recovery });
@@ -8225,7 +8890,15 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           localComposedCarried.set(varName, fused.carried);
           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 });
+          replacements.push({ start: init.start, end: init.end, replacement: withCoverageDefinitions(replacement, emittedCoverageDefinitions(replacement)) });
+          continue;
+        }
+        if (isComposeLeafCall(init)) {
+          const fused = compileComposeLeafCall(init);
+          if (!fused) {
+            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 });
           continue;
         }
         const mapFnSources = [];
@@ -8246,7 +8919,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           warn(init.start, `"${varName}" references a parseman macro import but isn't a statically-evaluable combinator`);
           continue;
         }
-        const compiled = compile(parser2, void 0, { recovery });
+        const compiled = compile(parser2, void 0, { recovery, coverage: grammarCoverage });
         if (compiled.inlineExpression === null) {
           warn(init.start, `"${varName}" couldn't be inlined (likely closes over a runtime value)`);
           continue;