parseman 0.28.1 → 0.30.0

package/dist/index.js

@@ -18,6 +18,15 @@ function intersects(a, b) {
 function fromChar(code) {
   return { kind: "ranges", ranges: [{ lo: code, hi: code }] };
 }
+function startsFirstSet(combinator, input, pos) {
+  const fs = combinator._meta.firstSet;
+  if (fs.kind === "any") return true;
+  if (fs.kind === "empty") return false;
+  const code = input.codePointAt(pos);
+  if (code === void 0) return false;
+  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
+  return false;
+}
 function fromRange(lo, hi) {
   return { kind: "ranges", ranges: [{ lo, hi }] };
 }
@@ -944,6 +953,17 @@ function deriveExpected(c) {
       return def.parsers.length > 0 ? deriveExpected(def.parsers[0]) : [];
     case "attempt":
       return deriveExpected(def.parser);
+    // Delegating wrappers whose first-token failure is their inner parser's — must
+    // pass through so a start-failure (and the first-set-miss fast-path in attempt/
+    // node, which reads this) names the real expected token, not the wrapper tag.
+    case "field":
+    case "withCtx":
+    case "recover":
+      return deriveExpected(def.parser);
+    case "skip":
+      return deriveExpected(def.main);
+    case "expect":
+      return def.expected;
     case "node":
     case "grammar":
     case "trivia":
@@ -1007,7 +1027,7 @@ function choice(...args) {
     disjoint
   };
   const strategy = disjoint || hasGates ? null : detectStrategy(parsers);
-  const autoNot = !disjoint && !hasGates && strategy?.tag === "firstMatch" ? computeAutoNot(parsers) : parsers.map(() => null);
+  const autoNot = !disjoint && !hasGates && (strategy?.tag === "firstMatch" || strategy?.tag === "sharedPrefix") ? computeAutoNot(parsers) : parsers.map(() => null);
   let greedyLitMap = null;
   let sortedParsers = null;
   const asciiDispatch = disjoint ? buildAsciiDispatch(parsers) : null;
@@ -1133,8 +1153,47 @@ function detectStrategy(parsers) {
     );
     return { tag: "literalsLongestFirst", sortedIndices };
   }
+  const shared = detectSharedPrefix(parsers);
+  if (shared !== null) return shared;
   return { tag: "firstMatch" };
 }
+function bareLeadingTermKey(term) {
+  const d = term._def;
+  if (d.tag === "literal" && !d.caseInsensitive) return `L:${d.value}`;
+  if (d.tag === "regex") return `R:${d.source}\0${d.flags}`;
+  return null;
+}
+function detectSharedPrefix(parsers) {
+  if (parsers.length < 2) return null;
+  let key = null;
+  let prefix = null;
+  const members = [];
+  for (let i = 0; i < parsers.length; i++) {
+    const term0 = leadingTermOfArm(parsers[i]);
+    if (term0 === null) return null;
+    const k = bareLeadingTermKey(term0);
+    if (k === null) return null;
+    if (key === null) {
+      key = k;
+      prefix = term0;
+    } else if (k !== key) return null;
+    members.push(i);
+  }
+  if (prefix === null || members.length < 2) return null;
+  return { tag: "sharedPrefix", prefix, members };
+}
+function leadingTermOfArm(arm) {
+  let d = arm._def;
+  for (; ; ) {
+    if (d.tag === "node" || d.tag === "grammar" || d.tag === "transform" || d.tag === "label") {
+      d = d.parser._def;
+      continue;
+    }
+    break;
+  }
+  if (d.tag !== "sequence" || d.parsers.length < 2) return null;
+  return d.parsers[0];
+}
 function computeAutoNot(parsers) {
   return parsers.map((p, i) => {
     const litVal = getCoreLiteralValue(p);
@@ -1728,11 +1787,20 @@ function sequence(...parsers) {
 
 // src/combinators/attempt.ts
 function attempt(parser2) {
+  const guardable = parser2._meta.firstSet.kind !== "any" && !matchesEmpty(parser2);
+  let failExpected;
   return {
     _tag: "attempt",
     _meta: parser2._meta,
     _def: { tag: "attempt", parser: parser2 },
     parse(input, pos, ctx) {
+      if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(parser2, input, pos)) {
+        if (failExpected === void 0) {
+          const e = deriveExpected(parser2);
+          failExpected = e.length > 0 ? e : [parser2._tag];
+        }
+        return { ok: false, expected: failExpected, span: { start: pos, end: pos } };
+      }
       const mark = saveCstMark(ctx);
       const log = ctx._triviaLog?.length;
       const result = parser2.parse(input, pos, ctx);
@@ -1745,7 +1813,7 @@ function attempt(parser2) {
 }
 
 // src/combinators/repeat.ts
-function repItem(combinator, input, cur, ctx) {
+function repItem(combinator, input, cur, ctx, guardable) {
   const mark = saveTriviaMark(ctx);
   let pos = cur;
   if (ctx.trivia) {
@@ -1761,6 +1829,10 @@ function repItem(combinator, input, cur, ctx) {
     rollbackTrivia(ctx, mark);
     return "stop";
   }
+  if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(combinator, input, pos)) {
+    rollbackTrivia(ctx, mark);
+    return "stop";
+  }
   const result = combinator.parse(input, pos, ctx);
   if (!result.ok) {
     rollbackTrivia(ctx, mark);
@@ -1780,6 +1852,7 @@ function many(combinator) {
   };
   const def = { tag: "many", parser: combinator, min: 0 };
   let expected;
+  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
   return {
     _tag: "many",
     _meta: meta,
@@ -1788,7 +1861,7 @@ function many(combinator) {
       const values = def.valueUnused ? void 0 : [];
       let cur = pos;
       while (cur < input.length) {
-        const item = repItem(combinator, input, cur, ctx);
+        const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop") break;
         if ("fail" in item) {
           const sync = ctx._tolerant ? ctx._sync : void 0;
@@ -1816,6 +1889,7 @@ function oneOrMore(combinator) {
   };
   const def = { tag: "oneOrMore", parser: combinator, min: 1 };
   let expected;
+  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
   return {
     _tag: "oneOrMore",
     _meta: meta,
@@ -1826,7 +1900,7 @@ function oneOrMore(combinator) {
       const values = def.valueUnused ? void 0 : [first.value];
       let cur = first.span.end;
       while (cur < input.length) {
-        const item = repItem(combinator, input, cur, ctx);
+        const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop") break;
         if ("fail" in item) {
           const sync = ctx._tolerant ? ctx._sync : void 0;
@@ -1869,15 +1943,6 @@ function optional(combinator) {
     }
   };
 }
-function startsFirstSet(combinator, input, pos) {
-  const fs = combinator._meta.firstSet;
-  if (fs.kind === "any") return true;
-  if (fs.kind === "empty") return false;
-  const code = input.codePointAt(pos);
-  if (code === void 0) return false;
-  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
-  return false;
-}
 function sepBy(combinator, separator) {
   const meta = {
     firstSet: combinator._meta.firstSet,
@@ -2411,11 +2476,20 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   const capturesTrivia = captureTrivia || trailingTrivia || (build ? buildReadsTrivia(def) : true);
   const clonesState = build ? buildReadsState(def) : true;
   const capturesFields = parserHasOwnFields(combinator) && (build ? buildReadsFields(def) : true);
+  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
+  let failExpected;
   return {
     _tag: "node",
     _meta: meta,
     _def: def,
     parse(input, pos, ctx) {
+      if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(combinator, input, pos)) {
+        if (failExpected === void 0) {
+          const e = deriveExpected(combinator);
+          failExpected = e.length > 0 ? e : [combinator._tag];
+        }
+        return { ok: false, expected: failExpected, span: { start: pos, end: pos } };
+      }
       const saved = beginCstNodeCapture(ctx);
       const savedFields = ctx._fields;
       ctx._fields = capturesFields ? [] : void 0;
@@ -4140,6 +4214,61 @@ function tryInlineDestructureTransform(src, valueVars) {
 }
 
 // src/compiler/codegen.ts
+function leadingFirstSetRecipe(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return { concrete: empty(), refs: [] };
+  seen.add(p);
+  const d = p._def;
+  const rec = (c) => leadingFirstSetRecipe(c, seen);
+  const merge2 = (a, b) => ({ concrete: union(a.concrete, b.concrete), refs: [...a.refs, ...b.refs] });
+  switch (d.tag) {
+    case "lazy": {
+      const name = p._ruleName;
+      if (name !== void 0) return { concrete: empty(), refs: [name] };
+      try {
+        return rec(d.thunk());
+      } catch {
+        return { concrete: any(), refs: [] };
+      }
+    }
+    case "literal":
+    case "regex":
+    case "keywords":
+      return { concrete: p._meta.firstSet, refs: [] };
+    case "choice": {
+      let out = { concrete: empty(), refs: [] };
+      for (const arm of d.parsers) out = merge2(out, rec(arm));
+      return out;
+    }
+    case "sequence": {
+      let out = { concrete: empty(), refs: [] };
+      for (const term of d.parsers) {
+        out = merge2(out, rec(term));
+        if (!matchesEmpty(term)) return out;
+      }
+      return out;
+    }
+    case "oneOrMore":
+    case "many":
+    case "optional":
+    case "transform":
+    case "label":
+    case "field":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "node":
+    case "grammar":
+    case "expect":
+      return rec(d.parser);
+    case "sepBy":
+      return rec(d.parser);
+    case "skip":
+      return rec(d.main);
+    // not / scanTo / guard / withCtx / recover / unknown → shallow set (safe).
+    default:
+      return { concrete: p._meta.firstSet, refs: [] };
+  }
+}
 var HOST_READS_DECL = "const _hostReads = (b, n) => { if (b === undefined) return false; let s; try { s = Function.prototype.toString.call(b) } catch (e) { return true } if (/\\barguments\\b/.test(s)) return true; const m = /^[^(]*\\(([\\s\\S]*?)\\)/.exec(s); if (m && /\\.\\.\\.|=/.test(m[1])) return true; return b.length > n }";
 var _loweringSink = null;
 function v(ctx, prefix = "_v") {
@@ -4373,6 +4502,7 @@ var SWITCH_RANGE_LIMIT = 4;
 var SWITCH_MAX_CASES = 48;
 var SWITCH_MIN_CASES = 3;
 var _forceDisjointIf = false;
+var _forceNoSharedPrefix = false;
 function planDisjointDispatch(parsers) {
   const cases = [];
   let total = 0;
@@ -5008,7 +5138,7 @@ function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos, cov
   stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)));
   return { stmts, valueVar: valV, endVar: endV };
 }
-function emitFirstMatch(def, ctx, pos, coverageBase) {
+function emitFirstMatch(def, ctx, pos, coverageBase, preStmts, armGuardPrefix) {
   const resValV = v(ctx, "_crv");
   const resEndV = v(ctx, "_cre");
   const resOkV = v(ctx, "_crok");
@@ -5022,6 +5152,7 @@ function emitFirstMatch(def, ctx, pos, coverageBase) {
     ...autoRejectedV === void 0 ? [] : [`${ind0}const ${autoRejectedV} = []`],
     `${ind0}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`
   ];
+  if (preStmts) stmts.push(...preStmts);
   for (let i = 0; i < def.parsers.length; i++) {
     const p = def.parsers[i];
     const gate = def.gates[i];
@@ -5029,11 +5160,12 @@ function emitFirstMatch(def, ctx, pos, coverageBase) {
     const atStart = failsAtStart(p);
     const staticFx = armStaticExpected(ctx, p);
     const deferRuleName = ctx.deferFirstSetRefs ? p._ruleName : void 0;
-    const fsGuard = deferRuleName !== void 0 ? `/*@FS:${deferRuleName}:${codeV}@*/true` : needsFirstSetGuard(p) ? firstSetCond(codeV, p._meta.firstSet) : (() => {
+    const baseFsGuard = deferRuleName !== void 0 ? `/*@FS:${deferRuleName}:${codeV}@*/true` : needsFirstSetGuard(p) ? firstSetCond(codeV, p._meta.firstSet) : (() => {
       if (p._meta.firstSet.kind !== "any" || matchesEmpty(p)) return null;
       const deep = firstSetOf(p);
       return deep.kind === "ranges" ? firstSetCond(codeV, deep) : null;
     })();
+    const fsGuard = armGuardPrefix === void 0 ? baseFsGuard : baseFsGuard === null ? armGuardPrefix : `${armGuardPrefix} && (${baseFsGuard})`;
     let gateCond = null;
     if (gate) {
       const gateIdx = ctx.mapFns.length;
@@ -5102,11 +5234,64 @@ function emitFirstMatch(def, ctx, pos, coverageBase) {
   stmts.push(...emitIfFail(ctx, `!${resOkV}`, failArrBody(ctx, concatExpr, pos, false)));
   return { stmts, valueVar: resValV, endVar: resEndV };
 }
+function emitsAsNamedFn(p, ctx) {
+  if (p._def.tag === "lazy") return true;
+  if (ctx.ruleNames?.has(p)) return true;
+  if (ctx.namedParsers.has(p)) return true;
+  const usage = ctx.lazyUsage;
+  return !!usage && !ctx.noHoist && !ctx.capAsTrivia && isHoistableTag(p._def.tag) && (usage.counts.get(p) ?? 0) > 1 && (usage.sizes.get(p) ?? 0) >= HOIST_MIN_SUBTREE;
+}
+function armReplayInScope(arm, ctx) {
+  let p = arm;
+  for (; ; ) {
+    if (emitsAsNamedFn(p, ctx)) return false;
+    const d = p._def;
+    if (d.tag === "node" || d.tag === "grammar" || d.tag === "transform" || d.tag === "label") {
+      p = d.parser;
+      continue;
+    }
+    return d.tag === "sequence";
+  }
+}
+function emitSharedPrefix(def, strategy, ctx, pos) {
+  const { prefix, members } = strategy;
+  const savedCapturing = ctx.capturing;
+  ctx.capturing = false;
+  const pfx = emitFallible(prefix, ctx, pos, false);
+  ctx.capturing = savedCapturing;
+  const map = ctx.replayPrefix ??= /* @__PURE__ */ new Map();
+  const keys = [];
+  for (const i of members) {
+    const term0 = leadingTermOfArm(def.parsers[i]);
+    if (term0 === null) continue;
+    map.set(term0, { valVar: pfx.valVar, endVar: pfx.endVar });
+    keys.push(term0);
+  }
+  const r = emitFirstMatch(def, ctx, pos, void 0, pfx.stmts, pfx.okVar);
+  for (const k of keys) map.delete(k);
+  return r;
+}
+function emitReplayPrefixLeaf(ctx, pos, replay) {
+  const vv = v(ctx);
+  return {
+    stmts: [
+      `${ind(ctx)}const ${vv} = ${replay.valVar}`,
+      ...emitLeafCapture(ctx, vv, pos, replay.endVar)
+    ],
+    valueVar: vv,
+    endVar: replay.endVar
+  };
+}
 function emitNonDisjoint(def, strategy, allExpected, ctx, pos, coverageBase) {
   if (strategy.tag === "greedyClassify")
     return emitGreedyClassify(def, strategy.superIndex, ctx, pos, coverageBase);
   if (strategy.tag === "literalsLongestFirst")
     return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos, coverageBase);
+  if (strategy.tag === "sharedPrefix") {
+    if (!_forceNoSharedPrefix && coverageBase === void 0 && !ctx.recovery && strategy.members.every((i) => armReplayInScope(def.parsers[i], ctx)))
+      return emitSharedPrefix(def, strategy, ctx, pos);
+    return emitFirstMatch(def, ctx, pos, coverageBase);
+  }
   return emitFirstMatch(def, ctx, pos, coverageBase);
 }
 function pushMapFn(ctx, fn, src) {
@@ -5186,6 +5371,13 @@ function emitMany(def, ctx, pos) {
       itemPos = npV;
     }
   }
+  if (!ctx.recovery && !ctx.coverage && !failsAtStart(def.parser) && needsFirstSetGuard(def.parser)) {
+    const lcV = v(ctx, "_lc");
+    stmts.push(
+      `${ind(ctx)}const ${lcV} = ${itemPos} < input.length ? (input.codePointAt(${itemPos}) ?? -1) : -1`,
+      `${ind(ctx)}if (!(${firstSetCond(lcV, def.parser._meta.firstSet)})) { ${rollback}break }`
+    );
+  }
   const { stmts: iterStmts, okVar: iterOk, valVar: iterVal, endVar: iterEnd } = emitFallible(def.parser, ctx, itemPos, true);
   stmts.push(...iterStmts);
   if (ctx.recovery) {
@@ -5236,8 +5428,19 @@ function emitAttempt(p, def, ctx, pos) {
   const rollback = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${leaves}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${raw}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${trivia2}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${log}; if (_ctx._fields) _ctx._fields.length = ${fields}; if (_ctx._errors) _ctx._errors.length = ${errors}`;
   const traceId = ctx.coverage?.plan.attempts.get(p);
   const traceRollback = traceId === void 0 ? "" : ` _ctx._grammarTrace?.write({ id: ${JSON.stringify(traceId)}, phase: 'rollback', offset: ${pos} });`;
+  const preGuard = [];
+  if (!ctx.recovery && !ctx.coverage && needsFirstSetGuard(def.parser)) {
+    const gcV = v(ctx, "_agc");
+    const gExp = armStaticExpected(ctx, def.parser);
+    const gFail = ctx.failLabel ? `{ _ctx._fe = ${pos};${ctx.recordFail ? ` _ctx._fx = ${gExp};` : ""} break ${ctx.failLabel} }` : `{ _ctx._fe = ${pos}; ${failReturnArr(gExp, pos)} }`;
+    preGuard.push(
+      `${ind(ctx)}const ${gcV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,
+      `${ind(ctx)}if (!(${firstSetCond(gcV, def.parser._meta.firstSet)})) ${gFail}`
+    );
+  }
   return {
     stmts: [
+      ...preGuard,
       `${ind(ctx)}const ${leaves} = _ctx._cstLeaves?.length ?? 0, ${raw} = _ctx._cstRawChildren?.length ?? 0, ${trivia2} = _ctx._cstTriviaLog?.length ?? 0, ${log} = _ctx._triviaLog?.length ?? 0, ${fields} = _ctx._fields?.length ?? 0, ${errors} = _ctx._errors?.length ?? 0`,
       ...inner.stmts,
       ...emitIfFail(ctx, `!${inner.okVar}`, `{ ${rollback};${traceRollback} _ctx._fe = ${pos}; ${propagateFailBody(ctx)} }`)
@@ -5617,7 +5820,18 @@ ${i}const ${chV} = ${profileRecognizer} ? undefined : [], ${rawV} = ${profileRec
   const saveTrivia = needsTriviaFrame ? `, ${st} = _ctx.captureTrivia, ${stl} = _ctx._cstTriviaLog${smk ? `, ${smk} = _ctx._triviaCaptureMask` : ""}` : "";
   const installTrivia = needsTriviaFrame ? `; _ctx.captureTrivia = ${capTLv ?? "false"}; _ctx._cstTriviaLog = ${innerTl}${smk ? `; _ctx._triviaCaptureMask = ${capTLv} && _ctx.build !== undefined && _ctx.build._parsemanTriviaKinds !== undefined ? _ctx.build._parsemanTriviaKinds(${JSON.stringify(def.type)}) : ${smk}` : ""}` : "";
   const restoreTrivia = needsTriviaFrame ? `; _ctx.captureTrivia = ${st}; _ctx._cstTriviaLog = ${stl}${smk ? `; _ctx._triviaCaptureMask = ${smk}` : ""}` : "";
+  const preGuard = [];
+  if (!ctx.recovery && !ctx.coverage && (capturesChildren || structural) && needsFirstSetGuard(def.parser)) {
+    const gcV = v(ctx, "_ngc");
+    const gExp = armStaticExpected(ctx, def.parser);
+    const gFail = ctx.failLabel ? ctx.recordFail ? `{ _ctx._fe = ${pos}; _ctx._fx = ${gExp}; break ${ctx.failLabel} }` : `break ${ctx.failLabel}` : failReturnArr(gExp, pos);
+    preGuard.push(
+      `${i}const ${gcV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,
+      `${i}if (!(${firstSetCond(gcV, def.parser._meta.firstSet)})) ${gFail}`
+    );
+  }
   const stmts = [
+    ...preGuard,
     profHoist,
     allocStmt,
     `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren${saveTrivia}${sf ? `, ${sf} = _ctx._fields` : ""}`,
@@ -5791,6 +6005,8 @@ function emitExpect(def, ctx, pos) {
   return { stmts, valueVar: valVar, endVar };
 }
 function emit(p, ctx, pos) {
+  const replay = ctx.replayPrefix?.get(p);
+  if (replay !== void 0) return emitReplayPrefixLeaf(ctx, pos, replay);
   const dispatch = (emissionPos = pos) => {
     const savedRule = ctx.activeCoverageRuleId;
     const rule = ctx.coverage?.plan.rules.get(p);
@@ -6534,6 +6750,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
     ].join("\n")));
   }
   const firstSets = /* @__PURE__ */ new Map();
+  const firstSetRecipes = /* @__PURE__ */ new Map();
   for (const [key, rule] of ruleMap) {
     let resolved = rule;
     const d = rule._def;
@@ -6545,6 +6762,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
       }
     }
     firstSets.set(key, canMatchEmptyAtStart(resolved) ? { kind: "any" } : resolved._meta.firstSet);
+    firstSetRecipes.set(key, canMatchEmptyAtStart(resolved) ? { concrete: any(), refs: [] } : leadingFirstSetRecipe(resolved));
   }
   return {
     ns,
@@ -6553,6 +6771,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
     ruleFns,
     wrappers,
     firstSets,
+    firstSetRecipes,
     deps: ruleDependencies(ruleMap),
     needsEmptyTl: !!ctx.needsEmptyTl,
     needsHostReads: !!ctx.needsHostReads,
@@ -7188,10 +7407,30 @@ function fusedBody(pieces) {
   ];
   const wrapperEntries = [...winner].map(([k, p]) => `${JSON.stringify(k)}: ${p.wrappers.get(k)}`);
   const rawBody = [...lines, "return {", wrapperEntries.join(",\n"), "}"].join("\n");
-  const finalFS = /* @__PURE__ */ new Map();
+  const ANY2 = { kind: "any" };
+  const recipes = /* @__PURE__ */ new Map();
+  const shallow = /* @__PURE__ */ new Map();
   for (const [k, p] of winner) {
+    const r = p.firstSetRecipes?.get(k);
+    if (r) recipes.set(k, r);
     const fs = p.firstSets?.get(k);
-    if (fs) finalFS.set(k, fs);
+    if (fs) shallow.set(k, fs);
+  }
+  const finalFS = /* @__PURE__ */ new Map();
+  for (const [k] of winner) finalFS.set(k, recipes.get(k)?.concrete ?? shallow.get(k) ?? ANY2);
+  for (let iter = 0; iter <= recipes.size; iter++) {
+    let changed = false;
+    for (const [k, r] of recipes) {
+      let fs = r.concrete;
+      for (const ref2 of r.refs) {
+        fs = union(fs, recipes.has(ref2) || shallow.has(ref2) ? finalFS.get(ref2) ?? ANY2 : ANY2);
+      }
+      if (JSON.stringify(finalFS.get(k)) !== JSON.stringify(fs)) {
+        finalFS.set(k, fs);
+        changed = true;
+      }
+    }
+    if (!changed) break;
   }
   const body = rawBody.replace(
     // Rule name + code-point var are both JS identifiers (rule names are validated