numbl 0.4.17 → 0.4.19

package/dist-lib/lib.js

@@ -21826,7 +21826,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);
   }
@@ -21842,7 +21842,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;
           }
@@ -21854,7 +21854,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);
@@ -21870,7 +21870,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 {
@@ -30240,6 +30240,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 = [];
@@ -48808,8 +48811,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);
       }
     }
@@ -56863,6 +56867,7 @@ function registerSpecialBuiltins(rt) {
           if (na === 0) {
             rt.output(`Elapsed time is ${elapsed.toFixed(6)} seconds.
 `);
+            return void 0;
           }
           return RTV.num(elapsed);
         }
@@ -65575,8 +65580,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;
@@ -65625,8 +65629,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);
@@ -65862,6 +65883,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;
@@ -67028,7 +67053,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;
     }
@@ -67845,6 +67875,7 @@ function interpretWorkspaceFunction(target, args, nargout) {
           fn = funcDefFromStmt(stmt);
           break;
         }
+        if (stmt.type !== "ClassDef" && stmt.type !== "Import") break;
       }
     }
   }
@@ -68644,6 +68675,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 >
@@ -71829,8 +71871,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) };
   }
@@ -71844,14 +71890,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 };
@@ -74262,7 +74311,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',
@@ -87010,6 +87059,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)`,
@@ -87545,23 +87612,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(
@@ -87877,6 +87927,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":
@@ -87968,6 +88020,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 {
@@ -88574,6 +88643,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));
@@ -91407,30 +91595,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 walk = (stmts) => {
@@ -92481,7 +92678,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":
@@ -92527,11 +92734,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;
@@ -92554,6 +92770,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) {
@@ -92627,7 +92851,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;
@@ -92659,7 +92884,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),
@@ -92675,12 +92900,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;
@@ -92703,9 +92929,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?.(
@@ -92749,7 +92977,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;
@@ -92791,7 +93020,7 @@ var jitLoopExecutor = {
     );
     const nargout = d.outputs.length;
     try {
-      const { source, cName } = compileSpec({
+      const { source, cName, outputTypes } = compileSpec({
         workspace,
         lowerer,
         funcDecl,
@@ -92806,12 +93035,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;
@@ -92836,7 +93066,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 {
@@ -92848,7 +93080,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);
           }
         }
@@ -92936,7 +93170,7 @@ var jitTopLevelExecutor = {
     );
     const nargout = d.outputs.length;
     try {
-      const { source, cName } = compileSpec({
+      const { source, cName, outputTypes } = compileSpec({
         workspace,
         lowerer,
         funcDecl,
@@ -92951,12 +93185,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;
@@ -92981,7 +93216,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 {
@@ -92993,7 +93230,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);
           }
         }