numbl 0.0.17 → 0.0.18

package/dist-cli/cli.js

@@ -1275,11 +1275,13 @@ var getItemTypeFromRuntimeValue = (value) => {
         length: "unknown"
         // do not include length or we get too many jits
       };
-    case "struct":
-      return {
-        kind: "Struct",
-        knownFields: Array.from(value.fields.keys())
-      };
+    case "struct": {
+      const knownFields = {};
+      for (const [k, v] of value.fields) {
+        knownFields[k] = getItemTypeFromRuntimeValue(v);
+      }
+      return { kind: "Struct", knownFields };
+    }
     case "function":
       return {
         kind: "Function",
@@ -17022,10 +17024,309 @@ function eig(data, n, computeVL, computeVR, balance) {
     VR: computeVR ? vr : void 0
   };
 }
-function linsolveComplex(_ARe, _AIm, _m, _n, _BRe, _BIm, _nrhs) {
-  throw new Error(
-    "linsolveComplex: not yet implemented in pure-TypeScript fallback; the native LAPACK addon is required for complex matrix left-division"
-  );
+function linsolveComplex(ARe, AIm, m, n, BRe, BIm, nrhs) {
+  if (m === n) {
+    const aRe = new Float64Array(ARe);
+    const aIm = new Float64Array(AIm);
+    const bRe = new Float64Array(BRe);
+    const bIm = new Float64Array(BIm);
+    const ipiv = new Int32Array(n);
+    for (let k = 0; k < n; k++) {
+      let maxVal = aRe[k + k * n] * aRe[k + k * n] + aIm[k + k * n] * aIm[k + k * n];
+      let maxIdx = k;
+      for (let i = k + 1; i < n; i++) {
+        const v = aRe[i + k * n] * aRe[i + k * n] + aIm[i + k * n] * aIm[i + k * n];
+        if (v > maxVal) {
+          maxVal = v;
+          maxIdx = i;
+        }
+      }
+      ipiv[k] = maxIdx;
+      if (maxIdx !== k) {
+        for (let j = 0; j < n; j++) {
+          let tmp = aRe[k + j * n];
+          aRe[k + j * n] = aRe[maxIdx + j * n];
+          aRe[maxIdx + j * n] = tmp;
+          tmp = aIm[k + j * n];
+          aIm[k + j * n] = aIm[maxIdx + j * n];
+          aIm[maxIdx + j * n] = tmp;
+        }
+      }
+      if (maxVal === 0) throw new Error("linsolveComplex: matrix is singular");
+      const dRe = aRe[k + k * n];
+      const dIm = aIm[k + k * n];
+      const dAbs2 = dRe * dRe + dIm * dIm;
+      for (let i = k + 1; i < n; i++) {
+        const numRe = aRe[i + k * n];
+        const numIm = aIm[i + k * n];
+        const lRe = (numRe * dRe + numIm * dIm) / dAbs2;
+        const lIm = (numIm * dRe - numRe * dIm) / dAbs2;
+        aRe[i + k * n] = lRe;
+        aIm[i + k * n] = lIm;
+        for (let j = k + 1; j < n; j++) {
+          aRe[i + j * n] -= lRe * aRe[k + j * n] - lIm * aIm[k + j * n];
+          aIm[i + j * n] -= lRe * aIm[k + j * n] + lIm * aRe[k + j * n];
+        }
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      const pi = ipiv[i];
+      if (pi !== i) {
+        for (let c = 0; c < nrhs; c++) {
+          let tmp = bRe[i + c * n];
+          bRe[i + c * n] = bRe[pi + c * n];
+          bRe[pi + c * n] = tmp;
+          tmp = bIm[i + c * n];
+          bIm[i + c * n] = bIm[pi + c * n];
+          bIm[pi + c * n] = tmp;
+        }
+      }
+    }
+    for (let c = 0; c < nrhs; c++) {
+      for (let i = 1; i < n; i++) {
+        for (let k = 0; k < i; k++) {
+          const lRe = aRe[i + k * n];
+          const lIm = aIm[i + k * n];
+          bRe[i + c * n] -= lRe * bRe[k + c * n] - lIm * bIm[k + c * n];
+          bIm[i + c * n] -= lRe * bIm[k + c * n] + lIm * bRe[k + c * n];
+        }
+      }
+    }
+    for (let c = 0; c < nrhs; c++) {
+      for (let i = n - 1; i >= 0; i--) {
+        for (let k = i + 1; k < n; k++) {
+          const uRe = aRe[i + k * n];
+          const uIm = aIm[i + k * n];
+          bRe[i + c * n] -= uRe * bRe[k + c * n] - uIm * bIm[k + c * n];
+          bIm[i + c * n] -= uRe * bIm[k + c * n] + uIm * bRe[k + c * n];
+        }
+        const dRe = aRe[i + i * n];
+        const dIm = aIm[i + i * n];
+        const dAbs2 = dRe * dRe + dIm * dIm;
+        const xRe = (bRe[i + c * n] * dRe + bIm[i + c * n] * dIm) / dAbs2;
+        const xIm = (bIm[i + c * n] * dRe - bRe[i + c * n] * dIm) / dAbs2;
+        bRe[i + c * n] = xRe;
+        bIm[i + c * n] = xIm;
+      }
+    }
+    return { re: bRe, im: bIm };
+  } else if (m > n) {
+    const kk = n;
+    const aRe = new Float64Array(ARe);
+    const aIm = new Float64Array(AIm);
+    const tauRe = new Float64Array(kk);
+    const tauIm = new Float64Array(kk);
+    for (let j = 0; j < kk; j++) {
+      let xnorm2 = 0;
+      for (let i = j + 1; i < m; i++) {
+        xnorm2 += aRe[i + j * m] * aRe[i + j * m] + aIm[i + j * m] * aIm[i + j * m];
+      }
+      const alphaRe = aRe[j + j * m];
+      const alphaIm = aIm[j + j * m];
+      const alphaAbs2 = alphaRe * alphaRe + alphaIm * alphaIm;
+      if (xnorm2 === 0 && alphaIm === 0) {
+        tauRe[j] = 0;
+        tauIm[j] = 0;
+        continue;
+      }
+      const xnorm = Math.sqrt(alphaAbs2 + xnorm2);
+      const betaRe = alphaRe >= 0 ? -xnorm : xnorm;
+      const diffRe = betaRe - alphaRe;
+      const diffIm = -alphaIm;
+      tauRe[j] = diffRe / betaRe;
+      tauIm[j] = diffIm / betaRe;
+      const denomRe = alphaRe - betaRe;
+      const denomIm = alphaIm;
+      const denomAbs2 = denomRe * denomRe + denomIm * denomIm;
+      for (let i = j + 1; i < m; i++) {
+        const numRe = aRe[i + j * m];
+        const numIm = aIm[i + j * m];
+        aRe[i + j * m] = (numRe * denomRe + numIm * denomIm) / denomAbs2;
+        aIm[i + j * m] = (numIm * denomRe - numRe * denomIm) / denomAbs2;
+      }
+      aRe[j + j * m] = betaRe;
+      aIm[j + j * m] = 0;
+      for (let col = j + 1; col < n; col++) {
+        let wRe = aRe[j + col * m];
+        let wIm = aIm[j + col * m];
+        for (let i = 1; i < m - j; i++) {
+          const vRe = aRe[j + i + j * m];
+          const vIm = -aIm[j + i + j * m];
+          wRe += vRe * aRe[j + i + col * m] - vIm * aIm[j + i + col * m];
+          wIm += vRe * aIm[j + i + col * m] + vIm * aRe[j + i + col * m];
+        }
+        const twRe = tauRe[j] * wRe - tauIm[j] * wIm;
+        const twIm = tauRe[j] * wIm + tauIm[j] * wRe;
+        aRe[j + col * m] -= twRe;
+        aIm[j + col * m] -= twIm;
+        for (let i = 1; i < m - j; i++) {
+          const vRe = aRe[j + i + j * m];
+          const vIm = aIm[j + i + j * m];
+          aRe[j + i + col * m] -= vRe * twRe - vIm * twIm;
+          aIm[j + i + col * m] -= vRe * twIm + vIm * twRe;
+        }
+      }
+    }
+    const bRe = new Float64Array(BRe);
+    const bIm = new Float64Array(BIm);
+    for (let j = 0; j < kk; j++) {
+      if (tauRe[j] === 0 && tauIm[j] === 0) continue;
+      for (let c = 0; c < nrhs; c++) {
+        let wRe = bRe[j + c * m];
+        let wIm = bIm[j + c * m];
+        for (let i = 1; i < m - j; i++) {
+          const vRe = aRe[j + i + j * m];
+          const vIm = -aIm[j + i + j * m];
+          wRe += vRe * bRe[j + i + c * m] - vIm * bIm[j + i + c * m];
+          wIm += vRe * bIm[j + i + c * m] + vIm * bRe[j + i + c * m];
+        }
+        const twRe = tauRe[j] * wRe - tauIm[j] * wIm;
+        const twIm = tauRe[j] * wIm + tauIm[j] * wRe;
+        bRe[j + c * m] -= twRe;
+        bIm[j + c * m] -= twIm;
+        for (let i = 1; i < m - j; i++) {
+          const vRe = aRe[j + i + j * m];
+          const vIm = aIm[j + i + j * m];
+          bRe[j + i + c * m] -= vRe * twRe - vIm * twIm;
+          bIm[j + i + c * m] -= vRe * twIm + vIm * twRe;
+        }
+      }
+    }
+    const xRe = new Float64Array(n * nrhs);
+    const xIm = new Float64Array(n * nrhs);
+    for (let c = 0; c < nrhs; c++) {
+      for (let i = n - 1; i >= 0; i--) {
+        let valRe = bRe[i + c * m];
+        let valIm = bIm[i + c * m];
+        for (let k = i + 1; k < n; k++) {
+          const rRe = aRe[i + k * m];
+          const rIm = aIm[i + k * m];
+          valRe -= rRe * xRe[k + c * n] - rIm * xIm[k + c * n];
+          valIm -= rRe * xIm[k + c * n] + rIm * xRe[k + c * n];
+        }
+        const dRe = aRe[i + i * m];
+        const dIm = aIm[i + i * m];
+        const dAbs2 = dRe * dRe + dIm * dIm;
+        xRe[i + c * n] = (valRe * dRe + valIm * dIm) / dAbs2;
+        xIm[i + c * n] = (valIm * dRe - valRe * dIm) / dAbs2;
+      }
+    }
+    return { re: xRe, im: xIm };
+  } else {
+    const ahRe = new Float64Array(n * m);
+    const ahIm = new Float64Array(n * m);
+    for (let i = 0; i < m; i++) {
+      for (let j = 0; j < n; j++) {
+        ahRe[j + i * n] = ARe[i + j * m];
+        ahIm[j + i * n] = -AIm[i + j * m];
+      }
+    }
+    const kk = m;
+    const tauRe = new Float64Array(kk);
+    const tauIm = new Float64Array(kk);
+    for (let j = 0; j < kk; j++) {
+      let xnorm2 = 0;
+      for (let i = j + 1; i < n; i++) {
+        xnorm2 += ahRe[i + j * n] * ahRe[i + j * n] + ahIm[i + j * n] * ahIm[i + j * n];
+      }
+      const alphaRe = ahRe[j + j * n];
+      const alphaIm = ahIm[j + j * n];
+      const alphaAbs2 = alphaRe * alphaRe + alphaIm * alphaIm;
+      if (xnorm2 === 0 && alphaIm === 0) {
+        tauRe[j] = 0;
+        tauIm[j] = 0;
+        continue;
+      }
+      const xnorm = Math.sqrt(alphaAbs2 + xnorm2);
+      const betaRe = alphaRe >= 0 ? -xnorm : xnorm;
+      const diffRe = betaRe - alphaRe;
+      const diffIm = -alphaIm;
+      tauRe[j] = diffRe / betaRe;
+      tauIm[j] = diffIm / betaRe;
+      const denomRe = alphaRe - betaRe;
+      const denomIm = alphaIm;
+      const denomAbs2 = denomRe * denomRe + denomIm * denomIm;
+      for (let i = j + 1; i < n; i++) {
+        const numRe = ahRe[i + j * n];
+        const numIm = ahIm[i + j * n];
+        ahRe[i + j * n] = (numRe * denomRe + numIm * denomIm) / denomAbs2;
+        ahIm[i + j * n] = (numIm * denomRe - numRe * denomIm) / denomAbs2;
+      }
+      ahRe[j + j * n] = betaRe;
+      ahIm[j + j * n] = 0;
+      for (let col = j + 1; col < m; col++) {
+        let wRe = ahRe[j + col * n];
+        let wIm = ahIm[j + col * n];
+        for (let i = 1; i < n - j; i++) {
+          const vRe = ahRe[j + i + j * n];
+          const vIm = -ahIm[j + i + j * n];
+          wRe += vRe * ahRe[j + i + col * n] - vIm * ahIm[j + i + col * n];
+          wIm += vRe * ahIm[j + i + col * n] + vIm * ahRe[j + i + col * n];
+        }
+        const twRe = tauRe[j] * wRe - tauIm[j] * wIm;
+        const twIm = tauRe[j] * wIm + tauIm[j] * wRe;
+        ahRe[j + col * n] -= twRe;
+        ahIm[j + col * n] -= twIm;
+        for (let i = 1; i < n - j; i++) {
+          const vRe = ahRe[j + i + j * n];
+          const vIm = ahIm[j + i + j * n];
+          ahRe[j + i + col * n] -= vRe * twRe - vIm * twIm;
+          ahIm[j + i + col * n] -= vRe * twIm + vIm * twRe;
+        }
+      }
+    }
+    const yRe = new Float64Array(m * nrhs);
+    const yIm = new Float64Array(m * nrhs);
+    for (let c = 0; c < nrhs; c++) {
+      for (let i = 0; i < m; i++) {
+        let valRe = BRe[i + c * m];
+        let valIm = BIm[i + c * m];
+        for (let k = 0; k < i; k++) {
+          const rRe = ahRe[k + i * n];
+          const rIm = -ahIm[k + i * n];
+          valRe -= rRe * yRe[k + c * m] - rIm * yIm[k + c * m];
+          valIm -= rRe * yIm[k + c * m] + rIm * yRe[k + c * m];
+        }
+        const dRe = ahRe[i + i * n];
+        const dIm = -ahIm[i + i * n];
+        const dAbs2 = dRe * dRe + dIm * dIm;
+        yRe[i + c * m] = (valRe * dRe + valIm * dIm) / dAbs2;
+        yIm[i + c * m] = (valIm * dRe - valRe * dIm) / dAbs2;
+      }
+    }
+    const xRe = new Float64Array(n * nrhs);
+    const xIm = new Float64Array(n * nrhs);
+    for (let i = 0; i < m; i++) {
+      for (let c = 0; c < nrhs; c++) {
+        xRe[i + c * n] = yRe[i + c * m];
+        xIm[i + c * n] = yIm[i + c * m];
+      }
+    }
+    for (let j = kk - 1; j >= 0; j--) {
+      if (tauRe[j] === 0 && tauIm[j] === 0) continue;
+      for (let c = 0; c < nrhs; c++) {
+        let wRe = xRe[j + c * n];
+        let wIm = xIm[j + c * n];
+        for (let i = 1; i < n - j; i++) {
+          const vRe = ahRe[j + i + j * n];
+          const vIm = -ahIm[j + i + j * n];
+          wRe += vRe * xRe[j + i + c * n] - vIm * xIm[j + i + c * n];
+          wIm += vRe * xIm[j + i + c * n] + vIm * xRe[j + i + c * n];
+        }
+        const twRe = tauRe[j] * wRe - tauIm[j] * wIm;
+        const twIm = tauRe[j] * wIm + tauIm[j] * wRe;
+        xRe[j + c * n] -= twRe;
+        xIm[j + c * n] -= twIm;
+        for (let i = 1; i < n - j; i++) {
+          const vRe = ahRe[j + i + j * n];
+          const vIm = ahIm[j + i + j * n];
+          xRe[j + i + c * n] -= vRe * twRe - vIm * twIm;
+          xIm[j + i + c * n] -= vRe * twIm + vIm * twRe;
+        }
+      }
+    }
+    return { re: xRe, im: xIm };
+  }
 }
 function lu(data, m, n) {
   const a = new Float64Array(data);
@@ -17181,8 +17482,11 @@ function typeToString(ty) {
       return `Function<${ty.params.map(typeToString).join(", ")}, ${typeToString(
         ty.returns
       )}>`;
-    case "Struct":
-      return `Struct<${ty.knownFields ? ty.knownFields.join(", ") : "?"}>`;
+    case "Struct": {
+      const entries = Object.entries(ty.knownFields);
+      if (entries.length === 0) return "Struct<>";
+      return `Struct<${entries.map(([k, v]) => `${k}: ${typeToString(v)}`).join(", ")}>`;
+    }
     case "Void":
       return "Void";
     case "Unknown":
@@ -17227,6 +17531,8 @@ function isChar(t) {
   if (t.kind === "Unknown") return void 0;
   return false;
 }
+var isScalarType = (t) => t.kind === "Number" || t.kind === "Boolean" || t.kind === "ComplexNumber";
+var isComplexType = (t) => t.kind === "ComplexNumber" || t.kind === "Tensor" && !!t.isComplex;
 var IType = {
   Num: { kind: "Number" },
   Complex: { kind: "ComplexNumber" },
@@ -17254,7 +17560,7 @@ var IType = {
   func(params, returns) {
     return { kind: "Function", params, returns };
   },
-  struct(fields) {
+  struct(fields = {}) {
     return { kind: "Struct", knownFields: fields };
   },
   union(types) {
@@ -17319,16 +17625,34 @@ var IType = {
         }
         case "Struct": {
           if (b.kind === "Struct") {
-            const knownFields = a.knownFields.filter(
-              (f) => b.knownFields.includes(f)
-            );
+            const knownFields = {};
+            for (const [k, v] of Object.entries(a.knownFields)) {
+              if (k in b.knownFields) {
+                knownFields[k] = IType.unify(v, b.knownFields[k]) ?? IType.Unknown;
+              } else {
+                knownFields[k] = v;
+              }
+            }
+            for (const [k, v] of Object.entries(b.knownFields)) {
+              if (!(k in a.knownFields)) {
+                knownFields[k] = v;
+              }
+            }
             return { kind: "Struct", knownFields };
           }
           break;
         }
         case "Union": {
           if (b.kind === "Union") {
-            const types = Array.from(/* @__PURE__ */ new Set([...a.types, ...b.types]));
+            const seen = /* @__PURE__ */ new Set();
+            const types = [];
+            for (const t of [...a.types, ...b.types]) {
+              const key = typeToString(t);
+              if (!seen.has(key)) {
+                seen.add(key);
+                types.push(t);
+              }
+            }
             return { kind: "Union", types };
           }
           break;
@@ -17413,18 +17737,19 @@ function unregister(name) {
 }
 
 // src/numbl-core/builtins/linear-algebra/check-helpers.ts
+function isMatrixLike(A) {
+  return isFullyUnknown(A) || isNum(A) === true || isComplex(A) === true || A.kind === "Boolean" || isTensor(A) === true;
+}
+function isOptionalStringArg(arg) {
+  if (arg === void 0) return true;
+  return isFullyUnknown(arg) || arg.kind === "String" || arg.kind === "Char";
+}
 function out(...types) {
   return { outputTypes: types };
 }
 function unknownMatrix(isComplex2) {
   return IType.tensor({ isComplex: isComplex2 || void 0 });
 }
-function matrix(_shapeOrComplex, isComplex2) {
-  if (typeof _shapeOrComplex === "boolean") {
-    return IType.tensor({ isComplex: _shapeOrComplex || void 0 });
-  }
-  return IType.tensor({ isComplex: isComplex2 || void 0 });
-}
 function parseEconArg(argType) {
   if (argType === void 0) return false;
   if (isFullyUnknown(argType)) return "unknown";
@@ -17444,6 +17769,103 @@ function parseStringArgLower(arg) {
   }
   return String(arg).toLowerCase();
 }
+function parseEconArgRuntime(arg) {
+  if (arg === void 0) return false;
+  if (isRuntimeNumber(arg) && arg === 0) return true;
+  if (isRuntimeString(arg) && arg.toLowerCase() === "econ") return true;
+  if (isRuntimeChar(arg) && arg.value.toLowerCase() === "econ") return true;
+  return false;
+}
+function buildEigenvectorMatrix(packedV, wi, n, hasComplex) {
+  if (!hasComplex) {
+    return RTV.tensor(new FloatXArray(packedV), [n, n]);
+  }
+  const realPart = new FloatXArray(n * n);
+  const imagPart = new FloatXArray(n * n);
+  let j = 0;
+  while (j < n) {
+    if (Math.abs(wi[j]) === 0) {
+      for (let i = 0; i < n; i++) {
+        realPart[colMajorIndex(i, j, n)] = packedV[colMajorIndex(i, j, n)];
+      }
+      j++;
+    } else {
+      for (let i = 0; i < n; i++) {
+        const re = packedV[colMajorIndex(i, j, n)];
+        const im = packedV[colMajorIndex(i, j + 1, n)];
+        realPart[colMajorIndex(i, j, n)] = re;
+        imagPart[colMajorIndex(i, j, n)] = im;
+        realPart[colMajorIndex(i, j + 1, n)] = re;
+        imagPart[colMajorIndex(i, j + 1, n)] = -im;
+      }
+      j += 2;
+    }
+  }
+  return RTV.tensor(realPart, [n, n], imagPart);
+}
+function maybeComplexTensor(re, shape, im) {
+  const imag = im && im.some((v) => v !== 0) ? new FloatXArray(im) : void 0;
+  return RTV.tensor(new FloatXArray(re), shape, imag);
+}
+function buildDiagMatrix(realVals, imagVals, size) {
+  const [rows, cols] = typeof size === "number" ? [size, size] : size;
+  const k = Math.min(rows, cols, realVals.length);
+  const dReal = new FloatXArray(rows * cols);
+  for (let i = 0; i < k; i++) dReal[colMajorIndex(i, i, rows)] = realVals[i];
+  if (imagVals && imagVals.some((v) => v !== 0)) {
+    const dImag = new FloatXArray(rows * cols);
+    for (let i = 0; i < k; i++) dImag[colMajorIndex(i, i, rows)] = imagVals[i];
+    return RTV.tensor(dReal, [rows, cols], dImag);
+  }
+  return RTV.tensor(dReal, [rows, cols]);
+}
+function gaussJordanEliminate(aug, rows, totalCols) {
+  for (let col = 0; col < rows; col++) {
+    let maxVal = Math.abs(aug[col * rows + col]);
+    let maxRow = col;
+    for (let row = col + 1; row < rows; row++) {
+      const val = Math.abs(aug[col * rows + row]);
+      if (val > maxVal) {
+        maxVal = val;
+        maxRow = row;
+      }
+    }
+    if (maxRow !== col) {
+      for (let j = 0; j < totalCols; j++) {
+        const tmp = aug[j * rows + col];
+        aug[j * rows + col] = aug[j * rows + maxRow];
+        aug[j * rows + maxRow] = tmp;
+      }
+    }
+    const pivot = aug[col * rows + col];
+    if (Math.abs(pivot) < 1e-14) continue;
+    for (let j = 0; j < totalCols; j++) aug[j * rows + col] /= pivot;
+    for (let row = 0; row < rows; row++) {
+      if (row === col) continue;
+      const factor = aug[col * rows + row];
+      for (let j = 0; j < totalCols; j++) {
+        aug[j * rows + row] -= factor * aug[j * rows + col];
+      }
+    }
+  }
+}
+function applyBuiltin(caller, name, args, nargout) {
+  const branches = getBuiltin(name);
+  if (!branches)
+    throw new RuntimeError(`${caller}: builtin '${name}' not found`);
+  for (const branch of branches) {
+    const result = branch.apply(args, nargout);
+    if (result !== void 0) {
+      if (result instanceof Promise)
+        throw new RuntimeError(
+          `${caller}: builtin '${name}' returned async result`
+        );
+      if (Array.isArray(result)) return result[0];
+      return result;
+    }
+  }
+  throw new RuntimeError(`${caller}: builtin '${name}' returned no result`);
+}
 
 // src/numbl-core/builtins/linear-algebra/linsolve.ts
 function linsolveLapack(A, m, n, B, nrhs) {
@@ -17472,11 +17894,8 @@ function registerLinsolve() {
     {
       check: (argTypes, nargout) => {
         if (argTypes.length !== 2 || nargout !== 1) return null;
-        const A = argTypes[0];
-        const B = argTypes[1];
-        if (isFullyUnknown(A) || isFullyUnknown(B)) return out(unknownMatrix());
-        if (isNum(A) === true || isNum(B) === true) return out(unknownMatrix());
-        if (isTensor(A) !== true || isTensor(B) !== true) return null;
+        if (!isMatrixLike(argTypes[0]) || !isMatrixLike(argTypes[1]))
+          return null;
         return out(unknownMatrix());
       },
       apply: (args) => {
@@ -17516,23 +17935,36 @@ function registerLinsolve() {
   ]);
 }
 
-// src/numbl-core/builtins/linear-algebra/applyBuiltin.ts
-function applyBuiltin(caller, name, args, nargout) {
-  const branches = getBuiltin(name);
-  if (!branches)
-    throw new RuntimeError(`${caller}: builtin '${name}' not found`);
-  for (const branch of branches) {
-    const result = branch.apply(args, nargout);
-    if (result !== void 0) {
-      if (result instanceof Promise)
-        throw new RuntimeError(
-          `${caller}: builtin '${name}' returned async result`
-        );
-      if (Array.isArray(result)) return result[0];
-      return result;
-    }
+// src/numbl-core/builtins/shape-utils.ts
+function parseShapeArgs(args) {
+  if (args.length === 1 && isRuntimeTensor(args[0])) {
+    const t = args[0];
+    const shape = [];
+    for (let i = 0; i < t.data.length; i++)
+      shape.push(Math.max(0, Math.round(t.data[i])));
+    return shape;
   }
-  throw new RuntimeError(`${caller}: builtin '${name}' returned no result`);
+  return args.map((a) => Math.max(0, Math.round(toNumber(a))));
+}
+function coerceToTensor(v, name) {
+  if (isRuntimeTensor(v)) return v;
+  if (isRuntimeNumber(v))
+    return RTV.tensor(new FloatXArray([v]), [1, 1]);
+  if (isRuntimeLogical(v))
+    return RTV.tensor(new FloatXArray([v ? 1 : 0]), [1, 1]);
+  if (isRuntimeComplexNumber(v))
+    return RTV.tensor(
+      new FloatXArray([v.re]),
+      [1, 1],
+      new FloatXArray([v.im])
+    );
+  throw new RuntimeError(`${name}: argument must be numeric`);
+}
+function toNumericVector(v, name) {
+  if (isRuntimeNumber(v)) return [v];
+  if (isRuntimeLogical(v)) return [v ? 1 : 0];
+  if (isRuntimeTensor(v)) return Array.from(v.data);
+  throw new RuntimeError(`${name}: argument must be numeric`);
 }
 
 // src/numbl-core/builtins/arithmetic.ts
@@ -17725,10 +18157,8 @@ function mElemMul(a, b) {
   return binaryOp(a, b, (x, y) => x * y);
 }
 function mDiv(a, b) {
-  if (isRuntimeTensor(b) && !isRuntimeNumber(a) && !isRuntimeLogical(a)) {
-    const at = mConjugateTranspose(
-      isRuntimeNumber(a) || isRuntimeLogical(a) ? RTV.tensor(new FloatXArray([toNumber(a)]), [1, 1]) : a
-    );
+  if (isRuntimeTensor(b)) {
+    const at = mConjugateTranspose(coerceToTensor(a, "mrdivide"));
     const bt = mConjugateTranspose(b);
     const result = mLeftDiv(bt, at);
     return mConjugateTranspose(result);
@@ -21306,13 +21736,13 @@ var ExpressionParser = class extends ParserBase {
       }
       case 51 /* LBracket */: {
         const start = info.position;
-        const matrix2 = this.parseMatrix();
+        const matrix = this.parseMatrix();
         if (!this.consume(52 /* RBracket */)) {
           throw this.error("expected ']' to close matrix literal");
         }
         const end = this.lastTokenEnd();
         const span = this.spanFrom(start, end);
-        return { ...matrix2, span };
+        return { ...matrix, span };
       }
       case 53 /* LBrace */: {
         const start = info.position;
@@ -23877,10 +24307,17 @@ function elemwise(fn, o) {
       const result = fn(v ? 1 : 0);
       return o?.isLogical ? RTV.logical(!!result) : RTV.num(result);
     }
+    if (o?.complex && isRuntimeComplexNumber(v))
+      return RTV.complex(fn(v.re), fn(v.im));
     if (isRuntimeTensor(v)) {
       const result = new FloatXArray(v.data.length);
       for (let i = 0; i < v.data.length; i++) result[i] = fn(v.data[i]);
-      const t = RTV.tensor(result, v.shape);
+      let imag;
+      if (o?.complex && v.imag) {
+        imag = new FloatXArray(v.imag.length);
+        for (let i = 0; i < v.imag.length; i++) imag[i] = fn(v.imag[i]);
+      }
+      const t = RTV.tensor(result, v.shape, imag);
       if (o?.isLogical) t._isLogical = true;
       return t;
     }
@@ -23907,70 +24344,34 @@ function elemwise(fn, o) {
   });
   return ret;
 }
-function elemwiseComplex(fn, o) {
-  const ret = [];
-  const apply = (args) => {
-    if (args.length !== 1) throw new RuntimeError(`Expected 1 argument`);
-    const v = args[0];
-    if (isRuntimeNumber(v)) return RTV.num(fn(v));
-    if (isRuntimeLogical(v)) return RTV.num(fn(v ? 1 : 0));
-    if (isRuntimeComplexNumber(v)) return RTV.complex(fn(v.re), fn(v.im));
-    if (isRuntimeTensor(v)) {
-      const result = new FloatXArray(v.data.length);
-      for (let i = 0; i < v.data.length; i++) result[i] = fn(v.data[i]);
-      let imag;
-      if (v.imag) {
-        imag = new FloatXArray(v.imag.length);
-        for (let i = 0; i < v.imag.length; i++) imag[i] = fn(v.imag[i]);
-      }
-      return RTV.tensor(result, v.shape, imag);
-    }
-    throw new RuntimeError("Expected numeric argument");
-  };
-  if (o?.nativeJs) {
-    ret.push({
-      check: (argTypes) => {
-        if (argTypes.length !== 1) return null;
-        if (argTypes[0].kind !== "Number") return null;
-        return { outputTypes: [{ kind: "Number" }] };
-      },
-      apply,
-      nativeJsFn: o.nativeJs
-    });
+function binaryApply(a, b, fn) {
+  const aIsT = isRuntimeTensor(a);
+  const bIsT = isRuntimeTensor(b);
+  if (aIsT && bIsT) {
+    const result = new FloatXArray(a.data.length);
+    for (let i = 0; i < a.data.length; i++)
+      result[i] = fn(a.data[i], b.data[i]);
+    return RTV.tensor(result, a.shape);
   }
-  ret.push({
-    check: elemwiseCheck,
-    apply
-  });
-  return ret;
+  if (aIsT) {
+    const bv = toNumber(b);
+    const result = new FloatXArray(a.data.length);
+    for (let i = 0; i < a.data.length; i++) result[i] = fn(a.data[i], bv);
+    return RTV.tensor(result, a.shape);
+  }
+  if (bIsT) {
+    const av = toNumber(a);
+    const result = new FloatXArray(b.data.length);
+    for (let i = 0; i < b.data.length; i++) result[i] = fn(av, b.data[i]);
+    return RTV.tensor(result, b.shape);
+  }
+  return RTV.num(fn(toNumber(a), toNumber(b)));
 }
 function binaryScalar(fn, o) {
   const ret = [];
   const apply = (args) => {
     if (args.length !== 2) throw new RuntimeError(`Expected 2 arguments`);
-    const a = args[0];
-    const b = args[1];
-    const aIsT = isRuntimeTensor(a);
-    const bIsT = isRuntimeTensor(b);
-    if (aIsT && bIsT) {
-      const result = new FloatXArray(a.data.length);
-      for (let i = 0; i < a.data.length; i++)
-        result[i] = fn(a.data[i], b.data[i]);
-      return RTV.tensor(result, a.shape);
-    }
-    if (aIsT) {
-      const bv = toNumber(b);
-      const result = new FloatXArray(a.data.length);
-      for (let i = 0; i < a.data.length; i++) result[i] = fn(a.data[i], bv);
-      return RTV.tensor(result, a.shape);
-    }
-    if (bIsT) {
-      const av = toNumber(a);
-      const result = new FloatXArray(b.data.length);
-      for (let i = 0; i < b.data.length; i++) result[i] = fn(av, b.data[i]);
-      return RTV.tensor(result, b.shape);
-    }
-    return RTV.num(fn(toNumber(a), toNumber(b)));
+    return binaryApply(args[0], args[1], fn);
   };
   if (o?.nativeJs) {
     ret.push({
@@ -23993,32 +24394,6 @@ function binaryScalar(fn, o) {
   });
   return ret;
 }
-function applyBesselBinary(nuArg, zArg, fn) {
-  const nuIsT = isRuntimeTensor(nuArg);
-  const zIsT = isRuntimeTensor(zArg);
-  if (!nuIsT && !zIsT) {
-    return RTV.num(fn(toNumber(nuArg), toNumber(zArg)));
-  }
-  if (!nuIsT && zIsT) {
-    const nu = toNumber(nuArg);
-    const result2 = new FloatXArray(zArg.data.length);
-    for (let i = 0; i < zArg.data.length; i++) result2[i] = fn(nu, zArg.data[i]);
-    return RTV.tensor(result2, zArg.shape);
-  }
-  if (nuIsT && !zIsT) {
-    const z = toNumber(zArg);
-    const result2 = new FloatXArray(nuArg.data.length);
-    for (let i = 0; i < nuArg.data.length; i++)
-      result2[i] = fn(nuArg.data[i], z);
-    return RTV.tensor(result2, nuArg.shape);
-  }
-  const nut = nuArg;
-  const zt = zArg;
-  const result = new FloatXArray(nut.data.length);
-  for (let i = 0; i < nut.data.length; i++)
-    result[i] = fn(nut.data[i], zt.data[i]);
-  return RTV.tensor(result, nut.shape);
-}
 function registerMathFunctions() {
   register(
     "sin",
@@ -24261,106 +24636,19 @@ function registerMathFunctions() {
   );
   register(
     "sqrt",
-    [
-      // Num branch: returns Num if value is known and non-negative, otherwise Complex
-      {
-        check: (argTypes) => {
-          if (argTypes.length !== 1 || argTypes[0].kind !== "Number")
-            return null;
-          return { outputTypes: [{ kind: "ComplexNumber" }] };
-        },
-        apply: (args) => {
-          if (args.length !== 1) throw new RuntimeError("Expected 1 argument");
-          const v = args[0];
-          if (isRuntimeNumber(v)) {
-            if (v < 0) return RTV.complex(0, Math.sqrt(-v));
-            return RTV.num(Math.sqrt(v));
-          }
-          if (isRuntimeComplexNumber(v)) {
-            const r = Math.sqrt(v.re * v.re + v.im * v.im);
-            const theta = Math.atan2(v.im, v.re);
-            const sqrtR = Math.sqrt(r);
-            const reim = {
-              re: sqrtR * Math.cos(theta / 2),
-              im: sqrtR * Math.sin(theta / 2)
-            };
-            return reim.im === 0 ? RTV.num(reim.re) : RTV.complex(reim.re, reim.im);
-          }
-          return RTV.num(Math.sqrt(toNumber(v)));
-        }
-      },
-      // Complex input branch
-      {
-        check: (argTypes) => {
-          if (argTypes.length !== 1 || argTypes[0].kind !== "ComplexNumber")
-            return null;
-          return { outputTypes: [{ kind: "ComplexNumber" }] };
-        },
-        apply: (args) => {
-          if (args.length !== 1) throw new RuntimeError("Expected 1 argument");
-          const v = args[0];
-          if (isRuntimeComplexNumber(v)) {
-            const r = Math.sqrt(v.re * v.re + v.im * v.im);
-            const theta = Math.atan2(v.im, v.re);
-            const sqrtR = Math.sqrt(r);
-            const re = sqrtR * Math.cos(theta / 2), im = sqrtR * Math.sin(theta / 2);
-            return im === 0 ? RTV.num(re) : RTV.complex(re, im);
-          }
-          if (isRuntimeNumber(v)) {
-            if (v < 0) return RTV.complex(0, Math.sqrt(-v));
-            return RTV.num(Math.sqrt(v));
-          }
-          return RTV.num(Math.sqrt(toNumber(v)));
-        }
+    complexElemwise(
+      Math.sqrt,
+      (re, im) => {
+        const r = Math.sqrt(re * re + im * im);
+        const theta = Math.atan2(im, re);
+        const sqrtR = Math.sqrt(r);
+        return {
+          re: sqrtR * Math.cos(theta / 2),
+          im: sqrtR * Math.sin(theta / 2)
+        };
       },
-      // Fallback
-      {
-        check: elemwiseCheck,
-        apply: (args) => {
-          if (args.length !== 1) throw new RuntimeError("Expected 1 argument");
-          const v = args[0];
-          if (isRuntimeNumber(v)) {
-            if (v < 0) return RTV.complex(0, Math.sqrt(-v));
-            return RTV.num(Math.sqrt(v));
-          }
-          if (isRuntimeTensor(v)) {
-            let hasNeg = false;
-            for (let i = 0; i < v.data.length; i++) {
-              if (v.data[i] < 0) {
-                hasNeg = true;
-                break;
-              }
-            }
-            if (hasNeg || v.imag) {
-              const re = new FloatXArray(v.data.length);
-              const im = new FloatXArray(v.data.length);
-              for (let i = 0; i < v.data.length; i++) {
-                const rePart = v.data[i];
-                const imPart = v.imag ? v.imag[i] : 0;
-                const r = Math.sqrt(rePart * rePart + imPart * imPart);
-                const theta = Math.atan2(imPart, rePart);
-                const sqrtR = Math.sqrt(r);
-                re[i] = sqrtR * Math.cos(theta / 2);
-                im[i] = sqrtR * Math.sin(theta / 2);
-              }
-              let allRealZeroIm = true;
-              for (let i = 0; i < im.length; i++) {
-                if (im[i] !== 0) {
-                  allRealZeroIm = false;
-                  break;
-                }
-              }
-              return RTV.tensor(re, v.shape, allRealZeroIm ? void 0 : im);
-            }
-            const result = new FloatXArray(v.data.length);
-            for (let i = 0; i < v.data.length; i++)
-              result[i] = Math.sqrt(v.data[i]);
-            return RTV.tensor(result, v.shape);
-          }
-          return RTV.num(Math.sqrt(toNumber(v)));
-        }
-      }
-    ],
+      "ComplexNumber"
+    ),
     1
   );
   register(
@@ -24373,8 +24661,16 @@ function registerMathFunctions() {
     ),
     1
   );
-  register("floor", elemwiseComplex(Math.floor, { nativeJs: "Math.floor" }), 1);
-  register("ceil", elemwiseComplex(Math.ceil, { nativeJs: "Math.ceil" }), 1);
+  register(
+    "floor",
+    elemwise(Math.floor, { nativeJs: "Math.floor", complex: true }),
+    1
+  );
+  register(
+    "ceil",
+    elemwise(Math.ceil, { nativeJs: "Math.ceil", complex: true }),
+    1
+  );
   register(
     "round",
     builtinSingle((args) => {
@@ -24903,7 +25199,7 @@ function registerMathFunctions() {
         if (args.length < 2 || args.length > 3)
           throw new RuntimeError(`${name} requires 2 or 3 arguments`);
         const scale = args.length === 3 ? toNumber(args[2]) : 0;
-        return applyBesselBinary(args[0], args[1], (nu, z) => {
+        return binaryApply(args[0], args[1], (nu, z) => {
           const val = fn(nu, z);
           return scale === 1 ? val * scaleFn(z) : val;
         });
@@ -25201,18 +25497,6 @@ function legendreAllOrders(n, x) {
   return result;
 }
 
-// src/numbl-core/builtins/shape-utils.ts
-function parseShapeArgs(args) {
-  if (args.length === 1 && isRuntimeTensor(args[0])) {
-    const t = args[0];
-    const shape = [];
-    for (let i = 0; i < t.data.length; i++)
-      shape.push(Math.max(0, Math.round(t.data[i])));
-    return shape;
-  }
-  return args.map((a) => Math.max(0, Math.round(toNumber(a))));
-}
-
 // src/numbl-core/builtins/prng.ts
 var _rngState = null;
 var _rngSeed = 0;
@@ -26499,18 +26783,7 @@ function registerArrayManipulationFunctions() {
     builtinSingle((args) => {
       if (args.length !== 2)
         throw new RuntimeError("permute requires 2 arguments");
-      let v = args[0];
-      if (isRuntimeNumber(v)) {
-        v = RTV.tensor(new FloatXArray([v]), [1, 1]);
-      } else if (isRuntimeComplexNumber(v)) {
-        v = RTV.tensor(
-          new FloatXArray([v.re]),
-          [1, 1],
-          new FloatXArray([v.im])
-        );
-      } else if (!isRuntimeTensor(v)) {
-        throw new RuntimeError("permute: first argument must be a tensor");
-      }
+      const v = coerceToTensor(args[0], "permute");
       const orderArg = args[1];
       let order;
       if (isRuntimeTensor(orderArg)) {
@@ -26547,18 +26820,7 @@ function registerArrayManipulationFunctions() {
     builtinSingle((args) => {
       if (args.length !== 2)
         throw new RuntimeError("ipermute requires 2 arguments");
-      let v = args[0];
-      if (isRuntimeNumber(v)) {
-        v = RTV.tensor(new FloatXArray([v]), [1, 1]);
-      } else if (isRuntimeComplexNumber(v)) {
-        v = RTV.tensor(
-          new FloatXArray([v.re]),
-          [1, 1],
-          new FloatXArray([v.im])
-        );
-      } else if (!isRuntimeTensor(v)) {
-        throw new RuntimeError("ipermute: first argument must be a tensor");
-      }
+      const v = coerceToTensor(args[0], "ipermute");
       const orderArg = args[1];
       let order;
       if (isRuntimeTensor(orderArg)) {
@@ -26867,18 +27129,18 @@ function registerIntrospectionFunctions() {
       return RTV.logical(false);
     })
   );
-  register(
-    "isscalar",
+  const typePred = (name, pred) => register(
+    name,
     builtinSingle((args) => {
       if (args.length !== 1)
-        throw new RuntimeError("isscalar requires 1 argument");
-      const v = args[0];
-      if (isRuntimeNumber(v) || isRuntimeLogical(v) || isRuntimeComplexNumber(v))
-        return RTV.logical(true);
-      if (isRuntimeTensor(v)) return RTV.logical(v.data.length === 1);
-      return RTV.logical(false);
+        throw new RuntimeError(`${name} requires 1 argument`);
+      return RTV.logical(pred(args[0]));
     })
   );
+  typePred(
+    "isscalar",
+    (v) => isRuntimeNumber(v) || isRuntimeLogical(v) || isRuntimeComplexNumber(v) || isRuntimeTensor(v) && v.data.length === 1
+  );
   const getShape = (v) => {
     if (isRuntimeNumber(v) || isRuntimeLogical(v)) return [1, 1];
     if (isRuntimeTensor(v))
@@ -26887,118 +27149,36 @@ function registerIntrospectionFunctions() {
       return v.shape ?? (v.value.length === 0 ? [0, 0] : [1, v.value.length]);
     return [1, 1];
   };
-  register(
-    "isvector",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("isvector requires 1 argument");
-      const shape = getShape(args[0]);
-      const dimsGt1 = shape.filter((d) => d > 1).length;
-      return RTV.logical(dimsGt1 <= 1);
-    })
-  );
-  register(
-    "isrow",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("isrow requires 1 argument");
-      const shape = getShape(args[0]);
-      return RTV.logical(shape.length === 2 && shape[0] === 1);
-    })
-  );
-  register(
-    "iscolumn",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("iscolumn requires 1 argument");
-      const shape = getShape(args[0]);
-      return RTV.logical(shape.length === 2 && shape[1] === 1);
-    })
-  );
-  register(
-    "ismatrix",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("ismatrix requires 1 argument");
-      const shape = getShape(args[0]);
-      return RTV.logical(shape.length <= 2);
-    })
-  );
-  register(
+  typePred("isvector", (v) => {
+    const shape = getShape(v);
+    return shape.filter((d) => d > 1).length <= 1;
+  });
+  typePred("isrow", (v) => {
+    const shape = getShape(v);
+    return shape.length === 2 && shape[0] === 1;
+  });
+  typePred("iscolumn", (v) => {
+    const shape = getShape(v);
+    return shape.length === 2 && shape[1] === 1;
+  });
+  typePred("ismatrix", (v) => getShape(v).length <= 2);
+  typePred(
     "isfloat",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("isfloat requires 1 argument");
-      const v = args[0];
-      return RTV.logical(
-        isRuntimeNumber(v) || isRuntimeTensor(v) || isRuntimeComplexNumber(v)
-      );
-    })
-  );
-  register(
-    "isinteger",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("isinteger requires 1 argument");
-      return RTV.logical(false);
-    })
+    (v) => isRuntimeNumber(v) || isRuntimeTensor(v) || isRuntimeComplexNumber(v)
   );
-  register(
+  typePred("isinteger", () => false);
+  typePred(
     "isnumeric",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("isnumeric requires 1 argument");
-      const v = args[0];
-      return RTV.logical(
-        isRuntimeNumber(v) || isRuntimeTensor(v) || isRuntimeComplexNumber(v) || isRuntimeClassInstance(v) && v._builtinData !== void 0
-      );
-    })
+    (v) => isRuntimeNumber(v) || isRuntimeTensor(v) || isRuntimeComplexNumber(v) || isRuntimeClassInstance(v) && v._builtinData !== void 0
   );
-  register(
+  typePred(
     "islogical",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("islogical requires 1 argument");
-      const v = args[0];
-      return RTV.logical(
-        isRuntimeLogical(v) || isRuntimeTensor(v) && v._isLogical === true
-      );
-    })
-  );
-  register(
-    "ischar",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("ischar requires 1 argument");
-      return RTV.logical(isRuntimeChar(args[0]));
-    })
-  );
-  register(
-    "isstring",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("isstring requires 1 argument");
-      return RTV.logical(isRuntimeString(args[0]));
-    })
-  );
-  register(
-    "iscell",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("iscell requires 1 argument");
-      return RTV.logical(isRuntimeCell(args[0]));
-    })
-  );
-  register(
-    "isstruct",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("isstruct requires 1 argument");
-      return RTV.logical(
-        isRuntimeStruct(args[0]) || isRuntimeStructArray(args[0])
-      );
-    })
+    (v) => isRuntimeLogical(v) || isRuntimeTensor(v) && v._isLogical === true
   );
+  typePred("ischar", (v) => isRuntimeChar(v));
+  typePred("isstring", (v) => isRuntimeString(v));
+  typePred("iscell", (v) => isRuntimeCell(v));
+  typePred("isstruct", (v) => isRuntimeStruct(v) || isRuntimeStructArray(v));
   register(
     "isequal",
     builtinSingle((args) => {
@@ -27816,9 +27996,12 @@ function registerReductionFunctions() {
           if (scalar2 !== null) return scalar2;
           if (isRuntimeTensor(v)) {
             if (v.data.length === 0) return RTV.logical(mode === "all");
-            if (v.shape[0] === 1)
+            const numNonSingleton = v.shape.filter((d) => d > 1).length;
+            if (numNonSingleton <= 1) {
               return RTV.logical(scanLogical(v.data, v.imag, mode));
-            return logicalAlongDim(v, 1, mode);
+            }
+            const firstNonSingleton = v.shape.findIndex((d) => d > 1);
+            return logicalAlongDim(v, firstNonSingleton + 1, mode);
           }
           throw new RuntimeError(
             `${name}: argument must be numeric or logical`
@@ -30247,9 +30430,6 @@ function registerSymvar() {
 }
 
 // src/numbl-core/builtins/linear-algebra/norm.ts
-function complexAbs(re, im) {
-  return Math.sqrt(re * re + im * im);
-}
 function registerNorm() {
   register(
     "norm",
@@ -30259,7 +30439,7 @@ function registerNorm() {
           throw new RuntimeError("norm requires at least 1 argument");
         const v = args[0];
         if (isRuntimeNumber(v)) return RTV.num(Math.abs(v));
-        if (isRuntimeComplexNumber(v)) return RTV.num(complexAbs(v.re, v.im));
+        if (isRuntimeComplexNumber(v)) return RTV.num(Math.hypot(v.re, v.im));
         if (!isRuntimeTensor(v))
           throw new RuntimeError("norm: argument must be numeric");
         const shape = v.shape;
@@ -30284,7 +30464,7 @@ function registerNorm() {
           if (vp === Infinity) {
             let m = 0;
             for (let i = 0; i < v.data.length; i++) {
-              const a = imag ? complexAbs(v.data[i], imag[i]) : Math.abs(v.data[i]);
+              const a = imag ? Math.hypot(v.data[i], imag[i]) : Math.abs(v.data[i]);
               m = Math.max(m, a);
             }
             return RTV.num(m);
@@ -30292,14 +30472,14 @@ function registerNorm() {
           if (vp === -Infinity) {
             let m = Infinity;
             for (let i = 0; i < v.data.length; i++) {
-              const a = imag ? complexAbs(v.data[i], imag[i]) : Math.abs(v.data[i]);
+              const a = imag ? Math.hypot(v.data[i], imag[i]) : Math.abs(v.data[i]);
               m = Math.min(m, a);
             }
             return RTV.num(m);
           }
           let s = 0;
           for (let i = 0; i < v.data.length; i++) {
-            const a = imag ? complexAbs(v.data[i], imag[i]) : Math.abs(v.data[i]);
+            const a = imag ? Math.hypot(v.data[i], imag[i]) : Math.abs(v.data[i]);
             s += Math.pow(a, vp);
           }
           return RTV.num(Math.pow(s, 1 / vp));
@@ -30319,7 +30499,7 @@ function registerNorm() {
             let colSum = 0;
             for (let i = 0; i < rows; i++) {
               const idx = j * rows + i;
-              colSum += imag ? complexAbs(v.data[idx], imag[idx]) : Math.abs(v.data[idx]);
+              colSum += imag ? Math.hypot(v.data[idx], imag[idx]) : Math.abs(v.data[idx]);
             }
             maxColSum = Math.max(maxColSum, colSum);
           }
@@ -30331,7 +30511,7 @@ function registerNorm() {
             let rowSum = 0;
             for (let j = 0; j < cols; j++) {
               const idx = j * rows + i;
-              rowSum += imag ? complexAbs(v.data[idx], imag[idx]) : Math.abs(v.data[idx]);
+              rowSum += imag ? Math.hypot(v.data[idx], imag[idx]) : Math.abs(v.data[idx]);
             }
             maxRowSum = Math.max(maxRowSum, rowSum);
           }
@@ -30462,23 +30642,11 @@ function registerQr() {
       check: (argTypes, nargout) => {
         if (nargout < 1 || nargout > 2 || argTypes.length < 1 || argTypes.length > 2)
           return null;
-        const econ = parseEconArg(argTypes[1]);
-        if (econ === null) return null;
-        const A = argTypes[0];
-        const cpx = A.kind === "Tensor" && A.isComplex;
-        if (nargout === 1) {
-          if (isFullyUnknown(A)) return out(unknownMatrix());
-          if (isNum(A) === true) return out(matrix([1, 1]));
-          if (isTensor(A) !== true) return null;
-          return out(unknownMatrix(cpx || void 0));
-        }
-        if (isFullyUnknown(A)) return out(unknownMatrix(), unknownMatrix());
-        if (isNum(A) === true) return out(matrix([1, 1]), matrix([1, 1]));
-        if (isTensor(A) !== true) return null;
-        return out(
-          unknownMatrix(cpx || void 0),
-          unknownMatrix(cpx || void 0)
-        );
+        if (parseEconArg(argTypes[1]) === null) return null;
+        if (!isMatrixLike(argTypes[0])) return null;
+        const cpx = argTypes[0].kind === "Tensor" && argTypes[0].isComplex || void 0;
+        if (nargout === 1) return out(unknownMatrix(cpx));
+        return out(unknownMatrix(cpx), unknownMatrix(cpx));
       },
       apply: (args, nargout) => {
         if (args.length < 1)
@@ -30495,13 +30663,7 @@ function registerQr() {
         }
         if (!isRuntimeTensor(A))
           throw new RuntimeError("qr: argument must be numeric");
-        let econ = false;
-        if (args.length >= 2) {
-          const opt = args[1];
-          if (isRuntimeNumber(opt) && opt === 0) econ = true;
-          else if (isRuntimeString(opt) && opt.replace(/^['"]|['"]$/g, "").toLowerCase() === "econ")
-            econ = true;
-        }
+        const econ = parseEconArgRuntime(args[1]);
         const [m, n] = tensorSize2D(A);
         const k = Math.min(m, n);
         if (A.imag) {
@@ -30752,10 +30914,8 @@ function registerInv() {
       check: (argTypes, nargout) => {
         if (argTypes.length !== 1 || nargout !== 1) return null;
         const A = argTypes[0];
-        if (isFullyUnknown(A)) return out(unknownMatrix());
-        if (isComplex(A) === true || isNum(A) === true) return out(A);
-        if (isTensor(A) !== true) return null;
-        return out(A);
+        if (!isMatrixLike(A)) return null;
+        return out(A.kind === "Unknown" ? unknownMatrix() : A);
       },
       apply: (args) => {
         if (args.length < 1) throw new RuntimeError("inv requires 1 argument");
@@ -30890,10 +31050,7 @@ function registerDet() {
     {
       check: (argTypes, nargout) => {
         if (argTypes.length !== 1 || nargout !== 1) return null;
-        const A = argTypes[0];
-        if (isFullyUnknown(A)) return out(IType.num());
-        if (isNum(A) === true || A.kind === "Boolean") return out(IType.num());
-        if (isTensor(A) !== true) return null;
+        if (!isMatrixLike(argTypes[0])) return null;
         return out(IType.num());
       },
       apply: (args) => {
@@ -30919,10 +31076,7 @@ function registerDet() {
     {
       check: (argTypes, nargout) => {
         if (argTypes.length !== 1 || nargout !== 1) return null;
-        const A = argTypes[0];
-        if (isFullyUnknown(A)) return out(IType.num());
-        if (isNum(A) === true || A.kind === "Boolean") return out(IType.num());
-        if (isTensor(A) !== true) return null;
+        if (!isMatrixLike(argTypes[0])) return null;
         return out(IType.num());
       },
       apply: (args) => {
@@ -31012,20 +31166,9 @@ function registerSvd() {
       check: (argTypes, nargout) => {
         if (nargout < 1 || nargout > 3 || argTypes.length < 1 || argTypes.length > 2)
           return null;
-        const econ = parseEconArg(argTypes[1]);
-        if (econ === null) return null;
-        const A = argTypes[0];
-        if (nargout === 1) {
-          if (isFullyUnknown(A)) return out(unknownMatrix());
-          if (isNum(A) === true) return out(matrix([1, 1]));
-          if (isTensor(A) !== true) return null;
-          return out(unknownMatrix());
-        }
-        if (isFullyUnknown(A))
-          return out(unknownMatrix(), unknownMatrix(), unknownMatrix());
-        if (isNum(A) === true)
-          return out(matrix([1, 1]), matrix([1, 1]), matrix([1, 1]));
-        if (isTensor(A) !== true) return null;
+        if (parseEconArg(argTypes[1]) === null) return null;
+        if (!isMatrixLike(argTypes[0])) return null;
+        if (nargout === 1) return out(unknownMatrix());
         return out(unknownMatrix(), unknownMatrix(), unknownMatrix());
       },
       apply: (args, nargout) => {
@@ -31044,15 +31187,7 @@ function registerSvd() {
         }
         if (!isRuntimeTensor(A))
           throw new RuntimeError("svd: argument must be numeric");
-        let econ = false;
-        if (args.length >= 2) {
-          const opt = args[1];
-          if (isRuntimeNumber(opt) && opt === 0) econ = true;
-          else if (isRuntimeString(opt) && opt.toLowerCase() === "econ")
-            econ = true;
-          else if (isRuntimeChar(opt) && opt.value.toLowerCase() === "econ")
-            econ = true;
-        }
+        const econ = parseEconArgRuntime(args[1]);
         const [m, n] = tensorSize2D(A);
         const k = Math.min(m, n);
         if (A.imag) {
@@ -31079,20 +31214,11 @@ function registerSvd() {
             [m, uCols],
             new FloatXArray(lapackResult2.UIm)
           );
-          let S;
-          if (econ) {
-            const S_data = new FloatXArray(k * k);
-            for (let i = 0; i < k; i++) {
-              S_data[colMajorIndex(i, i, k)] = lapackResult2.S[i];
-            }
-            S = RTV.tensor(S_data, [k, k]);
-          } else {
-            const S_data = new FloatXArray(m * n);
-            for (let i = 0; i < k; i++) {
-              S_data[colMajorIndex(i, i, m)] = lapackResult2.S[i];
-            }
-            S = RTV.tensor(S_data, [m, n]);
-          }
+          const S = buildDiagMatrix(
+            lapackResult2.S,
+            void 0,
+            econ ? k : [m, n]
+          );
           const V = RTV.tensor(
             new FloatXArray(lapackResult2.VRe),
             [n, vCols],
@@ -31108,20 +31234,11 @@ function registerSvd() {
           const uCols = econ ? k : m;
           const vCols = econ ? k : n;
           const U = RTV.tensor(new FloatXArray(lapackResult.U), [m, uCols]);
-          let S;
-          if (econ) {
-            const S_data = new FloatXArray(k * k);
-            for (let i = 0; i < k; i++) {
-              S_data[colMajorIndex(i, i, k)] = lapackResult.S[i];
-            }
-            S = RTV.tensor(S_data, [k, k]);
-          } else {
-            const S_data = new FloatXArray(m * n);
-            for (let i = 0; i < k; i++) {
-              S_data[colMajorIndex(i, i, m)] = lapackResult.S[i];
-            }
-            S = RTV.tensor(S_data, [m, n]);
-          }
+          const S = buildDiagMatrix(
+            lapackResult.S,
+            void 0,
+            econ ? k : [m, n]
+          );
           const V = RTV.tensor(new FloatXArray(lapackResult.V), [n, vCols]);
           return [U, S, V];
         }
@@ -31595,24 +31712,10 @@ function registerKron() {
 
 // src/numbl-core/builtins/linear-algebra/eig.ts
 function parseEigOptions(argTypes) {
-  let balance = true;
-  let outputForm = "matrix";
   for (let i = 1; i < argTypes.length; i++) {
-    const arg = argTypes[i];
-    if (isFullyUnknown(arg)) {
-      balance = "unknown";
-      outputForm = "unknown";
-      continue;
-    }
-    if (arg.kind === "String" || arg.kind === "Char") {
-      balance = "unknown";
-      outputForm = "unknown";
-      continue;
-    } else {
-      return null;
-    }
+    if (!isOptionalStringArg(argTypes[i])) return false;
   }
-  return { balance, outputForm };
+  return true;
 }
 function parseEigOptionsRuntime(args) {
   let balance = true;
@@ -31645,49 +31748,12 @@ function registerEig() {
       check: (argTypes, nargout) => {
         if (nargout < 1 || nargout > 3) return null;
         if (argTypes.length < 1 || argTypes.length > 3) return null;
-        const opts = parseEigOptions(argTypes);
-        if (opts === null) return null;
-        const A = argTypes[0];
-        if (nargout === 1) {
-          if (isFullyUnknown(A)) return out(unknownMatrix());
-          if (isNum(A) === true) return out(matrix([1, 1], true));
-          if (isTensor(A) !== true) return null;
-          return out(unknownMatrix(true));
-        }
-        if (nargout === 2) {
-          if (isFullyUnknown(A)) return out(unknownMatrix(), unknownMatrix());
-          if (isNum(A) === true)
-            return out(matrix([1, 1], true), matrix([1, 1], true));
-          if (isTensor(A) !== true) return null;
-          if (opts.outputForm === "vector") {
-            return out(unknownMatrix(true), unknownMatrix(true));
-          }
-          return out(unknownMatrix(true), unknownMatrix(true));
-        }
-        if (nargout === 3) {
-          if (isFullyUnknown(A))
-            return out(unknownMatrix(), unknownMatrix(), unknownMatrix());
-          if (isNum(A) === true)
-            return out(
-              matrix([1, 1], true),
-              matrix([1, 1], true),
-              matrix([1, 1], true)
-            );
-          if (isTensor(A) !== true) return null;
-          if (opts.outputForm === "vector") {
-            return out(
-              unknownMatrix(true),
-              unknownMatrix(true),
-              unknownMatrix(true)
-            );
-          }
-          return out(
-            unknownMatrix(true),
-            unknownMatrix(true),
-            unknownMatrix(true)
-          );
-        }
-        return null;
+        if (!parseEigOptions(argTypes)) return null;
+        if (!isMatrixLike(argTypes[0])) return null;
+        const c = unknownMatrix(true);
+        if (nargout === 1) return out(c);
+        if (nargout === 2) return out(c, c);
+        return out(c, c, c);
       },
       apply: (args, nargout) => {
         if (args.length < 1)
@@ -31733,80 +31799,13 @@ function registerEig() {
             );
           }
           const { wRe, wIm, VLRe, VLIm, VRRe, VRIm } = result2;
-          let hasComplex2 = false;
-          for (let i = 0; i < n; i++) {
-            if (Math.abs(wIm[i]) > 0) {
-              hasComplex2 = true;
-              break;
-            }
-          }
           if (nargout === 1) {
-            if (hasComplex2) {
-              return RTV.tensor(
-                new FloatXArray(wRe),
-                [n, 1],
-                new FloatXArray(wIm)
-              );
-            }
-            return RTV.tensor(new FloatXArray(wRe), [n, 1]);
-          }
-          let Vout2;
-          if (computeVR && VRRe && VRIm) {
-            if (hasComplex2) {
-              Vout2 = RTV.tensor(
-                new FloatXArray(VRRe),
-                [n, n],
-                new FloatXArray(VRIm)
-              );
-            } else {
-              Vout2 = RTV.tensor(new FloatXArray(VRRe), [n, n]);
-            }
-          } else {
-            Vout2 = RTV.tensor(new FloatXArray(n * n), [n, n]);
-          }
-          let Dout2;
-          if (outputForm === "vector") {
-            if (hasComplex2) {
-              Dout2 = RTV.tensor(
-                new FloatXArray(wRe),
-                [n, 1],
-                new FloatXArray(wIm)
-              );
-            } else {
-              Dout2 = RTV.tensor(new FloatXArray(wRe), [n, 1]);
-            }
-          } else {
-            const dReal = new FloatXArray(n * n);
-            for (let i = 0; i < n; i++) {
-              dReal[colMajorIndex(i, i, n)] = wRe[i];
-            }
-            if (hasComplex2) {
-              const dImag = new FloatXArray(n * n);
-              for (let i = 0; i < n; i++) {
-                dImag[colMajorIndex(i, i, n)] = wIm[i];
-              }
-              Dout2 = RTV.tensor(dReal, [n, n], dImag);
-            } else {
-              Dout2 = RTV.tensor(dReal, [n, n]);
-            }
-          }
-          if (nargout === 2) {
-            return [Vout2, Dout2];
-          }
-          let Wout2;
-          if (computeVL && VLRe && VLIm) {
-            if (hasComplex2) {
-              Wout2 = RTV.tensor(
-                new FloatXArray(VLRe),
-                [n, n],
-                new FloatXArray(VLIm)
-              );
-            } else {
-              Wout2 = RTV.tensor(new FloatXArray(VLRe), [n, n]);
-            }
-          } else {
-            Wout2 = RTV.tensor(new FloatXArray(n * n), [n, n]);
+            return maybeComplexTensor(wRe, [n, 1], wIm);
           }
+          const Vout2 = computeVR && VRRe && VRIm ? maybeComplexTensor(VRRe, [n, n], VRIm) : RTV.tensor(new FloatXArray(n * n), [n, n]);
+          const Dout2 = outputForm === "vector" ? maybeComplexTensor(wRe, [n, 1], wIm) : buildDiagMatrix(wRe, wIm, n);
+          if (nargout === 2) return [Vout2, Dout2];
+          const Wout2 = computeVL && VLRe && VLIm ? maybeComplexTensor(VLRe, [n, n], VLIm) : RTV.tensor(new FloatXArray(n * n), [n, n]);
           return [Vout2, Dout2, Wout2];
         }
         const result = eigLapack(
@@ -31820,88 +31819,19 @@ function registerEig() {
           throw new RuntimeError("eig: LAPACK bridge not available");
         }
         const { wr, wi, VL, VR } = result;
-        let hasComplex = false;
-        for (let i = 0; i < n; i++) {
-          if (Math.abs(wi[i]) > 0) {
-            hasComplex = true;
-            break;
-          }
-        }
+        const hasComplex = wi.some((v) => v !== 0);
         if (nargout === 1) {
-          if (hasComplex) {
-            return RTV.tensor(new FloatXArray(wr), [n, 1], new FloatXArray(wi));
-          }
-          return RTV.tensor(new FloatXArray(wr), [n, 1]);
-        }
-        let Vout;
-        if (computeVR && VR) {
-          Vout = buildEigenvectorMatrix(VR, wi, n, hasComplex);
-        } else {
-          Vout = RTV.tensor(new FloatXArray(n * n), [n, n]);
-        }
-        let Dout;
-        if (outputForm === "vector") {
-          if (hasComplex) {
-            Dout = RTV.tensor(new FloatXArray(wr), [n, 1], new FloatXArray(wi));
-          } else {
-            Dout = RTV.tensor(new FloatXArray(wr), [n, 1]);
-          }
-        } else {
-          const dReal = new FloatXArray(n * n);
-          for (let i = 0; i < n; i++) {
-            dReal[colMajorIndex(i, i, n)] = wr[i];
-          }
-          if (hasComplex) {
-            const dImag = new FloatXArray(n * n);
-            for (let i = 0; i < n; i++) {
-              dImag[colMajorIndex(i, i, n)] = wi[i];
-            }
-            Dout = RTV.tensor(dReal, [n, n], dImag);
-          } else {
-            Dout = RTV.tensor(dReal, [n, n]);
-          }
-        }
-        if (nargout === 2) {
-          return [Vout, Dout];
-        }
-        let Wout;
-        if (computeVL && VL) {
-          Wout = buildEigenvectorMatrix(VL, wi, n, hasComplex);
-        } else {
-          Wout = RTV.tensor(new FloatXArray(n * n), [n, n]);
+          return maybeComplexTensor(wr, [n, 1], wi);
         }
+        const Vout = computeVR && VR ? buildEigenvectorMatrix(VR, wi, n, hasComplex) : RTV.tensor(new FloatXArray(n * n), [n, n]);
+        const Dout = outputForm === "vector" ? maybeComplexTensor(wr, [n, 1], wi) : buildDiagMatrix(wr, wi, n);
+        if (nargout === 2) return [Vout, Dout];
+        const Wout = computeVL && VL ? buildEigenvectorMatrix(VL, wi, n, hasComplex) : RTV.tensor(new FloatXArray(n * n), [n, n]);
         return [Vout, Dout, Wout];
       }
     }
   ]);
 }
-function buildEigenvectorMatrix(packedV, wi, n, hasComplex) {
-  if (!hasComplex) {
-    return RTV.tensor(new FloatXArray(packedV), [n, n]);
-  }
-  const realPart = new FloatXArray(n * n);
-  const imagPart = new FloatXArray(n * n);
-  let j = 0;
-  while (j < n) {
-    if (Math.abs(wi[j]) === 0) {
-      for (let i = 0; i < n; i++) {
-        realPart[colMajorIndex(i, j, n)] = packedV[colMajorIndex(i, j, n)];
-      }
-      j++;
-    } else {
-      for (let i = 0; i < n; i++) {
-        const re = packedV[colMajorIndex(i, j, n)];
-        const im = packedV[colMajorIndex(i, j + 1, n)];
-        realPart[colMajorIndex(i, j, n)] = re;
-        imagPart[colMajorIndex(i, j, n)] = im;
-        realPart[colMajorIndex(i, j + 1, n)] = re;
-        imagPart[colMajorIndex(i, j + 1, n)] = -im;
-      }
-      j += 2;
-    }
-  }
-  return RTV.tensor(realPart, [n, n], imagPart);
-}
 
 // src/numbl-core/builtins/linear-algebra/cond.ts
 function applyBuiltin2(name, args, nargout) {
@@ -31926,8 +31856,8 @@ function registerCond() {
         let p = 2;
         if (args.length >= 2) {
           const pArg = args[1];
-          if (isRuntimeString(pArg)) {
-            const pStr = pArg.replace(/^['"]|['"]$/g, "").toLowerCase();
+          if (isRuntimeString(pArg) || isRuntimeChar(pArg)) {
+            const pStr = parseStringArgLower(pArg);
             if (pStr === "fro") {
               p = "fro";
             } else {
@@ -32241,31 +32171,14 @@ function registerLu() {
       check: (argTypes, nargout) => {
         if (nargout < 1 || nargout > 3) return null;
         if (argTypes.length < 1 || argTypes.length > 2) return null;
-        const A = argTypes[0];
-        if (argTypes.length === 2) {
-          const fmt = argTypes[1];
-          if (!isFullyUnknown(fmt) && fmt.kind !== "String" && fmt.kind !== "Char")
-            return null;
-        }
-        if (nargout === 1) {
-          if (isFullyUnknown(A)) return out(unknownMatrix());
-          if (isNum(A) === true) return out(matrix([1, 1]));
-          if (isTensor(A) !== true) return null;
-          return out(unknownMatrix());
-        }
-        if (nargout === 2) {
-          if (isFullyUnknown(A)) return out(unknownMatrix(), unknownMatrix());
-          if (isNum(A) === true) return out(matrix([1, 1]), matrix([1, 1]));
-          if (isTensor(A) !== true) return null;
-          return out(unknownMatrix(), unknownMatrix());
-        }
-        if (isFullyUnknown(A))
-          return out(unknownMatrix(), unknownMatrix(), unknownMatrix());
-        if (isNum(A) === true)
-          return out(matrix([1, 1]), matrix([1, 1]), matrix([1, 1]));
-        if (isTensor(A) !== true || A.kind === "Tensor" && A.isComplex)
+        if (!isOptionalStringArg(argTypes[1])) return null;
+        if (!isMatrixLike(argTypes[0])) return null;
+        if (nargout === 3 && argTypes[0].kind === "Tensor" && argTypes[0].isComplex)
           return null;
-        return out(unknownMatrix(), unknownMatrix(), unknownMatrix());
+        const m = unknownMatrix();
+        if (nargout === 1) return out(m);
+        if (nargout === 2) return out(m, m);
+        return out(m, m, m);
       },
       apply: (args, nargout) => {
         if (args.length < 1)
@@ -32460,21 +32373,9 @@ function registerChol() {
       check: (argTypes, nargout) => {
         if (nargout < 1 || nargout > 2) return null;
         if (argTypes.length < 1 || argTypes.length > 2) return null;
-        const A = argTypes[0];
-        if (argTypes.length === 2) {
-          const tri = argTypes[1];
-          if (!isFullyUnknown(tri) && tri.kind !== "String" && tri.kind !== "Char")
-            return null;
-        }
-        if (nargout === 1) {
-          if (isFullyUnknown(A)) return out(unknownMatrix());
-          if (isNum(A) === true) return out(matrix([1, 1]));
-          if (isTensor(A) !== true) return null;
-          return out(unknownMatrix());
-        }
-        if (isFullyUnknown(A)) return out(unknownMatrix(), IType.num());
-        if (isNum(A) === true) return out(matrix([1, 1]), IType.num());
-        if (isTensor(A) !== true) return null;
+        if (!isOptionalStringArg(argTypes[1])) return null;
+        if (!isMatrixLike(argTypes[0])) return null;
+        if (nargout === 1) return out(unknownMatrix());
         return out(unknownMatrix(), IType.num());
       },
       apply: (args, nargout) => {
@@ -32648,48 +32549,14 @@ function pinvFallback(data, m, n) {
     }
     const augmented = new FloatXArray(n * (n + m));
     for (let i = 0; i < n; i++) {
-      for (let j = 0; j < n; j++) {
-        augmented[j * n + i] = ATA[j * n + i];
-      }
-      for (let j = 0; j < m; j++) {
-        augmented[(n + j) * n + i] = AT[j * n + i];
-      }
-    }
-    for (let col = 0; col < n; col++) {
-      let maxVal = Math.abs(augmented[col * n + col]);
-      let maxRow = col;
-      for (let row = col + 1; row < n; row++) {
-        const val = Math.abs(augmented[col * n + row]);
-        if (val > maxVal) {
-          maxVal = val;
-          maxRow = row;
-        }
-      }
-      if (maxRow !== col) {
-        for (let j = 0; j < n + m; j++) {
-          const tmp = augmented[j * n + col];
-          augmented[j * n + col] = augmented[j * n + maxRow];
-          augmented[j * n + maxRow] = tmp;
-        }
-      }
-      const pivot = augmented[col * n + col];
-      if (Math.abs(pivot) < 1e-14) continue;
-      for (let j = 0; j < n + m; j++) {
-        augmented[j * n + col] /= pivot;
-      }
-      for (let row = 0; row < n; row++) {
-        if (row === col) continue;
-        const factor = augmented[col * n + row];
-        for (let j = 0; j < n + m; j++) {
-          augmented[j * n + row] -= factor * augmented[j * n + col];
-        }
-      }
+      for (let j = 0; j < n; j++) augmented[j * n + i] = ATA[j * n + i];
+      for (let j = 0; j < m; j++) augmented[(n + j) * n + i] = AT[j * n + i];
     }
+    gaussJordanEliminate(augmented, n, n + m);
     const result = new FloatXArray(n * m);
     for (let i = 0; i < n; i++) {
-      for (let j = 0; j < m; j++) {
+      for (let j = 0; j < m; j++)
         result[j * n + i] = augmented[(n + j) * n + i];
-      }
     }
     return RTV.tensor(result, [n, m]);
   } else {
@@ -32705,54 +32572,20 @@ function pinvFallback(data, m, n) {
     }
     const augmented = new FloatXArray(m * 2 * m);
     for (let i = 0; i < m; i++) {
-      for (let j = 0; j < m; j++) {
-        augmented[j * m + i] = AAT[j * m + i];
-      }
+      for (let j = 0; j < m; j++) augmented[j * m + i] = AAT[j * m + i];
       augmented[(m + i) * m + i] = 1;
     }
-    for (let col = 0; col < m; col++) {
-      let maxVal = Math.abs(augmented[col * m + col]);
-      let maxRow = col;
-      for (let row = col + 1; row < m; row++) {
-        const val = Math.abs(augmented[col * m + row]);
-        if (val > maxVal) {
-          maxVal = val;
-          maxRow = row;
-        }
-      }
-      if (maxRow !== col) {
-        for (let j = 0; j < 2 * m; j++) {
-          const tmp = augmented[j * m + col];
-          augmented[j * m + col] = augmented[j * m + maxRow];
-          augmented[j * m + maxRow] = tmp;
-        }
-      }
-      const pivot = augmented[col * m + col];
-      if (Math.abs(pivot) < 1e-14) continue;
-      for (let j = 0; j < 2 * m; j++) {
-        augmented[j * m + col] /= pivot;
-      }
-      for (let row = 0; row < m; row++) {
-        if (row === col) continue;
-        const factor = augmented[col * m + row];
-        for (let j = 0; j < 2 * m; j++) {
-          augmented[j * m + row] -= factor * augmented[j * m + col];
-        }
-      }
-    }
+    gaussJordanEliminate(augmented, m, 2 * m);
     const AATinv = new FloatXArray(m * m);
     for (let i = 0; i < m; i++) {
-      for (let j = 0; j < m; j++) {
+      for (let j = 0; j < m; j++)
         AATinv[j * m + i] = augmented[(m + j) * m + i];
-      }
     }
     const result = new FloatXArray(n * m);
     for (let i = 0; i < n; i++) {
       for (let j = 0; j < m; j++) {
         let sum = 0;
-        for (let k = 0; k < m; k++) {
-          sum += AT[k * n + i] * AATinv[j * m + k];
-        }
+        for (let k = 0; k < m; k++) sum += AT[k * n + i] * AATinv[j * m + k];
         result[j * n + i] = sum;
       }
     }
@@ -32807,8 +32640,8 @@ function applyReal(A, B, n, nargout, computeEigvecs) {
       break;
     }
   }
-  const Vout = buildEigenvectorMatrix2(V, alphai, n, hasComplex);
-  const Wout = buildEigenvectorMatrix2(W, alphai, n, hasComplex);
+  const Vout = buildEigenvectorMatrix(V, alphai, n, hasComplex);
+  const Wout = buildEigenvectorMatrix(W, alphai, n, hasComplex);
   return [AAout, BBout, Qout, Zout, Vout, Wout];
 }
 function applyComplex(A, B, n, nargout, computeEigvecs) {
@@ -32860,44 +32693,19 @@ function registerQz() {
       check: (argTypes, nargout) => {
         if (nargout !== 4 && nargout !== 6) return null;
         if (argTypes.length < 2 || argTypes.length > 3) return null;
-        const A = argTypes[0];
-        const B = argTypes[1];
-        if (argTypes.length === 3) {
-          const mode = argTypes[2];
-          if (!isFullyUnknown(mode) && mode.kind !== "String" && mode.kind !== "Char")
-            return null;
-        }
-        if (!isFullyUnknown(A) && isTensor(A) !== true) return null;
-        if (!isFullyUnknown(B) && isTensor(B) !== true) return null;
-        if (nargout === 4) {
-          return out(
-            unknownMatrix(true),
-            unknownMatrix(true),
-            unknownMatrix(true),
-            unknownMatrix(true)
-          );
-        }
-        return out(
-          unknownMatrix(true),
-          unknownMatrix(true),
-          unknownMatrix(true),
-          unknownMatrix(true),
-          unknownMatrix(true),
-          unknownMatrix(true)
-        );
+        if (!isOptionalStringArg(argTypes[2])) return null;
+        if (!isMatrixLike(argTypes[0]) || !isMatrixLike(argTypes[1]))
+          return null;
+        const c = unknownMatrix(true);
+        if (nargout === 4) return out(c, c, c, c);
+        return out(c, c, c, c, c, c);
       },
       apply: (args, nargout) => {
         if (args.length < 2)
           throw new RuntimeError("qz requires at least 2 arguments");
         let mode = "complex";
         if (args.length >= 3) {
-          const modeArg = args[2];
-          let modeStr = "";
-          if (isRuntimeString(modeArg)) {
-            modeStr = modeArg.replace(/^['"]|['"]$/g, "").toLowerCase();
-          } else if (isRuntimeChar(modeArg)) {
-            modeStr = modeArg.value.replace(/^['"]|['"]$/g, "").toLowerCase();
-          }
+          const modeStr = parseStringArgLower(args[2]);
           if (modeStr === "complex") mode = "complex";
           else if (modeStr === "real") mode = "real";
           else throw new RuntimeError(`qz: unknown mode '${modeStr}'`);
@@ -32923,33 +32731,6 @@ function registerQz() {
     }
   ]);
 }
-function buildEigenvectorMatrix2(packedV, wi, n, hasComplex) {
-  if (!hasComplex) {
-    return RTV.tensor(new FloatXArray(packedV), [n, n]);
-  }
-  const realPart = new FloatXArray(n * n);
-  const imagPart = new FloatXArray(n * n);
-  let j = 0;
-  while (j < n) {
-    if (Math.abs(wi[j]) === 0) {
-      for (let i = 0; i < n; i++) {
-        realPart[colMajorIndex(i, j, n)] = packedV[colMajorIndex(i, j, n)];
-      }
-      j++;
-    } else {
-      for (let i = 0; i < n; i++) {
-        const re = packedV[colMajorIndex(i, j, n)];
-        const im = packedV[colMajorIndex(i, j + 1, n)];
-        realPart[colMajorIndex(i, j, n)] = re;
-        imagPart[colMajorIndex(i, j, n)] = im;
-        realPart[colMajorIndex(i, j + 1, n)] = re;
-        imagPart[colMajorIndex(i, j + 1, n)] = -im;
-      }
-      j += 2;
-    }
-  }
-  return RTV.tensor(realPart, [n, n], imagPart);
-}
 
 // src/numbl-core/builtins/linear-algebra/register-linear-algebra-functions.ts
 function registerLinearAlgebraFunctions() {
@@ -33039,51 +32820,54 @@ function registerMiscFunctions() {
   );
   register(
     "struct",
-    builtinSingle((args) => {
-      if (args.length === 0) return RTV.struct(/* @__PURE__ */ new Map());
-      if (args.length % 2 !== 0)
-        throw new RuntimeError("struct: requires field-value pairs");
-      const fieldNames = [];
-      const fieldValues = [];
-      let hasCell = false;
-      let arrayLen = -1;
-      for (let i = 0; i < args.length; i += 2) {
-        const name = toString(args[i]);
-        const val = args[i + 1];
-        fieldNames.push(name);
-        fieldValues.push(val);
-        if (isRuntimeCell(val)) {
-          hasCell = true;
-          const len = val.data.length;
-          if (arrayLen === -1) arrayLen = len;
-          else if (len !== arrayLen)
-            throw new RuntimeError(
-              "struct: cell array values must have the same length"
-            );
+    builtinSingle(
+      (args) => {
+        if (args.length === 0) return RTV.struct(/* @__PURE__ */ new Map());
+        if (args.length % 2 !== 0)
+          throw new RuntimeError("struct: requires field-value pairs");
+        const fieldNames = [];
+        const fieldValues = [];
+        let hasCell = false;
+        let arrayLen = -1;
+        for (let i = 0; i < args.length; i += 2) {
+          const name = toString(args[i]);
+          const val = args[i + 1];
+          fieldNames.push(name);
+          fieldValues.push(val);
+          if (isRuntimeCell(val)) {
+            hasCell = true;
+            const len = val.data.length;
+            if (arrayLen === -1) arrayLen = len;
+            else if (len !== arrayLen)
+              throw new RuntimeError(
+                "struct: cell array values must have the same length"
+              );
+          }
         }
-      }
-      if (!hasCell) {
-        const fields = /* @__PURE__ */ new Map();
-        for (let i = 0; i < fieldNames.length; i++) {
-          fields.set(fieldNames[i], fieldValues[i]);
+        if (!hasCell) {
+          const fields = /* @__PURE__ */ new Map();
+          for (let i = 0; i < fieldNames.length; i++) {
+            fields.set(fieldNames[i], fieldValues[i]);
+          }
+          return RTV.struct(fields);
         }
-        return RTV.struct(fields);
-      }
-      const elements = [];
-      for (let k = 0; k < arrayLen; k++) {
-        const fields = /* @__PURE__ */ new Map();
-        for (let i = 0; i < fieldNames.length; i++) {
-          const val = fieldValues[i];
-          if (isRuntimeCell(val)) {
-            fields.set(fieldNames[i], val.data[k]);
-          } else {
-            fields.set(fieldNames[i], val);
+        const elements = [];
+        for (let k = 0; k < arrayLen; k++) {
+          const fields = /* @__PURE__ */ new Map();
+          for (let i = 0; i < fieldNames.length; i++) {
+            const val = fieldValues[i];
+            if (isRuntimeCell(val)) {
+              fields.set(fieldNames[i], val.data[k]);
+            } else {
+              fields.set(fieldNames[i], val);
+            }
           }
+          elements.push(RTV.struct(fields));
         }
-        elements.push(RTV.struct(fields));
-      }
-      return RTV.structArray(fieldNames, elements);
-    })
+        return RTV.structArray(fieldNames, elements);
+      },
+      { outputType: IType.struct() }
+    )
   );
   const fieldnamesApply = builtinSingle((args) => {
     if (args.length !== 1)
@@ -33171,18 +32955,11 @@ function registerMiscFunctions() {
       if (args.length < 2)
         throw new RuntimeError("mat2cell requires at least 2 arguments");
       let A = args[0];
+      const distVec = (v) => toNumericVector(v, "mat2cell").map((x) => Math.round(x));
       if (isRuntimeChar(A)) {
         const str = A.value;
-        const getDistVector2 = (v) => {
-          if (isRuntimeNumber(v)) return [Math.round(v)];
-          if (isRuntimeTensor(v))
-            return Array.from(v.data).map((x) => Math.round(x));
-          throw new RuntimeError(
-            "mat2cell: distribution arguments must be numeric vectors"
-          );
-        };
-        getDistVector2(args[1]);
-        const colDist2 = args.length >= 3 ? getDistVector2(args[2]) : [str.length];
+        distVec(args[1]);
+        const colDist2 = args.length >= 3 ? distVec(args[2]) : [str.length];
         const nCellCols2 = colDist2.length;
         const cellData2 = [];
         let pos = 0;
@@ -33192,29 +32969,15 @@ function registerMiscFunctions() {
         }
         return RTV.cell(cellData2, [1, nCellCols2]);
       }
-      if (isRuntimeNumber(A)) {
-        A = RTV.tensor(new FloatXArray([A]), [1, 1]);
-      }
-      if (!isRuntimeTensor(A))
-        throw new RuntimeError(
-          "mat2cell: first argument must be a numeric array"
-        );
+      A = coerceToTensor(A, "mat2cell");
       const rows = A.shape[0];
       const cols = A.shape.length >= 2 ? A.shape[1] : 1;
-      const getDistVector = (v) => {
-        if (isRuntimeNumber(v)) return [Math.round(v)];
-        if (isRuntimeTensor(v))
-          return Array.from(v.data).map((x) => Math.round(x));
-        throw new RuntimeError(
-          "mat2cell: distribution arguments must be numeric vectors"
-        );
-      };
-      const rowDist = getDistVector(args[1]);
+      const rowDist = distVec(args[1]);
       let colDist;
       if (args.length === 2) {
         colDist = [cols];
       } else {
-        colDist = getDistVector(args[2]);
+        colDist = distVec(args[2]);
       }
       const rowSum = rowDist.reduce((a, b) => a + b, 0);
       const colSum = colDist.reduce((a, b) => a + b, 0);
@@ -35099,8 +34862,7 @@ function _computeItemType(kind) {
     case "Unary": {
       const operandType = itemTypeForExprKind(kind.operand.kind);
       if (kind.op === "Not") {
-        if (operandType.kind === "Number" || operandType.kind === "Boolean" || operandType.kind === "ComplexNumber")
-          return { kind: "Boolean" };
+        if (isScalarType(operandType)) return { kind: "Boolean" };
         if (operandType.kind === "Tensor") return operandType;
         return { kind: "Unknown" };
       }
@@ -35109,17 +34871,11 @@ function _computeItemType(kind) {
     case "Binary": {
       const leftType = itemTypeForExprKind(kind.left.kind);
       const rightType = itemTypeForExprKind(kind.right.kind);
-      const isScalar = (t) => t.kind === "Number" || t.kind === "Boolean" || t.kind === "ComplexNumber";
-      const isComplex2 = (t) => t.kind === "ComplexNumber" || t.kind === "Tensor" && t.isComplex;
       if (kind.op === "Equal" /* Equal */ || kind.op === "NotEqual" /* NotEqual */ || kind.op === "Less" /* Less */ || kind.op === "LessEqual" /* LessEqual */ || kind.op === "Greater" /* Greater */ || kind.op === "GreaterEqual" /* GreaterEqual */ || kind.op === "BitAnd" /* BitAnd */ || kind.op === "BitOr" /* BitOr */) {
-        if (isScalar(leftType) && isScalar(rightType))
+        if (isScalarType(leftType) && isScalarType(rightType))
           return { kind: "Boolean" };
         if (leftType.kind === "Tensor" || rightType.kind === "Tensor") {
-          return {
-            kind: "Tensor",
-            isLogical: true,
-            isComplex: isComplex2(leftType) || isComplex2(rightType) ? true : void 0
-          };
+          return { kind: "Tensor", isLogical: true };
         }
         return { kind: "Unknown" };
       }
@@ -35128,32 +34884,9 @@ function _computeItemType(kind) {
       if (leftType.kind === "Unknown" || rightType.kind === "Unknown" || leftType.kind === "ClassInstance" || rightType.kind === "ClassInstance") {
         return { kind: "Unknown" };
       }
-      if (kind.op === "Mul" /* Mul */) {
-        if (leftType.kind === "Tensor" && rightType.kind === "Tensor") {
-          return {
-            kind: "Tensor",
-            isComplex: isComplex2(leftType) || isComplex2(rightType) ? true : void 0
-          };
-        }
-      }
       if (leftType.kind === "Tensor" || rightType.kind === "Tensor") {
-        const resultIsComplex = isComplex2(leftType) || isComplex2(rightType) ? true : void 0;
-        if (isScalar(leftType) && rightType.kind === "Tensor") {
-          return { ...rightType, isComplex: resultIsComplex };
-        }
-        if (leftType.kind === "Tensor" && isScalar(rightType)) {
-          return { ...leftType, isComplex: resultIsComplex };
-        }
-        if (leftType.kind === "Tensor" && rightType.kind === "Tensor") {
-          return {
-            kind: "Tensor",
-            isComplex: resultIsComplex
-          };
-        }
-        return {
-          kind: "Tensor",
-          isComplex: resultIsComplex
-        };
+        const resultIsComplex = isComplexType(leftType) || isComplexType(rightType) ? true : void 0;
+        return { kind: "Tensor", isComplex: resultIsComplex };
       }
       if (leftType.kind === "ComplexNumber" || rightType.kind === "ComplexNumber") {
         return { kind: "ComplexNumber" };
@@ -35204,6 +34937,7 @@ function _computeItemType(kind) {
       }
       if (baseType.kind === "String") return { kind: "String" };
       if (baseType.kind === "Cell") return baseType;
+      if (baseType.kind === "Function") return baseType.returns;
       return { kind: "Unknown" };
     }
     case "IndexCell": {
@@ -35219,7 +34953,13 @@ function _computeItemType(kind) {
       return { kind: "Tensor" };
     case "End":
       return { kind: "Number" };
-    case "Member":
+    case "Member": {
+      const baseType = itemTypeForExprKind(kind.base.kind);
+      if (baseType.kind === "Struct" && kind.name in baseType.knownFields) {
+        return baseType.knownFields[kind.name];
+      }
+      return { kind: "Unknown" };
+    }
     case "MemberDynamic":
       return { kind: "Unknown" };
     case "MethodCall":
@@ -35227,10 +34967,15 @@ function _computeItemType(kind) {
     case "FuncCall": {
       return kind.returnType;
     }
-    case "AnonFunc":
-      return { kind: "Function", params: [], returns: { kind: "Unknown" } };
+    case "AnonFunc": {
+      const paramTypes = kind.params.map(
+        (p) => p.ty ?? { kind: "Unknown" }
+      );
+      const returnType = itemTypeForExprKind(kind.body.kind);
+      return { kind: "Function", params: paramTypes, returns: returnType };
+    }
     case "FuncHandle":
-      return { kind: "Unknown" };
+      return { kind: "Function", params: [], returns: { kind: "Unknown" } };
     case "MetaClass":
       return { kind: "Unknown" };
     case "ClassInstantiation":
@@ -35241,8 +34986,9 @@ function _computeItemType(kind) {
 }
 
 // src/numbl-core/lowering/varIdCollect.ts
-function collectStmtVarIds(stmts, out2) {
+function collectVarIds(stmts, out2) {
   for (const s of stmts) {
+    if (s.type === "Function") continue;
     collectStmtVarIdsOne(s, out2);
   }
 }
@@ -35267,57 +35013,50 @@ function collectStmtVarIdsOne(s, out2) {
       break;
     case "If":
       collectExprVarIds(s.cond, out2);
-      collectStmtVarIds(s.thenBody, out2);
+      collectVarIds(s.thenBody, out2);
       for (const b of s.elseifBlocks) {
         collectExprVarIds(b.cond, out2);
-        collectStmtVarIds(b.body, out2);
+        collectVarIds(b.body, out2);
       }
-      if (s.elseBody) collectStmtVarIds(s.elseBody, out2);
+      if (s.elseBody) collectVarIds(s.elseBody, out2);
       break;
     case "While":
       collectExprVarIds(s.cond, out2);
-      collectStmtVarIds(s.body, out2);
+      collectVarIds(s.body, out2);
       break;
     case "For":
       out2.add(s.variable.id.id);
       collectExprVarIds(s.expr, out2);
-      collectStmtVarIds(s.body, out2);
+      collectVarIds(s.body, out2);
       break;
     case "Switch":
       collectExprVarIds(s.expr, out2);
       for (const c of s.cases) {
         collectExprVarIds(c.value, out2);
-        collectStmtVarIds(c.body, out2);
+        collectVarIds(c.body, out2);
       }
-      if (s.otherwise) collectStmtVarIds(s.otherwise, out2);
+      if (s.otherwise) collectVarIds(s.otherwise, out2);
       break;
     case "TryCatch":
-      collectStmtVarIds(s.tryBody, out2);
+      collectVarIds(s.tryBody, out2);
       if (s.catchVar) out2.add(s.catchVar.id.id);
-      collectStmtVarIds(s.catchBody, out2);
+      collectVarIds(s.catchBody, out2);
       break;
     case "Function":
       break;
-    case "Global": {
-      const vars = s.vars;
-      vars.forEach((v) => out2.add(v.variable.id.id));
+    case "Global":
+    case "Persistent":
+      for (const v of s.vars) out2.add(v.variable.id.id);
       break;
-    }
     case "Return":
     case "Break":
     case "Continue":
-    case "Persistent":
       break;
-    default:
-      throw new Error(`Unhandled statement type: ${s.type}`);
   }
 }
 function collectExprVarIds(e, out2) {
   walkExpr2(e, (sub) => {
     if (sub.kind.type === "Var") out2.add(sub.kind.variable.id.id);
-    else if (sub.kind.type === "AnonFunc") {
-      for (const p of sub.kind.params) out2.add(p.id.id);
-    }
   });
 }
 function collectLValueVarIds(lv, out2) {
@@ -35326,8 +35065,11 @@ function collectLValueVarIds(lv, out2) {
       out2.add(lv.variable.id.id);
       break;
     case "Member":
+      collectExprVarIds(lv.base, out2);
+      break;
     case "MemberDynamic":
       collectExprVarIds(lv.base, out2);
+      collectExprVarIds(lv.nameExpr, out2);
       break;
     case "Index":
     case "IndexCell":
@@ -35801,7 +35543,7 @@ function packResults(results, shape) {
   }
   return RTV.cell(results, [...shape]);
 }
-function coerceToTensor(v, fnName, which) {
+function coerceToTensor2(v, fnName, which) {
   if (isRuntimeNumber(v)) {
     return RTV.tensor(new FloatXArray([v]), [1, 1]);
   }
@@ -36271,8 +36013,8 @@ function bsxfunImpl(rt, _nargout, args) {
   }
   const rawA = ensureRuntimeValue(args[1]);
   const rawB = ensureRuntimeValue(args[2]);
-  const a = coerceToTensor(rawA, "bsxfun", "first");
-  const b = coerceToTensor(rawB, "bsxfun", "second");
+  const a = coerceToTensor2(rawA, "bsxfun", "first");
+  const b = coerceToTensor2(rawB, "bsxfun", "second");
   const outShape = getBroadcastShape(a.shape, b.shape);
   if (!outShape)
     throw new RuntimeError(
@@ -38007,93 +37749,95 @@ function syncSleep(ms) {
 }
 
 // src/numbl-core/runtime/runtimePlot.ts
+function resolveStr(val) {
+  return typeof val === "string" ? val : toString(ensureRuntimeValue(val));
+}
+function resolveNum(val, fallback) {
+  if (typeof val === "number") return val;
+  try {
+    return toNumber(ensureRuntimeValue(val));
+  } catch {
+    return fallback ?? 0;
+  }
+}
+function resolveOnOff(val) {
+  if (typeof val === "boolean") return val;
+  return resolveStr(val) === "on";
+}
 function plotInstr(plotInstructions, instr) {
-  if (instr.type === "set_figure_handle") {
-    let handle;
-    if (typeof instr.handle === "number") {
-      handle = instr.handle;
-    } else {
-      try {
-        handle = toNumber(ensureRuntimeValue(instr.handle));
-      } catch {
-        handle = 1;
-      }
+  switch (instr.type) {
+    case "set_figure_handle":
+      plotInstructions.push({
+        type: "set_figure_handle",
+        handle: resolveNum(instr.handle, 1)
+      });
+      break;
+    case "plot":
+      plotInstructions.push({
+        type: "plot",
+        traces: [
+          {
+            x: runtimeValueToNumberArray(ensureRuntimeValue(instr.x)),
+            y: runtimeValueToNumberArray(ensureRuntimeValue(instr.y))
+          }
+        ]
+      });
+      break;
+    case "set_hold":
+      plotInstructions.push({
+        type: "set_hold",
+        value: resolveOnOff(instr.value)
+      });
+      break;
+    case "set_title":
+    case "set_xlabel":
+    case "set_ylabel":
+    case "set_zlabel":
+    case "set_sgtitle":
+      plotInstructions.push({ type: instr.type, text: resolveStr(instr.text) });
+      break;
+    case "set_shading": {
+      const shading = resolveStr(instr.shading).replace(/^'|'$/g, "");
+      plotInstructions.push({ type: "set_shading", shading });
+      break;
     }
-    plotInstructions.push({ type: "set_figure_handle", handle });
-  } else if (instr.type === "plot") {
-    plotInstructions.push({
-      type: "plot",
-      traces: [
-        {
-          x: runtimeValueToNumberArray(ensureRuntimeValue(instr.x)),
-          y: runtimeValueToNumberArray(ensureRuntimeValue(instr.y))
-        }
-      ]
-    });
-  } else if (instr.type === "set_hold") {
-    const val = instr.value;
-    let on;
-    if (typeof val === "string") on = val === "on";
-    else {
-      const mv = ensureRuntimeValue(val);
-      on = toString(mv) === "on";
-    }
-    plotInstructions.push({ type: "set_hold", value: on });
-  } else if (instr.type === "set_title") {
-    const text = typeof instr.text === "string" ? instr.text : toString(ensureRuntimeValue(instr.text));
-    plotInstructions.push({ type: "set_title", text });
-  } else if (instr.type === "set_xlabel") {
-    const text = typeof instr.text === "string" ? instr.text : toString(ensureRuntimeValue(instr.text));
-    plotInstructions.push({ type: "set_xlabel", text });
-  } else if (instr.type === "set_ylabel") {
-    const text = typeof instr.text === "string" ? instr.text : toString(ensureRuntimeValue(instr.text));
-    plotInstructions.push({ type: "set_ylabel", text });
-  } else if (instr.type === "set_shading") {
-    const raw = typeof instr.shading === "string" ? instr.shading : toString(ensureRuntimeValue(instr.shading));
-    const shading = raw.replace(/^'|'$/g, "");
-    plotInstructions.push({ type: "set_shading", shading });
-  } else if (instr.type === "close") {
-    plotInstructions.push({ type: "close" });
-  } else if (instr.type === "close_all") {
-    plotInstructions.push({ type: "close_all" });
-  } else if (instr.type === "clf") {
-    plotInstructions.push({ type: "clf" });
-  } else if (instr.type === "set_subplot") {
-    const rows = typeof instr.rows === "number" ? instr.rows : toNumber(ensureRuntimeValue(instr.rows));
-    const cols = typeof instr.cols === "number" ? instr.cols : toNumber(ensureRuntimeValue(instr.cols));
-    const index2 = typeof instr.index === "number" ? instr.index : toNumber(ensureRuntimeValue(instr.index));
-    plotInstructions.push({ type: "set_subplot", rows, cols, index: index2 });
-  } else if (instr.type === "set_sgtitle") {
-    const text = typeof instr.text === "string" ? instr.text : toString(ensureRuntimeValue(instr.text));
-    plotInstructions.push({ type: "set_sgtitle", text });
-  } else if (instr.type === "set_grid") {
-    const val = instr.value;
-    let on;
-    if (typeof val === "string") on = val === "on";
-    else if (typeof val === "boolean") on = val;
-    else {
-      const mv = ensureRuntimeValue(val);
-      on = toString(mv) === "on";
-    }
-    plotInstructions.push({ type: "set_grid", value: on });
-  } else if (instr.type === "set_zlabel") {
-    const text = typeof instr.text === "string" ? instr.text : toString(ensureRuntimeValue(instr.text));
-    plotInstructions.push({ type: "set_zlabel", text });
-  } else if (instr.type === "set_colorbar") {
-    const val = typeof instr.value === "string" ? instr.value : toString(ensureRuntimeValue(instr.value));
-    plotInstructions.push({ type: "set_colorbar", value: val });
-  } else if (instr.type === "set_colormap") {
-    const name = typeof instr.name === "string" ? instr.name : toString(ensureRuntimeValue(instr.name));
-    plotInstructions.push({
-      type: "set_colormap",
-      name: name.replace(/^"|"$/g, "")
-    });
-  } else if (instr.type === "set_axis") {
-    const val = typeof instr.value === "string" ? instr.value : toString(ensureRuntimeValue(instr.value));
-    plotInstructions.push({
-      type: "set_axis",
-      value: val.replace(/^"|"$/g, "")
-    });
+    case "close":
+    case "close_all":
+    case "clf":
+      plotInstructions.push({ type: instr.type });
+      break;
+    case "set_subplot":
+      plotInstructions.push({
+        type: "set_subplot",
+        rows: resolveNum(instr.rows),
+        cols: resolveNum(instr.cols),
+        index: resolveNum(instr.index)
+      });
+      break;
+    case "set_grid":
+      plotInstructions.push({
+        type: "set_grid",
+        value: resolveOnOff(instr.value)
+      });
+      break;
+    case "set_colorbar":
+      plotInstructions.push({
+        type: "set_colorbar",
+        value: resolveStr(instr.value)
+      });
+      break;
+    case "set_colormap":
+      plotInstructions.push({
+        type: "set_colormap",
+        name: resolveStr(instr.name).replace(/^"|"$/g, "")
+      });
+      break;
+    case "set_axis":
+      plotInstructions.push({
+        type: "set_axis",
+        value: resolveStr(instr.value).replace(/^"|"$/g, "")
+      });
+      break;
   }
 }
 function viewCall(plotInstructions, args) {
@@ -39026,19 +38770,12 @@ function extractClassInfo(classDef, qualifiedName, fileName, source) {
 }
 
 // src/numbl-core/lowering/specKey.ts
-function typeToDescriptor(ty) {
-  if (!ty) return { kind: "Unknown" };
-  if (ty.kind === "ClassInstance") {
-    return { kind: "ClassInstance", className: ty.className };
-  }
-  return { kind: ty.kind };
-}
 function computeSpecKey(name, argTypes) {
-  const args = argTypes.map((t) => typeToDescriptor(t));
+  const args = argTypes.map((t) => typeToString(t));
   return JSON.stringify({ name, args });
 }
 function hashForJsId(argTypes) {
-  const args = argTypes.map((t) => typeToDescriptor(t));
+  const args = argTypes.map((t) => typeToString(t));
   const input = JSON.stringify(args);
   let hash = 2166136261;
   for (let i = 0; i < input.length; i++) {
@@ -39122,6 +38859,54 @@ function determineReturnType(ctx, name, candidates, args, nargout) {
     const specialized = ctx.getOrLowerFunctionSpecialized(name, argTypes2) ?? ctx.getOrLowerWorkspaceFunctionSpecialized(name, argTypes2);
     return extractOutputTypes(specialized, nargout);
   }
+  if (candidate.type === "builtin" && name === "struct") {
+    if (args.length === 0) return IType.struct();
+    if (args.length % 2 === 0) {
+      const fields = {};
+      let allCharKeys = true;
+      for (let i = 0; i < args.length; i += 2) {
+        const keyExpr = args[i].kind;
+        if (keyExpr.type !== "Char") {
+          allCharKeys = false;
+          break;
+        }
+        const fieldName = keyExpr.value.replace(/^'|'$/g, "");
+        fields[fieldName] = itemTypeForExprKind(args[i + 1].kind);
+      }
+      if (allCharKeys) return IType.struct(fields);
+    }
+    return IType.struct();
+  }
+  if (candidate.type === "builtin" && (name === "arrayfun" || name === "cellfun")) {
+    if (args.length >= 2) {
+      const funcArgType = itemTypeForExprKind(args[0].kind);
+      if (funcArgType.kind === "Function" && funcArgType.returns.kind !== "Unknown") {
+        let uniformOutput = true;
+        for (let i = 2; i < args.length; i++) {
+          const a = args[i].kind;
+          if (a.type === "Char" && a.value.replace(/^'|'$/g, "").toLowerCase() === "uniformoutput") {
+            if (i + 1 < args.length) {
+              const val = args[i + 1].kind;
+              if (val.type === "Number" && val.value === "0") {
+                uniformOutput = false;
+              }
+            }
+          }
+        }
+        if (!uniformOutput) {
+          return IType.cell("unknown");
+        }
+        const retKind = funcArgType.returns.kind;
+        if (retKind === "Number" || retKind === "ComplexNumber") {
+          return { kind: "Tensor", isComplex: retKind === "ComplexNumber" };
+        }
+        if (retKind === "Boolean") {
+          return { kind: "Tensor", isLogical: true };
+        }
+      }
+    }
+    return { kind: "Unknown" };
+  }
   const argTypes = args.map((a) => itemTypeForExprKind(a.kind));
   if (argTypes.some((t) => t.kind === "Unknown")) {
     return { kind: "Unknown" };
@@ -39805,7 +39590,7 @@ function lowerLValue(ctx, lv) {
     }
     case "Member": {
       if (lv.base.type === "Ident") {
-        const vv = ctx.lookup(lv.base.name) ?? ctx.defineVariable(lv.base.name, IType.Unknown);
+        const vv = ctx.lookup(lv.base.name) ?? ctx.defineVariable(lv.base.name, void 0);
         const base2 = {
           kind: { type: "Var", variable: vv },
           span: lv.base.span
@@ -39816,7 +39601,7 @@ function lowerLValue(ctx, lv) {
         let root = lv.base;
         while (root.type === "Member") root = root.base;
         if (root.type === "Ident" && ctx.lookup(root.name) === null) {
-          ctx.defineVariable(root.name, IType.Unknown);
+          ctx.defineVariable(root.name, void 0);
         }
       }
       if (lv.base.type === "Index" || lv.base.type === "IndexCell") {
@@ -40011,10 +39796,13 @@ function lowerStmt(ctx, stmt) {
           span
         };
       }
+      if (irLv.type === "Member") {
+        const fieldType = itemTypeForExprKind(value.kind);
+        updateStructTypeForMemberAssign(irLv, fieldType);
+      }
       if ((irLv.type === "Index" || irLv.type === "IndexCell") && irLv.base.kind.type === "Var") {
         const v = irLv.base.kind.variable;
-        const k = v.ty?.kind;
-        if (k === "Number" || k === "Boolean" || k === "ComplexNumber") {
+        if (v.ty && isScalarType(v.ty)) {
           v.ty = IType.Unknown;
         }
       }
@@ -40125,6 +39913,24 @@ function lowerStmt(ctx, stmt) {
       );
   }
 }
+function updateStructTypeForMemberAssign(lv, fieldType) {
+  const chain = [lv.name];
+  let cursor = lv.base.kind;
+  while (cursor.type === "Member") {
+    chain.unshift(cursor.name);
+    cursor = cursor.base.kind;
+  }
+  if (cursor.type !== "Var") return;
+  const v = cursor.variable;
+  if (v.ty && v.ty.kind !== "Struct" && v.ty.kind !== "Unknown") return;
+  let ty = IType.struct({ [chain[chain.length - 1]]: fieldType });
+  for (let i = chain.length - 2; i >= 0; i--) {
+    ty = IType.struct({ [chain[i]]: ty });
+  }
+  if (!v.ty || v.ty.kind === "Struct") {
+    v.ty = IType.unify(v.ty, ty);
+  }
+}
 function lowerFunction(ctx, stmt, paramTypes) {
   const isNested = ctx.scopes.length > 1 && !stmt.isFileLocalSubfunction;
   if (isNested) {
@@ -41065,6 +40871,13 @@ var JS_RESERVED = /* @__PURE__ */ new Set([
   "Set",
   "JSON"
 ]);
+function assertNoUnknownArgTypes(argTypes, label) {
+  if (argTypes.some((t) => !t || t.kind === "Unknown")) {
+    throw new Error(
+      `Cannot generate specialized function for ${label}: unknown parameter types`
+    );
+  }
+}
 function exprContainsEndShallow(expr) {
   let found = false;
   function walk(e, insideInner) {
@@ -41123,77 +40936,6 @@ function exprContainsEndShallow(expr) {
   walk(expr, false);
   return found;
 }
-function collectVarIds(stmts, out2) {
-  for (const stmt of stmts) {
-    if (stmt.type === "Function") continue;
-    collectVarIdsFromStmt(stmt, out2);
-  }
-}
-function collectVarIdsFromStmt(stmt, out2) {
-  switch (stmt.type) {
-    case "Assign":
-      out2.add(stmt.variable.id.id);
-      collectVarIdsFromExpr(stmt.expr, out2);
-      break;
-    case "ExprStmt":
-      collectVarIdsFromExpr(stmt.expr, out2);
-      break;
-    case "MultiAssign":
-      collectVarIdsFromExpr(stmt.expr, out2);
-      for (const lv of stmt.lvalues) {
-        if (lv) collectVarIdsFromLValue(lv, out2);
-      }
-      break;
-    case "AssignLValue":
-      collectVarIdsFromLValue(stmt.lvalue, out2);
-      collectVarIdsFromExpr(stmt.expr, out2);
-      break;
-    case "If":
-      collectVarIdsFromExpr(stmt.cond, out2);
-      collectVarIds(stmt.thenBody, out2);
-      for (const b of stmt.elseifBlocks) {
-        collectVarIdsFromExpr(b.cond, out2);
-        collectVarIds(b.body, out2);
-      }
-      if (stmt.elseBody) collectVarIds(stmt.elseBody, out2);
-      break;
-    case "While":
-      collectVarIdsFromExpr(stmt.cond, out2);
-      collectVarIds(stmt.body, out2);
-      break;
-    case "For":
-      out2.add(stmt.variable.id.id);
-      collectVarIdsFromExpr(stmt.expr, out2);
-      collectVarIds(stmt.body, out2);
-      break;
-    case "Switch":
-      collectVarIdsFromExpr(stmt.expr, out2);
-      for (const c of stmt.cases) {
-        collectVarIdsFromExpr(c.value, out2);
-        collectVarIds(c.body, out2);
-      }
-      if (stmt.otherwise) collectVarIds(stmt.otherwise, out2);
-      break;
-    case "TryCatch":
-      collectVarIds(stmt.tryBody, out2);
-      if (stmt.catchVar) out2.add(stmt.catchVar.id.id);
-      collectVarIds(stmt.catchBody, out2);
-      break;
-    case "Global":
-    case "Persistent":
-      for (const v of stmt.vars) out2.add(v.variable.id.id);
-      break;
-    case "Return":
-    case "Break":
-    case "Continue":
-      break;
-  }
-}
-function collectVarIdsFromExpr(expr, out2) {
-  walkExpr2(expr, (e) => {
-    if (e.kind.type === "Var") out2.add(e.kind.variable.id.id);
-  });
-}
 function collectClassProperties(ctx, className) {
   const classInfo = ctx.getClassInfo(className);
   if (!classInfo) return { propertyNames: [], propertyDefaults: /* @__PURE__ */ new Map() };
@@ -41227,17 +40969,6 @@ function genPropertyDefaults(cg, className, defaults) {
   }
   return `{${entries.join(", ")}}`;
 }
-function collectVarIdsFromLValue(lv, out2) {
-  if (lv.type === "Var") {
-    out2.add(lv.variable.id.id);
-  } else if (lv.type === "Member" || lv.type === "MemberDynamic") {
-    collectVarIdsFromExpr(lv.base, out2);
-    if (lv.type === "MemberDynamic") collectVarIdsFromExpr(lv.nameExpr, out2);
-  } else if (lv.type === "Index" || lv.type === "IndexCell") {
-    collectVarIdsFromExpr(lv.base, out2);
-    for (const i of lv.indices) collectVarIdsFromExpr(i, out2);
-  }
-}
 
 // src/numbl-core/codegen/codegenExpr.ts
 function genExpr(cg, expr) {
@@ -41578,14 +41309,14 @@ function genMember(cg, kind) {
     current = current.kind.base;
   }
   const rootType = itemTypeForExprKind(current.kind);
-  if (rootType.kind === "ClassInstance" && hasSubsref(cg, rootType.className) && cg.loweringCtx.ownerClassName !== rootType.className) {
+  if (rootType.kind === "ClassInstance" && hasClassMethod(cg, rootType.className, "subsref") && cg.loweringCtx.ownerClassName !== rootType.className) {
     const rootCode = genExpr(cg, current);
     return `$rt.subsrefCall(${rootCode}, ${JSON.stringify(chain)})`;
   }
   const baseType = itemTypeForExprKind(kind.base.kind);
   if (baseType.kind === "ClassInstance") {
     const info = cg.loweringCtx.getClassInfo(baseType.className);
-    if (info && info.propertyNames.includes(kind.name) && !cg.loweringCtx.classHasMethod(baseType.className, `get.${kind.name}`) && !hasSubsref(cg, baseType.className)) {
+    if (info && info.propertyNames.includes(kind.name) && !cg.loweringCtx.classHasMethod(baseType.className, `get.${kind.name}`) && !hasClassMethod(cg, baseType.className, "subsref")) {
       const base2 = genExpr(cg, kind.base);
       return `${base2}.fields.get(${JSON.stringify(kind.name)})`;
     }
@@ -41932,13 +41663,7 @@ function genClassInstantiation(cg, kind) {
     }
   }
   cg.ensureClassRegistered(className);
-  const {
-    propertyNames: allPropertyNames,
-    propertyDefaults: allPropertyDefaults
-  } = collectClassProperties(cg.loweringCtx, className);
-  const propsJson = JSON.stringify(allPropertyNames);
-  const isHandleClass = cg.isHandleClass(classInfo);
-  const defaultsArg = genPropertyDefaults(cg, className, allPropertyDefaults);
+  const createExpr = cg.genCreateClassInstanceExpr(className, classInfo);
   if (classInfo.constructorName) {
     const selfType = { kind: "ClassInstance", className };
     const argTypes = [
@@ -41952,13 +41677,11 @@ function genClassInstantiation(cg, kind) {
     );
     if (jsId) {
       const instVar = cg.freshTemp("$inst");
-      cg.emit(
-        `var ${instVar} = $rt.createClassInstance(${JSON.stringify(className)}, ${propsJson}, ${defaultsArg}, ${isHandleClass});`
-      );
+      cg.emit(`var ${instVar} = ${createExpr};`);
       return `${jsId}(1, ${instVar}, ${args.join(", ")})`;
     }
   }
-  return `$rt.createClassInstance(${JSON.stringify(className)}, ${propsJson}, ${defaultsArg}, ${isHandleClass})`;
+  return createExpr;
 }
 var NATIVE_MATH_1 = {
   // Note: sqrt, asin, acos, log are NOT here because they can produce
@@ -42006,15 +41729,10 @@ function isOutputFunction(expr) {
   ];
   return outputFunctions.includes(expr.kind.name);
 }
-function hasSubsref(cg, className) {
+function hasClassMethod(cg, className, methodName) {
   const info = cg.loweringCtx.getClassInfo(className);
   if (!info) return false;
-  return info.methodNames.has("subsref");
-}
-function hasSubsasgn(cg, className) {
-  const info = cg.loweringCtx.getClassInfo(className);
-  if (!info) return false;
-  return info.methodNames.has("subsasgn");
+  return info.methodNames.has(methodName);
 }
 
 // src/numbl-core/codegen/codegenStmt.ts
@@ -42370,7 +42088,7 @@ function genMemberAssign(cg, lv, rhs) {
     const rootType = itemTypeForExprKind(root.kind);
     if (allMemberSteps(steps)) {
       const chain = [...memberNames(steps), lv.name];
-      if (rootType.kind === "ClassInstance" && hasSubsasgn(cg, rootType.className) && cg.loweringCtx.ownerClassName !== rootType.className) {
+      if (rootType.kind === "ClassInstance" && hasClassMethod(cg, rootType.className, "subsasgn") && cg.loweringCtx.ownerClassName !== rootType.className) {
         cg.emit(
           `${rootRef} = ${`$rt.subsasgnCall(${rootRef}, ${JSON.stringify(chain)}, ${rhs})`};`
         );
@@ -42872,6 +42590,25 @@ var Codegen = class {
     }
     return false;
   }
+  /**
+   * Build a `$rt.createClassInstance(...)` JS expression for a class,
+   * including property names, defaults, and handle-class flag.
+   * Used by both genClassInstantiation and ensureWorkspaceClassConstructorGenerated.
+   */
+  genCreateClassInstanceExpr(className, classInfo) {
+    const {
+      propertyNames: allPropertyNames,
+      propertyDefaults: allPropertyDefaults
+    } = collectClassProperties(this.loweringCtx, className);
+    const propsJson = JSON.stringify(allPropertyNames);
+    const isHandleClass = this.isHandleClass(classInfo);
+    const defaultsArg = genPropertyDefaults(
+      this,
+      className,
+      allPropertyDefaults
+    );
+    return `$rt.createClassInstance(${JSON.stringify(className)}, ${propsJson}, ${defaultsArg}, ${isHandleClass})`;
+  }
   getCode() {
     const builtinDecls = [];
     for (const name of [...this.usedBuiltins].sort()) {
@@ -43023,11 +42760,7 @@ var Codegen = class {
    * or null if it's not a local function.
    */
   ensureSpecializedFunctionGenerated(name, argTypes) {
-    if (argTypes.some((type) => type.kind === "Unknown")) {
-      throw new Error(
-        `Cannot generate specialized function for ${name}: unknown parameter types`
-      );
-    }
+    assertNoUnknownArgTypes(argTypes, name);
     const filePrefix = this.loweringCtx.getRelativePath(
       this.loweringCtx.mainFileName
     );
@@ -43072,11 +42805,7 @@ var Codegen = class {
     });
   }
   ensureWorkspaceFunctionGenerated(name, argTypes) {
-    if (argTypes.some((type) => type.kind === "Unknown")) {
-      throw new Error(
-        `Cannot generate specialized function for ${name}: unknown parameter types`
-      );
-    }
+    assertNoUnknownArgTypes(argTypes, name);
     return this.ensureExternalFunctionGenerated(name, argTypes, {
       specKeyPrefix: name,
       jsIdPrefix: "$fn_",
@@ -43085,11 +42814,7 @@ var Codegen = class {
     });
   }
   ensurePrivateFunctionGenerated(name, argTypes) {
-    if (argTypes.some((type) => type && type.kind === "Unknown")) {
-      throw new Error(
-        `Cannot generate specialized function for ${name}: unknown parameter types`
-      );
-    }
+    assertNoUnknownArgTypes(argTypes, name);
     return this.ensureExternalFunctionGenerated(name, argTypes, {
       specKeyPrefix: `private:${name}`,
       jsIdPrefix: "$fn_priv_",
@@ -43116,11 +42841,7 @@ var Codegen = class {
    * Used by JIT compilation when `feval('ClassName')` is called at runtime.
    */
   ensureWorkspaceClassConstructorGenerated(className, argTypes) {
-    if (argTypes.some((type) => type && type.kind === "Unknown")) {
-      throw new Error(
-        `Cannot generate constructor for ${className}: unknown parameter types`
-      );
-    }
+    assertNoUnknownArgTypes(argTypes, className);
     const classInfo = this.loweringCtx.getClassInfo(className);
     if (!classInfo) return null;
     const specKey = computeSpecKey(`${className}$$ctor`, argTypes);
@@ -43128,53 +42849,28 @@ var Codegen = class {
     if (existing) return existing.jsId;
     const hash = hashForJsId(argTypes);
     const jsId = `$fn_${this.sanitizeName(className)}$$ctor$${hash}`;
-    const {
-      propertyNames: allPropertyNames,
-      propertyDefaults: allPropertyDefaults
-    } = collectClassProperties(this.loweringCtx, className);
-    const propsJson = JSON.stringify(allPropertyNames);
-    const isHandleClass = this.isHandleClass(classInfo);
-    const defaultsArg = genPropertyDefaults(
-      this,
-      className,
-      allPropertyDefaults
-    );
-    this.pushEmitCapture();
+    const createExpr = this.genCreateClassInstanceExpr(className, classInfo);
+    let ctorJsId = null;
     if (classInfo.constructorName) {
       const selfType = { kind: "ClassInstance", className };
       const ctorArgTypes = [selfType, ...argTypes];
-      const ctorJsId = this.ensureClassMethodGenerated(
+      ctorJsId = this.ensureClassMethodGenerated(
         className,
         classInfo.constructorName,
         ctorArgTypes
       );
-      if (ctorJsId) {
-        this.emit(`function ${jsId}($nargout, ...args) {`);
-        this.pushIndent();
-        this.emit(
-          `var $inst = $rt.createClassInstance(${JSON.stringify(className)}, ${propsJson}, ${defaultsArg}, ${isHandleClass});`
-        );
-        this.emit(`return ${ctorJsId}(1, $inst, ...args);`);
-        this.popIndent();
-        this.emit(`}`);
-      } else {
-        this.emit(`function ${jsId}($nargout, ...args) {`);
-        this.pushIndent();
-        this.emit(
-          `return $rt.createClassInstance(${JSON.stringify(className)}, ${propsJson}, ${defaultsArg}, ${isHandleClass});`
-        );
-        this.popIndent();
-        this.emit(`}`);
-      }
+    }
+    this.pushEmitCapture();
+    this.emit(`function ${jsId}($nargout, ...args) {`);
+    this.pushIndent();
+    if (ctorJsId) {
+      this.emit(`var $inst = ${createExpr};`);
+      this.emit(`return ${ctorJsId}(1, $inst, ...args);`);
     } else {
-      this.emit(`function ${jsId}($nargout, ...args) {`);
-      this.pushIndent();
-      this.emit(
-        `return $rt.createClassInstance(${JSON.stringify(className)}, ${propsJson}, ${defaultsArg}, ${isHandleClass});`
-      );
-      this.popIndent();
-      this.emit(`}`);
+      this.emit(`return ${createExpr};`);
     }
+    this.popIndent();
+    this.emit(`}`);
     this.popEmitCaptureToDefinitions();
     this.generatedFunctions.set(specKey, {
       functionId: className,
@@ -43819,9 +43515,7 @@ function generateMainScriptCode(source, mainFileName = "script.m", workspaceFile
     codegen.noLineTracking = true;
   }
   const scriptVarIds = /* @__PURE__ */ new Set();
-  for (const stmt of irBody) {
-    collectStmtVarIdsOne(stmt, scriptVarIds);
-  }
+  collectVarIds(irBody, scriptVarIds);
   for (const v of initialVarIRVars) {
     scriptVarIds.add(v.id.id);
   }