Function runLoopNested

src/compute-engine/library/control-structures.ts:388–455

* Recursive nested iteration over Element clauses, producing a flat list of * body evaluations. Stops early on Break/Return by mutating `state.stopped`.

(
  body: Expression,
  elements: ReadonlyArray<Expression>,
  index: number,
  ce: ComputeEngine,
  results: Expression[],
  state: {
    stopped: boolean;
    broke: boolean;
    value?: Expression;
    count: number;
  }
)

          // order — since 2026-08-15 `And` is a short-circuit form and no
          // longer sorts; see `canonicalShortCircuit` in `logic.ts`).
          // Building with `_fn` skipped canonicalization altogether, which
          // at the time (when `And` still sorted) left the conjunction in
          // authored order while `.json` (which goes through `structural`)
          // sorted — so `x{a}{b}` and `x{b}{a}` serialized to identical
          // MathJSON while `isSame`/`hash` disagreed, and `ce.box(e.json)`
          // was not `isSame` to `e` (Tycho item-153 seed, the 11
          // `differs-json-equal` rows). Every view of the tree must come
          // from the same canonical construction.
          return ce._fn('When', [
            inner,
            ce.function('And', [innerCond, cond.canonical]),
          ]);
        }
        return ce._fn('When', [expr.canonical, cond.canonical]);
      },
      evaluate: ([expr, cond], options) => {
        const ce = options.engine;
        const c = cond.evaluate();

        // Desmos-style broadcast: a finite indexed collection of booleans
        // masks element-by-element (one masked branch per element). This
        // mirrors the boolean-mask branch of `At` in `collections.ts`. Lazy
        // operators bypass the generic broadcast machinery, so handle it here.
        if (c.isCollection && c.isFiniteCollection) {
          const conds = Array.from(c.each()) as Expression[];
          // A cell is a boolean condition when it types `boolean` — or
          // `broadcastable<boolean>`, the type of a comparison whose broadcast
          // outcome is not statically settled (`h(x) ≤ 1` with `h`
          // undeclared; see `comparisonResultType`,
          // `library/relational-operator.ts`). Such a cell is a scalar
          // relation here (it is one element of the materialized mask) and
          // is held exactly like an undecided `boolean` one; gating on
          // `boolean` alone left `x{h(x) ≤ [1,2,3]}` un-broadcast as
          // `When(x, [h(x) ≤ 1, …])`.
          if (
            conds.length > 0 &&
            conds.every(
              (ci) =>
                ci.type.matches('boolean') || possiblyElementwiseCondition([ci])
            )
          ) {
            // If `expr` itself evaluates to a finite indexed collection, zip
            // elementwise (expr_i masked by c_i); otherwise mask the scalar
            // `expr` by each c_i. Different lengths truncate to the shorter,
            // matching `At`'s mask alignment.
            const ev = expr.evaluate(options);
            const zip = ev.isCollection && ev.isFiniteCollection;
            const elems = zip ? (Array.from(ev.each()) as Expression[]) : [];
            const n = zip ? Math.min(conds.length, elems.length) : conds.length;
            const result: Expression[] = [];
            for (let i = 0; i < n; i++) {
              const ci = conds[i];
              const cis = sym(ci);
              // The per-element expression: the zipped element, or the scalar.
              const elem = zip ? elems[i] : ev;
              if (cis === 'True') result.push(elem);
              else if (cis === 'False') result.push(ce.symbol('Undefined'));
              // Indeterminate (symbolic boolean): hold `When` on the element.