Function boxCompiledRule

src/compute-engine/fungrim/loader.ts:341–426

(
  ce: IComputeEngine,
  rule: CompiledFungrimRule,
  onGuardUndecided: FungrimGuardUndecidedHandler | undefined
)

    if (k !== '_x' && k !== 'x' && v.has('_x')) return false;
  return true;
}

function boxCompiledRule(
  ce: IComputeEngine,
  rule: CompiledFungrimRule,
  onGuardUndecided: FungrimGuardUndecidedHandler | undefined
): { rule: BoxedRuleParts } | { error: string } {
  // Box in a child scope where the wildcards carry their guard-implied
  // types: strict validation of typed slots (Fibonacci(_n), Totient(_n), …)
  // passes, and inferred wildcard types never leak into the user's scope.
  const wildcards = collectWildcards(rule.match);
  collectWildcards(rule.replace, wildcards);
  for (const g of rule.guards) collectWildcards(guardJson(g), wildcards);
  const types = wildcardTypes(rule);

  ce.pushScope();
  try {
    for (const wc of wildcards) {
      try {
        ce.declare(wc, types[wc] ?? 'complex');
      } catch {
        /* tolerate */
      }
    }

    // The artifact stores match/replace in canonical-form MathJSON; box
    // CANONICALLY (raw boxing leaves ['Rational',1,2] as a structural
    // function expression and loses literal matches; a bare-string side
    // ('_x') passed unboxed to ce.rules would be parsed as LaTeX).
    const match = ce.expr(rule.match as ExpressionInput);
    if (!match.isValid)
      return { error: `invalid match: ${match.toString()}`.slice(0, 160) };
    const replace = ce.expr(rule.replace as ExpressionInput);
    if (!replace.isValid)
      return { error: `invalid replace: ${replace.toString()}`.slice(0, 160) };

    const closures = buildGuardClosures(ce, rule.guards);

    let condition: ((sub: BoxedSubstitution) => boolean) | undefined;
    if (closures.length > 0) {
      const id = rule.id;
      condition = (sub: BoxedSubstitution): boolean => {
        for (const f of closures) {
          const r = f(sub);
          if (r === true) continue;
          // Fail-closed: an undecided predicate blocks firing, but is
          // surfaced through the debug hook (§2.8).
          if (r === undefined) onGuardUndecided?.(id, sub);
          return false;
        }
        return true;
      };
    }

    // Solve-root templates (`target: 'solve'`) always carry the no-capture
    // filter (AND-combined with any guard closures) and run with variations
    // so the `__b` offset can be empty (`g(x) = 0`). The guard closures are
    // typically empty for these (domain guards dropped; see