parseman 0.2.0 → 0.3.1

package/dist/plugin/index.cjs

@@ -83,6 +83,51 @@ function mergeRanges(ranges) {
   return out;
 }
 
+// src/combinators/ref.ts
+function ref() {
+  let resolved = null;
+  const meta = {
+    firstSet: any(),
+    canMatchNewline: true,
+    isTrivia: false
+  };
+  const slot = {
+    _tag: "lazy",
+    _meta: meta,
+    _def: {
+      tag: "lazy",
+      thunk: () => {
+        if (!resolved) throw new Error("ref<T>() used before .define() was called");
+        return resolved;
+      }
+    },
+    parse(input, pos, ctx) {
+      if (!resolved) throw new Error("ref<T>() used before .define() was called");
+      return resolved.parse(input, pos, ctx);
+    },
+    define(p) {
+      if (resolved) throw new Error("ref<T>() already defined");
+      resolved = p;
+    }
+  };
+  return slot;
+}
+
+// src/combinators/probe.ts
+function failAt(ctx, expected, pos) {
+  const r = { ok: false, expected, span: { start: pos, end: pos } };
+  const probe = ctx._probe;
+  if (probe !== void 0 && pos <= probe.offset) {
+    const best = probe.best;
+    if (best === null || pos > best.span.start) {
+      probe.best = r;
+    } else if (pos === best.span.start) {
+      probe.best = { ...best, expected: [...best.expected, ...expected] };
+    }
+  }
+  return r;
+}
+
 // src/combinators/literal.ts
 var _collatorCache = null;
 function collator() {
@@ -112,21 +157,21 @@ function literal(value, opts = {}) {
     _tag: "literal",
     _meta: meta,
     _def: { tag: "literal", value, caseInsensitive },
-    parse(input, pos, _ctx) {
+    parse(input, pos, ctx) {
       const end = pos + value.length;
       if (end > input.length) {
-        return { ok: false, expected: [JSON.stringify(value)], span: { start: pos, end: pos } };
+        return failAt(ctx, [JSON.stringify(value)], pos);
       }
       const slice = input.slice(pos, end);
       const matched = caseInsensitive ? collator().compare(slice, value) === 0 : slice === value;
       if (matched) {
         const span = { start: pos, end };
         const leaf = { _tag: "leaf", value: slice, span };
-        if (_ctx._cstLeaves) _ctx._cstLeaves.push(leaf);
-        if (_ctx._cstRawChildren) _ctx._cstRawChildren.push(leaf);
+        if (ctx._cstLeaves) ctx._cstLeaves.push(leaf);
+        if (ctx._cstRawChildren) ctx._cstRawChildren.push(leaf);
         return { ok: true, value: slice, span };
       }
-      return { ok: false, expected: [JSON.stringify(value)], span: { start: pos, end: pos } };
+      return failAt(ctx, [JSON.stringify(value)], pos);
     }
   };
 }
@@ -141,38 +186,38 @@ function firstSetFromRegex(pattern) {
     return { firstSet: any(), canMatchNewline: true };
   }
 }
-function canBeEmpty(node) {
-  if (!node) return true;
-  switch (node.type) {
+function canBeEmpty(node2) {
+  if (!node2) return true;
+  switch (node2.type) {
     case "Repetition": {
-      const q = node.quantifier;
+      const q = node2.quantifier;
       return q.kind === "*" || q.kind === "?" || q.kind === "Range" && (q.from ?? 1) === 0;
     }
     case "Alternative": {
-      const exprs = node.expressions;
+      const exprs = node2.expressions;
       return !exprs || exprs.length === 0 || exprs.every((e) => canBeEmpty(e));
     }
     case "Group":
-      return canBeEmpty(node.expression);
+      return canBeEmpty(node2.expression);
     case "Disjunction":
-      return canBeEmpty(node.left) || canBeEmpty(node.right);
+      return canBeEmpty(node2.left) || canBeEmpty(node2.right);
     default:
       return false;
   }
 }
-function extractFirstSet(node) {
-  if (!node) return { firstSet: empty(), canMatchNewline: false };
-  switch (node.type) {
+function extractFirstSet(node2) {
+  if (!node2) return { firstSet: empty(), canMatchNewline: false };
+  switch (node2.type) {
     case "Disjunction": {
-      const left = extractFirstSet(node.left);
-      const right = extractFirstSet(node.right);
+      const left = extractFirstSet(node2.left);
+      const right = extractFirstSet(node2.right);
       return {
         firstSet: union(left.firstSet, right.firstSet),
         canMatchNewline: left.canMatchNewline || right.canMatchNewline
       };
     }
     case "Alternative": {
-      const exprs = node.expressions;
+      const exprs = node2.expressions;
       if (!exprs || exprs.length === 0) return { firstSet: empty(), canMatchNewline: false };
       let fs = empty();
       let canNL = false;
@@ -185,13 +230,13 @@ function extractFirstSet(node) {
       return { firstSet: fs, canMatchNewline: canNL };
     }
     case "Char": {
-      const kind = node.kind;
+      const kind = node2.kind;
       if (kind === "simple") {
-        const code = node.codePoint ?? node.value.codePointAt(0) ?? 0;
+        const code = node2.codePoint ?? node2.value.codePointAt(0) ?? 0;
         return { firstSet: fromRange(code, code), canMatchNewline: code === 10 };
       }
       if (kind === "meta") {
-        const val = node.value;
+        const val = node2.value;
         if (val === ".") return { firstSet: any(), canMatchNewline: false };
         if (val === "d") return { firstSet: fromRange(48, 57), canMatchNewline: false };
         if (val === "D") return { firstSet: any(), canMatchNewline: true };
@@ -208,7 +253,7 @@ function extractFirstSet(node) {
       return { firstSet: any(), canMatchNewline: true };
     }
     case "CharacterClass": {
-      const expressions = node.expressions;
+      const expressions = node2.expressions;
       let fs = empty();
       let canNL = false;
       for (const expr of expressions) {
@@ -223,14 +268,14 @@ function extractFirstSet(node) {
           canNL = canNL || r.canMatchNewline;
         }
       }
-      if (node.negative) return { firstSet: any(), canMatchNewline: true };
+      if (node2.negative) return { firstSet: any(), canMatchNewline: true };
       return { firstSet: fs, canMatchNewline: canNL };
     }
     case "Repetition": {
-      return extractFirstSet(node.expression);
+      return extractFirstSet(node2.expression);
     }
     case "Group": {
-      return extractFirstSet(node.expression);
+      return extractFirstSet(node2.expression);
     }
     default:
       return { firstSet: any(), canMatchNewline: true };
@@ -261,7 +306,7 @@ function regex(pattern, flags = "") {
       anchored.lastIndex = pos;
       const m = anchored.exec(input);
       if (m === null) {
-        return { ok: false, expected: [`/${source}/`], span: { start: pos, end: pos } };
+        return failAt(ctx, [`/${source}/`], pos);
       }
       const span = { start: pos, end: pos + m[0].length };
       const leaf = { _tag: "leaf", value: m[0], span };
@@ -272,6 +317,55 @@ function regex(pattern, flags = "") {
   };
 }
 
+// src/combinators/trivia-skip.ts
+var NOOP_COMMIT = () => {
+};
+function scanTrivia(input, cur, ctx) {
+  const triviaP = ctx.trivia;
+  if (!triviaP) return { end: cur, commit: NOOP_COMMIT };
+  const log = ctx._triviaLog;
+  if (log !== void 0) {
+    const tr2 = triviaP.parse(input, cur, { trackLines: false, state: ctx.state });
+    if (!tr2.ok || tr2.span.end === cur) return { end: cur, commit: NOOP_COMMIT };
+    const end = tr2.span.end;
+    return {
+      end,
+      commit: () => {
+        log.push(cur, end);
+      }
+    };
+  }
+  if (ctx.captureTrivia && ctx._cstRawChildren) {
+    const sink = [];
+    const tr2 = triviaP.parse(input, cur, {
+      trackLines: ctx.trackLines,
+      state: ctx.state,
+      _cstLeaves: sink
+    });
+    if (tr2.ok && tr2.span.end > cur) {
+      const out = ctx._cstRawChildren;
+      return {
+        end: tr2.span.end,
+        commit: () => {
+          for (const tok of sink) {
+            if (tok._tag === "leaf" && tok.span.end > tok.span.start) {
+              out.push({ _tag: "trivia", value: tok.value, span: tok.span });
+            }
+          }
+        }
+      };
+    }
+    return { end: cur, commit: NOOP_COMMIT };
+  }
+  const tr = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state });
+  return { end: tr.ok ? tr.span.end : cur, commit: NOOP_COMMIT };
+}
+function consumeTrivia(input, cur, ctx) {
+  const scan = scanTrivia(input, cur, ctx);
+  scan.commit();
+  return scan.end;
+}
+
 // src/combinators/sequence.ts
 function sequence(...parsers) {
   const meta = {
@@ -288,12 +382,19 @@ function sequence(...parsers) {
       let cur = pos;
       for (let i = 0; i < parsers.length; i++) {
         if (ctx.trivia && i > 0) {
-          const tr = ctx.trivia.parse(input, cur, { trivia: ctx.trivia, trackLines: ctx.trackLines, user: ctx.user });
-          if (tr.ok) {
-            if (ctx._cstRawChildren && tr.span.end > tr.span.start)
-              ctx._cstRawChildren.push({ _tag: "trivia", value: input.slice(tr.span.start, tr.span.end), span: tr.span });
-            cur = tr.span.end;
+          const scan = scanTrivia(input, cur, ctx);
+          const raw = ctx._cstRawChildren;
+          const mark = raw ? raw.length : 0;
+          scan.commit();
+          const result2 = parsers[i].parse(input, scan.end, ctx);
+          if (!result2.ok) return result2;
+          if (result2.span.end > scan.end) {
+            cur = result2.span.end;
+          } else if (raw) {
+            raw.length = mark;
           }
+          values.push(result2.value);
+          continue;
         }
         const result = parsers[i].parse(input, cur, ctx);
         if (!result.ok) return result;
@@ -394,14 +495,22 @@ function choice(...args) {
         return { ok: false, expected, span: { start: pos, end: pos } };
       }
       for (let i = 0; i < parsers.length; i++) {
-        if (gates[i] && !gates[i](ctx.user)) continue;
+        if (gates[i] && !gates[i](ctx.state)) continue;
+        const leavesLen = ctx._cstLeaves?.length;
+        const rawLen = ctx._cstRawChildren?.length;
         const result = parsers[i].parse(input, pos, ctx);
         if (!result.ok) {
+          if (leavesLen !== void 0 && ctx._cstLeaves) ctx._cstLeaves.length = leavesLen;
+          if (rawLen !== void 0 && ctx._cstRawChildren) ctx._cstRawChildren.length = rawLen;
           expected.push(...result.expected);
           continue;
         }
         const checks = autoNot[i];
-        if (checks && autoNotFires(input, result.span.end, checks)) continue;
+        if (checks && autoNotFires(input, result.span.end, checks)) {
+          if (leavesLen !== void 0 && ctx._cstLeaves) ctx._cstLeaves.length = leavesLen;
+          if (rawLen !== void 0 && ctx._cstRawChildren) ctx._cstRawChildren.length = rawLen;
+          continue;
+        }
         return result;
       }
       return { ok: false, expected, span: { start: pos, end: pos } };
@@ -532,6 +641,30 @@ function areDisjoint(sets) {
 }
 
 // src/combinators/repeat.ts
+function repItem(parser2, input, cur, ctx) {
+  const raw = ctx._cstRawChildren;
+  const mark = raw ? raw.length : 0;
+  let pos = cur;
+  if (ctx.trivia) {
+    const scan = scanTrivia(input, cur, ctx);
+    scan.commit();
+    pos = scan.end;
+  }
+  if (pos >= input.length) {
+    if (raw) raw.length = mark;
+    return "stop";
+  }
+  const result = parser2.parse(input, pos, ctx);
+  if (!result.ok) {
+    if (raw) raw.length = mark;
+    return { fail: result };
+  }
+  if (result.span.end === pos) {
+    if (raw) raw.length = mark;
+    return "stop";
+  }
+  return { value: result.value, end: result.span.end };
+}
 function many(parser2) {
   const meta = {
     firstSet: parser2._meta.firstSet,
@@ -546,11 +679,10 @@ function many(parser2) {
       const values = [];
       let cur = pos;
       while (cur < input.length) {
-        const result = parser2.parse(input, cur, ctx);
-        if (!result.ok) break;
-        if (result.span.end === cur) break;
-        values.push(result.value);
-        cur = result.span.end;
+        const item = repItem(parser2, input, cur, ctx);
+        if (item === "stop" || "fail" in item) break;
+        values.push(item.value);
+        cur = item.end;
       }
       return { ok: true, value: values, span: { start: pos, end: cur } };
     }
@@ -572,11 +704,10 @@ function oneOrMore(parser2) {
       const values = [first.value];
       let cur = first.span.end;
       while (cur < input.length) {
-        const result = parser2.parse(input, cur, ctx);
-        if (!result.ok) break;
-        if (result.span.end === cur) break;
-        values.push(result.value);
-        cur = result.span.end;
+        const item = repItem(parser2, input, cur, ctx);
+        if (item === "stop" || "fail" in item) break;
+        values.push(item.value);
+        cur = item.end;
       }
       return { ok: true, value: values, span: { start: pos, end: cur } };
     }
@@ -615,26 +746,10 @@ function sepBy(parser2, separator) {
       const values = [first.value];
       let cur = first.span.end;
       while (cur < input.length) {
-        let sepPos = cur;
-        if (ctx.trivia) {
-          const triviaCtx = { trivia: ctx.trivia, trackLines: ctx.trackLines, user: ctx.user };
-          const tr = ctx.trivia.parse(input, sepPos, triviaCtx);
-          if (tr.ok) {
-            if (ctx._cstRawChildren && tr.span.end > tr.span.start) ctx._cstRawChildren.push({ _tag: "trivia", value: input.slice(tr.span.start, tr.span.end), span: tr.span });
-            sepPos = tr.span.end;
-          }
-        }
+        const sepPos = ctx.trivia ? consumeTrivia(input, cur, ctx) : cur;
         const sep = separator.parse(input, sepPos, ctx);
         if (!sep.ok) break;
-        let nextPos = sep.span.end;
-        if (ctx.trivia) {
-          const triviaCtx = { trivia: ctx.trivia, trackLines: ctx.trackLines, user: ctx.user };
-          const tr = ctx.trivia.parse(input, nextPos, triviaCtx);
-          if (tr.ok) {
-            if (ctx._cstRawChildren && tr.span.end > tr.span.start) ctx._cstRawChildren.push({ _tag: "trivia", value: input.slice(tr.span.start, tr.span.end), span: tr.span });
-            nextPos = tr.span.end;
-          }
-        }
+        const nextPos = ctx.trivia ? consumeTrivia(input, sep.span.end, ctx) : sep.span.end;
         const next = parser2.parse(input, nextPos, ctx);
         if (!next.ok) break;
         values.push(next.value);
@@ -645,6 +760,148 @@ function sepBy(parser2, separator) {
   };
 }
 
+// src/combinators/not.ts
+function not(parser2) {
+  const meta = {
+    firstSet: any(),
+    // we don't know what NOT matches
+    canMatchNewline: false,
+    isTrivia: false
+  };
+  return {
+    _tag: "not",
+    _meta: meta,
+    _def: { tag: "not", parser: parser2 },
+    parse(input, pos, ctx) {
+      const result = parser2.parse(input, pos, ctx);
+      if (result.ok) {
+        return { ok: false, expected: [`not(${parser2._tag})`], span: { start: pos, end: pos } };
+      }
+      return { ok: true, value: null, span: { start: pos, end: pos } };
+    }
+  };
+}
+
+// src/combinators/node.ts
+function node(type, parser2, build) {
+  const meta = {
+    firstSet: parser2._meta.firstSet,
+    canMatchNewline: parser2._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "node",
+    _meta: meta,
+    _def: { tag: "node", type, parser: parser2, build },
+    parse(input, pos, ctx) {
+      const children = [];
+      const rawChildren = [];
+      const innerCtx = {
+        ...ctx,
+        // A node() always records the trivia between its terms — the library owns
+        // capture so grammar authors don't reconstruct it. (Matches the compiler.)
+        captureTrivia: true,
+        _cstChildren: children,
+        _cstLeaves: children,
+        _cstRawChildren: rawChildren
+      };
+      const r = parser2.parse(input, pos, innerCtx);
+      if (!r.ok) return r;
+      const built = build(children, rawChildren, r.span);
+      const isNodeLike = typeof built === "object" && built !== null && built._tag === "node";
+      if (ctx._cstChildren) ctx._cstChildren.push(built);
+      if (ctx._cstRawChildren) {
+        ctx._cstRawChildren.push(
+          isNodeLike ? built : { _tag: "leaf", value: typeof built === "string" ? built : "", span: r.span }
+        );
+      }
+      return { ok: true, value: built, span: r.span };
+    }
+  };
+}
+
+// src/combinators/map.ts
+function transform(parser2, fn) {
+  return {
+    _tag: "transform",
+    _meta: parser2._meta,
+    _def: { tag: "transform", parser: parser2, fn },
+    parse(input, pos, ctx) {
+      const result = parser2.parse(input, pos, ctx);
+      if (!result.ok) return result;
+      return { ...result, value: fn(result.value, result.span) };
+    }
+  };
+}
+function trivia(parser2) {
+  return {
+    _tag: parser2._tag,
+    _meta: { ...parser2._meta, isTrivia: true },
+    _def: { tag: "trivia", parser: parser2 },
+    parse: parser2.parse.bind(parser2)
+  };
+}
+
+// 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) {
+  return {
+    _tag: "grammar",
+    _meta: root._meta,
+    _def: {
+      tag: "grammar",
+      parser: root,
+      triviaParser: opts.trivia,
+      trackLines: opts.trackLines ?? false
+    },
+    parse(input, pos, _ctx) {
+      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false;
+      const ctx = {
+        ..._ctx,
+        trackLines,
+        ...opts.trivia !== void 0 ? { trivia: opts.trivia } : {},
+        ...opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {}
+      };
+      const result = root.parse(input, pos ?? 0, ctx);
+      if (trackLines) {
+        const idx = buildLineIndex(input);
+        return { ...result, span: annotateSpan(result.span, idx) };
+      }
+      return result;
+    }
+  };
+}
+
 // src/compiler/codegen.ts
 function v(ctx, prefix = "_v") {
   return `${prefix}${ctx.vars++}`;
@@ -652,9 +909,58 @@ function v(ctx, prefix = "_v") {
 function ind(ctx) {
   return "  ".repeat(ctx.indent);
 }
+function emitLeafCapture(ctx, valExpr, startExpr, endExpr) {
+  if (!ctx.capturing) return [];
+  const i = ind(ctx);
+  if (ctx.capAsTrivia) {
+    return [`${i}if (_ctx._cstRawChildren) _ctx._cstRawChildren.push({ _tag: 'trivia', value: ${valExpr}, span: { start: ${startExpr}, end: ${endExpr} } })`];
+  }
+  const lf = v(ctx, "_lf");
+  return [
+    `${i}if (_ctx._cstLeaves) {`,
+    `${i}  const ${lf} = { _tag: 'leaf', value: ${valExpr}, span: { start: ${startExpr}, end: ${endExpr} } }`,
+    `${i}  _ctx._cstLeaves.push(${lf})`,
+    `${i}  if (_ctx._cstRawChildren) _ctx._cstRawChildren.push(${lf})`,
+    `${i}}`
+  ];
+}
+function ensureTriviaCaptureFn(ctx) {
+  const trivia2 = ctx.activeTrivia;
+  const existing = ctx.triviaCaptureNames.get(trivia2);
+  if (existing) return existing;
+  const fnName = `_tc${ctx.triviaCaptureNames.size}`;
+  ctx.triviaCaptureNames.set(trivia2, fnName);
+  const saved = { indent: ctx.indent, failLabel: ctx.failLabel, asTrivia: ctx.capAsTrivia, trivia: ctx.activeTrivia };
+  ctx.indent = 2;
+  ctx.failLabel = "_cap";
+  ctx.capAsTrivia = true;
+  delete ctx.activeTrivia;
+  const r = emit(trivia2, ctx, "_pos");
+  ctx.indent = saved.indent;
+  ctx.failLabel = saved.failLabel;
+  ctx.capAsTrivia = saved.asTrivia;
+  if (saved.trivia) ctx.activeTrivia = saved.trivia;
+  ctx.namedFnDecls.push([
+    `function ${fnName}(input, _pos, _ctx) {`,
+    `  let _e = _pos`,
+    `  _cap: {`,
+    ...r.stmts,
+    `    _e = ${r.endVar}`,
+    `  }`,
+    `  if (_ctx._triviaLog !== undefined && _e > _pos) _ctx._triviaLog.push(_pos, _e)`,
+    `  return _e`,
+    `}`
+  ].join("\n"));
+  return fnName;
+}
 function failStmt(ctx, expected, posExpr) {
+  if (ctx.failLabel) return `${ind(ctx)}break ${ctx.failLabel}`;
   return `${ind(ctx)}return { ok: false, expected: [${expected}], span: { start: ${posExpr}, end: ${posExpr} } }`;
 }
+function failArr(ctx, expectedArr, posExpr) {
+  if (ctx.failLabel) return `${ind(ctx)}break ${ctx.failLabel}`;
+  return `${ind(ctx)}return { ok: false, expected: ${expectedArr}, span: { start: ${posExpr}, end: ${posExpr} } }`;
+}
 function firstSetCond(codeVar, fs) {
   if (fs.kind === "any") return "true";
   if (fs.kind === "empty") return "false";
@@ -670,6 +976,30 @@ function asIIFE(stmts, valueVar, endVar, startPos, indent) {
     `${indent}})()`
   ].join("\n");
 }
+function emitFallible(inner, ctx, pos) {
+  const lbl = v(ctx, "_lbl");
+  const okV = `${lbl}ok`;
+  const valV = `${lbl}v`;
+  const endV = `${lbl}e`;
+  const savedLabel = ctx.failLabel;
+  const savedIndent = ctx.indent;
+  ctx.failLabel = lbl;
+  ctx.indent = 0;
+  const r = emit(inner, ctx, pos);
+  ctx.failLabel = savedLabel;
+  ctx.indent = savedIndent;
+  const ind0 = ind(ctx);
+  const stmts = [
+    `${ind0}let ${okV} = false, ${valV}, ${endV} = ${pos}`,
+    `${ind0}${lbl}: {`,
+    ...r.stmts,
+    `${ind0}  ${valV} = ${r.valueVar}`,
+    `${ind0}  ${endV} = ${r.endVar}`,
+    `${ind0}  ${okV} = true`,
+    `${ind0}}`
+  ];
+  return { stmts, okVar: okV, valVar: valV, endVar: endV };
+}
 function emitLit(def, ctx, pos) {
   const { value, caseInsensitive } = def;
   const len = value.length;
@@ -707,12 +1037,19 @@ function emitLit(def, ctx, pos) {
       `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`
     );
   }
-  return { stmts, valueVar: vv, endVar: len === 0 ? pos : `${pos} + ${len}` };
+  const endVar = len === 0 ? pos : `${pos} + ${len}`;
+  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar));
+  return { stmts, valueVar: vv, endVar };
 }
 function emitRegex(def, ctx, pos) {
   const flags = "y" + def.flags.replace(/[gy]/g, "");
-  const rName = `_re${ctx.regexDecls.length}`;
-  ctx.regexDecls.push(`const ${rName} = /${def.optimizedSource}/${flags}`);
+  const key = `${def.optimizedSource}/${flags}`;
+  let rName = ctx.regexMap.get(key);
+  if (rName === void 0) {
+    rName = `_re${ctx.regexDecls.length}`;
+    ctx.regexDecls.push(`const ${rName} = /${def.optimizedSource}/${flags}`);
+    ctx.regexMap.set(key, rName);
+  }
   const mv = v(ctx, "_m");
   const vv = v(ctx);
   const expectedStr = JSON.stringify(`/${def.source}/`);
@@ -722,7 +1059,9 @@ function emitRegex(def, ctx, pos) {
     `${ind(ctx)}if (${mv} === null) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,
     `${ind(ctx)}const ${vv} = ${mv}[0]`
   ];
-  return { stmts, valueVar: vv, endVar: `${pos} + ${vv}.length` };
+  const endVar = `${pos} + ${vv}.length`;
+  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar));
+  return { stmts, valueVar: vv, endVar };
 }
 function ensureTriviaFn(ctx) {
   const trivia2 = ctx.activeTrivia;
@@ -730,9 +1069,15 @@ function ensureTriviaFn(ctx) {
     const fnName = `_pf${ctx.namedParsers.size}`;
     ctx.namedParsers.set(trivia2, fnName);
     const savedIndent = ctx.indent;
+    const savedFailLabel = ctx.failLabel;
+    const savedTrivia = ctx.activeTrivia;
     ctx.indent = 1;
+    ctx.failLabel = void 0;
+    delete ctx.activeTrivia;
     const r = emit(trivia2, ctx, "_pos");
     ctx.indent = savedIndent;
+    ctx.failLabel = savedFailLabel;
+    if (savedTrivia) ctx.activeTrivia = savedTrivia;
     ctx.namedFnDecls.push([
       `function ${fnName}(input, _pos, _ctx) {`,
       ...r.stmts,
@@ -752,12 +1097,17 @@ function emitSeq(def, ctx, pos) {
   const valueVars = [];
   for (let i = 0; i < def.parsers.length; i++) {
     if (i > 0 && ctx.activeTrivia) {
-      const trivFn = ensureTriviaFn(ctx);
-      const tmp = v(ctx, "_trv");
-      stmts.push(
-        `${ind(ctx)}const ${tmp} = ${trivFn}(input, ${curV}, _ctx)`,
-        `${ind(ctx)}if (${tmp}.ok) ${curV} = ${tmp}.span.end`
-      );
+      if (ctx.capturing) {
+        const capFn = ensureTriviaCaptureFn(ctx);
+        stmts.push(`${ind(ctx)}${curV} = ${capFn}(input, ${curV}, _ctx)`);
+      } else {
+        const trivFn = ensureTriviaFn(ctx);
+        const tmp = v(ctx, "_trv");
+        stmts.push(
+          `${ind(ctx)}const ${tmp} = ${trivFn}(input, ${curV}, _ctx)`,
+          `${ind(ctx)}if (${tmp}.ok) ${curV} = ${tmp}.span.end`
+        );
+      }
     }
     const r = emit(def.parsers[i], ctx, curV);
     stmts.push(...r.stmts, `${ind(ctx)}${curV} = ${r.endVar}`);
@@ -797,9 +1147,7 @@ function emitChoice(def, ctx, pos) {
       ctx.indent--;
       stmts.push(`${ind(ctx)}}`);
     }
-    stmts.push(
-      `${ind(ctx)}else return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`
-    );
+    stmts.push(`${ind(ctx)}else ${failArr({ ...ctx, indent: 0 }, allExpected, pos)}`);
     return { stmts, valueVar: valV, endVar: endV };
   }
   return emitNonDisjoint(def, def.strategy, allExpected, ctx, pos);
@@ -807,17 +1155,21 @@ function emitChoice(def, ctx, pos) {
 function emitGreedyClassify(def, superIndex, allExpected, ctx, pos) {
   const superParser = def.parsers[superIndex];
   const regexDef = getCoreRegexDef(superParser);
-  const reIdx = ctx.regexDecls.length;
-  const reVar = `_re${reIdx}`;
   const cleanFlags = "y" + regexDef.flags.replace(/[gy]/g, "");
-  ctx.regexDecls.push(`const ${reVar} = /${regexDef.source}/${cleanFlags}`);
+  const reKey = `${regexDef.source}/${cleanFlags}`;
+  let reVar = ctx.regexMap.get(reKey);
+  if (reVar === void 0) {
+    reVar = `_re${ctx.regexDecls.length}`;
+    ctx.regexDecls.push(`const ${reVar} = /${regexDef.source}/${cleanFlags}`);
+    ctx.regexMap.set(reKey, reVar);
+  }
   const matchV = v(ctx, "_gm");
   const wordV = v(ctx, "_gw");
   const endV = v(ctx, "_ge");
   const stmts = [
     `${ind(ctx)}${reVar}.lastIndex = ${pos}`,
     `${ind(ctx)}const ${matchV} = ${reVar}.exec(input)`,
-    `${ind(ctx)}if (${matchV} === null) return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`,
+    `${ind(ctx)}if (${matchV} === null) ${failArr({ ...ctx, indent: 0 }, allExpected, pos)}`,
     `${ind(ctx)}const ${wordV} = ${matchV}[0]`,
     `${ind(ctx)}const ${endV} = ${pos} + ${wordV}.length`
   ];
@@ -857,7 +1209,7 @@ function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos) {
     ctx.indent--;
     stmts.push(`${ind(ctx)}}`);
   }
-  stmts.push(`${ind(ctx)}else return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`);
+  stmts.push(`${ind(ctx)}else ${failArr({ ...ctx, indent: 0 }, allExpected, pos)}`);
   return { stmts, valueVar: valV, endVar: endV };
 }
 function emitFirstMatch(def, allExpected, ctx, pos) {
@@ -868,40 +1220,60 @@ function emitFirstMatch(def, allExpected, ctx, pos) {
     const gate = def.gates[i];
     const autoNot = def.autoNot[i];
     const savedIndent = ctx.indent;
+    const savedFailLabel = ctx.failLabel;
     ctx.indent = 0;
+    ctx.failLabel = void 0;
     const r = emit(p, ctx, pos);
     ctx.indent = savedIndent;
+    ctx.failLabel = savedFailLabel;
     const iife = asIIFE(r.stmts, r.valueVar, r.endVar, pos, ind(ctx));
     let gateCond = null;
     if (gate) {
       const gateIdx = ctx.mapFns.length;
       ctx.mapFns.push(gate);
-      gateCond = `_mf[${gateIdx}](_ctx.user)`;
+      gateCond = `_mf[${gateIdx}](_ctx.state)`;
     }
     const skipCond = gateCond ? `!${resV}?.ok && ${gateCond}` : `!${resV}?.ok`;
+    const markLeaves = ctx.capturing ? v(ctx, "_cml") : null;
+    const markRaw = ctx.capturing ? v(ctx, "_cmr") : null;
+    const rollback = markLeaves ? `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLeaves}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markRaw}` : "";
+    const markStmts = markLeaves ? [
+      `${ind(ctx)}  const ${markLeaves} = _ctx._cstLeaves?.length ?? 0`,
+      `${ind(ctx)}  const ${markRaw} = _ctx._cstRawChildren?.length ?? 0`
+    ] : [];
+    const rollbackStmt = rollback ? `${ind(ctx)}  if (!${resV}?.ok) { ${rollback} }` : "";
     if (autoNot && autoNot.length > 0) {
       const tmp = v(ctx, "_ct");
       const anCode = v(ctx, "_anc");
       const rejectCond = autoNot.map(
         (check) => check.kind === "firstSet" ? firstSetCond(anCode, check.set) : `input.startsWith(${JSON.stringify(check.value)}, ${tmp}.span.end)`
       ).join(" || ");
+      stmts.push(`${ind(ctx)}if (${skipCond}) {`);
+      stmts.push(...markStmts);
       stmts.push(
-        `${ind(ctx)}if (${skipCond}) { const ${tmp} = (() => { try { return ${iife} } catch {} })(); if (${tmp}?.ok) { const ${anCode} = ${tmp}.span.end < input.length ? input.charCodeAt(${tmp}.span.end) : -1; if (!(${rejectCond})) ${resV} = ${tmp} } }`
+        `${ind(ctx)}  const ${tmp} = (() => { try { return ${iife} } catch {} })()`,
+        `${ind(ctx)}  if (${tmp}?.ok) { const ${anCode} = ${tmp}.span.end < input.length ? input.charCodeAt(${tmp}.span.end) : -1; if (!(${rejectCond})) ${resV} = ${tmp} }`
       );
+      if (rollbackStmt) stmts.push(rollbackStmt);
+      stmts.push(`${ind(ctx)}}`);
     } else {
-      stmts.push(`${ind(ctx)}if (${skipCond}) { try { ${resV} = ${iife} } catch {} }`);
+      stmts.push(`${ind(ctx)}if (${skipCond}) {`);
+      stmts.push(...markStmts);
+      stmts.push(`${ind(ctx)}  try { ${resV} = ${iife} } catch {}`);
+      if (rollbackStmt) stmts.push(rollbackStmt);
+      stmts.push(`${ind(ctx)}}`);
     }
   }
-  stmts.push(
-    `${ind(ctx)}if (!${resV}?.ok) return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`
-  );
+  stmts.push(`${ind(ctx)}if (!${resV}?.ok) ${failArr({ ...ctx, indent: 0 }, allExpected, pos)}`);
   return { stmts, valueVar: `${resV}.value`, endVar: `${resV}.span.end` };
 }
 function emitNonDisjoint(def, strategy, allExpected, ctx, pos) {
-  if (strategy.tag === "greedyClassify")
-    return emitGreedyClassify(def, strategy.superIndex, allExpected, ctx, pos);
-  if (strategy.tag === "literalsLongestFirst")
-    return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos);
+  if (!ctx.capturing) {
+    if (strategy.tag === "greedyClassify")
+      return emitGreedyClassify(def, strategy.superIndex, allExpected, ctx, pos);
+    if (strategy.tag === "literalsLongestFirst")
+      return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos);
+  }
   return emitFirstMatch(def, allExpected, ctx, pos);
 }
 function emitTransformChain(p, baseValue, endV, startPos, ctx) {
@@ -910,6 +1282,7 @@ function emitTransformChain(p, baseValue, endV, startPos, ctx) {
     const innerR = emitTransformChain(def.parser, baseValue, endV, startPos, ctx);
     const fnIdx = ctx.mapFns.length;
     ctx.mapFns.push(def.fn);
+    ctx.mapFnSrcs.push(def.fnSrc ?? null);
     const vv = v(ctx);
     return {
       stmts: [...innerR.stmts, `${ind(ctx)}const ${vv} = _mf[${fnIdx}](${innerR.valueVar}, { start: ${startPos}, end: ${endV} })`],
@@ -937,13 +1310,6 @@ function emitMany(def, ctx, pos) {
     `${ind(ctx)}const ${arrV} = []`,
     `${ind(ctx)}let ${curV} = ${pos}`
   ];
-  const emitInnerIIFE = () => {
-    const savedIndent = ctx.indent;
-    ctx.indent = 0;
-    const r = emit(def.parser, ctx, curV);
-    ctx.indent = savedIndent;
-    return asIIFE(r.stmts, r.valueVar, r.endVar, curV, ind(ctx) + "  ");
-  };
   if (def.min === 1) {
     const firstR = emit(def.parser, ctx, curV);
     stmts.push(...firstR.stmts);
@@ -954,11 +1320,35 @@ function emitMany(def, ctx, pos) {
   }
   stmts.push(`${ind(ctx)}while (${curV} < input.length) {`);
   ctx.indent++;
+  let itemPos = curV;
+  let rollback = "";
+  if (ctx.activeTrivia) {
+    if (ctx.capturing) {
+      const capFn = ensureTriviaCaptureFn(ctx);
+      const markV = v(ctx, "_mk");
+      const npV = v(ctx, "_np");
+      stmts.push(
+        `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,
+        `${ind(ctx)}const ${npV} = ${capFn}(input, ${curV}, _ctx)`
+      );
+      itemPos = npV;
+      rollback = `if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; `;
+    } else {
+      const trivFn = ensureTriviaFn(ctx);
+      const npV = v(ctx, "_np");
+      stmts.push(
+        `${ind(ctx)}let ${npV} = ${curV}`,
+        `${ind(ctx)}{ const _trv = ${trivFn}(input, ${npV}, _ctx); if (_trv.ok) ${npV} = _trv.span.end }`
+      );
+      itemPos = npV;
+    }
+  }
+  const { stmts: iterStmts, okVar: iterOk, valVar: iterVal, endVar: iterEnd } = emitFallible(def.parser, ctx, itemPos);
   stmts.push(
-    `${ind(ctx)}const _iter = (() => { try { return ${emitInnerIIFE()} } catch { return null } })()`,
-    `${ind(ctx)}if (!_iter?.ok || _iter.span.end === ${curV}) break`,
-    `${ind(ctx)}${arrV}.push(_iter.value)`,
-    `${ind(ctx)}${curV} = _iter.span.end`
+    ...iterStmts,
+    `${ind(ctx)}if (!${iterOk} || ${iterEnd} === ${curV}) { ${rollback}break }`,
+    `${ind(ctx)}${arrV}.push(${iterVal})`,
+    `${ind(ctx)}${curV} = ${iterEnd}`
   );
   ctx.indent--;
   stmts.push(`${ind(ctx)}}`);
@@ -967,56 +1357,80 @@ function emitMany(def, ctx, pos) {
 function emitOptional(def, ctx, pos) {
   const valV = v(ctx, "_opt");
   const endV = v(ctx, "_opte");
-  const savedIndent = ctx.indent;
-  ctx.indent = 0;
-  const r = emit(def.parser, ctx, pos);
-  ctx.indent = savedIndent;
-  const iife = asIIFE(r.stmts, r.valueVar, r.endVar, pos, ind(ctx));
-  const resV = v(ctx, "_optr");
+  const { stmts: lblStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos);
+  const ind0 = ind(ctx);
   const stmts = [
-    `${ind(ctx)}const ${resV} = (() => { try { return ${iife} } catch { return null } })()`,
-    `${ind(ctx)}const ${valV} = ${resV}?.ok ? ${resV}.value : null`,
-    `${ind(ctx)}const ${endV} = ${resV}?.ok ? ${resV}.span.end : ${pos}`
+    ...lblStmts,
+    `${ind0}const ${valV} = ${okVar} ? ${valVar} : null`,
+    `${ind0}const ${endV} = ${okVar} ? ${endVar} : ${pos}`
   ];
   return { stmts, valueVar: valV, endVar: endV };
 }
 function emitSepBy(_p, def, ctx, pos) {
   const arrV = v(ctx, "_arr");
   const curV = v(ctx, "_cur");
-  const iife = (inner, posExpr) => {
-    const saved = ctx.indent;
-    ctx.indent = 0;
-    const r = emit(inner, ctx, posExpr);
-    ctx.indent = saved;
-    return asIIFE(r.stmts, r.valueVar, r.endVar, posExpr, ind(ctx));
-  };
-  const firstR_saved = ctx.indent;
-  ctx.indent = 0;
-  const firstR = emit(def.parser, ctx, pos);
-  ctx.indent = firstR_saved;
-  const firstV = v(ctx, "_sb0");
-  const sepV = v(ctx, "_sbs");
-  const nextV = v(ctx, "_sbn");
+  const { stmts: firstStmts, okVar: firstOk, valVar: firstVal, endVar: firstEnd } = emitFallible(def.parser, ctx, pos);
   const stmts = [
     `${ind(ctx)}const ${arrV} = []`,
     `${ind(ctx)}let ${curV} = ${pos}`,
-    `${ind(ctx)}const ${firstV} = (() => { try { return ${asIIFE(firstR.stmts, firstR.valueVar, firstR.endVar, pos, ind(ctx))} } catch { return null } })()`,
-    `${ind(ctx)}if (${firstV}?.ok) {`
+    ...firstStmts,
+    `${ind(ctx)}if (${firstOk}) {`
   ];
   ctx.indent++;
   stmts.push(
-    `${ind(ctx)}${arrV}.push(${firstV}.value)`,
-    `${ind(ctx)}${curV} = ${firstV}.span.end`,
+    `${ind(ctx)}${arrV}.push(${firstVal})`,
+    `${ind(ctx)}${curV} = ${firstEnd}`,
     `${ind(ctx)}while (${curV} < input.length) {`
   );
   ctx.indent++;
+  let rollback = "";
+  if (ctx.capturing) {
+    const markV = v(ctx, "_mk");
+    stmts.push(`${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`);
+    rollback = `if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; `;
+  }
+  let sepAtPos = curV;
+  if (ctx.activeTrivia) {
+    if (ctx.capturing) {
+      const capFn = ensureTriviaCaptureFn(ctx);
+      const spV = v(ctx, "_sp");
+      stmts.push(`${ind(ctx)}const ${spV} = ${capFn}(input, ${curV}, _ctx)`);
+      sepAtPos = spV;
+    } else {
+      const trivFn = ensureTriviaFn(ctx);
+      const spV = v(ctx, "_sp");
+      stmts.push(
+        `${ind(ctx)}let ${spV} = ${curV}`,
+        `${ind(ctx)}{ const _trv = ${trivFn}(input, ${spV}, _ctx); if (_trv.ok) ${spV} = _trv.span.end }`
+      );
+      sepAtPos = spV;
+    }
+  }
+  const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos);
+  stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollback}break }`);
+  let nextAtPos = sepEnd;
+  if (ctx.activeTrivia) {
+    if (ctx.capturing) {
+      const capFn = ensureTriviaCaptureFn(ctx);
+      const npV = v(ctx, "_np");
+      stmts.push(`${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx)`);
+      nextAtPos = npV;
+    } else {
+      const trivFn = ensureTriviaFn(ctx);
+      const npV = v(ctx, "_np");
+      stmts.push(
+        `${ind(ctx)}let ${npV} = ${sepEnd}`,
+        `${ind(ctx)}{ const _trv = ${trivFn}(input, ${npV}, _ctx); if (_trv.ok) ${npV} = _trv.span.end }`
+      );
+      nextAtPos = npV;
+    }
+  }
+  const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, nextAtPos);
   stmts.push(
-    `${ind(ctx)}const ${sepV} = (() => { try { return ${iife(def.separator, curV)} } catch { return null } })()`,
-    `${ind(ctx)}if (!${sepV}?.ok) break`,
-    `${ind(ctx)}const ${nextV} = (() => { try { return ${iife(def.parser, `${sepV}.span.end`)} } catch { return null } })()`,
-    `${ind(ctx)}if (!${nextV}?.ok) break`,
-    `${ind(ctx)}${arrV}.push(${nextV}.value)`,
-    `${ind(ctx)}${curV} = ${nextV}.span.end`
+    ...nextStmts,
+    `${ind(ctx)}if (!${nextOk}) { ${rollback}break }`,
+    `${ind(ctx)}${arrV}.push(${nextVal})`,
+    `${ind(ctx)}${curV} = ${nextEnd}`
   );
   ctx.indent--;
   stmts.push(`${ind(ctx)}}`);
@@ -1025,13 +1439,6 @@ function emitSepBy(_p, def, ctx, pos) {
   return { stmts, valueVar: arrV, endVar: curV };
 }
 function emitScanTo(def, ctx, pos) {
-  const safeIIFE = (inner, posExpr) => {
-    const saved = ctx.indent;
-    ctx.indent = 0;
-    const r = emit(inner, ctx, posExpr);
-    ctx.indent = saved;
-    return `(() => { try { return ${asIIFE(r.stmts, r.valueVar, r.endVar, posExpr, ind(ctx))} } catch { return null } })()`;
-  };
   const curV = v(ctx, "_stcur");
   const foundV = v(ctx, "_stfnd");
   const stmts = [
@@ -1040,18 +1447,19 @@ function emitScanTo(def, ctx, pos) {
     `${ind(ctx)}while (${curV} < input.length) {`
   ];
   ctx.indent++;
-  const sentV = v(ctx, "_sts");
-  stmts.push(
-    `${ind(ctx)}const ${sentV} = ${safeIIFE(def.sentinel, curV)}`,
-    `${ind(ctx)}if (${sentV}?.ok) { ${foundV} = true; break }`
-  );
+  const probeCtx = { ...ctx, capturing: false };
+  const { stmts: sentStmts, okVar: sentOk } = emitFallible(def.sentinel, probeCtx, curV);
+  stmts.push(...sentStmts, `${ind(ctx)}if (${sentOk}) { ${foundV} = true; break }`);
   if (def.skip.length > 0) {
     const advV = v(ctx, "_stadv");
     stmts.push(`${ind(ctx)}let ${advV} = false`);
     for (const skipper of def.skip) {
-      const skV = v(ctx, "_sk");
+      const { stmts: skStmts, okVar: skOk, endVar: skEnd } = emitFallible(skipper, probeCtx, curV);
       stmts.push(
-        `${ind(ctx)}if (!${advV}) { const ${skV} = ${safeIIFE(skipper, curV)}; if (${skV}?.ok && ${skV}.span.end > ${curV}) { ${curV} = ${skV}.span.end; ${advV} = true } }`
+        `${ind(ctx)}if (!${advV}) {`,
+        ...skStmts,
+        `${ind(ctx)}  if (${skOk} && ${skEnd} > ${curV}) { ${curV} = ${skEnd}; ${advV} = true }`,
+        `${ind(ctx)}}`
       );
     }
     stmts.push(`${ind(ctx)}if (!${advV}) ${curV}++`);
@@ -1063,14 +1471,54 @@ function emitScanTo(def, ctx, pos) {
   if (!def.orEOF) {
     const sentDef = def.sentinel._def;
     const expectedStr = sentDef.tag === "literal" ? JSON.stringify([JSON.stringify(sentDef.value)]) : `["sentinel"]`;
-    stmts.push(
-      `${ind(ctx)}if (!${foundV}) return { ok: false, expected: ${expectedStr}, span: { start: ${pos}, end: ${curV} } }`
-    );
+    stmts.push(`${ind(ctx)}if (!${foundV}) ${failArr({ ...ctx, indent: 0 }, expectedStr, pos)}`);
   }
   const valV = v(ctx);
   stmts.push(`${ind(ctx)}const ${valV} = input.slice(${pos}, ${curV})`);
+  if (ctx.capturing) {
+    const cap = emitLeafCapture(ctx, valV, pos, curV).map((s) => "  " + s);
+    stmts.push(`${ind(ctx)}if (${curV} > ${pos}) {`, ...cap, `${ind(ctx)}}`);
+  }
   return { stmts, valueVar: valV, endVar: curV };
 }
+function emitNot(def, ctx, pos) {
+  const { stmts, okVar } = emitFallible(def.parser, ctx, pos);
+  return {
+    stmts: [
+      ...stmts,
+      `${ind(ctx)}if (${okVar}) ${failStmt({ ...ctx, indent: 0 }, '"not"', pos).trim()}`
+    ],
+    valueVar: "null",
+    endVar: pos
+  };
+}
+function emitNode(def, ctx, pos) {
+  const fnIdx = ctx.buildFns.length;
+  ctx.buildFns.push(def.build);
+  ctx.buildSrcs.push(def.buildSrc ?? null);
+  const i = ind(ctx);
+  const chV = v(ctx, "_ch");
+  const rawV = v(ctx, "_raw");
+  const sc = v(ctx, "_sc"), sl = v(ctx, "_sl"), sr = v(ctx, "_sr"), st = v(ctx, "_st");
+  const stmts = [
+    `${i}const ${chV} = [], ${rawV} = []`,
+    `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${st} = _ctx.captureTrivia`,
+    `${i}_ctx._cstChildren = ${chV}; _ctx._cstLeaves = ${chV}; _ctx._cstRawChildren = ${rawV}; _ctx.captureTrivia = true`
+  ];
+  const { stmts: innerStmts, okVar, endVar } = emitFallible(def.parser, ctx, pos);
+  stmts.push(...innerStmts);
+  stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx.captureTrivia = ${st}`);
+  stmts.push(`${i}if (!${okVar}) ${failStmt({ ...ctx, indent: 0 }, '"node"', pos).trim()}`);
+  const ndV = v(ctx, "_nd");
+  stmts.push(
+    `${i}const ${ndV} = _build[${fnIdx}](${chV}, ${rawV}, { start: ${pos}, end: ${endVar} })`,
+    // Record into the caller's collectors (the node in children; the node, or a
+    // spanned leaf if build collapsed to a non-node value, in rawChildren).
+    `${i}if (${sc}) ${sc}.push(${ndV})`,
+    `${i}if (${sr}) ${sr}.push((typeof ${ndV} === 'object' && ${ndV} !== null && ${ndV}._tag === 'node') ? ${ndV} : { _tag: 'leaf', value: typeof ${ndV} === 'string' ? ${ndV} : '', span: { start: ${pos}, end: ${endVar} } })`
+  );
+  return { stmts, valueVar: ndV, endVar };
+}
 function emitRuntimeFallback(parser2, ctx, pos) {
   const idx = ctx.runtimeParsers.length;
   ctx.runtimeParsers.push(parser2);
@@ -1079,7 +1527,7 @@ function emitRuntimeFallback(parser2, ctx, pos) {
   const ev = v(ctx, "_rte");
   const stmts = [
     `${ind(ctx)}const ${rv} = _rp[${idx}].parse(input, ${pos}, _ctx)`,
-    `${ind(ctx)}if (!${rv}.ok) return ${rv}`,
+    `${ind(ctx)}if (!${rv}.ok) ${failStmt({ ...ctx, indent: 0 }, '"runtime"', pos).trim()}`,
     `${ind(ctx)}const ${vv} = ${rv}.value`,
     `${ind(ctx)}const ${ev} = ${rv}.span.end`
   ];
@@ -1097,9 +1545,12 @@ function emitLazy(p, def, ctx, pos) {
       return emitRuntimeFallback(p, ctx, pos);
     }
     const savedIndent = ctx.indent;
+    const savedFailLabel = ctx.failLabel;
     ctx.indent = 1;
+    ctx.failLabel = void 0;
     const r = emit(resolved, ctx, "_pos");
     ctx.indent = savedIndent;
+    ctx.failLabel = savedFailLabel;
     ctx.namedFnDecls.push([
       `function ${fnName2}(input, _pos, _ctx) {`,
       ...r.stmts,
@@ -1114,7 +1565,7 @@ function emitLazy(p, def, ctx, pos) {
   return {
     stmts: [
       `${ind(ctx)}const ${rv} = ${fnName}(input, ${pos}, _ctx)`,
-      `${ind(ctx)}if (!${rv}.ok) return ${rv}`,
+      `${ind(ctx)}if (!${rv}.ok) ${failStmt({ ...ctx, indent: 0 }, '"parser"', pos).trim()}`,
       `${ind(ctx)}const ${vv} = ${rv}.value`,
       `${ind(ctx)}const ${ev} = ${rv}.span.end`
     ],
@@ -1122,6 +1573,33 @@ function emitLazy(p, def, ctx, pos) {
     endVar: ev
   };
 }
+function emitRecover(def, ctx, pos) {
+  const { stmts: innerStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos);
+  const ind0 = ind(ctx);
+  const scanV = v(ctx, "_sc");
+  const errV = v(ctx, "_err");
+  const savedIndent = ctx.indent;
+  ctx.indent += 2;
+  const { stmts: sentStmts, okVar: sentOk } = emitFallible(def.sentinel, ctx, scanV);
+  ctx.indent = savedIndent;
+  const stmts = [
+    ...innerStmts,
+    `${ind0}if (!${okVar}) {`,
+    `${ind0}  let ${scanV} = ${pos}`,
+    `${ind0}  while (${scanV} < input.length) {`,
+    ...sentStmts,
+    `${ind0}    if (${sentOk}) break`,
+    `${ind0}    ${scanV}++`,
+    `${ind0}  }`,
+    `${ind0}  const ${errV} = { _tag: 'parseError', span: { start: ${pos}, end: ${scanV} }, expected: [] }`,
+    `${ind0}  if (_ctx._errors) _ctx._errors.push(${errV})`,
+    `${ind0}  ${valVar} = ${errV}`,
+    `${ind0}  ${endVar} = ${scanV}`,
+    `${ind0}  ${okVar} = true`,
+    `${ind0}}`
+  ];
+  return { stmts, valueVar: valVar, endVar };
+}
 function emit(p, ctx, pos) {
   const def = p._def;
   switch (def.tag) {
@@ -1144,6 +1622,7 @@ function emit(p, ctx, pos) {
       const inner = emit(def.parser, ctx, pos);
       const fnIdx = ctx.mapFns.length;
       ctx.mapFns.push(def.fn);
+      ctx.mapFnSrcs.push(def.fnSrc ?? null);
       const mv = v(ctx, "_mapped");
       return {
         stmts: [
@@ -1184,15 +1663,21 @@ function emit(p, ctx, pos) {
       else ctx.activeTrivia = savedTrivia;
       return r;
     }
+    case "not":
+      return emitNot(def, ctx, pos);
+    case "node":
+      return emitNode(def, ctx, pos);
     case "scanTo":
       return emitScanTo(def, ctx, pos);
+    case "recover":
+      return emitRecover(def, ctx, pos);
     case "guard": {
       const fnIdx = ctx.mapFns.length;
       ctx.mapFns.push(def.predicate);
       const vv = v(ctx);
       return {
         stmts: [
-          `${ind(ctx)}if (!_mf[${fnIdx}](_ctx.user)) ${failStmt({ ...ctx, indent: 0 }, '"gate"', pos).trim()}`,
+          `${ind(ctx)}if (!_mf[${fnIdx}](_ctx.state)) ${failStmt({ ...ctx, indent: 0 }, '"gate"', pos).trim()}`,
           `${ind(ctx)}const ${vv} = null`
         ],
         valueVar: vv,
@@ -1208,9 +1693,12 @@ function emit(p, ctx, pos) {
         const fnName = `_wcf${ctx.namedParsers.size}`;
         ctx.namedParsers.set(innerParser, fnName);
         const savedIndent = ctx.indent;
+        const savedFailLabel = ctx.failLabel;
         ctx.indent = 1;
+        ctx.failLabel = void 0;
         const innerR = emit(innerParser, ctx, "_pos");
         ctx.indent = savedIndent;
+        ctx.failLabel = savedFailLabel;
         ctx.namedFnDecls.push([
           `function ${fnName}(input, _pos, _ctx) {`,
           ...innerR.stmts,
@@ -1224,8 +1712,8 @@ function emit(p, ctx, pos) {
       const ev = v(ctx, "_wce");
       return {
         stmts: [
-          `${ind(ctx)}const ${rv} = ${fn}(input, ${pos}, { ..._ctx, user: _mf[${evIdx}]() })`,
-          `${ind(ctx)}if (!${rv}.ok) return ${rv}`,
+          `${ind(ctx)}const ${rv} = ${fn}(input, ${pos}, { ..._ctx, state: _mf[${evIdx}]() })`,
+          `${ind(ctx)}if (!${rv}.ok) ${failStmt({ ...ctx, indent: 0 }, '"withCtx"', pos).trim()}`,
           `${ind(ctx)}const ${vv} = ${rv}.value`,
           `${ind(ctx)}const ${ev} = ${rv}.span.end`
         ],
@@ -1237,16 +1725,61 @@ function emit(p, ctx, pos) {
       return emitRuntimeFallback(p, ctx, pos);
   }
 }
-function compile(parser2) {
+function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "node":
+      return true;
+    case "lazy": {
+      try {
+        return hasNodeDef(d.thunk(), seen);
+      } catch {
+        return false;
+      }
+    }
+    case "grammar":
+    case "trivia":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "not":
+    case "transform":
+      return hasNodeDef(d.parser, seen);
+    case "skip":
+      return hasNodeDef(d.main, seen) || hasNodeDef(d.skipped, seen);
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => hasNodeDef(x, seen));
+    case "sepBy":
+      return hasNodeDef(d.parser, seen) || hasNodeDef(d.separator, seen);
+    case "scanTo":
+      return hasNodeDef(d.sentinel, seen) || d.skip.some((x) => hasNodeDef(x, seen));
+    case "recover":
+      return hasNodeDef(d.parser, seen) || hasNodeDef(d.sentinel, seen);
+    case "withCtx":
+      return hasNodeDef(d.parser, seen);
+    default:
+      return false;
+  }
+}
+function compile(parser2, mapFnSources) {
   const ctx = {
     vars: 0,
     indent: 1,
     regexDecls: [],
+    regexMap: /* @__PURE__ */ new Map(),
     mapFns: [],
+    mapFnSrcs: [],
+    buildFns: [],
+    buildSrcs: [],
     runtimeParsers: [],
     needsCollator: false,
     namedParsers: /* @__PURE__ */ new Map(),
-    namedFnDecls: []
+    triviaCaptureNames: /* @__PURE__ */ new Map(),
+    namedFnDecls: [],
+    capturing: hasNodeDef(parser2)
   };
   const r = emit(parser2, ctx, "_pos");
   const collatorDecl = ctx.needsCollator ? `const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })
@@ -1255,13 +1788,13 @@ function compile(parser2) {
     ...ctx.regexDecls,
     "",
     ...ctx.namedFnDecls,
-    `${collatorDecl}function _parse(input, _pos, _rp, _mf, _ctx) {`,
+    `${collatorDecl}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} } }`,
     `}`
   ].join("\n");
-  const fn = new Function("input", "_pos", "_rp", "_mf", "_ctx", [
+  const fn = new Function("input", "_pos", "_rp", "_mf", "_build", "_ctx", [
     ...ctx.regexDecls,
     collatorDecl,
     ...ctx.namedFnDecls,
@@ -1270,17 +1803,27 @@ function compile(parser2) {
     `return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`
   ].join("\n"));
   const defaultCtx = { trackLines: false };
-  const canInline = ctx.runtimeParsers.length === 0 && ctx.mapFns.length === 0;
-  const inlineExpression = canInline ? buildInlineExpression(ctx, r, collatorDecl) : null;
+  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);
+  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, collatorDecl, effectiveSources, buildSources) : null;
   return {
     source,
     inlineExpression,
     parse(input, pos = 0) {
-      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, defaultCtx);
+      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, defaultCtx);
+    },
+    parseWithErrors(input, pos = 0) {
+      const errors = [];
+      const result = fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, { ...defaultCtx, _errors: errors });
+      return { ...result, errors };
     }
   };
 }
-function buildInlineExpression(ctx, r, collatorDecl) {
+function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources) {
   const bodyLines = [
     `  let pos = _pos`,
     ...r.stmts.map((s) => `  ${s}`),
@@ -1291,20 +1834,82 @@ function buildInlineExpression(ctx, r, collatorDecl) {
     ...bodyLines,
     `}`
   ].join("\n");
-  const needsWrapper = ctx.regexDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0;
-  if (!needsWrapper) {
-    return innerFn;
-  }
+  const mfDecl = mapFnSources?.length ? `  const _mf = [${mapFnSources.join(", ")}]` : "";
+  const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(", ")}]` : "";
+  const needsWrapper = ctx.regexDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl;
+  if (!needsWrapper) return innerFn;
   return [
     `/* @__PURE__ */ (() => {`,
     ...ctx.regexDecls.map((d) => `  ${d}`),
     collatorDecl ? `  ${collatorDecl.trim()}` : "",
+    mfDecl,
+    buildDecl,
     ...ctx.namedFnDecls.flatMap((f) => f.split("\n").map((l) => `  ${l}`)),
     `  return ${innerFn}`,
     `})()`
   ].filter(Boolean).join("\n");
 }
 
+// src/combinators/scanTo.ts
+function scanTo(sentinel, { skip: skip2 = [], orEOF = false } = {}) {
+  const meta = {
+    firstSet: any(),
+    canMatchNewline: true,
+    isTrivia: false
+  };
+  return {
+    _tag: "scanTo",
+    _meta: meta,
+    _def: { tag: "scanTo", sentinel, skip: skip2, orEOF },
+    parse(input, pos, ctx) {
+      let cur = pos;
+      const probeCtx = { trackLines: ctx.trackLines, state: ctx.state };
+      const emit2 = (end) => {
+        if (end > pos && (ctx._cstLeaves || ctx._cstRawChildren)) {
+          const leaf = { _tag: "leaf", value: input.slice(pos, end), span: { start: pos, end } };
+          if (ctx._cstLeaves) ctx._cstLeaves.push(leaf);
+          if (ctx._cstRawChildren) ctx._cstRawChildren.push(leaf);
+        }
+      };
+      while (cur < input.length) {
+        const s = sentinel.parse(input, cur, probeCtx);
+        if (s.ok) {
+          emit2(cur);
+          return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } };
+        }
+        let advanced = false;
+        for (const skipper of skip2) {
+          const r = skipper.parse(input, cur, probeCtx);
+          if (r.ok && r.span.end > cur) {
+            cur = r.span.end;
+            advanced = true;
+            break;
+          }
+        }
+        if (!advanced) cur++;
+      }
+      if (orEOF) {
+        emit2(cur);
+        return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } };
+      }
+      const sentDef = sentinel._def;
+      const expected = sentDef.tag === "literal" ? [JSON.stringify(sentDef.value)] : ["sentinel"];
+      return { ok: false, expected, span: { start: pos, end: cur } };
+    }
+  };
+}
+function balanced(open, close, options = {}) {
+  const inner = scanTo(literal(close), options);
+  const combi = transform(
+    sequence(literal(open), inner, literal(close)),
+    ([o, content, c]) => o + content + c
+  );
+  if (combi._def.tag === "transform") {
+    combi._def.fnSrc = "([o, content, c]) => o + content + c";
+  }
+  return combi;
+}
+
 // src/plugin/evaluator.ts
 var SUPPORTED = {
   literal: (...a) => literal(a[0], a[1]),
@@ -1314,19 +1919,144 @@ var SUPPORTED = {
   many: (...a) => many(a[0]),
   oneOrMore: (...a) => oneOrMore(a[0]),
   optional: (...a) => optional(a[0]),
-  sepBy: (...a) => sepBy(a[0], a[1])
-  // transform / grammar intentionally omitted — take user closures that can't be serialized
+  sepBy: (...a) => sepBy(a[0], a[1]),
+  trivia: (...a) => trivia(a[0])
 };
-function evaluateExpr(node, scope) {
-  if (node.type === "Identifier") return scope.get(node.name) ?? null;
-  if (node.type !== "CallExpression") return null;
-  const callee = node.callee;
+function isScopeEntry(v2) {
+  return !!v2 && typeof v2 === "object" && "combi" in v2 && "mfSrcs" in v2;
+}
+function isCombinator(v2) {
+  return !!v2 && typeof v2 === "object" && "_def" in v2;
+}
+function scopeGet(scope, name, mfs) {
+  const entry = scope.get(name);
+  if (!entry) return null;
+  if (isScopeEntry(entry)) {
+    if (mfs && entry.mfSrcs.length > 0) mfs.push(...entry.mfSrcs);
+    return entry.combi;
+  }
+  if (isCombinator(entry)) return entry;
+  return null;
+}
+function exprToCombi(node2, scope, code, mfs) {
+  if (node2.type === "Identifier") return scopeGet(scope, node2.name, mfs);
+  if (node2.type !== "CallExpression") return null;
+  const callee = node2.callee;
   if (callee.type !== "Identifier") return null;
+  if (callee.name === "transform" && 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 = code.slice(fnArg.start, fnArg.end);
+    mfs.push(fnSrc);
+    try {
+      const combi = transform(inner, (v2) => v2);
+      if (combi._def.tag === "transform") combi._def.fnSrc = fnSrc;
+      return combi;
+    } catch {
+      return null;
+    }
+  }
+  if (callee.name === "node" && code !== void 0) {
+    const [typeArg, parserArg, buildArg] = node2.arguments;
+    if (!typeArg || !parserArg || !buildArg || typeArg.type === "SpreadElement" || parserArg.type === "SpreadElement" || buildArg.type === "SpreadElement") return null;
+    const typeVal = anyValue(typeArg, scope, code);
+    if (typeof typeVal !== "string") return null;
+    const inner = anyValue(parserArg, scope, code, mfs);
+    if (!isCombinator(inner)) return null;
+    const buildSrc = code.slice(buildArg.start, buildArg.end);
+    try {
+      const combi = node(typeVal, inner, () => null);
+      if (combi._def.tag === "node") combi._def.buildSrc = buildSrc;
+      return combi;
+    } catch {
+      return null;
+    }
+  }
+  if (callee.name === "rules") return null;
+  if (callee.name === "parser") {
+    const [optsArg, rootArg] = node2.arguments;
+    if (!optsArg || !rootArg || optsArg.type === "SpreadElement" || rootArg.type === "SpreadElement") return null;
+    const opts = anyValue(optsArg, scope, code, []);
+    if (!opts || typeof opts !== "object") return null;
+    const root = anyValue(rootArg, scope, code, mfs);
+    if (!isCombinator(root)) return null;
+    try {
+      return parser(opts, root);
+    } catch {
+      return null;
+    }
+  }
+  if (callee.name === "sepBy") {
+    const [itemArg, sepArg] = node2.arguments;
+    if (!itemArg || !sepArg || itemArg.type === "SpreadElement" || sepArg.type === "SpreadElement") return null;
+    const itemMfs = [];
+    const itemCombi = anyValue(itemArg, scope, code, itemMfs);
+    if (!isCombinator(itemCombi)) return null;
+    const sepMfs = [];
+    const sepCombi = anyValue(sepArg, scope, code, sepMfs);
+    if (!isCombinator(sepCombi)) return null;
+    if (mfs) mfs.push(...itemMfs, ...sepMfs, ...itemMfs);
+    try {
+      return sepBy(itemCombi, sepCombi);
+    } catch {
+      return null;
+    }
+  }
+  if (callee.name === "oneOrMore") {
+    const [itemArg] = node2.arguments;
+    if (!itemArg || itemArg.type === "SpreadElement") return null;
+    const itemMfs = [];
+    const itemCombi = anyValue(itemArg, scope, code, itemMfs);
+    if (!isCombinator(itemCombi)) return null;
+    if (mfs) mfs.push(...itemMfs, ...itemMfs);
+    try {
+      return oneOrMore(itemCombi);
+    } catch {
+      return null;
+    }
+  }
+  if (callee.name === "not") {
+    const [innerArg] = node2.arguments;
+    if (!innerArg || innerArg.type === "SpreadElement") return null;
+    const inner = anyValue(innerArg, scope, code, mfs);
+    if (!isCombinator(inner)) return null;
+    try {
+      return not(inner);
+    } catch {
+      return null;
+    }
+  }
+  if (callee.name === "balanced") {
+    const [openArg, closeArg] = node2.arguments;
+    if (!openArg || !closeArg || openArg.type === "SpreadElement" || closeArg.type === "SpreadElement") return null;
+    const open = anyValue(openArg, scope, code, []);
+    const close = anyValue(closeArg, scope, code, []);
+    if (typeof open !== "string" || typeof close !== "string") return null;
+    try {
+      return balanced(open, close);
+    } catch {
+      return null;
+    }
+  }
+  if (callee.name === "scanTo") {
+    const [sentinelArg, optsArg] = node2.arguments;
+    if (!sentinelArg || sentinelArg.type === "SpreadElement") return null;
+    const sentinel = anyValue(sentinelArg, scope, code, []);
+    if (!isCombinator(sentinel)) return null;
+    const opts = optsArg && optsArg.type !== "SpreadElement" ? anyValue(optsArg, scope, code, []) : void 0;
+    try {
+      return scanTo(sentinel, opts);
+    } catch {
+      return null;
+    }
+  }
   const factory = SUPPORTED[callee.name];
   if (!factory) return null;
-  const args = node.arguments.map((arg) => {
+  const args = node2.arguments.map((arg) => {
     if (arg.type === "SpreadElement") return null;
-    return evaluateArg(arg, scope);
+    return anyValue(arg, scope, code, mfs);
   });
   if (args.some((a) => a === null)) return null;
   try {
@@ -1335,37 +2065,142 @@ function evaluateExpr(node, scope) {
     return null;
   }
 }
-function evaluateArg(node, scope) {
-  if (node.type === "Literal") {
-    if ("regex" in node && node.regex !== null && node.regex !== void 0) {
-      return new RegExp(node.regex.pattern, node.regex.flags);
+function anyValue(node2, scope, code, mfs) {
+  if (node2.type === "Literal") {
+    if ("regex" in node2 && node2.regex !== null && node2.regex !== void 0) {
+      return new RegExp(node2.regex.pattern, node2.regex.flags);
     }
-    return node.value;
+    return node2.value;
   }
-  if (node.type === "ObjectExpression") {
+  if (node2.type === "ArrayExpression") {
+    const arr = node2;
+    const out = [];
+    for (const el of arr.elements) {
+      if (el === null) {
+        out.push(null);
+        continue;
+      }
+      if (el.type === "SpreadElement") return null;
+      out.push(anyValue(el, scope, code, mfs));
+    }
+    return out;
+  }
+  if (node2.type === "ObjectExpression") {
     const obj = {};
-    for (const prop of node.properties) {
+    for (const prop of node2.properties) {
       if (prop.type !== "Property") return null;
       if (prop.computed) return null;
       const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "Literal" ? String(prop.key.value) : null;
       if (key === null) return null;
-      obj[key] = evaluateArg(prop.value, scope);
+      obj[key] = anyValue(prop.value, scope, code, mfs);
     }
     return obj;
   }
-  if (node.type === "Identifier") {
-    if (node.name === "undefined") return void 0;
-    return scope.get(node.name) ?? null;
+  if (node2.type === "Identifier") {
+    if (node2.name === "undefined") return void 0;
+    const entry = scope.get(node2.name) ?? null;
+    if (isScopeEntry(entry)) {
+      if (mfs && entry.mfSrcs.length > 0) mfs.push(...entry.mfSrcs);
+      return entry.combi;
+    }
+    return entry;
   }
-  if (node.type === "CallExpression") return evaluateExpr(node, scope);
+  if (node2.type === "MemberExpression") {
+    const mem = node2;
+    const obj = anyValue(mem.object, scope, code, mfs);
+    if (!obj || typeof obj !== "object") return null;
+    if (node2.computed) {
+      const key = anyValue(node2.property, scope, code, mfs);
+      if (typeof key !== "string" && typeof key !== "number") return null;
+      return obj[key] ?? null;
+    }
+    const propName = mem.property.name;
+    if (!propName) return null;
+    return obj[propName] ?? null;
+  }
+  if (node2.type === "CallExpression") return exprToCombi(node2, scope, code, mfs);
   return null;
 }
-function referencesAny(node, names, scope) {
-  if (node.type === "Identifier") {
-    return names.has(node.name) || scope.has(node.name);
+function evaluateExpr(node2, scope, code, mapFnSources) {
+  return exprToCombi(node2, scope, code, mapFnSources);
+}
+function evaluateParserFactory(factoryNode, scope, code, mapFnSources) {
+  if (factoryNode.type !== "ArrowFunctionExpression" && factoryNode.type !== "FunctionDeclaration" && factoryNode.type !== "FunctionExpression") return null;
+  const factory = factoryNode;
+  const params = factory.params;
+  if (params.length !== 1) return null;
+  const param = params[0];
+  const proxyName = param.type === "Identifier" ? param.name ?? null : null;
+  if (!proxyName) return null;
+  const body = factory.body;
+  if (!body) return null;
+  const statements = [];
+  let returnExpr = null;
+  if (body.type === "BlockStatement") {
+    const stmts = body.body;
+    for (const stmt of stmts) {
+      const s = stmt;
+      if (s.type === "ReturnStatement") {
+        returnExpr = s.argument ?? null;
+        break;
+      }
+      if (s.type === "VariableDeclaration") {
+        statements.push(s);
+      } else {
+        return null;
+      }
+    }
+  } else {
+    returnExpr = body;
+  }
+  if (!returnExpr) return null;
+  const retObj = returnExpr.type === "ParenthesizedExpression" ? returnExpr.expression : returnExpr;
+  if (retObj.type !== "ObjectExpression") return null;
+  const ruleRefs = /* @__PURE__ */ new Map();
+  for (const prop of retObj.properties) {
+    if (prop.type !== "Property") return null;
+    if (prop.computed) return null;
+    const p = prop;
+    const key = p.key.type === "Identifier" ? p.key.name : p.key.type === "Literal" ? String(p.key.value) : null;
+    if (!key) return null;
+    ruleRefs.set(key, ref());
+  }
+  const localScope = new Map(scope);
+  localScope.set(proxyName, Object.fromEntries(ruleRefs));
+  const bodyMfs = [];
+  for (const stmt of statements) {
+    for (const d of stmt.declarations) {
+      const decl = d;
+      if (!decl.init) return null;
+      const id = decl.id;
+      if (id.type !== "Identifier" && id.type !== "BindingIdentifier") return null;
+      const name = id.name;
+      const before = bodyMfs.length;
+      const val = anyValue(decl.init, localScope, code, bodyMfs);
+      if (val === null) return null;
+      const thisDeclMfSrcs = bodyMfs.slice(before);
+      if (isCombinator(val)) {
+        localScope.set(name, { combi: val, mfSrcs: thisDeclMfSrcs });
+      } else {
+        localScope.set(name, val);
+      }
+    }
+  }
+  for (const prop of retObj.properties) {
+    const p = prop;
+    const key = p.key.type === "Identifier" ? p.key.name : String(p.key.value);
+    const val = anyValue(p.value, localScope, code, mapFnSources);
+    if (!isCombinator(val)) return null;
+    ruleRefs.get(key).define(val);
+  }
+  return ruleRefs;
+}
+function referencesAny(node2, names, scope) {
+  if (node2.type === "Identifier") {
+    return names.has(node2.name) || scope.has(node2.name);
   }
-  for (const key of Object.keys(node)) {
-    const child = node[key];
+  for (const key of Object.keys(node2)) {
+    const child = node2[key];
     if (!child || typeof child !== "object") continue;
     if (Array.isArray(child)) {
       if (child.some((c) => c && typeof c === "object" && "type" in c && referencesAny(c, names, scope))) return true;
@@ -1380,6 +2215,10 @@ function referencesAny(node, names, scope) {
 var PARSEMAN_MODULE = "parseman";
 var plugin_default = (0, import_unplugin.createUnplugin)((opts = {}) => ({
   name: "parseman",
+  // Run BEFORE the bundler's TS/JS transform — otherwise esbuild (Vite) strips
+  // the `with { type: 'macro' }` import attribute before we ever see it, and the
+  // macro silently never fires.
+  enforce: "pre",
   transformInclude(id) {
     return /\.[jt]sx?$/.test(id) && !id.includes("node_modules");
   },
@@ -1387,7 +2226,15 @@ 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 ?? []]);
-    return transformMacro(code, id, moduleAliases);
+    const result = transformMacro(code, id, moduleAliases);
+    if (result?.warnings.length) {
+      for (const w of result.warnings) {
+        if (typeof this?.warn === "function") this.warn(`[parseman] ${w}`);
+        else console.warn(`[parseman] ${w}`);
+      }
+    }
+    if (!result) return null;
+    return { code: result.code, map: result.map };
   }
 }));
 function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE])) {
@@ -1420,35 +2267,136 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   if (macroImports.length === 0) return null;
   const scope = /* @__PURE__ */ new Map();
   const replacements = [];
+  const warnings = [];
   let anyUnresolved = false;
+  const lineOf = (pos) => {
+    let line = 1;
+    for (let i = 0; i < pos && i < code.length; i++) if (code.charCodeAt(i) === 10) line++;
+    return line;
+  };
+  const warn = (pos, msg) => {
+    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, label) => {
+    const args = init.arguments;
+    const factoryArg = args[0];
+    if (!factoryArg) {
+      warn(init.start, `${label}: rules() needs a factory argument`);
+      return null;
+    }
+    const ruleMap = evaluateParserFactory(factoryArg, scope, code, []);
+    if (!ruleMap) {
+      warn(init.start, `${label}: rules(...) factory isn't statically evaluable`);
+      return null;
+    }
+    const entries = [];
+    for (const [ruleKey, rule] of ruleMap) {
+      const compiled = compile(rule);
+      if (compiled.inlineExpression === null) {
+        warn(init.start, `${label}: rule "${ruleKey}" couldn't be inlined`);
+        return null;
+      }
+      entries.push([ruleKey, compiled.inlineExpression]);
+    }
+    return { entries, ruleMap };
+  };
+  const isRulesCall = (init) => init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "rules";
   for (const stmt of body) {
-    if (stmt.type !== "VariableDeclaration") continue;
-    for (const decl of stmt.declarations) {
+    let vd = null;
+    let stmtStart = stmt.start;
+    let stmtEnd = stmt.end;
+    let exportPrefix = "";
+    if (stmt.type === "VariableDeclaration") {
+      vd = stmt;
+    } else if (stmt.type === "ExportNamedDeclaration") {
+      const expStmt = stmt;
+      if (expStmt.declaration?.type === "VariableDeclaration") {
+        vd = expStmt.declaration;
+        exportPrefix = "export ";
+      }
+    }
+    if (!vd) continue;
+    for (const decl of vd.declarations) {
       const d = decl;
       if (!d.init) continue;
-      if (d.id.type !== "Identifier") continue;
-      const varName = d.id.name;
       const init = d.init;
-      if (!referencesAny(init, allNames, scope)) continue;
-      const parser2 = evaluateExpr(init, scope);
-      if (parser2 === null) {
-        anyUnresolved = true;
-        continue;
-      }
-      const compiled = compile(parser2);
-      if (compiled.inlineExpression === null) {
-        anyUnresolved = true;
-        continue;
+      const kind = vd.kind ?? "const";
+      if (d.id.type === "Identifier") {
+        const varName = d.id.name;
+        if (!referencesAny(init, allNames, scope)) continue;
+        if (isRulesCall(init)) {
+          const compiledRules = compileRulesFactory(init, varName);
+          if (!compiledRules) continue;
+          replacements.push({
+            start: init.start,
+            end: init.end,
+            replacement: `{ ${compiledRules.entries.map(([k, expr]) => `${k}: ${expr}`).join(", ")} }`
+          });
+          continue;
+        }
+        const mapFnSources = [];
+        const parser2 = evaluateExpr(init, scope, code, mapFnSources);
+        if (parser2 === null) {
+          warn(init.start, `"${varName}" references a parseman macro import but isn't a statically-evaluable combinator`);
+          continue;
+        }
+        const compiled = compile(parser2);
+        if (compiled.inlineExpression === null) {
+          warn(init.start, `"${varName}" couldn't be inlined (likely closes over a runtime value)`);
+          continue;
+        }
+        replacements.push({
+          start: init.start,
+          end: init.end,
+          replacement: compiled.inlineExpression
+        });
+        scope.set(varName, { combi: parser2, mfSrcs: mapFnSources });
+      } else if (d.id.type === "ObjectPattern") {
+        if (!referencesAny(init, allNames, scope)) continue;
+        if (!isRulesCall(init)) {
+          warn(init.start, `destructured macro binding must come from rules(...)`);
+          continue;
+        }
+        const compiledRules = compileRulesFactory(init, "{ \u2026 }");
+        if (!compiledRules) continue;
+        const byKey = new Map(compiledRules.entries);
+        const pattern = d.id;
+        const lines = [];
+        let allOk = true;
+        for (const prop of pattern.properties) {
+          const p = prop;
+          if (p.type === "RestElement" || p.type === "BindingRestElement") {
+            warn(init.start, `rest element in a rules() destructure isn't supported`);
+            allOk = false;
+            break;
+          }
+          const ruleKey = p.key.type === "Identifier" ? p.key.name : p.key.type === "StringLiteral" ? String(p.key.value) : null;
+          const localName = p.value.type === "Identifier" || p.value.type === "BindingIdentifier" ? p.value.name : ruleKey;
+          if (!ruleKey || !localName) {
+            allOk = false;
+            break;
+          }
+          const inlineExpr = byKey.get(ruleKey);
+          if (inlineExpr === void 0) {
+            warn(init.start, `destructured rule "${ruleKey}" isn't returned by the rules() factory`);
+            allOk = false;
+            break;
+          }
+          lines.push(`${exportPrefix}${kind} ${localName} = ${inlineExpr}`);
+          const rule = compiledRules.ruleMap.get(ruleKey);
+          if (rule) scope.set(localName, { combi: rule, mfSrcs: [] });
+        }
+        if (!allOk) continue;
+        replacements.push({
+          start: stmtStart,
+          end: stmtEnd,
+          replacement: lines.join("\n")
+        });
       }
-      replacements.push({
-        start: init.start,
-        end: init.end,
-        replacement: compiled.inlineExpression
-      });
-      scope.set(varName, parser2);
     }
   }
-  if (replacements.length === 0) return null;
+  if (replacements.length === 0 && warnings.length === 0) return null;
   for (const imp of macroImports) {
     imp.fullyResolved = !anyUnresolved;
   }
@@ -1467,7 +2415,8 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   }
   return {
     code: ms.toString(),
-    map: ms.generateMap({ hires: true })
+    map: ms.generateMap({ hires: true }),
+    warnings
   };
 }
 //# sourceMappingURL=index.cjs.map