numbl 0.4.18 → 0.4.21

package/dist-cli/cli.js

@@ -940,6 +940,9 @@ var RuntimeSparseMatrix = class extends Refcounted {
   jc;
   pr;
   pi;
+  /** Lazily computed by triangularInfo(); valid because sparse matrices are
+   *  never mutated in place (indexed assignment builds a new matrix). */
+  _triInfo = void 0;
   constructor(m, n, ir, jc, pr, pi2) {
     super();
     this.m = m;
@@ -975,7 +978,7 @@ var RuntimeDictionary = class extends Refcounted {
 };
 
 // src/numbl-core/native/lapack-bridge.ts
-var NATIVE_ADDON_EXPECTED_VERSION = 8;
+var NATIVE_ADDON_EXPECTED_VERSION = 9;
 var _bridge = null;
 function setLapackBridge(bridge) {
   _bridge = bridge;
@@ -3844,6 +3847,21 @@ function mMulSparse(a, b) {
     const m = a.m;
     const hasImag = isComplexSparse(a) || b.imag !== void 0;
     const result = allocFloat64Array(m * bCols);
+    if (!hasImag) {
+      const ir = a.ir, jc = a.jc, pr = a.pr, bd = b.data;
+      for (let col = 0; col < bCols; col++) {
+        const boff = col * bRows;
+        const roff = col * m;
+        for (let k = 0; k < a.n; k++) {
+          const bk = bd[boff + k];
+          if (bk === 0) continue;
+          const end = jc[k + 1];
+          for (let ka = jc[k]; ka < end; ka++)
+            result[roff + ir[ka]] += pr[ka] * bk;
+        }
+      }
+      return RTV.tensor(result, [m, bCols]);
+    }
     const resultImag = hasImag ? allocFloat64Array(m * bCols) : void 0;
     for (let col = 0; col < bCols; col++) {
       for (let k = 0; k < a.n; k++) {
@@ -4087,6 +4105,8 @@ var PIVOT_T = 1;
 var PIVOT_B = 2;
 var DIRECT_F = 0;
 var DIRECT_B = 1;
+var SORT_INC = 0;
+var SORT_DEC = 1;
 var VECT_Q = 0;
 var VECT_P = 1;
 
@@ -20693,6 +20713,1357 @@ function eigComplexTs(dataRe, dataIm, n, computeVL, computeVR) {
   return result;
 }
 
+// src/ts-lapack/src/SRC/dlanst.ts
+var NORM_MAX5 = 0;
+var NORM_ONE2 = 1;
+var NORM_INF2 = 2;
+var NORM_FRO2 = 3;
+function dlanst(norm2, n, d, dOff, e, eOff) {
+  let anorm = 0;
+  if (n <= 0) {
+    anorm = 0;
+  } else if (norm2 === NORM_MAX5) {
+    anorm = Math.abs(d[dOff + (n - 1)]);
+    for (let i = 1; i <= n - 1; i++) {
+      let sum2 = Math.abs(d[dOff + (i - 1)]);
+      if (anorm < sum2 || Number.isNaN(sum2)) anorm = sum2;
+      sum2 = Math.abs(e[eOff + (i - 1)]);
+      if (anorm < sum2 || Number.isNaN(sum2)) anorm = sum2;
+    }
+  } else if (norm2 === NORM_ONE2 || norm2 === NORM_INF2) {
+    if (n === 1) {
+      anorm = Math.abs(d[dOff]);
+    } else {
+      anorm = Math.abs(d[dOff]) + Math.abs(e[eOff]);
+      let sum2 = Math.abs(e[eOff + (n - 2)]) + Math.abs(d[dOff + (n - 1)]);
+      if (anorm < sum2 || Number.isNaN(sum2)) anorm = sum2;
+      for (let i = 2; i <= n - 1; i++) {
+        sum2 = Math.abs(d[dOff + (i - 1)]) + Math.abs(e[eOff + (i - 1)]) + Math.abs(e[eOff + (i - 2)]);
+        if (anorm < sum2 || Number.isNaN(sum2)) anorm = sum2;
+      }
+    }
+  } else if (norm2 === NORM_FRO2) {
+    const scale = { val: 0 };
+    const sum2 = { val: 1 };
+    if (n > 1) {
+      dlassq(n - 1, e, eOff, 1, scale, sum2);
+      sum2.val = 2 * sum2.val;
+    }
+    dlassq(n, d, dOff, 1, scale, sum2);
+    anorm = scale.val * Math.sqrt(sum2.val);
+  }
+  return anorm;
+}
+
+// src/ts-lapack/src/SRC/dlae2.ts
+function dlae2(a, b, c) {
+  const ONE10 = 1;
+  const TWO = 2;
+  const HALF = 0.5;
+  const sm = a + c;
+  const df = a - c;
+  const adf = Math.abs(df);
+  const tb = b + b;
+  const ab = Math.abs(tb);
+  let acmx, acmn;
+  if (Math.abs(a) > Math.abs(c)) {
+    acmx = a;
+    acmn = c;
+  } else {
+    acmx = c;
+    acmn = a;
+  }
+  let rt;
+  if (adf > ab) {
+    rt = adf * Math.sqrt(ONE10 + (ab / adf) ** 2);
+  } else if (adf < ab) {
+    rt = ab * Math.sqrt(ONE10 + (adf / ab) ** 2);
+  } else {
+    rt = ab * Math.sqrt(TWO);
+  }
+  let rt1, rt2;
+  if (sm < 0) {
+    rt1 = HALF * (sm - rt);
+    rt2 = acmx / rt1 * acmn - b / rt1 * b;
+  } else if (sm > 0) {
+    rt1 = HALF * (sm + rt);
+    rt2 = acmx / rt1 * acmn - b / rt1 * b;
+  } else {
+    rt1 = HALF * rt;
+    rt2 = -HALF * rt;
+  }
+  return { rt1, rt2 };
+}
+
+// src/ts-lapack/src/SRC/dlaev2.ts
+function dlaev2(a, b, c) {
+  const ONE10 = 1;
+  const TWO = 2;
+  const HALF = 0.5;
+  const sm = a + c;
+  const df = a - c;
+  const adf = Math.abs(df);
+  const tb = b + b;
+  const ab = Math.abs(tb);
+  let acmx, acmn;
+  if (Math.abs(a) > Math.abs(c)) {
+    acmx = a;
+    acmn = c;
+  } else {
+    acmx = c;
+    acmn = a;
+  }
+  let rt;
+  if (adf > ab) {
+    rt = adf * Math.sqrt(ONE10 + (ab / adf) ** 2);
+  } else if (adf < ab) {
+    rt = ab * Math.sqrt(ONE10 + (adf / ab) ** 2);
+  } else {
+    rt = ab * Math.sqrt(TWO);
+  }
+  let rt1, rt2, sgn1;
+  if (sm < 0) {
+    rt1 = HALF * (sm - rt);
+    sgn1 = -1;
+    rt2 = acmx / rt1 * acmn - b / rt1 * b;
+  } else if (sm > 0) {
+    rt1 = HALF * (sm + rt);
+    sgn1 = 1;
+    rt2 = acmx / rt1 * acmn - b / rt1 * b;
+  } else {
+    rt1 = HALF * rt;
+    rt2 = -HALF * rt;
+    sgn1 = 1;
+  }
+  let cs, sgn2;
+  if (df >= 0) {
+    cs = df + rt;
+    sgn2 = 1;
+  } else {
+    cs = df - rt;
+    sgn2 = -1;
+  }
+  let cs1, sn1;
+  const acs = Math.abs(cs);
+  if (acs > ab) {
+    const ct = -tb / cs;
+    sn1 = ONE10 / Math.sqrt(ONE10 + ct * ct);
+    cs1 = ct * sn1;
+  } else {
+    if (ab === 0) {
+      cs1 = ONE10;
+      sn1 = 0;
+    } else {
+      const tn = -cs / tb;
+      cs1 = ONE10 / Math.sqrt(ONE10 + tn * tn);
+      sn1 = tn * cs1;
+    }
+  }
+  if (sgn1 === sgn2) {
+    const tn = cs1;
+    cs1 = -sn1;
+    sn1 = tn;
+  }
+  return { rt1, rt2, cs1, sn1 };
+}
+
+// src/ts-lapack/src/SRC/dlasrt.ts
+function dlasrt(id, n, d, dOff) {
+  const SELECT = 20;
+  let info = 0;
+  let dir = -1;
+  if (id === SORT_DEC) {
+    dir = 0;
+  } else if (id === SORT_INC) {
+    dir = 1;
+  }
+  if (dir === -1) {
+    info = -1;
+  } else if (n < 0) {
+    info = -2;
+  }
+  if (info !== 0) {
+    return info;
+  }
+  if (n <= 1) {
+    return 0;
+  }
+  const stack1 = new Int32Array(33);
+  const stack2 = new Int32Array(33);
+  let stkpnt = 1;
+  stack1[1] = 1;
+  stack2[1] = n;
+  while (stkpnt > 0) {
+    const start = stack1[stkpnt];
+    const endd = stack2[stkpnt];
+    stkpnt--;
+    if (endd - start <= SELECT && endd - start > 0) {
+      if (dir === 0) {
+        for (let i = start + 1; i <= endd; i++) {
+          for (let j = i; j >= start + 1; j--) {
+            if (d[dOff + (j - 1)] > d[dOff + (j - 2)]) {
+              const dmnmx = d[dOff + (j - 1)];
+              d[dOff + (j - 1)] = d[dOff + (j - 2)];
+              d[dOff + (j - 2)] = dmnmx;
+            } else {
+              break;
+            }
+          }
+        }
+      } else {
+        for (let i = start + 1; i <= endd; i++) {
+          for (let j = i; j >= start + 1; j--) {
+            if (d[dOff + (j - 1)] < d[dOff + (j - 2)]) {
+              const dmnmx = d[dOff + (j - 1)];
+              d[dOff + (j - 1)] = d[dOff + (j - 2)];
+              d[dOff + (j - 2)] = dmnmx;
+            } else {
+              break;
+            }
+          }
+        }
+      }
+    } else if (endd - start > SELECT) {
+      const d1 = d[dOff + (start - 1)];
+      const d2 = d[dOff + (endd - 1)];
+      const ii = Math.trunc((start + endd) / 2);
+      const d3 = d[dOff + (ii - 1)];
+      let dmnmx;
+      if (d1 < d2) {
+        if (d3 < d1) {
+          dmnmx = d1;
+        } else if (d3 < d2) {
+          dmnmx = d3;
+        } else {
+          dmnmx = d2;
+        }
+      } else {
+        if (d3 < d2) {
+          dmnmx = d2;
+        } else if (d3 < d1) {
+          dmnmx = d3;
+        } else {
+          dmnmx = d1;
+        }
+      }
+      let i;
+      let j;
+      if (dir === 0) {
+        i = start - 1;
+        j = endd + 1;
+        while (true) {
+          do {
+            j--;
+          } while (d[dOff + (j - 1)] < dmnmx);
+          do {
+            i++;
+          } while (d[dOff + (i - 1)] > dmnmx);
+          if (i < j) {
+            const tmp = d[dOff + (i - 1)];
+            d[dOff + (i - 1)] = d[dOff + (j - 1)];
+            d[dOff + (j - 1)] = tmp;
+          } else {
+            break;
+          }
+        }
+        if (j - start > endd - j - 1) {
+          stkpnt++;
+          stack1[stkpnt] = start;
+          stack2[stkpnt] = j;
+          stkpnt++;
+          stack1[stkpnt] = j + 1;
+          stack2[stkpnt] = endd;
+        } else {
+          stkpnt++;
+          stack1[stkpnt] = j + 1;
+          stack2[stkpnt] = endd;
+          stkpnt++;
+          stack1[stkpnt] = start;
+          stack2[stkpnt] = j;
+        }
+      } else {
+        i = start - 1;
+        j = endd + 1;
+        while (true) {
+          do {
+            j--;
+          } while (d[dOff + (j - 1)] > dmnmx);
+          do {
+            i++;
+          } while (d[dOff + (i - 1)] < dmnmx);
+          if (i < j) {
+            const tmp = d[dOff + (i - 1)];
+            d[dOff + (i - 1)] = d[dOff + (j - 1)];
+            d[dOff + (j - 1)] = tmp;
+          } else {
+            break;
+          }
+        }
+        if (j - start > endd - j - 1) {
+          stkpnt++;
+          stack1[stkpnt] = start;
+          stack2[stkpnt] = j;
+          stkpnt++;
+          stack1[stkpnt] = j + 1;
+          stack2[stkpnt] = endd;
+        } else {
+          stkpnt++;
+          stack1[stkpnt] = j + 1;
+          stack2[stkpnt] = endd;
+          stkpnt++;
+          stack1[stkpnt] = start;
+          stack2[stkpnt] = j;
+        }
+      }
+    }
+  }
+  return 0;
+}
+
+// src/ts-lapack/src/SRC/dsteqr.ts
+var COMPZ_N = 0;
+var COMPZ_V = 1;
+var COMPZ_I = 2;
+var NORM_MAX6 = 0;
+var TYPE_G3 = 0;
+var UPLO_FULL2 = -1;
+function fsign6(a, b) {
+  return b >= 0 ? Math.abs(a) : -Math.abs(a);
+}
+function dsteqr(compz, n, d, dOff, e, eOff, z, zOff, ldz, work, workOff) {
+  const ZERO9 = 0;
+  const ONE10 = 1;
+  const TWO = 2;
+  const THREE = 3;
+  const MAXIT = 30;
+  let info = 0;
+  if (compz !== COMPZ_N && compz !== COMPZ_V && compz !== COMPZ_I) {
+    info = -1;
+  } else if (n < 0) {
+    info = -2;
+  } else if (ldz < 1 || compz > 0 && ldz < Math.max(1, n)) {
+    info = -6;
+  }
+  if (info !== 0) {
+    xerbla("DSTEQR", -info);
+    return info;
+  }
+  if (n === 0) return 0;
+  if (n === 1) {
+    if (compz === COMPZ_I) z[zOff] = ONE10;
+    return 0;
+  }
+  const D = (i) => dOff + (i - 1);
+  const E = (i) => eOff + (i - 1);
+  const Zc = (j) => zOff + (j - 1) * ldz;
+  const W = (i) => workOff + (i - 1);
+  const eps2 = dlamch(MACH_EPS);
+  const eps22 = eps2 * eps2;
+  const safmin = dlamch(MACH_SFMIN);
+  const safmax = ONE10 / safmin;
+  const ssfmax = Math.sqrt(safmax) / THREE;
+  const ssfmin = Math.sqrt(safmin) / eps22;
+  if (compz === COMPZ_I) dlaset(UPLO_FULL2, n, n, ZERO9, ONE10, z, zOff, ldz);
+  const nmaxit = n * MAXIT;
+  let jtot = 0;
+  let l1 = 1;
+  const nm1 = n - 1;
+  let ordered = false;
+  outer: for (; ; ) {
+    if (l1 > n) {
+      ordered = true;
+      break outer;
+    }
+    if (l1 > 1) e[E(l1 - 1)] = ZERO9;
+    let m = n;
+    if (l1 <= nm1) {
+      let split = false;
+      for (m = l1; m <= nm1; m++) {
+        const tst = Math.abs(e[E(m)]);
+        if (tst === ZERO9) {
+          split = true;
+          break;
+        }
+        if (tst <= Math.sqrt(Math.abs(d[D(m)])) * Math.sqrt(Math.abs(d[D(m + 1)])) * eps2) {
+          e[E(m)] = ZERO9;
+          split = true;
+          break;
+        }
+      }
+      if (!split) m = n;
+    }
+    let l = l1;
+    const lsv = l;
+    let lend = m;
+    const lendsv = lend;
+    l1 = m + 1;
+    if (lend === l) continue outer;
+    const anorm = dlanst(NORM_MAX6, lend - l + 1, d, D(l), e, E(l));
+    let iscale = 0;
+    if (anorm === ZERO9) continue outer;
+    if (anorm > ssfmax) {
+      iscale = 1;
+      dlascl(TYPE_G3, 0, 0, anorm, ssfmax, lend - l + 1, 1, d, D(l), n);
+      dlascl(TYPE_G3, 0, 0, anorm, ssfmax, lend - l, 1, e, E(l), n);
+    } else if (anorm < ssfmin) {
+      iscale = 2;
+      dlascl(TYPE_G3, 0, 0, anorm, ssfmin, lend - l + 1, 1, d, D(l), n);
+      dlascl(TYPE_G3, 0, 0, anorm, ssfmin, lend - l, 1, e, E(l), n);
+    }
+    if (Math.abs(d[D(lend)]) < Math.abs(d[D(l)])) {
+      lend = lsv;
+      l = lendsv;
+    }
+    if (lend > l) {
+      ql: for (; ; ) {
+        if (l !== lend) {
+          let found = false;
+          for (m = l; m <= lend - 1; m++) {
+            const tst = Math.abs(e[E(m)]) ** 2;
+            if (tst <= eps22 * Math.abs(d[D(m)]) * Math.abs(d[D(m + 1)]) + safmin) {
+              found = true;
+              break;
+            }
+          }
+          if (!found) m = lend;
+        } else {
+          m = lend;
+        }
+        if (m < lend) e[E(m)] = ZERO9;
+        let p2 = d[D(l)];
+        if (m === l) {
+          d[D(l)] = p2;
+          l = l + 1;
+          if (l <= lend) continue ql;
+          break ql;
+        }
+        if (m === l + 1) {
+          if (compz > 0) {
+            const r2 = dlaev2(d[D(l)], e[E(l)], d[D(l + 1)]);
+            work[W(l)] = r2.cs1;
+            work[W(n - 1 + l)] = r2.sn1;
+            dlasr(
+              RIGHT,
+              PIVOT_V,
+              DIRECT_B,
+              n,
+              2,
+              work,
+              W(l),
+              work,
+              W(n - 1 + l),
+              z,
+              Zc(l),
+              ldz
+            );
+            d[D(l)] = r2.rt1;
+            d[D(l + 1)] = r2.rt2;
+          } else {
+            const r2 = dlae2(d[D(l)], e[E(l)], d[D(l + 1)]);
+            d[D(l)] = r2.rt1;
+            d[D(l + 1)] = r2.rt2;
+          }
+          e[E(l)] = ZERO9;
+          l = l + 2;
+          if (l <= lend) continue ql;
+          break ql;
+        }
+        if (jtot === nmaxit) break ql;
+        jtot = jtot + 1;
+        let g = (d[D(l + 1)] - p2) / (TWO * e[E(l)]);
+        let r = dlapy2(g, ONE10);
+        g = d[D(m)] - p2 + e[E(l)] / (g + fsign6(r, g));
+        let s = ONE10;
+        let c = ONE10;
+        p2 = ZERO9;
+        for (let i = m - 1; i >= l; i--) {
+          const f = s * e[E(i)];
+          const b = c * e[E(i)];
+          const rot = dlartg(g, f);
+          c = rot.cs;
+          s = rot.sn;
+          r = rot.r;
+          if (i !== m - 1) e[E(i + 1)] = r;
+          g = d[D(i + 1)] - p2;
+          r = (d[D(i)] - g) * s + TWO * c * b;
+          p2 = s * r;
+          d[D(i + 1)] = g + p2;
+          g = c * r - b;
+          if (compz > 0) {
+            work[W(i)] = c;
+            work[W(n - 1 + i)] = -s;
+          }
+        }
+        if (compz > 0) {
+          const mm = m - l + 1;
+          dlasr(
+            RIGHT,
+            PIVOT_V,
+            DIRECT_B,
+            n,
+            mm,
+            work,
+            W(l),
+            work,
+            W(n - 1 + l),
+            z,
+            Zc(l),
+            ldz
+          );
+        }
+        d[D(l)] = d[D(l)] - p2;
+        e[E(l)] = g;
+        continue ql;
+      }
+    } else {
+      qr: for (; ; ) {
+        if (l !== lend) {
+          let found = false;
+          for (m = l; m >= lend + 1; m--) {
+            const tst = Math.abs(e[E(m - 1)]) ** 2;
+            if (tst <= eps22 * Math.abs(d[D(m)]) * Math.abs(d[D(m - 1)]) + safmin) {
+              found = true;
+              break;
+            }
+          }
+          if (!found) m = lend;
+        } else {
+          m = lend;
+        }
+        if (m > lend) e[E(m - 1)] = ZERO9;
+        let p2 = d[D(l)];
+        if (m === l) {
+          d[D(l)] = p2;
+          l = l - 1;
+          if (l >= lend) continue qr;
+          break qr;
+        }
+        if (m === l - 1) {
+          if (compz > 0) {
+            const r2 = dlaev2(d[D(l - 1)], e[E(l - 1)], d[D(l)]);
+            work[W(m)] = r2.cs1;
+            work[W(n - 1 + m)] = r2.sn1;
+            dlasr(
+              RIGHT,
+              PIVOT_V,
+              DIRECT_F,
+              n,
+              2,
+              work,
+              W(m),
+              work,
+              W(n - 1 + m),
+              z,
+              Zc(l - 1),
+              ldz
+            );
+            d[D(l - 1)] = r2.rt1;
+            d[D(l)] = r2.rt2;
+          } else {
+            const r2 = dlae2(d[D(l - 1)], e[E(l - 1)], d[D(l)]);
+            d[D(l - 1)] = r2.rt1;
+            d[D(l)] = r2.rt2;
+          }
+          e[E(l - 1)] = ZERO9;
+          l = l - 2;
+          if (l >= lend) continue qr;
+          break qr;
+        }
+        if (jtot === nmaxit) break qr;
+        jtot = jtot + 1;
+        let g = (d[D(l - 1)] - p2) / (TWO * e[E(l - 1)]);
+        let r = dlapy2(g, ONE10);
+        g = d[D(m)] - p2 + e[E(l - 1)] / (g + fsign6(r, g));
+        let s = ONE10;
+        let c = ONE10;
+        p2 = ZERO9;
+        for (let i = m; i <= l - 1; i++) {
+          const f = s * e[E(i)];
+          const b = c * e[E(i)];
+          const rot = dlartg(g, f);
+          c = rot.cs;
+          s = rot.sn;
+          r = rot.r;
+          if (i !== m) e[E(i - 1)] = r;
+          g = d[D(i)] - p2;
+          r = (d[D(i + 1)] - g) * s + TWO * c * b;
+          p2 = s * r;
+          d[D(i)] = g + p2;
+          g = c * r - b;
+          if (compz > 0) {
+            work[W(i)] = c;
+            work[W(n - 1 + i)] = s;
+          }
+        }
+        if (compz > 0) {
+          const mm = l - m + 1;
+          dlasr(
+            RIGHT,
+            PIVOT_V,
+            DIRECT_F,
+            n,
+            mm,
+            work,
+            W(m),
+            work,
+            W(n - 1 + m),
+            z,
+            Zc(m),
+            ldz
+          );
+        }
+        d[D(l)] = d[D(l)] - p2;
+        e[E(l - 1)] = g;
+        continue qr;
+      }
+    }
+    if (iscale === 1) {
+      dlascl(TYPE_G3, 0, 0, ssfmax, anorm, lendsv - lsv + 1, 1, d, D(lsv), n);
+      dlascl(TYPE_G3, 0, 0, ssfmax, anorm, lendsv - lsv, 1, e, E(lsv), n);
+    } else if (iscale === 2) {
+      dlascl(TYPE_G3, 0, 0, ssfmin, anorm, lendsv - lsv + 1, 1, d, D(lsv), n);
+      dlascl(TYPE_G3, 0, 0, ssfmin, anorm, lendsv - lsv, 1, e, E(lsv), n);
+    }
+    if (jtot < nmaxit) continue outer;
+    for (let i = 1; i <= n - 1; i++) {
+      if (e[E(i)] !== ZERO9) info = info + 1;
+    }
+    break outer;
+  }
+  if (!ordered) return info;
+  if (compz === COMPZ_N) {
+    const sortInfo = dlasrt(SORT_INC, n, d, dOff);
+    if (sortInfo !== 0) return sortInfo;
+  } else {
+    for (let ii = 2; ii <= n; ii++) {
+      const i = ii - 1;
+      let k = i;
+      let p2 = d[D(i)];
+      for (let j = ii; j <= n; j++) {
+        if (d[D(j)] < p2) {
+          k = j;
+          p2 = d[D(j)];
+        }
+      }
+      if (k !== i) {
+        d[D(k)] = d[D(i)];
+        d[D(i)] = p2;
+        dswap(n, z, Zc(i), 1, z, Zc(k), 1);
+      }
+    }
+  }
+  return info;
+}
+
+// src/numbl-core/native/ts-lapack-eig-hermitian.ts
+var EPS2 = 2220446049250313e-31;
+var SAFMIN2 = 22250738585072014e-324;
+function dlapy3(x, y, z) {
+  const w = Math.max(Math.abs(x), Math.abs(y), Math.abs(z));
+  if (w === 0 || !Number.isFinite(w))
+    return Math.abs(x) + Math.abs(y) + Math.abs(z);
+  return w * Math.sqrt((x / w) ** 2 + (y / w) ** 2 + (z / w) ** 2);
+}
+function fsign7(mag2, s) {
+  return s >= 0 ? Math.abs(mag2) : -Math.abs(mag2);
+}
+function cdiv2(ar, ai, br, bi) {
+  if (Math.abs(br) >= Math.abs(bi)) {
+    const r2 = bi / br;
+    const t2 = br + bi * r2;
+    return [(ar + ai * r2) / t2, (ai - ar * r2) / t2];
+  }
+  const r = br / bi;
+  const t = br * r + bi;
+  return [(ar * r + ai) / t, (ai * r - ar) / t];
+}
+function dznrm2(n, re, im, off, incx) {
+  let scale = 0;
+  let ssq = 1;
+  for (let i = 0, k = off; i < n; i++, k += incx) {
+    for (const v of [re[k], im[k]]) {
+      if (v !== 0) {
+        const a = Math.abs(v);
+        if (scale < a) {
+          ssq = 1 + ssq * (scale / a) ** 2;
+          scale = a;
+        } else {
+          ssq += (a / scale) ** 2;
+        }
+      }
+    }
+  }
+  return scale * Math.sqrt(ssq);
+}
+function zlarfg2(n, re, im, off, incx) {
+  if (n <= 0) return { tauRe: 0, tauIm: 0 };
+  let xnorm = dznrm2(n - 1, re, im, off + incx, incx);
+  let alphr = re[off];
+  let alphi = im[off];
+  if (xnorm === 0 && alphi === 0) {
+    return { tauRe: 0, tauIm: 0 };
+  }
+  let beta = -fsign7(dlapy3(alphr, alphi, xnorm), alphr);
+  const safmin = SAFMIN2 / EPS2;
+  const rsafmn = 1 / safmin;
+  let knt = 0;
+  if (Math.abs(beta) < safmin) {
+    do {
+      knt++;
+      for (let i = 1, k = off + incx; i < n; i++, k += incx) {
+        re[k] *= rsafmn;
+        im[k] *= rsafmn;
+      }
+      beta *= rsafmn;
+      alphi *= rsafmn;
+      alphr *= rsafmn;
+    } while (Math.abs(beta) < safmin && knt < 20);
+    xnorm = dznrm2(n - 1, re, im, off + incx, incx);
+    beta = -fsign7(dlapy3(alphr, alphi, xnorm), alphr);
+  }
+  const tauRe = (beta - alphr) / beta;
+  const tauIm = -alphi / beta;
+  const [sr, si] = cdiv2(1, 0, alphr - beta, alphi);
+  for (let i = 1, k = off + incx; i < n; i++, k += incx) {
+    const xr = re[k];
+    const xi = im[k];
+    re[k] = xr * sr - xi * si;
+    im[k] = xr * si + xi * sr;
+  }
+  for (let j = 1; j <= knt; j++) beta *= safmin;
+  re[off] = beta;
+  im[off] = 0;
+  return { tauRe, tauIm };
+}
+function zhemvLower(n, alphaRe, alphaIm, aRe, aIm, aOff, lda, xRe, xIm, xOff, yRe, yIm, yOff) {
+  for (let i = 0; i < n; i++) {
+    yRe[yOff + i] = 0;
+    yIm[yOff + i] = 0;
+  }
+  for (let j = 0; j < n; j++) {
+    const xjr = xRe[xOff + j];
+    const xji = xIm[xOff + j];
+    const t1r = alphaRe * xjr - alphaIm * xji;
+    const t1i = alphaRe * xji + alphaIm * xjr;
+    let t2r = 0;
+    let t2i = 0;
+    const col = aOff + j * lda;
+    yRe[yOff + j] += t1r * aRe[col + j];
+    yIm[yOff + j] += t1i * aRe[col + j];
+    for (let i = j + 1; i < n; i++) {
+      const ar = aRe[col + i];
+      const ai = aIm[col + i];
+      yRe[yOff + i] += t1r * ar - t1i * ai;
+      yIm[yOff + i] += t1r * ai + t1i * ar;
+      const xir = xRe[xOff + i];
+      const xii = xIm[xOff + i];
+      t2r += ar * xir + ai * xii;
+      t2i += ar * xii - ai * xir;
+    }
+    yRe[yOff + j] += alphaRe * t2r - alphaIm * t2i;
+    yIm[yOff + j] += alphaRe * t2i + alphaIm * t2r;
+  }
+}
+function zher2LowerMinus(n, xRe, xIm, xOff, yRe, yIm, yOff, aRe, aIm, aOff, lda) {
+  for (let j = 0; j < n; j++) {
+    const xjr = xRe[xOff + j];
+    const xji = xIm[xOff + j];
+    const yjr = yRe[yOff + j];
+    const yji = yIm[yOff + j];
+    const col = aOff + j * lda;
+    if (xjr !== 0 || xji !== 0 || yjr !== 0 || yji !== 0) {
+      const t1r = -yjr;
+      const t1i = yji;
+      const t2r = -xjr;
+      const t2i = xji;
+      aRe[col + j] = aRe[col + j] + (xjr * t1r - xji * t1i) + (yjr * t2r - yji * t2i);
+      aIm[col + j] = 0;
+      for (let i = j + 1; i < n; i++) {
+        const xir = xRe[xOff + i];
+        const xii = xIm[xOff + i];
+        const yir = yRe[yOff + i];
+        const yii = yIm[yOff + i];
+        aRe[col + i] += xir * t1r - xii * t1i + (yir * t2r - yii * t2i);
+        aIm[col + i] += xir * t1i + xii * t1r + (yir * t2i + yii * t2r);
+      }
+    } else {
+      aIm[col + j] = 0;
+    }
+  }
+}
+function zhetd2Lower(n, aRe, aIm, lda, d, e, tauRe, tauIm) {
+  const wRe = allocFloat64Array(Math.max(1, n));
+  const wIm = allocFloat64Array(Math.max(1, n));
+  for (let i = 1; i <= n - 1; i++) {
+    const off = i + (i - 1) * lda;
+    const t = zlarfg2(n - i, aRe, aIm, off, 1);
+    e[i - 1] = aRe[off];
+    const taur = t.tauRe;
+    const taui = t.tauIm;
+    if (taur !== 0 || taui !== 0) {
+      aRe[off] = 1;
+      aIm[off] = 0;
+      const m = n - i;
+      const a11 = i + i * lda;
+      zhemvLower(m, taur, taui, aRe, aIm, a11, lda, aRe, aIm, off, wRe, wIm, 0);
+      let dr = 0;
+      let di = 0;
+      for (let k = 0; k < m; k++) {
+        const vr = aRe[off + k];
+        const vi = aIm[off + k];
+        dr += wRe[k] * vr + wIm[k] * vi;
+        di += wRe[k] * vi - wIm[k] * vr;
+      }
+      const ar = -0.5 * (taur * dr - taui * di);
+      const ai = -0.5 * (taur * di + taui * dr);
+      for (let k = 0; k < m; k++) {
+        const vr = aRe[off + k];
+        const vi = aIm[off + k];
+        wRe[k] += ar * vr - ai * vi;
+        wIm[k] += ar * vi + ai * vr;
+      }
+      zher2LowerMinus(m, aRe, aIm, off, wRe, wIm, 0, aRe, aIm, a11, lda);
+    } else {
+      const a11 = i + i * lda;
+      aIm[a11] = 0;
+    }
+    aRe[off] = e[i - 1];
+    aIm[off] = 0;
+    d[i - 1] = aRe[i - 1 + (i - 1) * lda];
+    tauRe[i - 1] = taur;
+    tauIm[i - 1] = taui;
+  }
+  d[n - 1] = aRe[n - 1 + (n - 1) * lda];
+}
+function zungtrLower(n, aRe, aIm, lda, tauRe, tauIm) {
+  for (let j = n; j >= 2; j--) {
+    aRe[(j - 1) * lda] = 0;
+    aIm[(j - 1) * lda] = 0;
+    for (let i = j + 1; i <= n; i++) {
+      aRe[i - 1 + (j - 1) * lda] = aRe[i - 1 + (j - 2) * lda];
+      aIm[i - 1 + (j - 1) * lda] = aIm[i - 1 + (j - 2) * lda];
+    }
+  }
+  aRe[0] = 1;
+  aIm[0] = 0;
+  for (let i = 2; i <= n; i++) {
+    aRe[i - 1] = 0;
+    aIm[i - 1] = 0;
+  }
+  if (n <= 1) return;
+  const m = n - 1;
+  const base = 1 + lda;
+  const workRe = allocFloat64Array(Math.max(1, m));
+  const workIm = allocFloat64Array(Math.max(1, m));
+  for (let i = m; i >= 1; i--) {
+    const vOff = base + (i - 1) + (i - 1) * lda;
+    const tr = tauRe[i - 1];
+    const ti = tauIm[i - 1];
+    if (i < m) {
+      aRe[vOff] = 1;
+      aIm[vOff] = 0;
+      const rows = m - i + 1;
+      const cols = m - i;
+      const cOff = base + (i - 1) + i * lda;
+      for (let j = 0; j < cols; j++) {
+        let sr = 0;
+        let si = 0;
+        for (let k = 0; k < rows; k++) {
+          const cr = aRe[cOff + k + j * lda];
+          const ci = aIm[cOff + k + j * lda];
+          const vr = aRe[vOff + k];
+          const vi = aIm[vOff + k];
+          sr += cr * vr + ci * vi;
+          si += cr * vi - ci * vr;
+        }
+        workRe[j] = sr;
+        workIm[j] = si;
+      }
+      for (let j = 0; j < cols; j++) {
+        const wr = workRe[j];
+        const wi = -workIm[j];
+        const fr = -(tr * wr - ti * wi);
+        const fi = -(tr * wi + ti * wr);
+        for (let k = 0; k < rows; k++) {
+          const vr = aRe[vOff + k];
+          const vi = aIm[vOff + k];
+          aRe[cOff + k + j * lda] += fr * vr - fi * vi;
+          aIm[cOff + k + j * lda] += fr * vi + fi * vr;
+        }
+      }
+    }
+    if (i < m) {
+      for (let k = 1; k <= m - i; k++) {
+        const vr = aRe[vOff + k];
+        const vi = aIm[vOff + k];
+        aRe[vOff + k] = -(tr * vr - ti * vi);
+        aIm[vOff + k] = -(tr * vi + ti * vr);
+      }
+    }
+    aRe[vOff] = 1 - tr;
+    aIm[vOff] = -ti;
+    for (let k = 1; k <= i - 1; k++) {
+      aRe[base + (k - 1) + (i - 1) * lda] = 0;
+      aIm[base + (k - 1) + (i - 1) * lda] = 0;
+    }
+  }
+}
+function eigHermTs(dataRe, dataIm, n, computeV) {
+  const w = allocFloat64Array(n);
+  if (n === 0)
+    return { w, VRe: allocFloat64Array(0), VIm: allocFloat64Array(0) };
+  if (n === 1) {
+    w[0] = dataRe[0];
+    if (!computeV) return { w };
+    const VRe2 = allocFloat64Array(1);
+    VRe2[0] = 1;
+    return { w, VRe: VRe2, VIm: allocFloat64Array(1) };
+  }
+  const aRe = allocFloat64Array(dataRe);
+  const aIm = allocFloat64Array(dataIm);
+  const e = allocFloat64Array(Math.max(1, n - 1));
+  const tauRe = allocFloat64Array(Math.max(1, n - 1));
+  const tauIm = allocFloat64Array(Math.max(1, n - 1));
+  zhetd2Lower(n, aRe, aIm, n, w, e, tauRe, tauIm);
+  if (!computeV) {
+    const work2 = allocFloat64Array(Math.max(1, 2 * n - 2));
+    const dummy = allocFloat64Array(1);
+    dsteqr(COMPZ_N, n, w, 0, e, 0, dummy, 0, 1, work2, 0);
+    return { w };
+  }
+  zungtrLower(n, aRe, aIm, n, tauRe, tauIm);
+  const S = allocFloat64Array(n * n);
+  const work = allocFloat64Array(Math.max(1, 2 * n - 2));
+  dsteqr(COMPZ_I, n, w, 0, e, 0, S, 0, n, work, 0);
+  const VRe = allocFloat64Array(n * n);
+  const VIm = allocFloat64Array(n * n);
+  for (let j = 0; j < n; j++) {
+    for (let k = 0; k < n; k++) {
+      const s = S[k + j * n];
+      if (s === 0) continue;
+      for (let i = 0; i < n; i++) {
+        VRe[i + j * n] += aRe[i + k * n] * s;
+        VIm[i + j * n] += aIm[i + k * n] * s;
+      }
+    }
+  }
+  return { w, VRe, VIm };
+}
+
+// src/ts-lapack/src/SRC/dlansy.ts
+var NORM_MAX7 = 0;
+var NORM_ONE3 = 1;
+var NORM_INF3 = 2;
+var NORM_FRO3 = 3;
+function dlansy(norm2, uplo, n, a, aOff, lda, work, workOff) {
+  let value = 0;
+  if (n === 0) {
+    value = 0;
+  } else if (norm2 === NORM_MAX7) {
+    value = 0;
+    if (uplo === UPPER) {
+      for (let j = 1; j <= n; j++) {
+        for (let i = 1; i <= j; i++) {
+          const sum2 = Math.abs(a[aOff + (i - 1) + (j - 1) * lda]);
+          if (value < sum2 || Number.isNaN(sum2)) value = sum2;
+        }
+      }
+    } else {
+      for (let j = 1; j <= n; j++) {
+        for (let i = j; i <= n; i++) {
+          const sum2 = Math.abs(a[aOff + (i - 1) + (j - 1) * lda]);
+          if (value < sum2 || Number.isNaN(sum2)) value = sum2;
+        }
+      }
+    }
+  } else if (norm2 === NORM_ONE3 || norm2 === NORM_INF3) {
+    value = 0;
+    if (uplo === UPPER) {
+      for (let j = 1; j <= n; j++) {
+        let sum2 = 0;
+        for (let i = 1; i <= j - 1; i++) {
+          const absa = Math.abs(a[aOff + (i - 1) + (j - 1) * lda]);
+          sum2 += absa;
+          work[workOff + (i - 1)] += absa;
+        }
+        work[workOff + (j - 1)] = sum2 + Math.abs(a[aOff + (j - 1) + (j - 1) * lda]);
+      }
+      for (let i = 1; i <= n; i++) {
+        const sum2 = work[workOff + (i - 1)];
+        if (value < sum2 || Number.isNaN(sum2)) value = sum2;
+      }
+    } else {
+      for (let i = 1; i <= n; i++) work[workOff + (i - 1)] = 0;
+      for (let j = 1; j <= n; j++) {
+        let sum2 = work[workOff + (j - 1)] + Math.abs(a[aOff + (j - 1) + (j - 1) * lda]);
+        for (let i = j + 1; i <= n; i++) {
+          const absa = Math.abs(a[aOff + (i - 1) + (j - 1) * lda]);
+          sum2 += absa;
+          work[workOff + (i - 1)] += absa;
+        }
+        if (value < sum2 || Number.isNaN(sum2)) value = sum2;
+      }
+    }
+  } else if (norm2 === NORM_FRO3) {
+    const scale = { val: 0 };
+    const sum2 = { val: 1 };
+    if (uplo === UPPER) {
+      for (let j = 2; j <= n; j++) {
+        dlassq(j - 1, a, aOff + (j - 1) * lda, 1, scale, sum2);
+      }
+    } else {
+      for (let j = 1; j <= n - 1; j++) {
+        dlassq(n - j, a, aOff + j + (j - 1) * lda, 1, scale, sum2);
+      }
+    }
+    sum2.val = 2 * sum2.val;
+    dlassq(n, a, aOff, lda + 1, scale, sum2);
+    value = scale.val * Math.sqrt(sum2.val);
+  }
+  return value;
+}
+
+// src/ts-lapack/src/BLAS/dsymv.ts
+function dsymv(uplo, n, alpha, a, aOff, lda, x, xOff, incx, beta, y, yOff, incy) {
+  const ZERO9 = 0;
+  const ONE10 = 1;
+  let info = 0;
+  if (uplo !== UPPER && uplo !== LOWER) {
+    info = 1;
+  } else if (n < 0) {
+    info = 2;
+  } else if (lda < Math.max(1, n)) {
+    info = 5;
+  } else if (incx === 0) {
+    info = 7;
+  } else if (incy === 0) {
+    info = 10;
+  }
+  if (info !== 0) {
+    xerbla("DSYMV ", info);
+    return;
+  }
+  if (n === 0 || alpha === ZERO9 && beta === ONE10) return;
+  const kx = incx > 0 ? 0 : -(n - 1) * incx;
+  const ky = incy > 0 ? 0 : -(n - 1) * incy;
+  if (beta !== ONE10) {
+    let iy = ky;
+    if (beta === ZERO9) {
+      for (let i = 0; i < n; i++) {
+        y[yOff + iy] = ZERO9;
+        iy += incy;
+      }
+    } else {
+      for (let i = 0; i < n; i++) {
+        y[yOff + iy] *= beta;
+        iy += incy;
+      }
+    }
+  }
+  if (alpha === ZERO9) return;
+  if (uplo === UPPER) {
+    let jx = kx;
+    let jy = ky;
+    for (let j = 1; j <= n; j++) {
+      const temp1 = alpha * x[xOff + jx];
+      let temp2 = ZERO9;
+      const aCol = aOff + (j - 1) * lda;
+      let ix = kx;
+      let iy = ky;
+      for (let i = 1; i <= j - 1; i++) {
+        const aij = a[aCol + (i - 1)];
+        y[yOff + iy] += temp1 * aij;
+        temp2 += aij * x[xOff + ix];
+        ix += incx;
+        iy += incy;
+      }
+      y[yOff + jy] += temp1 * a[aCol + (j - 1)] + alpha * temp2;
+      jx += incx;
+      jy += incy;
+    }
+  } else {
+    let jx = kx;
+    let jy = ky;
+    for (let j = 1; j <= n; j++) {
+      const temp1 = alpha * x[xOff + jx];
+      let temp2 = ZERO9;
+      const aCol = aOff + (j - 1) * lda;
+      y[yOff + jy] += temp1 * a[aCol + (j - 1)];
+      let ix = jx;
+      let iy = jy;
+      for (let i = j + 1; i <= n; i++) {
+        ix += incx;
+        iy += incy;
+        const aij = a[aCol + (i - 1)];
+        y[yOff + iy] += temp1 * aij;
+        temp2 += aij * x[xOff + ix];
+      }
+      y[yOff + jy] += alpha * temp2;
+      jx += incx;
+      jy += incy;
+    }
+  }
+}
+
+// src/ts-lapack/src/BLAS/dsyr2.ts
+function dsyr2(uplo, n, alpha, x, xOff, incx, y, yOff, incy, a, aOff, lda) {
+  const ZERO9 = 0;
+  let info = 0;
+  if (uplo !== UPPER && uplo !== LOWER) {
+    info = 1;
+  } else if (n < 0) {
+    info = 2;
+  } else if (incx === 0) {
+    info = 5;
+  } else if (incy === 0) {
+    info = 7;
+  } else if (lda < Math.max(1, n)) {
+    info = 9;
+  }
+  if (info !== 0) {
+    xerbla("DSYR2 ", info);
+    return;
+  }
+  if (n === 0 || alpha === ZERO9) return;
+  const kx = incx > 0 ? 0 : -(n - 1) * incx;
+  const ky = incy > 0 ? 0 : -(n - 1) * incy;
+  let jx = kx;
+  let jy = ky;
+  if (uplo === UPPER) {
+    for (let j = 1; j <= n; j++) {
+      const xj = x[xOff + jx];
+      const yj = y[yOff + jy];
+      if (xj !== ZERO9 || yj !== ZERO9) {
+        const temp1 = alpha * yj;
+        const temp2 = alpha * xj;
+        const aCol = aOff + (j - 1) * lda;
+        let ix = kx;
+        let iy = ky;
+        for (let i = 1; i <= j; i++) {
+          a[aCol + (i - 1)] += x[xOff + ix] * temp1 + y[yOff + iy] * temp2;
+          ix += incx;
+          iy += incy;
+        }
+      }
+      jx += incx;
+      jy += incy;
+    }
+  } else {
+    for (let j = 1; j <= n; j++) {
+      const xj = x[xOff + jx];
+      const yj = y[yOff + jy];
+      if (xj !== ZERO9 || yj !== ZERO9) {
+        const temp1 = alpha * yj;
+        const temp2 = alpha * xj;
+        const aCol = aOff + (j - 1) * lda;
+        let ix = jx;
+        let iy = jy;
+        for (let i = j; i <= n; i++) {
+          a[aCol + (i - 1)] += x[xOff + ix] * temp1 + y[yOff + iy] * temp2;
+          ix += incx;
+          iy += incy;
+        }
+      }
+      jx += incx;
+      jy += incy;
+    }
+  }
+}
+
+// src/ts-lapack/src/SRC/dsytd2.ts
+function dsytd2(uplo, n, a, aOff, lda, d, dOff, e, eOff, tau, tauOff) {
+  const ONE10 = 1;
+  const ZERO9 = 0;
+  const HALF = 0.5;
+  let info = 0;
+  const upper = uplo === UPPER;
+  if (!upper && uplo !== LOWER) {
+    info = -1;
+  } else if (n < 0) {
+    info = -2;
+  } else if (lda < Math.max(1, n)) {
+    info = -4;
+  }
+  if (info !== 0) {
+    xerbla("DSYTD2", -info);
+    return info;
+  }
+  if (n <= 0) return 0;
+  const A = (i, j) => aOff + (i - 1) + (j - 1) * lda;
+  if (upper) {
+    for (let i = n - 1; i >= 1; i--) {
+      const r = dlarfg(i, a[A(i, i + 1)], a, A(1, i + 1), 1);
+      a[A(i, i + 1)] = r.alpha;
+      const taui = r.tau;
+      e[eOff + (i - 1)] = a[A(i, i + 1)];
+      if (taui !== ZERO9) {
+        a[A(i, i + 1)] = ONE10;
+        dsymv(
+          uplo,
+          i,
+          taui,
+          a,
+          aOff,
+          lda,
+          a,
+          A(1, i + 1),
+          1,
+          ZERO9,
+          tau,
+          tauOff,
+          1
+        );
+        const alpha = -HALF * taui * ddot(i, tau, tauOff, 1, a, A(1, i + 1), 1);
+        daxpy(i, alpha, a, A(1, i + 1), 1, tau, tauOff, 1);
+        dsyr2(uplo, i, -ONE10, a, A(1, i + 1), 1, tau, tauOff, 1, a, aOff, lda);
+        a[A(i, i + 1)] = e[eOff + (i - 1)];
+      }
+      d[dOff + i] = a[A(i + 1, i + 1)];
+      tau[tauOff + (i - 1)] = taui;
+    }
+    d[dOff] = a[A(1, 1)];
+  } else {
+    for (let i = 1; i <= n - 1; i++) {
+      const r = dlarfg(n - i, a[A(i + 1, i)], a, A(Math.min(i + 2, n), i), 1);
+      a[A(i + 1, i)] = r.alpha;
+      const taui = r.tau;
+      e[eOff + (i - 1)] = a[A(i + 1, i)];
+      if (taui !== ZERO9) {
+        a[A(i + 1, i)] = ONE10;
+        dsymv(
+          uplo,
+          n - i,
+          taui,
+          a,
+          A(i + 1, i + 1),
+          lda,
+          a,
+          A(i + 1, i),
+          1,
+          ZERO9,
+          tau,
+          tauOff + (i - 1),
+          1
+        );
+        const alpha = -HALF * taui * ddot(n - i, tau, tauOff + (i - 1), 1, a, A(i + 1, i), 1);
+        daxpy(n - i, alpha, a, A(i + 1, i), 1, tau, tauOff + (i - 1), 1);
+        dsyr2(
+          uplo,
+          n - i,
+          -ONE10,
+          a,
+          A(i + 1, i),
+          1,
+          tau,
+          tauOff + (i - 1),
+          1,
+          a,
+          A(i + 1, i + 1),
+          lda
+        );
+        a[A(i + 1, i)] = e[eOff + (i - 1)];
+      }
+      d[dOff + (i - 1)] = a[A(i, i)];
+      tau[tauOff + (i - 1)] = taui;
+    }
+    d[dOff + (n - 1)] = a[A(n, n)];
+  }
+  return 0;
+}
+
+// src/ts-lapack/src/SRC/dorgtr.ts
+function dorgtr(uplo, n, a, aOff, lda, tau, tauOff) {
+  const ONE10 = 1;
+  const ZERO9 = 0;
+  let info = 0;
+  if (uplo !== LOWER) {
+    info = -1;
+  } else if (n < 0) {
+    info = -2;
+  } else if (lda < Math.max(1, n)) {
+    info = -4;
+  }
+  if (info !== 0) {
+    xerbla("DORGTR", -info);
+    return info;
+  }
+  if (n === 0) return 0;
+  const A = (i, j) => aOff + (i - 1) + (j - 1) * lda;
+  for (let j = n; j >= 2; j--) {
+    a[A(1, j)] = ZERO9;
+    for (let i = j + 1; i <= n; i++) {
+      a[A(i, j)] = a[A(i, j - 1)];
+    }
+  }
+  a[A(1, 1)] = ONE10;
+  for (let i = 2; i <= n; i++) {
+    a[A(i, 1)] = ZERO9;
+  }
+  if (n > 1) {
+    info = dorgqr(n - 1, n - 1, n - 1, a, A(2, 2), lda, tau, tauOff);
+  }
+  return info;
+}
+
+// src/ts-lapack/src/SRC/dsyev.ts
+var NORM_MAX8 = 0;
+var TYPE_L2 = 1;
+function dsyev(wantz, uplo, n, a, aOff, lda, w, wOff) {
+  const ONE10 = 1;
+  const ZERO9 = 0;
+  let info = 0;
+  if (uplo !== LOWER) {
+    info = -2;
+  } else if (n < 0) {
+    info = -3;
+  } else if (lda < Math.max(1, n)) {
+    info = -5;
+  }
+  if (info !== 0) {
+    xerbla("DSYEV ", -info);
+    return info;
+  }
+  if (n === 0) return 0;
+  if (n === 1) {
+    w[wOff] = a[aOff];
+    if (wantz) a[aOff] = ONE10;
+    return 0;
+  }
+  const safmin = dlamch(MACH_SFMIN);
+  const eps2 = dlamch(MACH_PREC);
+  const smlnum = safmin / eps2;
+  const bignum = ONE10 / smlnum;
+  const rmin = Math.sqrt(smlnum);
+  const rmax = Math.sqrt(bignum);
+  const work = allocFloat64Array(Math.max(1, 3 * n));
+  const anrm = dlansy(NORM_MAX8, uplo, n, a, aOff, lda, work, 0);
+  let iscale = 0;
+  let sigma = ONE10;
+  if (anrm > ZERO9 && anrm < rmin) {
+    iscale = 1;
+    sigma = rmin / anrm;
+  } else if (anrm > rmax) {
+    iscale = 1;
+    sigma = rmax / anrm;
+  }
+  if (iscale === 1) dlascl(TYPE_L2, 0, 0, ONE10, sigma, n, n, a, aOff, lda);
+  const e = allocFloat64Array(Math.max(1, n - 1));
+  const tau = allocFloat64Array(Math.max(1, n - 1));
+  dsytd2(uplo, n, a, aOff, lda, w, wOff, e, 0, tau, 0);
+  if (!wantz) {
+    info = dsteqr(COMPZ_N, n, w, wOff, e, 0, a, aOff, lda, work, 0);
+  } else {
+    const iinfo = dorgtr(uplo, n, a, aOff, lda, tau, 0);
+    if (iinfo !== 0) return iinfo;
+    info = dsteqr(COMPZ_V, n, w, wOff, e, 0, a, aOff, lda, work, 0);
+  }
+  if (iscale === 1) {
+    const imax = info === 0 ? n : info - 1;
+    dscal(imax, ONE10 / sigma, w, wOff, 1);
+  }
+  return info;
+}
+
 // src/numbl-core/native/ts-lapack-bridge.ts
 function inv(data, n) {
   const a = allocFloat64Array(data);
@@ -20866,6 +22237,20 @@ function linsolve(A, m, n, B, nrhs) {
     return x;
   }
 }
+function eigSym(data, n, computeV) {
+  const a = allocFloat64Array(data);
+  const w = allocFloat64Array(n);
+  const info = dsyev(computeV, LOWER, n, a, 0, n, w, 0);
+  if (info !== 0) {
+    throw new Error(
+      info < 0 ? "eig: illegal argument passed to dsyev" : "QR algorithm failed to converge in dsyev"
+    );
+  }
+  return computeV ? { w, V: a } : { w };
+}
+function eigHerm(dataRe, dataIm, n, computeV) {
+  return eigHermTs(dataRe, dataIm, n, computeV);
+}
 function eig(data, n, computeVL, computeVR, balance) {
   const a = allocFloat64Array(data);
   const wr = allocFloat64Array(n);
@@ -21604,7 +22989,9 @@ var _bridge2 = {
   linsolve,
   linsolveComplex,
   eig,
+  eigSym,
   eigComplex: eigComplexTs,
+  eigHerm,
   lu,
   svd,
   chol,
@@ -22053,6 +23440,7 @@ function formatClassInstance(v) {
   const lines = [`  ${v.className} with properties:
 `];
   for (const [key, val] of v.fields) {
+    if (key.startsWith("_")) continue;
     lines.push(`    ${key}: ${displayValue(val)}`);
   }
   return lines.join("\n");
@@ -27756,6 +29144,707 @@ function sprintfFormat(fmt, args) {
   return result;
 }
 
+// src/numbl-core/helpers/warn.ts
+var sink = (msg) => console.warn("Warning: " + msg);
+function setWarningSink(fn) {
+  sink = fn;
+}
+function emitWarning(msg) {
+  sink(msg);
+}
+
+// src/numbl-core/helpers/sparse-direct.ts
+var SINGULAR_WARNING = "Matrix is singular to working precision.";
+function denseToSparse(t) {
+  const m = t.shape[0] ?? 1;
+  const n = t.shape.length >= 2 ? t.shape[1] : 1;
+  const irList = [];
+  const prList = [];
+  const piList = t.imag ? [] : void 0;
+  const jc = new Int32Array(n + 1);
+  for (let c = 0; c < n; c++) {
+    jc[c] = irList.length;
+    for (let r = 0; r < m; r++) {
+      const idx = c * m + r;
+      const re = t.data[idx];
+      const im = t.imag ? t.imag[idx] : 0;
+      if (re !== 0 || im !== 0) {
+        irList.push(r);
+        prList.push(re);
+        if (piList) piList.push(im);
+      }
+    }
+  }
+  jc[n] = irList.length;
+  return RTV.sparseMatrix(
+    m,
+    n,
+    new Int32Array(irList),
+    jc,
+    allocFloat64Array(prList),
+    piList ? allocFloat64Array(piList) : void 0
+  );
+}
+function denseDataToSparse(data, m, n) {
+  return denseToSparse(RTV.tensor(data, [m, n]));
+}
+function fromUnsortedColumns(m, n, ir, jc, pr) {
+  return sparseTranspose(sparseTranspose(RTV.sparseMatrix(m, n, ir, jc, pr)));
+}
+function permutationMatrix(p2) {
+  const n = p2.length;
+  const ir = new Int32Array(n);
+  const jc = new Int32Array(n + 1);
+  const pr = allocFloat64Array(n);
+  for (let k = 0; k < n; k++) jc[p2[k] + 1]++;
+  for (let c = 0; c < n; c++) jc[c + 1] += jc[c];
+  for (let k = 0; k < n; k++) {
+    ir[jc[p2[k]]] = k;
+    pr[jc[p2[k]]] = 1;
+  }
+  return RTV.sparseMatrix(n, n, ir, jc, pr);
+}
+function permVectorTensor(p2) {
+  const d = allocFloat64Array(p2.length);
+  for (let i = 0; i < p2.length; i++) d[i] = p2[i] + 1;
+  return RTV.tensor(d, [1, p2.length]);
+}
+function invertPerm(p2) {
+  const inv2 = new Int32Array(p2.length);
+  for (let i = 0; i < p2.length; i++) inv2[p2[i]] = i;
+  return inv2;
+}
+function sparsePermute(A, p2, q) {
+  const pinv = invertPerm(p2);
+  const nnz = A.jc[A.n];
+  const ir = new Int32Array(nnz);
+  const jc = new Int32Array(A.n + 1);
+  const pr = allocFloat64Array(nnz);
+  let pos = 0;
+  for (let k = 0; k < A.n; k++) {
+    jc[k] = pos;
+    const j = q[k];
+    for (let t = A.jc[j]; t < A.jc[j + 1]; t++) {
+      ir[pos] = pinv[A.ir[t]];
+      pr[pos] = A.pr[t];
+      pos++;
+    }
+  }
+  jc[A.n] = pos;
+  return fromUnsortedColumns(A.m, A.n, ir, jc, pr);
+}
+function sparseKron(A, B) {
+  const m = A.m, n = A.n, p2 = B.m, q = B.n;
+  const nnz = A.jc[n] * B.jc[q];
+  const ir = new Int32Array(nnz);
+  const jc = new Int32Array(n * q + 1);
+  const pr = allocFloat64Array(nnz);
+  const cplx = A.pi !== void 0 || B.pi !== void 0;
+  const pi2 = cplx ? allocFloat64Array(nnz) : void 0;
+  let pos = 0;
+  for (let ja = 0; ja < n; ja++) {
+    for (let jb = 0; jb < q; jb++) {
+      jc[ja * q + jb] = pos;
+      for (let ka = A.jc[ja]; ka < A.jc[ja + 1]; ka++) {
+        const rowBase = A.ir[ka] * p2;
+        const aRe = A.pr[ka];
+        const aIm = A.pi ? A.pi[ka] : 0;
+        for (let kb = B.jc[jb]; kb < B.jc[jb + 1]; kb++) {
+          ir[pos] = rowBase + B.ir[kb];
+          const bRe = B.pr[kb];
+          const bIm = B.pi ? B.pi[kb] : 0;
+          pr[pos] = aRe * bRe - aIm * bIm;
+          if (pi2) pi2[pos] = aRe * bIm + aIm * bRe;
+          pos++;
+        }
+      }
+    }
+  }
+  jc[n * q] = pos;
+  return RTV.sparseMatrix(m * p2, n * q, ir, jc, pr, pi2);
+}
+function triangularInfo(S) {
+  if (S._triInfo) return S._triInfo;
+  const n = S.n;
+  const ir = S.ir, jc = S.jc, pr = S.pr, pi2 = S.pi;
+  const diagPos = new Int32Array(n).fill(-1);
+  const diag2 = allocFloat64Array(n);
+  let upper = true;
+  let lower = true;
+  for (let j = 0; j < n; j++) {
+    const end = jc[j + 1];
+    for (let k = jc[j]; k < end; k++) {
+      const i = ir[k];
+      if (i === j) {
+        diagPos[j] = k;
+        diag2[j] = pr[k];
+        continue;
+      }
+      if (pr[k] === 0 && (!pi2 || pi2[k] === 0)) continue;
+      if (i > j) upper = false;
+      else lower = false;
+    }
+  }
+  const info = { upper, lower, diagPos, diag: diag2 };
+  S._triInfo = info;
+  return info;
+}
+function sparseIsUpper(S) {
+  return triangularInfo(S).upper;
+}
+function sparseIsLower(S) {
+  return triangularInfo(S).lower;
+}
+function sparseIsSymmetric(S) {
+  if (S.m !== S.n || S.pi) return false;
+  const T = sparseTranspose(S);
+  const nnz = S.jc[S.n];
+  if (T.jc[T.n] !== nnz) return false;
+  for (let j = 0; j <= S.n; j++) if (S.jc[j] !== T.jc[j]) return false;
+  for (let k = 0; k < nnz; k++)
+    if (S.ir[k] !== T.ir[k] || S.pr[k] !== T.pr[k]) return false;
+  return true;
+}
+function sparseAt(S, i, j) {
+  let lo = S.jc[j], hi = S.jc[j + 1] - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    const r = S.ir[mid];
+    if (r === i) return S.pr[mid];
+    if (r < i) lo = mid + 1;
+    else hi = mid - 1;
+  }
+  return 0;
+}
+function allDiagPositive(S) {
+  for (let j = 0; j < S.n; j++) if (!(sparseAt(S, j, j) > 0)) return false;
+  return true;
+}
+function sparseSolveUpper(R, B, nrhs) {
+  const n = R.n;
+  const { diagPos, diag: diag2 } = triangularInfo(R);
+  const ir = R.ir, jc = R.jc, pr = R.pr;
+  const x = allocFloat64Array(B);
+  let singular = false;
+  for (let j = 0; j < n; j++) if (diag2[j] === 0) singular = true;
+  for (let c = 0; c < nrhs; c++) {
+    const off = c * n;
+    for (let j = n - 1; j >= 0; j--) {
+      const xj = x[off + j] / diag2[j];
+      x[off + j] = xj;
+      if (xj === 0) continue;
+      const dp = diagPos[j];
+      const end = dp >= 0 ? dp : jc[j + 1];
+      for (let k = jc[j]; k < end; k++) x[off + ir[k]] -= pr[k] * xj;
+    }
+  }
+  return { x, singular };
+}
+function sparseSolveLower(L, B, nrhs) {
+  const n = L.n;
+  const { diagPos, diag: diag2 } = triangularInfo(L);
+  const ir = L.ir, jc = L.jc, pr = L.pr;
+  const x = allocFloat64Array(B);
+  let singular = false;
+  for (let j = 0; j < n; j++) if (diag2[j] === 0) singular = true;
+  for (let c = 0; c < nrhs; c++) {
+    const off = c * n;
+    for (let j = 0; j < n; j++) {
+      const xj = x[off + j] / diag2[j];
+      x[off + j] = xj;
+      if (xj === 0) continue;
+      const dp = diagPos[j];
+      const end = jc[j + 1];
+      for (let k = dp >= 0 ? dp + 1 : jc[j]; k < end; k++)
+        x[off + ir[k]] -= pr[k] * xj;
+    }
+  }
+  return { x, singular };
+}
+function permuteRows(X, n, nrhs, p2) {
+  const Y = allocFloat64Array(X.length);
+  for (let c = 0; c < nrhs; c++) {
+    const off = c * n;
+    for (let k = 0; k < n; k++) Y[off + k] = X[off + p2[k]];
+  }
+  return Y;
+}
+function unpermuteRows(X, n, nrhs, p2) {
+  const Y = allocFloat64Array(X.length);
+  for (let c = 0; c < nrhs; c++) {
+    const off = c * n;
+    for (let k = 0; k < n; k++) Y[off + p2[k]] = X[off + k];
+  }
+  return Y;
+}
+function eliminationTree(A) {
+  const n = A.n;
+  const parent = new Int32Array(n).fill(-1);
+  const ancestor = new Int32Array(n).fill(-1);
+  for (let k = 0; k < n; k++) {
+    for (let p2 = A.jc[k]; p2 < A.jc[k + 1]; p2++) {
+      let i = A.ir[p2];
+      while (i !== -1 && i < k) {
+        const inext = ancestor[i];
+        ancestor[i] = k;
+        if (inext === -1) parent[i] = k;
+        i = inext;
+      }
+    }
+  }
+  return parent;
+}
+function etreeReach(A, k, parent, s, mark) {
+  const n = A.n;
+  let top = n;
+  mark[k] = k;
+  for (let p2 = A.jc[k]; p2 < A.jc[k + 1]; p2++) {
+    let i = A.ir[p2];
+    if (i > k) continue;
+    let len = 0;
+    for (; mark[i] !== k; i = parent[i]) {
+      s[len++] = i;
+      mark[i] = k;
+    }
+    while (len > 0) s[--top] = s[--len];
+  }
+  return top;
+}
+function sparseChol(A) {
+  const n = A.n;
+  if (A.m !== n) throw new RuntimeError("chol: Matrix must be square.");
+  const parent = eliminationTree(A);
+  const s = new Int32Array(n);
+  const mark = new Int32Array(n).fill(-1);
+  const colCount = new Int32Array(n);
+  for (let k = 0; k < n; k++) {
+    const top = etreeReach(A, k, parent, s, mark);
+    for (let t = top; t < n; t++) colCount[s[t]]++;
+    colCount[k]++;
+  }
+  const Lp = new Int32Array(n + 1);
+  for (let j = 0; j < n; j++) Lp[j + 1] = Lp[j] + colCount[j];
+  const nnzL = Lp[n];
+  const Li = new Int32Array(nnzL);
+  const Lx = allocFloat64Array(nnzL);
+  const c = new Int32Array(n);
+  for (let j = 0; j < n; j++) c[j] = Lp[j];
+  const x = allocFloat64Array(n);
+  mark.fill(-1);
+  for (let k = 0; k < n; k++) {
+    const top = etreeReach(A, k, parent, s, mark);
+    x[k] = 0;
+    for (let p2 = A.jc[k]; p2 < A.jc[k + 1]; p2++) {
+      if (A.ir[p2] <= k) x[A.ir[p2]] = A.pr[p2];
+    }
+    let d = x[k];
+    x[k] = 0;
+    for (let t = top; t < n; t++) {
+      const i = s[t];
+      const lki = x[i] / Lx[Lp[i]];
+      x[i] = 0;
+      for (let p2 = Lp[i] + 1; p2 < c[i]; p2++) x[Li[p2]] -= Lx[p2] * lki;
+      d -= lki * lki;
+      const pos2 = c[i]++;
+      Li[pos2] = k;
+      Lx[pos2] = lki;
+    }
+    if (!(d > 0)) {
+      for (let i = k + 1; i < n; i++) {
+        const top2 = etreeReach(A, i, parent, s, mark);
+        for (let p2 = A.jc[i]; p2 < A.jc[i + 1]; p2++)
+          if (A.ir[p2] < k) x[A.ir[p2]] = A.pr[p2];
+        for (let t = top2; t < n; t++) {
+          const j = s[t];
+          if (j >= k) {
+            x[j] = 0;
+            continue;
+          }
+          const lij = x[j] / Lx[Lp[j]];
+          x[j] = 0;
+          for (let p2 = Lp[j] + 1; p2 < c[j]; p2++) x[Li[p2]] -= Lx[p2] * lij;
+          const pos2 = c[j]++;
+          Li[pos2] = i;
+          Lx[pos2] = lij;
+        }
+      }
+      return { L: leadingColumns(n, k, Lp, Li, Lx, c), ok: false, p: k + 1 };
+    }
+    const pos = c[k]++;
+    Li[pos] = k;
+    Lx[pos] = Math.sqrt(d);
+  }
+  return { L: RTV.sparseMatrix(n, n, Li, Lp, Lx), ok: true, p: 0 };
+}
+function leadingColumns(n, k, Lp, Li, Lx, c) {
+  let nnz = 0;
+  for (let j = 0; j < k; j++) nnz += c[j] - Lp[j];
+  const ir = new Int32Array(nnz);
+  const pr = allocFloat64Array(nnz);
+  const jc = new Int32Array(k + 1);
+  let pos = 0;
+  for (let j = 0; j < k; j++) {
+    jc[j] = pos;
+    for (let p2 = Lp[j]; p2 < c[j]; p2++) {
+      ir[pos] = Li[p2];
+      pr[pos] = Lx[p2];
+      pos++;
+    }
+  }
+  jc[k] = pos;
+  return RTV.sparseMatrix(n, k, ir, jc, pr);
+}
+function sparseLu(A, q, tol) {
+  const m = A.m, n = A.n;
+  const kmin = Math.min(m, n);
+  const Lp = [0];
+  const Li = [];
+  const Lx = [];
+  const Up = [0];
+  const Ui = [];
+  const Ux = [];
+  const pinv = new Int32Array(m).fill(-1);
+  const x = allocFloat64Array(m);
+  const xi = new Int32Array(m);
+  const stack = new Int32Array(m);
+  const pstack = new Int32Array(m);
+  const mark = new Int32Array(m).fill(-1);
+  let singular = false;
+  for (let k = 0; k < n; k++) {
+    const col = q ? q[k] : k;
+    let top = m;
+    for (let t = A.jc[col]; t < A.jc[col + 1]; t++) {
+      const i0 = A.ir[t];
+      if (mark[i0] === k) continue;
+      let head = 0;
+      stack[0] = i0;
+      mark[i0] = k;
+      pstack[i0] = pinv[i0] >= 0 ? Lp[pinv[i0]] : -1;
+      while (head >= 0) {
+        const j = stack[head];
+        const J = pinv[j];
+        let descended = false;
+        if (J >= 0) {
+          const end = Lp[J + 1];
+          let p3 = pstack[j];
+          for (; p3 < end; p3++) {
+            const i = Li[p3];
+            if (mark[i] !== k) {
+              mark[i] = k;
+              pstack[j] = p3 + 1;
+              stack[++head] = i;
+              pstack[i] = pinv[i] >= 0 ? Lp[pinv[i]] : -1;
+              descended = true;
+              break;
+            }
+          }
+          if (descended) continue;
+        }
+        head--;
+        xi[--top] = j;
+      }
+    }
+    for (let t = A.jc[col]; t < A.jc[col + 1]; t++) x[A.ir[t]] = A.pr[t];
+    for (let t = top; t < m; t++) {
+      const j = xi[t];
+      const J = pinv[j];
+      if (J < 0) continue;
+      const xj = x[j];
+      if (xj === 0) continue;
+      for (let p3 = Lp[J] + 1; p3 < Lp[J + 1]; p3++) x[Li[p3]] -= Lx[p3] * xj;
+    }
+    let ipiv = -1;
+    let amax = -1;
+    for (let t = top; t < m; t++) {
+      const i = xi[t];
+      if (pinv[i] >= 0) {
+        Ui.push(pinv[i]);
+        Ux.push(x[i]);
+      } else {
+        const a = Math.abs(x[i]);
+        if (a > amax) {
+          amax = a;
+          ipiv = i;
+        }
+      }
+    }
+    if (k < kmin) {
+      if (ipiv < 0 || amax === 0) {
+        singular = true;
+        if (ipiv < 0) {
+          for (let i = 0; i < m; i++)
+            if (pinv[i] < 0) {
+              ipiv = i;
+              break;
+            }
+        }
+      } else if (col < m && pinv[col] < 0 && Math.abs(x[col]) >= tol * amax && x[col] !== 0) {
+        ipiv = col;
+      }
+      const pivot = x[ipiv];
+      if (!Number.isFinite(pivot)) singular = true;
+      pinv[ipiv] = k;
+      Ui.push(k);
+      Ux.push(pivot);
+      Li.push(ipiv);
+      Lx.push(1);
+      if (pivot !== 0 && Number.isFinite(pivot)) {
+        for (let t = top; t < m; t++) {
+          const i = xi[t];
+          if (pinv[i] >= 0) continue;
+          const v = x[i] / pivot;
+          if (v !== 0) {
+            Li.push(i);
+            Lx.push(v);
+          }
+        }
+      }
+      Lp.push(Li.length);
+    }
+    Up.push(Ui.length);
+    for (let t = top; t < m; t++) x[xi[t]] = 0;
+  }
+  let next = kmin;
+  for (let i = 0; i < m; i++) if (pinv[i] < 0) pinv[i] = next++;
+  const LiArr = new Int32Array(Li.length);
+  for (let p3 = 0; p3 < Li.length; p3++) LiArr[p3] = pinv[Li[p3]];
+  const L = fromUnsortedColumns(
+    m,
+    kmin,
+    LiArr,
+    new Int32Array(Lp),
+    allocFloat64Array(Lx)
+  );
+  const U = fromUnsortedColumns(
+    kmin,
+    n,
+    new Int32Array(Ui),
+    new Int32Array(Up),
+    allocFloat64Array(Ux)
+  );
+  const p2 = invertPerm(pinv);
+  const qOut = q ? Int32Array.from(q) : identityPerm(n);
+  return { L, U, p: p2, q: qOut, singular };
+}
+function identityPerm(n) {
+  const p2 = new Int32Array(n);
+  for (let i = 0; i < n; i++) p2[i] = i;
+  return p2;
+}
+function symmetricAdjacency(A) {
+  const n = Math.max(A.m, A.n);
+  const adj = new Array(n);
+  for (let i = 0; i < n; i++) adj[i] = /* @__PURE__ */ new Set();
+  for (let j = 0; j < A.n; j++)
+    for (let k = A.jc[j]; k < A.jc[j + 1]; k++) {
+      const i = A.ir[k];
+      if (i === j) continue;
+      adj[i].add(j);
+      adj[j].add(i);
+    }
+  return adj;
+}
+function minimumDegreeOrdering(A) {
+  const adj = symmetricAdjacency(A);
+  const n = adj.length;
+  const perm = new Int32Array(n);
+  if (n === 0) return perm;
+  const head = new Int32Array(n + 1).fill(-1);
+  const next = new Int32Array(n).fill(-1);
+  const prev = new Int32Array(n).fill(-1);
+  const deg = new Int32Array(n);
+  const insert = (v) => {
+    const d = deg[v];
+    next[v] = head[d];
+    prev[v] = -1;
+    if (head[d] >= 0) prev[head[d]] = v;
+    head[d] = v;
+  };
+  const remove = (v) => {
+    const d = deg[v];
+    if (prev[v] >= 0) next[prev[v]] = next[v];
+    else head[d] = next[v];
+    if (next[v] >= 0) prev[next[v]] = prev[v];
+  };
+  for (let v = 0; v < n; v++) {
+    deg[v] = adj[v].size;
+    insert(v);
+  }
+  let mind = 0;
+  for (let step = 0; step < n; step++) {
+    while (head[mind] < 0) mind++;
+    const v = head[mind];
+    remove(v);
+    perm[step] = v;
+    const nbrs = Array.from(adj[v]);
+    for (const u of nbrs) adj[u].delete(v);
+    for (let a = 0; a < nbrs.length; a++) {
+      const u = nbrs[a];
+      const su = adj[u];
+      for (let b = a + 1; b < nbrs.length; b++) {
+        const w = nbrs[b];
+        if (!su.has(w)) {
+          su.add(w);
+          adj[w].add(u);
+        }
+      }
+    }
+    for (const u of nbrs) {
+      remove(u);
+      deg[u] = adj[u].size;
+      insert(u);
+      if (deg[u] < mind) mind = deg[u];
+    }
+    adj[v].clear();
+  }
+  return perm;
+}
+function reverseCuthillMcKee(A) {
+  const adj = symmetricAdjacency(A);
+  const n = adj.length;
+  const nb = adj.map(
+    (s) => Array.from(s).sort((a, b) => adj[a].size - adj[b].size || a - b)
+  );
+  const visited = new Uint8Array(n);
+  const order = [];
+  const bfsLevels = (start) => {
+    const seen = new Uint8Array(n);
+    let frontier = [start];
+    seen[start] = 1;
+    let levels = 0;
+    let last = start;
+    while (frontier.length > 0) {
+      const nextF = [];
+      for (const u of frontier)
+        for (const w of nb[u])
+          if (!seen[w]) {
+            seen[w] = 1;
+            nextF.push(w);
+          }
+      if (nextF.length === 0) {
+        last = frontier.reduce((a, b) => adj[b].size < adj[a].size ? b : a);
+        break;
+      }
+      frontier = nextF;
+      levels++;
+    }
+    return { last, levels };
+  };
+  for (let s0 = 0; s0 < n; s0++) {
+    if (visited[s0]) continue;
+    let start = s0;
+    let info = bfsLevels(start);
+    for (let iter = 0; iter < 4; iter++) {
+      const cand = bfsLevels(info.last);
+      if (cand.levels > info.levels) {
+        start = info.last;
+        info = cand;
+      } else {
+        start = info.last;
+        break;
+      }
+    }
+    const queue = [start];
+    visited[start] = 1;
+    let qh = 0;
+    while (qh < queue.length) {
+      const u = queue[qh++];
+      order.push(u);
+      for (const w of nb[u])
+        if (!visited[w]) {
+          visited[w] = 1;
+          queue.push(w);
+        }
+    }
+  }
+  const perm = new Int32Array(n);
+  for (let i = 0; i < n; i++) perm[i] = order[n - 1 - i];
+  return perm;
+}
+function ataPattern(A) {
+  const At = sparseTranspose(A);
+  const n = A.n;
+  const marker = new Int32Array(n).fill(-1);
+  const ir = [];
+  const jc = new Int32Array(n + 1);
+  for (let j = 0; j < n; j++) {
+    jc[j] = ir.length;
+    for (let k = A.jc[j]; k < A.jc[j + 1]; k++) {
+      const row = A.ir[k];
+      for (let t = At.jc[row]; t < At.jc[row + 1]; t++) {
+        const i = At.ir[t];
+        if (marker[i] !== j) {
+          marker[i] = j;
+          ir.push(i);
+        }
+      }
+    }
+  }
+  jc[n] = ir.length;
+  const pr = allocFloat64Array(ir.length).fill(1);
+  return fromUnsortedColumns(n, n, new Int32Array(ir), jc, pr);
+}
+function columnOrdering(A) {
+  return minimumDegreeOrdering(ataPattern(A));
+}
+var DENSE_FRACTION = 0.5;
+function sparseSolve(A, B, nrhs) {
+  const n = A.n;
+  if (A.m !== n || A.pi) return null;
+  if (n === 0) return allocFloat64Array(0);
+  const nnz = A.jc[n];
+  if (nnz > DENSE_FRACTION * n * n && n > 8) return null;
+  if (sparseIsUpper(A)) {
+    const r = sparseSolveUpper(A, B, nrhs);
+    if (r.singular) emitWarning(SINGULAR_WARNING);
+    return r.x;
+  }
+  if (sparseIsLower(A)) {
+    const r = sparseSolveLower(A, B, nrhs);
+    if (r.singular) emitWarning(SINGULAR_WARNING);
+    return r.x;
+  }
+  const perm = reverseCuthillMcKee(A);
+  if (sparseIsSymmetric(A) && allDiagPositive(A)) {
+    const Ap = sparsePermute(A, perm, perm);
+    const ch = sparseChol(Ap);
+    if (ch.ok) {
+      const Lt = sparseTranspose(ch.L);
+      const bp = permuteRows(B, n, nrhs, perm);
+      const y = sparseSolveLower(ch.L, bp, nrhs).x;
+      const z = sparseSolveUpper(Lt, y, nrhs).x;
+      return unpermuteRows(z, n, nrhs, perm);
+    }
+  }
+  const lu2 = sparseLu(A, perm, 1);
+  return luSolve(lu2, B, nrhs);
+}
+function luSolve(lu2, B, nrhs) {
+  const n = lu2.U.n;
+  const pb = permuteRows(B, n, nrhs, lu2.p);
+  const y = sparseSolveLower(lu2.L, pb, nrhs);
+  const z = sparseSolveUpper(lu2.U, y.x, nrhs);
+  if (lu2.singular || z.singular) emitWarning(SINGULAR_WARNING);
+  return unpermuteRows(z.x, n, nrhs, lu2.q);
+}
+function luSolveTransposed(lu2, B, nrhs) {
+  const n = lu2.U.n;
+  const qb = permuteRows(B, n, nrhs, lu2.q);
+  const y = sparseSolveLower(sparseTranspose(lu2.U), qb, nrhs);
+  const z = sparseSolveUpper(sparseTranspose(lu2.L), y.x, nrhs);
+  if (lu2.singular || y.singular) emitWarning(SINGULAR_WARNING);
+  return unpermuteRows(z.x, n, nrhs, lu2.p);
+}
+function sparseInverse(A) {
+  const n = A.n;
+  if (A.m !== n) throw new RuntimeError("inv: matrix must be square");
+  const I = allocFloat64Array(n * n);
+  for (let i = 0; i < n; i++) I[i + i * n] = 1;
+  const X = sparseSolve(A, I, n);
+  if (X === null) throw new RuntimeError("inv: unsupported sparse matrix");
+  return denseDataToSparse(X, n, n);
+}
+
 // src/numbl-core/helpers/arithmetic.ts
 function toComplex(v) {
   if (isRuntimeComplexNumber(v)) return { re: v.re, im: v.im };
@@ -28346,6 +30435,12 @@ function mElemMul(a, b) {
 }
 function mDiv(a, b) {
   if (isRuntimeSparseMatrix(a) || isRuntimeSparseMatrix(b)) {
+    if (isRuntimeSparseMatrix(a) && (isRuntimeNumber(b) || isRuntimeLogical(b) || isRuntimeComplexNumber(b) || isRuntimeTensor(b) && b.data.length === 1))
+      return mElemDivSparse(a, b);
+    if (isRuntimeSparseMatrix(b) && !(b.m === 1 && b.n === 1)) {
+      const result = mLeftDiv(mConjugateTranspose(b), mConjugateTranspose(a));
+      return mConjugateTranspose(result);
+    }
     return mDiv(densify(a), densify(b));
   }
   if (isRuntimeTensor(a) && a.data.length === 1) a = unwrap1x1(a);
@@ -28401,8 +30496,50 @@ function mElemDiv(a, b) {
   }
   return binaryOp(a, b, (x, y) => x / y, BIN_OP_DIV);
 }
+function sparseLeftDiv(A, b) {
+  if (A.pi) return null;
+  if (A.m === 1 && A.n === 1) return null;
+  let B;
+  let rows, nrhs;
+  const bSparse = isRuntimeSparseMatrix(b);
+  if (isRuntimeSparseMatrix(b)) {
+    if (b.pi) return null;
+    const d = sparseToDense(b);
+    B = d.data;
+    rows = b.m;
+    nrhs = b.n;
+  } else if (isRuntimeTensor(b)) {
+    if (b.imag) return null;
+    [rows, nrhs] = tensorSize2D(b);
+    B = b.data;
+  } else if (isRuntimeNumber(b) || isRuntimeLogical(b)) {
+    B = allocFloat64Array([toNumber(b)]);
+    rows = 1;
+    nrhs = 1;
+  } else {
+    return null;
+  }
+  if (rows !== A.m)
+    throw new RuntimeError(
+      `mldivide (\\): A is ${A.m}\xD7${A.n} but B has ${rows} rows`
+    );
+  if (A.m !== A.n) {
+    emitWarning(
+      "mldivide: sparse least-squares uses a dense factorization; the sparse matrix is converted to full."
+    );
+    return null;
+  }
+  const X = sparseSolve(A, B, nrhs);
+  if (X === null) return null;
+  if (bSparse) return denseDataToSparse(X, A.n, nrhs);
+  return unwrap1x1(RTV.tensor(X, [A.n, nrhs]));
+}
 function mLeftDiv(a, b) {
-  if (isRuntimeSparseMatrix(a)) return mLeftDiv(densify(a), b);
+  if (isRuntimeSparseMatrix(a)) {
+    const r = sparseLeftDiv(a, b);
+    if (r !== null) return r;
+    return mLeftDiv(densify(a), densify(b));
+  }
   if (isRuntimeSparseMatrix(b)) return mLeftDiv(a, densify(b));
   if (isRuntimeTensor(a) && a.data.length === 1) a = unwrap1x1(a);
   if (isRuntimeTensor(b) && b.data.length === 1) b = unwrap1x1(b);
@@ -29489,7 +31626,7 @@ function applyUnaryElemwiseMaybeComplex(v, realFn, complexFn, name, nativeOpCode
   if (typeof v === "boolean") v = v ? 1 : 0;
   if (typeof v === "number") {
     const r = realFn(v);
-    if (!Number.isNaN(r)) return r;
+    if (!Number.isNaN(r) || Number.isNaN(v)) return r;
     const c = complexFn(v, 0);
     return mkc(c.re, c.im);
   }
@@ -29505,7 +31642,7 @@ function applyUnaryElemwiseMaybeComplex(v, realFn, complexFn, name, nativeOpCode
         tensorOps.realUnaryElemwise(nativeOpCode, n, v.data, nativeOut);
         let firstNaN = -1;
         for (let i = 0; i < n; i++) {
-          if (Number.isNaN(nativeOut[i])) {
+          if (Number.isNaN(nativeOut[i]) && !Number.isNaN(v.data[i])) {
             firstNaN = i;
             break;
           }
@@ -29517,7 +31654,7 @@ function applyUnaryElemwiseMaybeComplex(v, realFn, complexFn, name, nativeOpCode
         const outI3 = allocFloat64Array(n);
         let hasImag2 = false;
         for (let i = 0; i < n; i++) {
-          if (!Number.isNaN(nativeOut[i])) {
+          if (!Number.isNaN(nativeOut[i]) || Number.isNaN(v.data[i])) {
             outR3[i] = nativeOut[i];
           } else {
             const c = complexFn(v.data[i], 0);
@@ -29533,7 +31670,7 @@ function applyUnaryElemwiseMaybeComplex(v, realFn, complexFn, name, nativeOpCode
       let hasImag = false;
       for (let i = 0; i < n; i++) {
         const r = realFn(v.data[i]);
-        if (!Number.isNaN(r)) {
+        if (!Number.isNaN(r) || Number.isNaN(v.data[i])) {
           outR2[i] = r;
           outI2[i] = 0;
         } else {
@@ -34326,7 +36463,11 @@ function binop(op, a, b) {
         result = mElemDiv(mb, ma);
         break;
       }
-      const tensorA = isRuntimeSparseMatrix(ma) ? sparseToDense(ma) : ma;
+      if (isRuntimeSparseMatrix(ma)) {
+        result = mLeftDiv(ma, mb);
+        break;
+      }
+      const tensorA = ma;
       const tensorB = isRuntimeNumber(mb) ? RTV.tensor(allocFloat64Array([mb]), [1, 1]) : isRuntimeSparseMatrix(mb) ? sparseToDense(mb) : mb;
       if (!isRuntimeTensor(tensorA) || !isRuntimeTensor(tensorB))
         throw new RuntimeError(
@@ -38237,6 +40378,709 @@ function tryDatetimeDurationBinop(opName, a, b) {
   );
 }
 
+// src/numbl-core/helpers/prng.ts
+var _rngState = null;
+var _rngSeed = 0;
+var _bmSpare = null;
+function setRngShuffle() {
+  _rngState = null;
+  _rngSeed = 0;
+  _bmSpare = null;
+}
+function setRngSeed(seed) {
+  _rngSeed = seed;
+}
+function splitmix32(seed) {
+  let s = seed | 0;
+  return () => {
+    s = s + 2654435769 | 0;
+    let z = s;
+    z = Math.imul(z ^ z >>> 16, 2246822507);
+    z = Math.imul(z ^ z >>> 13, 3266489909);
+    return (z ^ z >>> 16) >>> 0;
+  };
+}
+function seedRng(seed) {
+  _bmSpare = null;
+  const sm = splitmix32(seed);
+  _rngState = new Uint32Array([sm(), sm(), sm(), sm()]);
+  if (_rngState[0] === 0 && _rngState[1] === 0 && _rngState[2] === 0 && _rngState[3] === 0) {
+    _rngState[0] = 1;
+  }
+}
+function xoshiro128ss() {
+  const s = _rngState;
+  const result = Math.imul(rotl(Math.imul(s[1], 5), 7), 9) >>> 0;
+  const t = s[1] << 9;
+  s[2] ^= s[0];
+  s[3] ^= s[1];
+  s[1] ^= s[2];
+  s[0] ^= s[3];
+  s[2] ^= t;
+  s[3] = rotl(s[3], 11);
+  return result;
+}
+function rotl(x, k) {
+  return (x << k | x >>> 32 - k) >>> 0;
+}
+function rngRandom() {
+  if (_rngState === null) return Math.random();
+  return (xoshiro128ss() >>> 0) / 4294967296;
+}
+function boxMullerRandom() {
+  if (_bmSpare !== null) {
+    const s2 = _bmSpare;
+    _bmSpare = null;
+    return s2;
+  }
+  let u, v, s;
+  do {
+    u = 2 * rngRandom() - 1;
+    v = 2 * rngRandom() - 1;
+    s = u * u + v * v;
+  } while (s >= 1 || s === 0);
+  const mul = Math.sqrt(-2 * Math.log(s) / s);
+  _bmSpare = v * mul;
+  return u * mul;
+}
+function fillRandn(data) {
+  if (_rngState !== null) {
+    const bridge = getLapackBridge();
+    if (bridge?.fillRandn) {
+      const r = bridge.fillRandn(
+        _rngState,
+        data.length,
+        _bmSpare ?? 0,
+        _bmSpare !== null
+      );
+      _bmSpare = r.hasSpare ? r.spare : null;
+      data.set(r.data);
+      return;
+    }
+  }
+  const n = data.length;
+  let i = 0;
+  if (_bmSpare !== null && i < n) {
+    data[i++] = _bmSpare;
+    _bmSpare = null;
+  }
+  for (; i + 1 < n; i += 2) {
+    let u, v, s;
+    do {
+      u = 2 * rngRandom() - 1;
+      v = 2 * rngRandom() - 1;
+      s = u * u + v * v;
+    } while (s >= 1 || s === 0);
+    const mul = Math.sqrt(-2 * Math.log(s) / s);
+    data[i] = u * mul;
+    data[i + 1] = v * mul;
+  }
+  if (i < n) {
+    data[i] = boxMullerRandom();
+  }
+}
+function getRngStateStruct() {
+  const stateArray = _rngState ? RTV.tensor(allocFloat64Array(Array.from(_rngState).map((v) => v)), [4, 1]) : RTV.tensor(allocFloat64Array(0), [0, 1]);
+  return RTV.struct({
+    Type: RTV.char("twister"),
+    Seed: RTV.num(_rngSeed),
+    State: stateArray
+  });
+}
+function restoreRngState(s) {
+  const seedField = s.fields.get("Seed");
+  const stateField = s.fields.get("State");
+  if (seedField === void 0 || stateField === void 0) {
+    throw new RuntimeError("rng: invalid state structure");
+  }
+  _rngSeed = Math.round(toNumber(seedField));
+  if (isRuntimeTensor(stateField) && stateField.data.length === 4) {
+    _rngState = new Uint32Array(4);
+    for (let i = 0; i < 4; i++) _rngState[i] = stateField.data[i] >>> 0;
+  } else {
+    _rngState = null;
+  }
+}
+
+// src/numbl-core/interpreter/builtins/sparse-solvers.ts
+function toSparseArg(v, name) {
+  if (isRuntimeSparseMatrix(v)) return v;
+  if (isRuntimeTensor(v)) return denseToSparse(v);
+  if (isRuntimeNumber(v))
+    return denseToSparse(RTV.tensor(allocFloat64Array([v]), [1, 1]));
+  if (isRuntimeLogical(v))
+    return denseToSparse(RTV.tensor(allocFloat64Array([v ? 1 : 0]), [1, 1]));
+  throw new RuntimeError(`${name}: argument must be a numeric matrix`);
+}
+var ROW_VECTOR = { kind: "tensor", isComplex: false };
+registerIBuiltin({
+  name: "symrcm",
+  help: {
+    signatures: ["p = symrcm(A)"],
+    description: "Reverse Cuthill-McKee ordering of the pattern of A + A'. A(p,p) tends to have a smaller bandwidth than A."
+  },
+  resolve: (argTypes, nargout) => {
+    if (argTypes.length !== 1 || nargout > 1) return null;
+    return {
+      outputTypes: [ROW_VECTOR],
+      apply: (args) => permVectorTensor(reverseCuthillMcKee(toSparseArg(args[0], "symrcm")))
+    };
+  }
+});
+registerIBuiltin({
+  name: "amd",
+  help: {
+    signatures: ["p = amd(A)"],
+    description: "Minimum degree ordering of the pattern of A + A'. chol(A(p,p)) tends to be sparser than chol(A). numbl uses an exact minimum degree ordering, so p can differ from MATLAB's approximate minimum degree permutation."
+  },
+  resolve: (argTypes, nargout) => {
+    if (argTypes.length < 1 || argTypes.length > 2 || nargout > 1) return null;
+    return {
+      outputTypes: [ROW_VECTOR],
+      apply: (args) => permVectorTensor(minimumDegreeOrdering(toSparseArg(args[0], "amd")))
+    };
+  }
+});
+registerIBuiltin({
+  name: "colamd",
+  help: {
+    signatures: ["p = colamd(A)"],
+    description: "Column ordering for LU: minimum degree ordering of the pattern of A'*A. lu(A(:,p)) tends to produce sparser factors than lu(A)."
+  },
+  resolve: (argTypes, nargout) => {
+    if (argTypes.length < 1 || argTypes.length > 2 || nargout > 1) return null;
+    return {
+      outputTypes: [ROW_VECTOR],
+      apply: (args) => permVectorTensor(columnOrdering(toSparseArg(args[0], "colamd")))
+    };
+  }
+});
+function sampleDistinct(total, k) {
+  if (k >= total) {
+    const all2 = new Int32Array(total);
+    for (let i = 0; i < total; i++) all2[i] = i;
+    return all2;
+  }
+  let picked;
+  if (k > total / 3) {
+    const idx = new Int32Array(total);
+    for (let i = 0; i < total; i++) idx[i] = i;
+    for (let i = 0; i < k; i++) {
+      const j = i + Math.floor(rngRandom() * (total - i));
+      const t = idx[i];
+      idx[i] = idx[j];
+      idx[j] = t;
+    }
+    picked = idx.slice(0, k);
+  } else {
+    const set = /* @__PURE__ */ new Set();
+    while (set.size < k) set.add(Math.floor(rngRandom() * total));
+    picked = Int32Array.from(set);
+  }
+  return picked.sort();
+}
+function sparseFromLinearIndices(m, n, idx, gen) {
+  const nnz = idx.length;
+  const ir = new Int32Array(nnz);
+  const jc = new Int32Array(n + 1);
+  const pr = allocFloat64Array(nnz);
+  for (let k = 0; k < nnz; k++) {
+    const col = Math.floor(idx[k] / m);
+    ir[k] = idx[k] - col * m;
+    jc[col + 1]++;
+    pr[k] = gen();
+  }
+  for (let c = 0; c < n; c++) jc[c + 1] += jc[c];
+  return RTV.sparseMatrix(m, n, ir, jc, pr);
+}
+function registerSprand(name, gen) {
+  registerIBuiltin({
+    name,
+    help: {
+      signatures: [`R = ${name}(m, n, density)`, `R = ${name}(S)`],
+      description: `Random m-by-n sparse matrix with approximately density*m*n ` + (name === "sprand" ? "uniformly" : "normally") + ` distributed nonzeros, or a matrix with the pattern of S and random values.`
+    },
+    resolve: (argTypes, nargout) => {
+      if (nargout > 1) return null;
+      if (argTypes.length !== 1 && argTypes.length < 3) return null;
+      return {
+        outputTypes: [{ kind: "sparse_matrix", isComplex: false }],
+        apply: (args) => {
+          if (args.length === 1) {
+            const S = toSparseArg(args[0], name);
+            const pr = allocFloat64Array(S.pr.length);
+            for (let k2 = 0; k2 < pr.length; k2++) pr[k2] = gen();
+            return RTV.sparseMatrix(
+              S.m,
+              S.n,
+              new Int32Array(S.ir),
+              new Int32Array(S.jc),
+              pr
+            );
+          }
+          if (args.length > 3)
+            throw new RuntimeError(
+              `${name}: the reciprocal-condition form ${name}(m, n, density, rc) is not supported`
+            );
+          const m = Math.round(toNumber(args[0]));
+          const n = Math.round(toNumber(args[1]));
+          const density = toNumber(args[2]);
+          if (!(density >= 0 && density <= 1))
+            throw new RuntimeError(`${name}: density must be in [0, 1]`);
+          const total = m * n;
+          const k = Math.min(total, Math.round(density * total));
+          return sparseFromLinearIndices(m, n, sampleDistinct(total, k), gen);
+        }
+      };
+    }
+  });
+}
+registerSprand("sprand", rngRandom);
+registerSprand("sprandn", boxMullerRandom);
+registerIBuiltin({
+  name: "sprandsym",
+  help: {
+    signatures: ["R = sprandsym(n, density)", "R = sprandsym(S)"],
+    description: "Symmetric random n-by-n sparse matrix with approximately density*n*n normally distributed nonzeros, or a symmetric matrix with the pattern of the lower triangle of S."
+  },
+  resolve: (argTypes, nargout) => {
+    if (nargout > 1 || argTypes.length < 1 || argTypes.length > 2) return null;
+    return {
+      outputTypes: [{ kind: "sparse_matrix", isComplex: false }],
+      apply: (args) => {
+        let n;
+        let lowerIdx;
+        if (args.length === 1) {
+          const S = toSparseArg(args[0], "sprandsym");
+          if (S.m !== S.n)
+            throw new RuntimeError("sprandsym: S must be square");
+          n = S.n;
+          const idx = [];
+          for (let j = 0; j < n; j++)
+            for (let k = S.jc[j]; k < S.jc[j + 1]; k++)
+              if (S.ir[k] >= j) idx.push(j * n + S.ir[k]);
+          lowerIdx = Int32Array.from(idx);
+        } else {
+          n = Math.round(toNumber(args[0]));
+          const density = toNumber(args[1]);
+          if (!(density >= 0 && density <= 1))
+            throw new RuntimeError("sprandsym: density must be in [0, 1]");
+          const tri = n * (n + 1) / 2;
+          const k = Math.min(tri, Math.round(density * n * n / 2));
+          const triIdx = sampleDistinct(tri, k);
+          const lin = [];
+          for (let t = 0; t < triIdx.length; t++) {
+            let r = triIdx[t];
+            let col = 0;
+            while (r >= n - col) {
+              r -= n - col;
+              col++;
+            }
+            lin.push(col * n + col + r);
+          }
+          lowerIdx = Int32Array.from(lin).sort();
+        }
+        const lower = sparseFromLinearIndices(n, n, lowerIdx, boxMullerRandom);
+        const Lt = sparseTranspose(lower);
+        const dense = sparseToDense(lower).data;
+        const denseT = sparseToDense(Lt).data;
+        for (let i = 0; i < dense.length; i++) dense[i] += denseT[i];
+        for (let i = 0; i < n; i++) dense[i + i * n] /= 2;
+        return denseDataToSparse(dense, n, n);
+      }
+    };
+  }
+});
+var DEC_CLASS = "decomposition";
+function isDecomposition(v) {
+  return isRuntimeClassInstance(v) && v.className === DEC_CLASS;
+}
+function permFromField(d, name) {
+  const t = d.fields.get(name);
+  if (t === void 0 || !isRuntimeTensor(t))
+    throw new RuntimeError("decomposition: corrupt");
+  const p2 = new Int32Array(t.data.length);
+  for (let i = 0; i < p2.length; i++) p2[i] = t.data[i] - 1;
+  return p2;
+}
+function sparseField(d, name) {
+  const v = d.fields.get(name);
+  if (v === void 0 || !isRuntimeSparseMatrix(v))
+    throw new RuntimeError("decomposition: corrupt");
+  return v;
+}
+function charField(d, name) {
+  const v = d.fields.get(name);
+  if (v === void 0) throw new RuntimeError("decomposition: corrupt");
+  return parseStringArgLower(v);
+}
+function diagRatio(S) {
+  let lo = Infinity;
+  let hi = 0;
+  for (let j = 0; j < S.n; j++) {
+    let d = 0;
+    for (let k = S.jc[j]; k < S.jc[j + 1]; k++)
+      if (S.ir[k] === j) {
+        d = Math.abs(S.pr[k]);
+        break;
+      }
+    if (d < lo) lo = d;
+    if (d > hi) hi = d;
+  }
+  if (S.n === 0) return 1;
+  return hi === 0 ? 0 : lo / hi;
+}
+function denseLuFactors(data, n) {
+  const bridge = getEffectiveBridge("lu", "lu");
+  if (!bridge?.lu) throw new RuntimeError("decomposition: LU unavailable");
+  const { LU, ipiv } = bridge.lu(toF64(data), n, n);
+  const perm = new Int32Array(n);
+  for (let i = 0; i < n; i++) perm[i] = i;
+  for (let i = 0; i < ipiv.length; i++) {
+    const j = ipiv[i] - 1;
+    if (j !== i) {
+      const t = perm[i];
+      perm[i] = perm[j];
+      perm[j] = t;
+    }
+  }
+  const L = allocFloat64Array(n * n);
+  const U = allocFloat64Array(n * n);
+  let singular = false;
+  for (let j = 0; j < n; j++) {
+    L[j + j * n] = 1;
+    for (let i = j + 1; i < n; i++) L[i + j * n] = LU[i + j * n];
+    for (let i = 0; i <= j; i++) U[i + j * n] = LU[i + j * n];
+    if (U[j + j * n] === 0) singular = true;
+  }
+  return {
+    L: denseDataToSparse(L, n, n),
+    U: denseDataToSparse(U, n, n),
+    p: perm,
+    q: identityPerm(n),
+    singular
+  };
+}
+function denseCholLower(data, n) {
+  const bridge = getEffectiveBridge("chol", "chol");
+  if (!bridge?.chol) throw new RuntimeError("decomposition: chol unavailable");
+  const { R, info } = bridge.chol(toF64(data), n, false);
+  if (info > 0) return null;
+  return denseDataToSparse(R, n, n);
+}
+function denseIsTriangular(data, n, upper) {
+  for (let j = 0; j < n; j++)
+    for (let i = 0; i < n; i++) {
+      if (upper ? i <= j : i >= j) continue;
+      if (data[i + j * n] !== 0) return false;
+    }
+  return true;
+}
+registerIBuiltin({
+  name: "decomposition",
+  help: {
+    signatures: [
+      "dA = decomposition(A)",
+      "dA = decomposition(A, type)",
+      "dA = decomposition(A, 'triangular', 'upper' | 'lower')",
+      "x = dA \\ b",
+      "x = b / dA"
+    ],
+    description: "Factor a square matrix once and reuse the factors: dA \\ b and b / dA solve with the stored factorization. type is 'auto' (default), 'chol', 'lu', or 'triangular'; other MATLAB types fall back to LU. Sparse matrices use the sparse Cholesky / LU with a fill-reducing ordering. Properties: MatrixSize, Type, Datatype, IsReal, IsConjugateTransposed, ScaleFactor, CheckCondition."
+  },
+  resolve: (argTypes, nargout) => {
+    if (argTypes.length < 1 || nargout > 1) return null;
+    return {
+      outputTypes: [{ kind: "unknown" }],
+      apply: (args) => buildDecomposition(args)
+    };
+  }
+});
+function buildDecomposition(args) {
+  const A = args[0];
+  let type = "auto";
+  let triangle = null;
+  let checkCondition = true;
+  let luTol = 1;
+  let i = 1;
+  const isStr = (v) => isRuntimeChar(v) || isRuntimeString(v);
+  while (i < args.length) {
+    const a = args[i];
+    if (!isStr(a))
+      throw new RuntimeError("decomposition: options must be strings");
+    const s = parseStringArgLower(a);
+    if (s === "upper" || s === "lower") {
+      triangle = s;
+      i++;
+      continue;
+    }
+    if (s === "checkcondition" || s === "ranktolerance" || s === "banddensity" || s === "ldlpivottolerance" || s === "lupivottolerance") {
+      if (i + 1 >= args.length)
+        throw new RuntimeError(`decomposition: missing value for '${s}'`);
+      const v = args[i + 1];
+      if (s === "checkcondition") checkCondition = toNumber(v) !== 0;
+      if (s === "lupivottolerance") luTol = toNumber(v);
+      i += 2;
+      continue;
+    }
+    if (i === 1) {
+      type = s;
+      i++;
+      continue;
+    }
+    throw new RuntimeError(`decomposition: unknown option '${s}'`);
+  }
+  const known = [
+    "auto",
+    "chol",
+    "lu",
+    "triangular",
+    "ldl",
+    "qr",
+    "banded",
+    "diagonal",
+    "permutedtriangular",
+    "hessenberg",
+    "cod"
+  ];
+  if (!known.includes(type))
+    throw new RuntimeError(
+      `decomposition: unknown decomposition type '${type}'`
+    );
+  let S = null;
+  let dense = null;
+  let n;
+  if (isRuntimeSparseMatrix(A)) {
+    if (A.pi)
+      throw new RuntimeError(
+        "decomposition: complex matrices are not supported"
+      );
+    if (A.m !== A.n)
+      throw new RuntimeError(
+        "decomposition: only square matrices are supported"
+      );
+    S = A;
+    n = A.n;
+  } else if (isRuntimeTensor(A) || isRuntimeNumber(A)) {
+    const t = isRuntimeNumber(A) ? RTV.tensor(allocFloat64Array([A]), [1, 1]) : A;
+    if (t.imag)
+      throw new RuntimeError(
+        "decomposition: complex matrices are not supported"
+      );
+    const [m, nn] = tensorSize2D(t);
+    if (m !== nn)
+      throw new RuntimeError(
+        "decomposition: only square matrices are supported"
+      );
+    n = nn;
+    dense = t.data;
+  } else {
+    throw new RuntimeError("decomposition: A must be a numeric matrix");
+  }
+  const fields = /* @__PURE__ */ new Map();
+  const setCommon = (typeName, rc) => {
+    fields.set("MatrixSize", RTV.tensor(allocFloat64Array([n, n]), [1, 2]));
+    fields.set("Type", RTV.char(typeName));
+    fields.set("Datatype", RTV.char("double"));
+    fields.set("IsReal", RTV.logical(true));
+    fields.set("IsConjugateTransposed", RTV.logical(false));
+    fields.set("ScaleFactor", RTV.num(1));
+    fields.set("CheckCondition", RTV.logical(checkCondition));
+    fields.set("_rcond", RTV.num(rc));
+  };
+  const storeTriangular = (T, upper) => {
+    fields.set("_kind", RTV.char("triangular"));
+    fields.set("_T", T);
+    fields.set("_upper", RTV.logical(upper));
+    setCommon("triangular", diagRatio(T));
+  };
+  const storeChol = (L, p2) => {
+    fields.set("_kind", RTV.char("chol"));
+    fields.set("_L", L);
+    fields.set("_Lt", sparseTranspose(L));
+    fields.set("_p", permVectorTensor(p2));
+    setCommon("chol", diagRatio(L) ** 2);
+  };
+  const storeLu = (lu3) => {
+    fields.set("_kind", RTV.char("lu"));
+    fields.set("_L", lu3.L);
+    fields.set("_U", lu3.U);
+    fields.set("_p", permVectorTensor(lu3.p));
+    fields.set("_q", permVectorTensor(lu3.q));
+    setCommon(type === "auto" || type === "lu" ? "lu" : type, diagRatio(lu3.U));
+  };
+  const upperOk = S ? sparseIsUpper(S) : denseIsTriangular(dense, n, true);
+  const lowerOk = S ? sparseIsLower(S) : denseIsTriangular(dense, n, false);
+  if (type === "triangular" || type === "auto" && (upperOk || lowerOk)) {
+    let upper;
+    if (triangle) upper = triangle === "upper";
+    else if (upperOk) upper = true;
+    else if (lowerOk) upper = false;
+    else throw new RuntimeError("decomposition: matrix is not triangular");
+    const T = S ?? denseDataToSparse(dense, n, n);
+    storeTriangular(T, upper);
+    return new RuntimeClassInstance(DEC_CLASS, fields, false);
+  }
+  const symmetric = S !== null && sparseIsSymmetric(S);
+  if (type === "chol" || type === "auto" && symmetric) {
+    if (S) {
+      const perm = minimumDegreeOrdering(S);
+      const res = sparseChol(sparsePermute(S, perm, perm));
+      if (res.ok) {
+        storeChol(res.L, perm);
+        return new RuntimeClassInstance(DEC_CLASS, fields, false);
+      }
+    } else {
+      const L = denseCholLower(dense, n);
+      if (L) {
+        storeChol(L, identityPerm(n));
+        return new RuntimeClassInstance(DEC_CLASS, fields, false);
+      }
+    }
+    if (type === "chol")
+      throw new RuntimeError(
+        "Cholesky decomposition requires the input matrix to be positive definite."
+      );
+  }
+  const lu2 = S ? sparseLu(S, columnOrdering(S), luTol) : denseLuFactors(dense, n);
+  if (lu2.singular) emitWarning(SINGULAR_WARNING);
+  storeLu(lu2);
+  return new RuntimeClassInstance(DEC_CLASS, fields, false);
+}
+function decompositionRcond(d) {
+  const rc = d.fields.get("_rcond");
+  return typeof rc === "number" ? rc : 1;
+}
+registerIBuiltin({
+  name: "isIllConditioned",
+  help: {
+    signatures: ["tf = isIllConditioned(dA)"],
+    description: "True if the matrix stored in a decomposition object is ill conditioned (reciprocal condition estimate below eps)."
+  },
+  resolve: (argTypes, nargout) => {
+    if (argTypes.length !== 1 || nargout > 1) return null;
+    return {
+      outputTypes: [{ kind: "boolean" }],
+      apply: (args) => {
+        if (!isDecomposition(args[0]))
+          throw new RuntimeError(
+            "isIllConditioned: argument must be a decomposition object"
+          );
+        return RTV.logical(decompositionRcond(args[0]) < Number.EPSILON);
+      }
+    };
+  }
+});
+function decompositionSolve(d, B, n, nrhs, transposed) {
+  if (d.fields.get("CheckCondition") === true) {
+    const rc = decompositionRcond(d);
+    if (rc < Number.EPSILON)
+      emitWarning(
+        `Matrix is close to singular or badly scaled. Results may be inaccurate. RCOND =  ${rc.toExponential(6)}.`
+      );
+  }
+  const kind = charField(d, "_kind");
+  if (kind === "triangular") {
+    let T = sparseField(d, "_T");
+    let upper = d.fields.get("_upper") === true;
+    if (transposed) {
+      T = sparseTranspose(T);
+      upper = !upper;
+    }
+    const r = upper ? sparseSolveUpper(T, B, nrhs) : sparseSolveLower(T, B, nrhs);
+    if (r.singular) emitWarning(SINGULAR_WARNING);
+    return r.x;
+  }
+  if (kind === "chol") {
+    const L = sparseField(d, "_L");
+    const p2 = permFromField(d, "_p");
+    const bp = allocFloat64Array(B.length);
+    for (let c = 0; c < nrhs; c++)
+      for (let k = 0; k < n; k++) bp[c * n + k] = B[c * n + p2[k]];
+    const y = sparseSolveLower(L, bp, nrhs).x;
+    const z = sparseSolveUpper(sparseField(d, "_Lt"), y, nrhs).x;
+    const x = allocFloat64Array(B.length);
+    for (let c = 0; c < nrhs; c++)
+      for (let k = 0; k < n; k++) x[c * n + p2[k]] = z[c * n + k];
+    return x;
+  }
+  const lu2 = {
+    L: sparseField(d, "_L"),
+    U: sparseField(d, "_U"),
+    p: permFromField(d, "_p"),
+    q: permFromField(d, "_q"),
+    singular: false
+  };
+  return transposed ? luSolveTransposed(lu2, B, nrhs) : luSolve(lu2, B, nrhs);
+}
+function rhsData(v) {
+  if (isRuntimeSparseMatrix(v)) {
+    if (v.pi)
+      throw new RuntimeError(
+        "decomposition: complex operands are not supported"
+      );
+    return { data: sparseToDense(v).data, m: v.m, n: v.n };
+  }
+  if (isRuntimeTensor(v)) {
+    if (v.imag)
+      throw new RuntimeError(
+        "decomposition: complex operands are not supported"
+      );
+    const [m, n] = tensorSize2D(v);
+    return { data: v.data, m, n };
+  }
+  if (isRuntimeNumber(v) || isRuntimeLogical(v))
+    return { data: allocFloat64Array([toNumber(v)]), m: 1, n: 1 };
+  throw new RuntimeError("decomposition: operand must be numeric");
+}
+function tryDecompositionDivide(name, a, b) {
+  if (name === "mldivide") {
+    if (!isDecomposition(a)) {
+      if (isDecomposition(b))
+        throw new RuntimeError(
+          "decomposition: a decomposition object can only be the left operand of \\"
+        );
+      return void 0;
+    }
+    const n2 = toNumber(permSize(a));
+    const rhs2 = rhsData(b);
+    if (rhs2.m !== n2)
+      throw new RuntimeError(
+        `mldivide (\\): A is ${n2}\xD7${n2} but B has ${rhs2.m} rows`
+      );
+    const x2 = decompositionSolve(a, rhs2.data, n2, rhs2.n, false);
+    return RTV.tensor(x2, [n2, rhs2.n]);
+  }
+  if (!isDecomposition(b)) {
+    if (isDecomposition(a))
+      throw new RuntimeError(
+        "decomposition: a decomposition object can only be the right operand of /"
+      );
+    return void 0;
+  }
+  const n = toNumber(permSize(b));
+  const rhs = rhsData(a);
+  if (rhs.n !== n)
+    throw new RuntimeError(
+      `mrdivide (/): A is ${n}\xD7${n} but B has ${rhs.n} columns`
+    );
+  const nrhs = rhs.m;
+  const Bt = allocFloat64Array(n * nrhs);
+  for (let c = 0; c < nrhs; c++)
+    for (let k = 0; k < n; k++) Bt[c * n + k] = rhs.data[c + k * nrhs];
+  const xt = decompositionSolve(b, Bt, n, nrhs, true);
+  const x = allocFloat64Array(n * nrhs);
+  for (let c = 0; c < nrhs; c++)
+    for (let k = 0; k < n; k++) x[c + k * nrhs] = xt[c * n + k];
+  return RTV.tensor(x, [nrhs, n]);
+}
+function permSize(d) {
+  const ms = d.fields.get("MatrixSize");
+  if (ms === void 0 || !isRuntimeTensor(ms))
+    throw new RuntimeError("decomposition: corrupt");
+  return ms.data[0];
+}
+
 // src/numbl-core/interpreter/builtins/array-construction.ts
 function isClassNameType(t) {
   return t.kind === "char" || t.kind === "string";
@@ -38812,6 +41656,10 @@ for (const [name, op] of opMap) {
         apply: (args) => {
           const dt = tryDatetimeDurationBinop(name, args[0], args[1]);
           if (dt !== void 0) return dt;
+          if (name === "mldivide" || name === "mrdivide") {
+            const dec = tryDecompositionDivide(name, args[0], args[1]);
+            if (dec !== void 0) return dec;
+          }
           return op(args[0], args[1]);
         }
       };
@@ -39293,8 +42141,9 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes) => argTypes.length === 0 ? [{ kind: "number" }] : null,
-      apply: () => {
+      apply: (_args, nargout) => {
         ticTime = performance.now();
+        if (nargout === 0) return void 0;
         return RTV.num(ticTime / 1e3);
       }
     }
@@ -40201,6 +43050,7 @@ function registerSpecialBuiltins(rt) {
           if (na === 0) {
             rt.output(`Elapsed time is ${elapsed.toFixed(6)} seconds.
 `);
+            return void 0;
           }
           return RTV.num(elapsed);
         }
@@ -44286,6 +47136,7 @@ var Runtime = class _Runtime {
     if (options.cancelSAB) {
       this.cancelFlag = new Int32Array(options.cancelSAB);
     }
+    setWarningSink((msg) => this.output("Warning: " + msg + "\n"));
     this.initBuiltins();
   }
   outputLines = [];
@@ -51461,6 +54312,24 @@ defineBuiltin({
 });
 
 // src/numbl-core/interpreter/builtins/linear-algebra.ts
+var SPARSE_TYPE = { kind: "sparse_matrix", isComplex: false };
+function toSparseOperand(v, name) {
+  if (isRuntimeSparseMatrix(v)) return v;
+  if (isRuntimeNumber(v) || typeof v === "boolean")
+    return denseToSparse(RTV.tensor(allocFloat64Array([Number(v)]), [1, 1]));
+  if (isRuntimeTensor(v)) return denseToSparse(v);
+  throw new RuntimeError(`${name}: arguments must be numeric`);
+}
+function speyeSparse(n) {
+  const ir = new Int32Array(n);
+  const jc = new Int32Array(n + 1);
+  const pr = allocFloat64Array(n).fill(1);
+  for (let i = 0; i < n; i++) {
+    ir[i] = i;
+    jc[i + 1] = i + 1;
+  }
+  return RTV.sparseMatrix(n, n, ir, jc, pr);
+}
 function isNumericJitType(t) {
   return t.kind === "number" || t.kind === "boolean" || t.kind === "complex_or_number" || t.kind === "tensor" || t.kind === "sparse_matrix";
 }
@@ -51501,12 +54370,53 @@ function normApply(args) {
   const v = args[0];
   if (isRuntimeNumber(v)) return RTV.num(Math.abs(v));
   if (isRuntimeComplexNumber(v)) return RTV.num(Math.hypot(v.re, v.im));
-  if (isRuntimeSparseMatrix(v))
+  if (isRuntimeSparseMatrix(v)) {
+    const fast = sparseNormFast(v, args[1]);
+    if (fast !== null) return RTV.num(fast);
     return normApply([sparseToDense(v), ...args.slice(1)]);
+  }
   if (!isRuntimeTensor(v))
     throw new RuntimeError("norm: argument must be numeric");
   return normImplTensor(v, args);
 }
+function sparseNormFast(S, p2) {
+  if (S.m === 1 || S.n === 1) return null;
+  let kind = null;
+  if (p2 === void 0) return null;
+  if (isRuntimeNumber(p2)) {
+    if (p2 === 1) kind = "one";
+    else if (p2 === Infinity) kind = "inf";
+  } else if (isRuntimeChar(p2) || isRuntimeString(p2)) {
+    const s = parseStringArgLower(p2);
+    if (s === "fro") kind = "fro";
+    else if (s === "inf") kind = "inf";
+  }
+  if (kind === null) return null;
+  const mag2 = (k) => S.pi ? Math.hypot(S.pr[k], S.pi[k]) : Math.abs(S.pr[k]);
+  const nnz = S.jc[S.n];
+  if (kind === "fro") {
+    let sum2 = 0;
+    for (let k = 0; k < nnz; k++) {
+      const a = mag2(k);
+      sum2 += a * a;
+    }
+    return Math.sqrt(sum2);
+  }
+  if (kind === "one") {
+    let best2 = 0;
+    for (let j = 0; j < S.n; j++) {
+      let sum2 = 0;
+      for (let k = S.jc[j]; k < S.jc[j + 1]; k++) sum2 += mag2(k);
+      if (sum2 > best2) best2 = sum2;
+    }
+    return best2;
+  }
+  const rowSums = allocFloat64Array(S.m);
+  for (let k = 0; k < nnz; k++) rowSums[S.ir[k]] += mag2(k);
+  let best = 0;
+  for (let i = 0; i < S.m; i++) if (rowSums[i] > best) best = rowSums[i];
+  return best;
+}
 function scaledEuclid(magnitudes, count) {
   let scale = 0;
   let ssq = 1;
@@ -52131,11 +55041,18 @@ defineBuiltin({
         if (a.kind === "complex_or_number") return [COMPLEX_OR_NUM];
         if (a.kind === "tensor")
           return [{ kind: "tensor", isComplex: a.isComplex }];
+        if (a.kind === "sparse_matrix")
+          return [{ kind: "sparse_matrix", isComplex: a.isComplex }];
         return null;
       },
-      apply: (args) => {
+      apply: function invApply(args) {
         if (args.length < 1) throw new RuntimeError("inv requires 1 argument");
         const A = args[0];
+        if (isRuntimeSparseMatrix(A)) {
+          if (!A.pi) return sparseInverse(A);
+          const dense = invApply([sparseToDense(A)]);
+          return isRuntimeTensor(dense) ? denseToSparse(dense) : dense;
+        }
         if (isRuntimeComplexNumber(A)) {
           const { re, im } = A;
           if (re === 0 && im === 0)
@@ -52488,6 +55405,67 @@ registerIBuiltin({
     return { outputTypes: outs, apply: (args, n) => bandwidthApply(args, n) };
   }
 });
+function isTriangularValue(A, upper) {
+  if (isRuntimeNumber(A) || isRuntimeComplexNumber(A)) return true;
+  if (isRuntimeSparseMatrix(A))
+    return upper ? sparseIsUpper(A) : sparseIsLower(A);
+  if (isRuntimeTensor(A)) {
+    if (A.shape.length > 2) return false;
+    const [m, n] = tensorSize2D(A);
+    for (let j = 0; j < n; j++)
+      for (let i = 0; i < m; i++) {
+        if (upper ? i <= j : i >= j) continue;
+        const idx = colMajorIndex(i, j, m);
+        if (A.data[idx] !== 0 || A.imag && A.imag[idx] !== 0) return false;
+      }
+    return true;
+  }
+  throw new RuntimeError("istriu: argument must be a numeric matrix");
+}
+for (const [name, upper] of [
+  ["istriu", true],
+  ["istril", false]
+]) {
+  registerIBuiltin({
+    name,
+    help: {
+      signatures: [`tf = ${name}(A)`],
+      description: `True if A is ${upper ? "upper" : "lower"} triangular (all entries ${upper ? "below" : "above"} the main diagonal are zero). Works for dense and sparse matrices.`
+    },
+    resolve: (argTypes, nargout) => {
+      if (nargout > 1 || argTypes.length !== 1) return null;
+      if (!isNumericJitType(argTypes[0])) return null;
+      return {
+        outputTypes: [{ kind: "boolean" }],
+        apply: (args) => RTV.logical(isTriangularValue(args[0], upper))
+      };
+    }
+  });
+}
+registerIBuiltin({
+  name: "isbanded",
+  help: {
+    signatures: ["tf = isbanded(A, lower, upper)"],
+    description: "True if A has lower bandwidth at most `lower` and upper bandwidth at most `upper`. Works for dense and sparse matrices."
+  },
+  resolve: (argTypes, nargout) => {
+    if (nargout > 1 || argTypes.length !== 3) return null;
+    if (!isNumericJitType(argTypes[0])) return null;
+    return {
+      outputTypes: [{ kind: "boolean" }],
+      apply: (args) => {
+        const lo = toNumber(args[1]);
+        const up = toNumber(args[2]);
+        if (lo < 0 || up < 0 || !Number.isInteger(lo) || !Number.isInteger(up))
+          throw new RuntimeError(
+            "isbanded: bandwidths must be nonnegative integers"
+          );
+        const [l, u] = computeBandwidth(args[0]);
+        return RTV.logical(l <= lo && u <= up);
+      }
+    };
+  }
+});
 function computeATA(A_data, m, n) {
   const result = allocFloat64Array(n * n);
   for (let j = 0; j < n; j++)
@@ -52856,19 +55834,59 @@ function qrPivotApply(A, m, n, k, econ) {
 registerIBuiltin({
   name: "lu",
   resolve: (argTypes, nargout) => {
-    if (nargout < 0 || nargout > 3) return null;
-    if (argTypes.length < 1 || argTypes.length > 2) return null;
+    if (nargout < 0 || nargout > 4) return null;
+    if (argTypes.length < 1 || argTypes.length > 3) return null;
     if (!isNumericJitType(argTypes[0])) return null;
-    const t = tensorType();
+    const sparse = argTypes[0].kind === "sparse_matrix";
+    if (!sparse && (nargout > 3 || argTypes.length > 2)) return null;
+    const t = sparse ? SPARSE_TYPE : tensorType();
     const wrapped = (args, n) => withScratch(() => luApply(args, n));
     if (nargout <= 1) return { outputTypes: [t], apply: wrapped };
     if (nargout === 2) return { outputTypes: [t, t], apply: wrapped };
-    return { outputTypes: [t, t, t], apply: wrapped };
+    if (nargout === 3) return { outputTypes: [t, t, t], apply: wrapped };
+    return { outputTypes: [t, t, t, t], apply: wrapped };
   }
 });
+function sparseLuApply(S, args, nargout) {
+  let outputForm = "matrix";
+  let tol = nargout >= 4 ? 0.1 : 1;
+  for (const opt of args.slice(1)) {
+    if (isRuntimeNumber(opt)) {
+      if (!(opt >= 0 && opt <= 1))
+        throw new RuntimeError("lu: pivot threshold must be in [0, 1]");
+      tol = opt;
+    } else {
+      const form = parseLuOutputForm(opt);
+      if (form === null)
+        throw new RuntimeError("lu: outputForm must be 'matrix' or 'vector'");
+      outputForm = form;
+    }
+  }
+  const q = nargout >= 4 ? columnOrdering(S) : null;
+  const res = sparseLu(S, q, tol);
+  const { L, U, p: p2 } = res;
+  if (nargout <= 1) {
+    return mSub(mAdd(L, U), speyeSparse(Math.min(S.m, S.n)));
+  }
+  if (nargout === 2) {
+    const Lperm = sparsePermute(L, invertPerm(p2), identityPerm(L.n));
+    return [Lperm, U];
+  }
+  const permOut = (perm) => outputForm === "vector" ? permVectorTensor(perm) : permutationMatrix(perm);
+  if (nargout === 3) return [L, U, permOut(p2)];
+  const Q = outputForm === "vector" ? permVectorTensor(res.q) : sparseTranspose(permutationMatrix(res.q));
+  return [L, U, permOut(p2), Q];
+}
 function luApply(args, nargout) {
   if (args.length < 1)
     throw new RuntimeError("lu requires at least 1 argument");
+  if (isRuntimeSparseMatrix(args[0]) && !args[0].pi)
+    return sparseLuApply(args[0], args, nargout);
+  if (isRuntimeSparseMatrix(args[0])) {
+    const dense = luApply([sparseToDense(args[0]), ...args.slice(1)], nargout);
+    const toSp = (v) => isRuntimeTensor(v) ? denseToSparse(v) : v;
+    return Array.isArray(dense) ? dense.map(toSp) : toSp(dense);
+  }
   const outputForm = args.length >= 2 ? parseLuOutputForm(args[1]) : "matrix";
   if (outputForm === null)
     throw new RuntimeError("lu: outputForm must be 'matrix' or 'vector'");
@@ -52987,7 +56005,7 @@ function ipivToPermVector(ipiv, m) {
 registerIBuiltin({
   name: "eig",
   resolve: (argTypes, nargout) => {
-    if (nargout < 0 || nargout > 3 || argTypes.length < 1 || argTypes.length > 3)
+    if (nargout < 0 || nargout > 3 || argTypes.length < 1 || argTypes.length > 4)
       return null;
     if (!isNumericJitType(argTypes[0])) return null;
     const c = tensorType(true);
@@ -53002,7 +56020,9 @@ function eigApply(args, nargout) {
   if (args.length < 1)
     throw new RuntimeError("eig requires at least 1 argument");
   const A = args[0];
-  const { balance, outputForm } = parseEigOptionsRuntime(args);
+  const { B, balance, outputForm, algorithm } = parseEigOptionsRuntime(args);
+  if (B !== void 0)
+    return eigGeneralizedApply(A, B, nargout, outputForm, algorithm);
   if (isRuntimeNumber(A)) {
     const val = A;
     if (nargout <= 1) return RTV.num(val);
@@ -53019,6 +56039,10 @@ function eigApply(args, nargout) {
   const [m, n] = tensorSize2D(A);
   if (m !== n) throw new RuntimeError("eig: input must be a square matrix");
   const computeVL = nargout >= 3, computeVR = nargout >= 2;
+  if (isExactlyHermitian(A, n)) {
+    const symResult = eigSymmetricApply(A, n, nargout, outputForm);
+    if (symResult) return symResult;
+  }
   if (A.imag) {
     const bridge2 = getEffectiveBridge("eigComplex", "eigComplex");
     if (!bridge2.eigComplex)
@@ -53054,19 +56078,369 @@ function eigApply(args, nargout) {
   const Wout = computeVL && VL ? buildEigenvectorMatrix(VL, wi, n, hasComplex) : RTV.tensor(allocFloat64Array(n * n), [n, n]);
   return [Vout, Dout, Wout];
 }
+function isExactlyHermitian(A, n) {
+  const re = A.data;
+  const im = A.imag;
+  for (let j = 0; j < n; j++) {
+    if (im && im[j + j * n] !== 0) return false;
+    const dj = re[j + j * n];
+    if (Number.isNaN(dj)) return false;
+    for (let i = j + 1; i < n; i++) {
+      if (re[i + j * n] !== re[j + i * n]) return false;
+      if (im && im[i + j * n] !== -im[j + i * n]) return false;
+    }
+  }
+  return true;
+}
+function eigSymmetricApply(A, n, nargout, outputForm) {
+  const computeV = nargout >= 2;
+  let w;
+  let VRe;
+  let VIm;
+  if (A.imag) {
+    const bridge = getEffectiveBridge("eigHerm", "eigHerm");
+    if (!bridge.eigHerm) return null;
+    const r = bridge.eigHerm(toF64(A.data), toF64(A.imag), n, computeV);
+    if (!r) return null;
+    w = r.w;
+    VRe = r.VRe;
+    VIm = r.VIm;
+  } else {
+    const bridge = getEffectiveBridge("eigSym", "eigSym");
+    if (!bridge.eigSym) return null;
+    const r = bridge.eigSym(toF64(A.data), n, computeV);
+    if (!r) return null;
+    w = r.w;
+    VRe = r.V;
+  }
+  if (nargout <= 1) return RTV.tensor(w, [n, 1]);
+  const makeV = () => VRe ? maybeComplexTensor(
+    allocFloat64Array(VRe),
+    [n, n],
+    VIm ? allocFloat64Array(VIm) : void 0
+  ) : RTV.tensor(allocFloat64Array(n * n), [n, n]);
+  const Vout = makeV();
+  const Dout = outputForm === "vector" ? RTV.tensor(allocFloat64Array(w), [n, 1]) : buildDiagMatrix(w, void 0, n);
+  if (nargout === 2) return [Vout, Dout];
+  return [Vout, Dout, makeV()];
+}
 function parseEigOptionsRuntime(args) {
-  let balance = true, outputForm = "matrix";
-  for (let i = 1; i < args.length; i++) {
+  let balance = true, outputForm = "matrix", algorithm = "auto";
+  let B;
+  let first = 1;
+  if (args.length >= 2 && !isStringLikeArg(args[1])) {
+    B = args[1];
+    first = 2;
+  }
+  for (let i = first; i < args.length; i++) {
     const arg = args[i];
-    if (isRuntimeString(arg) || isRuntimeChar(arg)) {
-      const val = parseStringArgLower(arg);
-      if (val === "nobalance") balance = false;
-      else if (val === "balance") balance = true;
-      else if (val === "vector") outputForm = "vector";
-      else if (val === "matrix") outputForm = "matrix";
+    if (!isStringLikeArg(arg))
+      throw new RuntimeError(
+        "eig: option arguments must be character vectors or strings"
+      );
+    const val = parseStringArgLower(arg);
+    if (val === "nobalance") balance = false;
+    else if (val === "balance") balance = true;
+    else if (val === "vector") outputForm = "vector";
+    else if (val === "matrix") outputForm = "matrix";
+    else if (val === "chol" || val === "qz") algorithm = val;
+    else throw new RuntimeError(`eig: unknown option '${val}'`);
+  }
+  if (algorithm !== "auto" && B === void 0)
+    throw new RuntimeError(
+      `eig: the '${algorithm}' algorithm applies only to eig(A, B)`
+    );
+  return { B, balance, outputForm, algorithm };
+}
+function isStringLikeArg(arg) {
+  return isRuntimeString(arg) || isRuntimeChar(arg);
+}
+function toSplitSquare(v, name) {
+  if (isRuntimeNumber(v))
+    return { M: { re: allocFloat64Array([v]), im: null }, n: 1 };
+  if (isRuntimeComplexNumber(v))
+    return {
+      M: { re: allocFloat64Array([v.re]), im: allocFloat64Array([v.im]) },
+      n: 1
+    };
+  let t = v;
+  if (isRuntimeSparseMatrix(t))
+    t = sparseToDense(
+      t
+    );
+  if (!isRuntimeTensor(t))
+    throw new RuntimeError(`eig: ${name} must be a numeric matrix`);
+  const [rows, cols] = tensorSize2D(t);
+  if (rows !== cols)
+    throw new RuntimeError(`eig: ${name} must be a square matrix`);
+  return {
+    M: { re: toF64(t.data), im: t.imag ? toF64(t.imag) : null },
+    n: rows
+  };
+}
+function splitIsHermitian(M, n) {
+  for (let j = 0; j < n; j++) {
+    if (M.im && M.im[j + j * n] !== 0) return false;
+    if (Number.isNaN(M.re[j + j * n])) return false;
+    for (let i = j + 1; i < n; i++) {
+      if (M.re[i + j * n] !== M.re[j + i * n]) return false;
+      if (M.im && M.im[i + j * n] !== -M.im[j + i * n]) return false;
     }
   }
-  return { balance, outputForm };
+  return true;
+}
+function eigGeneralizedApply(Aval, Bval, nargout, outputForm, algorithm) {
+  const { M: A, n } = toSplitSquare(Aval, "A");
+  const { M: B, n: nB } = toSplitSquare(Bval, "B");
+  if (n !== nB) throw new RuntimeError("eig: A and B must be the same size");
+  if (algorithm !== "qz" && splitIsHermitian(A, n) && splitIsHermitian(B, n)) {
+    const R = choleskyFactor(B, n);
+    if (R) return eigSymmetricDefinite(A, R, n, nargout, outputForm);
+    if (algorithm === "chol")
+      throw new RuntimeError(
+        "eig: the 'chol' algorithm requires B to be symmetric positive definite"
+      );
+  }
+  return eigGeneralizedQz(A, B, n, nargout, outputForm);
+}
+function choleskyFactor(B, n) {
+  if (B.im) {
+    const bridge2 = getEffectiveBridge("cholComplex", "cholComplex");
+    if (!bridge2.cholComplex) return null;
+    const r2 = bridge2.cholComplex(B.re, B.im, n, true);
+    if (!r2 || r2.info !== 0) return null;
+    return { re: r2.RRe, im: r2.RIm };
+  }
+  const bridge = getEffectiveBridge("chol", "chol");
+  if (!bridge.chol) return null;
+  const r = bridge.chol(B.re, n, true);
+  if (!r || r.info !== 0) return null;
+  return { re: r.R, im: null };
+}
+function eigSymmetricDefinite(A, R, n, nargout, outputForm) {
+  const complex = !!(A.im || R.im);
+  const Y = solveLeftConjTransposeUpper(R, A, n, complex);
+  const C = solveRightUpper(Y, R, n, complex);
+  symmetrizeInPlace(C, n);
+  const computeV = nargout >= 2;
+  let w;
+  let SRe;
+  let SIm;
+  if (complex) {
+    const bridge = getEffectiveBridge("eigHerm", "eigHerm");
+    if (!bridge.eigHerm)
+      throw new RuntimeError("eig: Hermitian eig bridge not available");
+    const r = bridge.eigHerm(
+      C.re,
+      C.im ?? allocFloat64Array(n * n),
+      n,
+      computeV
+    );
+    w = r.w;
+    SRe = r.VRe;
+    SIm = r.VIm;
+  } else {
+    const bridge = getEffectiveBridge("eigSym", "eigSym");
+    if (!bridge.eigSym)
+      throw new RuntimeError("eig: symmetric eig bridge not available");
+    const r = bridge.eigSym(C.re, n, computeV);
+    w = r.w;
+    SRe = r.V;
+  }
+  if (nargout <= 1) return RTV.tensor(w, [n, 1]);
+  const S = {
+    re: SRe ?? allocFloat64Array(n * n),
+    im: SIm ?? null
+  };
+  const V = SRe ? solveUpper(R, S, n, complex) : S;
+  const makeV = () => maybeComplexTensor(
+    allocFloat64Array(V.re),
+    [n, n],
+    V.im ? allocFloat64Array(V.im) : void 0
+  );
+  const Vout = makeV();
+  const Dout = outputForm === "vector" ? RTV.tensor(allocFloat64Array(w), [n, 1]) : buildDiagMatrix(w, void 0, n);
+  if (nargout === 2) return [Vout, Dout];
+  return [Vout, Dout, makeV()];
+}
+function symmetrizeInPlace(M, n) {
+  for (let j = 0; j < n; j++) {
+    if (M.im) M.im[j + j * n] = 0;
+    for (let i = j + 1; i < n; i++) {
+      const a = (M.re[i + j * n] + M.re[j + i * n]) / 2;
+      M.re[i + j * n] = a;
+      M.re[j + i * n] = a;
+      if (M.im) {
+        const b = (M.im[i + j * n] - M.im[j + i * n]) / 2;
+        M.im[i + j * n] = b;
+        M.im[j + i * n] = -b;
+      }
+    }
+  }
+}
+function solveLeftConjTransposeUpper(R, Bm, n, complex) {
+  const X = {
+    re: allocFloat64Array(n * n),
+    im: complex ? allocFloat64Array(n * n) : null
+  };
+  for (let c = 0; c < n; c++) {
+    for (let i = 0; i < n; i++) {
+      let sr = Bm.re[i + c * n];
+      let si = Bm.im ? Bm.im[i + c * n] : 0;
+      for (let k = 0; k < i; k++) {
+        const lr = R.re[k + i * n];
+        const li = R.im ? -R.im[k + i * n] : 0;
+        const xr = X.re[k + c * n];
+        const xi = X.im ? X.im[k + c * n] : 0;
+        sr -= lr * xr - li * xi;
+        si -= lr * xi + li * xr;
+      }
+      const dr = R.re[i + i * n];
+      const di = R.im ? -R.im[i + i * n] : 0;
+      const [qr2, qi] = complexDivide2(sr, si, dr, di);
+      X.re[i + c * n] = qr2;
+      if (X.im) X.im[i + c * n] = qi;
+    }
+  }
+  return X;
+}
+function solveRightUpper(Y, R, n, complex) {
+  const C = {
+    re: allocFloat64Array(n * n),
+    im: complex ? allocFloat64Array(n * n) : null
+  };
+  for (let j = 0; j < n; j++) {
+    for (let i = 0; i < n; i++) {
+      let sr = Y.re[i + j * n];
+      let si = Y.im ? Y.im[i + j * n] : 0;
+      for (let k = 0; k < j; k++) {
+        const cr = C.re[i + k * n];
+        const ci = C.im ? C.im[i + k * n] : 0;
+        const rr = R.re[k + j * n];
+        const ri = R.im ? R.im[k + j * n] : 0;
+        sr -= cr * rr - ci * ri;
+        si -= cr * ri + ci * rr;
+      }
+      const dr = R.re[j + j * n];
+      const di = R.im ? R.im[j + j * n] : 0;
+      const [qr2, qi] = complexDivide2(sr, si, dr, di);
+      C.re[i + j * n] = qr2;
+      if (C.im) C.im[i + j * n] = qi;
+    }
+  }
+  return C;
+}
+function solveUpper(R, S, n, complex) {
+  const V = {
+    re: allocFloat64Array(n * n),
+    im: complex ? allocFloat64Array(n * n) : null
+  };
+  for (let c = 0; c < n; c++) {
+    for (let i = n - 1; i >= 0; i--) {
+      let sr = S.re[i + c * n];
+      let si = S.im ? S.im[i + c * n] : 0;
+      for (let k = i + 1; k < n; k++) {
+        const rr = R.re[i + k * n];
+        const ri = R.im ? R.im[i + k * n] : 0;
+        const vr = V.re[k + c * n];
+        const vi = V.im ? V.im[k + c * n] : 0;
+        sr -= rr * vr - ri * vi;
+        si -= rr * vi + ri * vr;
+      }
+      const dr = R.re[i + i * n];
+      const di = R.im ? R.im[i + i * n] : 0;
+      const [qr2, qi] = complexDivide2(sr, si, dr, di);
+      V.re[i + c * n] = qr2;
+      if (V.im) V.im[i + c * n] = qi;
+    }
+  }
+  return V;
+}
+function complexDivide2(ar, ai, br, bi) {
+  if (bi === 0) return [ar / br, ai / br];
+  if (Math.abs(br) >= Math.abs(bi)) {
+    const r2 = bi / br;
+    const t2 = br + bi * r2;
+    return [(ar + ai * r2) / t2, (ai - ar * r2) / t2];
+  }
+  const r = br / bi;
+  const t = br * r + bi;
+  return [(ar * r + ai) / t, (ai * r - ar) / t];
+}
+function eigGeneralizedQz(A, B, n, nargout, outputForm) {
+  const computeEigvecs = nargout >= 2;
+  const wr = allocFloat64Array(n);
+  const wi = allocFloat64Array(n);
+  let V = null;
+  let W = null;
+  if (A.im || B.im) {
+    const bridge = getEffectiveBridge("qzComplex", "qzComplex");
+    if (!bridge.qzComplex) throw generalizedUnsupported();
+    const r = bridge.qzComplex(
+      A.re,
+      A.im ?? allocFloat64Array(n * n),
+      B.re,
+      B.im ?? allocFloat64Array(n * n),
+      n,
+      computeEigvecs
+    );
+    if (!r) throw new RuntimeError("eig: complex QZ failed");
+    for (let i = 0; i < n; i++) {
+      const [qr2, qi] = complexDivide2(
+        r.alphaRe[i],
+        r.alphaIm[i],
+        r.betaRe[i],
+        r.betaIm[i]
+      );
+      wr[i] = qr2;
+      wi[i] = qi;
+    }
+    if (computeEigvecs) {
+      if (!r.VRe || !r.VIm || !r.WRe || !r.WIm)
+        throw new RuntimeError(
+          "eig: failed to compute generalized eigenvectors"
+        );
+      V = maybeComplexTensor(
+        allocFloat64Array(r.VRe),
+        [n, n],
+        allocFloat64Array(r.VIm)
+      );
+      W = maybeComplexTensor(
+        allocFloat64Array(r.WRe),
+        [n, n],
+        allocFloat64Array(r.WIm)
+      );
+    }
+  } else {
+    const bridge = getEffectiveBridge("qz", "qz");
+    if (!bridge.qz) throw generalizedUnsupported();
+    const r = bridge.qz(A.re, B.re, n, computeEigvecs);
+    if (!r) throw new RuntimeError("eig: real QZ failed");
+    let hasComplex = false;
+    for (let i = 0; i < n; i++) {
+      const beta = r.beta[i];
+      wr[i] = r.alphar[i] / beta;
+      wi[i] = r.alphai[i] === 0 && beta === 0 ? 0 : r.alphai[i] / beta;
+      if (r.alphai[i] !== 0) hasComplex = true;
+    }
+    if (computeEigvecs) {
+      if (!r.V || !r.W)
+        throw new RuntimeError(
+          "eig: failed to compute generalized eigenvectors"
+        );
+      V = buildEigenvectorMatrix(r.V, r.alphai, n, hasComplex);
+      W = buildEigenvectorMatrix(r.W, r.alphai, n, hasComplex);
+    }
+  }
+  if (nargout <= 1) return maybeComplexTensor(wr, [n, 1], wi);
+  const Dout = outputForm === "vector" ? maybeComplexTensor(wr, [n, 1], wi) : buildDiagMatrix(wr, wi, n);
+  if (nargout === 2) return [V, Dout];
+  return [V, Dout, W];
+}
+function generalizedUnsupported() {
+  return new RuntimeError(
+    "eig: the generalized eigenvalue problem eig(A, B) with a non symmetric-definite pencil requires the native LAPACK addon"
+  );
 }
 registerIBuiltin({
   name: "chol",
@@ -53074,13 +56448,31 @@ registerIBuiltin({
     if (nargout < 0 || nargout > 3 || argTypes.length < 1 || argTypes.length > 3)
       return null;
     if (!isNumericJitType(argTypes[0])) return null;
-    const t = tensorType();
+    const t = argTypes[0].kind === "sparse_matrix" ? SPARSE_TYPE : tensorType();
     const wrapped = (args, n) => withScratch(() => cholApply(args, n));
     if (nargout <= 1) return { outputTypes: [t], apply: wrapped };
     if (nargout === 2) return { outputTypes: [t, NUM], apply: wrapped };
     return { outputTypes: [t, NUM, t], apply: wrapped };
   }
 });
+function sparseCholApply(S, upper, outputForm, nargout) {
+  if (S.m !== S.n) throw new RuntimeError("chol: Matrix must be square.");
+  const n = S.n;
+  const perm = nargout >= 3 ? minimumDegreeOrdering(S) : identityPerm(n);
+  const A = nargout >= 3 ? sparsePermute(S, perm, perm) : S;
+  const res = sparseChol(A);
+  const R = upper ? sparseTranspose(res.L) : res.L;
+  const permOut = () => outputForm === "vector" ? permVectorTensor(perm) : permutationMatrix(invertPerm(perm));
+  if (!res.ok) {
+    if (nargout < 2)
+      throw new RuntimeError("chol: Matrix must be positive definite.");
+    if (nargout >= 3) return [R, RTV.num(res.p), permOut()];
+    return [R, RTV.num(res.p)];
+  }
+  if (nargout >= 3) return [R, RTV.num(0), permOut()];
+  if (nargout === 2) return [R, RTV.num(0)];
+  return R;
+}
 function cholApply(args, nargout) {
   if (args.length < 1)
     throw new RuntimeError("chol requires at least 1 argument");
@@ -53088,10 +56480,9 @@ function cholApply(args, nargout) {
   const inputIsSparse = isRuntimeSparseMatrix(A);
   if (nargout >= 3 && !inputIsSparse)
     throw new RuntimeError("Third output only available for sparse matrices.");
-  if (inputIsSparse)
-    A = sparseToDense(
-      A
-    );
+  const sparseInput = isRuntimeSparseMatrix(A) && !A.pi ? A : null;
+  if (inputIsSparse && !sparseInput)
+    A = sparseToDense(A);
   let triangle = "upper";
   let outputForm = "matrix";
   if (args.length === 2) {
@@ -53110,6 +56501,8 @@ function cholApply(args, nargout) {
     outputForm = form;
   }
   const upper = triangle === "upper";
+  if (sparseInput)
+    return sparseCholApply(sparseInput, upper, outputForm, nargout);
   if (isRuntimeNumber(A)) {
     const val = A;
     if (val <= 0) {
@@ -53527,15 +56920,28 @@ defineBuiltin({
         if (nargout > 1 || argTypes.length !== 2) return null;
         if (!isNumericJitType(argTypes[0]) || !isNumericJitType(argTypes[1]))
           return null;
+        if (argTypes.some((t) => t.kind === "sparse_matrix"))
+          return [
+            {
+              kind: "sparse_matrix",
+              isComplex: argTypes.some(
+                (t) => t.kind === "sparse_matrix" && t.isComplex
+              )
+            }
+          ];
         return [tensorType()];
       },
       apply: (args) => {
         if (args.length !== 2)
           throw new RuntimeError("kron requires 2 arguments");
+        if (isRuntimeSparseMatrix(args[0]) || isRuntimeSparseMatrix(args[1]))
+          return sparseKron(
+            toSparseOperand(args[0], "kron"),
+            toSparseOperand(args[1], "kron")
+          );
         const coerce = (v) => {
           if (isRuntimeNumber(v))
             return RTV.tensor(allocFloat64Array([v]), [1, 1]);
-          if (isRuntimeSparseMatrix(v)) return sparseToDense(v);
           if (isRuntimeTensor(v)) return v;
           throw new RuntimeError("kron: arguments must be numeric");
         };
@@ -59442,130 +62848,6 @@ registerIBuiltin({
   }
 });
 
-// src/numbl-core/helpers/prng.ts
-var _rngState = null;
-var _rngSeed = 0;
-var _bmSpare = null;
-function setRngShuffle() {
-  _rngState = null;
-  _rngSeed = 0;
-  _bmSpare = null;
-}
-function setRngSeed(seed) {
-  _rngSeed = seed;
-}
-function splitmix32(seed) {
-  let s = seed | 0;
-  return () => {
-    s = s + 2654435769 | 0;
-    let z = s;
-    z = Math.imul(z ^ z >>> 16, 2246822507);
-    z = Math.imul(z ^ z >>> 13, 3266489909);
-    return (z ^ z >>> 16) >>> 0;
-  };
-}
-function seedRng(seed) {
-  _bmSpare = null;
-  const sm = splitmix32(seed);
-  _rngState = new Uint32Array([sm(), sm(), sm(), sm()]);
-  if (_rngState[0] === 0 && _rngState[1] === 0 && _rngState[2] === 0 && _rngState[3] === 0) {
-    _rngState[0] = 1;
-  }
-}
-function xoshiro128ss() {
-  const s = _rngState;
-  const result = Math.imul(rotl(Math.imul(s[1], 5), 7), 9) >>> 0;
-  const t = s[1] << 9;
-  s[2] ^= s[0];
-  s[3] ^= s[1];
-  s[1] ^= s[2];
-  s[0] ^= s[3];
-  s[2] ^= t;
-  s[3] = rotl(s[3], 11);
-  return result;
-}
-function rotl(x, k) {
-  return (x << k | x >>> 32 - k) >>> 0;
-}
-function rngRandom() {
-  if (_rngState === null) return Math.random();
-  return (xoshiro128ss() >>> 0) / 4294967296;
-}
-function boxMullerRandom() {
-  if (_bmSpare !== null) {
-    const s2 = _bmSpare;
-    _bmSpare = null;
-    return s2;
-  }
-  let u, v, s;
-  do {
-    u = 2 * rngRandom() - 1;
-    v = 2 * rngRandom() - 1;
-    s = u * u + v * v;
-  } while (s >= 1 || s === 0);
-  const mul = Math.sqrt(-2 * Math.log(s) / s);
-  _bmSpare = v * mul;
-  return u * mul;
-}
-function fillRandn(data) {
-  if (_rngState !== null) {
-    const bridge = getLapackBridge();
-    if (bridge?.fillRandn) {
-      const r = bridge.fillRandn(
-        _rngState,
-        data.length,
-        _bmSpare ?? 0,
-        _bmSpare !== null
-      );
-      _bmSpare = r.hasSpare ? r.spare : null;
-      data.set(r.data);
-      return;
-    }
-  }
-  const n = data.length;
-  let i = 0;
-  if (_bmSpare !== null && i < n) {
-    data[i++] = _bmSpare;
-    _bmSpare = null;
-  }
-  for (; i + 1 < n; i += 2) {
-    let u, v, s;
-    do {
-      u = 2 * rngRandom() - 1;
-      v = 2 * rngRandom() - 1;
-      s = u * u + v * v;
-    } while (s >= 1 || s === 0);
-    const mul = Math.sqrt(-2 * Math.log(s) / s);
-    data[i] = u * mul;
-    data[i + 1] = v * mul;
-  }
-  if (i < n) {
-    data[i] = boxMullerRandom();
-  }
-}
-function getRngStateStruct() {
-  const stateArray = _rngState ? RTV.tensor(allocFloat64Array(Array.from(_rngState).map((v) => v)), [4, 1]) : RTV.tensor(allocFloat64Array(0), [0, 1]);
-  return RTV.struct({
-    Type: RTV.char("twister"),
-    Seed: RTV.num(_rngSeed),
-    State: stateArray
-  });
-}
-function restoreRngState(s) {
-  const seedField = s.fields.get("Seed");
-  const stateField = s.fields.get("State");
-  if (seedField === void 0 || stateField === void 0) {
-    throw new RuntimeError("rng: invalid state structure");
-  }
-  _rngSeed = Math.round(toNumber(seedField));
-  if (isRuntimeTensor(stateField) && stateField.data.length === 4) {
-    _rngState = new Uint32Array(4);
-    for (let i = 0; i < 4; i++) _rngState[i] = stateField.data[i] >>> 0;
-  } else {
-    _rngState = null;
-  }
-}
-
 // src/numbl-core/interpreter/builtins/prng.ts
 function parseShapeArgs3(rawArgs) {
   const args = stripClassNameArgs(rawArgs);
@@ -63315,7 +66597,7 @@ var H = {
   },
   inv: {
     signatures: ["B = inv(A)"],
-    description: "Matrix inverse."
+    description: "Matrix inverse. A sparse A gives a sparse B (computed by sparse LU); prefer A \\ b for solving systems."
   },
   expm: {
     signatures: ["Y = expm(X)"],
@@ -63326,8 +66608,15 @@ var H = {
     description: "Sum of diagonal elements."
   },
   eig: {
-    signatures: ["E = eig(A)", "[V, D] = eig(A)", "[V, D, W] = eig(A)"],
-    description: "Eigenvalues and eigenvectors of square matrix. With three outputs, W contains left eigenvectors."
+    signatures: [
+      "E = eig(A)",
+      "[V, D] = eig(A)",
+      "[V, D, W] = eig(A)",
+      "E = eig(A, B)",
+      "[V, D] = eig(A, B)",
+      "eig(A, ..., 'vector' | 'matrix' | 'nobalance' | 'chol' | 'qz')"
+    ],
+    description: "Eigenvalues and eigenvectors of a square matrix. With three outputs, W contains left eigenvectors. Symmetric (Hermitian) input gives real eigenvalues in ascending order and an orthonormal eigenvector basis. eig(A, B) solves the generalized problem A*v = lambda*B*v; for a symmetric-definite pencil V is normalized so that V'*B*V = I."
   },
   eigs: {
     signatures: [
@@ -63350,8 +66639,15 @@ var H = {
     description: "Singular value decomposition."
   },
   lu: {
-    signatures: ["Y = lu(A)", "[L, U] = lu(A)", "[L, U, P] = lu(A)"],
-    description: "LU factorization. With 2 outputs, L includes the permutation. With 3, P is a permutation matrix."
+    signatures: [
+      "Y = lu(A)",
+      "[L, U] = lu(A)",
+      "[L, U, P] = lu(A)",
+      "[L, U, P] = lu(A, 'vector')",
+      "[L, U, P, Q] = lu(S)",
+      "[L, U, P, Q] = lu(S, thresh)"
+    ],
+    description: "LU factorization. With 2 outputs, L includes the permutation. With 3, P is a permutation matrix (or a row vector with 'vector'). Sparse S returns sparse factors from a left-looking LU with threshold partial pivoting; with 4 outputs, Q is a fill-reducing column permutation and P*S*Q = L*U."
   },
   qr: {
     signatures: [
@@ -63363,8 +66659,14 @@ var H = {
     description: "QR factorization. With 3 outputs, E is a column permutation matrix (or vector in economy mode)."
   },
   chol: {
-    signatures: ["R = chol(A)", "[R, P] = chol(A)"],
-    description: "Cholesky factorization. A must be symmetric positive definite. With 2 outputs, P is 0 on success."
+    signatures: [
+      "R = chol(A)",
+      "L = chol(A, 'lower')",
+      "[R, p] = chol(A)",
+      "[R, p, P] = chol(S)",
+      "[R, p, q] = chol(S, 'vector')"
+    ],
+    description: "Cholesky factorization with R'*R = A, reading only the upper triangle. A must be symmetric positive definite; with 2 outputs, p is 0 on success and otherwise the failing column (no error). Sparse S returns a sparse factor; with 3 outputs, P is a fill-reducing permutation with R'*R = P'*S*P."
   },
   rank: {
     signatures: ["K = rank(A)", "K = rank(A, TOL)"],
@@ -63392,7 +66694,7 @@ var H = {
   },
   kron: {
     signatures: ["K = kron(A, B)"],
-    description: "Kronecker tensor product."
+    description: "Kronecker tensor product. If either operand is sparse, K is sparse with nnz(A)*nnz(B) entries."
   },
   linsolve: {
     signatures: ["X = linsolve(A, B)"],
@@ -64798,7 +68100,7 @@ function getSourceLine(getSource, file, line) {
 }
 
 // src/numbl-core/version.ts
-var NUMBL_VERSION = "0.4.18";
+var NUMBL_VERSION = "0.4.21";
 
 // src/cli-repl.ts
 import { createInterface } from "readline";
@@ -66022,9 +69324,9 @@ function analyzeLoop(stmt) {
   };
 }
 function collectReadsFromSiblings(stmts, startIdx, out) {
-  const sink = /* @__PURE__ */ new Set();
+  const sink2 = /* @__PURE__ */ new Set();
   for (let i = startIdx; i < stmts.length; i++) {
-    walkStmt2(stmts[i], sink, out);
+    walkStmt2(stmts[i], sink2, out);
   }
 }
 function walkStmts(stmts, assigned, referenced) {
@@ -66392,8 +69694,7 @@ var Registry = class {
     const stmt = siblings[i];
     const lowered = tryLower(siblings, i, ctx.interp, this.loweringCache);
     if (lowered === null) {
-      const signal2 = ctx.interp.execStmt(stmt);
-      return { signal: signal2 };
+      return this.interpretFallback(ctx, stmt);
     }
     let bestExec = null;
     let bestData = null;
@@ -66442,8 +69743,25 @@ var Registry = class {
         }
       }
     }
-    const signal = ctx.interp.execStmt(stmt);
-    return { signal };
+    return this.interpretFallback(ctx, stmt);
+  }
+  /** Run one stmt on the AST interpreter.
+   *
+   *  When that stmt is a loop, the interpreter is about to walk its body,
+   *  which invalidates the "an enclosing loop will capture me" assumption
+   *  behind the executors' `loopDepth` gate. `jitDeclinedLoopDepth` records
+   *  that for the duration of the body so nested loops and calls can bid for
+   *  themselves instead of running interpreted all the way down. */
+  interpretFallback(ctx, stmt) {
+    if (stmt.type === "For" || stmt.type === "While") {
+      ctx.interp.jitDeclinedLoopDepth++;
+      try {
+        return { signal: ctx.interp.execStmt(stmt) };
+      } finally {
+        ctx.interp.jitDeclinedLoopDepth--;
+      }
+    }
+    return { signal: ctx.interp.execStmt(stmt) };
   }
   runStmtCandidate(stmt, ctx, executor, data, lowered) {
     const result = this.executeCandidate(ctx, executor, stmt, data, stmt);
@@ -66679,6 +69997,10 @@ __export(interpreterExec_exports, {
 var lastDecline = null;
 function recordJitDecline(d) {
   lastDecline = d;
+  if (typeof process !== "undefined" && process.env?.NUMBL_JIT_LOG) {
+    const at = d.at ? ` [${d.at.file}@${d.at.start}]` : "";
+    console.error(`[jit-decline] ${d.where}${at}: ${d.message}`);
+  }
 }
 function getLastJitDecline() {
   return lastDecline;
@@ -68667,6 +71989,7 @@ function interpretWorkspaceFunction(target, args, nargout) {
           fn = funcDefFromStmt(stmt);
           break;
         }
+        if (stmt.type !== "ClassDef" && stmt.type !== "Import") break;
       }
     }
   }
@@ -69466,6 +72789,17 @@ var Interpreter = class {
    *  interpreter never sees them, so this gate only fires on calls
    *  that genuinely happen at the interpreter level inside a loop. */
   loopDepth = 0;
+  /** @internal Number of those enclosing loops that the JIT *declined*, so
+   *  the interpreter is walking their bodies statement by statement. The
+   *  `loopDepth > 0` gate above assumes an enclosing loop will be compiled
+   *  and will swallow whatever is nested inside it; when that loop was
+   *  declined instead, the assumption is false and everything below it would
+   *  run interpreted however expensive it is. The executors therefore gate on
+   *  `loopDepth > 0 && jitDeclinedLoopDepth === 0`: still no per-iteration JIT
+   *  attempts underneath a loop that is about to be compiled, but a nested
+   *  loop or call under a declined one gets its own chance. Bumped by the
+   *  registry around the interpreter fallback for a loop stmt. */
+  jitDeclinedLoopDepth = 0;
   /** @internal Number of enclosing conditional blocks (`if` / `switch` /
    *  `try`) whose bodies the interpreter is currently executing. Used by
    *  the loop classifier: when a loop is dispatched with `condBlockDepth >
@@ -70871,14 +74205,6 @@ end
     name: "+matlab/+internal/+math/blkdiag.m",
     source: "function B = blkdiag(varargin)\n    B = builtin('blkdiag', varargin{:});\nend\n"
   },
-  {
-    name: "decomposition.m",
-    source: "classdef decomposition\n    properties\n        A\n        checkCondition\n        isIllCond\n    end\n    methods\n        function obj = decomposition(A, varargin)\n            obj.A = A;\n            obj.checkCondition = true;\n            for i = 1:2:length(varargin)\n                if strcmpi(varargin{i}, 'CheckCondition')\n                    obj.checkCondition = varargin{i+1};\n                end\n            end\n            if obj.checkCondition\n                obj.isIllCond = (rcond(A) < eps);\n            else\n                obj.isIllCond = false;\n            end\n        end\n        function x = mldivide(obj, b)\n            x = obj.A \\ b;\n        end\n    end\nend\n"
-  },
-  {
-    name: "isIllConditioned.m",
-    source: "function result = isIllConditioned(dA)\n    result = dA.isIllCond;\nend\n"
-  },
   {
     name: "uihtml.m",
     source: "classdef uihtml < handle\n    %UIHTML Create an HTML UI component (numbl subset).\n    %   H = UIHTML('HTMLSource', HTML) renders the self-contained HTML string\n    %   HTML in the figure pane. An optional leading parent argument (e.g. a\n    %   figure) is accepted and ignored. Supported name-value options:\n    %   HTMLSource, Data, Position.\n    %\n    %   H = UIHTML('HTMLSource', HTML, 'Data', X) also sends X into the page.\n    %   Mirroring MATLAB, X is encoded with jsonencode, parsed in the page with\n    %   JSON.parse, and set on the JavaScript `htmlComponent.Data` object,\n    %   firing any \"DataChanged\" listener registered in the page's\n    %   `function setup(htmlComponent)`. To update the data after construction,\n    %   set H.Data and call show(H) (numbl re-renders the component):\n    %\n    %       h = uihtml('HTMLSource', html, 'Data', struct('n', 1));\n    %       h.Data = struct('n', 2);\n    %       show(h);\n    %\n    %   numbl currently supports HTMLSource given as an HTML markup string (a\n    %   single self-contained document). HTML file paths and supporting files\n    %   are not yet supported.\n    %\n    %   The reverse channel (page -> MATLAB) is supported for the IDE:\n    %   HTMLEventReceivedFcn fires when JS calls\n    %   htmlComponent.sendEventToMATLAB(name,data); inside the callback use\n    %   sendEventToHTMLSource(src,name,data) to send back to the page.\n    %   DataChangedFcn fires when JS sets htmlComponent.Data. Register callbacks\n    %   at construction (name-value) since numbl renders at construction.\n    properties\n        HTMLSource = ''\n        Data = []\n        Position = [100 100 100 100]\n        HTMLEventReceivedFcn = []\n        DataChangedFcn = []\n    end\n    methods\n        function obj = uihtml(varargin)\n            args = varargin;\n            % Ignore an optional leading parent argument (anything that is not\n            % a name-value name string).\n            if numel(args) >= 1 && ~(ischar(args{1}) || isstring(args{1}))\n                args = args(2:end);\n            end\n            for i = 1:2:numel(args) - 1\n                name = args{i};\n                val = args{i + 1};\n                if strcmpi(name, 'HTMLSource')\n                    obj.HTMLSource = val;\n                elseif strcmpi(name, 'Data')\n                    obj.Data = val;\n                elseif strcmpi(name, 'Position')\n                    obj.Position = val;\n                elseif strcmpi(name, 'HTMLEventReceivedFcn')\n                    obj.HTMLEventReceivedFcn = val;\n                elseif strcmpi(name, 'DataChangedFcn')\n                    obj.DataChangedFcn = val;\n                end\n            end\n            render(obj);\n        end\n\n        function show(obj)\n            render(obj);\n        end\n\n        function render(obj)\n            if isempty(obj.HTMLSource)\n                return;\n            end\n            if isempty(obj.Data)\n                id = drawuihtml(obj.HTMLSource);\n            else\n                id = drawuihtml(obj.HTMLSource, jsonencode(obj.Data));\n            end\n            if ~isempty(obj.HTMLEventReceivedFcn)\n                registeruihtmlcallback(id, 'HTMLEventReceived', ...\n                                       obj.HTMLEventReceivedFcn);\n            end\n            if ~isempty(obj.DataChangedFcn)\n                registeruihtmlcallback(id, 'DataChanged', obj.DataChangedFcn);\n            end\n        end\n    end\nend\n"
@@ -72651,8 +75977,12 @@ function mtoc2_cpow(a, b) {
   }
   return cexp2(mtoc2_cmul(b, clog2(a)));
 }
+function nanOnRealAxis(z) {
+  return z.im === 0 && Number.isNaN(z.re);
+}
 function mtoc2_csqrt(z) {
   if (z.im === 0) {
+    if (Number.isNaN(z.re)) return { re: z.re, im: 0 };
     if (z.re >= 0) return { re: Math.sqrt(z.re), im: 0 };
     return { re: 0, im: Math.sqrt(-z.re) };
   }
@@ -72666,14 +75996,17 @@ function mtoc2_cexp(z) {
   return cexp2(z);
 }
 function mtoc2_clog(z) {
+  if (nanOnRealAxis(z)) return { re: z.re, im: 0 };
   return clog2(z);
 }
 function mtoc2_clog2(z) {
+  if (nanOnRealAxis(z)) return { re: z.re, im: 0 };
   const l = clog2(z);
   const lg2 = Math.log(2);
   return { re: l.re / lg2, im: l.im / lg2 };
 }
 function mtoc2_clog10(z) {
+  if (nanOnRealAxis(z)) return { re: z.re, im: 0 };
   const l = clog2(z);
   const lg10 = Math.log(10);
   return { re: l.re / lg10, im: l.im / lg10 };
@@ -75084,7 +78417,7 @@ var JS_SNIPPETS = {
   "warning_fmt.js": '// JS sibling of `warning_fmt.h`. Format the message and write\n// `Warning: <msg>\\n` via `$write`. Matches numbl\n// (`runtime/specialBuiltins.ts:190` \u2014 `rt.output("Warning: " + msg + "\\n")`).\n\n\nfunction mtoc2_warning_fmt(fmt, ...args) {\n  $write("Warning: " + mtoc2_sprintf_format(fmt, args) + "\\n");\n}\n\nfunction mtoc2_warning_fmt_id(_id, fmt, ...args) {\n  // The id is informational \u2014 numbl threads it to lastwarn state,\n  // which mtoc2 doesn\'t expose. Drop it here so the visible output\n  // matches the bare form.\n  $write("Warning: " + mtoc2_sprintf_format(fmt, args) + "\\n");\n}\n',
   "plot_dispatch.js": '// JS sibling of `plot_dispatch.h`. Two delivery modes:\n//\n// 1. Host hook mode (numbl JIT bridge): when the host binds a\n//    `$plotDispatch(name, args)` callback into the emit\'s `$h`\n//    helpers, the helper forwards the raw mtoc2-shaped args to the\n//    host. The host is expected to translate the args into its own\n//    runtime value shape and route them into its plot pipeline\n//    (numbl: `dispatchPlotBuiltin` into `rt.plotInstructions`).\n//\n//    Wire-format encoding is skipped entirely in this mode \u2014 the\n//    host operates in-process and consumes the same value graph the\n//    emitted code already holds.\n//\n// 2. Wire-format mode (standalone AOT / viewer tee): when no host\n//    hook is present, fall back to the RS-prefixed JSON record on\n//    stdout that the launcher splits and forwards. Same shape the C\n//    sibling emits, so a single viewer parses both backends.\n//\n// Wire shape per call (mode 2):\n//   \\x1e mtoc2:plot \\t {"call":"<name>","args":[<arg>, ...]} \\n\n//\n// Arg encoding (per source-level arg):\n//   number \u2192 bare numeric (non-finite \u2192 null, matching the C side\n//            and JSON.stringify\'s natural behavior)\n//   string \u2192 {"kind":"text","data":"<text>"}\n//   char   \u2192 same as string (MATLAB plot semantics don\'t distinguish)\n//   tensor \u2192 {"kind":"tensor","dims":[\u2026],"data":[\u2026]} (column-major\n//            flatten; non-finite as null)\n\nfunction isTensor(v) {\n  return typeof v === "object" && v !== null && v.mtoc2Tag === "tensor";\n}\nfunction isChar(v) {\n  return typeof v === "object" && v !== null && v.mtoc2Tag === "char";\n}\n\nfunction encodeArg(v) {\n  if (typeof v === "number") {\n    return Number.isFinite(v) ? v : null;\n  }\n  if (typeof v === "boolean") return v ? 1 : 0;\n  if (typeof v === "string") return { kind: "text", data: v };\n  if (isChar(v)) return { kind: "text", data: v.value };\n  if (isTensor(v)) {\n    const data = new Array(v.data.length);\n    for (let i = 0; i < v.data.length; i++) {\n      const x = v.data[i];\n      data[i] = Number.isFinite(x) ? x : null;\n    }\n    return { kind: "tensor", dims: v.shape.slice(), data };\n  }\n  // Unknown shape \u2014 pass through. Type-level rejection on the\n  // lowering side keeps complex/struct/class/handle out of here.\n  return String(v);\n}\n\nfunction mtoc2_plot_dispatch(name, ...args) {\n  if (typeof globalThis.$plotDispatch === "function") {\n    globalThis.$plotDispatch(name, args);\n    return;\n  }\n  const record = { call: name, args: args.map(encodeArg) };\n  $write("\\x1emtoc2:plot\\t" + JSON.stringify(record) + "\\n");\n}\n',
   "cdiv.js": "// JS sibling of `cdiv.h`. Scalar complex division matching numbl's\n// signed-Inf-on-zero-divisor behavior via Smith's algorithm. Mirrors\n// the C side so cross-runner output stays byte-for-byte.\n\nfunction mtoc2_cdiv(a, b) {\n  const ar = a.re,\n    ai = a.im;\n  const br = b.re,\n    bi = b.im;\n  // Zero divisor: match the interpreter (helpers/arithmetic.ts) \u2014 0/0 is\n  // NaN, a nonzero numerator yields a signed Inf per component. Smith's\n  // algorithm below would otherwise produce NaN+NaNi here.\n  if (br === 0 && bi === 0) {\n    if (ar === 0 && ai === 0) return { re: NaN, im: 0 };\n    const signedInf = x => (x > 0 ? Infinity : x < 0 ? -Infinity : 0);\n    return { re: signedInf(ar), im: signedInf(ai) };\n  }\n  if (Math.abs(br) >= Math.abs(bi)) {\n    const r = bi / br;\n    const den = br + r * bi;\n    return { re: (ar + ai * r) / den, im: (ai - ar * r) / den };\n  }\n  const r = br / bi;\n  const den = bi + r * br;\n  return { re: (ar * r + ai) / den, im: (ai * r - ar) / den };\n}\n",
-  "cscalar.js": "// JS sibling of `cscalar.h`. JS has no native complex type, so each\n// helper takes and returns `{re, im}` objects. Mirrors the C\n// signatures so emitJs renders calls structurally identical to the\n// C path (just with JS objects instead of `double _Complex`).\n//\n// Division (`mtoc2_cdiv`) lives in `cdiv.js` because it needs\n// Smith's algorithm with signed-zero detection to match numbl\n// byte-for-byte.\n\nfunction mtoc2_cmake(re, im) {\n  return { re, im };\n}\nfunction mtoc2_creal(z) {\n  return z.re;\n}\nfunction mtoc2_cimag(z) {\n  return z.im;\n}\nfunction mtoc2_cadd(a, b) {\n  return { re: a.re + b.re, im: a.im + b.im };\n}\nfunction mtoc2_csub(a, b) {\n  return { re: a.re - b.re, im: a.im - b.im };\n}\nfunction mtoc2_cmul(a, b) {\n  return { re: a.re * b.re - a.im * b.im, im: a.re * b.im + a.im * b.re };\n}\nfunction mtoc2_cneg(z) {\n  return { re: -z.re, im: -z.im };\n}\nfunction mtoc2_cconj(z) {\n  return { re: z.re, im: -z.im };\n}\nfunction mtoc2_cabs(z) {\n  return Math.hypot(z.re, z.im);\n}\nfunction mtoc2_cangle(z) {\n  return Math.atan2(z.im, z.re);\n}\nfunction mtoc2_cnonzero(z) {\n  return z.re !== 0 || z.im !== 0;\n}\nfunction mtoc2_ceq(a, b) {\n  return a.re === b.re && a.im === b.im;\n}\nfunction mtoc2_cne(a, b) {\n  return a.re !== b.re || a.im !== b.im;\n}\n\n// `cpow(a, b) = exp(b * log(a))`. Matches numbl / C99 `cpow` for\n// finite inputs; special zero / pole cases follow the same path\n// the C side picks (exp(NaN) = NaN, etc.).\nfunction clog(z) {\n  // Normalize a -0 real part to +0 so log(-0) (a real -0) gives\n  // -Inf + 0i, not -Inf + \u03C0i \u2014 MATLAB / C99 treat -0 as 0, not as an\n  // approach-from-below negative. atan2's -0 second arg only changes the\n  // result when the first arg is also 0, so this affects nothing else.\n  const reAngle = z.re === 0 ? 0 : z.re;\n  return {\n    re: Math.log(Math.hypot(z.re, z.im)),\n    im: Math.atan2(z.im, reAngle),\n  };\n}\nfunction cexp(z) {\n  const m = Math.exp(z.re);\n  // Real-valued input (im === 0): the imaginary lane is m*sin(0) = 0, but\n  // when m overflows to Inf that becomes Inf*0 = NaN. Return a clean 0\n  // (matches the interpreter's real exp and C99 cexp).\n  if (z.im === 0) return { re: m, im: 0 };\n  return { re: m * Math.cos(z.im), im: m * Math.sin(z.im) };\n}\nfunction mtoc2_cpow(a, b) {\n  // Zero base: match the interpreter's complexPow (helpers/arithmetic.ts)\n  // \u2014 0^0 = 1, a positive real part of the exponent gives 0 (regardless\n  // of the imaginary part), and anything else gives Inf+0i. The old\n  // guard required b.im===0 for the zero case and otherwise returned\n  // NaN+NaNi.\n  if (a.re === 0 && a.im === 0) {\n    if (b.re === 0 && b.im === 0) return { re: 1, im: 0 };\n    if (b.re > 0) return { re: 0, im: 0 };\n    return { re: Infinity, im: 0 };\n  }\n  return cexp(mtoc2_cmul(b, clog(a)));\n}\n\n// Unary math.\nfunction mtoc2_csqrt(z) {\n  // Pure-real input: compute directly. Smith's formula below suffers\n  // catastrophic cancellation/overflow when z.im === 0 \u2014 e.g.\n  // sqrt(-Inf) \u2192 sqrt((Inf + -Inf)/2) = sqrt(NaN) = NaN, and\n  // sqrt(-1e308) \u2192 sqrt((1e308 - -1e308)/2) overflows to Inf instead of\n  // 1e154. Mirror the interpreter's complexSqrt (math.ts) and C's libm\n  // csqrt, both of which special-case the real axis.\n  if (z.im === 0) {\n    if (z.re >= 0) return { re: Math.sqrt(z.re), im: 0 };\n    return { re: 0, im: Math.sqrt(-z.re) };\n  }\n  // Smith's stable formula for hypot * sign.\n  const r = Math.hypot(z.re, z.im);\n  if (r === 0) return { re: 0, im: 0 };\n  const re = Math.sqrt((r + z.re) / 2);\n  const im = (z.im >= 0 ? 1 : -1) * Math.sqrt((r - z.re) / 2);\n  return { re, im };\n}\nfunction mtoc2_cexp(z) {\n  return cexp(z);\n}\nfunction mtoc2_clog(z) {\n  return clog(z);\n}\nfunction mtoc2_clog2(z) {\n  const l = clog(z);\n  const lg2 = Math.log(2);\n  return { re: l.re / lg2, im: l.im / lg2 };\n}\nfunction mtoc2_clog10(z) {\n  const l = clog(z);\n  const lg10 = Math.log(10);\n  return { re: l.re / lg10, im: l.im / lg10 };\n}\nfunction mtoc2_csin(z) {\n  // Guard 0*Inf=NaN on the imaginary axis: for a pure-imaginary input\n  // (sin(z.re)===0), the real lane is 0 and the imaginary lane is\n  // \xB1sinh(im); cosh/sinh overflow to Inf for large |im|, and 0*Inf would\n  // poison the result. C99 csin special-cases this \u2014 match it.\n  const sr = Math.sin(z.re);\n  const cr = Math.cos(z.re);\n  return {\n    re: sr === 0 ? 0 : sr * Math.cosh(z.im),\n    im: cr === 0 ? 0 : cr * Math.sinh(z.im),\n  };\n}\nfunction mtoc2_ccos(z) {\n  const cr = Math.cos(z.re);\n  const sr = Math.sin(z.re);\n  return {\n    re: cr === 0 ? 0 : cr * Math.cosh(z.im),\n    im: sr === 0 ? 0 : -sr * Math.sinh(z.im),\n  };\n}\nfunction mtoc2_ctan(z) {\n  // Double-angle form, matching the interpreter (interpreter/builtins/\n  // math.ts) and C99 ctan. Computing sin(z)/cos(z) with a |cos|^2\n  // denominator loses the (tiny but nonzero) real part and overflows\n  // for large imaginary parts \u2014 e.g. tan(1+200i) collapsed to 1i.\n  const denom = Math.cos(2 * z.re) + Math.cosh(2 * z.im);\n  return { re: Math.sin(2 * z.re) / denom, im: Math.sinh(2 * z.im) / denom };\n}\nfunction mtoc2_catan(z) {\n  // Real-valued input (im === 0): atan is a clean real function. The\n  // complex formula leaves a spurious \xB11e-17i residue (and NaN+NaNi once\n  // 1\xB1iz overflows, e.g. atan(1e300)). Take the real path.\n  if (z.im === 0) return { re: Math.atan(z.re), im: 0 };\n  // atan(z) = (i/2)\xB7log((1 \u2212 iz)/(1 + iz)) \u2014 MATLAB's branch (atan(2i) =\n  // \u22121.5708 + 0.5493i). The C runtime overrides its libc catan (which\n  // uses the opposite +\u03C0/2 Annex-G branch) to match this.\n  const iz = { re: -z.im, im: z.re }; // i*z\n  const num = { re: 1 - iz.re, im: -iz.im }; // 1 - iz\n  const denom = { re: 1 + iz.re, im: iz.im }; // 1 + iz\n  const dd = denom.re * denom.re + denom.im * denom.im;\n  const q = {\n    re: (num.re * denom.re + num.im * denom.im) / dd,\n    im: (num.im * denom.re - num.re * denom.im) / dd,\n  };\n  const l = clog(q);\n  return { re: -l.im / 2, im: l.re / 2 };\n}\n// Hyperbolic sinh/cosh/tanh \u2014 byte-for-byte with the interpreter's\n// complex formulas (interpreter/builtins/math.ts). Real-valued input\n// (im === 0) falls out cleanly: cos(0)=1, sin(0)=0, so the imaginary\n// lane is exactly 0.\nfunction mtoc2_csinh(z) {\n  return {\n    re: Math.sinh(z.re) * Math.cos(z.im),\n    im: Math.cosh(z.re) * Math.sin(z.im),\n  };\n}\nfunction mtoc2_ccosh(z) {\n  return {\n    re: Math.cosh(z.re) * Math.cos(z.im),\n    im: Math.sinh(z.re) * Math.sin(z.im),\n  };\n}\nfunction mtoc2_ctanh(z) {\n  const denom = Math.cosh(2 * z.re) + Math.cos(2 * z.im);\n  return { re: Math.sinh(2 * z.re) / denom, im: Math.sin(2 * z.im) / denom };\n}\nfunction mtoc2_cfloor(z) {\n  return { re: Math.floor(z.re), im: Math.floor(z.im) };\n}\nfunction mtoc2_cceil(z) {\n  return { re: Math.ceil(z.re), im: Math.ceil(z.im) };\n}\nfunction mtoc2_cround(z) {\n  // MATLAB rounds each component half-away-from-zero.\n  const half = x => Math.sign(x) * Math.round(Math.abs(x));\n  return { re: half(z.re), im: half(z.im) };\n}\nfunction mtoc2_cfix(z) {\n  return { re: Math.trunc(z.re), im: Math.trunc(z.im) };\n}\nfunction mtoc2_csign(z) {\n  if (z.re === 0 && z.im === 0) return { re: 0, im: 0 };\n  const m = Math.hypot(z.re, z.im);\n  return { re: z.re / m, im: z.im / m };\n}\n",
+  "cscalar.js": "// JS sibling of `cscalar.h`. JS has no native complex type, so each\n// helper takes and returns `{re, im}` objects. Mirrors the C\n// signatures so emitJs renders calls structurally identical to the\n// C path (just with JS objects instead of `double _Complex`).\n//\n// Division (`mtoc2_cdiv`) lives in `cdiv.js` because it needs\n// Smith's algorithm with signed-zero detection to match numbl\n// byte-for-byte.\n\nfunction mtoc2_cmake(re, im) {\n  return { re, im };\n}\nfunction mtoc2_creal(z) {\n  return z.re;\n}\nfunction mtoc2_cimag(z) {\n  return z.im;\n}\nfunction mtoc2_cadd(a, b) {\n  return { re: a.re + b.re, im: a.im + b.im };\n}\nfunction mtoc2_csub(a, b) {\n  return { re: a.re - b.re, im: a.im - b.im };\n}\nfunction mtoc2_cmul(a, b) {\n  return { re: a.re * b.re - a.im * b.im, im: a.re * b.im + a.im * b.re };\n}\nfunction mtoc2_cneg(z) {\n  return { re: -z.re, im: -z.im };\n}\nfunction mtoc2_cconj(z) {\n  return { re: z.re, im: -z.im };\n}\nfunction mtoc2_cabs(z) {\n  return Math.hypot(z.re, z.im);\n}\nfunction mtoc2_cangle(z) {\n  return Math.atan2(z.im, z.re);\n}\nfunction mtoc2_cnonzero(z) {\n  return z.re !== 0 || z.im !== 0;\n}\nfunction mtoc2_ceq(a, b) {\n  return a.re === b.re && a.im === b.im;\n}\nfunction mtoc2_cne(a, b) {\n  return a.re !== b.re || a.im !== b.im;\n}\n\n// `cpow(a, b) = exp(b * log(a))`. Matches numbl / C99 `cpow` for\n// finite inputs; special zero / pole cases follow the same path\n// the C side picks (exp(NaN) = NaN, etc.).\nfunction clog(z) {\n  // Normalize a -0 real part to +0 so log(-0) (a real -0) gives\n  // -Inf + 0i, not -Inf + \u03C0i \u2014 MATLAB / C99 treat -0 as 0, not as an\n  // approach-from-below negative. atan2's -0 second arg only changes the\n  // result when the first arg is also 0, so this affects nothing else.\n  const reAngle = z.re === 0 ? 0 : z.re;\n  return {\n    re: Math.log(Math.hypot(z.re, z.im)),\n    im: Math.atan2(z.im, reAngle),\n  };\n}\nfunction cexp(z) {\n  const m = Math.exp(z.re);\n  // Real-valued input (im === 0): the imaginary lane is m*sin(0) = 0, but\n  // when m overflows to Inf that becomes Inf*0 = NaN. Return a clean 0\n  // (matches the interpreter's real exp and C99 cexp).\n  if (z.im === 0) return { re: m, im: 0 };\n  return { re: m * Math.cos(z.im), im: m * Math.sin(z.im) };\n}\nfunction mtoc2_cpow(a, b) {\n  // Zero base: match the interpreter's complexPow (helpers/arithmetic.ts)\n  // \u2014 0^0 = 1, a positive real part of the exponent gives 0 (regardless\n  // of the imaginary part), and anything else gives Inf+0i. The old\n  // guard required b.im===0 for the zero case and otherwise returned\n  // NaN+NaNi.\n  if (a.re === 0 && a.im === 0) {\n    if (b.re === 0 && b.im === 0) return { re: 1, im: 0 };\n    if (b.re > 0) return { re: 0, im: 0 };\n    return { re: Infinity, im: 0 };\n  }\n  return cexp(mtoc2_cmul(b, clog(a)));\n}\n\n/** True when `z` is a NaN sitting on the real axis.\n *\n *  These helpers are reached both from genuinely complex arithmetic and from\n *  the *lift* the JIT performs on a real argument whose sign it cannot prove\n *  (`sqrt(x)`, `log(x)`). MATLAB's sqrt(NaN) and log(NaN) are a real NaN, so a\n *  lifted NaN must come back as NaN + 0i and not, say, 0 + NaN i: the lift is\n *  a compilation detail and must not change what `real`, `isreal`,\n *  `jsonencode` or a printed value say. */\nfunction nanOnRealAxis(z) {\n  return z.im === 0 && Number.isNaN(z.re);\n}\n\n// Unary math.\nfunction mtoc2_csqrt(z) {\n  // Pure-real input: compute directly. Smith's formula below suffers\n  // catastrophic cancellation/overflow when z.im === 0 \u2014 e.g.\n  // sqrt(-Inf) \u2192 sqrt((Inf + -Inf)/2) = sqrt(NaN) = NaN, and\n  // sqrt(-1e308) \u2192 sqrt((1e308 - -1e308)/2) overflows to Inf instead of\n  // 1e154. Mirror the interpreter's complexSqrt (math.ts) and C's libm\n  // csqrt, both of which special-case the real axis.\n  if (z.im === 0) {\n    if (Number.isNaN(z.re)) return { re: z.re, im: 0 };\n    if (z.re >= 0) return { re: Math.sqrt(z.re), im: 0 };\n    return { re: 0, im: Math.sqrt(-z.re) };\n  }\n  // Smith's stable formula for hypot * sign.\n  const r = Math.hypot(z.re, z.im);\n  if (r === 0) return { re: 0, im: 0 };\n  const re = Math.sqrt((r + z.re) / 2);\n  const im = (z.im >= 0 ? 1 : -1) * Math.sqrt((r - z.re) / 2);\n  return { re, im };\n}\nfunction mtoc2_cexp(z) {\n  return cexp(z);\n}\nfunction mtoc2_clog(z) {\n  if (nanOnRealAxis(z)) return { re: z.re, im: 0 };\n  return clog(z);\n}\nfunction mtoc2_clog2(z) {\n  if (nanOnRealAxis(z)) return { re: z.re, im: 0 };\n  const l = clog(z);\n  const lg2 = Math.log(2);\n  return { re: l.re / lg2, im: l.im / lg2 };\n}\nfunction mtoc2_clog10(z) {\n  if (nanOnRealAxis(z)) return { re: z.re, im: 0 };\n  const l = clog(z);\n  const lg10 = Math.log(10);\n  return { re: l.re / lg10, im: l.im / lg10 };\n}\nfunction mtoc2_csin(z) {\n  // Guard 0*Inf=NaN on the imaginary axis: for a pure-imaginary input\n  // (sin(z.re)===0), the real lane is 0 and the imaginary lane is\n  // \xB1sinh(im); cosh/sinh overflow to Inf for large |im|, and 0*Inf would\n  // poison the result. C99 csin special-cases this \u2014 match it.\n  const sr = Math.sin(z.re);\n  const cr = Math.cos(z.re);\n  return {\n    re: sr === 0 ? 0 : sr * Math.cosh(z.im),\n    im: cr === 0 ? 0 : cr * Math.sinh(z.im),\n  };\n}\nfunction mtoc2_ccos(z) {\n  const cr = Math.cos(z.re);\n  const sr = Math.sin(z.re);\n  return {\n    re: cr === 0 ? 0 : cr * Math.cosh(z.im),\n    im: sr === 0 ? 0 : -sr * Math.sinh(z.im),\n  };\n}\nfunction mtoc2_ctan(z) {\n  // Double-angle form, matching the interpreter (interpreter/builtins/\n  // math.ts) and C99 ctan. Computing sin(z)/cos(z) with a |cos|^2\n  // denominator loses the (tiny but nonzero) real part and overflows\n  // for large imaginary parts \u2014 e.g. tan(1+200i) collapsed to 1i.\n  const denom = Math.cos(2 * z.re) + Math.cosh(2 * z.im);\n  return { re: Math.sin(2 * z.re) / denom, im: Math.sinh(2 * z.im) / denom };\n}\nfunction mtoc2_catan(z) {\n  // Real-valued input (im === 0): atan is a clean real function. The\n  // complex formula leaves a spurious \xB11e-17i residue (and NaN+NaNi once\n  // 1\xB1iz overflows, e.g. atan(1e300)). Take the real path.\n  if (z.im === 0) return { re: Math.atan(z.re), im: 0 };\n  // atan(z) = (i/2)\xB7log((1 \u2212 iz)/(1 + iz)) \u2014 MATLAB's branch (atan(2i) =\n  // \u22121.5708 + 0.5493i). The C runtime overrides its libc catan (which\n  // uses the opposite +\u03C0/2 Annex-G branch) to match this.\n  const iz = { re: -z.im, im: z.re }; // i*z\n  const num = { re: 1 - iz.re, im: -iz.im }; // 1 - iz\n  const denom = { re: 1 + iz.re, im: iz.im }; // 1 + iz\n  const dd = denom.re * denom.re + denom.im * denom.im;\n  const q = {\n    re: (num.re * denom.re + num.im * denom.im) / dd,\n    im: (num.im * denom.re - num.re * denom.im) / dd,\n  };\n  const l = clog(q);\n  return { re: -l.im / 2, im: l.re / 2 };\n}\n// Hyperbolic sinh/cosh/tanh \u2014 byte-for-byte with the interpreter's\n// complex formulas (interpreter/builtins/math.ts). Real-valued input\n// (im === 0) falls out cleanly: cos(0)=1, sin(0)=0, so the imaginary\n// lane is exactly 0.\nfunction mtoc2_csinh(z) {\n  return {\n    re: Math.sinh(z.re) * Math.cos(z.im),\n    im: Math.cosh(z.re) * Math.sin(z.im),\n  };\n}\nfunction mtoc2_ccosh(z) {\n  return {\n    re: Math.cosh(z.re) * Math.cos(z.im),\n    im: Math.sinh(z.re) * Math.sin(z.im),\n  };\n}\nfunction mtoc2_ctanh(z) {\n  const denom = Math.cosh(2 * z.re) + Math.cos(2 * z.im);\n  return { re: Math.sinh(2 * z.re) / denom, im: Math.sin(2 * z.im) / denom };\n}\nfunction mtoc2_cfloor(z) {\n  return { re: Math.floor(z.re), im: Math.floor(z.im) };\n}\nfunction mtoc2_cceil(z) {\n  return { re: Math.ceil(z.re), im: Math.ceil(z.im) };\n}\nfunction mtoc2_cround(z) {\n  // MATLAB rounds each component half-away-from-zero.\n  const half = x => Math.sign(x) * Math.round(Math.abs(x));\n  return { re: half(z.re), im: half(z.im) };\n}\nfunction mtoc2_cfix(z) {\n  return { re: Math.trunc(z.re), im: Math.trunc(z.im) };\n}\nfunction mtoc2_csign(z) {\n  if (z.re === 0 && z.im === 0) return { re: 0, im: 0 };\n  const m = Math.hypot(z.re, z.im);\n  return { re: z.re / m, im: z.im / m };\n}\n",
   "deep_clone.js": '/* Deep-clone an owned-typed runtime value so a subsequent member /\n * indexed write through one alias doesn\'t leak to others. Mirrors\n * the c-aot per-typedef `_copy` protocol: every Var-RHS Assign /\n * MemberLoad-RHS Assign / function-call arg of an owned type is\n * wrapped through this helper at emit time, so JS-side aliasing\n * stops at the assignment boundary.\n *\n * Recognises the runtime shapes the rest of mtoc2 emits:\n *   - RuntimeTensor (`{mtoc2Tag:"tensor", shape, data, imag?, isLogical?}`)\n *   - RuntimeChar   (`{mtoc2Tag:"char", value}`)\n *   - struct / class / handle / handle-capture objects \u2014 plain JS\n *     objects, optionally with a non-enumerable `mtoc2Class` tag\n *     (class instances) that must survive the clone for method\n *     dispatch\n *\n * Primitives (numbers, booleans, strings, null/undefined) flow\n * through unchanged \u2014 they\'re already value-typed in JS.\n */\n\nfunction mtoc2_deep_clone(v) {\n  if (v === null || typeof v !== "object") return v;\n  if (v.mtoc2Tag === "tensor") {\n    const out = {\n      mtoc2Tag: "tensor",\n      shape: v.shape.slice(),\n      data: v.data.slice(),\n    };\n    if (v.imag !== undefined) out.imag = v.imag.slice();\n    if (v.isLogical) out.isLogical = true;\n    return out;\n  }\n  if (v.mtoc2Tag === "char") {\n    return { mtoc2Tag: "char", value: v.value };\n  }\n  if (v.mtoc2Tag === "cell") {\n    return {\n      mtoc2Tag: "cell",\n      shape: v.shape.slice(),\n      data: v.data.map(mtoc2_deep_clone),\n    };\n  }\n  if (v.mtoc2Handle === true) {\n    // Function handle \u2014 captures are deep-cloned so a later write\n    // through one alias doesn\'t bleed into another handle\'s frozen\n    // capture snapshot.\n    if (v.kind === "named") {\n      return { mtoc2Handle: true, kind: "named", name: v.name };\n    }\n    const captures = {};\n    for (const k of Object.keys(v.captures)) {\n      captures[k] = mtoc2_deep_clone(v.captures[k]);\n    }\n    return {\n      mtoc2Handle: true,\n      kind: "anon",\n      params: v.params,\n      body: v.body,\n      captures,\n    };\n  }\n  // Plain struct / class instance: walk enumerable fields, then\n  // restore the non-enumerable `mtoc2Class` tag if it was present.\n  const out = {};\n  for (const k of Object.keys(v)) {\n    out[k] = mtoc2_deep_clone(v[k]);\n  }\n  const tag = Object.getOwnPropertyDescriptor(v, "mtoc2Class");\n  if (tag !== undefined) {\n    Object.defineProperty(out, "mtoc2Class", {\n      value: tag.value,\n      enumerable: false,\n      writable: false,\n    });\n  }\n  return out;\n}\n',
   "isequal.js": "// JS sibling of `isequal.h`. Same real-numeric equality semantics for\n// the js-aot backend. Tensors carry `shape` / `data` (the JS analogue\n// of the C struct's `dims` / `real`).\n\nfunction mtoc2_isequal_tt(a, b) {\n  if (a.shape.length !== b.shape.length) return 0;\n  let n = 1;\n  for (let i = 0; i < a.shape.length; i++) {\n    if (a.shape[i] !== b.shape[i]) return 0;\n    n *= a.shape[i];\n  }\n  for (let i = 0; i < n; i++) {\n    if (a.data[i] !== b.data[i]) return 0;\n  }\n  return 1;\n}\n\nfunction mtoc2_isequal_st(s, t) {\n  let n = 1;\n  for (let i = 0; i < t.shape.length; i++) n *= t.shape[i];\n  if (n !== 1) return 0;\n  return t.data[0] === s ? 1 : 0;\n}\n",
   "tictoc.js": '// JS sibling of `tictoc.h`. Same "one global timer" semantics. Uses\n// `performance.now()` to match numbl\'s wall-clock source; the output\n// format string mirrors numbl\'s `"Elapsed time is %.6f seconds.\\n"`\n// so the cross-runner\'s masking regex still treats both runtimes as\n// equivalent.\n//\n// Module-scope state for the shared `tic` slot. The codegen path\n// inlines this declaration alongside the helpers; the interpreter\n// imports them as ES exports and the same module-scope `let` is the\n// canonical slot.\n\nlet mtoc2_tic_seconds = 0;\n\nfunction mtoc2_now_seconds() {\n  // `performance.now()` returns milliseconds since some monotonic\n  // epoch; divide for seconds. (Node and browsers both supply it on\n  // `globalThis.performance` as of recent versions.)\n  return performance.now() / 1000;\n}\n\nfunction mtoc2_tic() {\n  mtoc2_tic_seconds = mtoc2_now_seconds();\n  return mtoc2_tic_seconds;\n}\n\nfunction mtoc2_toc() {\n  return mtoc2_now_seconds() - mtoc2_tic_seconds;\n}\n\nfunction mtoc2_toc_handle(start_seconds) {\n  return mtoc2_now_seconds() - start_seconds;\n}\n\nfunction mtoc2_toc_print() {\n  const elapsed = mtoc2_toc();\n  $write(`Elapsed time is ${elapsed.toFixed(6)} seconds.\\n`);\n}\n\nfunction mtoc2_toc_handle_print(start_seconds) {\n  const elapsed = mtoc2_now_seconds() - start_seconds;\n  $write(`Elapsed time is ${elapsed.toFixed(6)} seconds.\\n`);\n}\n',
@@ -80190,7 +83523,7 @@ function cCos(z) {
     im: -Math.sin(z.re) * Math.sinh(z.im)
   };
 }
-function cdiv2(a, b) {
+function cdiv3(a, b) {
   if (Math.abs(b.re) >= Math.abs(b.im)) {
     const r2 = b.im / b.re;
     const den2 = b.re + r2 * b.im;
@@ -80201,7 +83534,7 @@ function cdiv2(a, b) {
   return { re: (a.re * r + a.im) / den, im: (a.im * r - a.re) / den };
 }
 function cTan(z) {
-  return cdiv2(cSin(z), cCos(z));
+  return cdiv3(cSin(z), cCos(z));
 }
 function cSinh(z) {
   return {
@@ -80223,7 +83556,7 @@ function cAtan(z) {
   const iz = { re: -z.im, im: z.re };
   const num = { re: 1 - iz.re, im: -iz.im };
   const den = { re: 1 + iz.re, im: iz.im };
-  const q = cdiv2(num, den);
+  const q = cdiv3(num, den);
   const l = cLog(q);
   return { re: -l.im / 2, im: l.re / 2 };
 }
@@ -87933,6 +91266,24 @@ function lowerMultiAssign(s) {
       );
     }
   }
+  if (target?.kind === "mtoc2UserFunction") {
+    const userBuiltin = this.workspace.getUserBuiltin(target.name);
+    if (!userBuiltin) {
+      throw new UnsupportedConstruct(
+        `internal: workspace resolved '${callName}' to a .mtoc2.js function but no Builtin is loaded`,
+        s.span
+      );
+    }
+    return buildBuiltinMultiAssign.call(
+      this,
+      callName,
+      userBuiltin,
+      anfArgs,
+      argTypes,
+      argHoists,
+      s
+    );
+  }
   if (target?.kind !== "userFunction") {
     throw new UnsupportedConstruct(
       `multi-assign of '${callName}': only user-defined functions can appear on the right of '[...] = ...' (or as a bare multi-output statement)`,
@@ -88468,23 +91819,6 @@ function lowerIndexSliceStore(lvalue, exprAst, span) {
       }
     }
   }
-  if (!isSingleSlot && r.baseTy.kind === "Numeric") {
-    for (let i = 0; i < slots.length; i++) {
-      const slot = slots[i];
-      if (slot.kind !== "Scalar") continue;
-      const dim = r.baseTy.dims[i];
-      const t = slot.expr.ty;
-      const dimKnown = dim !== void 0 && dim.kind === "exact";
-      const valKnown = t.kind === "Numeric" && typeof t.exact === "number";
-      const provablyInBounds = dimKnown && valKnown && Math.round(t.exact) >= 1 && Math.round(t.exact) <= dim.value;
-      if (!provablyInBounds) {
-        throw new UnsupportedConstruct(
-          `indexed write to '${displayName}' at axis ${i + 1}: cannot statically prove the index stays within the tensor's bounds; would auto-grow / OOB in MATLAB, but auto-grow is not modeled in the JIT`,
-          slot.span
-        );
-      }
-    }
-  }
   const rawRhs = this.lowerExpr(exprAst);
   if (!isNumeric2(rawRhs.ty)) {
     throw new TypeError2(
@@ -88800,6 +92134,8 @@ var Lowerer = class {
         return lowerMultiAssign.call(this, s);
       case "If":
         return this.lowerIf(s);
+      case "Switch":
+        return this.lowerSwitch(s);
       case "While":
         return this.lowerWhile(s);
       case "For":
@@ -88891,6 +92227,23 @@ var Lowerer = class {
     return entries;
   }
   lowerExprStmt(s) {
+    if (this.env.get("tic") === void 0 && !this.workspace.isClass("tic")) {
+      const bareTic = s.expr.type === "Ident" && s.expr.name === "tic" || s.expr.type === "FuncCall" && s.expr.name === "tic" && s.expr.args.length === 0;
+      if (bareTic) {
+        return {
+          kind: "ExprStmt",
+          expr: {
+            kind: "Call",
+            cName: "mtoc2_tic",
+            name: "tic",
+            args: [],
+            ty: VOID,
+            span: s.expr.span
+          },
+          span: s.span
+        };
+      }
+    }
     if (this.env.get("toc") === void 0 && !this.workspace.isClass("toc")) {
       if (s.expr.type === "Ident" && s.expr.name === "toc") {
         return {
@@ -89497,6 +92850,125 @@ var Lowerer = class {
       }
     ];
   }
+  /** MATLAB `switch` lowered to the equivalent if/elseif chain.
+   *
+   *  The subject is evaluated once — hoisted to a temp unless it is already a
+   *  plain variable — and each case label becomes an equality test against it:
+   *  `strcmp` for text, `==` for numbers. A `case {a, b}` list is the OR of
+   *  the individual tests. Everything after that is `lowerIf`'s problem, which
+   *  means switch inherits its branch-env merging and cond folding.
+   *
+   *  Declined (leaving the unit to the interpreter, as before this existed):
+   *  a subject that is neither a scalar number nor text, a label whose kind
+   *  does not match the subject's, and an empty `case {}`.
+   */
+  lowerSwitch(s) {
+    const span = s.span;
+    const pre = [];
+    let subject = s.expr;
+    if (!(s.expr.type === "Ident" && this.env.has(s.expr.name))) {
+      const tmp = this.freshTempName();
+      const assign = {
+        type: "Assign",
+        name: tmp,
+        expr: s.expr,
+        suppressed: true,
+        span
+      };
+      const lowered = this.lowerStmt(assign);
+      if (lowered !== null) {
+        if (Array.isArray(lowered)) pre.push(...lowered);
+        else pre.push(lowered);
+      }
+      subject = { type: "Ident", name: tmp, span };
+    }
+    const subjTy = this.env.get(subject.name)?.ty;
+    if (subjTy === void 0) {
+      throw new UnsupportedConstruct(
+        "switch subject is not a value the JIT can type",
+        span
+      );
+    }
+    const subjIsText = subjTy.kind === "Char" || subjTy.kind === "String";
+    const subjIsNum = isScalarRealNumeric(subjTy) || subjTy.kind === "Numeric";
+    if (!subjIsText && !(subjIsNum && isScalar(subjTy))) {
+      throw new UnsupportedConstruct(
+        `switch on a ${typeToString(subjTy)} subject is not supported (scalar numeric or text only)`,
+        span
+      );
+    }
+    const labelIsText = (label) => {
+      if (label.type === "Char" || label.type === "String") return true;
+      if (label.type === "Ident") {
+        const t = this.env.get(label.name)?.ty;
+        return t !== void 0 && (t.kind === "Char" || t.kind === "String");
+      }
+      return false;
+    };
+    const labelCond = (label) => {
+      if (subjIsText) {
+        if (!labelIsText(label)) {
+          throw new UnsupportedConstruct(
+            "switch on text with a non-text case label is not supported",
+            label.span
+          );
+        }
+        return {
+          type: "FuncCall",
+          name: "strcmp",
+          args: [subject, label],
+          span: label.span
+        };
+      }
+      if (labelIsText(label)) {
+        throw new UnsupportedConstruct(
+          "switch on a number with a text case label is not supported",
+          label.span
+        );
+      }
+      return {
+        type: "Binary",
+        left: subject,
+        op: "Equal" /* Equal */,
+        right: label,
+        span: label.span
+      };
+    };
+    const caseCond = (value) => {
+      if (value.type !== "Cell") return labelCond(value);
+      const items = value.rows.flat();
+      if (items.length === 0) {
+        throw new UnsupportedConstruct(
+          "switch with an empty case list is not supported",
+          value.span
+        );
+      }
+      return items.map(labelCond).reduce((acc, c) => ({
+        type: "Binary",
+        left: acc,
+        op: "OrOr" /* OrOr */,
+        right: c,
+        span: value.span
+      }));
+    };
+    if (s.cases.length === 0) {
+      const body = s.otherwise ? this.lowerStmts(s.otherwise) : [];
+      return [...pre, ...body];
+    }
+    const chain = {
+      type: "If",
+      cond: caseCond(s.cases[0].value),
+      thenBody: s.cases[0].body,
+      elseifBlocks: s.cases.slice(1).map((c) => ({
+        cond: caseCond(c.value),
+        body: c.body
+      })),
+      elseBody: s.otherwise,
+      span
+    };
+    const ir = this.lowerIf(chain);
+    return [...pre, ...Array.isArray(ir) ? ir : [ir]];
+  }
   lowerWhile(s) {
     const envBefore = new Map(this.env);
     stripExactFromEnv(this.env, collectAssignedNames(s.body));
@@ -92384,30 +95856,39 @@ function compileSpec(args) {
   const { workspace, lowerer, funcDecl, argTypes, nargout } = args;
   workspace.finalize();
   const widenedArgTypes = argTypes.map(withoutExact);
-  const spec = specializeUserFunction.call(
-    lowerer,
-    funcDecl,
-    widenedArgTypes,
-    void 0,
-    void 0,
-    void 0,
-    nargout,
-    void 0
-  );
-  assertNoNonVoidBareExprStmts(spec);
-  const prog = {
-    topLevelStmts: [],
-    functions: new Map(lowerer.specializations)
-  };
-  const { source, activatedSnippets } = emitJsProgram(prog, {
-    workspace,
-    exposeSpec: spec.cName
-  });
-  return {
-    cName: spec.cName,
-    source,
-    activatedSnippets
-  };
+  const before = new Set(lowerer.specializations.keys());
+  try {
+    const spec = specializeUserFunction.call(
+      lowerer,
+      funcDecl,
+      widenedArgTypes,
+      void 0,
+      void 0,
+      void 0,
+      nargout,
+      void 0
+    );
+    assertNoNonVoidBareExprStmts(spec);
+    const prog = {
+      topLevelStmts: [],
+      functions: new Map(lowerer.specializations)
+    };
+    const { source, activatedSnippets } = emitJsProgram(prog, {
+      workspace,
+      exposeSpec: spec.cName
+    });
+    return {
+      cName: spec.cName,
+      source,
+      activatedSnippets,
+      outputTypes: spec.outputTypes
+    };
+  } catch (err) {
+    for (const key of lowerer.specializations.keys()) {
+      if (!before.has(key)) lowerer.specializations.delete(key);
+    }
+    throw err;
+  }
 }
 function assertNoNonVoidBareExprStmts(spec) {
   const walk2 = (stmts) => {
@@ -94057,7 +97538,7 @@ function emitNdScalarOffset(state, indices, baseCName, grow = false) {
   }
   return terms.join(" + ");
 }
-function emitSliceSlotSetup(state, lines, indent, slotsTyped, baseCName, cleanups) {
+function emitSliceSlotSetup(state, lines, indent, slotsTyped, baseCName, cleanups, grow = false) {
   const slotSrc = [];
   for (let i = 0; i < slotsTyped.length; i++) {
     const slot = slotsTyped[i];
@@ -94066,12 +97547,18 @@ function emitSliceSlotSetup(state, lines, indent, slotsTyped, baseCName, cleanup
       lines.push(`${indent}long _mtoc2_n_${i} = ${baseCName}.dims[${i}];`);
       slotSrc.push(kVar);
     } else if (slot.kind === "Scalar") {
-      useRuntimeByName(state, "mtoc2_oob_abort");
+      const axisFn = grow ? "mtoc2_idx_axis_grow" : "mtoc2_idx_axis";
+      if (grow) {
+        useRuntimeByName(state, "mtoc2_grow_bail");
+        state.usedGrowBail = true;
+      } else {
+        useRuntimeByName(state, "mtoc2_oob_abort");
+      }
       const scalarStr = emitExpr2(slot.expr, state);
       const loc = locStringOf(slot.span);
       lines.push(`${indent}long _mtoc2_n_${i} = 1;`);
       lines.push(
-        `${indent}long _mtoc2_src_${i} = mtoc2_idx_axis(&${baseCName}, ${i}, mtoc2_to_idx(${scalarStr}), ${loc});`
+        `${indent}long _mtoc2_src_${i} = ${axisFn}(&${baseCName}, ${i}, mtoc2_to_idx(${scalarStr}), ${loc});`
       );
       slotSrc.push(`_mtoc2_src_${i}`);
     } else if (slot.kind === "IndexVec") {
@@ -94461,7 +97948,10 @@ function emitIndexSliceStore(s, indent, state) {
     lines,
     `${indent}  `,
     s.index,
-    baseCName
+    baseCName,
+    void 0,
+    /*grow=*/
+    true
   );
   const totalParts = [];
   for (let i = 0; i < ndim; i++) totalParts.push(`_mtoc2_n_${i}`);
@@ -95521,40 +99011,48 @@ function compileSpecC(args) {
   const { workspace, lowerer, funcDecl, argTypes, nargout } = args;
   workspace.finalize();
   const widenedArgTypes = argTypes.map(withoutExact);
-  const spec = specializeUserFunction.call(
-    lowerer,
-    funcDecl,
-    widenedArgTypes,
-    void 0,
-    void 0,
-    void 0,
-    nargout,
-    void 0
-  );
-  assertNoNonVoidBareExprStmts2(spec);
-  const prog = {
-    topLevelStmts: [],
-    functions: new Map(lowerer.specializations)
-  };
-  const checkEntryOutputs = args.entrySynthetic !== true;
-  assertDefiniteAssignment(spec, { checkOutputs: checkEntryOutputs });
-  for (const fn of prog.functions.values()) {
-    if (fn.cName === spec.cName) continue;
-    assertDefiniteAssignment(fn, { checkOutputs: true });
+  const before = new Set(lowerer.specializations.keys());
+  try {
+    const spec = specializeUserFunction.call(
+      lowerer,
+      funcDecl,
+      widenedArgTypes,
+      void 0,
+      void 0,
+      void 0,
+      nargout,
+      void 0
+    );
+    assertNoNonVoidBareExprStmts2(spec);
+    const prog = {
+      topLevelStmts: [],
+      functions: new Map(lowerer.specializations)
+    };
+    const checkEntryOutputs = args.entrySynthetic !== true;
+    assertDefiniteAssignment(spec, { checkOutputs: checkEntryOutputs });
+    for (const fn of prog.functions.values()) {
+      if (fn.cName === spec.cName) continue;
+      assertDefiniteAssignment(fn, { checkOutputs: true });
+    }
+    const source = emitProgram(prog, {
+      workspace,
+      exposeSpec: spec.cName
+    });
+    return {
+      cName: spec.cName,
+      source,
+      // The C emit doesn't currently expose its activated-snippet set
+      // through emitProgram's return; the .so build doesn't need it.
+      // Diagnostic field kept for symmetry with `compileSpec` (JS).
+      activatedSnippets: [],
+      signature: buildSignature(spec)
+    };
+  } catch (err) {
+    for (const key of lowerer.specializations.keys()) {
+      if (!before.has(key)) lowerer.specializations.delete(key);
+    }
+    throw err;
   }
-  const source = emitProgram(prog, {
-    workspace,
-    exposeSpec: spec.cName
-  });
-  return {
-    cName: spec.cName,
-    source,
-    // The C emit doesn't currently expose its activated-snippet set
-    // through emitProgram's return; the .so build doesn't need it.
-    // Diagnostic field kept for symmetry with `compileSpec` (JS).
-    activatedSnippets: [],
-    signature: buildSignature(spec)
-  };
 }
 function buildSignature(spec) {
   const params = spec.cParams.map((cName, i) => ({
@@ -96616,7 +100114,17 @@ function jitTypeToCompilerType(jt) {
     case "char":
       return { kind: "Char" };
     // Kinds the JIT path doesn't accept yet — fall through to interp.
-    case "struct":
+    case "struct": {
+      if (jt.fields === void 0) return null;
+      const names = Object.keys(jt.fields).sort();
+      const fields = [];
+      for (const name of names) {
+        const fty = jitTypeToCompilerType(jt.fields[name]);
+        if (fty === null) return null;
+        fields.push({ name, ty: fty });
+      }
+      return { kind: "Struct", fields };
+    }
     case "struct_array":
     case "class_instance":
     case "sparse_matrix":
@@ -96662,11 +100170,20 @@ function numblToJit(v, paramType) {
   if (isRuntimeComplexNumber(v)) {
     return { re: v.re, im: v.im };
   }
+  if (isRuntimeStruct(v)) {
+    const sty = paramType?.kind === "Struct" ? paramType : void 0;
+    const out = {};
+    for (const [name, fv] of v.fields) {
+      const fty = sty?.fields.find((f) => f.name === name)?.ty;
+      out[name] = numblToJit(fv, fty);
+    }
+    return out;
+  }
   throw new Error(
     `numblToJit: unsupported RuntimeValue (executor should have declined)`
   );
 }
-function jitToNumbl(v) {
+function jitToNumbl(v, retType) {
   if (typeof v === "number") return v;
   if (typeof v === "boolean") return v;
   if (typeof v === "string") return v;
@@ -96689,6 +100206,14 @@ function jitToNumbl(v) {
   if (typeof tagged.re === "number" && typeof tagged.im === "number") {
     return new RuntimeComplexNumber(tagged.re, tagged.im);
   }
+  if (retType?.kind === "Struct") {
+    const fields = /* @__PURE__ */ new Map();
+    for (const f of retType.fields) {
+      const fv = v[f.name];
+      if (fv !== void 0) fields.set(f.name, jitToNumbl(fv, f.ty));
+    }
+    return new RuntimeStruct(fields);
+  }
   throw new Error(`jitToNumbl: unrecognized return shape`);
 }
 function isGrowBail(e) {
@@ -96762,7 +100287,8 @@ var jitCallExecutor = {
   name: "jit-call",
   propose(lowered, ctx) {
     if (lowered.kind !== "call") return null;
-    if (ctx.interp.loopDepth > 0) return null;
+    if (ctx.interp.loopDepth > 0 && ctx.interp.jitDeclinedLoopDepth === 0)
+      return null;
     const classification = lowered.classification;
     if (ctx.interp.optimization === "2" && classification.assertsCJit) {
       return null;
@@ -96794,7 +100320,7 @@ var jitCallExecutor = {
   compile(d, ctx) {
     const { workspace, lowerer } = getOrCreateSession(ctx.interp);
     try {
-      const { source, cName } = compileSpec({
+      const { source, cName, outputTypes } = compileSpec({
         workspace,
         lowerer,
         funcDecl: synthesizeFuncStmt(d.fn),
@@ -96810,12 +100336,13 @@ var jitCallExecutor = {
       );
       const factory = new Function(source)();
       const specFn = factory(buildHostHelpers(interp.rt));
-      return { specFn };
+      return { specFn, outputTypes };
     } catch (e) {
       if (e instanceof UnsupportedConstruct || e instanceof TypeError2) {
         recordJitDecline({
           message: e.message,
           kind: e.constructor.name,
+          at: e.span ? { file: e.span.file, start: e.span.start } : void 0,
           where: "jit-call"
         });
         return null;
@@ -96838,9 +100365,11 @@ var jitCallExecutor = {
             `jit-call: expected array for nargout=${d.nargout}, got ${typeof result}`
           );
         }
-        return { result: result.map((v) => jitToNumbl(v)) };
+        return {
+          result: result.map((v, i) => jitToNumbl(v, compiled.outputTypes[i]))
+        };
       }
-      return { result: jitToNumbl(result) };
+      return { result: jitToNumbl(result, compiled.outputTypes[0]) };
     } catch (e) {
       if (isGrowBail(e)) {
         ctx.interp.onJitBail?.(
@@ -96884,7 +100413,8 @@ var jitLoopExecutor = {
   name: "jit-loop",
   propose(lowered, ctx) {
     if (lowered.kind !== "loop") return null;
-    if (ctx.interp.loopDepth > 0) return null;
+    if (ctx.interp.loopDepth > 0 && ctx.interp.jitDeclinedLoopDepth === 0)
+      return null;
     const classification = lowered.classification;
     if (ctx.interp.optimization === "2" && classification.assertsCJit) {
       return null;
@@ -96926,7 +100456,7 @@ var jitLoopExecutor = {
     );
     const nargout = d.outputs.length;
     try {
-      const { source, cName } = compileSpec({
+      const { source, cName, outputTypes } = compileSpec({
         workspace,
         lowerer,
         funcDecl,
@@ -96941,12 +100471,13 @@ var jitLoopExecutor = {
       );
       const factory = new Function(source)();
       const specFn = factory(buildHostHelpers(interp.rt));
-      return { specFn };
+      return { specFn, outputTypes };
     } catch (e) {
       if (e instanceof UnsupportedConstruct || e instanceof TypeError2) {
         recordJitDecline({
           message: e.message,
           kind: e.constructor.name,
+          at: e.span ? { file: e.span.file, start: e.span.start } : void 0,
           where: "jit-loop"
         });
         return null;
@@ -96971,7 +100502,9 @@ var jitLoopExecutor = {
       if (d.outputs.length === 0) {
       } else if (d.outputs.length === 1) {
         if (result !== void 0) {
-          const rv = ensureRuntimeValue(jitToNumbl(result));
+          const rv = ensureRuntimeValue(
+            jitToNumbl(result, compiled.outputTypes[0])
+          );
           interp.env.set(d.outputs[0], rv);
         }
       } else {
@@ -96983,7 +100516,9 @@ var jitLoopExecutor = {
         for (let i = 0; i < d.outputs.length; i++) {
           const elt = result[i];
           if (elt !== void 0) {
-            const rv = ensureRuntimeValue(jitToNumbl(elt));
+            const rv = ensureRuntimeValue(
+              jitToNumbl(elt, compiled.outputTypes[i])
+            );
             interp.env.set(d.outputs[i], rv);
           }
         }
@@ -97071,7 +100606,7 @@ var jitTopLevelExecutor = {
     );
     const nargout = d.outputs.length;
     try {
-      const { source, cName } = compileSpec({
+      const { source, cName, outputTypes } = compileSpec({
         workspace,
         lowerer,
         funcDecl,
@@ -97086,12 +100621,13 @@ var jitTopLevelExecutor = {
       );
       const factory = new Function(source)();
       const specFn = factory(buildHostHelpers(interp.rt));
-      return { specFn, nargout };
+      return { specFn, nargout, outputTypes };
     } catch (e) {
       if (e instanceof UnsupportedConstruct || e instanceof TypeError2) {
         recordJitDecline({
           message: e.message,
           kind: e.constructor.name,
+          at: e.span ? { file: e.span.file, start: e.span.start } : void 0,
           where: "jit-top-level"
         });
         return null;
@@ -97116,7 +100652,9 @@ var jitTopLevelExecutor = {
       if (d.outputs.length === 0) {
       } else if (d.outputs.length === 1) {
         if (result !== void 0) {
-          const rv = ensureRuntimeValue(jitToNumbl(result));
+          const rv = ensureRuntimeValue(
+            jitToNumbl(result, compiled.outputTypes[0])
+          );
           interp.env.set(d.outputs[0], rv);
         }
       } else {
@@ -97128,7 +100666,9 @@ var jitTopLevelExecutor = {
         for (let i = 0; i < d.outputs.length; i++) {
           const elt = result[i];
           if (elt !== void 0) {
-            const rv = ensureRuntimeValue(jitToNumbl(elt));
+            const rv = ensureRuntimeValue(
+              jitToNumbl(elt, compiled.outputTypes[i])
+            );
             interp.env.set(d.outputs[i], rv);
           }
         }
@@ -99950,7 +103490,7 @@ static void mtoc2__format_walk(mtoc2__writer_fn writer, void *ctx,
   "warning_fmt.h": '/* mtoc2 runtime helper: warning \u2014 write a `Warning: <formatted text>\\n`\n * line to stdout. Matches numbl\'s `warning(...)` shape\n * (numbl/src/numbl-core/runtime/specialBuiltins.ts:190 \u2014 `rt.output("Warning: " + ... + "\\n")`).\n *\n * Two forms:\n *  - `mtoc2_warning_fmt(fmt, nargs, args)` \u2014 bare `warning(fmt, ...)`.\n *  - `mtoc2_warning_fmt_id(id, fmt, nargs, args)` \u2014 id-bearing\n *    `warning(\'id:topic\', fmt, ...)`. The c-aot path ignores the id\n *    (it has no `lastwarn`-style state to update); the JS sibling\n *    matches numbl by including the id only in side-channel state if\n *    we ever add it. For now both forms produce the same prefix.\n *\n * Format engine is shared with sprintf / fprintf \u2014 see format_engine.h.\n */\n\n#include <stdio.h>\n\nstatic void mtoc2__warning_writer(void *ctx, const char *bytes, long len) {\n  (void)ctx;\n  if (len > 0) fwrite(bytes, 1, (size_t)len, stdout);\n}\n\nstatic void mtoc2_warning_fmt(mtoc2_text_view_t fmt, int nargs,\n                              const mtoc2_fprintf_arg_t *args) {\n  fputs("Warning: ", stdout);\n  mtoc2__format_walk(mtoc2__warning_writer, NULL, fmt, nargs, args);\n  fputc(\'\\n\', stdout);\n}\n\nstatic void mtoc2_warning_fmt_id(mtoc2_text_view_t id, mtoc2_text_view_t fmt,\n                                 int nargs, const mtoc2_fprintf_arg_t *args) {\n  (void)id; /* c-aot has no lastwarn state to set */\n  mtoc2_warning_fmt(fmt, nargs, args);\n}\n',
   "plot_dispatch.h": '/* mtoc2 runtime: plot dispatch \u2014 single helper for every plotting\n * builtin (`plot`, `surf`, `imagesc`, `bar`, `figure`, `hold`, \u2026).\n *\n * Numbl handles plotting by accumulating an in-memory "instruction\n * stream" that a separate viewer renders; the CLI never writes plot\n * output to stdout. mtoc2 mirrors that data-shape on the wire: each\n * plotting call emits one line of JSON on stdout, prefixed by the\n * ASCII RS (`\\x1e`) sentinel plus the literal tag `mtoc2:plot\\t`.\n * A launcher / viewer process tees stdout, splits on the prefix,\n * and feeds the records into numbl\'s own plot module \u2014 no C\n * plotting code needed.\n *\n * Why RS as the sentinel: RS (0x1E, "record separator") is a C0\n * control character that practical numeric / text output never\n * contains, so the splitter can identify plot lines purely by\n * prefix without escaping user output. The cross-runner drops\n * these lines globally before the byte-for-byte stdout compare\n * (numbl produces no such lines, so the drop is a no-op there).\n *\n * The wire shape per call is:\n *\n *   \\x1e mtoc2:plot \\t {"call":"<name>","args":[<arg>, ...]} \\n\n *\n * Argument encoding (one element per source-level arg):\n *   double   ->  bare numeric (NaN / \xB1Infinity rendered as `null`,\n *                matching JS `JSON.stringify` behavior so the\n *                viewer round-trips through `JSON.parse`)\n *   text     ->  {"kind":"text","data":"<utf-8 with JSON escapes>"}\n *                (char and string sources both flatten to this \u2014\n *                MATLAB plot semantics don\'t distinguish them)\n *   tensor   ->  {"kind":"tensor","dims":[d1,...,dN],\n *                 "data":[v1, ...]}  (column-major flatten;\n *                 non-finite elements as `null`)\n *\n * Argument transport reuses `mtoc2_fprintf_arg_t` from\n * `format_engine.h` (slot kinds DOUBLE / TEXT / TENSOR). Type-level\n * rejection of unsupported arg kinds (complex / struct / class /\n * handle / Void / Unknown) happens at lowering \u2014 the dispatcher\n * itself never receives them.\n *\n * `fflush(stdout)` after every record makes plots stream live when\n * stdout is piped to a viewer; cost is one syscall per call and\n * negligible compared to user-level disp output.\n */\n\nstatic void mtoc2__plot_emit(const char *s, long n) {\n  if (n > 0) fwrite(s, 1, (size_t)n, stdout);\n}\n\nstatic void mtoc2__plot_emit_cstr(const char *s) {\n  mtoc2__plot_emit(s, (long)strlen(s));\n}\n\nstatic void mtoc2__plot_emit_double(double x) {\n  if (!isfinite(x)) {\n    mtoc2__plot_emit_cstr("null");\n    return;\n  }\n  char buf[32];\n  long n;\n  if (fabs(x) < 1e16 && x == (double)(long long)x) {\n    n = (long)snprintf(buf, sizeof(buf), "%lld", (long long)x);\n  } else {\n    n = (long)snprintf(buf, sizeof(buf), "%.17g", x);\n  }\n  mtoc2__plot_emit(buf, n);\n}\n\nstatic void mtoc2__plot_emit_json_string(const char *data, long len) {\n  fputc(\'"\', stdout);\n  for (long i = 0; i < len; i++) {\n    unsigned char c = (unsigned char)data[i];\n    if (c == \'"\' || c == \'\\\\\') {\n      char esc[2] = { \'\\\\\', (char)c };\n      mtoc2__plot_emit(esc, 2);\n    } else if (c == \'\\n\') {\n      mtoc2__plot_emit("\\\\n", 2);\n    } else if (c == \'\\r\') {\n      mtoc2__plot_emit("\\\\r", 2);\n    } else if (c == \'\\t\') {\n      mtoc2__plot_emit("\\\\t", 2);\n    } else if (c == \'\\b\') {\n      mtoc2__plot_emit("\\\\b", 2);\n    } else if (c == \'\\f\') {\n      mtoc2__plot_emit("\\\\f", 2);\n    } else if (c < 0x20) {\n      char esc[8];\n      long n = (long)snprintf(esc, sizeof(esc), "\\\\u%04x", c);\n      mtoc2__plot_emit(esc, n);\n    } else {\n      /* Bytes \u2265 0x20 (including high-bit UTF-8 continuation) pass\n       * through verbatim; JSON allows raw UTF-8 in string content. */\n      fputc((int)c, stdout);\n    }\n  }\n  fputc(\'"\', stdout);\n}\n\nstatic void mtoc2__plot_emit_arg(const mtoc2_fprintf_arg_t *a) {\n  switch (a->kind) {\n    case MTOC2_FA_DOUBLE:\n      mtoc2__plot_emit_double(a->u.d);\n      return;\n    case MTOC2_FA_TEXT: {\n      mtoc2_text_view_t tv = a->u.t;\n      long n = tv.len > 0 ? tv.len : 0;\n      const char *data = tv.data ? tv.data : "";\n      mtoc2__plot_emit_cstr("{\\"kind\\":\\"text\\",\\"data\\":");\n      mtoc2__plot_emit_json_string(data, n);\n      fputc(\'}\', stdout);\n      return;\n    }\n    case MTOC2_FA_TENSOR: {\n      const mtoc2_tensor_t *t = a->u.tensor;\n      mtoc2__plot_emit_cstr("{\\"kind\\":\\"tensor\\",\\"dims\\":[");\n      long total = 1;\n      for (int k = 0; k < t->ndim; k++) {\n        if (k > 0) fputc(\',\', stdout);\n        char buf[24];\n        long n = (long)snprintf(buf, sizeof(buf), "%ld", (long)t->dims[k]);\n        mtoc2__plot_emit(buf, n);\n        total *= t->dims[k];\n      }\n      mtoc2__plot_emit_cstr("],\\"data\\":[");\n      for (long i = 0; i < total; i++) {\n        if (i > 0) fputc(\',\', stdout);\n        mtoc2__plot_emit_double(t->real[i]);\n      }\n      mtoc2__plot_emit_cstr("]}");\n      return;\n    }\n    default:\n      mtoc2__plot_emit_cstr("null");\n      return;\n  }\n}\n\nstatic void mtoc2_plot_dispatch(const char *name, int nargs,\n                                const mtoc2_fprintf_arg_t *args) {\n  mtoc2__plot_emit_cstr("\\x1emtoc2:plot\\t{\\"call\\":");\n  mtoc2__plot_emit_json_string(name, (long)strlen(name));\n  mtoc2__plot_emit_cstr(",\\"args\\":[");\n  for (int i = 0; i < nargs; i++) {\n    if (i > 0) fputc(\',\', stdout);\n    mtoc2__plot_emit_arg(&args[i]);\n  }\n  mtoc2__plot_emit_cstr("]}\\n");\n  fflush(stdout);\n}\n',
   "cdiv.h": "/* mtoc2 runtime helper: scalar complex division `a / b` matching\n * numbl's signed-Inf-on-zero-divisor behavior.\n *\n * C99's `_Complex` division is unspecified at the signs of NaN /\n * Inf results when the divisor is zero, so divisions like\n * `(1 + 2i) / 0` can disagree between compilers. Numbl uses Smith's\n * algorithm (which factors out the larger-magnitude divisor\n * component) and explicit \xB10 detection to land on the same byte\n * stream regardless of the underlying libc. This helper mirrors\n * that path so cross-runner output stays aligned.\n */\n\n#include <complex.h>\n#include <math.h>\n\nstatic double mtoc2_signed_inf(double x) {\n  return x > 0 ? INFINITY : (x < 0 ? -INFINITY : 0.0);\n}\n\n/* Pack re/im into a complex without the `im * I` trap: `INFINITY * I`\n * is `NaN + INFINITY*i` (0*Inf in the real lane), which would corrupt a\n * signed-Inf result. __builtin_complex (gcc/clang) sets the components\n * directly; CMPLX is the C11 fallback. */\nstatic double _Complex mtoc2_cpack(double re, double im) {\n#if defined(__clang__) || defined(__GNUC__)\n  return __builtin_complex(re, im);\n#else\n  return CMPLX(re, im);\n#endif\n}\n\nstatic double _Complex mtoc2_cdiv(double _Complex a, double _Complex b) {\n  double ar = creal(a), ai = cimag(a);\n  double br = creal(b), bi = cimag(b);\n  /* Zero divisor: match the interpreter (helpers/arithmetic.ts) \u2014 0/0 is\n   * NaN, a nonzero numerator yields a signed Inf per component. Smith's\n   * algorithm below would otherwise produce NaN+NaNi here. */\n  if (br == 0.0 && bi == 0.0) {\n    if (ar == 0.0 && ai == 0.0) return mtoc2_cpack(NAN, 0.0);\n    return mtoc2_cpack(mtoc2_signed_inf(ar), mtoc2_signed_inf(ai));\n  }\n  /* Standard Smith's: pick the scaling that puts the larger-magnitude\n   * divisor component in the denominator. */\n  if (fabs(br) >= fabs(bi)) {\n    double r = bi / br;\n    double den = br + r * bi;\n    return (ar + ai * r) / den + ((ai - ar * r) / den) * I;\n  }\n  double r = br / bi;\n  double den = bi + r * br;\n  return (ar * r + ai) / den + ((ai * r - ar) / den) * I;\n}\n",
-  "cscalar.h": "/* mtoc2 runtime helpers: scalar complex operations as explicit\n * function calls.\n *\n * Every `double _Complex` operation mtoc2 emits into user code routes\n * through one of these helpers instead of relying on C99's operator\n * overloading or the `I` macro. On the C path each is `static inline`\n * and the compiler folds back to the same instructions C99 would have\n * generated. The win is parallelism with the js-aot path: the JS\n * sibling (`cscalar.js`) ships a matching set of helpers that operate\n * on a `{re, im}` JS representation, so user code emitted by `emitJs`\n * uses the same call shape the C emitter would have produced.\n *\n * Division and pow are NOT defined here:\n *   - `mtoc2_cdiv` lives in `cdiv.h` because it needs Smith's\n *     algorithm + signed-zero detection to match numbl byte-for-byte.\n *   - `cpow` is emitted directly today (still a libm call, not an\n *     operator); a `mtoc2_cpow` wrapper lands when the JS side grows\n *     a power helper.\n */\n\n#include <complex.h>\n#include <math.h>\n\nstatic inline double _Complex mtoc2_cmake(double re, double im) {\n  return re + im * I;\n}\nstatic inline double mtoc2_creal(double _Complex z) { return creal(z); }\nstatic inline double mtoc2_cimag(double _Complex z) { return cimag(z); }\nstatic inline double _Complex mtoc2_cadd(double _Complex a, double _Complex b) { return a + b; }\nstatic inline double _Complex mtoc2_csub(double _Complex a, double _Complex b) { return a - b; }\nstatic inline double _Complex mtoc2_cmul(double _Complex a, double _Complex b) { return a * b; }\nstatic inline double _Complex mtoc2_cneg(double _Complex z) { return -z; }\nstatic inline double _Complex mtoc2_cconj(double _Complex z) { return conj(z); }\nstatic inline double mtoc2_cabs(double _Complex z) {\n  return hypot(creal(z), cimag(z));\n}\nstatic inline double mtoc2_cangle(double _Complex z) {\n  return atan2(cimag(z), creal(z));\n}\nstatic inline int mtoc2_cnonzero(double _Complex z) {\n  return creal(z) != 0.0 || cimag(z) != 0.0;\n}\nstatic inline int mtoc2_ceq(double _Complex a, double _Complex b) {\n  return creal(a) == creal(b) && cimag(a) == cimag(b);\n}\nstatic inline int mtoc2_cne(double _Complex a, double _Complex b) {\n  return creal(a) != creal(b) || cimag(a) != cimag(b);\n}\nstatic inline double _Complex mtoc2_cpow(double _Complex a, double _Complex b) {\n  return cpow(a, b);\n}\n\n/* Unary complex math \u2014 `<complex.h>` wrappers + a handful of\n * derived helpers C99 doesn't ship (log2/log10, MATLAB-style\n * componentwise rounding, signum). Same `mtoc2_c*` shape as the\n * core scalar helpers above so the c2js backend can substitute\n * its own `{re, im}` JS implementations.\n *\n * The rounding helpers (floor/ceil/round/fix) match MATLAB by\n * applying the rounding mode to each component independently and\n * returning a complex result; the magnitude is NOT preserved\n * (MATLAB's `floor([1.5 + 1.5i])` returns `1 + 1i`, not the\n * floor of the magnitude).\n *\n * `mtoc2_csign(z)` matches MATLAB: `z/|z|` for nonzero, exactly\n * `0 + 0i` for the zero scalar. */\nstatic inline double _Complex mtoc2_csqrt(double _Complex z) { return csqrt(z); }\nstatic inline double _Complex mtoc2_cexp(double _Complex z) { return cexp(z); }\nstatic inline double _Complex mtoc2_clog(double _Complex z) { return clog(z); }\nstatic inline double _Complex mtoc2_clog2(double _Complex z) {\n  return clog(z) / log(2.0);\n}\nstatic inline double _Complex mtoc2_clog10(double _Complex z) {\n  return clog(z) / log(10.0);\n}\nstatic inline double _Complex mtoc2_csin(double _Complex z) { return csin(z); }\nstatic inline double _Complex mtoc2_ccos(double _Complex z) { return ccos(z); }\nstatic inline double _Complex mtoc2_ctan(double _Complex z) { return ctan(z); }\nstatic inline double _Complex mtoc2_catan(double _Complex z) {\n  /* Real-valued input: clean real atan (no spurious imaginary residue,\n     no Inf/Inf NaN at large |re|). */\n  if (cimag(z) == 0.0) return mtoc2_cmake(atan(creal(z)), 0.0);\n  /* atan(z) = (i/2)*log((1 - iz)/(1 + iz)). MATLAB's branch for a\n     pure-imaginary z with |z| > 1 is -pi/2 + ... (atan(2i) = -1.5708 +\n     0.5493i); libc catan uses the opposite +pi/2 Annex-G branch. Compute\n     the formula here so the C path matches MATLAB and the JS runtime.\n     Normalize a -0 imaginary part of the quotient to +0 (via +0.0) so\n     clog picks the +pi branch \u2014 a -0 would flip it to -pi -> +pi/2. */\n  double _Complex iz = mtoc2_cmake(-cimag(z), creal(z));\n  double _Complex num = mtoc2_cmake(1.0 - creal(iz), -cimag(iz));\n  double _Complex den = mtoc2_cmake(1.0 + creal(iz), cimag(iz));\n  double _Complex q = num / den;\n  double _Complex l = clog(mtoc2_cmake(creal(q), cimag(q) + 0.0));\n  return mtoc2_cmake(-cimag(l) / 2.0, creal(l) / 2.0);\n}\n/* Hyperbolic sinh/cosh/tanh are entire functions (no branch cuts), so\n * C99's csinh/ccosh/ctanh agree with the JS componentwise formulas in\n * `cscalar.js` to within floating-point ULPs everywhere. */\nstatic inline double _Complex mtoc2_csinh(double _Complex z) { return csinh(z); }\nstatic inline double _Complex mtoc2_ccosh(double _Complex z) { return ccosh(z); }\nstatic inline double _Complex mtoc2_ctanh(double _Complex z) { return ctanh(z); }\nstatic inline double _Complex mtoc2_cfloor(double _Complex z) {\n  return floor(creal(z)) + floor(cimag(z)) * I;\n}\nstatic inline double _Complex mtoc2_cceil(double _Complex z) {\n  return ceil(creal(z)) + ceil(cimag(z)) * I;\n}\nstatic inline double _Complex mtoc2_cround(double _Complex z) {\n  return round(creal(z)) + round(cimag(z)) * I;\n}\nstatic inline double _Complex mtoc2_cfix(double _Complex z) {\n  return trunc(creal(z)) + trunc(cimag(z)) * I;\n}\nstatic inline double _Complex mtoc2_csign(double _Complex z) {\n  double re = creal(z), im = cimag(z);\n  if (re == 0.0 && im == 0.0) return 0.0;\n  double m = hypot(re, im);\n  return (re / m) + (im / m) * I;\n}\n",
+  "cscalar.h": "/* mtoc2 runtime helpers: scalar complex operations as explicit\n * function calls.\n *\n * Every `double _Complex` operation mtoc2 emits into user code routes\n * through one of these helpers instead of relying on C99's operator\n * overloading or the `I` macro. On the C path each is `static inline`\n * and the compiler folds back to the same instructions C99 would have\n * generated. The win is parallelism with the js-aot path: the JS\n * sibling (`cscalar.js`) ships a matching set of helpers that operate\n * on a `{re, im}` JS representation, so user code emitted by `emitJs`\n * uses the same call shape the C emitter would have produced.\n *\n * Division and pow are NOT defined here:\n *   - `mtoc2_cdiv` lives in `cdiv.h` because it needs Smith's\n *     algorithm + signed-zero detection to match numbl byte-for-byte.\n *   - `cpow` is emitted directly today (still a libm call, not an\n *     operator); a `mtoc2_cpow` wrapper lands when the JS side grows\n *     a power helper.\n */\n\n#include <complex.h>\n#include <math.h>\n\nstatic inline double _Complex mtoc2_cmake(double re, double im) {\n  return re + im * I;\n}\nstatic inline double mtoc2_creal(double _Complex z) { return creal(z); }\nstatic inline double mtoc2_cimag(double _Complex z) { return cimag(z); }\nstatic inline double _Complex mtoc2_cadd(double _Complex a, double _Complex b) { return a + b; }\nstatic inline double _Complex mtoc2_csub(double _Complex a, double _Complex b) { return a - b; }\nstatic inline double _Complex mtoc2_cmul(double _Complex a, double _Complex b) { return a * b; }\nstatic inline double _Complex mtoc2_cneg(double _Complex z) { return -z; }\nstatic inline double _Complex mtoc2_cconj(double _Complex z) { return conj(z); }\nstatic inline double mtoc2_cabs(double _Complex z) {\n  return hypot(creal(z), cimag(z));\n}\nstatic inline double mtoc2_cangle(double _Complex z) {\n  return atan2(cimag(z), creal(z));\n}\nstatic inline int mtoc2_cnonzero(double _Complex z) {\n  return creal(z) != 0.0 || cimag(z) != 0.0;\n}\nstatic inline int mtoc2_ceq(double _Complex a, double _Complex b) {\n  return creal(a) == creal(b) && cimag(a) == cimag(b);\n}\nstatic inline int mtoc2_cne(double _Complex a, double _Complex b) {\n  return creal(a) != creal(b) || cimag(a) != cimag(b);\n}\nstatic inline double _Complex mtoc2_cpow(double _Complex a, double _Complex b) {\n  return cpow(a, b);\n}\n\n/* Unary complex math \u2014 `<complex.h>` wrappers + a handful of\n * derived helpers C99 doesn't ship (log2/log10, MATLAB-style\n * componentwise rounding, signum). Same `mtoc2_c*` shape as the\n * core scalar helpers above so the c2js backend can substitute\n * its own `{re, im}` JS implementations.\n *\n * The rounding helpers (floor/ceil/round/fix) match MATLAB by\n * applying the rounding mode to each component independently and\n * returning a complex result; the magnitude is NOT preserved\n * (MATLAB's `floor([1.5 + 1.5i])` returns `1 + 1i`, not the\n * floor of the magnitude).\n *\n * `mtoc2_csign(z)` matches MATLAB: `z/|z|` for nonzero, exactly\n * `0 + 0i` for the zero scalar. */\n/* True when z is a NaN on the real axis. The JIT lifts a real argument whose\n * sign it cannot prove onto these complex helpers, and MATLAB's sqrt(NaN) /\n * log(NaN) are a real NaN \u2014 so a lifted NaN must come back as NaN + 0i, not\n * 0 + NaN i. The lift is a compilation detail and must not be observable. */\nstatic inline int mtoc2_nan_on_real_axis(double _Complex z) {\n  return cimag(z) == 0.0 && isnan(creal(z));\n}\nstatic inline double _Complex mtoc2_csqrt(double _Complex z) {\n  if (mtoc2_nan_on_real_axis(z)) return mtoc2_cmake(creal(z), 0.0);\n  return csqrt(z);\n}\nstatic inline double _Complex mtoc2_cexp(double _Complex z) { return cexp(z); }\nstatic inline double _Complex mtoc2_clog(double _Complex z) {\n  if (mtoc2_nan_on_real_axis(z)) return mtoc2_cmake(creal(z), 0.0);\n  return clog(z);\n}\nstatic inline double _Complex mtoc2_clog2(double _Complex z) {\n  if (mtoc2_nan_on_real_axis(z)) return mtoc2_cmake(creal(z), 0.0);\n  return clog(z) / log(2.0);\n}\nstatic inline double _Complex mtoc2_clog10(double _Complex z) {\n  if (mtoc2_nan_on_real_axis(z)) return mtoc2_cmake(creal(z), 0.0);\n  return clog(z) / log(10.0);\n}\nstatic inline double _Complex mtoc2_csin(double _Complex z) { return csin(z); }\nstatic inline double _Complex mtoc2_ccos(double _Complex z) { return ccos(z); }\nstatic inline double _Complex mtoc2_ctan(double _Complex z) { return ctan(z); }\nstatic inline double _Complex mtoc2_catan(double _Complex z) {\n  /* Real-valued input: clean real atan (no spurious imaginary residue,\n     no Inf/Inf NaN at large |re|). */\n  if (cimag(z) == 0.0) return mtoc2_cmake(atan(creal(z)), 0.0);\n  /* atan(z) = (i/2)*log((1 - iz)/(1 + iz)). MATLAB's branch for a\n     pure-imaginary z with |z| > 1 is -pi/2 + ... (atan(2i) = -1.5708 +\n     0.5493i); libc catan uses the opposite +pi/2 Annex-G branch. Compute\n     the formula here so the C path matches MATLAB and the JS runtime.\n     Normalize a -0 imaginary part of the quotient to +0 (via +0.0) so\n     clog picks the +pi branch \u2014 a -0 would flip it to -pi -> +pi/2. */\n  double _Complex iz = mtoc2_cmake(-cimag(z), creal(z));\n  double _Complex num = mtoc2_cmake(1.0 - creal(iz), -cimag(iz));\n  double _Complex den = mtoc2_cmake(1.0 + creal(iz), cimag(iz));\n  double _Complex q = num / den;\n  double _Complex l = clog(mtoc2_cmake(creal(q), cimag(q) + 0.0));\n  return mtoc2_cmake(-cimag(l) / 2.0, creal(l) / 2.0);\n}\n/* Hyperbolic sinh/cosh/tanh are entire functions (no branch cuts), so\n * C99's csinh/ccosh/ctanh agree with the JS componentwise formulas in\n * `cscalar.js` to within floating-point ULPs everywhere. */\nstatic inline double _Complex mtoc2_csinh(double _Complex z) { return csinh(z); }\nstatic inline double _Complex mtoc2_ccosh(double _Complex z) { return ccosh(z); }\nstatic inline double _Complex mtoc2_ctanh(double _Complex z) { return ctanh(z); }\nstatic inline double _Complex mtoc2_cfloor(double _Complex z) {\n  return floor(creal(z)) + floor(cimag(z)) * I;\n}\nstatic inline double _Complex mtoc2_cceil(double _Complex z) {\n  return ceil(creal(z)) + ceil(cimag(z)) * I;\n}\nstatic inline double _Complex mtoc2_cround(double _Complex z) {\n  return round(creal(z)) + round(cimag(z)) * I;\n}\nstatic inline double _Complex mtoc2_cfix(double _Complex z) {\n  return trunc(creal(z)) + trunc(cimag(z)) * I;\n}\nstatic inline double _Complex mtoc2_csign(double _Complex z) {\n  double re = creal(z), im = cimag(z);\n  if (re == 0.0 && im == 0.0) return 0.0;\n  double m = hypot(re, im);\n  return (re / m) + (im / m) * I;\n}\n",
   "deep_clone.h": "/* JS-only snippet (paired with `deep_clone.js`).\n *\n * The C path's owned-value protocol (per-typedef `_copy` helpers\n * generated by `emitNamedTypedef`) provides the equivalent\n * always-copy semantics. This snippet exists only to give the\n * activation system a `.h` sibling for the JS-side\n * `mtoc2_deep_clone` helper; the C body is intentionally empty.\n */\n",
   "isequal.h": "/* mtoc2 runtime helpers for `isequal` over real numeric values.\n *\n * Complex tensors, char / string, struct and cell comparison are\n * handled by the interpreter's `call` hook; the AOT `emitC` rejects\n * those argument combinations with `UnsupportedConstruct`. These two\n * helpers cover the dominant cases: tensor-vs-tensor and\n * scalar-vs-tensor over real data.\n *\n * Equality follows numbl's `valuesEqualSimple` / `tensorsEqual`:\n * same rank, same per-axis extent, element-for-element `==`\n * (so `NaN != NaN`, matching MATLAB / numbl).\n */\n\n/* Two real tensors: equal iff identical shape and data. */\nstatic double mtoc2_isequal_tt(mtoc2_tensor_t a, mtoc2_tensor_t b) {\n  if (a.ndim != b.ndim) return 0.0;\n  long n = 1;\n  for (int i = 0; i < a.ndim; i++) {\n    if (a.dims[i] != b.dims[i]) return 0.0;\n    n *= a.dims[i];\n  }\n  for (long i = 0; i < n; i++) {\n    if (a.real[i] != b.real[i]) return 0.0;\n  }\n  return 1.0;\n}\n\n/* Real scalar vs real tensor: equal iff the tensor holds exactly one\n * element equal to `s` (numbl treats a scalar as a 1\xD71 tensor). */\nstatic double mtoc2_isequal_st(double s, mtoc2_tensor_t t) {\n  long n = 1;\n  for (int i = 0; i < t.ndim; i++) n *= t.dims[i];\n  if (n != 1) return 0.0;\n  return t.real[0] == s ? 1.0 : 0.0;\n}\n",
   "length.h": "/* mtoc runtime helper: MATLAB's `length(t)` on a multi-element tensor.\n *\n * Returns the size of the largest axis as a double, or 0.0 if any axis\n * has length 0. Mirrors MATLAB/numbl semantics. Scalar args don't reach\n * this helper \u2014 codegen emits the literal `1.0` directly because the C\n * arg is a bare `double`, not an `mtoc2_tensor_t`.\n */\n\nstatic double mtoc2_length(mtoc2_tensor_t t) {\n  long max = 0;\n  for (int i = 0; i < t.ndim; i++) {\n    if (t.dims[i] == 0) return 0.0;\n    if (t.dims[i] > max) max = t.dims[i];\n  }\n  return (double)max;\n}\n",
@@ -100487,7 +104027,8 @@ var cJitLoopExecutor = {
     if (lowered.kind !== "loop") return null;
     const bridge = ctx.interp.nativeBridge;
     if (!bridge || !bridge.koffi) return null;
-    if (ctx.interp.loopDepth > 0) return null;
+    if (ctx.interp.loopDepth > 0 && ctx.interp.jitDeclinedLoopDepth === 0)
+      return null;
     const classification = lowered.classification;
     if (classification.hasReturn) return null;
     const compilerInputTypes = [];
@@ -100699,7 +104240,8 @@ var cJitCallExecutor = {
     if (lowered.kind !== "call") return null;
     const bridge = ctx.interp.nativeBridge;
     if (!bridge || !bridge.koffi) return null;
-    if (ctx.interp.loopDepth > 0) return null;
+    if (ctx.interp.loopDepth > 0 && ctx.interp.jitDeclinedLoopDepth === 0)
+      return null;
     const classification = lowered.classification;
     if (classification.nargout === 0) return null;
     const compilerArgTypes = [];
@@ -101230,7 +104772,9 @@ Options (for run and eval):
 
 Environment variables:
   NUMBL_PATH              Extra workspace directories (separated by ${delimiter})
-  NUMBL_NO_NATIVE         If set, do not load the native LAPACK addon`);
+  NUMBL_NO_NATIVE         If set, do not load the native LAPACK addon
+  NUMBL_JIT_LOG           If set, print every JIT decline (executor, source
+                          position, reason) to stderr`);
 }
 function parseOptions(args) {
   const opts = {