Function wrapHotHeadRule

src/compute-engine/fungrim/loader.ts:601–655

* For a simplify-target rule whose canonical match head is in a hot bucket, * return a pre-screened functional rule with an `operators` dispatch hint; * for all other rules return the plain pattern rule unchanged. * * The functional body reproduces `applyRule()`'s pattern-rule sequence for * th

(parts: BoxedRuleParts)

 * builds, so the `onGuardUndecided` hook payload is unchanged) → `subs()`.
 * Returning a `RuleStep` keeps the rule's own `id` in `because` and its
 * `purpose` on the step.
 */
function wrapHotHeadRule(parts: BoxedRuleParts): Rule {
  const { match, replace, condition, id, purpose } = parts;

  const head = (match as { ops?: ReadonlyArray<Expression> }).ops
    ? match.operator
    : undefined;
  if (
    head === undefined ||
    head.startsWith('_') ||
    !HOT_DISPATCH_HEADS.has(head)
  )
    return parts as Rule;

  const required = rankRequiredFeatures(requiredFeatures(match), head);

  const replaceFn = (expr: Expression): RuleStep | undefined => {
    // 1. Cheap conservative pre-screen
    const features = featuresOf(expr);
    for (let i = 0; i < required.length; i++)
      if (!features.has(required[i])) return undefined;

    // 2. Full pattern match (same options applyRule uses on this channel)
    const sub = expr.match(match, {
      useVariations: false,
      recursive: false,
      matchPermutations: true,
    });
    if (sub === null) return undefined;

    // 3. Guard conditions (same substitution shape applyRule builds:
    //    wildcard keys plus their de-prefixed aliases)
    if (condition !== undefined) {
      const conditionSub = {
        ...Object.fromEntries(
          Object.entries(sub).map(([k, v]) => [k.slice(1), v])
        ),
        ...sub,
      };
      try {
        if (!condition(conditionSub)) return undefined;
      } catch {
        return undefined;
      }
    }

    // 4. Replacement (canonical, as on the engine's simplification channels)
    return {
      value: replace.subs(sub, { canonical: true }),
      because: id,
      purpose,
    };
  };

  return { replace: replaceFn, operators: [head], id, purpose };
}