numbl 0.1.4 → 0.1.6

package/dist-lib/lib.js

@@ -64,6 +64,9 @@ var RuntimeError = class extends Error {
    * Format error with location and snippet context.
    */
   toString() {
+    if (this.callStack != null && this.callStack.length > 0) {
+      return this._formatWithCallStack();
+    }
     let result = this.name;
     if (this.file && this.line !== null) {
       result += ` at ${this.file}:${this.line}`;
@@ -78,58 +81,51 @@ var RuntimeError = class extends Error {
       result += `
 ${this.snippet}`;
     }
-    if (this.callStack != null && this.callStack.length > 0) {
-      result += `
-Call stack (most recent call first):`;
-      const N = this.callStack.length;
-      for (let i = N - 1; i >= 0; i--) {
-        const name = this.callStack[i].name;
-        let loc;
-        let frameFile = null;
-        let frameLine = 0;
-        if (i === N - 1) {
-          frameFile = this.file;
-          frameLine = this.line ?? 0;
-          if (frameFile && frameLine > 0) {
-            loc = `${frameFile}:${frameLine}`;
-          } else if (frameLine > 0) {
-            loc = `line ${frameLine}`;
-          } else {
-            loc = "unknown";
-          }
-        } else {
-          const callerFrame = this.callStack[i + 1];
-          frameFile = callerFrame.callerFile;
-          frameLine = callerFrame.callerLine;
-          if (frameFile && frameLine > 0) {
-            loc = `${frameFile}:${frameLine}`;
-          } else if (frameLine > 0) {
-            loc = `line ${frameLine}`;
-          } else {
-            loc = "unknown";
-          }
-        }
-        result += `
-  at ${name} (${loc})`;
-        if (frameFile && frameLine > 0) {
-          const srcLine = this._getSourceLine(frameFile, frameLine);
-          if (srcLine) result += `
-        ${srcLine}`;
-        }
-      }
-      const outermost = this.callStack[0];
-      if (outermost.callerFile && outermost.callerLine > 0) {
-        result += `
-  at ${outermost.callerFile}:${outermost.callerLine}`;
-        const srcLine = this._getSourceLine(
-          outermost.callerFile,
-          outermost.callerLine
-        );
-        if (srcLine) result += `
-        ${srcLine}`;
+    return result;
+  }
+  /** Format error with MATLAB-style call stack. */
+  _formatWithCallStack() {
+    const stack = this.callStack;
+    const N = stack.length;
+    const parts = [];
+    const innerName = stack[N - 1].name;
+    const innerFile = this.file;
+    const innerLine = this.line ?? 0;
+    if (innerFile && innerLine > 0) {
+      parts.push(`Error using ${innerName} (${innerFile}:${innerLine})`);
+    } else if (innerLine > 0) {
+      parts.push(`Error using ${innerName} (line ${innerLine})`);
+    } else {
+      parts.push(`Error using ${innerName}`);
+    }
+    parts.push(this.message);
+    for (let i = N - 2; i >= 0; i--) {
+      const name = stack[i].name;
+      const callerFrame = stack[i + 1];
+      const file = callerFrame.callerFile;
+      const line = callerFrame.callerLine;
+      parts.push("");
+      if (file && line > 0) {
+        parts.push(`Error in ${name} (${file}:${line})`);
+        const srcLine = this._getSourceLine(file, line);
+        if (srcLine) parts.push(`    ${srcLine}`);
+      } else if (line > 0) {
+        parts.push(`Error in ${name} (line ${line})`);
+      } else {
+        parts.push(`Error in ${name}`);
       }
     }
-    return result;
+    const outermost = stack[0];
+    if (outermost.callerFile && outermost.callerLine > 0) {
+      parts.push("");
+      parts.push(`Error in ${outermost.callerFile}:${outermost.callerLine}`);
+      const srcLine = this._getSourceLine(
+        outermost.callerFile,
+        outermost.callerLine
+      );
+      if (srcLine) parts.push(`    ${srcLine}`);
+    }
+    return parts.join("\n");
   }
   /** Look up a single trimmed source line from fileSources. */
   _getSourceLine(file, line) {
@@ -1577,6 +1573,435 @@ function dgetrf(m, n, a, lda, ipiv) {
   return info;
 }
 
+// src/numbl-core/helpers/gmres.ts
+function gmresCore(matvec, precSolve, b, n, restart, tol, maxit, x0) {
+  const x = x0 ? new Float64Array(x0) : new Float64Array(n);
+  if (restart <= 0 || restart > n) restart = n;
+  let r = sub(b, matvec(x), n);
+  if (precSolve) r = precSolve(r);
+  let beta = nrm2(r, n);
+  let normMb;
+  if (precSolve) {
+    normMb = nrm2(precSolve(new Float64Array(b)), n);
+  } else {
+    normMb = nrm2(b, n);
+  }
+  if (normMb === 0) normMb = 1;
+  const resvecList = [beta];
+  if (beta / normMb <= tol) {
+    return {
+      x,
+      flag: 0,
+      relres: beta / normMb,
+      iter: [0, 0],
+      resvec: new Float64Array(resvecList)
+    };
+  }
+  let flag = 1;
+  let outerIter = 0;
+  let innerIter = 0;
+  for (let outer = 1; outer <= maxit; outer++) {
+    outerIter = outer;
+    const V = new Float64Array(n * (restart + 1));
+    for (let i = 0; i < n; i++) V[i] = r[i] / beta;
+    const H2 = new Float64Array((restart + 1) * restart);
+    const cs = new Float64Array(restart);
+    const sn = new Float64Array(restart);
+    const g = new Float64Array(restart + 1);
+    g[0] = beta;
+    let converged = false;
+    for (let j = 0; j < restart; j++) {
+      innerIter = j + 1;
+      let w = matvec(V.subarray(j * n, (j + 1) * n));
+      if (precSolve) w = precSolve(w);
+      const ldh = restart + 1;
+      for (let i = 0; i <= j; i++) {
+        const viOff = i * n;
+        let hij = 0;
+        for (let k = 0; k < n; k++) hij += w[k] * V[viOff + k];
+        H2[i + j * ldh] = hij;
+        for (let k = 0; k < n; k++) w[k] -= hij * V[viOff + k];
+      }
+      const wnorm = nrm2(w, n);
+      H2[j + 1 + j * ldh] = wnorm;
+      if (wnorm > 1e-300) {
+        const vOff = (j + 1) * n;
+        for (let k = 0; k < n; k++) V[vOff + k] = w[k] / wnorm;
+      }
+      for (let i = 0; i < j; i++) {
+        const hi = H2[i + j * ldh];
+        const hi1 = H2[i + 1 + j * ldh];
+        H2[i + j * ldh] = cs[i] * hi + sn[i] * hi1;
+        H2[i + 1 + j * ldh] = -sn[i] * hi + cs[i] * hi1;
+      }
+      const [c, s] = givensRotation(H2[j + j * ldh], H2[j + 1 + j * ldh]);
+      cs[j] = c;
+      sn[j] = s;
+      H2[j + j * ldh] = c * H2[j + j * ldh] + s * H2[j + 1 + j * ldh];
+      H2[j + 1 + j * ldh] = 0;
+      const gj = g[j];
+      g[j] = c * gj;
+      g[j + 1] = -s * gj;
+      const residNorm = Math.abs(g[j + 1]);
+      resvecList.push(residNorm);
+      if (residNorm / normMb <= tol) {
+        const y2 = backSolve(H2, g, j + 1, ldh);
+        for (let k = 0; k < n; k++) {
+          for (let l = 0; l <= j; l++) x[k] += V[k + l * n] * y2[l];
+        }
+        flag = 0;
+        converged = true;
+        break;
+      }
+    }
+    if (converged) break;
+    const y = backSolve(H2, g, restart, restart + 1);
+    for (let k = 0; k < n; k++) {
+      for (let l = 0; l < restart; l++) x[k] += V[k + l * n] * y[l];
+    }
+    r = sub(b, matvec(x), n);
+    if (precSolve) r = precSolve(r);
+    beta = nrm2(r, n);
+    if (beta / normMb <= tol) {
+      flag = 0;
+      innerIter = 0;
+      break;
+    }
+  }
+  let relres;
+  if (flag === 0) {
+    let finalR = sub(b, matvec(x), n);
+    if (precSolve) finalR = precSolve(finalR);
+    relres = nrm2(finalR, n) / normMb;
+  } else {
+    relres = beta / normMb;
+  }
+  return {
+    x,
+    flag,
+    relres,
+    iter: [outerIter, innerIter],
+    resvec: new Float64Array(resvecList)
+  };
+}
+function nrm2(a, n) {
+  let s = 0;
+  for (let i = 0; i < n; i++) s += a[i] * a[i];
+  return Math.sqrt(s);
+}
+function sub(a, b, n) {
+  const r = new Float64Array(n);
+  for (let i = 0; i < n; i++) r[i] = a[i] - b[i];
+  return r;
+}
+function givensRotation(a, b) {
+  if (b === 0) return [1, 0];
+  if (Math.abs(b) > Math.abs(a)) {
+    const t2 = a / b;
+    const s = 1 / Math.sqrt(1 + t2 * t2);
+    return [s * t2, s];
+  }
+  const t = b / a;
+  const c = 1 / Math.sqrt(1 + t * t);
+  return [c, c * t];
+}
+function backSolve(H2, g, m, ldh) {
+  const y = new Float64Array(m);
+  for (let i = 0; i < m; i++) y[i] = g[i];
+  for (let i = m - 1; i >= 0; i--) {
+    for (let j = i + 1; j < m; j++) y[i] -= H2[i + j * ldh] * y[j];
+    y[i] /= H2[i + i * ldh];
+  }
+  return y;
+}
+function gmresCoreComplex(matvec, precSolve, b, n, restart, tol, maxit, x0) {
+  const xRe = x0 ? new Float64Array(x0.re) : new Float64Array(n);
+  const xIm = x0 ? new Float64Array(x0.im) : new Float64Array(n);
+  if (restart <= 0 || restart > n) restart = n;
+  const ax = matvec({ re: xRe, im: xIm });
+  let rRe = new Float64Array(n);
+  let rIm = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    rRe[i] = b.re[i] - ax.re[i];
+    rIm[i] = b.im[i] - ax.im[i];
+  }
+  if (precSolve) {
+    const pr = precSolve({ re: rRe, im: rIm });
+    rRe = new Float64Array(pr.re);
+    rIm = new Float64Array(pr.im);
+  }
+  let beta = cnrm2(rRe, rIm, n);
+  let normMb;
+  if (precSolve) {
+    const mb = precSolve({
+      re: new Float64Array(b.re),
+      im: new Float64Array(b.im)
+    });
+    normMb = cnrm2(mb.re, mb.im, n);
+  } else {
+    normMb = cnrm2(b.re, b.im, n);
+  }
+  if (normMb === 0) normMb = 1;
+  const resvecList = [beta];
+  if (beta / normMb <= tol) {
+    return {
+      x: { re: xRe, im: xIm },
+      flag: 0,
+      relres: beta / normMb,
+      iter: [0, 0],
+      resvec: new Float64Array(resvecList)
+    };
+  }
+  let flag = 1;
+  let outerIter = 0;
+  let innerIter = 0;
+  for (let outer = 1; outer <= maxit; outer++) {
+    outerIter = outer;
+    const VRe = new Float64Array(n * (restart + 1));
+    const VIm = new Float64Array(n * (restart + 1));
+    for (let i = 0; i < n; i++) {
+      VRe[i] = rRe[i] / beta;
+      VIm[i] = rIm[i] / beta;
+    }
+    const ldh = restart + 1;
+    const HRe = new Float64Array(ldh * restart);
+    const HIm = new Float64Array(ldh * restart);
+    const cs = new Float64Array(restart);
+    const snRe = new Float64Array(restart);
+    const snIm = new Float64Array(restart);
+    const gRe = new Float64Array(restart + 1);
+    const gIm = new Float64Array(restart + 1);
+    gRe[0] = beta;
+    let converged = false;
+    for (let j = 0; j < restart; j++) {
+      innerIter = j + 1;
+      const vjOff = j * n;
+      let wRe, wIm;
+      const mv = matvec({
+        re: VRe.subarray(vjOff, vjOff + n),
+        im: VIm.subarray(vjOff, vjOff + n)
+      });
+      wRe = mv.re;
+      wIm = mv.im;
+      if (precSolve) {
+        const pw = precSolve({ re: wRe, im: wIm });
+        wRe = pw.re;
+        wIm = pw.im;
+      }
+      if (wRe.length !== n) wRe = new Float64Array(wRe);
+      if (wIm.length !== n) wIm = new Float64Array(wIm);
+      for (let i = 0; i <= j; i++) {
+        const viOff = i * n;
+        let dRe = 0, dIm = 0;
+        for (let k = 0; k < n; k++) {
+          dRe += VRe[viOff + k] * wRe[k] + VIm[viOff + k] * wIm[k];
+          dIm += VRe[viOff + k] * wIm[k] - VIm[viOff + k] * wRe[k];
+        }
+        HRe[i + j * ldh] = dRe;
+        HIm[i + j * ldh] = dIm;
+        for (let k = 0; k < n; k++) {
+          wRe[k] -= dRe * VRe[viOff + k] - dIm * VIm[viOff + k];
+          wIm[k] -= dRe * VIm[viOff + k] + dIm * VRe[viOff + k];
+        }
+      }
+      const wnorm = cnrm2(wRe, wIm, n);
+      HRe[j + 1 + j * ldh] = wnorm;
+      if (wnorm > 1e-300) {
+        const vOff = (j + 1) * n;
+        for (let k = 0; k < n; k++) {
+          VRe[vOff + k] = wRe[k] / wnorm;
+          VIm[vOff + k] = wIm[k] / wnorm;
+        }
+      }
+      for (let i = 0; i < j; i++) {
+        const c2 = cs[i], sR2 = snRe[i], sI2 = snIm[i];
+        const hiR = HRe[i + j * ldh], hiI = HIm[i + j * ldh];
+        const hi1R = HRe[i + 1 + j * ldh], hi1I = HIm[i + 1 + j * ldh];
+        HRe[i + j * ldh] = c2 * hiR + (sR2 * hi1R - sI2 * hi1I);
+        HIm[i + j * ldh] = c2 * hiI + (sR2 * hi1I + sI2 * hi1R);
+        HRe[i + 1 + j * ldh] = -(sR2 * hiR + sI2 * hiI) + c2 * hi1R;
+        HIm[i + 1 + j * ldh] = -(-sI2 * hiR + sR2 * hiI) + c2 * hi1I;
+      }
+      const aR = HRe[j + j * ldh], aI = HIm[j + j * ldh];
+      const bR2 = HRe[j + 1 + j * ldh], bI2 = HIm[j + 1 + j * ldh];
+      const {
+        c,
+        sRe: sR,
+        sIm: sI,
+        rRe: rrR,
+        rIm: rrI
+      } = complexGivens(aR, aI, bR2, bI2);
+      cs[j] = c;
+      snRe[j] = sR;
+      snIm[j] = sI;
+      HRe[j + j * ldh] = rrR;
+      HIm[j + j * ldh] = rrI;
+      HRe[j + 1 + j * ldh] = 0;
+      HIm[j + 1 + j * ldh] = 0;
+      const gjR = gRe[j], gjI = gIm[j];
+      const gj1R = gRe[j + 1], gj1I = gIm[j + 1];
+      gRe[j] = c * gjR + (sR * gj1R - sI * gj1I);
+      gIm[j] = c * gjI + (sR * gj1I + sI * gj1R);
+      gRe[j + 1] = -(sR * gjR + sI * gjI) + c * gj1R;
+      gIm[j + 1] = -(-sI * gjR + sR * gjI) + c * gj1I;
+      const residNorm = Math.sqrt(
+        gRe[j + 1] * gRe[j + 1] + gIm[j + 1] * gIm[j + 1]
+      );
+      resvecList.push(residNorm);
+      if (residNorm / normMb <= tol) {
+        const { yRe: yRe2, yIm: yIm2 } = complexBackSolve(HRe, HIm, gRe, gIm, j + 1, ldh);
+        for (let k = 0; k < n; k++) {
+          for (let l = 0; l <= j; l++) {
+            xRe[k] += VRe[k + l * n] * yRe2[l] - VIm[k + l * n] * yIm2[l];
+            xIm[k] += VRe[k + l * n] * yIm2[l] + VIm[k + l * n] * yRe2[l];
+          }
+        }
+        flag = 0;
+        converged = true;
+        break;
+      }
+    }
+    if (converged) break;
+    const { yRe, yIm } = complexBackSolve(HRe, HIm, gRe, gIm, restart, ldh);
+    for (let k = 0; k < n; k++) {
+      for (let l = 0; l < restart; l++) {
+        xRe[k] += VRe[k + l * n] * yRe[l] - VIm[k + l * n] * yIm[l];
+        xIm[k] += VRe[k + l * n] * yIm[l] + VIm[k + l * n] * yRe[l];
+      }
+    }
+    const ax2 = matvec({ re: xRe, im: xIm });
+    rRe = new Float64Array(n);
+    rIm = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+      rRe[i] = b.re[i] - ax2.re[i];
+      rIm[i] = b.im[i] - ax2.im[i];
+    }
+    if (precSolve) {
+      const pr = precSolve({ re: rRe, im: rIm });
+      rRe = new Float64Array(pr.re);
+      rIm = new Float64Array(pr.im);
+    }
+    beta = cnrm2(rRe, rIm, n);
+    if (beta / normMb <= tol) {
+      flag = 0;
+      innerIter = 0;
+      break;
+    }
+  }
+  let relres;
+  if (flag === 0) {
+    const ax3 = matvec({ re: xRe, im: xIm });
+    let fRe = new Float64Array(n), fIm = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+      fRe[i] = b.re[i] - ax3.re[i];
+      fIm[i] = b.im[i] - ax3.im[i];
+    }
+    if (precSolve) {
+      const pr = precSolve({ re: fRe, im: fIm });
+      fRe = new Float64Array(pr.re);
+      fIm = new Float64Array(pr.im);
+    }
+    relres = cnrm2(fRe, fIm, n) / normMb;
+  } else {
+    relres = beta / normMb;
+  }
+  return {
+    x: { re: xRe, im: xIm },
+    flag,
+    relres,
+    iter: [outerIter, innerIter],
+    resvec: new Float64Array(resvecList)
+  };
+}
+function cnrm2(re2, im2, n) {
+  let s = 0;
+  for (let i = 0; i < n; i++) s += re2[i] * re2[i] + im2[i] * im2[i];
+  return Math.sqrt(s);
+}
+function complexGivens(aRe, aIm, bRe, bIm) {
+  const absB = Math.sqrt(bRe * bRe + bIm * bIm);
+  if (absB === 0) return { c: 1, sRe: 0, sIm: 0, rRe: aRe, rIm: aIm };
+  const absA = Math.sqrt(aRe * aRe + aIm * aIm);
+  if (absA === 0)
+    return { c: 0, sRe: bRe / absB, sIm: -bIm / absB, rRe: absB, rIm: 0 };
+  const norm = Math.sqrt(absA * absA + absB * absB);
+  const c = absA / norm;
+  const alpRe = aRe / absA, alpIm = aIm / absA;
+  const sRe2 = (alpRe * bRe + alpIm * bIm) / norm;
+  const sIm2 = (alpIm * bRe - alpRe * bIm) / norm;
+  return { c, sRe: sRe2, sIm: sIm2, rRe: alpRe * norm, rIm: alpIm * norm };
+}
+function complexBackSolve(HRe, HIm, gRe, gIm, m, ldh) {
+  const yRe = new Float64Array(m);
+  const yIm = new Float64Array(m);
+  for (let i = 0; i < m; i++) {
+    yRe[i] = gRe[i];
+    yIm[i] = gIm[i];
+  }
+  for (let i = m - 1; i >= 0; i--) {
+    for (let j = i + 1; j < m; j++) {
+      const hR = HRe[i + j * ldh], hI = HIm[i + j * ldh];
+      yRe[i] -= hR * yRe[j] - hI * yIm[j];
+      yIm[i] -= hR * yIm[j] + hI * yRe[j];
+    }
+    const dR = HRe[i + i * ldh], dI = HIm[i + i * ldh];
+    const dAbs2 = dR * dR + dI * dI;
+    const tmpR = yRe[i], tmpI = yIm[i];
+    yRe[i] = (tmpR * dR + tmpI * dI) / dAbs2;
+    yIm[i] = (tmpI * dR - tmpR * dI) / dAbs2;
+  }
+  return { yRe, yIm };
+}
+function complexLuSolveInPlace(n, LURe, LUIm, ipiv, rhsRe, rhsIm) {
+  for (let i = 0; i < n; i++) {
+    const pi = ipiv[i] - 1;
+    if (pi !== i) {
+      let tmp = rhsRe[i];
+      rhsRe[i] = rhsRe[pi];
+      rhsRe[pi] = tmp;
+      tmp = rhsIm[i];
+      rhsIm[i] = rhsIm[pi];
+      rhsIm[pi] = tmp;
+    }
+  }
+  for (let i = 1; i < n; i++) {
+    for (let j = 0; j < i; j++) {
+      const lR = LURe[i + j * n], lI = LUIm[i + j * n];
+      rhsRe[i] -= lR * rhsRe[j] - lI * rhsIm[j];
+      rhsIm[i] -= lR * rhsIm[j] + lI * rhsRe[j];
+    }
+  }
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = i + 1; j < n; j++) {
+      const uR = LURe[i + j * n], uI = LUIm[i + j * n];
+      rhsRe[i] -= uR * rhsRe[j] - uI * rhsIm[j];
+      rhsIm[i] -= uR * rhsIm[j] + uI * rhsRe[j];
+    }
+    const dR = LURe[i + i * n], dI = LUIm[i + i * n];
+    const dAbs2 = dR * dR + dI * dI;
+    const tmpR = rhsRe[i], tmpI = rhsIm[i];
+    rhsRe[i] = (tmpR * dR + tmpI * dI) / dAbs2;
+    rhsIm[i] = (tmpI * dR - tmpR * dI) / dAbs2;
+  }
+}
+function luSolveInPlace(n, LU, ipiv, rhs) {
+  for (let i = 0; i < n; i++) {
+    const pi = ipiv[i] - 1;
+    if (pi !== i) {
+      const tmp = rhs[i];
+      rhs[i] = rhs[pi];
+      rhs[pi] = tmp;
+    }
+  }
+  for (let i = 1; i < n; i++) {
+    for (let j = 0; j < i; j++) rhs[i] -= LU[i + j * n] * rhs[j];
+  }
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = i + 1; j < n; j++) rhs[i] -= LU[i + j * n] * rhs[j];
+    rhs[i] /= LU[i + i * n];
+  }
+}
+
 // src/ts-lapack/src/BLAS/dgemv.ts
 function dgemv(trans, m, n, alpha, a, aOff, lda, x, xOff, incx, beta, y, yOff, incy) {
   const notrans = trans === NOTRANS;
@@ -17138,6 +17563,160 @@ function cholComplex(dataRe, dataIm, n, upper) {
   }
   return { RRe: re2, RIm: im2, info };
 }
+function gmres(A, n, b, restart, tol, maxit, M1, M2, x0) {
+  const matvecFn = (x) => {
+    const y = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+      let s = 0;
+      for (let j = 0; j < n; j++) s += A[i + j * n] * x[j];
+      y[i] = s;
+    }
+    return y;
+  };
+  let precSolveFn = null;
+  if (M1 || M2) {
+    const m1lu = M1 ? new Float64Array(M1) : null;
+    const m1ipiv = M1 ? new Int32Array(n) : null;
+    if (m1lu && m1ipiv) {
+      const info = dgetrf(n, n, m1lu, n, m1ipiv);
+      if (info > 0) throw new Error("gmres: preconditioner M1 is singular");
+    }
+    const m2lu = M2 ? new Float64Array(M2) : null;
+    const m2ipiv = M2 ? new Int32Array(n) : null;
+    if (m2lu && m2ipiv) {
+      const info = dgetrf(n, n, m2lu, n, m2ipiv);
+      if (info > 0) throw new Error("gmres: preconditioner M2 is singular");
+    }
+    precSolveFn = (r) => {
+      const z = new Float64Array(r);
+      if (m1lu && m1ipiv) luSolveInPlace(n, m1lu, m1ipiv, z);
+      if (m2lu && m2ipiv) luSolveInPlace(n, m2lu, m2ipiv, z);
+      return z;
+    };
+  }
+  const result = gmresCore(
+    matvecFn,
+    precSolveFn,
+    b,
+    n,
+    restart,
+    tol,
+    maxit,
+    x0
+  );
+  const iterArr = new Int32Array(2);
+  iterArr[0] = result.iter[0];
+  iterArr[1] = result.iter[1];
+  return {
+    x: result.x,
+    flag: result.flag,
+    relres: result.relres,
+    iter: iterArr,
+    resvec: result.resvec
+  };
+}
+function gmresComplex(ARe, AIm, n, bRe, bIm, restart, tol, maxit, M1Re, M1Im, M2Re, M2Im, x0Re, x0Im) {
+  const matvecFn = (x) => {
+    const yRe = new Float64Array(n);
+    const yIm = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+      let sRe2 = 0, sIm2 = 0;
+      for (let j = 0; j < n; j++) {
+        const aR = ARe[i + j * n], aI = AIm[i + j * n];
+        sRe2 += aR * x.re[j] - aI * x.im[j];
+        sIm2 += aR * x.im[j] + aI * x.re[j];
+      }
+      yRe[i] = sRe2;
+      yIm[i] = sIm2;
+    }
+    return { re: yRe, im: yIm };
+  };
+  let precSolveFn = null;
+  if (M1Re || M2Re) {
+    const m1luRe = M1Re ? new Float64Array(M1Re) : null;
+    const m1luIm = M1Im ? new Float64Array(M1Im) : null;
+    const m1ipiv = M1Re ? new Int32Array(n) : null;
+    if (m1luRe && m1luIm && m1ipiv) {
+      complexLuFactor(n, m1luRe, m1luIm, m1ipiv);
+    }
+    const m2luRe = M2Re ? new Float64Array(M2Re) : null;
+    const m2luIm = M2Im ? new Float64Array(M2Im) : null;
+    const m2ipiv = M2Re ? new Int32Array(n) : null;
+    if (m2luRe && m2luIm && m2ipiv) {
+      complexLuFactor(n, m2luRe, m2luIm, m2ipiv);
+    }
+    precSolveFn = (r) => {
+      const zRe = new Float64Array(r.re);
+      const zIm = new Float64Array(r.im);
+      if (m1luRe && m1luIm && m1ipiv)
+        complexLuSolveInPlace(n, m1luRe, m1luIm, m1ipiv, zRe, zIm);
+      if (m2luRe && m2luIm && m2ipiv)
+        complexLuSolveInPlace(n, m2luRe, m2luIm, m2ipiv, zRe, zIm);
+      return { re: zRe, im: zIm };
+    };
+  }
+  const result = gmresCoreComplex(
+    matvecFn,
+    precSolveFn,
+    { re: bRe, im: bIm },
+    n,
+    restart,
+    tol,
+    maxit,
+    x0Re && x0Im ? { re: x0Re, im: x0Im } : null
+  );
+  const iterArr = new Int32Array(2);
+  iterArr[0] = result.iter[0];
+  iterArr[1] = result.iter[1];
+  return {
+    xRe: result.x.re,
+    xIm: result.x.im,
+    flag: result.flag,
+    relres: result.relres,
+    iter: iterArr,
+    resvec: result.resvec
+  };
+}
+function complexLuFactor(n, re2, im2, ipiv) {
+  for (let k = 0; k < n; k++) {
+    let maxVal = -1;
+    let maxIdx = k;
+    for (let i = k; i < n; i++) {
+      const v = Math.sqrt(
+        re2[i + k * n] * re2[i + k * n] + im2[i + k * n] * im2[i + k * n]
+      );
+      if (v > maxVal) {
+        maxVal = v;
+        maxIdx = i;
+      }
+    }
+    ipiv[k] = maxIdx + 1;
+    if (maxIdx !== k) {
+      for (let j = 0; j < n; j++) {
+        let tmp = re2[k + j * n];
+        re2[k + j * n] = re2[maxIdx + j * n];
+        re2[maxIdx + j * n] = tmp;
+        tmp = im2[k + j * n];
+        im2[k + j * n] = im2[maxIdx + j * n];
+        im2[maxIdx + j * n] = tmp;
+      }
+    }
+    const dR = re2[k + k * n], dI = im2[k + k * n];
+    const dAbs2 = dR * dR + dI * dI;
+    if (dAbs2 === 0) continue;
+    for (let i = k + 1; i < n; i++) {
+      const aR = re2[i + k * n], aI = im2[i + k * n];
+      const lR = (aR * dR + aI * dI) / dAbs2;
+      const lI = (aI * dR - aR * dI) / dAbs2;
+      re2[i + k * n] = lR;
+      im2[i + k * n] = lI;
+      for (let j = k + 1; j < n; j++) {
+        re2[i + j * n] -= lR * re2[k + j * n] - lI * im2[k + j * n];
+        im2[i + j * n] -= lR * im2[k + j * n] + lI * re2[k + j * n];
+      }
+    }
+  }
+}
 var _bridge2 = {
   inv,
   matmul,
@@ -17148,7 +17727,9 @@ var _bridge2 = {
   lu,
   svd,
   chol,
-  cholComplex
+  cholComplex,
+  gmres,
+  gmresComplex
 };
 function getTsLapackBridge() {
   return _bridge2;
@@ -18115,9 +18696,6 @@ function registerDynamicIBuiltin(b) {
   registry.set(b.name, b);
   _onDynamicRegister?.(b);
 }
-function unregisterIBuiltin(name) {
-  registry.delete(name);
-}
 function getAllIBuiltinNames() {
   return Array.from(registry.keys());
 }
@@ -22025,11 +22603,27 @@ function catAlongDim(values, dimIdx) {
   if (tensors.length === 0) return RTV.tensor(new FloatXArray(0), [0, 0]);
   if (tensors.length === 1) return tensors[0];
   const ndim = Math.max(2, ...tensors.map((t) => t.shape.length));
-  const shapes = tensors.map((t) => {
+  let shapes = tensors.map((t) => {
     const s = [...t.shape];
     while (s.length < ndim) s.push(1);
     return s;
   });
+  const refIdx = tensors.findIndex((t) => t.data.length > 0);
+  if (refIdx >= 0) {
+    const ref = shapes[refIdx];
+    const keep = tensors.map((t, i) => {
+      if (t.data.length > 0) return true;
+      for (let d = 0; d < ndim; d++) {
+        if (d === dimIdx) continue;
+        if (shapes[i][d] !== ref[d]) return false;
+      }
+      return true;
+    });
+    tensors = tensors.filter((_, i) => keep[i]);
+    shapes = shapes.filter((_, i) => keep[i]);
+    if (tensors.length === 0) return RTV.tensor(new FloatXArray(0), [0, 0]);
+    if (tensors.length === 1) return tensors[0];
+  }
   const refShape = shapes[0];
   for (let i = 1; i < shapes.length; i++) {
     for (let d = 0; d < ndim; d++) {
@@ -28135,7 +28729,7 @@ defineBuiltin({
       },
       apply: (args) => {
         const first = textValue(args[0]) ?? String(args[0]);
-        if (args.length >= 2 && first.includes(":")) {
+        if (args.length >= 2 && /^[A-Za-z]\w*(:[A-Za-z]\w*)+$/.test(first)) {
           const msg2 = args.length === 2 ? textValue(args[1]) ?? String(args[1]) : sprintfFormat(
             textValue(args[1]) ?? String(args[1]),
             args.slice(2)
@@ -28173,6 +28767,134 @@ defineBuiltin({
     }
   ]
 });
+function makeMException(identifier, message) {
+  return RTV.struct(
+    /* @__PURE__ */ new Map([
+      ["identifier", RTV.char(identifier)],
+      ["message", RTV.char(message)],
+      ["cause", RTV.cell([], [0, 0])],
+      ["stack", emptyStackField()]
+    ])
+  );
+}
+defineBuiltin({
+  name: "MException",
+  help: {
+    signatures: [
+      "ME = MException(errID, msg)",
+      "ME = MException(errID, msg, A1, ..., An)"
+    ],
+    description: "Construct an exception object with an error identifier and message. Extra arguments format the message with sprintf-style conversion specifiers. In numbl the result is a struct with fields identifier, message, cause, and stack."
+  },
+  cases: [
+    {
+      match: (argTypes) => {
+        if (argTypes.length < 2) return null;
+        const k0 = argTypes[0].kind;
+        const k1 = argTypes[1].kind;
+        if (k0 !== "string" && k0 !== "char") return null;
+        if (k1 !== "string" && k1 !== "char") return null;
+        return [{ kind: "struct", fields: {} }];
+      },
+      apply: (args) => {
+        const errID = textValue(args[0]) ?? String(args[0]);
+        const fmt = textValue(args[1]) ?? String(args[1]);
+        const msg = args.length === 2 ? fmt : sprintfFormat(fmt, args.slice(2));
+        return makeMException(errID, msg);
+      }
+    }
+  ]
+});
+function throwException(me) {
+  if (isRuntimeStruct(me)) {
+    const msgVal = me.fields.get("message");
+    const idVal = me.fields.get("identifier");
+    const msg = msgVal ? textValue(msgVal) ?? String(msgVal) : "";
+    const err = new RuntimeError(msg);
+    if (idVal) err.identifier = textValue(idVal) ?? "";
+    throw err;
+  }
+  throw new RuntimeError(String(me));
+}
+defineBuiltin({
+  name: "throw",
+  help: {
+    signatures: ["throw(ME)"],
+    description: "Throw an exception. ME is an MException-shaped struct with identifier and message fields."
+  },
+  cases: [
+    {
+      match: (argTypes) => {
+        if (argTypes.length !== 1) return null;
+        return [];
+      },
+      apply: (args) => throwException(args[0])
+    }
+  ]
+});
+defineBuiltin({
+  name: "throwAsCaller",
+  help: {
+    signatures: ["throwAsCaller(ME)"],
+    description: "Throw an exception as if from the calling function. In numbl this is equivalent to throw(ME) \u2014 the throw site is not hidden from the stack."
+  },
+  cases: [
+    {
+      match: (argTypes) => {
+        if (argTypes.length !== 1) return null;
+        return [];
+      },
+      apply: (args) => throwException(args[0])
+    }
+  ]
+});
+defineBuiltin({
+  name: "getReport",
+  help: {
+    signatures: ["S = getReport(ME)", "S = getReport(ME, TYPE)"],
+    description: "Return a formatted error report for an MException-shaped struct as a char string. TYPE is 'basic' or 'extended' (default 'extended'). The 'extended' form appends stack frames if present."
+  },
+  cases: [
+    {
+      match: (argTypes) => {
+        if (argTypes.length < 1 || argTypes.length > 4) return null;
+        return [{ kind: "char" }];
+      },
+      apply: (args) => {
+        const me = args[0];
+        if (!isRuntimeStruct(me)) {
+          return RTV.char(String(me));
+        }
+        const msgVal = me.fields.get("message");
+        const message = msgVal ? textValue(msgVal) ?? String(msgVal) : "";
+        let type = "extended";
+        if (args.length >= 2) {
+          const t = textValue(args[1]);
+          if (t === "basic" || t === "extended") type = t;
+        }
+        if (type === "basic") return RTV.char(message);
+        const stackVal = me.fields.get("stack");
+        const lines = [message];
+        const appendFrame = (frame) => {
+          if (!isRuntimeStruct(frame)) return;
+          const nameVal = frame.fields.get("name");
+          const lineVal = frame.fields.get("line");
+          const name = nameVal ? textValue(nameVal) ?? "" : "";
+          const lineNum = typeof lineVal === "number" ? lineVal : 0;
+          if (name) lines.push(`Error in ${name} (line ${lineNum})`);
+        };
+        if (stackVal) {
+          if (isRuntimeStructArray(stackVal)) {
+            for (const el of stackVal.elements) appendFrame(el);
+          } else if (isRuntimeStruct(stackVal)) {
+            appendFrame(stackVal);
+          }
+        }
+        return RTV.char(lines.join("\n"));
+      }
+    }
+  ]
+});
 
 // src/numbl-core/interpreter/builtins/introspection.ts
 function anyToLogicalCase(applyFn) {
@@ -30057,6 +30779,150 @@ registerIBuiltin({
     };
   }
 });
+var RE_ALPHA = /\p{L}/u;
+var RE_ALPHANUM = /[\p{L}\p{N}]/u;
+var RE_CNTRL = /\p{Cc}/u;
+var RE_GRAPHIC = /[\p{L}\p{N}\p{P}\p{S}\p{M}]/u;
+var RE_LOWER = /\p{Ll}/u;
+var RE_PUNCT = /\p{P}/u;
+var RE_UPPER = /\p{Lu}/u;
+var RE_WSPACE = /\s/u;
+function isstrpropPredicate(category) {
+  switch (category) {
+    case "alpha":
+      return (cp) => RE_ALPHA.test(String.fromCodePoint(cp));
+    case "alphanum":
+      return (cp) => RE_ALPHANUM.test(String.fromCodePoint(cp));
+    case "cntrl":
+      return (cp) => RE_CNTRL.test(String.fromCodePoint(cp));
+    case "digit":
+      return (cp) => cp >= 48 && cp <= 57;
+    case "graphic":
+      return (cp) => RE_GRAPHIC.test(String.fromCodePoint(cp));
+    case "lower":
+      return (cp) => RE_LOWER.test(String.fromCodePoint(cp));
+    case "print":
+      return (cp) => cp === 32 || RE_GRAPHIC.test(String.fromCodePoint(cp));
+    case "punct":
+      return (cp) => RE_PUNCT.test(String.fromCodePoint(cp));
+    case "wspace":
+      return (cp) => RE_WSPACE.test(String.fromCodePoint(cp));
+    case "upper":
+      return (cp) => RE_UPPER.test(String.fromCodePoint(cp));
+    case "xdigit":
+      return (cp) => cp >= 48 && cp <= 57 || cp >= 65 && cp <= 70 || cp >= 97 && cp <= 102;
+    default:
+      return null;
+  }
+}
+function stringCodePoints(s) {
+  const out = [];
+  for (const ch of s) out.push(ch.codePointAt(0));
+  return out;
+}
+function logicalRowFromString(s, pred, shape) {
+  const cps = stringCodePoints(s);
+  const data = new FloatXArray(cps.length);
+  for (let i = 0; i < cps.length; i++) data[i] = pred(cps[i]) ? 1 : 0;
+  return {
+    kind: "tensor",
+    data,
+    shape: shape ?? [1, cps.length],
+    _isLogical: true,
+    _rc: 1
+  };
+}
+function logicalFromNumericTensor(data, shape, pred) {
+  const out = new FloatXArray(data.length);
+  for (let i = 0; i < data.length; i++) {
+    out[i] = pred(Math.round(data[i])) ? 1 : 0;
+  }
+  return {
+    kind: "tensor",
+    data: out,
+    shape: [...shape],
+    _isLogical: true,
+    _rc: 1
+  };
+}
+function isstrpropApply(args) {
+  const v = args[0];
+  const category = toString(args[1]);
+  const pred = isstrpropPredicate(category);
+  if (!pred) {
+    throw new RuntimeError(`isstrprop: unknown category '${category}'`);
+  }
+  let forceCell = false;
+  if (args.length >= 3) {
+    const flagName = toString(args[2]).toLowerCase();
+    if (flagName !== "forcecelloutput") {
+      throw new RuntimeError(`isstrprop: unknown name '${toString(args[2])}'`);
+    }
+    if (args.length < 4) {
+      throw new RuntimeError("isstrprop: 'ForceCellOutput' requires a value");
+    }
+    forceCell = toNumber(args[3]) !== 0;
+  }
+  if (isRuntimeCell(v)) {
+    const out = new Array(v.data.length);
+    for (let i = 0; i < v.data.length; i++) {
+      const elem = v.data[i];
+      const s = isText(elem) ? toString(elem) : "";
+      out[i] = logicalRowFromString(s, pred);
+    }
+    return RTV.cell(out, [...v.shape]);
+  }
+  let result;
+  if (isRuntimeString(v)) {
+    result = logicalRowFromString(toString(v), pred);
+  } else if (isRuntimeChar(v)) {
+    const c = v;
+    result = logicalRowFromString(
+      c.value,
+      pred,
+      c.shape ? [...c.shape] : void 0
+    );
+  } else if (isRuntimeTensor(v)) {
+    result = logicalFromNumericTensor(v.data, v.shape, pred);
+  } else if (isRuntimeNumber(v) || isRuntimeLogical(v)) {
+    const cp = Math.round(toNumber(v));
+    const data = new FloatXArray(1);
+    data[0] = pred(cp) ? 1 : 0;
+    result = { kind: "tensor", data, shape: [1, 1], _isLogical: true, _rc: 1 };
+  } else {
+    throw new RuntimeError("isstrprop: unsupported input type");
+  }
+  if (forceCell) return RTV.cell([result], [1, 1]);
+  return result;
+}
+registerIBuiltin({
+  name: "isstrprop",
+  help: {
+    signatures: [
+      "TF = isstrprop(str, category)",
+      "TF = isstrprop(str, category, 'ForceCellOutput', tf)"
+    ],
+    description: "Test which characters in str belong to a category (alpha, alphanum, cntrl, digit, graphic, lower, print, punct, upper, wspace, xdigit). Returns a logical array, or a cell of logical vectors when str is a cell array or ForceCellOutput is true. Numeric input is treated as Unicode code points."
+  },
+  resolve: (argTypes) => {
+    if (argTypes.length < 2 || argTypes.length > 4) return null;
+    if (!isTextType(argTypes[1])) return null;
+    if (argTypes.length >= 3 && !isTextType(argTypes[2])) return null;
+    if (argTypes.length === 4) {
+      const k = argTypes[3].kind;
+      if (k !== "number" && k !== "boolean") return null;
+    }
+    const t0 = argTypes[0];
+    if (t0.kind !== "char" && t0.kind !== "string" && t0.kind !== "number" && t0.kind !== "boolean" && t0.kind !== "tensor" && t0.kind !== "cell") {
+      return null;
+    }
+    const isCell = t0.kind === "cell";
+    return {
+      outputTypes: isCell ? [{ kind: "cell" }] : [{ kind: "tensor", isComplex: false, isLogical: true }],
+      apply: (args) => isstrpropApply(args)
+    };
+  }
+});
 registerIBuiltin({
   name: "contains",
   resolve: (argTypes) => {
@@ -31029,32 +31895,31 @@ defineBuiltin({
     }
   ]
 });
-defineBuiltin({
-  name: "ismember",
-  cases: [
-    {
-      match: (argTypes, nargout) => {
-        if (argTypes.length < 2) return null;
-        const out = [{ kind: "unknown" }];
-        if (nargout > 1) out.push({ kind: "unknown" });
-        return out;
-      },
-      apply: (args, nargout) => {
-        if (args.length < 2)
-          throw new RuntimeError("ismember requires 2 arguments");
-        const v = args[0];
-        const b = args[1];
-        const isStringLike = (x) => isRuntimeString(x) || isRuntimeChar(x);
-        const isCellOfStrings = (x) => isRuntimeCell(x) && x.data.every(
-          (e) => isRuntimeString(e) || isRuntimeChar(e)
-        );
-        if (isStringLike(v) || isCellOfStrings(v) || isStringLike(b) || isCellOfStrings(b))
-          return ismemberStrings(v, b, nargout);
-        return ismemberNumeric(v, b, nargout);
-      }
+var ismemberCases = [
+  {
+    match: (argTypes, nargout) => {
+      if (argTypes.length < 2) return null;
+      const out = [{ kind: "unknown" }];
+      if (nargout > 1) out.push({ kind: "unknown" });
+      return out;
+    },
+    apply: (args, nargout) => {
+      if (args.length < 2)
+        throw new RuntimeError("ismember requires 2 arguments");
+      const v = args[0];
+      const b = args[1];
+      const isStringLike = (x) => isRuntimeString(x) || isRuntimeChar(x);
+      const isCellOfStrings = (x) => isRuntimeCell(x) && x.data.every(
+        (e) => isRuntimeString(e) || isRuntimeChar(e)
+      );
+      if (isStringLike(v) || isCellOfStrings(v) || isStringLike(b) || isCellOfStrings(b))
+        return ismemberStrings(v, b, nargout);
+      return ismemberNumeric(v, b, nargout);
     }
-  ]
-});
+  }
+];
+defineBuiltin({ name: "ismember", cases: ismemberCases });
+defineBuiltin({ name: "ismembc", cases: ismemberCases });
 function ismemberStrings(v, b, nargout) {
   const isStringLike = (x) => isRuntimeString(x) || isRuntimeChar(x);
   const isCellOfStrings = (x) => isRuntimeCell(x) && x.data.every((e) => isRuntimeString(e) || isRuntimeChar(e));
@@ -35596,11 +36461,11 @@ defineBuiltin({
           }
         } else {
           const p2 = n / 2;
-          const sub = new Array(p2 * p2).fill(0);
+          const sub2 = new Array(p2 * p2).fill(0);
           const sset = (r, c, v) => {
-            sub[c * p2 + r] = v;
+            sub2[c * p2 + r] = v;
           };
-          const sget = (r, c) => sub[c * p2 + r];
+          const sget = (r, c) => sub2[c * p2 + r];
           let si = 0;
           let sj = Math.floor(p2 / 2);
           for (let k2 = 1; k2 <= p2 * p2; k2++) {
@@ -38464,13 +39329,7 @@ registerIBuiltin({
   })
 });
 function getMexExt() {
-  if (typeof process === "undefined") return "";
-  const platform = process.platform;
-  const cpuArch = process.arch;
-  if (platform === "win32") return "mexw64";
-  if (platform === "darwin")
-    return cpuArch === "arm64" ? "mexmaca64" : "mexmaci64";
-  return "mexa64";
+  return "numbl.js";
 }
 defineBuiltin({
   name: "mexext",
@@ -39045,6 +39904,88 @@ for (const [name, fn, scaleFn] of besselDefs) {
     })
   });
 }
+function besselhScalar(nu, k, z, scale) {
+  const J = besselj(nu, z);
+  const Y = bessely(nu, z);
+  let re2 = J;
+  let im2 = k === 1 ? Y : -Y;
+  if (scale) {
+    const c = Math.cos(z);
+    const s = Math.sin(z);
+    if (k === 1) {
+      const newRe = re2 * c + im2 * s;
+      const newIm = im2 * c - re2 * s;
+      re2 = newRe;
+      im2 = newIm;
+    } else {
+      const newRe = re2 * c - im2 * s;
+      const newIm = re2 * s + im2 * c;
+      re2 = newRe;
+      im2 = newIm;
+    }
+  }
+  return { re: re2, im: im2 };
+}
+function binaryApplyComplex(a, b, fn, name) {
+  const aIsT = isRuntimeTensor(a);
+  const bIsT = isRuntimeTensor(b);
+  const buildTensor = (len, shape, iter) => {
+    const re2 = new FloatXArray(len);
+    const im2 = new FloatXArray(len);
+    let hasImag = false;
+    for (let i = 0; i < len; i++) {
+      const r2 = iter(i);
+      re2[i] = r2.re;
+      im2[i] = r2.im;
+      if (r2.im !== 0) hasImag = true;
+    }
+    return RTV.tensor(re2, shape, hasImag ? im2 : void 0);
+  };
+  if (aIsT && bIsT) {
+    if (a.data.length !== b.data.length)
+      throw new RuntimeError(`${name}: array dimensions must agree`);
+    return buildTensor(a.data.length, a.shape, (i) => fn(a.data[i], b.data[i]));
+  }
+  if (aIsT) {
+    const bv = toNumber(b);
+    return buildTensor(a.data.length, a.shape, (i) => fn(a.data[i], bv));
+  }
+  if (bIsT) {
+    const av = toNumber(a);
+    return buildTensor(b.data.length, b.shape, (i) => fn(av, b.data[i]));
+  }
+  const r = fn(toNumber(a), toNumber(b));
+  return r.im === 0 ? RTV.num(r.re) : RTV.complex(r.re, r.im);
+}
+registerIBuiltin({
+  name: "besselh",
+  resolve: () => ({
+    outputTypes: [{ kind: "unknown" }],
+    apply: (args) => {
+      if (args.length < 2 || args.length > 4)
+        throw new RuntimeError("besselh requires 2 to 4 arguments");
+      const nuArg = args[0];
+      let k = 1;
+      let zArg;
+      let scale = false;
+      if (args.length === 2) {
+        zArg = args[1];
+      } else {
+        k = Math.round(toNumber(args[1]));
+        if (k !== 1 && k !== 2)
+          throw new RuntimeError("besselh: K must be 1 or 2");
+        zArg = args[2];
+        if (args.length === 4) scale = toNumber(args[3]) === 1;
+      }
+      return binaryApplyComplex(
+        nuArg,
+        zArg,
+        (nu, z) => besselhScalar(nu, k, z, scale),
+        "besselh"
+      );
+    }
+  })
+});
 var airyFns = [airyAi, airyAiPrime, airyBi, airyBiPrime];
 var airyComplexKeys = ["ai", "aip", "bi", "bip"];
 function scaleAiry(n, x, val) {
@@ -39640,7 +40581,7 @@ registerIBuiltin({
     };
   }
 });
-for (const name of ["groot", "gcf", "gca", "shg", "newplot", "caxis"]) {
+for (const name of ["groot", "gcf", "gca", "shg", "newplot"]) {
   registerIBuiltin({
     name,
     resolve: () => ({
@@ -39653,7 +40594,32 @@ registerIBuiltin({
   name: "get",
   resolve: () => ({
     outputTypes: [{ kind: "unknown" }],
-    apply: () => RTV.dummyHandle()
+    apply: (args) => {
+      if (args.length >= 2) {
+        const prop = args[1];
+        const propStr = isRuntimeChar(prop) ? prop.value : isRuntimeString(prop) ? prop : "";
+        if (propStr.toLowerCase() === "colormap") {
+          const n = 64;
+          const data = new Float64Array(n * 3);
+          for (let i = 0; i < n; i++) {
+            const t = i / (n - 1);
+            if (t < 0.5) {
+              const s = t * 2;
+              data[i] = 0.2 * (1 - s);
+              data[n + i] = 0.1 + 0.6 * s;
+              data[2 * n + i] = 0.9 - 0.3 * s;
+            } else {
+              const s = (t - 0.5) * 2;
+              data[i] = 0.2 + 0.8 * s;
+              data[n + i] = 0.7 + 0.3 * s;
+              data[2 * n + i] = 0.6 - 0.5 * s;
+            }
+          }
+          return RTV.tensor(data, [n, 3]);
+        }
+      }
+      return RTV.dummyHandle();
+    }
   })
 });
 registerIBuiltin({
@@ -41440,6 +42406,14 @@ var H = {
     signatures: ["Y = besselk(NU, Z)", "Y = besselk(NU, Z, SCALE)"],
     description: "Modified Bessel function of the second kind. SCALE=1 applies exponential scaling."
   },
+  besselh: {
+    signatures: [
+      "H = besselh(NU, Z)",
+      "H = besselh(NU, K, Z)",
+      "H = besselh(NU, K, Z, SCALE)"
+    ],
+    description: "Hankel function (Bessel function of the third kind). K=1 (default) gives H^(1) = J + i*Y; K=2 gives H^(2) = J - i*Y. SCALE=1 multiplies by exp(-i*Z) for K=1 or exp(+i*Z) for K=2."
+  },
   airy: {
     signatures: ["Y = airy(X)", "Y = airy(K, X)", "Y = airy(K, X, SCALE)"],
     description: "Airy functions. K selects the function: 0=Ai (default), 1=Ai', 2=Bi, 3=Bi'. SCALE=1 applies exponential scaling."
@@ -41490,6 +42464,15 @@ var H = {
     signatures: ["TF = isequal(A, B, ...)"],
     description: "True if all inputs are equal (NaN ~= NaN)."
   },
+  // ── Dynamic evaluation ────────────────────────────────────────────────
+  evalin: {
+    signatures: ["V = evalin(WS, EXPR)", "V = evalin(WS, EXPR, DEFAULT)"],
+    description: "Evaluate EXPR in workspace WS ('caller' or 'base'/'workspace').\n\nnumbl-specific note: variables read by evalin must be declared in the\nfunction that owns them with a `% external-access:` comment, e.g.\n    function out = f()\n        % external-access: x y\n        x = 1; y = 2;\n        ...\n    end\nVariables not listed in `% external-access` are stored in a separate\ndynamic map and are only reachable through evalin/assignin. The\ndirective is a comment, so MATLAB ignores it."
+  },
+  assignin: {
+    signatures: ["assignin(WS, NAME, VALUE)"],
+    description: "Assign VALUE to variable NAME in workspace WS ('caller' or 'base'/'workspace').\n\nnumbl-specific note: variables written by assignin must be declared in\nthe function that owns them with a `% external-access:` comment, e.g.\n    function out = f()\n        % external-access: x y\n        x = 1; y = 2;\n        ...\n    end\nVariables not listed in `% external-access` are stored in a separate\ndynamic map and are only reachable through evalin/assignin. The\ndirective is a comment, so MATLAB ignores it."
+  },
   // ── Misc ──────────────────────────────────────────────────────────────
   disp: {
     signatures: ["disp(X)"],
@@ -42689,6 +43672,84 @@ function expandXY(xVal, yVal, rows, cols) {
   }
   return { x, y };
 }
+var PCOLOR_NAME_VALUE_KEYS = /* @__PURE__ */ new Set(["edgecolor", "facealpha"]);
+function isPcolorNameValueKey(v) {
+  if (!isRuntimeString(v) && !isRuntimeChar(v)) return null;
+  const lower = isRuntimeString(v) ? v.toLocaleLowerCase() : v.value.toLowerCase();
+  if (PCOLOR_NAME_VALUE_KEYS.has(lower)) return lower;
+  return null;
+}
+function applyPcolorNameValue(trace, key, value) {
+  switch (key) {
+    case "edgecolor": {
+      const s = getStringValueIfString(value);
+      if (s !== void 0 && s.toLowerCase() === "none") {
+        trace.edgeColor = "none";
+        break;
+      }
+      const c = resolveColor(value);
+      if (c) trace.edgeColor = c;
+      break;
+    }
+    case "facealpha": {
+      const n = typeof value === "number" ? value : toNumber(value);
+      trace.faceAlpha = n;
+      break;
+    }
+  }
+}
+function parsePcolorArgs(args) {
+  let pos = 0;
+  let xData;
+  let yData;
+  let cData;
+  let rows;
+  let cols;
+  let numericCount = 0;
+  for (let i = pos; i < args.length; i++) {
+    if (isNumericArg(args[i])) numericCount++;
+    else break;
+  }
+  if (numericCount === 1) {
+    const c = args[pos++];
+    const info = getMatrixInfo(c);
+    rows = info.rows;
+    cols = info.cols;
+    cData = info.data;
+    const gen = generateMeshgrid(rows, cols);
+    xData = gen.x;
+    yData = gen.y;
+  } else if (numericCount >= 3) {
+    const x = args[pos++];
+    const y = args[pos++];
+    const c = args[pos++];
+    const cInfo = getMatrixInfo(c);
+    rows = cInfo.rows;
+    cols = cInfo.cols;
+    cData = cInfo.data;
+    const expanded = expandXY(x, y, rows, cols);
+    xData = expanded.x;
+    yData = expanded.y;
+  } else {
+    throw new Error("pcolor requires 1 or 3 numeric input arguments");
+  }
+  const trace = {
+    x: xData,
+    y: yData,
+    c: cData,
+    rows,
+    cols
+  };
+  while (pos < args.length) {
+    const key = isPcolorNameValueKey(args[pos]);
+    if (!key) break;
+    pos++;
+    if (pos >= args.length) break;
+    const value = args[pos++];
+    applyPcolorNameValue(trace, key, value);
+  }
+  return trace;
+}
 function applySurfNameValue(trace, key, value) {
   switch (key) {
     case "edgecolor": {
@@ -43724,24 +44785,38 @@ function plotInstr(plotInstructions, instr) {
         value: resolveOnOff(instr.value)
       });
       break;
-    case "set_colorbar":
-      plotInstructions.push({
+    case "set_colorbar": {
+      const cbInstr = {
         type: "set_colorbar",
         value: resolveStr(instr.value)
-      });
+      };
+      if (instr.location !== void 0) {
+        cbInstr.location = resolveStr(instr.location);
+      }
+      plotInstructions.push(cbInstr);
       break;
-    case "set_colormap":
-      plotInstructions.push({
+    }
+    case "set_colormap": {
+      const cmInstr = {
         type: "set_colormap",
         name: resolveStr(instr.name).replace(/^"|"$/g, "")
-      });
+      };
+      if (instr.data) cmInstr.data = instr.data;
+      plotInstructions.push(cmInstr);
       break;
+    }
     case "set_axis":
       plotInstructions.push({
         type: "set_axis",
         value: resolveStr(instr.value).replace(/^"|"$/g, "")
       });
       break;
+    case "set_caxis":
+      plotInstructions.push({
+        type: "set_caxis",
+        limits: instr.limits
+      });
+      break;
   }
 }
 function viewCall(plotInstructions, args) {
@@ -43784,6 +44859,10 @@ function imagescCall(plotInstructions, args) {
   const trace = parseImagescArgs(args);
   plotInstructions.push({ type: "imagesc", trace });
 }
+function pcolorCall(plotInstructions, args) {
+  const trace = parsePcolorArgs(args);
+  plotInstructions.push({ type: "pcolor", trace });
+}
 function contourCall(plotInstructions, args, filled) {
   const trace = parseContourArgs(args, filled);
   plotInstructions.push({ type: "contour", trace });
@@ -44546,6 +45625,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "surf",
   "scatter",
   "imagesc",
+  "pcolor",
   "contour",
   "contourf",
   "mesh",
@@ -44588,6 +45668,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "zlabel",
   "colorbar",
   "axis",
+  "caxis",
   "mfilename",
   "addpath",
   "rmpath",
@@ -44613,7 +45694,8 @@ var SPECIAL_BUILTIN_NAMES = [
   "ode23",
   "deval",
   "toc",
-  "quadgk"
+  "quadgk",
+  "gmres"
 ];
 
 // src/numbl-core/runtime/specialBuiltins.ts
@@ -45953,6 +47035,53 @@ function registerSpecialBuiltins(rt) {
     plotInstr(rt.plotInstructions, { type: "clf" });
     return nargout >= 1 ? RTV.num(1) : void 0;
   });
+  registerSpecial("colorbar", (nargout, args) => {
+    const LOCATIONS = /* @__PURE__ */ new Set([
+      "east",
+      "west",
+      "north",
+      "south",
+      "eastoutside",
+      "westoutside",
+      "northoutside",
+      "southoutside"
+    ]);
+    let value = "on";
+    let location;
+    let i = 0;
+    while (i < args.length) {
+      let s;
+      try {
+        s = toString(args[i]);
+      } catch {
+        break;
+      }
+      const lower = s.toLowerCase();
+      if (lower === "off") {
+        value = "off";
+        i++;
+        continue;
+      }
+      if (LOCATIONS.has(lower)) {
+        location = lower;
+        i++;
+        continue;
+      }
+      i += 2;
+    }
+    plotInstr(rt.plotInstructions, {
+      type: "set_colorbar",
+      value,
+      location
+    });
+    if (nargout >= 1) {
+      return RTV.struct({
+        Location: RTV.char(location ?? "eastoutside"),
+        Visible: RTV.char(value === "off" ? "off" : "on")
+      });
+    }
+    return void 0;
+  });
   registerSpecial("ode45", (nargout, args) => {
     return _ode45Impl(rt, nargout, args, dormandPrince45);
   });
@@ -45962,6 +47091,9 @@ function registerSpecialBuiltins(rt) {
   registerSpecial("deval", (_nargout, args) => {
     return _devalImpl(args);
   });
+  registerSpecial("gmres", (nargout, args) => {
+    return _gmresImpl(rt, nargout, args);
+  });
 }
 function _ode45Impl(rt, nargout, args, tableau = dormandPrince45) {
   const solverName = tableau.name;
@@ -46190,6 +47322,530 @@ function _devalImpl(args) {
   }
   return RTV.tensor(yData, [neq, nPts]);
 }
+function _gmresImpl(rt, nargout, args) {
+  if (args.length < 2)
+    throw new RuntimeError("gmres requires at least 2 arguments (A, b)");
+  const Aarg = ensureRuntimeValue(args[0]);
+  const bArg = ensureRuntimeValue(args[1]);
+  if (!isRuntimeTensor(bArg) && !isRuntimeNumber(bArg) && !isRuntimeComplexNumber(bArg))
+    throw new RuntimeError("gmres: b must be a numeric vector");
+  let n;
+  if (isRuntimeTensor(bArg)) {
+    n = bArg.data.length;
+  } else {
+    n = 1;
+  }
+  const restartArg = args.length >= 3 ? ensureRuntimeValue(args[2]) : null;
+  const tolArg = args.length >= 4 ? ensureRuntimeValue(args[3]) : null;
+  const maxitArg = args.length >= 5 ? ensureRuntimeValue(args[4]) : null;
+  const M1arg = args.length >= 6 ? ensureRuntimeValue(args[5]) : null;
+  const M2arg = args.length >= 7 ? ensureRuntimeValue(args[6]) : null;
+  const x0Arg = args.length >= 8 ? ensureRuntimeValue(args[7]) : null;
+  let restart = n;
+  if (restartArg !== null && !_isEmpty(restartArg)) {
+    restart = _toNum(restartArg, "gmres: restart");
+  }
+  if (restart <= 0 || restart > n) restart = n;
+  const noRestart = restart === n;
+  const tol = tolArg !== null && !_isEmpty(tolArg) ? _toNum(tolArg, "gmres: tol") : 1e-6;
+  let maxit;
+  if (maxitArg !== null && !_isEmpty(maxitArg)) {
+    maxit = _toNum(maxitArg, "gmres: maxit");
+  } else {
+    maxit = noRestart ? 1 : Math.max(1, Math.min(Math.ceil(n / restart), 10));
+  }
+  if (noRestart && maxitArg === null) restart = Math.min(n, 10);
+  const isComplex2 = _isComplexArg(Aarg) || _isComplexArg(bArg) || M1arg !== null && _isComplexArg(M1arg) || M2arg !== null && _isComplexArg(M2arg) || x0Arg !== null && _isComplexArg(x0Arg);
+  let flag;
+  let relres;
+  let iter;
+  let resvec;
+  let xTensor;
+  if (isComplex2) {
+    const bCV = _toComplexVec(bArg, n);
+    const x0CV = x0Arg !== null && !_isEmpty(x0Arg) ? _toComplexVec(x0Arg, n) : null;
+    const allMatrices = _isMatrixArg(Aarg) && _isMatrixArg(M1arg) && _isMatrixArg(M2arg);
+    if (allMatrices) {
+      const { re: ARe, im: AIm } = _toComplexMatrix(Aarg, n * n);
+      const M1cv = _extractComplexMatrix(M1arg, n * n);
+      const M2cv = _extractComplexMatrix(M2arg, n * n);
+      const bridge = getEffectiveBridge("gmresComplex", "gmresComplex");
+      if (bridge?.gmresComplex) {
+        const r = bridge.gmresComplex(
+          ARe,
+          AIm,
+          n,
+          bCV.re,
+          bCV.im,
+          restart,
+          tol,
+          maxit,
+          M1cv?.re ?? null,
+          M1cv?.im ?? null,
+          M2cv?.re ?? null,
+          M2cv?.im ?? null,
+          x0CV?.re ?? null,
+          x0CV?.im ?? null
+        );
+        flag = r.flag;
+        relres = r.relres;
+        iter = [r.iter[0], r.iter[1]];
+        resvec = r.resvec;
+        xTensor = RTV.tensor(
+          new FloatXArray(r.xRe),
+          [n, 1],
+          new FloatXArray(r.xIm)
+        );
+      } else {
+        const matvec = _makeComplexMatvec(rt, Aarg, n);
+        const precSolve = _makeComplexPrecSolve(rt, M1arg, M2arg, n);
+        const r = gmresCoreComplex(
+          matvec,
+          precSolve,
+          bCV,
+          n,
+          restart,
+          tol,
+          maxit,
+          x0CV
+        );
+        flag = r.flag;
+        relres = r.relres;
+        iter = r.iter;
+        resvec = r.resvec;
+        xTensor = RTV.tensor(
+          new FloatXArray(r.x.re),
+          [n, 1],
+          new FloatXArray(r.x.im)
+        );
+      }
+    } else {
+      const matvec = _makeComplexMatvec(rt, Aarg, n);
+      const precSolve = _makeComplexPrecSolve(rt, M1arg, M2arg, n);
+      const r = gmresCoreComplex(
+        matvec,
+        precSolve,
+        bCV,
+        n,
+        restart,
+        tol,
+        maxit,
+        x0CV
+      );
+      flag = r.flag;
+      relres = r.relres;
+      iter = r.iter;
+      resvec = r.resvec;
+      xTensor = RTV.tensor(
+        new FloatXArray(r.x.re),
+        [n, 1],
+        new FloatXArray(r.x.im)
+      );
+    }
+  } else {
+    let bData;
+    if (isRuntimeNumber(bArg)) {
+      bData = new Float64Array([bArg]);
+    } else {
+      bData = toF64(bArg.data);
+    }
+    let x0 = null;
+    if (x0Arg !== null && !_isEmpty(x0Arg)) {
+      if (isRuntimeTensor(x0Arg)) x0 = toF64(x0Arg.data);
+      else if (isRuntimeNumber(x0Arg)) x0 = new Float64Array([x0Arg]);
+    }
+    let xResult;
+    const Ais_matrix = _isMatrixArg(Aarg);
+    const M1is_matrix = _isMatrixArg(M1arg);
+    const M2is_matrix = _isMatrixArg(M2arg);
+    if (Ais_matrix && M1is_matrix && M2is_matrix) {
+      const Adata = _extractRealMatrix(Aarg);
+      const M1data = _extractMatrix(M1arg);
+      const M2data = _extractMatrix(M2arg);
+      const bridge = getEffectiveBridge("gmres", "gmres");
+      if (bridge?.gmres) {
+        const result = bridge.gmres(
+          Adata,
+          n,
+          bData,
+          restart,
+          tol,
+          maxit,
+          M1data,
+          M2data,
+          x0
+        );
+        xResult = result.x;
+        flag = result.flag;
+        relres = result.relres;
+        iter = [result.iter[0], result.iter[1]];
+        resvec = result.resvec;
+      } else {
+        const r = _gmresWithCallbacks(
+          Adata,
+          n,
+          bData,
+          restart,
+          tol,
+          maxit,
+          M1data,
+          M2data,
+          x0
+        );
+        xResult = r.x;
+        flag = r.flag;
+        relres = r.relres;
+        iter = r.iter;
+        resvec = r.resvec;
+      }
+    } else {
+      const matvec = _makeMatvec(rt, Aarg, n);
+      const precSolve = _makePrecSolve(rt, M1arg, M2arg, n);
+      const r = gmresCore(matvec, precSolve, bData, n, restart, tol, maxit, x0);
+      xResult = r.x;
+      flag = r.flag;
+      relres = r.relres;
+      iter = r.iter;
+      resvec = r.resvec;
+    }
+    xTensor = RTV.tensor(new FloatXArray(xResult), [n, 1]);
+  }
+  if (nargout <= 1) {
+    if (flag === 0) {
+      rt.output(
+        `gmres converged at iteration ${iter[1]} to a solution with relative residual ${relres.toExponential(1)}.
+`
+      );
+    } else {
+      rt.output(
+        `gmres stopped at iteration ${iter[1]} without converging to the desired tolerance ${tol}
+because the maximum number of iterations was reached.
+The iterate returned (number ${iter[1]}) has relative residual ${relres.toExponential(1)}.
+`
+      );
+    }
+  }
+  if (nargout <= 1) return xTensor;
+  if (nargout === 2) return [xTensor, flag];
+  if (nargout === 3) return [xTensor, flag, relres];
+  if (nargout === 4) {
+    const iterTensor2 = RTV.tensor(new FloatXArray([iter[0], iter[1]]), [1, 2]);
+    return [xTensor, flag, relres, iterTensor2];
+  }
+  const iterTensor = RTV.tensor(new FloatXArray([iter[0], iter[1]]), [1, 2]);
+  const resvecTensor = RTV.tensor(new FloatXArray(resvec), [resvec.length, 1]);
+  return [xTensor, flag, relres, iterTensor, resvecTensor];
+}
+function _isEmpty(v) {
+  if (isRuntimeTensor(v) && v.data.length === 0) return true;
+  return false;
+}
+function _toNum(v, ctx) {
+  if (isRuntimeNumber(v)) return v;
+  if (isRuntimeTensor(v) && v.data.length === 1) return v.data[0];
+  throw new RuntimeError(`${ctx} must be a scalar`);
+}
+function _extractMatrix(arg) {
+  if (arg === null || _isEmpty(arg)) return null;
+  if (isRuntimeNumber(arg)) return new Float64Array([arg]);
+  if (isRuntimeSparseMatrix(arg)) {
+    const dense = sparseToDense(arg);
+    return toF64(dense.data);
+  }
+  if (isRuntimeTensor(arg)) return toF64(arg.data);
+  return null;
+}
+function _makeMatvec(rt, Aarg, n) {
+  if (isRuntimeFunction(Aarg)) {
+    return (x) => {
+      const xTensor = RTV.tensor(new FloatXArray(x), [n, 1]);
+      const resultRaw = rt.index(Aarg, [xTensor], 1);
+      const rv = ensureRuntimeValue(resultRaw);
+      if (isRuntimeNumber(rv)) return new Float64Array([rv]);
+      if (isRuntimeTensor(rv)) return toF64(rv.data);
+      throw new RuntimeError("gmres: A(x) must return a numeric vector");
+    };
+  }
+  let Adata;
+  if (isRuntimeNumber(Aarg)) {
+    Adata = new Float64Array([Aarg]);
+  } else if (isRuntimeSparseMatrix(Aarg)) {
+    Adata = toF64(sparseToDense(Aarg).data);
+  } else if (isRuntimeTensor(Aarg)) {
+    Adata = toF64(Aarg.data);
+  } else {
+    throw new RuntimeError("gmres: A must be a matrix or function handle");
+  }
+  return (x) => {
+    const y = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+      let s = 0;
+      for (let j = 0; j < n; j++) s += Adata[i + j * n] * x[j];
+      y[i] = s;
+    }
+    return y;
+  };
+}
+function _makePrecSolve(rt, M1arg, M2arg, n) {
+  const hasM1 = M1arg !== null && !_isEmpty(M1arg);
+  const hasM2 = M2arg !== null && !_isEmpty(M2arg);
+  if (!hasM1 && !hasM2) return null;
+  const solve1 = hasM1 ? _makeSinglePrecSolve(rt, M1arg, n) : null;
+  const solve2 = hasM2 ? _makeSinglePrecSolve(rt, M2arg, n) : null;
+  return (r) => {
+    let z = r;
+    if (solve1) z = solve1(z);
+    if (solve2) z = solve2(z);
+    return z;
+  };
+}
+function _makeSinglePrecSolve(rt, Marg, n) {
+  if (isRuntimeFunction(Marg)) {
+    return (r) => {
+      const rTensor = RTV.tensor(new FloatXArray(r), [n, 1]);
+      const resultRaw = rt.index(Marg, [rTensor], 1);
+      const rv = ensureRuntimeValue(resultRaw);
+      if (isRuntimeNumber(rv)) return new Float64Array([rv]);
+      if (isRuntimeTensor(rv)) return toF64(rv.data);
+      throw new RuntimeError("gmres: M(x) must return a numeric vector");
+    };
+  }
+  let Mdata;
+  if (isRuntimeNumber(Marg)) {
+    Mdata = new Float64Array([Marg]);
+  } else if (isRuntimeSparseMatrix(Marg)) {
+    Mdata = toF64(sparseToDense(Marg).data);
+  } else if (isRuntimeTensor(Marg)) {
+    Mdata = toF64(Marg.data);
+  } else {
+    throw new RuntimeError(
+      "gmres: preconditioner must be a matrix or function handle"
+    );
+  }
+  const LU = new Float64Array(Mdata);
+  const ipiv = new Int32Array(n);
+  const info = dgetrf(n, n, LU, n, ipiv);
+  if (info > 0)
+    throw new RuntimeError("gmres: preconditioner matrix is singular");
+  return (r) => {
+    const z = new Float64Array(r);
+    luSolveInPlace(n, LU, ipiv, z);
+    return z;
+  };
+}
+function _gmresWithCallbacks(A, n, b, restart, tol, maxit, M1, M2, x0) {
+  const matvec = (x) => {
+    const y = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+      let s = 0;
+      for (let j = 0; j < n; j++) s += A[i + j * n] * x[j];
+      y[i] = s;
+    }
+    return y;
+  };
+  let precSolve = null;
+  if (M1 || M2) {
+    const m1lu = M1 ? new Float64Array(M1) : null;
+    const m1ipiv = M1 ? new Int32Array(n) : null;
+    if (m1lu && m1ipiv) dgetrf(n, n, m1lu, n, m1ipiv);
+    const m2lu = M2 ? new Float64Array(M2) : null;
+    const m2ipiv = M2 ? new Int32Array(n) : null;
+    if (m2lu && m2ipiv) dgetrf(n, n, m2lu, n, m2ipiv);
+    precSolve = (r) => {
+      const z = new Float64Array(r);
+      if (m1lu && m1ipiv) luSolveInPlace(n, m1lu, m1ipiv, z);
+      if (m2lu && m2ipiv) luSolveInPlace(n, m2lu, m2ipiv, z);
+      return z;
+    };
+  }
+  return gmresCore(matvec, precSolve, b, n, restart, tol, maxit, x0);
+}
+function _isComplexArg(v) {
+  if (v === null) return false;
+  if (isRuntimeComplexNumber(v)) return true;
+  if (isRuntimeTensor(v) && v.imag) return true;
+  if (isRuntimeSparseMatrix(v) && v.pi) return true;
+  return false;
+}
+function _isMatrixArg(v) {
+  if (v === null) return true;
+  if (_isEmpty(v)) return true;
+  return isRuntimeTensor(v) || isRuntimeNumber(v) || isRuntimeComplexNumber(v) || isRuntimeSparseMatrix(v);
+}
+function _extractRealMatrix(arg) {
+  if (arg === null) return null;
+  if (isRuntimeNumber(arg)) return new Float64Array([arg]);
+  if (isRuntimeSparseMatrix(arg)) return toF64(sparseToDense(arg).data);
+  if (isRuntimeTensor(arg)) return toF64(arg.data);
+  return null;
+}
+function _toComplexVec(v, n) {
+  if (isRuntimeComplexNumber(v)) {
+    return { re: new Float64Array([v.re]), im: new Float64Array([v.im]) };
+  }
+  if (isRuntimeTensor(v)) {
+    return {
+      re: new Float64Array(toF64(v.data)),
+      im: v.imag ? new Float64Array(toF64(v.imag)) : new Float64Array(n)
+    };
+  }
+  if (isRuntimeNumber(v)) {
+    const re2 = new Float64Array(1);
+    re2[0] = v;
+    return { re: re2, im: new Float64Array(1) };
+  }
+  throw new RuntimeError("gmres: cannot convert argument to complex vector");
+}
+function _toComplexMatrix(v, len) {
+  if (isRuntimeTensor(v)) {
+    return {
+      re: new Float64Array(toF64(v.data)),
+      im: v.imag ? new Float64Array(toF64(v.imag)) : new Float64Array(len)
+    };
+  }
+  if (isRuntimeSparseMatrix(v)) {
+    const dense = sparseToDense(v);
+    return {
+      re: new Float64Array(toF64(dense.data)),
+      im: dense.imag ? new Float64Array(toF64(dense.imag)) : new Float64Array(len)
+    };
+  }
+  if (isRuntimeNumber(v)) {
+    const re2 = new Float64Array(1);
+    re2[0] = v;
+    return { re: re2, im: new Float64Array(1) };
+  }
+  throw new RuntimeError("gmres: cannot convert to complex matrix");
+}
+function _extractComplexMatrix(arg, len) {
+  if (arg === null || _isEmpty(arg)) return null;
+  return _toComplexMatrix(arg, len);
+}
+function _makeComplexMatvec(rt, Aarg, n) {
+  if (isRuntimeFunction(Aarg)) {
+    return (x) => {
+      const xTensor = RTV.tensor(
+        new FloatXArray(x.re),
+        [n, 1],
+        new FloatXArray(x.im)
+      );
+      const resultRaw = rt.index(Aarg, [xTensor], 1);
+      const rv = ensureRuntimeValue(resultRaw);
+      if (isRuntimeTensor(rv)) {
+        return {
+          re: new Float64Array(toF64(rv.data)),
+          im: rv.imag ? new Float64Array(toF64(rv.imag)) : new Float64Array(n)
+        };
+      }
+      if (isRuntimeComplexNumber(rv)) {
+        return { re: new Float64Array([rv.re]), im: new Float64Array([rv.im]) };
+      }
+      if (isRuntimeNumber(rv)) {
+        const re2 = new Float64Array(1);
+        re2[0] = rv;
+        return { re: re2, im: new Float64Array(1) };
+      }
+      throw new RuntimeError("gmres: A(x) must return a numeric vector");
+    };
+  }
+  const { re: ARe, im: AIm } = _toComplexMatrix(Aarg, n * n);
+  return (x) => {
+    const yRe = new Float64Array(n);
+    const yIm = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+      let sR = 0, sI = 0;
+      for (let j = 0; j < n; j++) {
+        const aR = ARe[i + j * n], aI = AIm[i + j * n];
+        sR += aR * x.re[j] - aI * x.im[j];
+        sI += aR * x.im[j] + aI * x.re[j];
+      }
+      yRe[i] = sR;
+      yIm[i] = sI;
+    }
+    return { re: yRe, im: yIm };
+  };
+}
+function _makeComplexPrecSolve(rt, M1arg, M2arg, n) {
+  const hasM1 = M1arg !== null && !_isEmpty(M1arg);
+  const hasM2 = M2arg !== null && !_isEmpty(M2arg);
+  if (!hasM1 && !hasM2) return null;
+  const solve1 = hasM1 ? _makeSingleComplexPrecSolve(rt, M1arg, n) : null;
+  const solve2 = hasM2 ? _makeSingleComplexPrecSolve(rt, M2arg, n) : null;
+  return (r) => {
+    let z = r;
+    if (solve1) z = solve1(z);
+    if (solve2) z = solve2(z);
+    return z;
+  };
+}
+function _makeSingleComplexPrecSolve(rt, Marg, n) {
+  if (isRuntimeFunction(Marg)) {
+    return (r) => {
+      const rTensor = RTV.tensor(
+        new FloatXArray(r.re),
+        [n, 1],
+        new FloatXArray(r.im)
+      );
+      const resultRaw = rt.index(Marg, [rTensor], 1);
+      const rv = ensureRuntimeValue(resultRaw);
+      if (isRuntimeTensor(rv)) {
+        return {
+          re: new Float64Array(toF64(rv.data)),
+          im: rv.imag ? new Float64Array(toF64(rv.imag)) : new Float64Array(n)
+        };
+      }
+      throw new RuntimeError("gmres: M(x) must return a numeric vector");
+    };
+  }
+  const { re: MRe, im: MIm } = _toComplexMatrix(Marg, n * n);
+  const ipiv = new Int32Array(n);
+  _complexLuFactor(n, MRe, MIm, ipiv);
+  return (r) => {
+    const zRe = new Float64Array(r.re);
+    const zIm = new Float64Array(r.im);
+    complexLuSolveInPlace(n, MRe, MIm, ipiv, zRe, zIm);
+    return { re: zRe, im: zIm };
+  };
+}
+function _complexLuFactor(n, re2, im2, ipiv) {
+  for (let k = 0; k < n; k++) {
+    let maxVal = -1, maxIdx = k;
+    for (let i = k; i < n; i++) {
+      const v = Math.sqrt(
+        re2[i + k * n] * re2[i + k * n] + im2[i + k * n] * im2[i + k * n]
+      );
+      if (v > maxVal) {
+        maxVal = v;
+        maxIdx = i;
+      }
+    }
+    ipiv[k] = maxIdx + 1;
+    if (maxIdx !== k) {
+      for (let j = 0; j < n; j++) {
+        let tmp = re2[k + j * n];
+        re2[k + j * n] = re2[maxIdx + j * n];
+        re2[maxIdx + j * n] = tmp;
+        tmp = im2[k + j * n];
+        im2[k + j * n] = im2[maxIdx + j * n];
+        im2[maxIdx + j * n] = tmp;
+      }
+    }
+    const dR = re2[k + k * n], dI = im2[k + k * n];
+    const dAbs2 = dR * dR + dI * dI;
+    if (dAbs2 === 0) continue;
+    for (let i = k + 1; i < n; i++) {
+      const aR = re2[i + k * n], aI = im2[i + k * n];
+      const lR = (aR * dR + aI * dI) / dAbs2;
+      const lI = (aI * dR - aR * dI) / dAbs2;
+      re2[i + k * n] = lR;
+      im2[i + k * n] = lI;
+      for (let j = k + 1; j < n; j++) {
+        re2[i + j * n] -= lR * re2[k + j * n] - lI * im2[k + j * n];
+        im2[i + j * n] -= lR * im2[k + j * n] + lI * re2[k + j * n];
+      }
+    }
+  }
+}
 
 // src/numbl-core/interpreter/builtins/index.ts
 registerExtraBuiltinNames(getAllIBuiltinNames());
@@ -46208,6 +47864,8 @@ function dispatchPlotCall(rt, name, args) {
       return rt.scatter_call(args.map((a) => ensureRuntimeValue(a)));
     case "imagesc":
       return rt.imagesc_call(args.map((a) => ensureRuntimeValue(a)));
+    case "pcolor":
+      return rt.pcolor_call(args.map((a) => ensureRuntimeValue(a)));
     case "contour":
       return rt.contour_call(
         args.map((a) => ensureRuntimeValue(a)),
@@ -47130,10 +48788,10 @@ function index(rt, base, indices, nargout = 1, skipSubsref = false) {
         let stride = 1;
         for (let k = 0; k < nIdx; k++) {
           const dimSize = k < s.length ? s[k] : 1;
-          const sub = Math.round(indices[k]) - 1;
-          if (sub < 0 || sub >= dimSize)
+          const sub2 = Math.round(indices[k]) - 1;
+          if (sub2 < 0 || sub2 >= dimSize)
             throw new RuntimeError("Index exceeds array bounds");
-          lin += sub * stride;
+          lin += sub2 * stride;
           stride *= dimSize;
         }
         if (t.imag !== void 0) {
@@ -47330,16 +48988,24 @@ function indexStore(rt, base, indices, rhs, skipSubsasgn = false) {
     }
     return dictInsertSingle(mv, key, rhsMv2);
   }
-  if (indices.length === 1 && (isRuntimeStructArray(mv) || isRuntimeTensor(mv) && mv.data.length === 0)) {
+  if (indices.length === 1 && (isRuntimeStructArray(mv) || isRuntimeStruct(mv) || isRuntimeTensor(mv) && mv.data.length === 0)) {
     const rhsMv2 = ensureRuntimeValue(rhs);
     if (isRuntimeStruct(rhsMv2)) {
       const idxVal = ensureRuntimeValue(indices[0]);
       const k = Math.round(toNumber(idxVal)) - 1;
-      const existingElements = isRuntimeStructArray(mv) ? [...mv.elements] : [];
-      const existingFieldNames = isRuntimeStructArray(mv) ? mv.fieldNames : [];
+      const existingElements = isRuntimeStructArray(mv) ? [...mv.elements] : isRuntimeStruct(mv) ? [mv] : [];
+      const existingFieldNames = isRuntimeStructArray(mv) ? mv.fieldNames : isRuntimeStruct(mv) ? [...mv.fields.keys()] : [];
       const allFieldNames = [
         .../* @__PURE__ */ new Set([...existingFieldNames, ...[...rhsMv2.fields.keys()]])
       ];
+      for (let ei = 0; ei < existingElements.length; ei++) {
+        const el = existingElements[ei];
+        for (const f of allFieldNames) {
+          if (!el.fields.has(f)) {
+            el.fields.set(f, RTV.tensor(new FloatXArray(0), [0, 0]));
+          }
+        }
+      }
       while (existingElements.length <= k) {
         existingElements.push(
           RTV.struct(
@@ -47769,6 +49435,11 @@ var Runtime = class _Runtime {
   // Custom builtins (execution-specific overrides).
   // These take priority over IBuiltins.
   customBuiltins = {};
+  // Per-runtime JIT helpers ($h) — populated by executeCode after the runtime
+  // is constructed. Cloned from the global jitHelpers and extended with
+  // ib_<name> entries for any .numbl.js user functions of this execution.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  jitHelpers = null;
   // JIT compilation callback: compiles and evaluates a specialized function at
   // runtime. Set by executeCode() to close over the LoweringContext and Codegen.
   // The callback handles the full resolution chain (local → class method →
@@ -47789,6 +49460,8 @@ var Runtime = class _Runtime {
   profileStack = [];
   profileAccum = /* @__PURE__ */ new Map();
   profileCounts = /* @__PURE__ */ new Map();
+  // Profiling: interpreted loops with >1000 iterations (keyed by "file:line")
+  hotLoops = /* @__PURE__ */ new Map();
   // ── Builtin initialization ──────────────────────────────────────────
   initBuiltins() {
     registerSpecialBuiltins(this);
@@ -47807,6 +49480,10 @@ var Runtime = class _Runtime {
     this.builtins["imagesc"] = (_nargout, args) => {
       this.imagesc_call(args.map((a) => ensureRuntimeValue(a)));
     };
+    this.builtins["pcolor"] = (_nargout, args) => {
+      this.pcolor_call(args.map((a) => ensureRuntimeValue(a)));
+      if (_nargout >= 1) return RTV.dummyHandle();
+    };
     this.builtins["contour"] = (_nargout, args) => {
       this.contour_call(
         args.map((a) => ensureRuntimeValue(a)),
@@ -47891,8 +49568,21 @@ var Runtime = class _Runtime {
     this.builtins["colormap"] = (_nargout, args) => {
       if (args.length > 0) {
         const rv = ensureRuntimeValue(args[0]);
-        const name = toString(rv).replace(/^"|"$/g, "");
-        plotInstr(this.plotInstructions, { type: "set_colormap", name });
+        if (isRuntimeTensor(rv) && rv.shape.length === 2 && rv.shape[1] === 3) {
+          const rows = rv.shape[0];
+          const data = [];
+          for (let i = 0; i < rows; i++) {
+            data.push([rv.data[i], rv.data[rows + i], rv.data[2 * rows + i]]);
+          }
+          plotInstr(this.plotInstructions, {
+            type: "set_colormap",
+            name: "__custom__",
+            data
+          });
+        } else {
+          const name = toString(rv).replace(/^"|"$/g, "");
+          plotInstr(this.plotInstructions, { type: "set_colormap", name });
+        }
       }
     };
     this.builtins["view"] = (_nargout, args) => {
@@ -47906,10 +49596,6 @@ var Runtime = class _Runtime {
         });
       }
     };
-    this.builtins["colorbar"] = (_nargout, args) => {
-      const val = args.length > 0 ? toString(ensureRuntimeValue(args[0])) : "on";
-      plotInstr(this.plotInstructions, { type: "set_colorbar", value: val });
-    };
     this.builtins["axis"] = (_nargout, args) => {
       if (args.length > 0) {
         const val = toString(ensureRuntimeValue(args[0])).replace(
@@ -47919,6 +49605,17 @@ var Runtime = class _Runtime {
         plotInstr(this.plotInstructions, { type: "set_axis", value: val });
       }
     };
+    this.builtins["caxis"] = (_nargout, args) => {
+      if (args.length > 0) {
+        const rv = ensureRuntimeValue(args[0]);
+        if (isRuntimeTensor(rv) && rv.data.length >= 2) {
+          plotInstr(this.plotInstructions, {
+            type: "set_caxis",
+            limits: [rv.data[0], rv.data[1]]
+          });
+        }
+      }
+    };
   }
   profileEnter(key) {
     if (!this.profilingEnabled) return;
@@ -48025,8 +49722,9 @@ var Runtime = class _Runtime {
     if (e instanceof RuntimeError) {
       return RTV.struct(
         /* @__PURE__ */ new Map([
-          ["message", RTV.char(e.message)],
           ["identifier", RTV.char(e.identifier)],
+          ["message", RTV.char(e.message)],
+          ["cause", RTV.cell([], [0, 0])],
           ["stack", buildStackField(e)]
         ])
       );
@@ -48034,16 +49732,18 @@ var Runtime = class _Runtime {
     if (e instanceof Error) {
       return RTV.struct(
         /* @__PURE__ */ new Map([
-          ["message", RTV.char(e.message)],
           ["identifier", RTV.char("")],
+          ["message", RTV.char(e.message)],
+          ["cause", RTV.cell([], [0, 0])],
           ["stack", emptyStackField()]
         ])
       );
     }
     return RTV.struct(
       /* @__PURE__ */ new Map([
-        ["message", RTV.char(String(e))],
         ["identifier", RTV.char("")],
+        ["message", RTV.char(String(e))],
+        ["cause", RTV.cell([], [0, 0])],
         ["stack", emptyStackField()]
       ])
     );
@@ -48782,6 +50482,9 @@ var Runtime = class _Runtime {
   imagesc_call(args) {
     imagescCall(this.plotInstructions, args);
   }
+  pcolor_call(args) {
+    pcolorCall(this.plotInstructions, args);
+  }
   contour_call(args, filled) {
     contourCall(this.plotInstructions, args, filled);
   }
@@ -48937,7 +50640,7 @@ function buildStackField(e) {
 // src/numbl-core/jsUserFunctions.ts
 function funcNameFromFile(fileName) {
   const base = fileName.split("/").pop();
-  return base.replace(/\.js$/, "");
+  return base.replace(/\.numbl\.js$/, "");
 }
 function buildWasmMap(wasmFiles) {
   const map = /* @__PURE__ */ new Map();
@@ -48961,6 +50664,9 @@ function parseDirectives(source) {
   }
   return directives;
 }
+function isNumblJsFile(fileName) {
+  return fileName.endsWith(".numbl.js");
+}
 function nativeLibFilename(baseName) {
   const platform = typeof process !== "undefined" ? process.platform : "linux";
   switch (platform) {
@@ -49034,7 +50740,7 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge) {
   for (const file of jsFiles) {
     const base = file.name.split("/").pop();
     if (base.startsWith("_")) {
-      const libName = base.replace(/\.js$/, "");
+      const libName = base.replace(/\.numbl\.js$/, "");
       libraryFiles.set(libName, file);
     } else {
       functionFiles.push(file);
@@ -49044,13 +50750,13 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge) {
   function importJS(name) {
     const cached = libCache.get(name);
     if (cached === LOADING) {
-      throw new RuntimeError(`Circular dependency detected: ${name}.js`);
+      throw new RuntimeError(`Circular dependency detected: ${name}.numbl.js`);
     }
     if (libCache.has(name)) return cached;
     const libFile = libraryFiles.get(name);
     if (!libFile) {
       throw new RuntimeError(
-        `importJS: library '${name}.js' not found in workspace`
+        `importJS: library '${name}.numbl.js' not found in workspace`
       );
     }
     libCache.set(name, LOADING);
@@ -49063,7 +50769,7 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge) {
     );
     const dummyRegister = () => {
       throw new RuntimeError(
-        `Library file '${name}.js' must not call register(). Use return {...} to export values.`
+        `Library file '${name}.numbl.js' must not call register(). Use return {...} to export values.`
       );
     };
     const factory = new Function(
@@ -49098,7 +50804,7 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge) {
         }
         if (builtin) {
           throw new Error(
-            "register() called more than once \u2014 only one registration per .js file"
+            "register() called more than once \u2014 only one registration per .numbl.js file"
           );
         }
         builtin = {
@@ -49165,7 +50871,7 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge) {
           };
         };
       }
-      result.push(builtin);
+      result.push({ name: funcName, fileName: file.name, builtin });
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       throw new Error(
@@ -49378,7 +51084,7 @@ function resolveFunction(name, argTypes, callSite, index2) {
     };
   }
   if (index2.jsUserFunctions.has(name)) {
-    return { kind: "builtin", name };
+    return { kind: "jsUserFunction", name, argTypes };
   }
   if (index2.workspaceClasses.has(name)) {
     return {
@@ -50231,7 +51937,8 @@ function lowerMultiAssign(ctx, stmt) {
   if (args.some((a) => a === null)) return null;
   const loweredArgs = args;
   const argJitTypes = loweredArgs.map((a) => a.jitType);
-  const ib = getIBuiltin(rhs.name);
+  const jsEntry = ctx.interp?.ctx.registry.jsUserFunctionsByName.get(rhs.name);
+  const ib = jsEntry?.builtin ?? getIBuiltin(rhs.name);
   if (!ib) return null;
   const resolution = ib.resolve(argJitTypes, nargout);
   if (!resolution || resolution.outputTypes.length < nargout) return null;
@@ -50655,7 +52362,8 @@ function resolveUserFunction(interp, name, argJitTypes) {
   return null;
 }
 function lowerIBuiltinCall(ctx, expr) {
-  const ib = getIBuiltin(expr.name);
+  const jsEntry = ctx.interp?.ctx.registry.jsUserFunctionsByName.get(expr.name);
+  const ib = jsEntry?.builtin ?? getIBuiltin(expr.name);
   if (!ib) return null;
   const args = expr.args.map((a) => lowerExpr(ctx, a));
   if (args.some((a) => a === null)) return null;
@@ -50898,10 +52606,10 @@ function idxN(base, indices) {
     let stride = 1;
     for (let k = 0; k < indices.length; k++) {
       const dimSize = k < s.length ? s[k] : 1;
-      const sub = Math.round(indices[k]) - 1;
-      if (sub < 0 || sub >= dimSize)
+      const sub2 = Math.round(indices[k]) - 1;
+      if (sub2 < 0 || sub2 >= dimSize)
         throw new Error("Index exceeds array bounds");
-      lin += sub * stride;
+      lin += sub2 * stride;
       stride *= dimSize;
     }
     if (base.imag !== void 0) {
@@ -51012,6 +52720,48 @@ setDynamicRegisterHook((b) => {
     return typeof result === "boolean" ? result ? 1 : 0 : result;
   };
 });
+function buildPerRuntimeJitHelpers(jsUserFunctions) {
+  const h = Object.assign({}, jitHelpers);
+  for (const [name, ib] of jsUserFunctions) {
+    h[`ib_${name}`] = (...args) => {
+      const pe = h._profileEnter;
+      const pl = h._profileLeave;
+      pe("jsUserFunction:jit:" + name);
+      const rtArgs = args;
+      const argTypes = rtArgs.map(inferJitType);
+      const res = ib.resolve(argTypes, 1);
+      if (!res) {
+        pl();
+        throw new Error(`JIT ib_${name}: resolve failed`);
+      }
+      const result = res.apply(rtArgs, 1);
+      pl();
+      return typeof result === "boolean" ? result ? 1 : 0 : result;
+    };
+  }
+  const origIbcall = h.ibcall;
+  h.ibcall = (name, nargout, ...args) => {
+    const ib = jsUserFunctions.get(name);
+    if (!ib) return origIbcall(name, nargout, ...args);
+    const pe = h._profileEnter;
+    const pl = h._profileLeave;
+    pe("jsUserFunction:jit:" + name);
+    const rtArgs = args;
+    const argTypes = rtArgs.map(inferJitType);
+    const res = ib.resolve(argTypes, nargout);
+    if (!res) {
+      pl();
+      throw new Error(`JIT ibcall: resolve failed for ${name}`);
+    }
+    const result = res.apply(rtArgs, nargout);
+    pl();
+    if (Array.isArray(result)) {
+      return result.map((v) => typeof v === "boolean" ? v ? 1 : 0 : v);
+    }
+    return [typeof result === "boolean" ? result ? 1 : 0 : result];
+  };
+  return h;
+}
 
 // src/numbl-core/interpreter/jit/jitLoopAnalysis.ts
 function analyzeForLoop(stmt) {
@@ -51426,18 +53176,26 @@ function execStmt(stmt) {
     }
     case "While": {
       if (this.optimization >= 1 && tryJitWhile(this, stmt)) return null;
+      const _whileStart = this.rt.profilingEnabled ? performance.now() : 0;
+      let _whileIters = 0;
       while (true) {
         const cond = this.evalExpr(stmt.cond);
         if (!this.rt.toBool(cond)) break;
+        _whileIters++;
         const signal = this.execStmts(stmt.body);
         if (signal instanceof BreakSignal) break;
         if (signal instanceof ContinueSignal) continue;
-        if (signal instanceof ReturnSignal) return signal;
+        if (signal instanceof ReturnSignal) {
+          recordHotLoop(this, stmt, "while", _whileIters, _whileStart);
+          return signal;
+        }
       }
+      recordHotLoop(this, stmt, "while", _whileIters, _whileStart);
       return null;
     }
     case "For": {
       if (this.optimization >= 1 && tryJitFor(this, stmt)) return null;
+      const _forStart = this.rt.profilingEnabled ? performance.now() : 0;
       const iterVal = this.evalExpr(stmt.expr);
       const rv = ensureRuntimeValue(iterVal);
       const iterItems = forIter(rv);
@@ -51446,8 +53204,12 @@ function execStmt(stmt) {
         const signal = this.execStmts(stmt.body);
         if (signal instanceof BreakSignal) break;
         if (signal instanceof ContinueSignal) continue;
-        if (signal instanceof ReturnSignal) return signal;
+        if (signal instanceof ReturnSignal) {
+          recordHotLoop(this, stmt, "for", _i + 1, _forStart);
+          return signal;
+        }
       }
+      recordHotLoop(this, stmt, "for", iterItems.length, _forStart);
       return null;
     }
     case "Switch": {
@@ -52209,6 +53971,33 @@ function isOutputExpr(expr) {
   if (expr.type === "Ident") return outputFunctions.includes(expr.name);
   return false;
 }
+function recordHotLoop(interp, stmt, kind, iterations, startTime) {
+  if (!interp.rt.profilingEnabled || iterations <= 1e3 || !stmt.span) return;
+  const durationMs = performance.now() - startTime;
+  let table = interp.lineTableCache.get(stmt.span.file);
+  if (!table) {
+    const src = interp.fileSources.get(stmt.span.file) ?? "";
+    table = buildLineTable(src);
+    interp.lineTableCache.set(stmt.span.file, table);
+  }
+  const line = offsetToLineFast(table, stmt.span.start);
+  const key = `${stmt.span.file}:${line}`;
+  const prev = interp.rt.hotLoops.get(key);
+  if (prev) {
+    prev.callCount++;
+    prev.totalTimeMs += durationMs;
+    if (iterations > prev.iterations) prev.iterations = iterations;
+  } else {
+    interp.rt.hotLoops.set(key, {
+      file: stmt.span.file,
+      line,
+      kind,
+      iterations,
+      callCount: 1,
+      totalTimeMs: durationMs
+    });
+  }
+}
 
 // src/numbl-core/interpreter/interpreterFunctions.ts
 var interpreterFunctions_exports = {};
@@ -52227,6 +54016,7 @@ __export(interpreterFunctions_exports, {
   instantiateClass: () => instantiateClass,
   interpretClassMethod: () => interpretClassMethod,
   interpretConstructor: () => interpretConstructor,
+  interpretJsUserFunction: () => interpretJsUserFunction,
   interpretLocalFunction: () => interpretLocalFunction,
   interpretPrivateFunction: () => interpretPrivateFunction,
   interpretTarget: () => interpretTarget,
@@ -52290,7 +54080,8 @@ function tryJitCall(interp, fn, args, nargout) {
   const rt = interp.rt;
   try {
     const factory = new Function("$h", "$rt", ...paramNames, jsBody);
-    compiledFn = (...callArgs) => factory(jitHelpers, rt, ...callArgs);
+    const helpers = rt.jitHelpers ?? jitHelpers;
+    compiledFn = (...callArgs) => factory(helpers, rt, ...callArgs);
   } catch {
     fnWithCache._jitCache.set(cacheKey, null);
     return JIT_SKIP;
@@ -52392,27 +54183,76 @@ register("exist", (ctx, args) => {
   if (args.length < 1) return FALL_THROUGH;
   const nameArg = toString(ensureRuntimeValue(args[0]));
   const typeArg = args.length >= 2 ? toString(ensureRuntimeValue(args[1])) : "";
+  const fio = ctx.rt.fileIO;
+  const isBuiltin2 = () => !!(ctx.rt.builtins[nameArg] || getIBuiltin(nameArg));
+  const fileTypeFromExt = (path) => /\.numbl\.js$/i.test(path) ? 3 : 2;
+  const nameHasKnownExt = /\.(numbl\.js|m|mlx|mlapp)$/i.test(nameArg);
+  const isAbsolutePath = (p2) => p2.startsWith("/") || p2.startsWith("\\") || /^[a-zA-Z]:[/\\]/.test(p2);
+  const joinPath = (dir, name) => {
+    if (!dir) return name;
+    if (dir.endsWith("/") || dir.endsWith("\\")) return dir + name;
+    return dir + "/" + name;
+  };
+  const walkSearchPath = (acceptDir) => {
+    if (!fio?.existsPath) return 0;
+    const dirs = isAbsolutePath(nameArg) ? [""] : ctx.rt.searchPaths.length > 0 ? ctx.rt.searchPaths : [""];
+    for (const dir of dirs) {
+      if (acceptDir) {
+        const t = fio.existsPath(joinPath(dir, nameArg));
+        if (t === "dir") return 7;
+      }
+      if (!nameHasKnownExt) {
+        for (const ext of [".m", ".mlx", ".mlapp"]) {
+          const t = fio.existsPath(joinPath(dir, nameArg + ext));
+          if (t === "file") {
+            const ws = ctx.lookupWorkspaceFile(nameArg);
+            return ws?.kind === "class" ? 8 : 2;
+          }
+        }
+        const numblJs = fio.existsPath(joinPath(dir, nameArg + ".numbl.js"));
+        if (numblJs === "file") return 3;
+      }
+      const lit = fio.existsPath(joinPath(dir, nameArg));
+      if (lit === "file") return fileTypeFromExt(nameArg);
+    }
+    return 0;
+  };
+  const workspaceTypeId = () => {
+    const ws = ctx.lookupWorkspaceFile(nameArg);
+    if (!ws) return 0;
+    switch (ws.kind) {
+      case "function":
+        return 2;
+      case "jsfunction":
+        return 3;
+      case "class":
+        return 8;
+    }
+  };
   if (typeArg === "var") {
     return ctx.env.has(nameArg) ? 1 : 0;
   }
   if (typeArg === "builtin") {
-    return ctx.rt.builtins[nameArg] || getIBuiltin(nameArg) ? 5 : 0;
+    return isBuiltin2() ? 5 : 0;
+  }
+  if (typeArg === "class") {
+    const ws = ctx.lookupWorkspaceFile(nameArg);
+    return ws?.kind === "class" ? 8 : 0;
   }
   if (typeArg === "dir") {
-    const fio = ctx.rt.fileIO;
-    if (!fio?.existsPath) return FALL_THROUGH;
-    return fio.existsPath(nameArg) === "dir" ? 7 : 0;
-  }
-  if (typeArg === "file" || typeArg === "") {
-    const fio = ctx.rt.fileIO;
-    if (!fio?.existsPath) return FALL_THROUGH;
-    const result = fio.existsPath(nameArg);
-    if (typeArg === "file") return result === "file" ? 2 : 0;
+    return walkSearchPath(true) === 7 ? 7 : 0;
+  }
+  if (typeArg === "file") {
+    const t = walkSearchPath(true);
+    if (t) return t;
+    return workspaceTypeId();
+  }
+  if (typeArg === "") {
     if (ctx.env.has(nameArg)) return 1;
-    if (result === "dir") return 7;
-    if (result === "file") return 2;
-    if (ctx.rt.builtins[nameArg] || getIBuiltin(nameArg)) return 5;
-    return 0;
+    if (isBuiltin2()) return 5;
+    const t = walkSearchPath(true);
+    if (t) return t;
+    return workspaceTypeId();
   }
   return FALL_THROUGH;
 });
@@ -52420,8 +54260,8 @@ register("which", (ctx, args) => {
   if (args.length < 1) return FALL_THROUGH;
   const nameArg = toString(ensureRuntimeValue(args[0]));
   if (ctx.env.has(nameArg)) return RTV.char("variable");
-  const filePath = ctx.lookupWorkspaceFile(nameArg);
-  if (filePath) return RTV.char(filePath);
+  const ws = ctx.lookupWorkspaceFile(nameArg);
+  if (ws) return RTV.char(ws.path);
   if (ctx.rt.builtins[nameArg] || getIBuiltin(nameArg)) {
     return RTV.char("built-in");
   }
@@ -52568,9 +54408,11 @@ function callFunction(name, args, nargout) {
       rt: this.rt,
       lookupWorkspaceFile: (n) => {
         const entry = this.ctx.registry.filesByFuncName.get(n);
-        if (entry) return entry.fileName;
+        if (entry) return { path: entry.fileName, kind: "function" };
         const classInfo = this.ctx.getClassInfo(n);
-        if (classInfo) return classInfo.fileName;
+        if (classInfo) return { path: classInfo.fileName, kind: "class" };
+        const jsEntry = this.ctx.registry.jsUserFunctionsByName.get(n);
+        if (jsEntry) return { path: jsEntry.fileName, kind: "jsfunction" };
         return void 0;
       }
     };
@@ -52636,6 +54478,8 @@ function interpretTarget(target, args, nargout) {
       return this.interpretLocalFunction(target, args, nargout);
     case "workspaceFunction":
       return this.interpretWorkspaceFunction(target, args, nargout);
+    case "jsUserFunction":
+      return this.interpretJsUserFunction(target, args, nargout);
     case "classMethod":
       return this.interpretClassMethod(target, args, nargout);
     case "workspaceClassConstructor":
@@ -52644,6 +54488,36 @@ function interpretTarget(target, args, nargout) {
       return this.interpretPrivateFunction(target, args, nargout);
   }
 }
+function interpretJsUserFunction(target, args, nargout) {
+  const entry = this.ctx.registry.jsUserFunctionsByName.get(target.name);
+  if (!entry) {
+    throw new RuntimeError(`JS user function '${target.name}' not found`);
+  }
+  const ib = entry.builtin;
+  const margs = args.map((a) => ensureRuntimeValue(a));
+  const argTypes = margs.map(inferJitType);
+  const resolution = ib.resolve(argTypes, nargout);
+  if (!resolution) {
+    const typeNames = argTypes.map((t) => t.kind);
+    throw new RuntimeError(
+      `JS user function '${target.name}' does not support these argument types: (${typeNames.join(", ")})`
+    );
+  }
+  const isVoid = resolution.outputTypes.length === 0;
+  if (isVoid && nargout > 0) {
+    throw new RuntimeError("Too many output arguments.");
+  }
+  return this.withFileContext(entry.fileName, void 0, void 0, () => {
+    if (this.rt.profilingEnabled) {
+      this.rt.profileEnter("jsUserFunction:interp:" + target.name);
+      const result2 = resolution.apply(margs, nargout);
+      this.rt.profileLeave();
+      return isVoid ? void 0 : result2;
+    }
+    const result = resolution.apply(margs, nargout);
+    return isVoid ? void 0 : result;
+  });
+}
 function interpretLocalFunction(target, args, nargout) {
   const { source } = target;
   if (source.from === "main") {
@@ -53508,6 +55382,7 @@ function extractClassInfo(classDef, qualifiedName, fileName, source) {
 function createWorkspaceRegistry() {
   return {
     filesByFuncName: /* @__PURE__ */ new Map(),
+    jsUserFunctionsByName: /* @__PURE__ */ new Map(),
     fileContexts: /* @__PURE__ */ new Map(),
     classesByName: /* @__PURE__ */ new Map(),
     localClassesByName: /* @__PURE__ */ new Map(),
@@ -53701,6 +55576,7 @@ var LoweringContext = class _LoweringContext {
   /** Clear workspace-level registrations so they can be rebuilt after addpath/rmpath. */
   clearWorkspaceRegistrations() {
     this.registry.filesByFuncName.clear();
+    this.registry.jsUserFunctionsByName.clear();
     this.registry.classesByName.clear();
     this.registry.privateFilesByDir.clear();
     this.registry.fileContexts.clear();
@@ -53708,6 +55584,14 @@ var LoweringContext = class _LoweringContext {
     this.registry.externalAccessByFile.clear();
     this.registry.functionIndex = null;
   }
+  /**
+   * Register a JS user function (.numbl.js) in the workspace registry.
+   * Uses first-wins semantics so search-path priority is honored.
+   */
+  registerJsUserFunction(funcName, fileName, builtin) {
+    if (this.registry.jsUserFunctionsByName.has(funcName)) return;
+    this.registry.jsUserFunctionsByName.set(funcName, { fileName, builtin });
+  }
   // ── Private function management ──────────────────────────────────
   /**
    * Get the effective directory for this context's file, used for
@@ -53971,19 +55855,15 @@ var LoweringContext = class _LoweringContext {
    * Should be called once after registerWorkspaceFiles() and registerLocalFunctionAST().
    * Parses all workspace files eagerly to discover subfunctions.
    */
-  buildFunctionIndex(jsUserFunctionNames) {
+  buildFunctionIndex() {
     const builtins = /* @__PURE__ */ new Set([
       ...getAllBuiltinNames(),
       ...getAllIBuiltinNames(),
       ...SPECIAL_BUILTIN_NAMES
     ]);
-    const jsUserFunctions = /* @__PURE__ */ new Set();
-    if (jsUserFunctionNames) {
-      for (const name of jsUserFunctionNames) {
-        builtins.delete(name);
-        jsUserFunctions.add(name);
-      }
-    }
+    const jsUserFunctions = new Set(
+      this.registry.jsUserFunctionsByName.keys()
+    );
     const mainLocalFunctions = new Set(this.localFunctionASTs.keys());
     const workspaceFunctions = new Set(this.registry.filesByFuncName.keys());
     const workspaceClasses = /* @__PURE__ */ new Set([
@@ -54517,7 +56397,7 @@ function executeCode(source, options = {}, workspaceFiles, mainFileName = "scrip
     for (const f of workspaceFiles) {
       if (f.name.endsWith(".m")) {
         mWorkspaceFiles.push(f);
-      } else if (f.name.endsWith(".js")) {
+      } else if (isNumblJsFile(f.name)) {
         jsWorkspaceFiles.push(f);
       } else if (f.name.endsWith(".wasm")) {
         wasmWorkspaceFiles.push(f);
@@ -54541,6 +56421,8 @@ function executeCode(source, options = {}, workspaceFiles, mainFileName = "scrip
           for (const f of cwdFiles) {
             if (f.name.endsWith(".m")) {
               mWorkspaceFiles.push(f);
+            } else if (isNumblJsFile(f.name)) {
+              jsWorkspaceFiles.push(f);
             }
           }
         }
@@ -54554,7 +56436,6 @@ function executeCode(source, options = {}, workspaceFiles, mainFileName = "scrip
     wasmWorkspaceFiles,
     nativeBridge
   );
-  const jsUserFunctionNames = jsUserFunctions.map((ib) => ib.name);
   const stdlibShimNames = /* @__PURE__ */ new Set();
   for (const f of stdlibFiles) {
     mWorkspaceFiles.push(f);
@@ -54601,19 +56482,21 @@ function executeCode(source, options = {}, workspaceFiles, mainFileName = "scrip
   if (mWorkspaceFiles.length > 0) {
     ctx.registerWorkspaceFiles(mWorkspaceFiles);
   }
-  const functionIndex = ctx.buildFunctionIndex(jsUserFunctionNames);
+  for (const entry of jsUserFunctions) {
+    ctx.registerJsUserFunction(entry.name, entry.fileName, entry.builtin);
+  }
+  const functionIndex = ctx.buildFunctionIndex();
   const savedSpecialBuiltins = /* @__PURE__ */ new Map();
   for (const name of SPECIAL_BUILTIN_NAMES) {
     const existing = getIBuiltin(name);
     if (existing) savedSpecialBuiltins.set(name, existing);
   }
   const rt = new Runtime(options, options.initialVariableValues);
-  const savedIBuiltins = /* @__PURE__ */ new Map();
-  for (const ib of jsUserFunctions) {
-    const orig = getIBuiltin(ib.name);
-    if (orig) savedIBuiltins.set(ib.name, orig);
-    registerDynamicIBuiltin(ib);
+  const jsBuiltinMap = /* @__PURE__ */ new Map();
+  for (const [n, e] of ctx.registry.jsUserFunctionsByName.entries()) {
+    jsBuiltinMap.set(n, e.builtin);
   }
+  rt.jitHelpers = buildPerRuntimeJitHelpers(jsBuiltinMap);
   if (options.customBuiltins) {
     Object.assign(rt.builtins, options.customBuiltins);
     Object.assign(rt.customBuiltins, options.customBuiltins);
@@ -54648,6 +56531,14 @@ ${jsCode}`
   interpreter.installRuntimeCallbacks();
   rt.searchPaths = ctx.registry.searchPaths;
   let pathsModified = false;
+  const loadedJsUserFunctions = [...jsUserFunctions];
+  const rebuildJitHelpers = () => {
+    const map = /* @__PURE__ */ new Map();
+    for (const [n, e] of ctx.registry.jsUserFunctionsByName.entries()) {
+      map.set(n, e.builtin);
+    }
+    rt.jitHelpers = buildPerRuntimeJitHelpers(map);
+  };
   const rebuildWorkspace = () => {
     const paths = ctx.registry.searchPaths;
     const priorityOf = (name) => {
@@ -54666,11 +56557,18 @@ ${jsCode}`
       return bestIdx;
     };
     mWorkspaceFiles.sort((a, b) => priorityOf(a.name) - priorityOf(b.name));
+    loadedJsUserFunctions.sort(
+      (a, b) => priorityOf(a.fileName) - priorityOf(b.fileName)
+    );
     ctx.clearWorkspaceRegistrations();
     ctx.registerWorkspaceFiles(mWorkspaceFiles);
-    const newIndex = ctx.buildFunctionIndex(jsUserFunctionNames);
+    for (const entry of loadedJsUserFunctions) {
+      ctx.registerJsUserFunction(entry.name, entry.fileName, entry.builtin);
+    }
+    const newIndex = ctx.buildFunctionIndex();
     interpreter.functionIndex = newIndex;
     interpreter.clearAllCaches();
+    rebuildJitHelpers();
     pathsModified = true;
   };
   rt.onPathChange = (action, dir, position) => {
@@ -54709,24 +56607,32 @@ ${jsCode}`
             }
             interpreter.fileSources.set(f.name, f.source);
             mWorkspaceFiles.push(f);
-          } else if (f.name.endsWith(".js")) {
+          } else if (isNumblJsFile(f.name)) {
             newJsFiles.push(f);
+            if (!jsWorkspaceFiles.some((e) => e.name === f.name)) {
+              jsWorkspaceFiles.push(f);
+            }
           } else if (f.name.endsWith(".wasm")) {
             newWasmFiles.push(f);
+            if (!wasmWorkspaceFiles.some((e) => e.name === f.name)) {
+              wasmWorkspaceFiles.push(f);
+            }
           }
         }
         if (newJsFiles.length > 0) {
-          const newIBuiltins = loadJsUserFunctions(
+          const loaded = loadJsUserFunctions(
             newJsFiles,
             newWasmFiles,
             nativeBridge
           );
-          for (const ib of newIBuiltins) {
-            const orig = getIBuiltin(ib.name);
-            if (orig) savedIBuiltins.set(ib.name, orig);
-            registerDynamicIBuiltin(ib);
-            if (!jsUserFunctionNames.includes(ib.name)) {
-              jsUserFunctionNames.push(ib.name);
+          for (const entry of loaded) {
+            const existingIdx = loadedJsUserFunctions.findIndex(
+              (e) => e.fileName === entry.fileName
+            );
+            if (existingIdx >= 0) {
+              loadedJsUserFunctions[existingIdx] = entry;
+            } else {
+              loadedJsUserFunctions.push(entry);
             }
           }
         }
@@ -54744,6 +56650,21 @@ ${jsCode}`
           mWorkspaceFiles.splice(i, 1);
         }
       }
+      for (let i = loadedJsUserFunctions.length - 1; i >= 0; i--) {
+        if (loadedJsUserFunctions[i].fileName.startsWith(prefix)) {
+          loadedJsUserFunctions.splice(i, 1);
+        }
+      }
+      for (let i = jsWorkspaceFiles.length - 1; i >= 0; i--) {
+        if (jsWorkspaceFiles[i].name.startsWith(prefix)) {
+          jsWorkspaceFiles.splice(i, 1);
+        }
+      }
+      for (let i = wasmWorkspaceFiles.length - 1; i >= 0; i--) {
+        if (wasmWorkspaceFiles[i].name.startsWith(prefix)) {
+          wasmWorkspaceFiles.splice(i, 1);
+        }
+      }
     }
     rebuildWorkspace();
   };
@@ -54771,6 +56692,24 @@ ${jsCode}`
           mWorkspaceFiles.splice(i, 1);
         }
       }
+      for (let i = loadedJsUserFunctions.length - 1; i >= 0; i--) {
+        const fname = loadedJsUserFunctions[i].fileName;
+        if ((fname === implicitCwdPath || fname.startsWith(oldPrefix)) && !fileBelongsToDeeperPath(fname)) {
+          loadedJsUserFunctions.splice(i, 1);
+        }
+      }
+      for (let i = jsWorkspaceFiles.length - 1; i >= 0; i--) {
+        const fname = jsWorkspaceFiles[i].name;
+        if ((fname === implicitCwdPath || fname.startsWith(oldPrefix)) && !fileBelongsToDeeperPath(fname)) {
+          jsWorkspaceFiles.splice(i, 1);
+        }
+      }
+      for (let i = wasmWorkspaceFiles.length - 1; i >= 0; i--) {
+        const fname = wasmWorkspaceFiles[i].name;
+        if ((fname === implicitCwdPath || fname.startsWith(oldPrefix)) && !fileBelongsToDeeperPath(fname)) {
+          wasmWorkspaceFiles.splice(i, 1);
+        }
+      }
       const oldIdx = ctx.registry.searchPaths.indexOf(implicitCwdPath);
       if (oldIdx >= 0) ctx.registry.searchPaths.splice(oldIdx, 1);
       implicitCwdPath = null;
@@ -54787,6 +56726,8 @@ ${jsCode}`
         newFiles = fileIO.scanDirectory(absNewCwd);
       } catch {
       }
+      const newJsFiles = [];
+      const newWasmFiles = [];
       for (const f of newFiles) {
         if (f.name.endsWith(".m") && !ctx.fileASTCache.has(f.name)) {
           try {
@@ -54803,6 +56744,33 @@ ${jsCode}`
           }
           interpreter.fileSources.set(f.name, f.source);
           mWorkspaceFiles.push(f);
+        } else if (isNumblJsFile(f.name)) {
+          newJsFiles.push(f);
+          if (!jsWorkspaceFiles.some((e) => e.name === f.name)) {
+            jsWorkspaceFiles.push(f);
+          }
+        } else if (f.name.endsWith(".wasm")) {
+          newWasmFiles.push(f);
+          if (!wasmWorkspaceFiles.some((e) => e.name === f.name)) {
+            wasmWorkspaceFiles.push(f);
+          }
+        }
+      }
+      if (newJsFiles.length > 0) {
+        const loaded = loadJsUserFunctions(
+          newJsFiles,
+          newWasmFiles,
+          nativeBridge
+        );
+        for (const entry of loaded) {
+          const existingIdx = loadedJsUserFunctions.findIndex(
+            (e) => e.fileName === entry.fileName
+          );
+          if (existingIdx >= 0) {
+            loadedJsUserFunctions[existingIdx] = entry;
+          } else {
+            loadedJsUserFunctions.push(entry);
+          }
         }
       }
     }
@@ -54812,9 +56780,11 @@ ${jsCode}`
     const nestedSearchPaths = ctx.registry.searchPaths.filter(
       (p2) => p2 !== SHIM_SEARCH_PATH && p2 !== implicitCwdPath
     );
-    const nestedWorkspaceFiles = mWorkspaceFiles.filter(
-      (f) => !stdlibShimNames.has(f.name)
-    );
+    const nestedWorkspaceFiles = [
+      ...mWorkspaceFiles.filter((f) => !stdlibShimNames.has(f.name)),
+      ...jsWorkspaceFiles,
+      ...wasmWorkspaceFiles
+    ];
     const evalResult = executeCode(
       code,
       {
@@ -54860,16 +56830,19 @@ ${jitSections.join("\n\n")}` : "// No JS generated",
         executionTimeMs,
         jitCompileTimeMs: rt.getJitCompileTimeMs(),
         builtins: rt.getBuiltinProfile(),
-        dispatches: rt.getDispatchProfile()
+        dispatches: rt.getDispatchProfile(),
+        hotLoops: [...rt.hotLoops.values()]
       };
     }
     if (pathsModified) {
       result.searchPaths = ctx.registry.searchPaths.filter(
         (p2) => p2 !== SHIM_SEARCH_PATH && p2 !== implicitCwdPath
       );
-      result.workspaceFiles = mWorkspaceFiles.filter(
-        (f) => !stdlibShimNames.has(f.name)
-      );
+      result.workspaceFiles = [
+        ...mWorkspaceFiles.filter((f) => !stdlibShimNames.has(f.name)),
+        ...jsWorkspaceFiles,
+        ...wasmWorkspaceFiles
+      ];
     }
     result.implicitCwdPath = implicitCwdPath;
     return result;
@@ -54899,14 +56872,6 @@ ${jitSections.join("\n\n")}` : "// No JS generated";
       jitHelpers._profileEnter = Function.prototype;
       jitHelpers._profileLeave = Function.prototype;
     }
-    for (const ib of jsUserFunctions) {
-      const orig = savedIBuiltins.get(ib.name);
-      if (orig) {
-        registerDynamicIBuiltin(orig);
-      } else {
-        unregisterIBuiltin(ib.name);
-      }
-    }
     for (const [, ib] of savedSpecialBuiltins) {
       registerDynamicIBuiltin(ib);
     }