parseman 0.12.0 → 0.14.0

package/dist/index.js

@@ -251,6 +251,36 @@ function literal(value, opts = {}) {
 }
 
 // src/combinators/regex.ts
+var firstSetAnalyzer = null;
+function registerRegexAnalyzer(analyzer) {
+  firstSetAnalyzer = analyzer;
+}
+var permissiveFirstSet = () => ({ firstSet: any(), canMatchNewline: true });
+function regex(pattern, flags = "") {
+  const source = typeof pattern === "string" ? pattern : pattern.source;
+  const resolvedFlags = typeof pattern === "string" ? flags : pattern.flags;
+  const anchored = new RegExp(source, "y" + resolvedFlags.replace(/[gy]/g, ""));
+  const { firstSet, canMatchNewline } = (firstSetAnalyzer ?? permissiveFirstSet)(source);
+  const meta = { firstSet, canMatchNewline, isTrivia: false };
+  return {
+    _tag: "regex",
+    _meta: meta,
+    _def: { tag: "regex", source, flags: resolvedFlags },
+    parse(input, pos, ctx) {
+      anchored.lastIndex = pos;
+      const m = anchored.exec(input);
+      if (m === null) {
+        return failAt(ctx, [`/${source}/`], pos);
+      }
+      const span = { start: pos, end: pos + m[0].length };
+      const leaf = { _tag: "leaf", value: m[0], span };
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
+      return { ok: true, value: m[0], span };
+    }
+  };
+}
+
+// src/combinators/regex-analyze.ts
 import regexpTree from "regexp-tree";
 function firstSetFromRegex(pattern) {
   try {
@@ -355,40 +385,6 @@ function extractFirstSet(node2) {
       return { firstSet: any(), canMatchNewline: true };
   }
 }
-function optimizeRegex(source, flags) {
-  try {
-    const result = regexpTree.optimize(`/${source}/${flags}`);
-    const str = result.toString();
-    const lastSlash = str.lastIndexOf("/");
-    return str.slice(1, lastSlash);
-  } catch {
-    return source;
-  }
-}
-function regex(pattern, flags = "") {
-  const source = typeof pattern === "string" ? pattern : pattern.source;
-  const resolvedFlags = typeof pattern === "string" ? flags : pattern.flags;
-  const optimizedSource = optimizeRegex(source, resolvedFlags);
-  const anchored = new RegExp(optimizedSource, "y" + resolvedFlags.replace(/[gy]/g, ""));
-  const { firstSet, canMatchNewline } = firstSetFromRegex(source);
-  const meta = { firstSet, canMatchNewline, isTrivia: false };
-  return {
-    _tag: "regex",
-    _meta: meta,
-    _def: { tag: "regex", source, flags: resolvedFlags, optimizedSource },
-    parse(input, pos, ctx) {
-      anchored.lastIndex = pos;
-      const m = anchored.exec(input);
-      if (m === null) {
-        return failAt(ctx, [`/${source}/`], pos);
-      }
-      const span = { start: pos, end: pos + m[0].length };
-      const leaf = { _tag: "leaf", value: m[0], span };
-      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
-      return { ok: true, value: m[0], span };
-    }
-  };
-}
 
 // src/combinators/keywords.ts
 function word(str, boundary = "_0-9A-Za-z") {
@@ -1086,7 +1082,9 @@ function rules(factory) {
       if (typeof key !== "string") return void 0;
       const record = target;
       if (!(key in record)) {
-        record[key] = ref();
+        const r = ref();
+        r._ruleName = key;
+        record[key] = r;
       }
       return record[key];
     }
@@ -1151,12 +1149,14 @@ function confirmedBuildArity(src) {
   return parts.length;
 }
 function buildReadsTrivia(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 buildReadsState(def) {
+  if (!def.build) return true;
   const src = def.buildSrc ?? def.build.toString();
   const arity = confirmedBuildArity(src);
   if (arity === null) return true;
@@ -1175,8 +1175,8 @@ function node(type, combinator, build, opts) {
   };
   const collapse = opts?.collapse === true;
   const def = collapse ? { tag: "node", type, parser: combinator, build, collapse: true } : { tag: "node", type, parser: combinator, build };
-  const capturesTrivia = buildReadsTrivia(def);
-  const clonesState = buildReadsState(def);
+  const capturesTrivia = build ? buildReadsTrivia(def) : true;
+  const clonesState = build ? buildReadsState(def) : true;
   return {
     _tag: "node",
     _meta: meta,
@@ -1187,13 +1187,8 @@ function node(type, combinator, build, opts) {
       const r = combinator.parse(input, pos, ctx);
       const { children, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
       if (!r.ok) return r;
-      const built = collapse && children.length === 1 ? collapseChild(children[0]) : build(
-        children,
-        rawChildren,
-        r.span,
-        triviaLog,
-        clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0
-      );
+      const st = clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
+      const built = collapse && children.length === 1 ? collapseChild(children[0]) : build ? build(children, rawChildren, r.span, triviaLog, st) : ctx.build ? ctx.build(type, children, rawChildren, r.span, triviaLog, st) : { _tag: "node", type, span: { start: r.span.start, end: r.span.end }, state: st ?? null, children };
       const isNodeLike = typeof built === "object" && built !== null && built._tag === "node";
       const rawEntry = isNodeLike ? built : { _tag: "leaf", value: typeof built === "string" ? built : "", span: r.span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
@@ -1368,8 +1363,14 @@ function staticExpected(c) {
     case "transform":
     case "not":
       return staticExpected(def.parser);
-    case "lazy":
-      return staticExpected(def.thunk());
+    case "lazy": {
+      const name = c._ruleName;
+      try {
+        return staticExpected(def.thunk());
+      } catch {
+        return name ? [name] : [];
+      }
+    }
     default:
       return [];
   }
@@ -1399,8 +1400,29 @@ function expect(combinator, label2) {
 var BACKSLASH = 92;
 var CLASS_ESCAPES = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
 var META = new Set("()[]{}*+?|^$.".split(""));
+var SPACE_RANGES = [
+  [9, 13],
+  [32, 32],
+  [160, 160],
+  [5760, 5760],
+  [8192, 8202],
+  [8232, 8232],
+  [8233, 8233],
+  [8239, 8239],
+  [8287, 8287],
+  [12288, 12288],
+  [65279, 65279]
+];
 function shorthandRanges(ch) {
-  return ch === "d" ? [[48, 57]] : [[48, 57], [65, 90], [97, 122], [95, 95]];
+  if (ch === "d") return [[48, 57]];
+  if (ch === "s") return SPACE_RANGES;
+  return [[48, 57], [65, 90], [97, 122], [95, 95]];
+}
+function readUnicodeEscape(body, i) {
+  if (body[i] !== "\\" || body[i + 1] !== "u") return null;
+  const hex = body.slice(i + 2, i + 6);
+  if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null;
+  return { cp: Number.parseInt(hex, 16), next: i + 6 };
 }
 function parseClassRanges(body) {
   const ranges = [];
@@ -1409,11 +1431,16 @@ function parseClassRanges(body) {
     const ch = body[i];
     if (ch === void 0) return null;
     if (ch === "\\") {
+      const uni = readUnicodeEscape(body, i);
+      if (uni) {
+        i = uni.next;
+        return { cp: uni.cp };
+      }
       const e = body[i + 1];
       if (e === void 0) return null;
       i += 2;
       if (e in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[e] };
-      if (e === "d" || e === "w") return { set: shorthandRanges(e) };
+      if (e === "d" || e === "w" || e === "s") return { set: shorthandRanges(e) };
       if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
       return { cp: e.codePointAt(0) };
     }
@@ -1441,10 +1468,16 @@ function parseClassRanges(body) {
 function classToRanges(cls) {
   if (cls === "\\d") return shorthandRanges("d");
   if (cls === "\\w") return shorthandRanges("w");
+  if (cls === "\\s") return shorthandRanges("s");
   const body = cls.slice(1, -1);
   if (body.startsWith("^")) return null;
   return parseClassRanges(body);
 }
+var foldEq = (cVar, cp) => {
+  if (cp >= 65 && cp <= 90) return `(${cVar} === ${cp} || ${cVar} === ${cp + 32})`;
+  if (cp >= 97 && cp <= 122) return `(${cVar} === ${cp} || ${cVar} === ${cp - 32})`;
+  return `${cVar} === ${cp}`;
+};
 function literalCodePoints(frag) {
   const out = [];
   let i = 0;
@@ -1491,22 +1524,612 @@ function parseStringShape(source) {
   if (!inSet(qcp) || !inSet(BACKSLASH)) return null;
   return { kind: "string", quote: qcp, excluded, escLineTerm: esc !== "." };
 }
+function parseSeqParts(source) {
+  const parts = [];
+  let lit = [];
+  const flush = () => {
+    if (lit.length) {
+      parts.push({ part: "lit", cps: lit, optional: false });
+      lit = [];
+    }
+  };
+  const runFrom = (ranges, negated, q) => {
+    if (q === "+") {
+      parts.push({ part: "run", ranges, negated, min: 1, unbounded: true });
+      return 1;
+    }
+    if (q === "*") {
+      parts.push({ part: "run", ranges, negated, min: 0, unbounded: true });
+      return 1;
+    }
+    if (q === "?") {
+      parts.push({ part: "run", ranges, negated, min: 0, unbounded: false });
+      return 1;
+    }
+    parts.push({ part: "run", ranges, negated, min: 1, unbounded: false });
+    return 0;
+  };
+  let i = 0;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === "[") {
+      let k = i + 1;
+      const neg = source[k] === "^";
+      if (neg) k++;
+      let body = "";
+      while (k < source.length && source[k] !== "]") {
+        if (source[k] === "\\") {
+          body += source[k] + (source[k + 1] ?? "");
+          k += 2;
+        } else {
+          body += source[k];
+          k++;
+        }
+      }
+      if (source[k] !== "]") return null;
+      const ranges = parseClassRanges(body);
+      if (!ranges) return null;
+      flush();
+      i = k + 1;
+      i += runFrom(ranges, neg, source[i]);
+      continue;
+    }
+    if (ch === "\\") {
+      const e = source[i + 1];
+      if (e === "d" || e === "w" || e === "s") {
+        flush();
+        i += 2;
+        i += runFrom(shorthandRanges(e), false, source[i]);
+        continue;
+      }
+      const uni = readUnicodeEscape(source, i);
+      let cp2;
+      if (uni) {
+        cp2 = uni.cp;
+        i = uni.next;
+      } else if (e === void 0) return null;
+      else if (e in CLASS_ESCAPES) {
+        cp2 = CLASS_ESCAPES[e];
+        i += 2;
+      } else if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
+      else {
+        cp2 = e.codePointAt(0);
+        i += 2;
+      }
+      if (source[i] === "?") {
+        flush();
+        parts.push({ part: "lit", cps: [cp2], optional: true });
+        i++;
+      } else lit.push(cp2);
+      continue;
+    }
+    if (ch === "(") {
+      if (source[i + 1] !== "?" || source[i + 2] !== ":") return null;
+      let k = i + 3;
+      let depth = 1;
+      while (k < source.length && depth > 0) {
+        const c2 = source[k];
+        if (c2 === "\\") {
+          k += 2;
+          continue;
+        }
+        if (c2 === "[") {
+          let j = k + 1;
+          if (source[j] === "^") j++;
+          while (j < source.length && source[j] !== "]") {
+            if (source[j] === "\\") j += 2;
+            else j++;
+          }
+          if (source[j] !== "]") return null;
+          k = j + 1;
+          continue;
+        }
+        if (c2 === "(") depth++;
+        else if (c2 === ")") depth--;
+        k++;
+      }
+      if (depth !== 0) return null;
+      const body = source.slice(i + 3, k - 1);
+      const inner = parseScanShape(body);
+      if (!inner || !groupInnerSafe(inner)) return null;
+      const q = source[k];
+      if (q === "{") return null;
+      flush();
+      if (q === "+") {
+        if (shapeCanBeEmpty(inner)) return null;
+        parts.push({ part: "group", inner, min: 1, unbounded: true });
+        i = k + 1;
+      } else if (q === "*") {
+        if (shapeCanBeEmpty(inner)) return null;
+        parts.push({ part: "group", inner, min: 0, unbounded: true });
+        i = k + 1;
+      } else if (q === "?") {
+        parts.push({ part: "group", inner, min: 0, unbounded: false });
+        i = k + 1;
+      } else {
+        parts.push({ part: "group", inner, min: 1, unbounded: false });
+        i = k;
+      }
+      continue;
+    }
+    if (META.has(ch)) return null;
+    const cp = ch.codePointAt(0);
+    i += ch.length;
+    if (source[i] === "?") {
+      flush();
+      parts.push({ part: "lit", cps: [cp], optional: true });
+      i++;
+    } else lit.push(cp);
+  }
+  flush();
+  return parts.length ? parts : null;
+}
+function seqIsUnambiguous(parts) {
+  let hasMandatory = false;
+  for (let k = 0; k < parts.length; k++) {
+    const p = parts[k];
+    const mandatory = p.part === "lit" ? !p.optional : p.min === 1;
+    if (mandatory) hasMandatory = true;
+    if (p.part === "group") {
+      const exposure = groupPartExposure(p);
+      if (exposure === "unsupported") {
+        const trailingOnce = k === parts.length - 1 && p.min === 1 && !p.unbounded;
+        if (!trailingOnce) return false;
+      } else if (exposure !== null) {
+        if (!firstSetsDisjoint(exposure, seqFirstAccept(parts.slice(k + 1)))) return false;
+      }
+    }
+    const skippableSingle = p.part === "lit" && p.optional || p.part !== "lit" && !p.unbounded && p.min === 0;
+    const isUnboundedRepeat = p.part !== "lit" && p.unbounded;
+    if (skippableSingle || isUnboundedRepeat) {
+      const rest = seqFirstAccept(parts.slice(k + 1));
+      if (!firstSetsDisjoint(partFirstAccept(p), rest)) return false;
+    }
+  }
+  return hasMandatory;
+}
+function rangesOverlap(a, b) {
+  return a.some(([lo, hi]) => b.some(([lo2, hi2]) => lo <= hi2 && lo2 <= hi));
+}
+function rangesSubset(sub, sup) {
+  return sub.every(([lo, hi]) => sup.some(([lo2, hi2]) => lo >= lo2 && hi <= hi2));
+}
+function parseClassOperand(body) {
+  if (body === "\\d" || body === "\\w" || body === "\\s") {
+    return { ranges: shorthandRanges(body[1]), negated: false };
+  }
+  if (body.length >= 2 && body[0] === "[" && body[body.length - 1] === "]") {
+    let inner = body.slice(1, -1);
+    const negated = inner.startsWith("^");
+    if (negated) inner = inner.slice(1);
+    const ranges = parseClassRanges(inner);
+    return ranges ? { ranges, negated } : null;
+  }
+  const cps = literalCodePoints(body);
+  if (cps && cps.length === 1) return { ranges: [[cps[0], cps[0]]], negated: false };
+  return null;
+}
+function classSubset(t, u) {
+  if (!t.negated && !u.negated) return rangesSubset(t.ranges, u.ranges);
+  if (!t.negated && u.negated) return !rangesOverlap(t.ranges, u.ranges);
+  if (t.negated && !u.negated) return false;
+  return rangesSubset(u.ranges, t.ranges);
+}
+function classDisjoint(t, u) {
+  if (!t.negated && !u.negated) return !rangesOverlap(t.ranges, u.ranges);
+  if (!t.negated && u.negated) return rangesSubset(t.ranges, u.ranges);
+  if (t.negated && !u.negated) return rangesSubset(u.ranges, t.ranges);
+  return false;
+}
+function firstSetsDisjoint(a, b) {
+  if (a === "any" || b === "any") return false;
+  return classDisjoint(a, b);
+}
+function fixedClassSeq(shape) {
+  if (shape.kind !== "seq") return null;
+  const out = [];
+  for (const p of shape.parts) {
+    if (p.part === "lit") {
+      if (p.optional) return null;
+      for (const cp of p.cps) out.push({ ranges: [[cp, cp]], negated: false });
+    } else if (p.part === "run" && !p.unbounded && p.min === 1) {
+      out.push({ ranges: p.ranges, negated: p.negated });
+    } else {
+      return null;
+    }
+  }
+  return out.length ? out : null;
+}
+function altFixedMutuallyExclusive(shape) {
+  if (shape.kind !== "alt" || shape.disjoint) return false;
+  const lists = [];
+  for (const arm of shape.arms) {
+    const f = fixedClassSeq(arm);
+    if (!f) return false;
+    lists.push(f);
+  }
+  for (let i = 0; i < lists.length; i++) {
+    for (let j = 0; j < lists.length; j++) {
+      if (i === j) continue;
+      const a = lists[i];
+      const b = lists[j];
+      if (a.length > b.length) continue;
+      let disjointAt = false;
+      for (let p = 0; p < a.length; p++) {
+        if (classDisjoint(a[p], b[p])) {
+          disjointAt = true;
+          break;
+        }
+      }
+      if (!disjointAt) return false;
+    }
+  }
+  return true;
+}
+function groupPartExposure(part) {
+  const innerWiggle = trailingBacktrackClass(part.inner);
+  if (innerWiggle === "unsupported") return "unsupported";
+  const requiredOnce = !part.unbounded && part.min === 1;
+  if (requiredOnce) return innerWiggle;
+  const dropExposed = shapeFirstAccept(part.inner);
+  if (dropExposed === "any") return "unsupported";
+  if (innerWiggle === null) return dropExposed;
+  const unioned = unionCharSets([innerWiggle, dropExposed]);
+  return unioned === "any" ? "unsupported" : unioned;
+}
+function trailingBacktrackClass(shape) {
+  if (shape.kind === "chars") return { ranges: shape.ranges, negated: false };
+  if (shape.kind === "ident") return { ranges: shape.tail, negated: false };
+  if (shape.kind === "litFold") return null;
+  if (shape.kind === "seq") {
+    const last = shape.parts[shape.parts.length - 1];
+    if (last.part === "lit") return null;
+    if (last.part === "run") {
+      if (last.unbounded || last.min === 0) return { ranges: last.ranges, negated: last.negated };
+      return null;
+    }
+    return groupPartExposure(last);
+  }
+  if (shape.kind === "alt") {
+    if (!shape.disjoint) return altFixedMutuallyExclusive(shape) ? null : "unsupported";
+    const classes = shape.arms.map(trailingBacktrackClass);
+    if (classes.some((c) => c === "unsupported")) return "unsupported";
+    const concrete = classes.filter((c) => c !== null);
+    if (concrete.length === 0) return null;
+    const unioned = unionCharSets(concrete);
+    return unioned === "any" ? "unsupported" : unioned;
+  }
+  return "unsupported";
+}
+function lookaheadUnambiguous(inner, operand, negative) {
+  const tail = trailingBacktrackClass(inner);
+  if (tail === "unsupported") return false;
+  if (tail === null) return true;
+  return negative ? classSubset(tail, operand) : classDisjoint(tail, operand);
+}
+function stripTrailingLookahead(source) {
+  if (!source.endsWith(")")) return null;
+  for (const negative of [true, false]) {
+    const lead = negative ? "(?!" : "(?=";
+    const idx = source.lastIndexOf(lead);
+    if (idx === -1) continue;
+    const body = source.slice(idx + lead.length, -1);
+    const operand = body.length ? parseClassOperand(body) : null;
+    if (!operand) continue;
+    return { base: source.slice(0, idx), ranges: operand.ranges, classNegated: operand.negated, negative };
+  }
+  return null;
+}
+function unwrapOuterGroup(source) {
+  while (source.startsWith("(?:")) {
+    let depth = 1;
+    let i = 3;
+    let ok = true;
+    while (i < source.length && depth > 0) {
+      const ch = source[i];
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === "[") {
+        let j = i + 1;
+        if (source[j] === "^") j++;
+        while (j < source.length && source[j] !== "]") {
+          if (source[j] === "\\") j += 2;
+          else j++;
+        }
+        if (source[j] !== "]") {
+          ok = false;
+          break;
+        }
+        i = j + 1;
+        continue;
+      }
+      if (ch === "(") depth++;
+      else if (ch === ")") depth--;
+      i++;
+    }
+    if (!ok || depth !== 0 || i !== source.length) break;
+    source = source.slice(3, -1);
+  }
+  return source;
+}
+function splitTopLevelAlternation(source) {
+  const body = unwrapOuterGroup(source);
+  const parts = [];
+  let depth = 0;
+  let last = 0;
+  let i = 0;
+  while (i < body.length) {
+    const ch = body[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "[") {
+      let j = i + 1;
+      if (body[j] === "^") j++;
+      while (j < body.length && body[j] !== "]") {
+        if (body[j] === "\\") j += 2;
+        else j++;
+      }
+      if (body[j] !== "]") return null;
+      i = j + 1;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      depth--;
+      if (depth < 0) return null;
+      i++;
+      continue;
+    }
+    if (ch === "|" && depth === 0) {
+      parts.push(body.slice(last, i));
+      last = i + 1;
+      i++;
+      continue;
+    }
+    i++;
+  }
+  if (depth !== 0) return null;
+  parts.push(body.slice(last));
+  if (parts.length < 2 || parts.some((p) => p.length === 0)) return null;
+  return parts;
+}
+function shapeCanBeEmpty(shape) {
+  if (shape.kind === "chars") return !shape.minOne;
+  if (shape.kind === "lookahead") return shapeCanBeEmpty(shape.inner);
+  if (shape.kind === "alt") return shape.arms.some(shapeCanBeEmpty);
+  return false;
+}
+function unionCharSets(sets) {
+  if (sets.some((s) => s === "any")) return "any";
+  const concrete = sets;
+  if (concrete.length === 1) return concrete[0];
+  if (concrete.some((s) => s.negated)) return "any";
+  return { ranges: concrete.flatMap((s) => s.ranges), negated: false };
+}
+function partFirstAccept(part) {
+  if (part.part === "lit") return { ranges: [[part.cps[0], part.cps[0]]], negated: false };
+  if (part.part === "run") return { ranges: part.ranges, negated: part.negated };
+  return shapeFirstAccept(part.inner);
+}
+function seqFirstAccept(parts) {
+  const sets = [];
+  for (const p of parts) {
+    const mandatory = p.part === "lit" ? !p.optional : p.min === 1;
+    sets.push(partFirstAccept(p));
+    if (mandatory) break;
+  }
+  return unionCharSets(sets);
+}
+function groupInnerSafe(shape) {
+  if (shape.kind === "chars" || shape.kind === "ident" || shape.kind === "seq" || shape.kind === "litFold") return true;
+  if (shape.kind === "lookahead") return groupInnerSafe(shape.inner);
+  if (shape.kind === "alt") return true;
+  return false;
+}
+function shapeFirstAccept(shape) {
+  if (shapeCanBeEmpty(shape)) return "any";
+  switch (shape.kind) {
+    case "chars":
+      return { ranges: shape.ranges, negated: false };
+    case "ident":
+      return { ranges: shape.head, negated: false };
+    case "until":
+      return { ranges: [[shape.open[0], shape.open[0]]], negated: false };
+    case "delimited":
+      return { ranges: [[shape.open[0], shape.open[0]]], negated: false };
+    case "string":
+      return { ranges: [[shape.quote, shape.quote]], negated: false };
+    case "litFold": {
+      const cp = shape.open[0];
+      if (cp >= 65 && cp <= 90) return { ranges: [[cp, cp], [cp + 32, cp + 32]], negated: false };
+      if (cp >= 97 && cp <= 122) return { ranges: [[cp, cp], [cp - 32, cp - 32]], negated: false };
+      return { ranges: [[cp, cp]], negated: false };
+    }
+    case "seq":
+      return seqFirstAccept(shape.parts);
+    case "lookahead":
+      return shapeFirstAccept(shape.inner);
+    // zero-width — doesn't change first-char acceptance
+    case "alt": {
+      const sets = shape.firsts.map((f) => f === null ? "any" : f);
+      return unionCharSets(sets);
+    }
+  }
+}
+function allPairsDisjoint(sets) {
+  for (let i = 0; i < sets.length; i++) {
+    const a = sets[i];
+    if (a === "any") return false;
+    for (let j = i + 1; j < sets.length; j++) {
+      const b = sets[j];
+      if (b === "any" || !classDisjoint(a, b)) return false;
+    }
+  }
+  return true;
+}
+function parseAlternation(source) {
+  const parts = splitTopLevelAlternation(source);
+  if (!parts) return null;
+  const arms = [];
+  for (const p of parts) {
+    const arm = parseScanShape(p);
+    if (!arm) return null;
+    arms.push(arm);
+  }
+  const firstSets = arms.map(shapeFirstAccept);
+  const disjoint = allPairsDisjoint(firstSets);
+  return { kind: "alt", arms, disjoint, firsts: firstSets.map((f) => f === "any" ? null : f) };
+}
 function parseScanShape(source) {
+  const alt = parseAlternation(source);
+  if (alt) return alt;
+  const la = stripTrailingLookahead(source);
+  if (la) {
+    const inner = parseScanShapeCore(la.base);
+    if (!inner) return null;
+    const operand = { ranges: la.ranges, negated: la.classNegated };
+    if (!lookaheadUnambiguous(inner, operand, la.negative)) return null;
+    return { kind: "lookahead", inner, ranges: la.ranges, classNegated: la.classNegated, negative: la.negative };
+  }
+  return parseScanShapeCore(source);
+}
+function splitDelimArms(body) {
+  const arms = [];
+  let depth = 0;
+  let last = 0;
+  let i = 0;
+  while (i < body.length) {
+    const ch = body[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "[") {
+      let j = i + 1;
+      if (body[j] === "^") j++;
+      while (j < body.length && body[j] !== "]") {
+        if (body[j] === "\\") j += 2;
+        else j++;
+      }
+      if (body[j] !== "]") return null;
+      i = j + 1;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      depth--;
+      if (depth < 0) return null;
+      i++;
+      continue;
+    }
+    if (ch === "|" && depth === 0) {
+      arms.push(body.slice(last, i));
+      last = i + 1;
+    }
+    i++;
+  }
+  if (depth !== 0) return null;
+  arms.push(body.slice(last));
+  return arms;
+}
+function delimitedBodySound(body, close) {
+  const l0 = close[0];
+  if (close.length > 2) return false;
+  const arms = splitDelimArms(body);
+  if (!arms) return false;
+  let bulkSeen = false;
+  let guardSeen = false;
+  for (const arm of arms) {
+    const bulk = /^\[\^((?:\\.|[^\]])+)\]$/.exec(arm);
+    if (bulk) {
+      if (bulkSeen) return false;
+      const ranges = parseClassRanges(bulk[1]);
+      if (!ranges || ranges.length !== 1 || ranges[0][0] !== l0 || ranges[0][1] !== l0) return false;
+      bulkSeen = true;
+      continue;
+    }
+    if (close.length === 2 && arm.endsWith(")")) {
+      const idx = arm.indexOf("(?!");
+      if (idx === -1) return false;
+      const prefix = literalCodePoints(arm.slice(0, idx));
+      const op = parseClassOperand(arm.slice(idx + 3, -1));
+      const prefixIsL0 = prefix?.length === 1 && prefix[0] === l0;
+      const forbidsL1 = op && !op.negated && op.ranges.length === 1 && op.ranges[0][0] === close[1] && op.ranges[0][1] === close[1];
+      if (!prefixIsL0 || !forbidsL1 || guardSeen) return false;
+      guardSeen = true;
+      continue;
+    }
+    return false;
+  }
+  return bulkSeen && guardSeen === (close.length === 2);
+}
+function parseDelimited(source) {
+  if (source.includes("\\\\")) return null;
+  let i = 0;
+  while (i < source.length && source[i] !== "(") {
+    i += source[i] === "\\" ? 2 : 1;
+  }
+  if (source[i] !== "(" || source[i + 1] !== "?" || source[i + 2] !== ":") return null;
+  const openFrag = source.slice(0, i);
+  let k = i + 3;
+  let depth = 1;
+  while (k < source.length && depth > 0) {
+    const ch = source[k];
+    if (ch === "\\") {
+      k += 2;
+      continue;
+    }
+    if (ch === "[") {
+      let j = k + 1;
+      if (source[j] === "^") j++;
+      while (j < source.length && source[j] !== "]") {
+        if (source[j] === "\\") j += 2;
+        else j++;
+      }
+      if (source[j] !== "]") return null;
+      k = j + 1;
+      continue;
+    }
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    k++;
+  }
+  if (depth !== 0) return null;
+  const body = source.slice(i + 3, k - 1);
+  if (source[k] !== "*") return null;
+  const closeFrag = source.slice(k + 1);
+  const open = literalCodePoints(openFrag);
+  const close = literalCodePoints(closeFrag);
+  if (!open || !close || !delimitedBodySound(body, close)) return null;
+  return { kind: "delimited", open, close };
+}
+function parseScanShapeCore(source) {
   let m = /^\[((?:\\.|[^\]])+)\]([+*])$/.exec(source);
-  if (m) {
-    if (m[1].startsWith("^")) return null;
+  if (m && !m[1].startsWith("^")) {
     const ranges = parseClassRanges(m[1]);
     return ranges ? { kind: "chars", ranges, minOne: m[2] === "+" } : null;
   }
-  m = /^\\([dw])([+*])$/.exec(source);
+  m = /^\\([dws])([+*])$/.exec(source);
   if (m) {
     return { kind: "chars", ranges: shorthandRanges(m[1]), minOne: m[2] === "+" };
   }
-  m = /^(\[(?:\\.|[^\]])+\]|\\[dw])(\[(?:\\.|[^\]])+\]|\\[dw])\*$/.exec(source);
+  m = /^(\[(?:\\.|[^\]])+\]|\\[dws])(\[(?:\\.|[^\]])+\]|\\[dws])\*$/.exec(source);
   if (m) {
     const head = classToRanges(m[1]);
     const tail = classToRanges(m[2]);
-    return head && tail ? { kind: "ident", head, tail } : null;
+    if (head && tail) return { kind: "ident", head, tail };
   }
   const str = parseStringShape(source);
   if (str) return str;
@@ -1515,20 +2138,19 @@ function parseScanShape(source) {
     const open = literalCodePoints(m[1]);
     const stop = parseClassRanges(m[2]);
     if (open && stop) return { kind: "until", open, stop };
-    return null;
-  }
-  if (!source.includes("\\\\")) {
-    m = /^(.*?)\((?:\?:)?[\s\S]*\)\*(.*?)$/.exec(source);
-    if (m && m[1] && m[2]) {
-      const open = literalCodePoints(m[1]);
-      const close = literalCodePoints(m[2]);
-      if (open && close) return { kind: "delimited", open, close };
-    }
   }
+  const delim = parseDelimited(source);
+  if (delim) return delim;
+  const parts = parseSeqParts(source);
+  if (parts && seqIsUnambiguous(parts)) return { kind: "seq", parts };
   return null;
 }
 function scanShapeFromRegex(source, flags) {
-  if (/[imsu]/.test(flags)) return null;
+  if (/[msu]/.test(flags)) return null;
+  if (/i/.test(flags)) {
+    const open = literalCodePoints(source);
+    return open ? { kind: "litFold", open } : null;
+  }
   return parseScanShape(source);
 }
 var classCond = (cVar, ranges) => ranges.map(([lo, hi]) => lo === hi ? `${cVar} === ${lo}` : `(${cVar} >= ${lo} && ${cVar} <= ${hi})`).join(" || ");
@@ -1543,6 +2165,53 @@ function stringHardStop(shape) {
 }
 var codeAt = (start, firstChar) => firstChar ?? `input.charCodeAt(${start})`;
 function emitShapeMatch(shape, start, mint, ind2, firstChar) {
+  if (shape.kind === "lookahead") {
+    const inner = emitShapeMatch(shape.inner, start, mint, ind2, firstChar);
+    const okV = mint("_ok");
+    const endV2 = mint("_end");
+    const rawIn = classCond(`input.charCodeAt(${inner.end})`, shape.ranges);
+    const charInClass = shape.classNegated ? `!(${rawIn})` : `(${rawIn})`;
+    const hasMatchingChar = `${inner.end} < input.length && ${charInClass}`;
+    const guardFails = shape.negative ? hasMatchingChar : `!(${hasMatchingChar})`;
+    return {
+      setup: [
+        ...inner.setup,
+        `${ind2}let ${okV} = ${inner.ok}`,
+        `${ind2}let ${endV2} = ${inner.end}`,
+        `${ind2}if (${okV} && (${guardFails})) { ${okV} = false; ${endV2} = ${start} }`
+      ],
+      ok: okV,
+      end: endV2
+    };
+  }
+  if (shape.kind === "alt") {
+    const okV = mint("_ok");
+    const endV2 = mint("_end");
+    const lines = [`${ind2}let ${okV} = false`, `${ind2}let ${endV2} = ${start}`];
+    if (shape.disjoint) {
+      const c0 = codeAt(start, firstChar);
+      shape.arms.forEach((arm, k) => {
+        const fs = shape.firsts[k];
+        const cond = fs.negated ? `!(${classCond(c0, fs.ranges)})` : `(${classCond(c0, fs.ranges)})`;
+        const m = emitShapeMatch(arm, start, mint, `${ind2}  `, firstChar);
+        lines.push(`${ind2}${k === 0 ? "if" : "else if"} (${start} < input.length && ${cond}) {`);
+        lines.push(...m.setup);
+        lines.push(`${ind2}  ${okV} = ${m.ok}`);
+        lines.push(`${ind2}  ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+        lines.push(`${ind2}}`);
+      });
+    } else {
+      const lbl = mint("_alt");
+      lines.push(`${ind2}${lbl}: {`);
+      for (const arm of shape.arms) {
+        const m = emitShapeMatch(arm, start, mint, `${ind2}  `, firstChar);
+        lines.push(...m.setup);
+        lines.push(`${ind2}  if (${m.ok}) { ${okV} = true; ${endV2} = ${m.end}; break ${lbl} }`);
+      }
+      lines.push(`${ind2}}`);
+    }
+    return { setup: lines, ok: okV, end: endV2 };
+  }
   if (shape.kind === "chars") {
     const cur = mint("_e");
     return {
@@ -1569,6 +2238,82 @@ function emitShapeMatch(shape, start, mint, ind2, firstChar) {
       end: cur
     };
   }
+  if (shape.kind === "seq") {
+    const endV2 = mint("_e");
+    const okV = mint("_ok");
+    const runCond = (p, at) => {
+      const c = classCond(`input.charCodeAt(${at})`, p.ranges);
+      return p.negated ? `!(${c})` : `(${c})`;
+    };
+    const lines = [`${ind2}let ${endV2} = ${start}`, `${ind2}let ${okV} = false`, `${ind2}do {`];
+    let first = true;
+    for (const p of shape.parts) {
+      if (p.part === "lit") {
+        const L = p.cps.length;
+        const cond = litCond(endV2, p.cps, first ? firstChar : void 0);
+        if (p.optional) {
+          lines.push(`${ind2}  if (${endV2} + ${L} <= input.length && (${cond})) ${endV2} += ${L}`);
+        } else {
+          lines.push(`${ind2}  if (!(${endV2} + ${L} <= input.length && (${cond}))) break`);
+          lines.push(`${ind2}  ${endV2} += ${L}`);
+        }
+      } else if (p.part === "run" && !p.unbounded) {
+        if (p.min === 1) {
+          lines.push(`${ind2}  if (!(${endV2} < input.length && ${runCond(p, endV2)})) break`);
+          lines.push(`${ind2}  ${endV2}++`);
+        } else {
+          lines.push(`${ind2}  if (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
+        }
+      } else if (p.part === "run") {
+        const s = mint("_s");
+        lines.push(`${ind2}  const ${s} = ${endV2}`);
+        lines.push(`${ind2}  while (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
+        if (p.min === 1) lines.push(`${ind2}  if (${endV2} === ${s}) break`);
+      } else {
+        const inner = emitShapeMatch(p.inner, endV2, mint, `${ind2}  `, first ? firstChar : void 0);
+        if (!p.unbounded) {
+          lines.push(...inner.setup);
+          if (p.min === 1) {
+            lines.push(`${ind2}  if (!(${inner.ok})) break`);
+            lines.push(`${ind2}  ${endV2} = ${inner.end}`);
+          } else {
+            lines.push(`${ind2}  if (${inner.ok}) ${endV2} = ${inner.end}`);
+          }
+        } else {
+          const progV = mint("_prog");
+          lines.push(`${ind2}  let ${progV} = false`);
+          lines.push(`${ind2}  while (true) {`);
+          lines.push(...inner.setup);
+          lines.push(`${ind2}    if (!(${inner.ok})) break`);
+          lines.push(`${ind2}    ${endV2} = ${inner.end}`);
+          lines.push(`${ind2}    ${progV} = true`);
+          lines.push(`${ind2}  }`);
+          if (p.min === 1) lines.push(`${ind2}  if (!${progV}) break`);
+        }
+      }
+      first = false;
+    }
+    lines.push(`${ind2}  ${okV} = true`);
+    lines.push(`${ind2}} while (false)`);
+    lines.push(`${ind2}if (!${okV}) ${endV2} = ${start}`);
+    return { setup: lines, ok: okV, end: endV2 };
+  }
+  if (shape.kind === "litFold") {
+    const openLen2 = shape.open.length;
+    const endV2 = mint("_end");
+    const checks = shape.open.map((cp, k) => {
+      const cVar = k === 0 && firstChar ? firstChar : `input.charCodeAt(${start} + ${k})`;
+      return foldEq(cVar, cp);
+    });
+    return {
+      setup: [
+        `${ind2}let ${endV2} = ${start}`,
+        `${ind2}if (${start} + ${openLen2} <= input.length && (${checks.join(" && ")})) ${endV2} = ${start} + ${openLen2}`
+      ],
+      ok: `${endV2} > ${start}`,
+      end: endV2
+    };
+  }
   if (shape.kind === "until") {
     const j2 = mint("_j");
     const openLen2 = shape.open.length;
@@ -1850,6 +2595,7 @@ function looseMkBuildRe(type) {
   );
 }
 function analyzeMkInlineBuild(def) {
+  if (!def.build) return null;
   const src = (def.buildSrc ?? def.build.toString()).trim();
   const strict = src.match(MK_BUILD_RE);
   if (strict) {
@@ -1947,6 +2693,15 @@ function v(ctx, prefix = "_v") {
 function ind(ctx) {
   return "  ".repeat(ctx.indent);
 }
+function nsp(ctx) {
+  return ctx.ns ?? "";
+}
+function mfRef(ctx) {
+  return `${nsp(ctx)}_mf`;
+}
+function buildRef(ctx) {
+  return `${nsp(ctx)}_build`;
+}
 function reindentStmts(stmts, targetLevels) {
   const nonEmpty = stmts.filter((s) => s.trim().length > 0);
   if (nonEmpty.length === 0) return stmts;
@@ -1963,8 +2718,8 @@ function failReturnArr(expectedArr, posExpr) {
 function hoistExpected(ctx, constArrSource) {
   let name = ctx.expectedMap.get(constArrSource);
   if (name === void 0) {
-    name = `_fx${ctx.expectedDecls.length}`;
-    ctx.expectedDecls.push(`const ${name} = Object.freeze(${constArrSource})`);
+    name = `${nsp(ctx)}_fx${ctx.expectedDecls.length}`;
+    ctx.expectedDecls.push(`const ${name} = ${constArrSource}`);
     ctx.expectedMap.set(constArrSource, name);
   }
   return name;
@@ -2062,13 +2817,13 @@ function emitLeafCapture(ctx, valExpr, startExpr, endExpr) {
     `${i}}`
   ];
 }
-function ensureRegexDecl(ctx, optimizedSource, flags) {
+function ensureRegexDecl(ctx, source, flags) {
   const f = "y" + flags.replace(/[gy]/g, "");
-  const key = `${optimizedSource}/${f}`;
+  const key = `${source}/${f}`;
   let rName = ctx.regexMap.get(key);
   if (rName === void 0) {
-    rName = `_re${ctx.regexDecls.length}`;
-    ctx.regexDecls.push(`const ${rName} = /${optimizedSource}/${f}`);
+    rName = `${nsp(ctx)}_re${ctx.regexDecls.length}`;
+    ctx.regexDecls.push(`const ${rName} = /${source}/${f}`);
     ctx.regexMap.set(key, rName);
   }
   return rName;
@@ -2077,7 +2832,7 @@ function ensureTriviaFn(ctx) {
   const trivia2 = ctx.activeTrivia;
   const existing = ctx.triviaFnNames.get(trivia2);
   if (existing) return existing;
-  const fnName = `_tf${ctx.triviaFnNames.size}`;
+  const fnName = `${nsp(ctx)}_tf${ctx.triviaFnNames.size}`;
   ctx.triviaFnNames.set(trivia2, fnName);
   ctx.triviaCaptureNames.set(trivia2, fnName);
   const labeledSpec = analyzeLabeledTrivia(trivia2);
@@ -2099,7 +2854,7 @@ function ensureTriviaFn(ctx) {
       for (const arm of regexSpec.arms) {
         const def = arm.parser._def;
         if (def.tag !== "regex") break;
-        reNames.push(ensureRegexDecl(ctx, def.optimizedSource, def.flags));
+        reNames.push(ensureRegexDecl(ctx, def.source, def.flags));
       }
       if (reNames.length === regexSpec.arms.length) {
         ctx.namedFnDecls.push(buildLabeledRegexTriviaFnDecl(fnName, regexSpec, reNames));
@@ -2286,18 +3041,21 @@ function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
       return true;
   }
 }
-function emitFallible(inner, ctx, pos) {
+function emitFallible(inner, ctx, pos, swallow = false) {
   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;
+  const savedRecord = ctx.recordFail;
   ctx.failLabel = lbl;
   ctx.indent = savedIndent + 1;
+  if (swallow) ctx.recordFail = false;
   const r = emit(inner, ctx, pos);
   ctx.failLabel = savedLabel;
   ctx.indent = savedIndent;
+  ctx.recordFail = savedRecord;
   const ind0 = ind(ctx);
   const needsRollback = ctx.capturing && mayLeavePartialCapture(inner);
   const mL = needsRollback ? v(ctx, "_fcl") : null;
@@ -2320,6 +3078,7 @@ function emitFallible(inner, ctx, pos) {
   ];
   return { stmts, okVar: okV, valVar: valV, endVar: endV };
 }
+var CHARCODE_CHAIN_MAX = 16;
 function emitLit(def, ctx, pos) {
   const { value, caseInsensitive } = def;
   const len = value.length;
@@ -2342,7 +3101,7 @@ function emitLit(def, ctx, pos) {
       ...emitIfFail(ctx, `${pos} >= input.length || input.charCodeAt(${pos}) !== ${code}`, failBody(ctx, expectedStr, pos)),
       `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`
     );
-  } else if (len <= 4) {
+  } else if (len <= CHARCODE_CHAIN_MAX) {
     const checks = Array.from(
       { length: len },
       (_, i) => `input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ""}) !== ${value.codePointAt(i)}`
@@ -2364,7 +3123,55 @@ function emitLit(def, ctx, pos) {
 function escapeKeywordRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function emitKeywordsFast(def, ctx, pos) {
+  if (def.words.length === 0 || def.words.some((w) => w.length === 0)) return null;
+  if (def.words.some((w) => Array.from(w).length !== w.length)) return null;
+  if (def.caseInsensitive && def.boundary) return null;
+  let boundary = null;
+  if (def.boundary) {
+    let body = def.boundary;
+    const negated = body.startsWith("^");
+    if (negated) body = body.slice(1);
+    const ranges = parseClassRanges(body);
+    if (!ranges) return null;
+    boundary = { ranges, negated };
+  }
+  const mint = (prefix = "_v") => v(ctx, prefix);
+  const lbl = v(ctx, "_kwLbl");
+  const valV = v(ctx, "_kwv");
+  const endV = v(ctx, "_kwe");
+  const bodyInd = ind(ctx) + "  ";
+  const tries = [];
+  for (const w of def.words) {
+    const cps = Array.from(w, (ch) => ch.codePointAt(0));
+    let shape = def.caseInsensitive ? { kind: "litFold", open: cps } : { kind: "seq", parts: [{ part: "lit", cps, optional: false }] };
+    if (boundary) {
+      shape = { kind: "lookahead", inner: shape, ranges: boundary.ranges, classNegated: boundary.negated, negative: true };
+    }
+    const m = emitShapeMatch(shape, pos, mint, bodyInd);
+    tries.push(
+      ...m.setup,
+      // Slice from input rather than reusing the literal word: `caseInsensitive`
+      // must return the text as it actually appeared (e.g. "ABC" for keyword
+      // "abc"), matching what the original `RegExp.exec()[0]` returned.
+      `${bodyInd}if (${m.ok}) { ${valV} = input.slice(${pos}, ${m.end}); ${endV} = ${m.end}; break ${lbl} }`
+    );
+  }
+  const stmts = [
+    `${ind(ctx)}let ${valV} = '', ${endV} = ${pos}`,
+    `${ind(ctx)}${lbl}: {`,
+    ...tries,
+    `${ind(ctx)}}`,
+    // Every word has length >= 1 (checked above), so a real match always
+    // advances past `pos` — `endV === pos` only happens when no candidate matched.
+    ...emitIfFail(ctx, `${endV} === ${pos}`, failBody(ctx, '"keyword"', pos))
+  ];
+  stmts.push(...emitLeafCapture(ctx, valV, pos, endV));
+  return { stmts, valueVar: valV, endVar: endV };
+}
 function emitKeywords(def, ctx, pos) {
+  const fast = emitKeywordsFast(def, ctx, pos);
+  if (fast) return fast;
   const alt = def.words.map(escapeKeywordRe).join("|");
   const boundary = def.boundary ? `(?![${def.boundary}])` : "";
   const flags = def.caseInsensitive ? "iuy" : "uy";
@@ -2372,7 +3179,7 @@ function emitKeywords(def, ctx, pos) {
   const key = `${source}/${flags}`;
   let rName = ctx.regexMap.get(key);
   if (rName === void 0) {
-    rName = `_re${ctx.regexDecls.length}`;
+    rName = `${nsp(ctx)}_re${ctx.regexDecls.length}`;
     ctx.regexDecls.push(`const ${rName} = /${source}/${flags}`);
     ctx.regexMap.set(key, rName);
   }
@@ -2406,11 +3213,11 @@ function emitRegex(def, ctx, pos) {
     }
   }
   const flags = "y" + def.flags.replace(/[gy]/g, "");
-  const key = `${def.optimizedSource}/${flags}`;
+  const key = `${def.source}/${flags}`;
   let rName = ctx.regexMap.get(key);
   if (rName === void 0) {
-    rName = `_re${ctx.regexDecls.length}`;
-    ctx.regexDecls.push(`const ${rName} = /${def.optimizedSource}/${flags}`);
+    rName = `${nsp(ctx)}_re${ctx.regexDecls.length}`;
+    ctx.regexDecls.push(`const ${rName} = /${def.source}/${flags}`);
     ctx.regexMap.set(key, rName);
   }
   const mv = v(ctx, "_m");
@@ -2495,6 +3302,31 @@ function failsAtStart(p) {
       return false;
   }
 }
+function armStaticExpected(ctx, p) {
+  return hoistExpected(ctx, staticExpectedArr([p]));
+}
+function canMatchEmptyAtStart(p) {
+  const d = p._def;
+  switch (d.tag) {
+    case "regex":
+      return /(?:[*?]|\{0,|\{\d*,)/.test(d.source);
+    case "optional":
+      return true;
+    case "many":
+      return true;
+    case "transform":
+    case "label":
+      return canMatchEmptyAtStart(d.parser);
+    case "literal":
+      return d.value.length === 0;
+    default:
+      return false;
+  }
+}
+function needsFirstSetGuard(p) {
+  const fs = p._meta.firstSet;
+  return fs.kind !== "any" && !canMatchEmptyAtStart(p);
+}
 function emitDisjointArm(p, ctx, pos, valV, endV) {
   if (failsAtStart(p)) {
     const r = emit(p, ctx, pos);
@@ -2562,7 +3394,7 @@ function emitGreedyClassify(def, superIndex, ctx, pos) {
   const reKey = `${regexDef.source}/${cleanFlags}`;
   let reVar = ctx.regexMap.get(reKey);
   if (reVar === void 0) {
-    reVar = `_re${ctx.regexDecls.length}`;
+    reVar = `${nsp(ctx)}_re${ctx.regexDecls.length}`;
     ctx.regexDecls.push(`const ${reVar} = /${regexDef.source}/${cleanFlags}`);
     ctx.regexMap.set(reKey, reVar);
   }
@@ -2636,21 +3468,26 @@ function emitFirstMatch(def, ctx, pos) {
   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 ind0 = ind(ctx);
   const stmts = [
     `${ind0}let ${resValV}, ${resEndV} = ${pos}, ${resOkV} = false`,
-    `${ind0}let ${slots.join(", ")}`
+    `${ind0}let ${slots.join(", ")}`,
+    `${ind0}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`
   ];
   for (let i = 0; i < def.parsers.length; i++) {
     const p = def.parsers[i];
     const gate = def.gates[i];
     const autoNot = def.autoNot[i];
+    const atStart = failsAtStart(p);
+    const staticFx = armStaticExpected(ctx, p);
+    const fsGuard = needsFirstSetGuard(p) ? firstSetCond(codeV, p._meta.firstSet) : null;
     let gateCond = null;
     if (gate) {
       const gateIdx = ctx.mapFns.length;
       ctx.mapFns.push(gate);
-      gateCond = `_mf[${gateIdx}](_ctx.state)`;
+      gateCond = `${mfRef(ctx)}[${gateIdx}](_ctx.state)`;
     }
     const skipCond = gateCond ? `!${resOkV} && ${gateCond}` : `!${resOkV}`;
     const armHasAutoNot = !!(autoNot && autoNot.length > 0);
@@ -2660,39 +3497,41 @@ function emitFirstMatch(def, ctx, pos) {
     const markTl = armNeedsRollback ? v(ctx, "_cmtl") : null;
     const markLog = armNeedsRollback ? v(ctx, "_cmlg") : null;
     const rollback = markLeaves ? captureRestoreBody(markLeaves, markRaw, markTl, markLog) : "";
+    const failSlot = atStart ? staticFx : "_ctx._fx";
     stmts.push(`${ind0}if (${skipCond}) {`);
-    ctx.indent++;
-    const ind1 = ind(ctx);
+    if (fsGuard) stmts.push(`${ind(ctx)}if (${fsGuard}) {`);
+    ctx.indent += fsGuard ? 2 : 1;
     if (markLeaves) {
       stmts.push(
-        `${ind1}const ${markLeaves} = _ctx._cstLeaves?.length ?? 0`,
-        `${ind1}const ${markRaw} = _ctx._cstRawChildren?.length ?? 0`,
-        `${ind1}const ${markTl} = _ctx._cstTriviaLog?.length ?? 0`,
-        `${ind1}const ${markLog} = _ctx._triviaLog?.length ?? 0`
+        `${ind(ctx)}const ${markLeaves} = _ctx._cstLeaves?.length ?? 0`,
+        `${ind(ctx)}const ${markRaw} = _ctx._cstRawChildren?.length ?? 0`,
+        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog?.length ?? 0`,
+        `${ind(ctx)}const ${markLog} = _ctx._triviaLog?.length ?? 0`
       );
     }
-    const { stmts: armStmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos);
+    const { stmts: armStmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos, atStart);
     stmts.push(...armStmts);
-    ctx.indent--;
     if (autoNot && autoNot.length > 0) {
       const anCode = v(ctx, "_anc");
       const rejectCond = autoNot.map(
         (check) => check.kind === "firstSet" ? firstSetCond(anCode, check.set) : `input.startsWith(${JSON.stringify(check.value)}, ${endVar})`
       ).join(" || ");
-      stmts.push(`${ind0}  if (${okVar}) {`);
-      stmts.push(`${ind0}    const ${anCode} = ${endVar} < input.length ? input.charCodeAt(${endVar}) : -1`);
-      stmts.push(`${ind0}    if (!(${rejectCond})) {`);
-      stmts.push(`${ind0}      ${resValV} = ${valVar}`);
-      stmts.push(`${ind0}      ${resEndV} = ${endVar}`);
-      stmts.push(`${ind0}      ${resOkV} = true`);
-      stmts.push(`${ind0}    }`);
-      stmts.push(`${ind0}  }`);
-      stmts.push(`${ind0}  else { ${slots[i]} = _ctx._fx }`);
-      if (rollback) stmts.push(`${ind0}  if (!${resOkV}) { ${rollback} }`);
+      stmts.push(`${ind(ctx)}if (${okVar}) {`);
+      stmts.push(`${ind(ctx)}  const ${anCode} = ${endVar} < input.length ? input.charCodeAt(${endVar}) : -1`);
+      stmts.push(`${ind(ctx)}  if (!(${rejectCond})) {`);
+      stmts.push(`${ind(ctx)}    ${resValV} = ${valVar}`);
+      stmts.push(`${ind(ctx)}    ${resEndV} = ${endVar}`);
+      stmts.push(`${ind(ctx)}    ${resOkV} = true`);
+      stmts.push(`${ind(ctx)}  }`);
+      stmts.push(`${ind(ctx)}}`);
+      stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot} }`);
+      if (rollback) stmts.push(`${ind(ctx)}if (!${resOkV}) { ${rollback} }`);
     } else {
-      stmts.push(`${ind0}  if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true }`);
-      stmts.push(`${ind0}  else { ${slots[i]} = _ctx._fx${rollback ? `; ${rollback}` : ""} }`);
+      stmts.push(`${ind(ctx)}if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true }`);
+      stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot}${rollback ? `; ${rollback}` : ""} }`);
     }
+    ctx.indent -= fsGuard ? 2 : 1;
+    if (fsGuard) stmts.push(`${ind(ctx)}} else { ${slots[i]} = ${staticFx} }`);
     stmts.push(`${ind0}}`);
   }
   const concatExpr = `[${slots.map((s) => `...(${s} || [])`).join(", ")}]`;
@@ -2715,7 +3554,7 @@ function emitTransformChain(p, baseValue, endV, startPos, ctx) {
     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} })`],
+      stmts: [...innerR.stmts, `${ind(ctx)}const ${vv} = ${mfRef(ctx)}[${fnIdx}](${innerR.valueVar}, { start: ${startPos}, end: ${endV} })`],
       valueVar: vv,
       endVar: endV
     };
@@ -2725,7 +3564,7 @@ function emitTransformChain(p, baseValue, endV, startPos, ctx) {
 function emitLiteralCondition(litVal, pos) {
   const len = litVal.length;
   if (len === 0) return "true";
-  if (len > 4) return `input.startsWith(${JSON.stringify(litVal)}, ${pos})`;
+  if (len > CHARCODE_CHAIN_MAX) return `input.startsWith(${JSON.stringify(litVal)}, ${pos})`;
   const checks = [`${pos} + ${len} <= input.length`];
   for (let i = 0; i < len; i++) {
     const code = litVal.codePointAt(i);
@@ -2774,7 +3613,7 @@ function emitMany(def, ctx, pos) {
       itemPos = npV;
     }
   }
-  const { stmts: iterStmts, okVar: iterOk, valVar: iterVal, endVar: iterEnd } = emitFallible(def.parser, ctx, itemPos);
+  const { stmts: iterStmts, okVar: iterOk, valVar: iterVal, endVar: iterEnd } = emitFallible(def.parser, ctx, itemPos, true);
   stmts.push(
     ...iterStmts,
     `${ind(ctx)}if (!${iterOk} || ${iterEnd} <= ${itemPos}) { ${rollback}break }`,
@@ -2788,7 +3627,7 @@ function emitMany(def, ctx, pos) {
 function emitOptional(def, ctx, pos) {
   const valV = v(ctx, "_opt");
   const endV = v(ctx, "_opte");
-  const { stmts: lblStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos);
+  const { stmts: lblStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos, true);
   const ind0 = ind(ctx);
   const stmts = [
     ...lblStmts,
@@ -2800,7 +3639,7 @@ function emitOptional(def, ctx, pos) {
 function emitSepBy(_p, def, ctx, pos) {
   const arrV = v(ctx, "_arr");
   const curV = v(ctx, "_cur");
-  const { stmts: firstStmts, okVar: firstOk, valVar: firstVal, endVar: firstEnd } = emitFallible(def.parser, ctx, pos);
+  const { stmts: firstStmts, okVar: firstOk, valVar: firstVal, endVar: firstEnd } = emitFallible(def.parser, ctx, pos, true);
   const stmts = [
     `${ind(ctx)}const ${arrV} = []`,
     `${ind(ctx)}let ${curV} = ${pos}`,
@@ -2832,11 +3671,11 @@ function emitSepBy(_p, def, ctx, pos) {
       );
       sepAtPos = spV;
       const rollbackToSep = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `;
-      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos);
+      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true);
       stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}break }`);
       const npV = v(ctx, "_np");
       stmts.push(`${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx, 1)`);
-      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV);
+      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV, true);
       stmts.push(
         ...nextStmts,
         // item failed → unwind the separator too, back to the end of the last item
@@ -2849,11 +3688,11 @@ function emitSepBy(_p, def, ctx, pos) {
       const spV = v(ctx, "_sp");
       stmts.push(`${ind(ctx)}const ${spV} = ${trivFn}(input, ${curV}, _ctx)`);
       sepAtPos = spV;
-      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos);
+      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true);
       stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`);
       const npV = v(ctx, "_np");
       stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${sepEnd}, _ctx)`);
-      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV);
+      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV, true);
       stmts.push(
         ...nextStmts,
         `${ind(ctx)}if (!${nextOk}) break`,
@@ -2870,10 +3709,10 @@ function emitSepBy(_p, def, ctx, pos) {
         `${ind(ctx)}const ${markRw} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`
       );
     }
-    const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos);
+    const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true);
     stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`);
     const nextRb = markLv ? `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markRw}; ` : "";
-    const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, sepEnd);
+    const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, sepEnd, true);
     stmts.push(
       ...nextStmts,
       `${ind(ctx)}if (!${nextOk}) { ${nextRb}break }`,
@@ -2931,7 +3770,7 @@ function emitScanTo(def, ctx, pos) {
   return { stmts, valueVar: valV, endVar: curV };
 }
 function emitNot(def, ctx, pos) {
-  const { stmts, okVar } = emitFallible(def.parser, ctx, pos);
+  const { stmts, okVar } = emitFallible(def.parser, ctx, pos, true);
   const label2 = JSON.stringify(`not(${def.parser._tag})`);
   return {
     stmts: [
@@ -2943,16 +3782,17 @@ function emitNot(def, ctx, pos) {
   };
 }
 function emitNode(def, ctx, pos) {
-  const mkType = analyzeMkInlineBuild(def);
+  const structural = def.build === void 0;
+  const mkType = structural ? null : analyzeMkInlineBuild(def);
   let buildIdx = null;
-  if (!mkType) {
+  if (!mkType && !structural) {
     buildIdx = ctx.buildFns.length;
     ctx.buildFns.push(def.build);
     ctx.buildSrcs.push(def.buildSrc ?? null);
   }
   const i = ind(ctx);
-  const capturesTrivia = mkType !== null || buildReadsTrivia(def);
-  const clonesState = buildReadsState(def);
+  const capturesTrivia = mkType !== null || structural || buildReadsTrivia(def);
+  const clonesState = structural || buildReadsState(def);
   const chV = v(ctx, "_ch");
   const rawV = v(ctx, "_raw");
   const tlV = capturesTrivia ? v(ctx, "_tl") : "_EMPTY_TL";
@@ -2975,7 +3815,8 @@ function emitNode(def, ctx, pos) {
     stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
   }
   const ndV = v(ctx, "_nd");
-  const ndExpr = mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, pos, endVar, tlV) : `_build[${buildIdx}](${chV}, ${rawV}, { start: ${pos}, end: ${endVar} }, ${tlV}, ${stV})`;
+  const buildExpr = structural ? `{ _tag: 'node', type: ${JSON.stringify(def.type)}, span: { start: ${pos}, end: ${endVar} }, state: ${stV} ?? null, children: ${chV} }` : mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, pos, endVar, tlV) : `${buildRef(ctx)}[${buildIdx}](${chV}, ${rawV}, { start: ${pos}, end: ${endVar} }, ${tlV}, ${stV})`;
+  const ndExpr = ctx.ns || structural ? `_ctx.build !== undefined ? _ctx.build(${JSON.stringify(def.type)}, ${chV}, ${rawV}, { start: ${pos}, end: ${endVar} }, ${tlV}, ${stV}) : (${buildExpr})` : buildExpr;
   const finalExpr = def.collapse ? `${chV}.length === 1 ? (${chV}[0] !== null && typeof ${chV}[0] === 'object' && ${chV}[0]._tag === 'leaf' ? ${chV}[0].value : ${chV}[0]) : (${ndExpr})` : ndExpr;
   stmts.push(
     `${i}const ${ndV} = ${finalExpr}`,
@@ -3000,8 +3841,9 @@ function emitRuntimeFallback(parser2, ctx, pos) {
   return { stmts, valueVar: vv, endVar: ev };
 }
 function emitLazy(p, def, ctx, pos) {
+  const canonical = ctx.ruleNames?.get(p);
   const usage = ctx.lazyUsage;
-  if (usage && (usage.counts.get(p) ?? 0) <= 1 && !usage.recursive.has(p)) {
+  if (!canonical && usage && (usage.counts.get(p) ?? 0) <= 1 && !usage.recursive.has(p)) {
     let resolved;
     try {
       resolved = def.thunk();
@@ -3011,7 +3853,7 @@ function emitLazy(p, def, ctx, pos) {
     return emit(resolved, ctx, pos);
   }
   if (!ctx.namedParsers.has(p)) {
-    const fnName2 = `_pf${ctx.namedParsers.size}`;
+    const fnName2 = canonical ?? `${nsp(ctx)}_pf${ctx.namedParsers.size}`;
     ctx.namedParsers.set(p, fnName2);
     let resolved;
     try {
@@ -3022,11 +3864,14 @@ function emitLazy(p, def, ctx, pos) {
     }
     const savedIndent = ctx.indent;
     const savedFailLabel = ctx.failLabel;
+    const savedRecord = ctx.recordFail;
     ctx.indent = 1;
     ctx.failLabel = "_pfail";
+    ctx.recordFail = 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);
   }
   const fnName = ctx.namedParsers.get(p);
@@ -3126,7 +3971,7 @@ function emit(p, ctx, pos) {
       return {
         stmts: [
           ...inner.stmts,
-          `${ind(ctx)}const ${mv} = _mf[${fnIdx}](${inner.valueVar}, { start: ${pos}, end: ${inner.endVar} })`
+          `${ind(ctx)}const ${mv} = ${mfRef(ctx)}[${fnIdx}](${inner.valueVar}, { start: ${pos}, end: ${inner.endVar} })`
         ],
         valueVar: mv,
         endVar: inner.endVar
@@ -3189,7 +4034,7 @@ function emit(p, ctx, pos) {
       const vv = v(ctx);
       return {
         stmts: [
-          ...emitIfFail(ctx, `!_mf[${fnIdx}](_ctx.state)`, failBody(ctx, '"gate"', pos)),
+          ...emitIfFail(ctx, `!${mfRef(ctx)}[${fnIdx}](_ctx.state)`, failBody(ctx, '"gate"', pos)),
           `${ind(ctx)}const ${vv} = null`
         ],
         valueVar: vv,
@@ -3206,11 +4051,14 @@ function emit(p, ctx, pos) {
         ctx.namedParsers.set(innerParser, fnName);
         const savedIndent = ctx.indent;
         const savedFailLabel = ctx.failLabel;
+        const savedRecord = ctx.recordFail;
         ctx.indent = 1;
         ctx.failLabel = "_pfail";
+        ctx.recordFail = true;
         const innerR = emit(innerParser, ctx, "_pos");
         ctx.indent = savedIndent;
         ctx.failLabel = savedFailLabel;
+        ctx.recordFail = savedRecord;
         pushNamedFnDecl(ctx, fnName, innerR.stmts, innerR.valueVar, innerR.endVar);
       }
       const fn = ctx.namedParsers.get(innerParser);
@@ -3219,7 +4067,7 @@ function emit(p, ctx, pos) {
       const ev = v(ctx, "_wce");
       return {
         stmts: [
-          `${ind(ctx)}const ${rv} = { ..._ctx, state: _mf[${evIdx}]() }`,
+          `${ind(ctx)}const ${rv} = { ..._ctx, state: ${mfRef(ctx)}[${evIdx}]() }`,
           `${ind(ctx)}const ${vv} = ${fn}(input, ${pos}, ${rv})`,
           // withCtx runs on a spread child ctx — copy its recorded failure back
           // and propagate the inner failure verbatim (interpreter parity).
@@ -3350,6 +4198,39 @@ function analyzeLazyUsageMulti(roots) {
   for (const root of roots) walk2(root);
   return { counts, recursive };
 }
+function ruleDependencies(ruleMap) {
+  const nameOf = /* @__PURE__ */ new Map();
+  for (const [name, comb] of ruleMap) nameOf.set(comb, name);
+  const deps = /* @__PURE__ */ new Map();
+  for (const [name, comb] of ruleMap) {
+    const found = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set();
+    const walk2 = (p, isRoot) => {
+      const def = p._def;
+      const boundary = def.tag === "lazy" ? p._ruleName ?? nameOf.get(p) : nameOf.get(p);
+      if (!isRoot && boundary !== void 0) {
+        found.add(boundary);
+        return;
+      }
+      if (seen.has(p)) return;
+      seen.add(p);
+      if (def.tag === "lazy") {
+        let resolved;
+        try {
+          resolved = def.thunk();
+        } catch {
+          return;
+        }
+        walk2(resolved, false);
+        return;
+      }
+      for (const child of childrenOf(def)) walk2(child, false);
+    };
+    walk2(comb, true);
+    deps.set(name, [...found]);
+  }
+  return deps;
+}
 function compile(combinator, mapFnSources) {
   const ctx = {
     vars: 0,
@@ -3358,6 +4239,7 @@ function compile(combinator, mapFnSources) {
     regexMap: /* @__PURE__ */ new Map(),
     expectedDecls: [],
     expectedMap: /* @__PURE__ */ new Map(),
+    recordFail: true,
     mapFns: [],
     mapFnSrcs: [],
     buildFns: [],
@@ -3432,6 +4314,150 @@ function compile(combinator, mapFnSources) {
     }
   };
 }
+function compileLinkable(ruleMapArg, ns) {
+  if (!ns) throw new Error("compileLinkable: ns must be a non-empty namespace");
+  const ruleMap = ruleMapArg.filter(([, val]) => {
+    const d = val._def;
+    if (d.tag !== "lazy") return true;
+    try {
+      d.thunk();
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  const ctx = {
+    vars: 0,
+    indent: 1,
+    regexDecls: [],
+    regexMap: /* @__PURE__ */ new Map(),
+    expectedDecls: [],
+    expectedMap: /* @__PURE__ */ new Map(),
+    recordFail: true,
+    mapFns: [],
+    mapFnSrcs: [],
+    buildFns: [],
+    buildSrcs: [],
+    runtimeParsers: [],
+    needsCollator: false,
+    namedParsers: /* @__PURE__ */ new Map(),
+    triviaCaptureNames: /* @__PURE__ */ new Map(),
+    triviaFnNames: /* @__PURE__ */ new Map(),
+    namedFnDecls: [],
+    capturing: ruleMap.some(([, rule]) => hasNodeDef(rule)),
+    lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),
+    ns
+  };
+  const seen = /* @__PURE__ */ new Map();
+  const ruleNames = /* @__PURE__ */ new Map();
+  const fnNameToKey = /* @__PURE__ */ new Map();
+  for (const [key, rule] of ruleMap) {
+    const base = `_r_${key.replace(/[^A-Za-z0-9_$]/g, "_")}`;
+    const n = seen.get(base) ?? 0;
+    seen.set(base, n + 1);
+    const fn = n === 0 ? base : `${base}$${n}`;
+    ruleNames.set(rule, fn);
+    fnNameToKey.set(fn, key);
+  }
+  ctx.ruleNames = ruleNames;
+  {
+    const scanned = /* @__PURE__ */ new Set();
+    const scanExternal = (p) => {
+      if (scanned.has(p)) return;
+      scanned.add(p);
+      const def = p._def;
+      if (def.tag === "lazy") {
+        let resolved;
+        try {
+          resolved = def.thunk();
+        } catch {
+          resolved = void 0;
+        }
+        if (resolved === void 0) {
+          const name = p._ruleName;
+          if (name && !ctx.namedParsers.has(p)) {
+            const fn = `_r_${name.replace(/[^A-Za-z0-9_$]/g, "_")}`;
+            ruleNames.set(p, fn);
+            ctx.namedParsers.set(p, fn);
+          }
+          return;
+        }
+        scanExternal(resolved);
+        return;
+      }
+      for (const child of childrenOf(def)) scanExternal(child);
+    };
+    for (const [, rule] of ruleMap) scanExternal(rule);
+  }
+  const perEntry = [];
+  for (const [key, rule] of ruleMap) {
+    const fn = ruleNames.get(rule);
+    if (!ctx.namedParsers.has(rule)) {
+      ctx.namedParsers.set(rule, fn);
+      let resolved = rule;
+      const def = rule._def;
+      if (def.tag === "lazy") {
+        try {
+          resolved = def.thunk();
+        } catch {
+          return null;
+        }
+      }
+      const savedIndent = ctx.indent, savedFail = ctx.failLabel, savedRec = ctx.recordFail;
+      ctx.indent = 1;
+      ctx.failLabel = "_pfail";
+      ctx.recordFail = true;
+      const body = emit(resolved, ctx, "_pos");
+      ctx.indent = savedIndent;
+      ctx.failLabel = savedFail;
+      ctx.recordFail = savedRec;
+      pushNamedFnDecl(ctx, fn, body.stmts, body.valueVar, body.endVar);
+    }
+    perEntry.push({ key, r: emitNamedFnCall(ctx, fn, "_pos") });
+  }
+  if (ctx.runtimeParsers.length !== 0) return null;
+  const mfSrcs = ctx.mapFns.length > 0 && ctx.mapFnSrcs.every((s) => s !== null) ? ctx.mapFnSrcs : null;
+  const buildSrcs = ctx.buildFns.length > 0 && ctx.buildSrcs.every((s) => s !== null) ? ctx.buildSrcs : null;
+  const ruleFns = /* @__PURE__ */ new Map();
+  const privateFns = [];
+  for (const decl of ctx.namedFnDecls) {
+    const fnName = decl.match(/^function (\S+?)\(/)?.[1];
+    const key = fnName ? fnNameToKey.get(fnName) : void 0;
+    if (key !== void 0) ruleFns.set(key, decl);
+    else privateFns.push(decl);
+  }
+  const mfDecl = ctx.mapFns.length === 0 ? "" : mfSrcs ? `const ${mfRef(ctx)} = [${mfSrcs.join(", ")}]` : `const ${mfRef(ctx)} = _env[${JSON.stringify(nsp(ctx) + "mf")}]`;
+  const buildDecl = ctx.buildFns.length === 0 ? "" : buildSrcs ? `const ${buildRef(ctx)} = [${buildSrcs.join(", ")}]` : `const ${buildRef(ctx)} = _env[${JSON.stringify(nsp(ctx) + "build")}]`;
+  const prelude = [
+    ...ctx.regexDecls,
+    ...ctx.expectedDecls,
+    mfDecl,
+    buildDecl,
+    ...privateFns
+  ].filter(Boolean);
+  const wrappers = /* @__PURE__ */ new Map();
+  for (const { key, r } of perEntry) {
+    wrappers.set(key, [
+      `function(input, _pos, _ctx) {`,
+      `  let pos = _pos`,
+      ...r.stmts,
+      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+      `}`
+    ].join("\n"));
+  }
+  return {
+    ns,
+    keys: perEntry.map((e) => e.key),
+    prelude,
+    ruleFns,
+    wrappers,
+    deps: ruleDependencies(ruleMap),
+    needsEmptyTl: !!ctx.needsEmptyTl,
+    needsCollator: ctx.needsCollator,
+    mfFns: mfSrcs ? [] : ctx.mapFns,
+    buildFns: buildSrcs ? [] : ctx.buildFns
+  };
+}
 function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources) {
   const bodyLines = [
     `  let pos = _pos`,
@@ -3470,6 +4496,87 @@ function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources)
   ].join("\n");
 }
 
+// src/compiler/linker.ts
+var _nsCounter = 0;
+function linkable(rulesMap, ns) {
+  const pieces = compileLinkable([...Object.entries(rulesMap)], ns ?? `_lk${_nsCounter++}_`);
+  if (!pieces) throw new Error("linkable(): this grammar cannot be compiled to a linkable artifact (contains a runtime-only parser fallback)");
+  return pieces;
+}
+function cstBuildHost(type, children, _rawChildren, span, _triviaLog, state) {
+  return { _tag: "node", type, span: { start: span.start, end: span.end }, state: state ?? null, children: [...children] };
+}
+function pick(grammar, names) {
+  const p = grammar.ruleFns instanceof Map ? grammar : linkable(grammar);
+  const keep = /* @__PURE__ */ new Set();
+  const has = new Set(p.keys);
+  for (const n of names) {
+    if (!has.has(n)) throw new Error(`pick: rule "${n}" is not in this grammar (available: ${p.keys.join(", ")})`);
+  }
+  const visit = (n) => {
+    if (keep.has(n) || !has.has(n)) return;
+    keep.add(n);
+    for (const d of p.deps.get(n) ?? []) visit(d);
+  };
+  for (const n of names) visit(n);
+  const filt = (m) => new Map([...m].filter(([k]) => keep.has(k)));
+  return {
+    ...p,
+    keys: [...keep],
+    ruleFns: filt(p.ruleFns),
+    wrappers: filt(p.wrappers),
+    deps: filt(p.deps)
+  };
+}
+function fusedBody(pieces) {
+  const winner = /* @__PURE__ */ new Map();
+  for (const p of pieces) for (const k of p.keys) winner.set(k, p);
+  for (const [k, p] of winner) {
+    for (const d of p.deps.get(k) ?? []) {
+      if (!winner.has(d)) throw new Error(`compose: rule "${k}" references missing rule "${d}"`);
+    }
+  }
+  const contributing = new Set(winner.values());
+  const needsEmptyTl = [...contributing].some((p) => p.needsEmptyTl);
+  const needsCollator = [...contributing].some((p) => p.needsCollator);
+  const lines = [
+    // Shared sentinel protocol (must match NAMED_FN_FAIL / NAMED_FN_END in codegen).
+    "const _pfFail = {}",
+    "let _pfEnd",
+    ...needsEmptyTl ? ["const _EMPTY_TL = Object.freeze([])"] : [],
+    ...needsCollator ? ["const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })"] : [],
+    // Each contributing artifact's namespaced private prelude (regexes, _pf, …).
+    ...[...contributing].flatMap((p) => p.prelude),
+    // The winning `_r_<Name>` function for each rule (one per name → no redeclare).
+    ...[...winner].map(([k, p]) => p.ruleFns.get(k))
+  ];
+  const wrapperEntries = [...winner].map(([k, p]) => `${JSON.stringify(k)}: ${p.wrappers.get(k)}`);
+  const body = [...lines, "return {", wrapperEntries.join(",\n"), "}"].join("\n");
+  const env = {};
+  for (const p of contributing) {
+    if (p.mfFns.length) env[`${p.ns}mf`] = p.mfFns;
+    if (p.buildFns.length) env[`${p.ns}build`] = p.buildFns;
+  }
+  return { body, env };
+}
+function fuseRules(pieces) {
+  const { body, env } = fusedBody(pieces);
+  return new Function("_env", body)(env);
+}
+var COMPOSED_PIECES = /* @__PURE__ */ Symbol.for("parseman.composedPieces");
+function itemPieces(item) {
+  const carried = item[COMPOSED_PIECES];
+  if (Array.isArray(carried)) return carried;
+  if (item.ruleFns instanceof Map) return [item];
+  return [linkable(item)];
+}
+function compose(items) {
+  const pieces = items.flatMap(itemPieces);
+  const map = fuseRules(pieces);
+  Object.defineProperty(map, COMPOSED_PIECES, { value: pieces, enumerable: false });
+  return map;
+}
+
 // src/combinators/guard.ts
 function guard(predicate) {
   const meta = {
@@ -3667,6 +4774,7 @@ function manyRecover(item, until) {
 }
 
 // src/functional/doc.ts
+var REENTRY_MAX_SPAN_FRACTION = 0.5;
 function isNode(x) {
   return typeof x === "object" && x !== null && x._tag === "node";
 }
@@ -3727,7 +4835,48 @@ function graftAndShift(root, path, newNode, delta) {
     children: newChildren
   };
 }
-var FunctionalDocImpl = class _FunctionalDocImpl {
+function structurallyEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  const at = a._tag;
+  const bt = b._tag;
+  if (at !== bt) return false;
+  const as = a.span;
+  const bs = b.span;
+  if (as || bs) {
+    if (!as || !bs || as.start !== bs.start || as.end !== bs.end) return false;
+  }
+  if (at === "leaf" || at === "trivia") {
+    return a.value === b.value;
+  }
+  if (a.type !== b.type) return false;
+  const ac = a.children;
+  const bc = b.children;
+  if (ac || bc) {
+    if (!ac || !bc || ac.length !== bc.length) return false;
+    for (let i = 0; i < ac.length; i++) if (!structurallyEqual(ac[i], bc[i])) return false;
+  }
+  return true;
+}
+function boundaryIsSafe(ruleFn, newInput, start, boundary, state, build, produced) {
+  if (!produced.ok) return false;
+  if (boundary >= newInput.length) return true;
+  for (const sentinel of [" ", "\uFFFF"]) {
+    if (newInput[boundary] === sentinel) continue;
+    const probed = newInput.slice(0, boundary) + sentinel.repeat(newInput.length - boundary);
+    const ctx = { trackLines: false, state, build };
+    let r;
+    try {
+      r = ruleFn(probed, start, ctx);
+    } catch {
+      return false;
+    }
+    if (!r.ok || r.span.end !== produced.span.end) return false;
+    if (!structurallyEqual(r.value, produced.value)) return false;
+  }
+  return true;
+}
+var ParseDocImpl = class _ParseDocImpl {
   _registry;
   _rootRule;
   _opts;
@@ -3744,7 +4893,7 @@ var FunctionalDocImpl = class _FunctionalDocImpl {
   }
   edit(from, to, replacement) {
     const newInput = this.input.slice(0, from) + replacement + this.input.slice(to);
-    const reparse = () => makeFunctionalDoc(this._registry, this._rootRule, newInput, this._opts);
+    const reparse = () => parseDoc(this._registry, this._rootRule, newInput, this._opts);
     if (!this.tree) return reparse();
     const delta = replacement.length - (to - from);
     const found = findContaining(this.tree, from);
@@ -3758,41 +4907,78 @@ var FunctionalDocImpl = class _FunctionalDocImpl {
     }
     const rebuild = this._opts.rebuild ?? defaultRebuild;
     for (const { node: node2, path } of candidates) {
+      if (node2.span.end - node2.span.start > this.input.length * REENTRY_MAX_SPAN_FRACTION) break;
       const ruleFn = this._registry[node2.type];
       if (!ruleFn) continue;
-      const ctx = { trackLines: false, state: node2.state };
+      if (!(node2.span.start <= from && to <= node2.span.end)) continue;
+      const ctx = { trackLines: false, state: node2.state, build: this._opts.build };
       const r = ruleFn(newInput, node2.span.start, ctx);
       if (!r.ok) continue;
-      if (r.span.end === node2.span.end + delta) {
-        if (delta === 0) {
-          const newTree2 = replaceAtPath(rebuild, this.tree, path, r.value);
-          return new _FunctionalDocImpl(this._registry, this._rootRule, this._opts, newTree2, [], newInput);
-        }
-        if (this._opts.rebuild) return reparse();
-        const newTree = graftAndShift(this.tree, path, r.value, delta);
-        return new _FunctionalDocImpl(this._registry, this._rootRule, this._opts, newTree, [], newInput);
+      if (r.span.end !== node2.span.end + delta) continue;
+      if (!boundaryIsSafe(ruleFn, newInput, node2.span.start, node2.span.end + delta, node2.state, this._opts.build, r)) {
+        continue;
+      }
+      if (delta === 0) {
+        const newTree2 = replaceAtPath(rebuild, this.tree, path, r.value);
+        return new _ParseDocImpl(this._registry, this._rootRule, this._opts, newTree2, [], newInput);
       }
+      if (this._opts.rebuild) return reparse();
+      const newTree = graftAndShift(this.tree, path, r.value, delta);
+      return new _ParseDocImpl(this._registry, this._rootRule, this._opts, newTree, [], newInput);
     }
     return reparse();
   }
 };
-function makeFunctionalDoc(registry, rootRule, input, opts = {}) {
+function parseDoc(registry, rootRule, input, opts = {}) {
   const ruleFn = registry[rootRule];
   if (!ruleFn) throw new Error(`No rule '${rootRule}' in registry`);
-  const ctx = { trackLines: false, state: opts.state };
+  const ctx = { trackLines: false, state: opts.state, build: opts.build };
   const r = ruleFn(input, 0, ctx);
   if (r.ok) {
-    return new FunctionalDocImpl(registry, rootRule, opts, r.value, [], input);
+    return new ParseDocImpl(registry, rootRule, opts, r.value, [], input);
+  }
+  return new ParseDocImpl(registry, rootRule, opts, null, [{ ok: false, expected: r.expected, span: r.span }], input);
+}
+
+// src/functional/run.ts
+var invoke = (r, input, pos, ctx) => typeof r === "function" ? r(input, pos, ctx) : r.parse(input, pos, ctx);
+function run(entry, input, options = {}) {
+  const triviaLog = [];
+  const errors = [];
+  const ctx = {
+    trackLines: false,
+    _triviaLog: triviaLog,
+    _errors: errors,
+    build: options.build,
+    state: options.state
+  };
+  const r = invoke(entry, input, 0, ctx);
+  let unconsumedFrom = null;
+  if (r.ok) {
+    let pos = r.span?.end ?? 0;
+    if (options.trivia && pos < input.length) {
+      const t = invoke(options.trivia, input, pos, { trackLines: false });
+      if (t.ok && t.span.end > pos) pos = t.span.end;
+    }
+    unconsumedFrom = pos < input.length ? pos : null;
   }
-  return new FunctionalDocImpl(registry, rootRule, opts, null, [{ ok: false, expected: r.expected, span: r.span }], input);
+  return {
+    ok: r.ok,
+    value: r.ok ? r.value : void 0,
+    span: r.span ?? { start: 0, end: 0 },
+    expected: r.ok ? [] : r.expected ?? [],
+    errors,
+    triviaLog,
+    unconsumedFrom
+  };
 }
 
 // src/cst/trivia-index.ts
-function merge(map, key, run) {
-  if (run.length === 0) return;
+function merge(map, key, run2) {
+  if (run2.length === 0) return;
   const existing = map.get(key);
-  if (existing) existing.push(...run);
-  else map.set(key, [...run]);
+  if (existing) existing.push(...run2);
+  else map.set(key, [...run2]);
 }
 function buildTriviaIndex(root, input = "", opts) {
   const before = /* @__PURE__ */ new Map();
@@ -3804,11 +4990,11 @@ function buildTriviaIndex(root, input = "", opts) {
       for (let i = 0; i < log.length; i += 3) {
         const tStart = log[i], tEnd = log[i + 1], insertIdx = log[i + 2];
         if (tEnd <= tStart) continue;
-        const run = [{ value: input.slice(tStart, tEnd), span: { start: tStart, end: tEnd } }];
+        const run2 = [{ value: input.slice(tStart, tEnd), span: { start: tStart, end: tEnd } }];
         const next = raw[insertIdx];
-        if (next) merge(before, next.span.start, run);
+        if (next) merge(before, next.span.start, run2);
         const prev = insertIdx > 0 ? raw[insertIdx - 1] : void 0;
-        if (prev) merge(after, prev.span.end, run);
+        if (prev) merge(after, prev.span.end, run2);
       }
     }
     const ch = node2.children;
@@ -3825,17 +5011,17 @@ function buildTriviaIndex(root, input = "", opts) {
     const rootSpan = root?.span;
     const re = new RegExp(opts.trivia.source, opts.trivia.flags.replace(/[gy]/g, "") + "y");
     const scanFrom = (from) => {
-      const run = [];
+      const run2 = [];
       let pos = from;
       re.lastIndex = pos;
       let m = re.exec(input);
       while (m && m.index === pos && m[0].length > 0) {
-        run.push({ value: m[0], span: { start: pos, end: pos + m[0].length } });
+        run2.push({ value: m[0], span: { start: pos, end: pos + m[0].length } });
         pos += m[0].length;
         re.lastIndex = pos;
         m = re.exec(input);
       }
-      return run;
+      return run2;
     };
     if (rootSpan && rootSpan.start > 0) {
       const lead = scanFrom(0);
@@ -3921,22 +5107,296 @@ function triviaEntries(log, labels, opts) {
     }
   };
 }
+
+// src/cst/offset-model.ts
+var { isFinite } = Number;
+function floorIndex(arr, len, x) {
+  let lo = 0;
+  let hi = len - 1;
+  let ans = -1;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    if (arr[mid] <= x) {
+      ans = mid;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return ans;
+}
+var OffsetIndex = class {
+  /** Slot starts, sorted ascending. Parallel to `_ends`. */
+  _starts;
+  _ends;
+  count;
+  docStart;
+  docEnd;
+  constructor(slots, docStart = 0, docEnd) {
+    const sorted = [...slots].sort((a, b) => a.start - b.start);
+    const starts = [];
+    const ends = [];
+    let prevEnd = docStart;
+    for (const s of sorted) {
+      if (!isFinite(s.start) || !isFinite(s.end) || s.end < s.start) {
+        throw new RangeError(`OffsetIndex: invalid slot [${s.start}, ${s.end}]`);
+      }
+      if (s.start < prevEnd) {
+        throw new RangeError(`OffsetIndex: overlapping/out-of-order slot [${s.start}, ${s.end}] after end ${prevEnd}`);
+      }
+      starts.push(s.start);
+      ends.push(s.end);
+      prevEnd = s.end;
+    }
+    this._starts = starts;
+    this._ends = ends;
+    this.count = starts.length;
+    this.docStart = docStart;
+    this.docEnd = docEnd ?? (this.count ? Math.max(prevEnd, ends[ends.length - 1]) : docStart);
+  }
+  /** The slot at index `i` (0-based, source order), or undefined. */
+  slot(i) {
+    if (i < 0 || i >= this.count) return void 0;
+    return { start: this._starts[i], end: this._ends[i] };
+  }
+  /**
+   * Index of the gap that CONTAINS `offset`, in `[0, count]`. Gap `i` spans
+   * `[endOf(i-1), startOf(i))` where `endOf(-1)=docStart` and `startOf(count)=docEnd`.
+   * An offset that lands inside a slot returns that slot's TRAILING gap index
+   * (i.e. the gap after it) — callers querying at slot boundaries get the
+   * intuitive answer via `gapBefore`/`gapAfter`.
+   */
+  gapIndexAt(offset) {
+    const i = floorIndex(this._starts, this.count, offset);
+    if (i < 0) return 0;
+    if (offset < this._ends[i]) return i + 1;
+    return i + 1;
+  }
+  /** The gap at index `i` in `[0, count]`. */
+  gap(i) {
+    if (i < 0 || i > this.count) return void 0;
+    const start = i === 0 ? this.docStart : this._ends[i - 1];
+    const end = i === this.count ? this.docEnd : this._starts[i];
+    return { start, end };
+  }
+  /**
+   * The trivia gap immediately BEFORE `offset` (`[prevSlotEnd, offset)`), where
+   * `prevSlotEnd` is the end of the last slot ending at or before `offset` (or
+   * `docStart`). For a real slot start this is the gap preceding that slot; for an
+   * adjacent slot the gap is empty and agrees with `gapAfter` on the same seam.
+   */
+  gapBefore(offset) {
+    const e = floorIndex(this._ends, this.count, offset);
+    const start = e >= 0 ? this._ends[e] : this.docStart;
+    return { start, end: offset };
+  }
+  /**
+   * The trivia gap immediately AFTER `offset` (`[offset, nextSlotStart)`), where
+   * `nextSlotStart` is the least slot start at or after `offset` (or `docEnd`).
+   */
+  gapAfter(offset) {
+    return { start: offset, end: this._ceilStart(offset) };
+  }
+  /** Least slot start `>= offset`, else `docEnd`. */
+  _ceilStart(offset) {
+    let lo = 0;
+    let hi = this.count - 1;
+    let ans = this.docEnd;
+    while (lo <= hi) {
+      const mid = lo + hi >>> 1;
+      if (this._starts[mid] >= offset) {
+        ans = this._starts[mid];
+        hi = mid - 1;
+      } else {
+        lo = mid + 1;
+      }
+    }
+    return ans;
+  }
+  /** Is this gap empty (adjacent slots, no trivia)? */
+  isEmpty(gap) {
+    return gap.end <= gap.start;
+  }
+};
+var NL = 10;
+var CR = 13;
+var SP = 32;
+var TAB = 9;
+function gapText(source, gap) {
+  return gap.end > gap.start ? source.slice(gap.start, gap.end) : "";
+}
+function lineBreaksIn(source, gap) {
+  let n = 0;
+  for (let i = gap.start; i < gap.end; i++) {
+    const c = source.charCodeAt(i);
+    if (c === NL) n++;
+    else if (c === CR && source.charCodeAt(i + 1) !== NL) n++;
+  }
+  return n;
+}
+function blankLinesIn(source, gap) {
+  return Math.max(0, lineBreaksIn(source, gap) - 1);
+}
+function lineStartWithin(source, gap) {
+  for (let i = gap.end - 1; i >= gap.start; i--) {
+    const c = source.charCodeAt(i);
+    if (c === NL || c === CR) return i + 1;
+  }
+  return gap.start;
+}
+function indentWidth(source, gap) {
+  const ls = lineStartWithin(source, gap);
+  if (ls === gap.start) return 0;
+  return gap.end - ls;
+}
+function indentMixed(source, gap) {
+  const ls = lineStartWithin(source, gap);
+  let sawSpace = false;
+  let sawTab = false;
+  for (let i = ls; i < gap.end; i++) {
+    const c = source.charCodeAt(i);
+    if (c === SP) sawSpace = true;
+    else if (c === TAB) sawTab = true;
+  }
+  return sawSpace && sawTab;
+}
+function commentsIn(source, gap, comment) {
+  const re = new RegExp(comment.source, comment.flags.replace(/[gy]/g, "") + "g");
+  re.lastIndex = gap.start;
+  const out = [];
+  let m;
+  while ((m = re.exec(source)) && m.index < gap.end) {
+    if (m[0].length === 0) {
+      re.lastIndex++;
+      continue;
+    }
+    if (m.index + m[0].length > gap.end) break;
+    out.push({ start: m.index, end: m.index + m[0].length });
+  }
+  return out;
+}
+function gapIsSignificant(source, gap, comment) {
+  if (gap.end <= gap.start) return false;
+  if (lineBreaksIn(source, gap) > 0) return true;
+  if (comment && commentsIn(source, gap, comment).length > 0) return true;
+  return false;
+}
+function collectLeafSlots(root) {
+  const slots = [];
+  const visit = (n) => {
+    const kids = n.children;
+    if (kids && kids.length) {
+      for (const c of kids) visit(c);
+    } else if (n.span) {
+      slots.push({ start: n.span.start, end: n.span.end });
+    }
+  };
+  if (root) visit(root);
+  return slots;
+}
+function buildOffsetIndex(root, input = "") {
+  return new OffsetIndex(collectLeafSlots(root), 0, input.length);
+}
+
+// src/cst/relative-spans.ts
+function relativize(node2, parentBase = 0) {
+  return {
+    start: node2.start - parentBase,
+    end: node2.end - parentBase,
+    children: node2.children.map((c) => relativize(c, node2.start))
+  };
+}
+function absolutize(node2, parentBase = 0) {
+  const start = parentBase + node2.start;
+  return {
+    start,
+    end: parentBase + node2.end,
+    children: node2.children.map((c) => absolutize(c, start))
+  };
+}
+function absoluteSpanAt(root, path) {
+  let base = 0;
+  let node2 = root;
+  for (const idx of path) {
+    base += node2.start;
+    const child = node2.children[idx];
+    if (!child) throw new RangeError(`absoluteSpanAt: no child ${idx} on path ${path.join(".")}`);
+    node2 = child;
+  }
+  return { start: base + node2.start, end: base + node2.end };
+}
+function shiftAbsolute(node2, at, delta) {
+  const s = node2.start >= at ? node2.start + delta : node2.start;
+  const e = node2.end >= at ? node2.end + delta : node2.end;
+  return {
+    start: s,
+    end: e,
+    children: node2.children.map((c) => shiftAbsolute(c, at, delta))
+  };
+}
+function applyEdit(root, at, delta, stats) {
+  return editNode(root, at, delta, 0, 0, stats);
+}
+function editNode(node2, at, delta, parentBase, parentShift, stats) {
+  const absStart = parentBase + node2.start;
+  const absEnd = parentBase + node2.end;
+  if (absEnd < at) return node2;
+  const startShifts = absStart >= at;
+  if (startShifts && parentShift === delta) return node2;
+  if (stats) stats.allocated++;
+  const newAbsStart = startShifts ? absStart + delta : absStart;
+  const newAbsEnd = absEnd + delta;
+  const newParentBase = parentBase + parentShift;
+  const newStart = newAbsStart - newParentBase;
+  const newEnd = newAbsEnd - newParentBase;
+  const ownShift = newAbsStart - absStart;
+  let changed = false;
+  const newChildren = [];
+  for (const c of node2.children) {
+    const nc = editNode(c, at, delta, absStart, ownShift, stats);
+    if (nc !== c) changed = true;
+    newChildren.push(nc);
+  }
+  return {
+    start: newStart,
+    end: newEnd,
+    children: changed ? newChildren : node2.children
+  };
+}
+
+// src/index.ts
+registerRegexAnalyzer(firstSetFromRegex);
 export {
+  OffsetIndex,
+  absoluteSpanAt,
+  absolutize,
   annotateSpan,
+  applyEdit,
   balanced,
+  blankLinesIn,
   buildLineIndex,
+  buildOffsetIndex,
   buildTriviaIndex,
   choice,
+  collectLeafSlots,
+  commentsIn,
   compile,
   completionsAt,
+  compose,
   createVisitor,
+  cstBuildHost,
   expect,
+  gapIsSignificant,
+  gapText,
   guard,
+  indentMixed,
+  indentWidth,
   isParseError,
   keywords,
   label,
+  lineBreaksIn,
+  lineStartWithin,
   literal,
-  makeFunctionalDoc,
   makeWord,
   many,
   manyRecover,
@@ -3947,15 +5407,20 @@ export {
   oneOrMore,
   optional,
   parse,
+  parseDoc,
   parser,
+  pick,
   recover,
   ref,
   regex,
+  relativize,
   rules,
+  run,
   scanTo,
   sepBy,
   sepByRecover,
   sequence,
+  shiftAbsolute,
   skip,
   staticExpected,
   transform,