parseman 0.32.0 → 0.34.0

package/dist/plugin/index.js

@@ -7,6 +7,11 @@ import { ResolverFactory } from "oxc-resolver";
 import MagicString from "magic-string";
 
 // src/combinators/first-set.ts
+function resolveNamedRef(p, resolve2) {
+  if (resolve2 === void 0) return void 0;
+  const name = p._ruleName;
+  return name === void 0 ? void 0 : resolve2(name);
+}
 function union(a, b) {
   if (a.kind === "any" || b.kind === "any") return { kind: "any" };
   if (a.kind === "empty") return b;
@@ -44,10 +49,10 @@ function any() {
 function empty() {
   return { kind: "empty" };
 }
-function matchesEmpty(p, seen = /* @__PURE__ */ new Set()) {
+function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve2) {
   if (seen.has(p)) return true;
   seen.add(p);
-  const me = (c) => matchesEmpty(c, seen);
+  const me = (c) => matchesEmpty(c, seen, resolve2);
   const d = p._def;
   switch (d.tag) {
     case "literal":
@@ -64,8 +69,16 @@ function matchesEmpty(p, seen = /* @__PURE__ */ new Set()) {
     case "many":
     case "optional":
     case "not":
+    case "peek":
       return true;
     // zero repetitions / absent / lookahead
+    // Default `sepBy` is `(item (sep item)*)?` — it MATCHES THE EMPTY STRING.
+    // Any `min >= 1` requires that many ITEMS, so it is nullable only when the
+    // item is. (Keying this off `min === 1` reported every `{ min: 2 }` list as
+    // nullable — safe, but wrong, and it put a bogus `nullable-prefix` note on
+    // the gating diagnostic for a list that can never match empty.)
+    case "sepBy":
+      return d.min >= 1 ? me(d.parser) : true;
     case "oneOrMore":
       return me(d.parser);
     case "sequence":
@@ -89,7 +102,8 @@ function matchesEmpty(p, seen = /* @__PURE__ */ new Set()) {
       try {
         return me(d.thunk());
       } catch {
-        return true;
+        const t = resolveNamedRef(p, resolve2);
+        return t ? me(t) : true;
       }
     default:
       return true;
@@ -98,18 +112,45 @@ function matchesEmpty(p, seen = /* @__PURE__ */ new Set()) {
 function isZeroWidthAssertion(p) {
   return p._def.tag === "not";
 }
+function isPositiveLookahead(p) {
+  return p._def.tag === "peek";
+}
+function narrowBy(acc, constraint) {
+  if (constraint.kind === "any") return acc;
+  if (acc === null) return constraint;
+  if (acc.kind === "any") return constraint;
+  if (acc.kind === "empty" || constraint.kind === "empty") return { kind: "empty" };
+  const ranges = [];
+  for (const a of acc.ranges) for (const b of constraint.ranges) {
+    const lo = Math.max(a.lo, b.lo);
+    const hi = Math.min(a.hi, b.hi);
+    if (lo <= hi) ranges.push({ lo, hi });
+  }
+  return ranges.length === 0 ? { kind: "empty" } : { kind: "ranges", ranges };
+}
+function applyAssertion(fs2, assertion) {
+  if (assertion === null) return fs2;
+  if (fs2.kind === "empty") return assertion;
+  return narrowBy(fs2, assertion) ?? fs2;
+}
 function sequenceFirstSet(parsers) {
   let fs2 = empty();
+  let assertion = null;
   for (const p of parsers) {
+    if (isPositiveLookahead(p)) {
+      assertion = narrowBy(assertion, p._meta.firstSet);
+      continue;
+    }
     if (!isZeroWidthAssertion(p)) fs2 = union(fs2, p._meta.firstSet);
-    if (!matchesEmpty(p)) return fs2;
+    if (!matchesEmpty(p)) return applyAssertion(fs2, assertion);
   }
-  return fs2;
+  return applyAssertion(fs2, assertion);
 }
-function firstSetOf(p, seen = /* @__PURE__ */ new Set()) {
+function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve2) {
   if (seen.has(p)) return any();
   seen.add(p);
-  const fs2 = (c) => firstSetOf(c, seen);
+  const fs2 = (c) => firstSetOf(c, seen, resolve2);
+  const empties = (c) => matchesEmpty(c, /* @__PURE__ */ new Set(), resolve2);
   const d = p._def;
   switch (d.tag) {
     case "literal":
@@ -121,7 +162,8 @@ function firstSetOf(p, seen = /* @__PURE__ */ new Set()) {
       try {
         return fs2(d.thunk());
       } catch {
-        return any();
+        const t = resolveNamedRef(p, resolve2);
+        return t ? fs2(t) : any();
       }
     case "choice": {
       let out = empty();
@@ -130,11 +172,20 @@ function firstSetOf(p, seen = /* @__PURE__ */ new Set()) {
     }
     case "sequence": {
       let out = empty();
+      let assertion = null;
       for (const term of d.parsers) {
+        if (isPositiveLookahead(term)) {
+          assertion = narrowBy(assertion, fs2(term));
+          continue;
+        }
         if (!isZeroWidthAssertion(term)) out = union(out, fs2(term));
-        if (!matchesEmpty(term)) return out;
+        if (!empties(term)) return applyAssertion(out, assertion);
       }
-      return out;
+      return applyAssertion(out, assertion);
+    }
+    case "peek": {
+      const inner = d.parser;
+      return empties(inner) ? any() : fs2(inner);
     }
     case "oneOrMore":
     case "many":
@@ -150,6 +201,7 @@ function firstSetOf(p, seen = /* @__PURE__ */ new Set()) {
       return fs2(d.parser);
     case "sepBy":
       return fs2(d.parser);
+    // both min 0 and min 1 start with the item
     case "skip":
       return fs2(d.main);
     default:
@@ -871,9 +923,46 @@ function firstSetFromRegex(source) {
   return { firstSet: firstSet(ast), canMatchNewline: firstCanBeNewline(ast) };
 }
 
+// src/combinators/case-fold.ts
+function canonical(ch2) {
+  const u = ch2.toUpperCase();
+  if (u.length !== 1) return ch2;
+  if (ch2.codePointAt(0) >= 128 && u.codePointAt(0) < 128) return ch2;
+  return u;
+}
+var foldIndex = null;
+function buildFoldIndex() {
+  const byCanonical = /* @__PURE__ */ new Map();
+  for (let cp = 0; cp < 65536; cp++) {
+    if (cp >= 55296 && cp <= 57343) continue;
+    const key = canonical(String.fromCharCode(cp));
+    const bucket = byCanonical.get(key);
+    if (bucket) bucket.push(cp);
+    else byCanonical.set(key, [cp]);
+  }
+  const index = /* @__PURE__ */ new Map();
+  for (const members of byCanonical.values()) {
+    if (members.length < 2) continue;
+    for (const cp of members) index.set(cp, members);
+  }
+  return index;
+}
+function caseFoldVariants(cp) {
+  if (cp < 128) {
+    if (cp >= 65 && cp <= 90) return [cp, cp + 32];
+    if (cp >= 97 && cp <= 122) return [cp, cp - 32];
+    return [cp];
+  }
+  if (cp > 65535) return [cp];
+  foldIndex ??= buildFoldIndex();
+  return foldIndex.get(cp) ?? [cp];
+}
+
 // src/combinators/keywords.ts
-function word(str, boundary = "_0-9A-Za-z") {
-  return keywords([str], { boundary });
+function word(str, boundaryOrOpts, opts) {
+  const boundary = typeof boundaryOrOpts === "string" ? boundaryOrOpts : "_0-9A-Za-z";
+  const rest = typeof boundaryOrOpts === "object" && boundaryOrOpts !== null ? boundaryOrOpts : opts;
+  return keywords([str], { ...rest, boundary });
 }
 function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -882,7 +971,7 @@ function keywords(words, opts = {}) {
   const sorted = [...new Set(words)].sort((a, b) => b.length - a.length);
   const alt = sorted.map(escapeRe).join("|");
   const boundary = opts.boundary ? `(?![${opts.boundary}])` : "";
-  const flags = opts.caseInsensitive ? "iuy" : "uy";
+  const flags = opts.caseInsensitive ? "iy" : "uy";
   const re = new RegExp(`(?:${alt})${boundary}`, flags);
   let firstSet2 = empty();
   for (const w of sorted) {
@@ -890,10 +979,7 @@ function keywords(words, opts = {}) {
     const cp = w.codePointAt(0);
     firstSet2 = union(firstSet2, fromChar(cp));
     if (opts.caseInsensitive) {
-      const u = String.fromCodePoint(cp).toUpperCase().codePointAt(0);
-      const l = String.fromCodePoint(cp).toLowerCase().codePointAt(0);
-      if (u !== void 0) firstSet2 = union(firstSet2, fromChar(u));
-      if (l !== void 0) firstSet2 = union(firstSet2, fromChar(l));
+      for (const v2 of caseFoldVariants(cp)) firstSet2 = union(firstSet2, fromChar(v2));
     }
   }
   const meta = { firstSet: firstSet2, canMatchNewline: false, isTrivia: false };
@@ -1041,6 +1127,7 @@ function deriveExpected(c) {
     case "oneOrMore":
     case "transform":
     case "not":
+    case "peek":
       return deriveExpected(def.parser);
     case "lazy": {
       const name = c._ruleName;
@@ -1511,6 +1598,13 @@ function rollbackTrivia(ctx, mark) {
   rollbackCstCapture(ctx, { raw: mark.raw, tlog: mark.tlog, leaves: mark.leaves, fields: mark.fields, errors: mark.errors });
   if (ctx._triviaLog) ctx._triviaLog.length = mark.log;
 }
+function saveLookaheadMark(ctx) {
+  return { ...saveTriviaMark(ctx), probeBest: ctx._probe ? ctx._probe.best : null };
+}
+function rollbackLookahead(ctx, mark) {
+  rollbackTrivia(ctx, mark);
+  if (ctx._probe) ctx._probe.best = mark.probeBest;
+}
 function scanWithLabels(input, cur, ctx) {
   const triviaP = ctx.trivia;
   const spec = analyzeLabeledTrivia(triviaP);
@@ -1908,13 +2002,26 @@ function repItem(combinator, input, cur, ctx, guardable) {
   }
   return { value: result.value, end: result.span.end };
 }
-function many(combinator) {
+function resolveBounds(what, opts) {
+  const min = opts.min ?? 0;
+  const max = opts.max ?? Infinity;
+  const bad = (msg) => {
+    throw new RangeError(`parseman: ${what} ${msg}`);
+  };
+  if (!Number.isInteger(min) || min < 0) bad(`min must be a non-negative integer (got ${String(opts.min)})`);
+  if (max !== Infinity && (!Number.isInteger(max) || max < 1)) bad(`max must be a positive integer (got ${String(opts.max)})`);
+  if (max < min) bad(`max (${max}) is less than min (${min}) \u2014 the combinator could never succeed`);
+  return { min, max };
+}
+function many(combinator, opts = {}) {
+  const { min, max } = resolveBounds("many()", opts);
+  if (min >= 1) return atLeast(combinator, min, max);
   const meta = {
     firstSet: combinator._meta.firstSet,
     canMatchNewline: combinator._meta.canMatchNewline,
     isTrivia: false
   };
-  const def = { tag: "many", parser: combinator, min: 0 };
+  const def = { tag: "many", parser: combinator, min: 0, ...max === Infinity ? {} : { max } };
   let expected;
   const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
   return {
@@ -1924,7 +2031,9 @@ function many(combinator) {
     parse(input, pos, ctx) {
       const values = def.valueUnused ? void 0 : [];
       let cur = pos;
+      let count = 0;
       while (cur < input.length) {
+        if (count >= max) break;
         const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop") break;
         if ("fail" in item) {
@@ -1935,23 +2044,28 @@ function many(combinator) {
           const { error, end } = recoverScan(input, item.failPos, ctx, sync, expected);
           if (values !== void 0) values.push(error);
           captureError(ctx, error);
+          count++;
           cur = end;
           continue;
         }
         if (values !== void 0) values.push(item.value);
+        count++;
         cur = item.end;
       }
       return { ok: true, value: values ?? void 0, span: { start: pos, end: cur } };
     }
   };
 }
-function oneOrMore(combinator) {
+function oneOrMore(combinator, opts = {}) {
+  return many(combinator, { ...opts, min: opts.min ?? 1 });
+}
+function atLeast(combinator, min, max) {
   const meta = {
     firstSet: combinator._meta.firstSet,
     canMatchNewline: combinator._meta.canMatchNewline,
     isTrivia: false
   };
-  const def = { tag: "oneOrMore", parser: combinator, min: 1 };
+  const def = { tag: "oneOrMore", parser: combinator, min, ...max === Infinity ? {} : { max } };
   let expected;
   const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
   return {
@@ -1963,7 +2077,19 @@ function oneOrMore(combinator) {
       if (!first.ok) return first;
       const values = def.valueUnused ? void 0 : [first.value];
       let cur = first.span.end;
+      let count = 1;
+      while (count < min) {
+        const item = repItem(combinator, input, cur, ctx, guardable);
+        if (item === "stop" || "fail" in item) {
+          expected ??= deriveExpected(combinator);
+          return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: cur, end: cur } };
+        }
+        if (values !== void 0) values.push(item.value);
+        cur = item.end;
+        count++;
+      }
       while (cur < input.length) {
+        if (count >= max) break;
         const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop") break;
         if ("fail" in item) {
@@ -1974,10 +2100,12 @@ function oneOrMore(combinator) {
           const { error, end } = recoverScan(input, item.failPos, ctx, sync, expected);
           if (values !== void 0) values.push(error);
           captureError(ctx, error);
+          count++;
           cur = end;
           continue;
         }
         if (values !== void 0) values.push(item.value);
+        count++;
         cur = item.end;
       }
       return { ok: true, value: values ?? void 0, span: { start: pos, end: cur } };
@@ -2007,17 +2135,33 @@ function optional(combinator) {
     }
   };
 }
-function sepBy(combinator, separator) {
+function oneOrMoreSep(combinator, separator, opts = {}) {
+  return sepBy(combinator, separator, { ...opts, min: opts.min ?? 1 });
+}
+function sepBy(combinator, separator, opts = {}) {
+  const { min, max } = resolveBounds("sepBy()", opts);
+  const trailing = opts.trailing ?? "forbid";
   const meta = {
     firstSet: combinator._meta.firstSet,
     canMatchNewline: combinator._meta.canMatchNewline || separator._meta.canMatchNewline,
     isTrivia: false
   };
   let expected;
+  const failAt2 = (at) => {
+    expected ??= deriveExpected(combinator);
+    return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: at, end: at } };
+  };
   return {
     _tag: "sepBy",
     _meta: meta,
-    _def: { tag: "sepBy", parser: combinator, separator },
+    _def: {
+      tag: "sepBy",
+      parser: combinator,
+      separator,
+      min,
+      ...max === Infinity ? {} : { max },
+      ...trailing === "forbid" ? {} : { trailing }
+    },
     parse(input, pos, ctx) {
       const first = combinator.parse(input, pos, ctx);
       const values = [];
@@ -2028,6 +2172,7 @@ function sepBy(combinator, separator) {
       } else {
         const term = ctx._tolerant ? ctx._sync : void 0;
         if (term === void 0 || matchesAt(term, input, pos, ctx)) {
+          if (min >= 1) return failAt2(pos);
           return { ok: true, value: [], span: { start: pos, end: pos } };
         }
         expected ??= deriveExpected(combinator);
@@ -2037,6 +2182,7 @@ function sepBy(combinator, separator) {
         cur = rec.end;
       }
       while (cur < input.length) {
+        if (values.length >= max) break;
         const loopMark = saveTriviaMark(ctx);
         let sepPos = cur;
         if (ctx.trivia) {
@@ -2053,6 +2199,7 @@ function sepBy(combinator, separator) {
           rollbackTrivia(ctx, loopMark);
           break;
         }
+        const sepMark = trailing === "forbid" ? void 0 : saveTriviaMark(ctx);
         let nextPos = sep2.span.end;
         if (ctx.trivia) {
           if (needsDeferredTriviaCommit(ctx)) {
@@ -2074,12 +2221,18 @@ function sepBy(combinator, separator) {
             cur = rec.end;
             continue;
           }
+          if (sepMark !== void 0) {
+            rollbackTrivia(ctx, sepMark);
+            cur = sep2.span.end;
+            break;
+          }
           rollbackTrivia(ctx, loopMark);
           break;
         }
         values.push(next.value);
         cur = next.span.end;
       }
+      if (values.length < min) return failAt2(cur);
       return { ok: true, value: values, span: { start: pos, end: cur } };
     }
   };
@@ -2132,6 +2285,7 @@ function markUnusedValues(root) {
         visit(def.separator, false);
         return;
       case "not":
+      case "peek":
         visit(def.parser, false);
         return;
       case "grammar":
@@ -2250,9 +2404,9 @@ function not(combinator) {
     _meta: meta,
     _def: { tag: "not", parser: combinator },
     parse(input, pos, ctx) {
-      const mark = saveCstMark(ctx);
+      const mark = saveLookaheadMark(ctx);
       const result = combinator.parse(input, pos, ctx);
-      rollbackCstCapture(ctx, mark);
+      rollbackLookahead(ctx, mark);
       if (result.ok) {
         return { ok: false, expected: [`not(${combinator._tag})`], span: { start: pos, end: pos } };
       }
@@ -2261,6 +2415,28 @@ function not(combinator) {
   };
 }
 
+// src/combinators/peek.ts
+function peek(combinator) {
+  const meta = {
+    // A nullable body imposes no first-char constraint — `any()`, not its set.
+    firstSet: matchesEmpty(combinator) ? any() : combinator._meta.firstSet,
+    canMatchNewline: false,
+    isTrivia: false
+  };
+  return {
+    _tag: "peek",
+    _meta: meta,
+    _def: { tag: "peek", parser: combinator },
+    parse(input, pos, ctx) {
+      const mark = saveLookaheadMark(ctx);
+      const result = combinator.parse(input, pos, ctx);
+      rollbackLookahead(ctx, mark);
+      if (result.ok) return { ok: true, value: null, span: { start: pos, end: pos } };
+      return { ok: false, expected: [`peek(${combinator._tag})`], span: { start: pos, end: pos } };
+    }
+  };
+}
+
 // src/compiler/build-arity.ts
 var PARAM_LIST_RE = (
   // (params) => ...   |   function name?(params) ...   |   single-ident arrow `x => ...`
@@ -2359,6 +2535,7 @@ function parserHasOwnFields(p, seen = /* @__PURE__ */ new Set()) {
     case "expect":
     case "withCtx":
     case "not":
+    case "peek":
       return parserHasOwnFields(d.parser, seen);
     default:
       return false;
@@ -2398,6 +2575,7 @@ function parserHasTriviaSite(p, seen = /* @__PURE__ */ new Set()) {
     case "expect":
     case "withCtx":
     case "not":
+    case "peek":
     case "field":
       return parserHasTriviaSite(d.parser, seen);
     case "choice":
@@ -2447,6 +2625,7 @@ function parserEnablesTriviaCapture(p, seen = /* @__PURE__ */ new Set()) {
     case "expect":
     case "withCtx":
     case "not":
+    case "peek":
       return parserEnablesTriviaCapture(d.parser, seen);
     // leaf() clears the inner CST/trivia collector and publishes only its own
     // terminal result. An inner parser() capture cannot reach this node.
@@ -2795,7 +2974,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.32.0";
+var PARSEMAN_VERSION = "0.34.0";
 
 // src/analysis/gating.ts
 var isAny = (fs2) => fs2.kind === "any";
@@ -2835,14 +3014,15 @@ function firstSetToString(fs2) {
 var ruleNameOf = (p) => p._ruleName;
 var SUGGESTIONS = {
   "broad-recognizer": "if this arm leads with a keyword regex, use word('kw', boundary) / keywords([...]) \u2014 they expose an EXACT, gating first-set and lower to the same charCodeAt scan. A genuine scanTo fallback is fine; accept it in the gating snapshot if intentional.",
-  "leading-not": "let the arm lead with its actual consuming terminal (first-sets gate it automatically); keep not(...) only as a TRAILING boundary. Do not hand-roll not(not(...)) to fake gating.",
-  "nullable-prefix": "a leading optional/many lets a later, broad term start the arm. Split the empty case into its own arm, or gate on the prefix first char.",
+  "leading-not": "let the arm lead with its actual consuming terminal (first-sets gate it automatically); keep not(...) only as a TRAILING boundary. Do not hand-roll not(not(...)) to fake gating \u2014 use peek(X), which is zero-width AND carries X first-set.",
+  "nullable-prefix": "a leading optional/many lets a later, broad term start the arm. Split the empty case into its own arm, or gate on the prefix first char. A plain sepBy(item, sep) is ALSO nullable \u2014 pass { min: 1 } for a list that cannot be empty.",
   "cross-artifact-ref": "parseman >=0.32.0 resolves a g.Foo ref first-set at fuse time; if still ANY the target rule is itself ungated \u2014 analyze it and give it a concrete non-nullable lead.",
   "opaque-wrapper": "this wrapper (guard/withCtx/recover) contributes no first char; put a concrete leading terminal before it.",
   "ref-cycle": "a recursive ref resolved to ANY; ensure the recursion has a concrete terminal lead on the base case."
 };
-function classifyBroadArm(arm) {
+function classifyBroadArm(arm, resolve2) {
   const seen = /* @__PURE__ */ new Set();
+  const relabel = (inner, cause, detail) => ({ cause, detail, ...inner?.unresolvedExternal ? { unresolvedExternal: true } : {} });
   const walk2 = (p) => {
     if (seen.has(p)) return { cause: "ref-cycle", detail: "ref cycle" };
     seen.add(p);
@@ -2854,6 +3034,10 @@ function classifyBroadArm(arm) {
         return isAny(p._meta.firstSet) ? { cause: "broad-recognizer", detail: `broad recognizer (${d.tag})` } : null;
       case "not":
         return { cause: "leading-not", detail: "leading not(...) (first-set ANY)" };
+      // peek() CARRIES its body's first-set, so it is only broad when the body is
+      // (or the body is nullable) — walk in for the real cause.
+      case "peek":
+        return walk2(d.parser);
       case "scanTo":
         return { cause: "broad-recognizer", detail: "scanTo (any first char)" };
       // `guard` (the `gate()` state predicate) has a genuinely-`any` first-set of
@@ -2870,18 +3054,23 @@ function classifyBroadArm(arm) {
         return walk2(d.parser);
       case "lazy": {
         const name = p._ruleName;
+        let target;
         try {
-          const inner = walk2(d.thunk());
-          if (name !== void 0) return inner ? { cause: "cross-artifact-ref", detail: `via ref g.${name} \u2192 ${inner.detail}` } : null;
-          return inner;
+          target = d.thunk();
         } catch {
-          return { cause: "cross-artifact-ref", detail: `unresolved ref${name ? ` g.${name}` : ""}` };
+          const bound = name !== void 0 ? resolve2?.(name) : void 0;
+          if (bound === void 0)
+            return { cause: "cross-artifact-ref", detail: `unresolved ref${name ? ` g.${name}` : ""}`, unresolvedExternal: name !== void 0 };
+          target = bound;
         }
+        const inner = walk2(target);
+        if (name !== void 0) return inner ? relabel(inner, "cross-artifact-ref", `via ref g.${name} \u2192 ${inner.detail}`) : null;
+        return inner;
       }
       case "optional":
       case "many": {
         const inner = walk2(d.parser);
-        return { cause: "nullable-prefix", detail: inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term" };
+        return relabel(inner, "nullable-prefix", inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term");
       }
       case "oneOrMore":
       case "transform":
@@ -2903,13 +3092,13 @@ function classifyBroadArm(arm) {
             sawNullablePrefix = true;
             continue;
           }
-          if (isAny(firstSetOf(t))) {
+          if (isAny(firstSetOf(t, /* @__PURE__ */ new Set(), resolve2))) {
             const inner = walk2(t);
             if (sawNullablePrefix)
-              return { cause: "nullable-prefix", detail: inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term" };
+              return relabel(inner, "nullable-prefix", inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term");
             return inner ?? { cause: "broad-recognizer", detail: "sequence leading term is broad" };
           }
-          if (matchesEmpty(t)) {
+          if (matchesEmpty(t, /* @__PURE__ */ new Set(), resolve2)) {
             sawNullablePrefix = true;
             continue;
           }
@@ -2920,7 +3109,7 @@ function classifyBroadArm(arm) {
       case "choice": {
         for (const a of d.parsers) {
           const r = walk2(a);
-          if (r) return { cause: r.cause, detail: `choice arm \u2192 ${r.detail}` };
+          if (r) return relabel(r, r.cause, `choice arm \u2192 ${r.detail}`);
         }
         return null;
       }
@@ -2957,7 +3146,7 @@ function detectAntiPatterns(rule, arms) {
           kind: "double-not",
           rule,
           armIndex: i,
-          message: "not(not(...)) hand-rolls automatic first-char gating and MISCOMPILES among shared-first-char sibling arms (its first-set is ANY, poisoning dispatch). Remove it; let the arm lead with its consuming terminal, or use word()/keywords() for an exact first-set."
+          message: "not(not(...)) hand-rolls automatic first-char gating and MISCOMPILES among shared-first-char sibling arms (its first-set is ANY, poisoning dispatch). Prefer letting the arm lead with its consuming terminal; where a real positive lookahead IS needed, use peek(X) \u2014 zero-width like not(not(X)) but it CARRIES X's first-set, so the arm still dispatches."
         });
       } else {
         out.push({
@@ -2980,6 +3169,9 @@ function detectAntiPatterns(rule, arms) {
   return out;
 }
 function analyzeGating(entry, opts) {
+  return analyzeGatingRules([[ruleNameOf(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
+}
+function analyzeGatingRules(ruleMap, opts) {
   const raw = [];
   const antiPatterns = [];
   const visited = /* @__PURE__ */ new Set();
@@ -2989,7 +3181,7 @@ function analyzeGating(entry, opts) {
     const d = p._def;
     const rule = ruleNameOf(p) ?? enclosingRule;
     if (d.tag === "choice") {
-      raw.push({ g: analyzeChoice(p, d, rule), rule });
+      raw.push({ g: analyzeChoice(p, d, rule, opts?.resolveRef), rule });
       antiPatterns.push(...detectAntiPatterns(rule, d.parsers));
     }
     const rec = d;
@@ -3006,7 +3198,7 @@ function analyzeGating(entry, opts) {
     }
     for (const k of kids) visit(k, rule);
   };
-  visit(entry, ruleNameOf(entry) ?? "<entry>");
+  for (const [name, root] of ruleMap) visit(root, ruleNameOf(root) ?? name);
   const perRule = /* @__PURE__ */ new Map();
   for (const r of raw) perRule.set(r.rule, (perRule.get(r.rule) ?? 0) + 1);
   const seenInRule = /* @__PURE__ */ new Map();
@@ -3022,18 +3214,19 @@ function analyzeGating(entry, opts) {
   });
   const gated = choices.filter((c) => c.gates === "yes").length;
   const recoverable = choices.filter((c) => c.gates === "recoverable").length;
-  const ungated = choices.filter((c) => c.gates === "no" && !c.accepted);
+  const ungated = choices.filter((c) => c.gates === "no" && !c.accepted && !c.deferred);
   const accepted = choices.filter((c) => c.gates === "no" && c.accepted);
+  const deferred = choices.filter((c) => c.gates === "no" && !c.accepted && c.deferred);
   const acceptedUnused = [...accept].filter((id) => !usedAccept.has(id));
-  return { totalChoices: choices.length, gated, recoverable, ungated, accepted, acceptedUnused, choices, antiPatterns };
+  return { totalChoices: choices.length, gated, recoverable, ungated, accepted, deferred, acceptedUnused, choices, antiPatterns };
 }
-function analyzeChoice(p, d, rule) {
+function analyzeChoice(p, d, rule, resolve2) {
   const arms = d.parsers;
   const shallow = arms.map((a) => a._meta.firstSet);
-  const deep = arms.map((a) => firstSetOf(a));
+  const deep = arms.map((a) => firstSetOf(a, /* @__PURE__ */ new Set(), resolve2));
   const anyArms = deep.map((fs2, index) => ({ fs: fs2, index })).filter((x) => isAny(x.fs)).map(({ index }) => {
-    const { cause, detail } = classifyBroadArm(arms[index]);
-    return { index, cause, detail, shallowAnyOnly: false, suggestion: SUGGESTIONS[cause] };
+    const { cause, detail, unresolvedExternal } = classifyBroadArm(arms[index], resolve2);
+    return { index, cause, detail, shallowAnyOnly: false, unresolvedExternal: unresolvedExternal === true, suggestion: SUGGESTIONS[cause] };
   });
   const overlaps = [];
   for (let i = 0; i < deep.length; i++)
@@ -3049,10 +3242,12 @@ function analyzeChoice(p, d, rule) {
   if (d.disjoint) gates = "yes";
   else if (anyArms.length === 0 && overlaps.length === 0) gates = "recoverable";
   else gates = "no";
+  const deferred = gates === "no" && overlaps.length === 0 && anyArms.length > 0 && anyArms.every((a) => a.unresolvedExternal);
   return {
     rule,
     strategy: d.strategy?.tag ?? "firstMatch",
     gates,
+    deferred,
     combinedFirstSet: { shallow: combine(shallow), deep: combine(deep) },
     anyArms,
     overlaps
@@ -3219,6 +3414,7 @@ function children(def, winners) {
     case "field":
     case "grammar":
     case "not":
+    case "peek":
     case "node":
     case "guard":
     case "withCtx":
@@ -4992,6 +5188,9 @@ function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set()) {
     case "keywords":
     case "guard":
     case "not":
+    // peek(): emitted under a non-capturing probe ctx and zero-width on both
+    // outcomes, so it can never leave a partial capture behind.
+    case "peek":
     case "trivia":
     case "token":
     case "leaf":
@@ -5063,6 +5262,7 @@ function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
     case "leaf":
       return true;
     case "not":
+    case "peek":
     case "guard":
     case "trivia":
     case "unknown":
@@ -5189,6 +5389,7 @@ 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;
+  if (def.caseInsensitive && def.words.some((w) => w.split("").some((c) => c.charCodeAt(0) > 127))) return null;
   let boundary = null;
   if (def.boundary) {
     let body = def.boundary;
@@ -5236,7 +5437,7 @@ function emitKeywords(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";
+  const flags = def.caseInsensitive ? "iy" : "uy";
   const source = `(?:${alt})${boundary}`;
   const key = `${source}/${flags}`;
   let rName = ctx.regexMap.get(key);
@@ -5382,6 +5583,7 @@ function failsAtStart(p) {
     case "keywords":
     case "guard":
     case "not":
+    case "peek":
       return true;
     case "transform":
     case "label":
@@ -5795,14 +5997,17 @@ function emitMany(def, ctx, pos) {
   ];
   const mySyncV = ctx.recovery ? v(ctx, "_mysy") : "";
   if (ctx.recovery) stmts.push(`${ind(ctx)}const ${mySyncV} = _ctx._sync`);
-  if (def.min === 1) {
+  for (let i = 0; i < def.min; i++) {
     const firstR = emit(def.parser, ctx, curV);
     stmts.push(...firstR.stmts);
     if (wantValue) stmts.push(`${ind(ctx)}${arrV}.push(${firstR.valueVar})`);
     stmts.push(`${ind(ctx)}${curV} = ${firstR.endVar}`);
   }
+  const maxV = def.max === void 0 ? null : wantValue ? `${arrV}.length` : v(ctx, "_cnt");
+  if (maxV !== null && !wantValue) stmts.push(`${ind(ctx)}let ${maxV} = ${def.min}`);
   stmts.push(`${ind(ctx)}while (${curV} < input.length) {`);
   ctx.indent++;
+  if (maxV !== null) stmts.push(`${ind(ctx)}if (${maxV} >= ${def.max}) break`);
   let itemPos = curV;
   let rollback = "";
   if (ctx.activeTrivia) {
@@ -5843,7 +6048,7 @@ function emitMany(def, ctx, pos) {
       `${ind(ctx)}if (!${iterOk}) {`,
       `${ind(ctx)}  ${rollback}if (_ctx._tolerant && ${mySyncV} !== undefined && !_ctx._rec.at(${mySyncV}, input, ${itemPos}, _ctx)) {`,
       `${ind(ctx)}    const ${rrV} = _ctx._rec.scan(input, ${itemPos}, _ctx, ${mySyncV}, ${exp})`,
-      ...wantValue ? [`${ind(ctx)}    ${arrV}.push(${rrV}.error)`] : [],
+      ...wantValue ? [`${ind(ctx)}    ${arrV}.push(${rrV}.error)`] : maxV !== null ? [`${ind(ctx)}    ${maxV}++`] : [],
       `${ind(ctx)}    _ctx._rec.capture(_ctx, ${rrV}.error)`,
       `${ind(ctx)}    ${curV} = ${rrV}.end`,
       `${ind(ctx)}    continue`,
@@ -5856,6 +6061,7 @@ function emitMany(def, ctx, pos) {
     stmts.push(`${ind(ctx)}if (!${iterOk} || ${iterEnd} <= ${itemPos}) { ${rollback}break }`);
   }
   if (wantValue) stmts.push(`${ind(ctx)}${arrV}.push(${iterVal})`);
+  else if (maxV !== null) stmts.push(`${ind(ctx)}${maxV}++`);
   stmts.push(`${ind(ctx)}${curV} = ${iterEnd}`);
   ctx.indent--;
   stmts.push(`${ind(ctx)}}`);
@@ -5920,8 +6126,8 @@ function emitSepBy(_p, def, ctx, pos) {
     ...rec ? [`${ind(ctx)}const ${mySyncV} = _ctx._sync`] : [],
     ...firstStmts
   ];
-  const failItem = (nextOkVar, itemPosVar, rb, originalFail) => {
-    if (!rec) return [originalFail];
+  const failItem = (nextOkVar, itemPosVar, breakStmt) => {
+    if (!rec) return [`${ind(ctx)}if (!${nextOkVar}) ${breakStmt === "break" ? "break" : `{ ${breakStmt} }`}`];
     const rr = v(ctx, "_rr");
     return [
       `${ind(ctx)}if (!${nextOkVar}) {`,
@@ -5929,10 +6135,24 @@ function emitSepBy(_p, def, ctx, pos) {
       `${ind(ctx)}    const ${rr} = _ctx._rec.scan(input, ${itemPosVar}, _ctx, ${scanSync}, ${exp})`,
       `${ind(ctx)}    ${arrV}.push(${rr}.error); _ctx._rec.capture(_ctx, ${rr}.error); ${curV} = ${rr}.end; continue`,
       `${ind(ctx)}  }`,
-      `${ind(ctx)}  ${rb}break`,
+      `${ind(ctx)}  ${breakStmt}`,
       `${ind(ctx)}}`
     ];
   };
+  const itemFailBreak = (sepEndVar, sepRb, postSepRb) => def.trailing === void 0 ? `${sepRb}break` : `${postSepRb}${curV} = ${sepEndVar}; break`;
+  const postSepMarks = () => {
+    if (def.trailing === void 0 || !ctx.capturing) return { decl: [], rb: "" };
+    const lv = v(ctx, "_tlv"), rw = v(ctx, "_trw"), tl = v(ctx, "_ttl"), lg = v(ctx, "_tlg");
+    return {
+      decl: [
+        `${ind(ctx)}const ${lv} = _ctx._cstLeaves ? _ctx._cstLeaves.length : 0`,
+        `${ind(ctx)}const ${rw} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,
+        `${ind(ctx)}const ${tl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,
+        `${ind(ctx)}const ${lg} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`
+      ],
+      rb: `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${lv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${rw}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${tl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${lg}; `
+    };
+  };
   if (rec) {
     const rr0 = v(ctx, "_rr0");
     const didV = v(ctx, "_did");
@@ -5958,6 +6178,7 @@ function emitSepBy(_p, def, ctx, pos) {
     );
     ctx.indent++;
   }
+  if (def.max !== void 0) stmts.push(`${ind(ctx)}if (${arrV}.length >= ${def.max}) break`);
   let sepAtPos = curV;
   if (ctx.activeTrivia) {
     if (ctx.capturing) {
@@ -5978,12 +6199,14 @@ function emitSepBy(_p, def, ctx, pos) {
       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, true);
       stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}break }`);
+      const post = postSepMarks();
+      stmts.push(...post.decl);
       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, true);
       stmts.push(
         ...nextStmts,
-        ...failItem(nextOk, npV, rollbackToSep, `${ind(ctx)}if (!${nextOk}) { ${rollbackToSep}break }`),
+        ...failItem(nextOk, npV, itemFailBreak(sepEnd, rollbackToSep, post.rb)),
         `${ind(ctx)}${arrV}.push(${nextVal})`,
         `${ind(ctx)}${curV} = ${nextEnd}`
       );
@@ -5999,7 +6222,7 @@ function emitSepBy(_p, def, ctx, pos) {
       const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV, true);
       stmts.push(
         ...nextStmts,
-        ...failItem(nextOk, npV, "", `${ind(ctx)}if (!${nextOk}) break`),
+        ...failItem(nextOk, npV, itemFailBreak(sepEnd, "", "")),
         `${ind(ctx)}${arrV}.push(${nextVal})`,
         `${ind(ctx)}${curV} = ${nextEnd}`
       );
@@ -6016,10 +6239,12 @@ function emitSepBy(_p, def, ctx, pos) {
     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 post = postSepMarks();
+    stmts.push(...post.decl);
     const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, sepEnd, true);
     stmts.push(
       ...nextStmts,
-      ...failItem(nextOk, sepEnd, nextRb, `${ind(ctx)}if (!${nextOk}) { ${nextRb}break }`),
+      ...failItem(nextOk, sepEnd, itemFailBreak(sepEnd, nextRb, post.rb)),
       `${ind(ctx)}${arrV}.push(${nextVal})`,
       `${ind(ctx)}${curV} = ${nextEnd}`
     );
@@ -6028,6 +6253,9 @@ function emitSepBy(_p, def, ctx, pos) {
   stmts.push(`${ind(ctx)}}`);
   ctx.indent--;
   stmts.push(`${ind(ctx)}}`);
+  if (def.min >= 1) {
+    stmts.push(...emitIfFail(ctx, `${arrV}.length < ${def.min}`, failArrBody(ctx, deriveExpectedArr([def.parser]), curV)));
+  }
   return { stmts, valueVar: arrV, endVar: curV };
 }
 function emitScanTo(def, ctx, pos) {
@@ -6079,17 +6307,44 @@ function emitScanTo(def, ctx, pos) {
   return { stmts, valueVar: valV, endVar: curV };
 }
 function emitNot(def, ctx, pos) {
+  const sinksLive = !!ctx.capturing || !!ctx.recovery;
+  const leaves = sinksLive ? v(ctx, "_ntl") : null;
+  const raw = sinksLive ? v(ctx, "_ntr") : null;
+  const tl = sinksLive ? v(ctx, "_ntt") : null;
+  const log = sinksLive ? v(ctx, "_ntg") : null;
+  const fields = sinksLive ? v(ctx, "_ntf") : null;
+  const errors = sinksLive ? v(ctx, "_nte") : null;
   const { stmts, okVar } = emitFallible(def.parser, ctx, pos, true);
   const label2 = JSON.stringify(`not(${def.parser._tag})`);
   return {
     stmts: [
+      ...sinksLive ? [
+        `${ind(ctx)}const ${leaves} = _ctx._cstLeaves?.length ?? 0, ${raw} = _ctx._cstRawChildren?.length ?? 0, ${tl} = _ctx._cstTriviaLog?.length ?? 0, ${log} = _ctx._triviaLog?.length ?? 0, ${fields} = _ctx._fields?.length ?? 0, ${errors} = _ctx._errors?.length ?? 0`
+      ] : [],
       ...stmts,
+      ...sinksLive ? [
+        `${ind(ctx)}if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${leaves}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${raw}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${tl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${log}; if (_ctx._fields) _ctx._fields.length = ${fields}; if (_ctx._errors) _ctx._errors.length = ${errors}`
+      ] : [],
       ...emitIfFail(ctx, okVar, failBody(ctx, label2, pos))
     ],
     valueVar: "null",
     endVar: pos
   };
 }
+function emitPeek(def, ctx, pos) {
+  const probeCtx = { ...ctx, capturing: false, noHoist: true };
+  const { stmts, okVar } = emitFallible(def.parser, probeCtx, pos, true);
+  ctx.vars = probeCtx.vars;
+  const label2 = JSON.stringify(`peek(${def.parser._tag})`);
+  return {
+    stmts: [
+      ...stmts,
+      ...emitIfFail(ctx, `!${okVar}`, failBody(ctx, label2, pos))
+    ],
+    valueVar: "null",
+    endVar: pos
+  };
+}
 function escapeTokenLiteral(value) {
   return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
 }
@@ -6377,9 +6632,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 canonical2 = ctx.ruleNames?.get(p);
   const usage = ctx.lazyUsage;
-  if (!canonical && usage && (usage.counts.get(p) ?? 0) <= 1 && !usage.recursive.has(p)) {
+  if (!canonical2 && usage && (usage.counts.get(p) ?? 0) <= 1 && !usage.recursive.has(p)) {
     let resolved;
     try {
       resolved = def.thunk();
@@ -6389,7 +6644,7 @@ function emitLazy(p, def, ctx, pos) {
     return emit(resolved, ctx, pos);
   }
   if (!ctx.namedParsers.has(p)) {
-    const fnName2 = canonical ?? `${nsp(ctx)}_pf${ctx.namedParsers.size}`;
+    const fnName2 = canonical2 ?? `${nsp(ctx)}_pf${ctx.namedParsers.size}`;
     ctx.namedParsers.set(p, fnName2);
     let resolved;
     try {
@@ -6672,6 +6927,8 @@ function emitDispatch(p, ctx, pos) {
     }
     case "not":
       return emitNot(def, ctx, pos);
+    case "peek":
+      return emitPeek(def, ctx, pos);
     case "node":
       return emitNode(def, ctx, pos);
     case "scanTo":
@@ -6760,6 +7017,7 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
     case "many":
     case "oneOrMore":
     case "not":
+    case "peek":
     case "transform":
       return hasNodeDef(d.parser, seen);
     case "skip":
@@ -6811,17 +7069,18 @@ function childrenOf(def) {
     case "field":
     case "grammar":
     case "not":
+    case "peek":
     case "node":
     case "withCtx":
     case "expect":
       return [def.parser];
-    // emitMany's oneOrMore branch and emitSepBy both codegen `def.parser` TWICE
-    // (a mandatory first match, then again inside the repeat loop) — two real
-    // emit() call sites, so the usage analysis must see two edges here or it
+    // emitMany's min>=1 branch and emitSepBy both codegen `def.parser` more than
+    // once (`min` mandatory matches, then again inside the repeat loop) — each is a
+    // real emit() call site, so the usage analysis must see one edge per site or it
     // undercounts a single-use `parser` ref as inline-safe when it's actually
-    // referenced from two positions within this one compiled function.
+    // referenced from several positions within this one compiled function.
     case "oneOrMore":
-      return [def.parser, def.parser];
+      return Array.from({ length: def.min + 1 }, () => def.parser);
     case "sepBy":
       return [def.parser, def.parser, def.separator];
     case "skip":
@@ -6967,12 +7226,41 @@ function resolveGatingLevel(opt) {
   return "warn";
 }
 function runGatingDiagnostic(combinator, opt) {
+  return reportGating(opt, (o) => analyzeGating(combinator, o));
+}
+function runGatingDiagnosticRules(ruleMap, opt) {
+  return reportGating(opt, (o) => analyzeGatingRules(ruleMap, o));
+}
+function runFusedGatingDiagnostic(getRuleMaps, opt) {
+  if (resolveGatingLevel(opt) === "off") return void 0;
+  const ruleMaps = getRuleMaps();
+  if (!ruleMaps.some((map) => hasExternalRuleRef(map))) return void 0;
+  const winners = /* @__PURE__ */ new Map();
+  for (const map of ruleMaps) for (const [name, rule] of map) {
+    if (rule._def.tag === "lazy") {
+      try {
+        rule._def.thunk();
+      } catch {
+        continue;
+      }
+    }
+    winners.set(name, rule);
+  }
+  const entries = [...winners];
+  return reportGating(opt, (o) => {
+    const deferredHere = new Set(analyzeGatingRules(entries, o).deferred.map((c) => c.id));
+    const fused = analyzeGatingRules(entries, { ...o, resolveRef: (name) => winners.get(name) });
+    return { ...fused, ungated: fused.ungated.filter((c) => deferredHere.has(c.id)), antiPatterns: [] };
+  });
+}
+function reportGating(opt, analyze) {
   const level = resolveGatingLevel(opt);
   if (level === "off") return void 0;
-  const accept = opt !== null && typeof opt === "object" ? opt.accept : void 0;
+  const obj = opt !== null && typeof opt === "object" ? opt : void 0;
+  const analyzeOpts = obj?.accept !== void 0 || obj?.entryName !== void 0 ? { ...obj.accept !== void 0 ? { accept: obj.accept } : {}, ...obj.entryName !== void 0 ? { entryName: obj.entryName } : {} } : void 0;
   let report;
   try {
-    report = analyzeGating(combinator, accept ? { accept } : void 0);
+    report = analyze(analyzeOpts);
   } catch {
     return void 0;
   }
@@ -7108,6 +7396,7 @@ function publicRuleWrapperSource(rule, fnSource) {
   return `Object.assign(${fnSource}, { _meta: { triviaKindLabels: ${JSON.stringify(labels)} } })`;
 }
 function compileRuleMap(ruleMap, opts) {
+  runGatingDiagnosticRules(ruleMap, opts?.gating);
   for (const [, rule] of ruleMap) markUnusedValues(rule);
   const coverageWinners = opts?.coverage ? Object.fromEntries(ruleMap.filter(([, rule]) => rule._def.tag !== "lazy")) : void 0;
   const grammarTrivia = opts?.trivia;
@@ -7226,6 +7515,7 @@ function compileRuleMap(ruleMap, opts) {
 }
 function compileLinkable(ruleMapArg, ns, opts) {
   if (!ns) throw new Error("compileLinkable: ns must be a non-empty namespace");
+  if (opts?.gating !== void 0) runGatingDiagnosticRules(ruleMapArg, opts.gating);
   for (const [, rule] of ruleMapArg) markUnusedValues(rule);
   const grammarTrivia = opts?.trivia ?? ruleMapArg.map(([, r]) => r._meta.grammarTrivia).find(Boolean);
   const grammarScanSkip = opts?.scanSkip ?? ruleMapArg.map(([, r]) => r._meta.grammarScanSkip).find(Boolean);
@@ -7282,6 +7572,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
     fnNameToKey.set(fn, key);
   }
   ctx.ruleNames = ruleNames;
+  const externalRefs = /* @__PURE__ */ new Set();
   {
     const scanned = /* @__PURE__ */ new Set();
     const scanExternal = (p) => {
@@ -7297,11 +7588,14 @@ function compileLinkable(ruleMapArg, ns, opts) {
         }
         if (resolved === void 0) {
           const name = p._ruleName;
-          if (name && !ctx.namedParsers.has(p)) {
-            assertRuleName(name);
-            const fn = `_r_${name}`;
-            ruleNames.set(p, fn);
-            ctx.namedParsers.set(p, fn);
+          if (name) {
+            externalRefs.add(p);
+            if (!ctx.namedParsers.has(p)) {
+              assertRuleName(name);
+              const fn = `_r_${name}`;
+              ruleNames.set(p, fn);
+              ctx.namedParsers.set(p, fn);
+            }
           }
           return;
         }
@@ -7414,12 +7708,32 @@ function compileLinkable(ruleMapArg, ns, opts) {
     needsEmptyTl: !!ctx.needsEmptyTl,
     needsHostReads: !!ctx.needsHostReads,
     hasDirectBuilders: ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
-    isRecognitionOnly: !hasSemanticReduction(ruleMap.map(([, rule]) => rule)),
+    isRecognitionOnly: !hasSemanticReduction(ruleMap.map(([, rule]) => rule), externalRefs),
     mfFns: mfSrcs ? [] : ctx.mapFns,
     buildFns: buildSrcs ? [] : ctx.buildFns
   };
 }
-function hasSemanticReduction(roots) {
+function hasExternalRuleRef(ruleMap) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (p) => {
+    if (seen.has(p)) return false;
+    seen.add(p);
+    const def = p._def;
+    if (def.tag === "lazy") {
+      let resolved;
+      try {
+        resolved = def.thunk();
+      } catch {
+        resolved = void 0;
+      }
+      if (resolved === void 0) return p._ruleName !== void 0;
+      return visit(resolved);
+    }
+    return childrenOf(def).some(visit);
+  };
+  return ruleMap.some(([, rule]) => visit(rule));
+}
+function hasSemanticReduction(roots, externalRefs) {
   const seen = /* @__PURE__ */ new Set();
   const visit = (parser2) => {
     if (seen.has(parser2)) return false;
@@ -7430,6 +7744,7 @@ function hasSemanticReduction(roots) {
     if (def.tag === "guard" || def.tag === "withCtx") return true;
     if (def.tag === "node" && def.build !== void 0) return true;
     if (def.tag === "lazy") {
+      if (externalRefs?.has(parser2)) return false;
       try {
         return visit(def.thunk());
       } catch {
@@ -7521,6 +7836,7 @@ function childrenOf2(def) {
     case "label":
     case "field":
     case "not":
+    case "peek":
     case "node":
     case "withCtx":
     case "expect":
@@ -7554,9 +7870,16 @@ function lazyTarget(c) {
 }
 var Unserializable = class extends Error {
 };
-function serializeRuleMap(ruleMap) {
+function repeatOpts(min, max, trailing) {
+  const parts = [];
+  if (min !== 0) parts.push(`min: ${min}`);
+  if (max !== void 0) parts.push(`max: ${max}`);
+  if (trailing !== void 0) parts.push(`trailing: ${JSON.stringify(trailing)}`);
+  return parts.length === 0 ? "" : `, { ${parts.join(", ")} }`;
+}
+function serializeRuleMap(ruleMap, scanSkip) {
   try {
-    return new Serializer(ruleMap).run();
+    return new Serializer(ruleMap, scanSkip ?? []).run();
   } catch (e) {
     if (e instanceof Unserializable) {
       if (process.env.PARSEMAN_IR_DEBUG) console.error(`[ir] fallback: ${e.message}`);
@@ -7657,6 +7980,7 @@ function evalRuleMapIR(ir) {
     "optional",
     "sepBy",
     "not",
+    "peek",
     "node",
     "parser",
     "scanTo",
@@ -7689,6 +8013,7 @@ function evalRuleMapIR(ir) {
     optional,
     sepBy,
     not,
+    peek,
     node,
     parser,
     scanTo,
@@ -7717,10 +8042,28 @@ var Serializer = class {
   decls = [];
   ruleValues = /* @__PURE__ */ new Set();
   ruleMap;
-  constructor(ruleMap) {
+  scanSkip;
+  constructor(ruleMap, scanSkip = []) {
     this.ruleMap = ruleMap;
+    this.scanSkip = scanSkip;
     for (const [, c] of ruleMap) this.ruleValues.add(this.body(c));
   }
+  /** A grammar-level `scanSkip` unit is an opaque TERMINAL (a string, a balanced
+   * bracket) — it must not reach a grammar-rule ref (`g[name]`), because the
+   * serialized `scanSkip` array sits in the `rules({ scanSkip })` OPTIONS position,
+   * outside the `(g) => …` factory where `g` is bound. A unit that does reference a
+   * rule can't be carried in options; bail to the full-pieces fallback. */
+  assertNoRuleRef(c, seen) {
+    if (seen.has(c)) return;
+    seen.add(c);
+    if (c._def.tag === "lazy") {
+      if (ruleNameOf2(c) !== void 0) throw new Unserializable("scanSkip unit references a grammar rule");
+      const target = lazyTarget(c);
+      if (target) this.assertNoRuleRef(target, seen);
+      return;
+    }
+    for (const child of childrenOf2(c._def)) this.assertNoRuleRef(child, seen);
+  }
   /** A `rules()` map wraps each rule value in a named `lazy` proxy; the real body is
    * its target (compileLinkable unwraps the same way). A ref INSIDE a body stays a
    * `g[name]` ref — only the top-level entry is unwrapped. */
@@ -7729,21 +8072,38 @@ var Serializer = class {
   }
   run() {
     for (const [, c] of this.ruleMap) this.analyze(this.body(c), /* @__PURE__ */ new Set());
+    for (const c of this.scanSkip) {
+      this.assertNoRuleRef(c, /* @__PURE__ */ new Set());
+      this.analyze(c, /* @__PURE__ */ new Set());
+    }
     let n = 0;
     for (const [c, count] of this.counts) {
       if (this.ruleValues.has(c)) continue;
       if (count >= 2 || this.selfRef.has(c)) this.constName.set(c, `_s${n++}`);
     }
+    const outerDecls = [];
+    const innerDecls = [];
+    let optionsArg = "";
+    if (this.scanSkip.length > 0) {
+      this.decls = outerDecls;
+      const units = this.scanSkip.map((c) => this.ref(c, null));
+      optionsArg = `{ scanSkip: [${units.join(", ")}] }, `;
+    }
+    this.decls = innerDecls;
     const body = this.ruleMap.map(([name, c]) => `  ${JSON.stringify(name)}: ${this.wrap(this.body(c))}`).join(",\n");
-    if (this.decls.length === 0) return `rules((g) => ({
+    const factory = innerDecls.length === 0 ? `(g) => ({
 ${body}
-}))`;
-    return `rules((g) => {
-${this.decls.map((d) => "  " + d).join("\n")}
+})` : `(g) => {
+${innerDecls.map((d) => "  " + d).join("\n")}
   return ({
 ${body}
 })
-})`;
+}`;
+    const call = `rules(${optionsArg}${factory})`;
+    return outerDecls.length === 0 ? call : `(() => {
+${outerDecls.map((d) => "  " + d).join("\n")}
+  return ${call}
+})()`;
   }
   /** Count identity references and flag self-referential subtrees. `active` is the
    * set of combinators on the current DFS path (to detect a lazy pointing back). */
@@ -7828,17 +8188,21 @@ ${body}
         return `_gch([${items.join(", ")}])`;
       }
       case "many":
-        return `many(${kid(def.parser)})`;
+        return `many(${kid(def.parser)}${repeatOpts(def.min, def.max)})`;
+      // A `oneOrMore` def with min > 1 came from `many(x, { min: n })`; round-trip
+      // it through `many` so the bounds survive (oneOrMore defaults min to 1).
       case "oneOrMore":
-        return `oneOrMore(${kid(def.parser)})`;
+        return def.min === 1 && def.max === void 0 ? `oneOrMore(${kid(def.parser)})` : `many(${kid(def.parser)}${repeatOpts(def.min, def.max)})`;
       case "optional":
         return `optional(${kid(def.parser)})`;
       case "attempt":
         return `attempt(${kid(def.parser)})`;
       case "sepBy":
-        return `sepBy(${kid(def.parser)}, ${kid(def.separator)})`;
+        return `sepBy(${kid(def.parser)}, ${kid(def.separator)}${repeatOpts(def.min, def.max, def.trailing)})`;
       case "not":
         return `not(${kid(def.parser)})`;
+      case "peek":
+        return `peek(${kid(def.parser)})`;
       case "trivia":
         return `trivia(${kid(def.parser)})`;
       case "token":
@@ -8274,15 +8638,12 @@ var SUPPORTED = {
   literal: (...a) => literal(a[0], a[1]),
   regex: (...a) => regex(a[0], a[1]),
   keywords: (...a) => keywords(a[0], a[1]),
-  word: (...a) => word(a[0], a[1]),
+  word: (...a) => word(a[0], a[1], a[2]),
   sequence: (...a) => sequence(...a),
   choice: (...a) => choice(...a),
   attempt: (...a) => attempt(a[0]),
-  many: (...a) => many(a[0]),
-  oneOrMore: (...a) => oneOrMore(a[0]),
   optional: (...a) => optional(a[0]),
   skip: (...a) => skip(a[0], a[1]),
-  sepBy: (...a) => sepBy(a[0], a[1]),
   trivia: (...a) => trivia(a[0]),
   label: (...a) => label(a[0], a[1]),
   field: (...a) => field(a[0], a[1]),
@@ -8458,8 +8819,8 @@ function exprToCombi(node2, scope, code, mfs) {
       return null;
     }
   }
-  if (callee.name === "sepBy") {
-    const [itemArg, sepArg] = node2.arguments;
+  if (callee.name === "sepBy" || callee.name === "oneOrMoreSep") {
+    const [itemArg, sepArg, optsArg] = node2.arguments;
     if (!itemArg || !sepArg || itemArg.type === "SpreadElement" || sepArg.type === "SpreadElement") return null;
     const itemMfs = [];
     const itemCombi = anyValue(itemArg, scope, code, itemMfs);
@@ -8467,25 +8828,42 @@ function exprToCombi(node2, scope, code, mfs) {
     const sepMfs = [];
     const sepCombi = anyValue(sepArg, scope, code, sepMfs);
     if (!isCombinator(sepCombi)) return null;
+    let opts;
+    if (optsArg) {
+      if (optsArg.type === "SpreadElement") return null;
+      const v2 = anyValue(optsArg, scope, code, []);
+      if (!v2 || typeof v2 !== "object") return null;
+      opts = v2;
+    }
     if (mfs) mfs.push(...itemMfs, ...sepMfs, ...itemMfs);
     try {
-      return sepBy(itemCombi, sepCombi);
+      return callee.name === "sepBy" ? sepBy(itemCombi, sepCombi, opts) : oneOrMoreSep(itemCombi, sepCombi, opts);
     } catch {
       return null;
     }
   }
-  if (callee.name === "oneOrMore") {
-    const [itemArg] = node2.arguments;
+  if (callee.name === "oneOrMore" || callee.name === "many") {
+    const [itemArg, optsArg] = 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);
+    let opts;
+    if (optsArg) {
+      if (optsArg.type === "SpreadElement") return null;
+      const v2 = anyValue(optsArg, scope, code, []);
+      if (!v2 || typeof v2 !== "object") return null;
+      opts = v2;
+    }
+    let combi;
     try {
-      return oneOrMore(itemCombi);
+      combi = callee.name === "many" ? many(itemCombi, opts) : oneOrMore(itemCombi, opts);
     } catch {
       return null;
     }
+    const min = combi._def.tag === "oneOrMore" ? combi._def.min : 0;
+    if (mfs) for (let i = 0; i <= min; i++) mfs.push(...itemMfs);
+    return combi;
   }
   if (callee.name === "not") {
     const [innerArg] = node2.arguments;
@@ -8498,6 +8876,17 @@ function exprToCombi(node2, scope, code, mfs) {
       return null;
     }
   }
+  if (callee.name === "peek") {
+    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 peek(inner);
+    } catch {
+      return null;
+    }
+  }
   if (callee.name === "balanced") {
     const [openArg, closeArg, optsArg] = node2.arguments;
     if (!openArg || !closeArg || openArg.type === "SpreadElement" || closeArg.type === "SpreadElement") return null;
@@ -9127,6 +9516,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const warnings = [];
   beginLoweringCapture();
   let anyUnresolved = false;
+  let keepMacroImport = false;
   let runtimeComposeFallback = false;
   let ruleMapHolderCounter = 0;
   const lineOf = (pos) => {
@@ -9161,17 +9551,21 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     const gTrivia = triviaValue ? evaluateExpr(triviaValue, scope, code, []) : void 0;
     const scanSkipValue = optionValue("scanSkip");
     const gScanSkip = scanSkipValue ? evaluateCombinatorArray(scanSkipValue, scope, code) ?? void 0 : void 0;
+    if (gScanSkip) {
+      for (const rule of ruleMap.values()) {
+        if (rule && !rule._meta.isTrivia) {
+          ;
+          rule._meta.grammarScanSkip = gScanSkip;
+        }
+      }
+    }
     return { ruleMap, ...gTrivia ? { trivia: gTrivia } : {}, ...gScanSkip ? { scanSkip: gScanSkip } : {} };
   };
   const compileRulesFactory = (init, label2) => {
     const evaluated = evaluateRulesFactory(init, label2);
     if (!evaluated) return null;
     const compiled = compileRuleMap([...evaluated.ruleMap], { ...evaluated.trivia ? { trivia: evaluated.trivia } : {}, ...evaluated.scanSkip ? { scanSkip: evaluated.scanSkip } : {}, recovery, coverage: grammarCoverage });
-    if (!compiled) {
-      warn(init.start, `${label2}: rule map couldn't be inlined`);
-      return null;
-    }
-    return { replacement: compiled.replacement, ruleMap: evaluated.ruleMap, ...compiled.coverageDefinitions ? { coverageDefinitions: compiled.coverageDefinitions } : {}, ...evaluated.trivia ? { trivia: evaluated.trivia } : {}, ...evaluated.scanSkip ? { scanSkip: evaluated.scanSkip } : {} };
+    return { replacement: compiled?.replacement ?? null, ruleMap: evaluated.ruleMap, ...compiled?.coverageDefinitions ? { coverageDefinitions: compiled.coverageDefinitions } : {}, ...evaluated.trivia ? { trivia: evaluated.trivia } : {}, ...evaluated.scanSkip ? { scanSkip: evaluated.scanSkip } : {} };
   };
   const isRulesCall = (init) => init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "rules";
   const isComposeCall = (init) => init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "compose";
@@ -9266,6 +9660,17 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     }
     return out;
   };
+  const carriedRuleMaps = (items) => {
+    const out = [];
+    const add = (it) => {
+      if (isIR(it)) out.push(evalRuleMapIR(it.ir));
+    };
+    for (const it of items) {
+      if (isSpread(it)) for (const p of importedPieces(it.__spreadLocal) ?? []) add(p);
+      else add(it);
+    }
+    return out;
+  };
   const materializeLeafCoverage = (items, localRules, localNs, composing, captureTerminals = false) => {
     const sources = [];
     const add = (item) => {
@@ -9297,12 +9702,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     }
     return pieces;
   };
-  const localCarried = (rm, label2, composing) => {
+  const localCarried = (rm, label2, composing, scanSkip) => {
     const entries = [...rm];
     const ns = nsFor(label2);
-    const ir = serializeRuleMap(entries);
+    const ir = serializeRuleMap(entries, scanSkip);
     if (ir) return { carried: [{ ns, ir }] };
-    const p = compileLinkable(entries, ns, { ...composing ? { trivia: composing } : {}, recovery });
+    const p = compileLinkable(entries, ns, { ...composing ? { trivia: composing } : {}, ...scanSkip ? { scanSkip } : {}, recovery });
     return p ? { carried: [p] } : null;
   };
   const argPieces = (arg, label2, composing) => {
@@ -9327,18 +9732,13 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       }
     }
     if (isRulesCall(arg)) {
-      const rulesArgs = arg.arguments;
-      const a0 = rulesArgs[0];
-      const a1 = rulesArgs[1];
-      const optionsFirst = a0?.type === "ObjectExpression";
-      const factory = optionsFirst ? a1 : a0;
-      const rm = factory ? evaluateParserFactory(factory, scope, code, []) : null;
-      return rm ? localCarried(rm, label2, composing) : null;
+      const evaluated = evaluateRulesFactory(arg, label2);
+      return evaluated ? localCarried(evaluated.ruleMap, label2, composing, evaluated.scanSkip) : null;
     }
     if (arg.type === "Identifier") {
       const name = arg.name;
       const rm = localRuleMaps.get(name);
-      if (rm) return localCarried(rm, label2, composing);
+      if (rm) return localCarried(rm, label2, composing, localGrammarScanSkip.get(name));
       const composed = localComposedCarried.get(name);
       if (composed) return { carried: composed };
       const pieces = importedPieces(name);
@@ -9404,6 +9804,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       }
       carried.push(...r.carried);
     }
+    runFusedGatingDiagnostic(() => carriedRuleMaps(carried));
     const pieces = materializeCarried(carried, composing);
     try {
       return { replacement: emitFusedSource(pieces), carried, ...composing ? { trivia: composing } : {} };
@@ -9452,6 +9853,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     }
     try {
       const localNs = nsFor(`composeLeaf${init.start}`);
+      runFusedGatingDiagnostic(() => [...carriedRuleMaps(carried), [...localRules]]);
       const plainLocalPiece = compileLinkable([...localRules], localNs, { ...composing ? { trivia: composing } : {}, ...localScanSkip ? { scanSkip: localScanSkip } : {}, recovery });
       if (!plainLocalPiece) {
         warn(init.start, "composeLeaf(): local rules could not be statically compiled");
@@ -9540,7 +9942,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           const refEntry = scope.get(varName);
           const refCombi = refEntry?.combi ?? null;
           if (refCombi) {
-            const compiled2 = compile(refCombi, void 0, { recovery, coverage: grammarCoverage });
+            const compiled2 = compile(refCombi, void 0, { recovery, coverage: grammarCoverage, gating: { entryName: varName } });
             if (compiled2.inlineExpression === null) {
               warn(init.start, `"${varName}" is a ref() that couldn't be inlined (was .define() called with a static combinator?)`);
               continue;
@@ -9555,17 +9957,26 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           localRuleMaps.set(varName, compiledRules.ruleMap);
           if (compiledRules.trivia) localGrammarTrivia.set(varName, compiledRules.trivia);
           if (compiledRules.scanSkip) localGrammarScanSkip.set(varName, compiledRules.scanSkip);
+          const ns = nsFor(varName);
+          const pieces = exportPrefix || compiledRules.replacement === null ? compileLinkable([...compiledRules.ruleMap], ns, {
+            ...compiledRules.scanSkip ? { scanSkip: compiledRules.scanSkip } : {},
+            recovery
+          }) : null;
+          if (compiledRules.replacement === null) {
+            if (!pieces || !hasExternalRuleRef([...compiledRules.ruleMap])) {
+              warn(init.start, `${varName}: rule map couldn't be inlined`);
+              continue;
+            }
+            keepMacroImport = true;
+          }
+          const source = compiledRules.replacement ?? code.slice(init.start, init.end);
           let replacement = withCoverageDefinitions(
-            compiledRules.replacement,
-            compiledRules.coverageDefinitions?.length ? compiledRules.coverageDefinitions : emittedCoverageDefinitions(compiledRules.replacement)
+            source,
+            compiledRules.coverageDefinitions?.length ? compiledRules.coverageDefinitions : emittedCoverageDefinitions(source)
           );
-          if (exportPrefix) {
-            const ns = nsFor(varName);
-            const pieces = compileLinkable([...compiledRules.ruleMap], ns, { recovery });
-            if (pieces && !pieces.mfFns.length && !pieces.buildFns.length) {
-              const ir = serializeRuleMap([...compiledRules.ruleMap]);
-              replacement = withCarriedPieces(replacement, [ir ? { ns, ir } : pieces]);
-            }
+          if (exportPrefix && pieces && !pieces.mfFns.length && !pieces.buildFns.length) {
+            const ir = serializeRuleMap([...compiledRules.ruleMap], compiledRules.scanSkip);
+            replacement = withCarriedPieces(replacement, [ir ? { ns, ir } : pieces]);
           }
           replacements.push({ start: init.start, end: init.end, replacement });
           continue;
@@ -9608,7 +10019,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           warn(init.start, `"${varName}" references a parseman macro import but isn't a statically-evaluable combinator`);
           continue;
         }
-        const compiled = compile(parser2, void 0, { recovery, coverage: grammarCoverage });
+        const compiled = compile(parser2, void 0, { recovery, coverage: grammarCoverage, gating: { entryName: varName } });
         if (compiled.inlineExpression === null) {
           warn(init.start, `"${varName}" couldn't be inlined (likely closes over a runtime value)`);
           continue;
@@ -9627,6 +10038,10 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         }
         const compiledRules = compileRulesFactory(init, "{ \u2026 }");
         if (!compiledRules) continue;
+        if (compiledRules.replacement === null) {
+          warn(init.start, `{ \u2026 }: rule map couldn't be inlined`);
+          continue;
+        }
         const pattern = d.id;
         const bindings = [];
         let allOk = true;
@@ -9668,7 +10083,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   }
   if (replacements.length === 0 && warnings.length === 0) return null;
   for (const imp of macroImports) {
-    imp.fullyResolved = !anyUnresolved;
+    imp.fullyResolved = !anyUnresolved && !keepMacroImport;
   }
   const ms = new MagicString(code);
   if (!anyUnresolved) {