Function buildGuardClosures

src/compute-engine/fungrim/loader.ts:131–302

* Box guard sub-expressions once per rule at load time (wildcards as typed * symbols, declared by the caller's scope); `.subs()`-instantiated per match.

(
  ce: IComputeEngine,
  guards: ReadonlyArray<GuardSpec>
)

 * symbols, declared by the caller's scope); `.subs()`-instantiated per match.
 */
function buildGuardClosures(
  ce: IComputeEngine,
  guards: ReadonlyArray<GuardSpec>
): GuardClosure[] {
  const boxGuardExpr = (x: FungrimMathJson): Expression => {
    try {
      const b = ce.expr(x as ExpressionInput);
      if (b.isValid) return b;
    } catch {
      /* fall through to raw boxing */
    }
    return ce.expr(x as ExpressionInput, { form: 'raw' });
  };

  return guards.map((g): GuardClosure => {
    switch (g.k) {
      case 'type': {
        if (g.t === 'complex') {
          // Fungrim CC = FINITE complex numbers. Literal fast path via the
          // type lattice; symbols go through the boxed Element evaluation,
          // which mirrors `ComplexNumbers.contains` and consults the Track-3
          // type refinements made by `assume(Element(z, ComplexNumbers))`.
          const pred = boxGuardExpr(['Element', g.wc, 'ComplexNumbers']);
          return (sub) => {
            const v = sub[g.wc];
            if (v === undefined) return false;
            // Fungrim CC = FINITE complex numbers. Under D10 (2026-07-02)
            // `real ⊂ complex`, so a symbol declared complex — or
            // real/rational/integer (or a finite_ variant, all subtypes of
            // `real ⊂ complex`) — satisfies a complex guard through the normal
            // subtype path (`type.matches('complex')`). Fungrim's CC is finite,
            // so exclude a PROVABLY-infinite value (a ±∞ literal has
            // isFinite === false; a plain real/complex symbol's is undefined
            // and is accepted). This replaces the pre-D10 shim that had to
            // special-case `type.matches('real')` because `real ⊄ complex`.
            if (v.isFinite !== false && v.type.matches('complex')) return true;
            try {
              const r = pred.subs(sub).evaluate().json;
              if (r === 'True') return true;
              if (r === 'False') return false;
              return undefined; // symbolic residue: undecided
            } catch {
              return undefined;
            }
          };
        }
        return (sub) => {
          const v = sub[g.wc];
          if (v === undefined) return false;
          // Fungrim's declared domains (ZZ/QQ/RR) are FINITE, matching the
          // 'complex' guard's finiteness gate above (SYM P3-7). A value
          // PROVABLY non-finite (a ±∞ or ~∞ literal has `isFinite === false`;
          // note `(+∞).isReal === true`, so without this gate a real guard
          // would fail-open at infinity) is blocked. Unknown finiteness
          // (`isFinite === undefined`, e.g. a plain declared-real symbol)
          // still passes — `!== false` — so ordinary symbols discharge as
          // before; only a known-infinite instance is rejected.
          if (v.isFinite === false) return false;