numbl 0.4.17 → 0.4.19

package/dist-cli/cli.js

@@ -29489,7 +29489,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 +29505,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 +29517,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 +29533,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 {
@@ -31940,6 +31940,9 @@ var ExpressionParser = class extends ParserBase {
       if (this.peekToken() === 50 /* LParen */ && this.inMatrixExpr && this.pos > 0 && !this.tokensAdjacent(this.pos - 1, this.pos)) {
         break;
       }
+      if (this.peekToken() === 54 /* LBrace */ && this.inMatrixExpr && this.pos > 0 && !this.tokensAdjacent(this.pos - 1, this.pos)) {
+        break;
+      }
       if (this.consume(50 /* LParen */)) {
         const start = expr.span.start;
         const args = [];
@@ -39290,8 +39293,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);
       }
     }
@@ -40198,6 +40202,7 @@ function registerSpecialBuiltins(rt) {
           if (na === 0) {
             rt.output(`Elapsed time is ${elapsed.toFixed(6)} seconds.
 `);
+            return void 0;
           }
           return RTV.num(elapsed);
         }
@@ -64795,7 +64800,7 @@ function getSourceLine(getSource, file, line) {
 }
 
 // src/numbl-core/version.ts
-var NUMBL_VERSION = "0.4.17";
+var NUMBL_VERSION = "0.4.19";
 
 // src/cli-repl.ts
 import { createInterface } from "readline";
@@ -66389,8 +66394,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;
@@ -66439,8 +66443,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);
@@ -66676,6 +66697,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;
@@ -67842,7 +67867,12 @@ function evalLValueBase(base, defaultVal) {
     }
     const indices = this.evalIndicesWithEnd(baseVal, base.indices);
     try {
-      return this.rt.indexCell(baseVal, indices);
+      const result = this.rt.indexCell(baseVal, indices);
+      if (Array.isArray(result)) {
+        if (result.length === 1) return result[0];
+        if (result.length === 0) return defaultVal;
+      }
+      return result;
     } catch {
       return defaultVal;
     }
@@ -68659,6 +68689,7 @@ function interpretWorkspaceFunction(target, args, nargout) {
           fn = funcDefFromStmt(stmt);
           break;
         }
+        if (stmt.type !== "ClassDef" && stmt.type !== "Import") break;
       }
     }
   }
@@ -69458,6 +69489,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 >
@@ -72643,8 +72685,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) };
   }
@@ -72658,14 +72704,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 };
@@ -75076,7 +75125,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',
@@ -87925,6 +87974,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)`,
@@ -88460,23 +88527,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(
@@ -88792,6 +88842,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":
@@ -88883,6 +88935,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 {
@@ -89489,6 +89558,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));
@@ -92376,30 +92564,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) => {
@@ -94049,7 +94246,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];
@@ -94058,12 +94255,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") {
@@ -94453,7 +94656,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}`);
@@ -95513,40 +95719,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) => ({
@@ -96608,7 +96822,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":
@@ -96654,11 +96878,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;
@@ -96681,6 +96914,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) {
@@ -96754,7 +96995,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;
@@ -96786,7 +97028,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),
@@ -96802,12 +97044,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;
@@ -96830,9 +97073,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?.(
@@ -96876,7 +97121,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;
@@ -96918,7 +97164,7 @@ var jitLoopExecutor = {
     );
     const nargout = d.outputs.length;
     try {
-      const { source, cName } = compileSpec({
+      const { source, cName, outputTypes } = compileSpec({
         workspace,
         lowerer,
         funcDecl,
@@ -96933,12 +97179,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;
@@ -96963,7 +97210,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 {
@@ -96975,7 +97224,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);
           }
         }
@@ -97063,7 +97314,7 @@ var jitTopLevelExecutor = {
     );
     const nargout = d.outputs.length;
     try {
-      const { source, cName } = compileSpec({
+      const { source, cName, outputTypes } = compileSpec({
         workspace,
         lowerer,
         funcDecl,
@@ -97078,12 +97329,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;
@@ -97108,7 +97360,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 {
@@ -97120,7 +97374,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);
           }
         }
@@ -99942,7 +100198,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",
@@ -100479,7 +100735,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 = [];
@@ -100691,7 +100948,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 = [];
@@ -101222,7 +101480,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 = {