numbl 0.0.16 → 0.0.17

package/dist-cli/cli.js

@@ -158,7 +158,7 @@ async function fetchPackageIndex(backend, indexUrl = DEFAULT_INDEX_URL) {
   return backend.fetchJson(indexUrl);
 }
 function findPackageEntry(index2, packageName, arch) {
-  for (const candidate of ["numbl_" + arch, "numbl_wasm", "all"]) {
+  for (const candidate of ["numbl_" + arch, "numbl_wasm", "any"]) {
     const entry = index2.packages.find(
       (p) => p.name === packageName && p.architecture === candidate
     );
@@ -168,7 +168,7 @@ function findPackageEntry(index2, packageName, arch) {
 }
 function listAvailablePackages(index2, arch) {
   return index2.packages.filter(
-    (p) => p.architecture === arch || p.architecture === "wasm" || p.architecture === "all"
+    (p) => p.architecture === "numbl_" + arch || p.architecture === "numbl_wasm" || p.architecture === "any"
   );
 }
 
@@ -17432,14 +17432,24 @@ function parseEconArg(argType) {
   if (isString(argType) === true || isChar(argType) === true) return "unknown";
   return null;
 }
+function toF64(data) {
+  return data instanceof Float64Array ? data : new Float64Array(data);
+}
+function parseStringArgLower(arg) {
+  if (typeof arg === "string") {
+    return arg.replace(/^['"]|['"]$/g, "").toLowerCase();
+  }
+  if (arg && typeof arg === "object" && "value" in arg) {
+    return String(arg.value).replace(/^['"]|['"]$/g, "").toLowerCase();
+  }
+  return String(arg).toLowerCase();
+}
 
 // src/numbl-core/builtins/linear-algebra/linsolve.ts
 function linsolveLapack(A, m, n, B, nrhs) {
   const bridge = getEffectiveBridge("linsolve", "linsolve");
   if (!bridge?.linsolve) return null;
-  const f64A = A instanceof Float64Array ? A : new Float64Array(A);
-  const f64B = B instanceof Float64Array ? B : new Float64Array(B);
-  return bridge.linsolve(f64A, m, n, f64B, nrhs);
+  return bridge.linsolve(toF64(A), m, n, toF64(B), nrhs);
 }
 function linsolveComplexLapack(ARe, AIm, m, n, BRe, BIm, nrhs) {
   const bridge = getEffectiveBridge("linsolveComplex", "linsolveComplex");
@@ -17447,11 +17457,15 @@ function linsolveComplexLapack(ARe, AIm, m, n, BRe, BIm, nrhs) {
     throw new RuntimeError(
       "linsolveComplex: no bridge available (should not happen)"
     );
-  const f64ARe = ARe instanceof Float64Array ? ARe : new Float64Array(ARe);
-  const f64AIm = AIm instanceof Float64Array ? AIm : new Float64Array(AIm);
-  const f64BRe = BRe instanceof Float64Array ? BRe : new Float64Array(BRe);
-  const f64BIm = BIm instanceof Float64Array ? BIm : new Float64Array(BIm);
-  return bridge.linsolveComplex(f64ARe, f64AIm, m, n, f64BRe, f64BIm, nrhs);
+  return bridge.linsolveComplex(
+    toF64(ARe),
+    toF64(AIm),
+    m,
+    n,
+    toF64(BRe),
+    toF64(BIm),
+    nrhs
+  );
 }
 function registerLinsolve() {
   register("linsolve", [
@@ -24523,82 +24537,43 @@ function registerMathFunctions() {
     }),
     1
   );
-  register(
-    "isnan",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("isnan requires 1 argument");
-      const v = args[0];
-      if (isRuntimeNumber(v)) return RTV.logical(Number.isNaN(v));
-      if (isRuntimeLogical(v)) return RTV.logical(false);
-      if (isRuntimeComplexNumber(v))
-        return RTV.logical(Number.isNaN(v.re) || Number.isNaN(v.im));
-      if (isRuntimeTensor(v)) {
-        const result = new FloatXArray(v.data.length);
-        for (let i = 0; i < v.data.length; i++) {
-          const reNaN = Number.isNaN(v.data[i]);
-          const imNaN = v.imag ? Number.isNaN(v.imag[i]) : false;
-          result[i] = reNaN || imNaN ? 1 : 0;
-        }
-        const t = RTV.tensor(result, v.shape);
-        t._isLogical = true;
-        return t;
-      }
-      throw new RuntimeError("Expected numeric argument");
-    }),
-    1
-  );
-  register(
-    "isinf",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("isinf requires 1 argument");
-      const v = args[0];
-      const isInf = (x) => !Number.isFinite(x) && !Number.isNaN(x);
-      if (isRuntimeNumber(v)) return RTV.logical(isInf(v));
-      if (isRuntimeLogical(v)) return RTV.logical(false);
-      if (isRuntimeComplexNumber(v))
-        return RTV.logical(isInf(v.re) || isInf(v.im));
-      if (isRuntimeTensor(v)) {
-        const result = new FloatXArray(v.data.length);
-        for (let i = 0; i < v.data.length; i++) {
-          const reInf = isInf(v.data[i]);
-          const imInf = v.imag ? isInf(v.imag[i]) : false;
-          result[i] = reInf || imInf ? 1 : 0;
+  function numericPredicate(name, scalarTest, logicalDefault, combineReIm) {
+    register(
+      name,
+      builtinSingle((args) => {
+        if (args.length !== 1)
+          throw new RuntimeError(`${name} requires 1 argument`);
+        const v = args[0];
+        if (isRuntimeNumber(v)) return RTV.logical(scalarTest(v));
+        if (isRuntimeLogical(v)) return RTV.logical(logicalDefault);
+        if (isRuntimeComplexNumber(v)) {
+          const re = scalarTest(v.re), im = scalarTest(v.im);
+          return RTV.logical(combineReIm === "or" ? re || im : re && im);
         }
-        const t = RTV.tensor(result, v.shape);
-        t._isLogical = true;
-        return t;
-      }
-      throw new RuntimeError("Expected numeric argument");
-    }),
-    1
-  );
-  register(
-    "isfinite",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("isfinite requires 1 argument");
-      const v = args[0];
-      if (isRuntimeNumber(v)) return RTV.logical(Number.isFinite(v));
-      if (isRuntimeLogical(v)) return RTV.logical(true);
-      if (isRuntimeComplexNumber(v))
-        return RTV.logical(Number.isFinite(v.re) && Number.isFinite(v.im));
-      if (isRuntimeTensor(v)) {
-        const result = new FloatXArray(v.data.length);
-        for (let i = 0; i < v.data.length; i++) {
-          const reFin = Number.isFinite(v.data[i]);
-          const imFin = v.imag ? Number.isFinite(v.imag[i]) : true;
-          result[i] = reFin && imFin ? 1 : 0;
+        if (isRuntimeTensor(v)) {
+          const result = new FloatXArray(v.data.length);
+          for (let i = 0; i < v.data.length; i++) {
+            const re = scalarTest(v.data[i]);
+            const im = v.imag ? scalarTest(v.imag[i]) : logicalDefault;
+            result[i] = (combineReIm === "or" ? re || im : re && im) ? 1 : 0;
+          }
+          const t = RTV.tensor(result, v.shape);
+          t._isLogical = true;
+          return t;
         }
-        const t = RTV.tensor(result, v.shape);
-        t._isLogical = true;
-        return t;
-      }
-      throw new RuntimeError("Expected numeric argument");
-    }),
-    1
+        throw new RuntimeError("Expected numeric argument");
+      }),
+      1
+    );
+  }
+  numericPredicate("isnan", Number.isNaN, false, "or");
+  numericPredicate(
+    "isinf",
+    (x) => !Number.isFinite(x) && !Number.isNaN(x),
+    false,
+    "or"
   );
+  numericPredicate("isfinite", Number.isFinite, true, "and");
   register(
     "real",
     builtinSingle((args) => {
@@ -24915,54 +24890,26 @@ function registerMathFunctions() {
     }),
     1
   );
-  register(
-    "besselj",
-    builtinSingle((args) => {
-      if (args.length < 2 || args.length > 3)
-        throw new RuntimeError("besselj requires 2 or 3 arguments");
-      const scale = args.length === 3 ? toNumber(args[2]) : 0;
-      return applyBesselBinary(args[0], args[1], (nu, z) => {
-        const val = besselj(nu, z);
-        return scale === 1 ? val * Math.exp(-Math.abs(z)) : val;
-      });
-    })
-  );
-  register(
-    "bessely",
-    builtinSingle((args) => {
-      if (args.length < 2 || args.length > 3)
-        throw new RuntimeError("bessely requires 2 or 3 arguments");
-      const scale = args.length === 3 ? toNumber(args[2]) : 0;
-      return applyBesselBinary(args[0], args[1], (nu, z) => {
-        const val = bessely(nu, z);
-        return scale === 1 ? val * Math.exp(-Math.abs(z)) : val;
-      });
-    })
-  );
-  register(
-    "besseli",
-    builtinSingle((args) => {
-      if (args.length < 2 || args.length > 3)
-        throw new RuntimeError("besseli requires 2 or 3 arguments");
-      const scale = args.length === 3 ? toNumber(args[2]) : 0;
-      return applyBesselBinary(args[0], args[1], (nu, z) => {
-        const val = besseli(nu, z);
-        return scale === 1 ? val * Math.exp(-Math.abs(z)) : val;
-      });
-    })
-  );
-  register(
-    "besselk",
-    builtinSingle((args) => {
-      if (args.length < 2 || args.length > 3)
-        throw new RuntimeError("besselk requires 2 or 3 arguments");
-      const scale = args.length === 3 ? toNumber(args[2]) : 0;
-      return applyBesselBinary(args[0], args[1], (nu, z) => {
-        const val = besselk(nu, z);
-        return scale === 1 ? val * Math.exp(z) : val;
-      });
-    })
-  );
+  const besselDefs = [
+    ["besselj", besselj, (z) => Math.exp(-Math.abs(z))],
+    ["bessely", bessely, (z) => Math.exp(-Math.abs(z))],
+    ["besseli", besseli, (z) => Math.exp(-Math.abs(z))],
+    ["besselk", besselk, (z) => Math.exp(z)]
+  ];
+  for (const [name, fn, scaleFn] of besselDefs) {
+    register(
+      name,
+      builtinSingle((args) => {
+        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) => {
+          const val = fn(nu, z);
+          return scale === 1 ? val * scaleFn(z) : val;
+        });
+      })
+    );
+  }
   const airyFns = [airyAi, airyAiPrime, airyBi, airyBiPrime];
   const airyComplexKeys = ["ai", "aip", "bi", "bip"];
   function applyAiryElementwise(xArg, n, scaled) {
@@ -25378,33 +25325,36 @@ function registerPrngFunctions() {
       return RTV.num(0);
     })
   );
-  register("rand", [
-    // Legacy: rand('seed', s) — prefer rng(s) instead
-    {
-      check: (argTypes) => argTypes.length === 2 && (argTypes[0].kind === "Char" || argTypes[0].kind === "String") && (argTypes[1].kind === "Number" || argTypes[1].kind === "Unknown") ? { outputTypes: [{ kind: "Number" }] } : null,
-      apply: (args) => {
-        const s = args[0];
-        if (!isRuntimeString(s) && !isRuntimeChar(s) || rstr(s) !== "seed")
-          throw new RuntimeError(
-            "rand: only 'seed' string option is supported"
-          );
-        seedRng(Math.round(toNumber(args[1])));
-        return RTV.num(0);
-      }
-    },
-    {
-      check: realArrayConstructorCheck,
-      apply: (args) => {
-        if (args.length === 0) return RTV.num(rngRandom());
-        const shape = parseShapeArgs(args);
-        if (shape.length === 1) shape.push(shape[0]);
-        const n = numel(shape);
-        const data = new FloatXArray(n);
-        for (let i = 0; i < n; i++) data[i] = rngRandom();
-        return RTV.tensor(data, shape);
+  function registerRandFn(name, gen) {
+    register(name, [
+      {
+        check: (argTypes) => argTypes.length === 2 && (argTypes[0].kind === "Char" || argTypes[0].kind === "String") && (argTypes[1].kind === "Number" || argTypes[1].kind === "Unknown") ? { outputTypes: [{ kind: "Number" }] } : null,
+        apply: (args) => {
+          const s = args[0];
+          if (!isRuntimeString(s) && !isRuntimeChar(s) || rstr(s) !== "seed")
+            throw new RuntimeError(
+              `${name}: only 'seed' string option is supported`
+            );
+          seedRng(Math.round(toNumber(args[1])));
+          return RTV.num(0);
+        }
+      },
+      {
+        check: realArrayConstructorCheck,
+        apply: (args) => {
+          if (args.length === 0) return RTV.num(gen());
+          const shape = parseShapeArgs(args);
+          if (shape.length === 1) shape.push(shape[0]);
+          const n = numel(shape);
+          const data = new FloatXArray(n);
+          for (let i = 0; i < n; i++) data[i] = gen();
+          return RTV.tensor(data, shape);
+        }
       }
-    }
-  ]);
+    ]);
+  }
+  registerRandFn("rand", rngRandom);
+  registerRandFn("randn", boxMullerRandom);
   register(
     "randi",
     builtinSingle((args) => {
@@ -25457,33 +25407,6 @@ function registerPrngFunctions() {
       return RTV.tensor(perm.slice(0, k), [1, k]);
     })
   );
-  register("randn", [
-    // Legacy: randn('seed', s) — prefer rng(s) instead
-    {
-      check: (argTypes) => argTypes.length === 2 && (argTypes[0].kind === "Char" || argTypes[0].kind === "String") && (argTypes[1].kind === "Number" || argTypes[1].kind === "Unknown") ? { outputTypes: [{ kind: "Number" }] } : null,
-      apply: (args) => {
-        const s = args[0];
-        if (!isRuntimeString(s) && !isRuntimeChar(s) || rstr(s) !== "seed")
-          throw new RuntimeError(
-            "randn: only 'seed' string option is supported"
-          );
-        seedRng(Math.round(toNumber(args[1])));
-        return RTV.num(0);
-      }
-    },
-    {
-      check: realArrayConstructorCheck,
-      apply: (args) => {
-        if (args.length === 0) return RTV.num(boxMullerRandom());
-        const shape = parseShapeArgs(args);
-        if (shape.length === 1) shape.push(shape[0]);
-        const n = numel(shape);
-        const data = new FloatXArray(n);
-        for (let i = 0; i < n; i++) data[i] = boxMullerRandom();
-        return RTV.tensor(data, shape);
-      }
-    }
-  ]);
 }
 
 // src/numbl-core/builtins/array.ts
@@ -25556,7 +25479,7 @@ function registerArrayFunctions() {
     "linspace",
     builtinSingle((args) => {
       if (args.length < 2 || args.length > 3)
-        throw new Error("linspace requires 2 or 3 arguments");
+        throw new RuntimeError("linspace requires 2 or 3 arguments");
       const start = toNumber(args[0]);
       const end = toNumber(args[1]);
       const n = args.length === 3 ? Math.round(toNumber(args[2])) : 100;
@@ -25576,7 +25499,7 @@ function registerArrayFunctions() {
         return makeRangeTensor(toNumber(args[0]), 1, toNumber(args[1]));
       if (args.length === 3)
         return makeRangeTensor(toNumber(args[0]), toNumber(args[1]), toNumber(args[2]));
-      throw new Error("colon requires 2 or 3 arguments");
+      throw new RuntimeError("colon requires 2 or 3 arguments");
     })
   );
   register(
@@ -27209,6 +27132,69 @@ function registerIntrospectionFunctions() {
 }
 
 // src/numbl-core/builtins/reduction.ts
+function nextSubscripts(subs, shape, skipDim) {
+  for (let d = 0; d < subs.length; d++) {
+    if (skipDim !== void 0 && d === skipDim) continue;
+    subs[d]++;
+    if (subs[d] < shape[d]) return true;
+    subs[d] = 0;
+  }
+  return false;
+}
+function squeezeTrailing(shape) {
+  while (shape.length > 2 && shape[shape.length - 1] === 1) {
+    shape.pop();
+  }
+}
+function scanLogical(data, imag, mode) {
+  const defaultResult = mode === "all";
+  for (let i = 0; i < data.length; i++) {
+    const isNonZero = data[i] !== 0 || imag !== void 0 && imag[i] !== 0;
+    if (isNonZero !== defaultResult) return !defaultResult;
+  }
+  return defaultResult;
+}
+function logicalAlongDim(v, dim, mode) {
+  const shape = v.shape;
+  const dimIdx = dim - 1;
+  if (dimIdx >= shape.length) {
+    const result2 = new FloatXArray(v.data.length);
+    for (let i = 0; i < v.data.length; i++)
+      result2[i] = v.data[i] !== 0 || v.imag && v.imag[i] !== 0 ? 1 : 0;
+    const t2 = RTV.tensor(result2, [...shape]);
+    t2._isLogical = true;
+    return t2;
+  }
+  const reduceDimSize = shape[dimIdx];
+  const resultShape = [...shape];
+  resultShape[dimIdx] = 1;
+  const totalElems = resultShape.reduce((a, b) => a * b, 1);
+  const result = new FloatXArray(totalElems);
+  const outSubs = new Array(shape.length).fill(0);
+  for (let i = 0; i < totalElems; i++) {
+    let val = mode === "all";
+    for (let k = 0; k < reduceDimSize; k++) {
+      const srcSubs = [...outSubs];
+      srcSubs[dimIdx] = k;
+      const srcIdx = sub2ind(shape, srcSubs);
+      const isNonZero = v.data[srcIdx] !== 0 || v.imag !== void 0 && v.imag[srcIdx] !== 0;
+      if (mode === "any" && isNonZero) {
+        val = true;
+        break;
+      }
+      if (mode === "all" && !isNonZero) {
+        val = false;
+        break;
+      }
+    }
+    result[i] = val ? 1 : 0;
+    nextSubscripts(outSubs, resultShape, dimIdx);
+  }
+  squeezeTrailing(resultShape);
+  const t = RTV.tensor(result, resultShape);
+  t._isLogical = true;
+  return t;
+}
 function dimReduce(v, dim, reduceFn, initialValue, finalizeFn) {
   if (!isRuntimeTensor(v))
     throw new RuntimeError("dimReduce: argument must be a tensor");
@@ -27241,16 +27227,9 @@ function dimReduce(v, dim, reduceFn, initialValue, finalizeFn) {
     result[i] = finalizeFn ? finalizeFn(acc, reduceDimSize) : acc;
     if (resultImag)
       resultImag[i] = finalizeFn ? finalizeFn(accIm, reduceDimSize) : accIm;
-    for (let d = 0; d < outSubs.length; d++) {
-      if (d === dimIdx) continue;
-      outSubs[d]++;
-      if (outSubs[d] < resultShape[d]) break;
-      outSubs[d] = 0;
-    }
-  }
-  while (resultShape.length > 2 && resultShape[resultShape.length - 1] === 1) {
-    resultShape.pop();
+    nextSubscripts(outSubs, resultShape, dimIdx);
   }
+  squeezeTrailing(resultShape);
   const imOut = resultImag && resultImag.some((x) => x !== 0) ? resultImag : void 0;
   return RTV.tensor(result, resultShape, imOut);
 }
@@ -27294,15 +27273,9 @@ function complexProd(v, dim) {
       }
       resultRe[i] = accRe;
       resultIm[i] = accIm;
-      for (let d = 0; d < outSubs.length; d++) {
-        if (d === dimIdx) continue;
-        outSubs[d]++;
-        if (outSubs[d] < resultShape[d]) break;
-        outSubs[d] = 0;
-      }
+      nextSubscripts(outSubs, resultShape, dimIdx);
     }
-    while (resultShape.length > 2 && resultShape[resultShape.length - 1] === 1)
-      resultShape.pop();
+    squeezeTrailing(resultShape);
     const imOut = resultIm.some((x) => x !== 0) ? resultIm : void 0;
     return RTV.tensor(resultRe, resultShape, imOut);
   }
@@ -27366,92 +27339,6 @@ function preserveTypeCheck(argTypes, nargout) {
   if (nargout === 2) return { outputTypes: [outType, outType] };
   return null;
 }
-function anyAlongDim(v, dim) {
-  const shape = v.shape;
-  const dimIdx = dim - 1;
-  if (dimIdx >= shape.length) {
-    const result2 = new FloatXArray(v.data.length);
-    for (let i = 0; i < v.data.length; i++)
-      result2[i] = v.data[i] !== 0 || v.imag && v.imag[i] !== 0 ? 1 : 0;
-    const t2 = RTV.tensor(result2, [...shape]);
-    t2._isLogical = true;
-    return t2;
-  }
-  const reduceDimSize = shape[dimIdx];
-  const resultShape = [...shape];
-  resultShape[dimIdx] = 1;
-  const totalElems = resultShape.reduce((a, b) => a * b, 1);
-  const result = new FloatXArray(totalElems);
-  const outSubs = new Array(shape.length).fill(0);
-  for (let i = 0; i < totalElems; i++) {
-    let found = false;
-    for (let k = 0; k < reduceDimSize; k++) {
-      const srcSubs = [...outSubs];
-      srcSubs[dimIdx] = k;
-      const srcIdx = sub2ind(shape, srcSubs);
-      if (v.data[srcIdx] !== 0 || v.imag && v.imag[srcIdx] !== 0) {
-        found = true;
-        break;
-      }
-    }
-    result[i] = found ? 1 : 0;
-    for (let d = 0; d < outSubs.length; d++) {
-      if (d === dimIdx) continue;
-      outSubs[d]++;
-      if (outSubs[d] < resultShape[d]) break;
-      outSubs[d] = 0;
-    }
-  }
-  while (resultShape.length > 2 && resultShape[resultShape.length - 1] === 1) {
-    resultShape.pop();
-  }
-  const t = RTV.tensor(result, resultShape);
-  t._isLogical = true;
-  return t;
-}
-function allAlongDim(v, dim) {
-  const shape = v.shape;
-  const dimIdx = dim - 1;
-  if (dimIdx >= shape.length) {
-    const result2 = new FloatXArray(v.data.length);
-    for (let i = 0; i < v.data.length; i++)
-      result2[i] = v.data[i] !== 0 || v.imag && v.imag[i] !== 0 ? 1 : 0;
-    const t2 = RTV.tensor(result2, [...shape]);
-    t2._isLogical = true;
-    return t2;
-  }
-  const reduceDimSize = shape[dimIdx];
-  const resultShape = [...shape];
-  resultShape[dimIdx] = 1;
-  const totalElems = resultShape.reduce((a, b) => a * b, 1);
-  const result = new FloatXArray(totalElems);
-  const outSubs = new Array(shape.length).fill(0);
-  for (let i = 0; i < totalElems; i++) {
-    let allNonZero = true;
-    for (let k = 0; k < reduceDimSize; k++) {
-      const srcSubs = [...outSubs];
-      srcSubs[dimIdx] = k;
-      const srcIdx = sub2ind(shape, srcSubs);
-      if (v.data[srcIdx] === 0 && (!v.imag || v.imag[srcIdx] === 0)) {
-        allNonZero = false;
-        break;
-      }
-    }
-    result[i] = allNonZero ? 1 : 0;
-    for (let d = 0; d < outSubs.length; d++) {
-      if (d === dimIdx) continue;
-      outSubs[d]++;
-      if (outSubs[d] < resultShape[d]) break;
-      outSubs[d] = 0;
-    }
-  }
-  while (resultShape.length > 2 && resultShape[resultShape.length - 1] === 1) {
-    resultShape.pop();
-  }
-  const t = RTV.tensor(result, resultShape);
-  t._isLogical = true;
-  return t;
-}
 function registerReductionFunctions() {
   const defaultDimOrScalar = (v, reduceFn, initial, finalizeFn) => {
     const shape = v.shape;
@@ -27516,15 +27403,9 @@ function registerReductionFunctions() {
         slice[k] = v.data[sub2ind(shape, srcSubs)];
       }
       result[i] = sliceFn(slice);
-      for (let d = 0; d < outSubs.length; d++) {
-        if (d === dimIdx) continue;
-        outSubs[d]++;
-        if (outSubs[d] < resultShape[d]) break;
-        outSubs[d] = 0;
-      }
+      nextSubscripts(outSubs, resultShape, dimIdx);
     }
-    while (resultShape.length > 2 && resultShape[resultShape.length - 1] === 1)
-      resultShape.pop();
+    squeezeTrailing(resultShape);
     return RTV.tensor(result, resultShape);
   };
   const makeSliceReduction = (name, sliceFn) => ({
@@ -27788,16 +27669,9 @@ function registerReductionFunctions() {
             resultRe[i] = mRe;
             resultIm[i] = mIm;
             if (indices2) indices2[i] = mIdx + 1;
-            for (let d = 0; d < outSubsC.length; d++) {
-              if (d === dimIdx) continue;
-              outSubsC[d]++;
-              if (outSubsC[d] < resultShape[d]) break;
-              outSubsC[d] = 0;
-            }
-          }
-          while (resultShape.length > 2 && resultShape[resultShape.length - 1] === 1) {
-            resultShape.pop();
+            nextSubscripts(outSubsC, resultShape, dimIdx);
           }
+          squeezeTrailing(resultShape);
           const hasImag = resultIm.some((x) => x !== 0);
           const outTensorC = RTV.tensor(
             resultRe,
@@ -27829,16 +27703,9 @@ function registerReductionFunctions() {
           if (!foundNonNaN) m = NaN;
           result[i] = m;
           if (indices) indices[i] = mIdx + 1;
-          for (let d = 0; d < outSubs.length; d++) {
-            if (d === dimIdx) continue;
-            outSubs[d]++;
-            if (outSubs[d] < resultShape[d]) break;
-            outSubs[d] = 0;
-          }
-        }
-        while (resultShape.length > 2 && resultShape[resultShape.length - 1] === 1) {
-          resultShape.pop();
+          nextSubscripts(outSubs, resultShape, dimIdx);
         }
+        squeezeTrailing(resultShape);
         const outTensor3 = RTV.tensor(result, resultShape);
         if (v._isLogical) outTensor3._isLogical = true;
         if (nargout > 1) return [outTensor3, RTV.tensor(indices, resultShape)];
@@ -27914,168 +27781,82 @@ function registerReductionFunctions() {
       apply: stdVarApply("var", (v) => v)
     }
   ]);
-  register("any", [
-    {
-      check: (argTypes, nargout) => {
-        if (nargout !== 1) return null;
-        if (argTypes.length === 1) {
+  const makeAnyAll = (name, mode) => {
+    const anyAllCheck = (argTypes, nargout) => {
+      if (nargout !== 1) return null;
+      if (argTypes.length === 1) {
+        return { outputTypes: [{ kind: "Boolean" }] };
+      }
+      if (argTypes.length === 2) {
+        const arg2 = argTypes[1];
+        if (arg2.kind === "Char" || arg2.kind === "String") {
           return { outputTypes: [{ kind: "Boolean" }] };
         }
-        if (argTypes.length === 2) {
-          const arg2 = argTypes[1];
-          if (arg2.kind === "Char" || arg2.kind === "String") {
-            return { outputTypes: [{ kind: "Boolean" }] };
-          }
-          return {
-            outputTypes: [
-              { kind: "Tensor", ndim: 2, shape: "unknown" }
-            ]
-          };
-        }
-        return null;
-      },
-      apply: (args) => {
-        if (args.length < 1)
-          throw new RuntimeError("any requires at least 1 argument");
-        const v = args[0];
-        if (args.length === 1) {
-          if (isRuntimeNumber(v)) return RTV.logical(v !== 0);
-          if (isRuntimeLogical(v)) return RTV.logical(v);
-          if (isRuntimeComplexNumber(v))
-            return RTV.logical(v.re !== 0 || v.im !== 0);
-          if (isRuntimeTensor(v)) {
-            if (v.data.length === 0) return RTV.logical(false);
-            const shape = v.shape;
-            if (shape[0] === 1) {
-              for (let i = 0; i < v.data.length; i++) {
-                if (v.data[i] !== 0) return RTV.logical(true);
-                if (v.imag && v.imag[i] !== 0) return RTV.logical(true);
-              }
-              return RTV.logical(false);
-            }
-            return anyAlongDim(v, 1);
-          }
-          throw new RuntimeError("any: argument must be numeric or logical");
-        }
-        const arg2 = args[1];
-        if ((isRuntimeString(arg2) || isRuntimeChar(arg2)) && rstr(arg2).toLowerCase() === "all") {
-          if (isRuntimeNumber(v)) return RTV.logical(v !== 0);
-          if (isRuntimeLogical(v)) return RTV.logical(v);
-          if (isRuntimeComplexNumber(v))
-            return RTV.logical(v.re !== 0 || v.im !== 0);
-          if (isRuntimeTensor(v)) {
-            for (let i = 0; i < v.data.length; i++) {
-              if (v.data[i] !== 0) return RTV.logical(true);
-              if (v.imag && v.imag[i] !== 0) return RTV.logical(true);
-            }
-            return RTV.logical(false);
-          }
-          throw new RuntimeError("any: argument must be numeric or logical");
-        }
-        if (isRuntimeNumber(v)) return RTV.logical(v !== 0);
-        if (isRuntimeLogical(v)) return RTV.logical(v);
-        if (isRuntimeComplexNumber(v))
-          return RTV.logical(v.re !== 0 || v.im !== 0);
-        if (isRuntimeTensor(v)) {
-          if (isRuntimeNumber(arg2)) {
-            return anyAlongDim(v, Math.round(arg2));
-          }
-          if (isRuntimeTensor(arg2)) {
-            const dims = Array.from(arg2.data).map((d) => Math.round(d));
-            let result = v;
-            for (const dim of dims) {
-              if (isRuntimeTensor(result)) {
-                result = anyAlongDim(result, dim);
-              }
-            }
-            return result;
-          }
-        }
-        throw new RuntimeError("any: invalid arguments");
+        return {
+          outputTypes: [{ kind: "Tensor" }]
+        };
       }
-    }
-  ]);
-  register("all", [
-    {
-      check: (argTypes, nargout) => {
-        if (nargout !== 1) return null;
-        if (argTypes.length === 1) {
-          return { outputTypes: [{ kind: "Boolean" }] };
-        }
-        if (argTypes.length === 2) {
-          const arg2 = argTypes[1];
-          if (arg2.kind === "Char" || arg2.kind === "String") {
-            return { outputTypes: [{ kind: "Boolean" }] };
-          }
-          return {
-            outputTypes: [
-              { kind: "Tensor", ndim: 2, shape: "unknown" }
-            ]
-          };
-        }
-        return null;
-      },
+      return null;
+    };
+    const scalarLogical = (v) => {
+      if (isRuntimeNumber(v)) return RTV.logical(v !== 0);
+      if (isRuntimeLogical(v)) return RTV.logical(v);
+      if (isRuntimeComplexNumber(v))
+        return RTV.logical(v.re !== 0 || v.im !== 0);
+      return null;
+    };
+    return {
+      check: anyAllCheck,
       apply: (args) => {
         if (args.length < 1)
-          throw new RuntimeError("all requires at least 1 argument");
+          throw new RuntimeError(`${name} requires at least 1 argument`);
         const v = args[0];
         if (args.length === 1) {
-          if (isRuntimeNumber(v)) return RTV.logical(v !== 0);
-          if (isRuntimeLogical(v)) return RTV.logical(v);
-          if (isRuntimeComplexNumber(v))
-            return RTV.logical(v.re !== 0 || v.im !== 0);
+          const scalar2 = scalarLogical(v);
+          if (scalar2 !== null) return scalar2;
           if (isRuntimeTensor(v)) {
-            if (v.data.length === 0) return RTV.logical(true);
-            const shape = v.shape;
-            if (shape[0] === 1) {
-              for (let i = 0; i < v.data.length; i++) {
-                if (v.data[i] === 0 && (!v.imag || v.imag[i] === 0))
-                  return RTV.logical(false);
-              }
-              return RTV.logical(v.data.length > 0);
-            }
-            return allAlongDim(v, 1);
+            if (v.data.length === 0) return RTV.logical(mode === "all");
+            if (v.shape[0] === 1)
+              return RTV.logical(scanLogical(v.data, v.imag, mode));
+            return logicalAlongDim(v, 1, mode);
           }
-          throw new RuntimeError("all: argument must be numeric or logical");
+          throw new RuntimeError(
+            `${name}: argument must be numeric or logical`
+          );
         }
         const arg2 = args[1];
         if ((isRuntimeString(arg2) || isRuntimeChar(arg2)) && rstr(arg2).toLowerCase() === "all") {
-          if (isRuntimeNumber(v)) return RTV.logical(v !== 0);
-          if (isRuntimeLogical(v)) return RTV.logical(v);
-          if (isRuntimeComplexNumber(v))
-            return RTV.logical(v.re !== 0 || v.im !== 0);
-          if (isRuntimeTensor(v)) {
-            for (let i = 0; i < v.data.length; i++) {
-              if (v.data[i] === 0 && (!v.imag || v.imag[i] === 0))
-                return RTV.logical(false);
-            }
-            return RTV.logical(v.data.length > 0);
-          }
-          throw new RuntimeError("all: argument must be numeric or logical");
+          const scalar2 = scalarLogical(v);
+          if (scalar2 !== null) return scalar2;
+          if (isRuntimeTensor(v))
+            return RTV.logical(scanLogical(v.data, v.imag, mode));
+          throw new RuntimeError(
+            `${name}: argument must be numeric or logical`
+          );
         }
-        if (isRuntimeNumber(v)) return RTV.logical(v !== 0);
-        if (isRuntimeLogical(v)) return RTV.logical(v);
-        if (isRuntimeComplexNumber(v))
-          return RTV.logical(v.re !== 0 || v.im !== 0);
+        const scalar = scalarLogical(v);
+        if (scalar !== null) return scalar;
         if (isRuntimeTensor(v)) {
           if (isRuntimeNumber(arg2)) {
-            return allAlongDim(v, Math.round(arg2));
+            return logicalAlongDim(v, Math.round(arg2), mode);
           }
           if (isRuntimeTensor(arg2)) {
             const dims = Array.from(arg2.data).map((d) => Math.round(d));
             let result = v;
             for (const dim of dims) {
               if (isRuntimeTensor(result)) {
-                result = allAlongDim(result, dim);
+                result = logicalAlongDim(result, dim, mode);
               }
             }
             return result;
           }
         }
-        throw new RuntimeError("all: invalid arguments");
+        throw new RuntimeError(`${name}: invalid arguments`);
       }
-    }
-  ]);
+    };
+  };
+  register("any", [makeAnyAll("any", "any")]);
+  register("all", [makeAnyAll("all", "all")]);
   register(
     "xor",
     builtinSingle(
@@ -28326,11 +28107,7 @@ function registerReductionFunctions() {
                   resultIm[fiberFlatIdx[r]] = im[fiberFlatIdx[order[r]]];
                 if (resultIdx) resultIdx[fiberFlatIdx[r]] = order[r] + 1;
               }
-              for (let d = 0; d < fiberSubs.length; d++) {
-                fiberSubs[d]++;
-                if (fiberSubs[d] < fiberShape[d]) break;
-                fiberSubs[d] = 0;
-              }
+              nextSubscripts(fiberSubs, fiberShape);
             }
           }
           const imOut = resultIm && resultIm.some((x) => x !== 0) ? resultIm : void 0;
@@ -28709,11 +28486,7 @@ function registerReductionFunctions() {
               if (resultImag) resultImag[idx] = accIm;
             }
           }
-          for (let d = 0; d < fiberSubs.length; d++) {
-            fiberSubs[d]++;
-            if (fiberSubs[d] < fiberShape[d]) break;
-            fiberSubs[d] = 0;
-          }
+          nextSubscripts(fiberSubs, fiberShape);
         }
       }
       const imOut = resultImag && resultImag.some((x) => x !== 0) ? resultImag : void 0;
@@ -30676,15 +30449,12 @@ function registerDot() {
 function qrLapack(data, m, n, econ, wantQ) {
   const bridge = getEffectiveBridge("qr", "qr");
   if (!bridge?.qr) return null;
-  const f64 = data instanceof Float64Array ? data : new Float64Array(data);
-  return bridge.qr(f64, m, n, econ, wantQ);
+  return bridge.qr(toF64(data), m, n, econ, wantQ);
 }
 function qrLapackComplex(dataRe, dataIm, m, n, econ, wantQ) {
   const bridge = getEffectiveBridge("qr", "qrComplex");
   if (!bridge?.qrComplex) return null;
-  const re = dataRe instanceof Float64Array ? dataRe : new Float64Array(dataRe);
-  const im = dataIm instanceof Float64Array ? dataIm : new Float64Array(dataIm);
-  return bridge.qrComplex(re, im, m, n, econ, wantQ);
+  return bridge.qrComplex(toF64(dataRe), toF64(dataIm), m, n, econ, wantQ);
 }
 function registerQr() {
   register("qr", [
@@ -30902,15 +30672,12 @@ function registerQr() {
 // src/numbl-core/builtins/linear-algebra/inv.ts
 function invLapack(data, n) {
   const bridge = getEffectiveBridge("inv");
-  const f64 = data instanceof Float64Array ? data : new Float64Array(data);
-  return bridge.inv(f64, n);
+  return bridge.inv(toF64(data), n);
 }
 function invLapackComplex(dataRe, dataIm, n) {
   const bridge = getLapackBridge();
   if (!bridge || !bridge.invComplex) return null;
-  const f64Re = dataRe instanceof Float64Array ? dataRe : new Float64Array(dataRe);
-  const f64Im = dataIm instanceof Float64Array ? dataIm : new Float64Array(dataIm);
-  return bridge.invComplex(f64Re, f64Im, n);
+  return bridge.invComplex(toF64(dataRe), toF64(dataIm), n);
 }
 function invComplexJS(dataRe, dataIm, n) {
   const augRe = new Float64Array(n * 2 * n);
@@ -31140,14 +30907,11 @@ function registerDet() {
         const [m, n] = tensorSize2D(A);
         if (m !== n) throw new RuntimeError("det: matrix must be square");
         if (A.imag) {
-          const dataRe = A.data instanceof Float64Array ? A.data : new Float64Array(A.data);
-          const dataIm = A.imag instanceof Float64Array ? A.imag : new Float64Array(A.imag);
-          const [detRe, detIm] = detComplexJS(dataRe, dataIm, n);
+          const [detRe, detIm] = detComplexJS(toF64(A.data), toF64(A.imag), n);
           if (Math.abs(detIm) < 1e-15) return RTV.num(detRe);
           return RTV.complex(detRe, detIm);
         }
-        const data = A.data instanceof Float64Array ? A.data : new Float64Array(A.data);
-        return RTV.num(detJS(data, n));
+        return RTV.num(detJS(toF64(A.data), n));
       }
     }
   ]);
@@ -31235,15 +30999,12 @@ function registerDet() {
 function svdLapack(data, m, n, econ, computeUV) {
   const bridge = getEffectiveBridge("svd", "svd");
   if (!bridge || !bridge.svd) return null;
-  const f64 = data instanceof Float64Array ? data : new Float64Array(data);
-  return bridge.svd(f64, m, n, econ, computeUV);
+  return bridge.svd(toF64(data), m, n, econ, computeUV);
 }
 function svdLapackComplex(dataRe, dataIm, m, n, econ, computeUV) {
   const bridge = getLapackBridge();
   if (!bridge || !bridge.svdComplex) return null;
-  const f64Re = dataRe instanceof Float64Array ? dataRe : new Float64Array(dataRe);
-  const f64Im = dataIm instanceof Float64Array ? dataIm : new Float64Array(dataIm);
-  return bridge.svdComplex(f64Re, f64Im, m, n, econ, computeUV);
+  return bridge.svdComplex(toF64(dataRe), toF64(dataIm), m, n, econ, computeUV);
 }
 function registerSvd() {
   register("svd", [
@@ -31858,14 +31619,8 @@ function parseEigOptionsRuntime(args) {
   let outputForm = "matrix";
   for (let i = 1; i < args.length; i++) {
     const arg = args[i];
-    if (isRuntimeString(arg)) {
-      const val = arg.replace(/^['"]|['"]$/g, "").toLowerCase();
-      if (val === "nobalance") balance = false;
-      else if (val === "balance") balance = true;
-      else if (val === "vector") outputForm = "vector";
-      else if (val === "matrix") outputForm = "matrix";
-    } else if (isRuntimeChar(arg)) {
-      const val = arg.value.replace(/^['"]|['"]$/g, "").toLowerCase();
+    if (isRuntimeString(arg) || isRuntimeChar(arg)) {
+      const val = parseStringArgLower(arg);
       if (val === "nobalance") balance = false;
       else if (val === "balance") balance = true;
       else if (val === "vector") outputForm = "vector";
@@ -31965,11 +31720,9 @@ function registerEig() {
         const computeVL = nargout >= 3;
         const computeVR = nargout >= 2;
         if (A.imag) {
-          const f64Re = A.data instanceof Float64Array ? A.data : new Float64Array(A.data);
-          const f64Im = A.imag instanceof Float64Array ? A.imag : new Float64Array(A.imag);
           const result2 = eigLapackComplex(
-            f64Re,
-            f64Im,
+            toF64(A.data),
+            toF64(A.imag),
             n,
             computeVL,
             computeVR
@@ -32056,8 +31809,13 @@ function registerEig() {
           }
           return [Vout2, Dout2, Wout2];
         }
-        const f64 = A.data instanceof Float64Array ? A.data : new Float64Array(A.data);
-        const result = eigLapack(f64, n, computeVL, computeVR, balance);
+        const result = eigLapack(
+          toF64(A.data),
+          n,
+          computeVL,
+          computeVR,
+          balance
+        );
         if (!result) {
           throw new RuntimeError("eig: LAPACK bridge not available");
         }
@@ -32450,15 +32208,12 @@ function registerPagetranspose() {
 function luLapack(data, m, n) {
   const bridge = getEffectiveBridge("lu", "lu");
   if (!bridge?.lu) return null;
-  const f64 = data instanceof Float64Array ? data : new Float64Array(data);
-  return bridge.lu(f64, m, n);
+  return bridge.lu(toF64(data), m, n);
 }
 function luLapackComplex(dataRe, dataIm, m, n) {
   const bridge = getEffectiveBridge("lu", "luComplex");
   if (!bridge?.luComplex) return null;
-  const re = dataRe instanceof Float64Array ? dataRe : new Float64Array(dataRe);
-  const im = dataIm instanceof Float64Array ? dataIm : new Float64Array(dataIm);
-  return bridge.luComplex(re, im, m, n);
+  return bridge.luComplex(toF64(dataRe), toF64(dataIm), m, n);
 }
 function ipivToPermVector(ipiv, m) {
   const perm = new Int32Array(m);
@@ -32475,15 +32230,9 @@ function ipivToPermVector(ipiv, m) {
 }
 function parseOutputForm(arg) {
   if (arg === void 0) return "matrix";
-  let s;
-  if (isRuntimeString(arg)) {
-    s = arg.replace(/^['"]|['"]$/g, "").toLowerCase();
-  } else if (typeof arg === "object" && arg !== null && arg.kind === "char") {
-    s = arg.value.toLowerCase();
-  }
+  const s = parseStringArgLower(arg);
   if (s === "vector") return "vector";
   if (s === "matrix") return "matrix";
-  if (s !== void 0) return null;
   return null;
 }
 function registerLu() {
@@ -32691,24 +32440,16 @@ function registerBlkdiag() {
 function cholLapack(data, n, upper) {
   const bridge = getEffectiveBridge("chol", "chol");
   if (!bridge?.chol) return null;
-  const f64 = data instanceof Float64Array ? data : new Float64Array(data);
-  return bridge.chol(f64, n, upper);
+  return bridge.chol(toF64(data), n, upper);
 }
 function cholLapackComplex(dataRe, dataIm, n, upper) {
   const bridge = getEffectiveBridge("chol", "cholComplex");
   if (!bridge?.cholComplex) return null;
-  const re = dataRe instanceof Float64Array ? dataRe : new Float64Array(dataRe);
-  const im = dataIm instanceof Float64Array ? dataIm : new Float64Array(dataIm);
-  return bridge.cholComplex(re, im, n, upper);
+  return bridge.cholComplex(toF64(dataRe), toF64(dataIm), n, upper);
 }
 function parseTriangleArg(arg) {
   if (arg === void 0) return "upper";
-  let s;
-  if (isRuntimeString(arg)) {
-    s = arg.replace(/^['"]|['"]$/g, "").toLowerCase();
-  } else if (typeof arg === "object" && arg !== null && arg.kind === "char") {
-    s = arg.value.toLowerCase();
-  }
+  const s = parseStringArgLower(arg);
   if (s === "upper") return "upper";
   if (s === "lower") return "lower";
   return null;
@@ -32856,8 +32597,7 @@ function registerPinv() {
       if (!bridge || !bridge.svd) {
         return pinvFallback(A.data, m, n);
       }
-      const f64 = A.data instanceof Float64Array ? A.data : new Float64Array(A.data);
-      const svdResult = bridge.svd(f64, m, n, true, true);
+      const svdResult = bridge.svd(toF64(A.data), m, n, true, true);
       if (!svdResult || !svdResult.U || !svdResult.V)
         throw new RuntimeError("pinv: SVD computation failed");
       const { U, S, V } = svdResult;
@@ -33038,9 +32778,6 @@ function qzComplexLapack(dataARe, dataAIm, dataBRe, dataBIm, n, computeEigvecs)
     computeEigvecs
   );
 }
-function toF64(data) {
-  return data instanceof Float64Array ? data : new Float64Array(data);
-}
 function zeroF64(n) {
   return new Float64Array(n);
 }
@@ -33815,48 +33552,32 @@ function registerMiscFunctions() {
       { outputType: { kind: "Number" } }
     )
   );
-  register(
-    "true",
-    builtinSingle((args) => {
-      if (args.length === 0) return RTV.logical(true);
-      const shape = parseShapeArgs(args);
-      const rows = shape[0];
-      const cols = shape[1] ?? rows;
-      const t = RTV.tensor(new FloatXArray(rows * cols).fill(1), [rows, cols]);
-      t._isLogical = true;
-      return t;
-    })
-  );
-  register(
-    "false",
-    builtinSingle((args) => {
-      if (args.length === 0) return RTV.logical(false);
-      const shape = parseShapeArgs(args);
-      const rows = shape[0];
-      const cols = shape[1] ?? rows;
-      const t = RTV.tensor(new FloatXArray(rows * cols), [rows, cols]);
-      t._isLogical = true;
-      return t;
-    })
-  );
-  register(
-    "clear",
-    builtinSingle(() => {
-      return RTV.num(0);
-    })
-  );
-  register(
-    "clc",
-    builtinSingle(() => {
-      return RTV.num(0);
-    })
-  );
-  register(
-    "clf",
-    builtinSingle(() => {
-      return RTV.num(0);
-    })
-  );
+  for (const [name, scalarVal, fillVal] of [
+    ["true", true, 1],
+    ["false", false, 0]
+  ]) {
+    register(
+      name,
+      builtinSingle((args) => {
+        if (args.length === 0) return RTV.logical(scalarVal);
+        const shape = parseShapeArgs(args);
+        const rows = shape[0];
+        const cols = shape[1] ?? rows;
+        const t = RTV.tensor(
+          fillVal ? new FloatXArray(rows * cols).fill(1) : new FloatXArray(rows * cols),
+          [rows, cols]
+        );
+        t._isLogical = true;
+        return t;
+      })
+    );
+  }
+  for (const name of ["clear", "clc", "clf"]) {
+    register(
+      name,
+      builtinSingle(() => RTV.num(0))
+    );
+  }
   register(
     "exist",
     builtinSingle((args) => {
@@ -33906,12 +33627,14 @@ function registerMiscFunctions() {
       return result.returnValue;
     })
   );
-  register(
-    "feval",
-    builtinSingle(() => {
-      throw new RuntimeError("feval: should be handled by runtime");
-    })
-  );
+  for (const name of ["feval", "arrayfun", "cellfun", "structfun", "bsxfun"]) {
+    register(
+      name,
+      builtinSingle(() => {
+        throw new RuntimeError(`${name}: should be handled by runtime`);
+      })
+    );
+  }
   register(
     "deal",
     builtinSingle((args, nargout) => {
@@ -33940,30 +33663,6 @@ function registerMiscFunctions() {
       return RTV.string(v.name);
     })
   );
-  register(
-    "arrayfun",
-    builtinSingle(() => {
-      throw new RuntimeError("arrayfun: should be handled by runtime");
-    })
-  );
-  register(
-    "cellfun",
-    builtinSingle(() => {
-      throw new RuntimeError("cellfun: should be handled by runtime");
-    })
-  );
-  register(
-    "structfun",
-    builtinSingle(() => {
-      throw new RuntimeError("structfun: should be handled by runtime");
-    })
-  );
-  register(
-    "bsxfun",
-    builtinSingle(() => {
-      throw new RuntimeError("bsxfun: should be handled by runtime");
-    })
-  );
   const opMap = [
     ["plus", mAdd],
     ["minus", mSub],
@@ -34010,18 +33709,12 @@ function registerMiscFunctions() {
       return args[0];
     })
   );
-  register(
-    "narginchk",
-    builtinSingle(() => {
-      return RTV.num(0);
-    })
-  );
-  register(
-    "nargoutchk",
-    builtinSingle(() => {
-      return RTV.num(0);
-    })
-  );
+  for (const name of ["narginchk", "nargoutchk"]) {
+    register(
+      name,
+      builtinSingle(() => RTV.num(0))
+    );
+  }
   register(
     "__inferred_type_str",
     builtinSingle(
@@ -34033,335 +33726,119 @@ function registerMiscFunctions() {
       { outputType: { kind: "String" } }
     )
   );
-  register(
-    "cart2sph",
-    builtinSingle((args, nargout) => {
-      if (args.length !== 3)
-        throw new RuntimeError("cart2sph requires 3 arguments");
-      const x = args[0];
-      const y = args[1];
-      const z = args[2];
-      const xIsT = isRuntimeTensor(x);
-      const yIsT = isRuntimeTensor(y);
-      const zIsT = isRuntimeTensor(z);
-      if (xIsT || yIsT || zIsT) {
-        const xd = xIsT ? x.data : null;
-        const yd = yIsT ? y.data : null;
-        const zd = zIsT ? z.data : null;
-        const shape = xIsT ? x.shape : yIsT ? y.shape : z.shape;
-        const len = xIsT ? xd.length : yIsT ? yd.length : zd.length;
-        const azData = new FloatXArray(len);
-        const elData = new FloatXArray(len);
-        const rData = new FloatXArray(len);
-        for (let i = 0; i < len; i++) {
-          const xi = xd ? xd[i] : toNumber(x);
-          const yi = yd ? yd[i] : toNumber(y);
-          const zi = zd ? zd[i] : toNumber(z);
-          const hypotxy2 = Math.sqrt(xi * xi + yi * yi);
-          azData[i] = Math.atan2(yi, xi);
-          elData[i] = Math.atan2(zi, hypotxy2);
-          rData[i] = Math.sqrt(xi * xi + yi * yi + zi * zi);
-        }
-        if (nargout <= 1) return RTV.tensor(azData, shape);
-        return [
-          RTV.tensor(azData, shape),
-          RTV.tensor(elData, shape),
-          RTV.tensor(rData, shape)
-        ];
-      }
-      const xv = toNumber(x);
-      const yv = toNumber(y);
-      const zv = toNumber(z);
-      const hypotxy = Math.sqrt(xv * xv + yv * yv);
-      const az = Math.atan2(yv, xv);
-      const el = Math.atan2(zv, hypotxy);
-      const r = Math.sqrt(xv * xv + yv * yv + zv * zv);
-      if (nargout <= 1) return RTV.num(az);
-      return [RTV.num(az), RTV.num(el), RTV.num(r)];
-    }),
-    3
-  );
-  register(
-    "sph2cart",
-    builtinSingle((args, nargout) => {
-      if (args.length !== 3)
-        throw new RuntimeError("sph2cart requires 3 arguments");
-      const az = args[0];
-      const el = args[1];
-      const r = args[2];
-      const azIsT = isRuntimeTensor(az);
-      const elIsT = isRuntimeTensor(el);
-      const rIsT = isRuntimeTensor(r);
-      if (azIsT || elIsT || rIsT) {
-        const azd = azIsT ? az.data : null;
-        const eld = elIsT ? el.data : null;
-        const rd = rIsT ? r.data : null;
-        const shape = azIsT ? az.shape : elIsT ? el.shape : r.shape;
-        const len = azIsT ? azd.length : elIsT ? eld.length : rd.length;
-        const xData = new FloatXArray(len);
-        const yData = new FloatXArray(len);
-        const zData = new FloatXArray(len);
-        for (let i = 0; i < len; i++) {
-          const a = azd ? azd[i] : toNumber(az);
-          const e = eld ? eld[i] : toNumber(el);
-          const rv2 = rd ? rd[i] : toNumber(r);
-          const rcosel2 = rv2 * Math.cos(e);
-          xData[i] = rcosel2 * Math.cos(a);
-          yData[i] = rcosel2 * Math.sin(a);
-          zData[i] = rv2 * Math.sin(e);
-        }
-        if (nargout <= 1) return RTV.tensor(xData, shape);
-        return [
-          RTV.tensor(xData, shape),
-          RTV.tensor(yData, shape),
-          RTV.tensor(zData, shape)
-        ];
-      }
-      const av = toNumber(az);
-      const ev = toNumber(el);
-      const rv = toNumber(r);
-      const rcosel = rv * Math.cos(ev);
-      const xv = rcosel * Math.cos(av);
-      const yv = rcosel * Math.sin(av);
-      const zv = rv * Math.sin(ev);
-      if (nargout <= 1) return RTV.num(xv);
-      return [RTV.num(xv), RTV.num(yv), RTV.num(zv)];
-    }),
-    3
-  );
-  register(
-    "cart2pol",
-    builtinSingle((args, nargout) => {
-      if (args.length < 2 || args.length > 3)
-        throw new RuntimeError("cart2pol requires 2 or 3 arguments");
-      const x = args[0];
-      const y = args[1];
-      const hasZ = args.length === 3;
-      const z = hasZ ? args[2] : void 0;
-      const xIsT = isRuntimeTensor(x);
-      const yIsT = isRuntimeTensor(y);
-      const zIsT = z !== void 0 && isRuntimeTensor(z);
-      if (xIsT || yIsT || zIsT) {
-        const xd = xIsT ? x.data : null;
-        const yd = yIsT ? y.data : null;
-        const zd = zIsT ? z.data : null;
-        const shape = xIsT ? x.shape : yIsT ? y.shape : z.shape;
-        const len = xIsT ? xd.length : yIsT ? yd.length : zd.length;
-        const thData = new FloatXArray(len);
-        const rhoData = new FloatXArray(len);
-        for (let i = 0; i < len; i++) {
-          const xi = xd ? xd[i] : toNumber(x);
-          const yi = yd ? yd[i] : toNumber(y);
-          thData[i] = Math.atan2(yi, xi);
-          rhoData[i] = Math.sqrt(xi * xi + yi * yi);
-        }
-        if (!hasZ) {
-          if (nargout <= 1) return RTV.tensor(thData, shape);
-          return [RTV.tensor(thData, shape), RTV.tensor(rhoData, shape)];
-        }
-        const zOutData = new FloatXArray(len);
-        for (let i = 0; i < len; i++) {
-          zOutData[i] = zd ? zd[i] : toNumber(z);
-        }
-        if (nargout <= 1) return RTV.tensor(thData, shape);
-        if (nargout === 2)
-          return [RTV.tensor(thData, shape), RTV.tensor(rhoData, shape)];
-        return [
-          RTV.tensor(thData, shape),
-          RTV.tensor(rhoData, shape),
-          RTV.tensor(zOutData, shape)
-        ];
-      }
-      const xv = toNumber(x);
-      const yv = toNumber(y);
-      const th = Math.atan2(yv, xv);
-      const rho = Math.sqrt(xv * xv + yv * yv);
-      if (!hasZ) {
-        if (nargout <= 1) return RTV.num(th);
-        return [RTV.num(th), RTV.num(rho)];
-      }
-      const zv = toNumber(z);
-      if (nargout <= 1) return RTV.num(th);
-      if (nargout === 2) return [RTV.num(th), RTV.num(rho)];
-      return [RTV.num(th), RTV.num(rho), RTV.num(zv)];
-    })
-  );
-  register(
-    "pol2cart",
-    builtinSingle((args, nargout) => {
-      if (args.length < 2 || args.length > 3)
-        throw new RuntimeError("pol2cart requires 2 or 3 arguments");
-      const theta = args[0];
-      const rho = args[1];
-      const hasZ = args.length === 3;
-      const z = hasZ ? args[2] : void 0;
-      const thIsT = isRuntimeTensor(theta);
-      const rhoIsT = isRuntimeTensor(rho);
-      const zIsT = z !== void 0 && isRuntimeTensor(z);
-      if (thIsT || rhoIsT || zIsT) {
-        const thd = thIsT ? theta.data : null;
-        const rhod = rhoIsT ? rho.data : null;
-        const zd = zIsT ? z.data : null;
-        const shape = thIsT ? theta.shape : rhoIsT ? rho.shape : z.shape;
-        const len = thIsT ? thd.length : rhoIsT ? rhod.length : zd.length;
-        const xData = new FloatXArray(len);
-        const yData = new FloatXArray(len);
-        for (let i = 0; i < len; i++) {
-          const t = thd ? thd[i] : toNumber(theta);
-          const rv2 = rhod ? rhod[i] : toNumber(rho);
-          xData[i] = rv2 * Math.cos(t);
-          yData[i] = rv2 * Math.sin(t);
-        }
-        if (!hasZ) {
-          if (nargout <= 1) return RTV.tensor(xData, shape);
-          return [RTV.tensor(xData, shape), RTV.tensor(yData, shape)];
-        }
-        const zOutData = new FloatXArray(len);
-        for (let i = 0; i < len; i++) {
-          zOutData[i] = zd ? zd[i] : toNumber(z);
-        }
-        if (nargout <= 1) return RTV.tensor(xData, shape);
-        if (nargout === 2)
-          return [RTV.tensor(xData, shape), RTV.tensor(yData, shape)];
-        return [
-          RTV.tensor(xData, shape),
-          RTV.tensor(yData, shape),
-          RTV.tensor(zOutData, shape)
-        ];
-      }
-      const tv = toNumber(theta);
-      const rv = toNumber(rho);
-      const xv = rv * Math.cos(tv);
-      const yv = rv * Math.sin(tv);
-      if (!hasZ) {
-        if (nargout <= 1) return RTV.num(xv);
-        return [RTV.num(xv), RTV.num(yv)];
-      }
-      const zv = toNumber(z);
-      if (nargout <= 1) return RTV.num(xv);
-      if (nargout === 2) return [RTV.num(xv), RTV.num(yv)];
-      return [RTV.num(xv), RTV.num(yv), RTV.num(zv)];
-    })
-  );
+  function coordTransform(name, nArgs, nOut, fn) {
+    register(
+      name,
+      builtinSingle((args, nargout) => {
+        const minArgs = nArgs === "2or3" ? 2 : nArgs;
+        const maxArgs = nArgs === "2or3" ? 3 : nArgs;
+        if (args.length < minArgs || args.length > maxArgs)
+          throw new RuntimeError(
+            `${name} requires ${nArgs === "2or3" ? "2 or 3" : nArgs} arguments`
+          );
+        const n = args.length;
+        const tensors = args.map((a) => isRuntimeTensor(a) ? a : null);
+        const anyTensor = tensors.some((t) => t !== null);
+        if (anyTensor) {
+          const refT = tensors.find((t) => t !== null);
+          const shape = refT.shape;
+          const len = refT.data.length;
+          const datas = tensors.map((t) => t ? t.data : null);
+          const scalars = args.map((a, i) => datas[i] ? 0 : toNumber(a));
+          const outArrays = Array.from(
+            { length: nOut },
+            () => new FloatXArray(len)
+          );
+          for (let i = 0; i < len; i++) {
+            const vals2 = datas.map((d, j) => d ? d[i] : scalars[j]);
+            const result2 = fn(...vals2);
+            for (let k = 0; k < nOut; k++) outArrays[k][i] = result2[k];
+          }
+          const effOut2 = nArgs === "2or3" && n === 3 ? 3 : nOut;
+          const outTensors = outArrays.map((d) => RTV.tensor(d, shape));
+          if (nArgs === "2or3" && n === 3 && nOut === 2) {
+            const zd = datas[2];
+            const zOut = new FloatXArray(len);
+            for (let i = 0; i < len; i++) zOut[i] = zd ? zd[i] : scalars[2];
+            outTensors.push(RTV.tensor(zOut, shape));
+          }
+          if (nargout <= 1) return outTensors[0];
+          return outTensors.slice(0, Math.min(nargout, effOut2));
+        }
+        const vals = args.map((a) => toNumber(a));
+        const result = fn(...vals);
+        const effOut = nArgs === "2or3" && n === 3 ? 3 : nOut;
+        const outVals = result.map((v) => RTV.num(v));
+        if (nArgs === "2or3" && n === 3 && nOut === 2) {
+          outVals.push(RTV.num(vals[2]));
+        }
+        if (nargout <= 1) return outVals[0];
+        return outVals.slice(0, Math.min(nargout, effOut));
+      }),
+      nOut
+    );
+  }
+  coordTransform("cart2sph", 3, 3, (x, y, z) => {
+    const hypotxy = Math.sqrt(x * x + y * y);
+    return [
+      Math.atan2(y, x),
+      Math.atan2(z, hypotxy),
+      Math.sqrt(x * x + y * y + z * z)
+    ];
+  });
+  coordTransform("sph2cart", 3, 3, (az, el, r) => {
+    const rcosel = r * Math.cos(el);
+    return [rcosel * Math.cos(az), rcosel * Math.sin(az), r * Math.sin(el)];
+  });
+  coordTransform("cart2pol", "2or3", 2, (x, y) => [
+    Math.atan2(y, x),
+    Math.sqrt(x * x + y * y)
+  ]);
+  coordTransform("pol2cart", "2or3", 2, (theta, rho) => [
+    rho * Math.cos(theta),
+    rho * Math.sin(theta)
+  ]);
 }
 
 // src/numbl-core/builtins/graphics.ts
 function registerGraphicsFunctions() {
-  register(
+  const placeholderNames = [
     "figure",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "plot",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "plot3",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "surf",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "hold",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
-    "ishold",
-    builtinSingle(() => RTV.logical(false), { outputType: IType.Logical })
-  );
-  register(
     "grid",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "clf",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "close",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "title",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "xlabel",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "ylabel",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "shading",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "subplot",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "legend",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "sgtitle",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "zlabel",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "colorbar",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "colormap",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "axis",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "view",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "imagesc",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "contour",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "contourf",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "mesh",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "waterfall",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "scatter",
-    builtinSingle(() => RTV.num(0))
-  );
-  register(
     "drawnow",
-    builtinSingle(() => RTV.num(0))
-  );
+    "pause"
+  ];
+  const placeholder = builtinSingle(() => RTV.num(0));
+  for (const name of placeholderNames) {
+    register(name, placeholder);
+  }
   register(
-    "pause",
-    builtinSingle(() => RTV.num(0))
+    "ishold",
+    builtinSingle(() => RTV.logical(false), { outputType: IType.Logical })
   );
   const colormapNames = [
     "parula",
@@ -34539,6 +34016,9 @@ function registerValidatorFunctions() {
 }
 
 // src/numbl-core/builtins/dummy.ts
+function registerDummyGroup(names, fn) {
+  for (const name of names) register(name, fn);
+}
 var dummyHandleFunctions = [
   "groot",
   "gcf",
@@ -34550,14 +34030,6 @@ var dummyHandleFunctions = [
   "axis",
   "odeset"
 ];
-function registerDummyHandleFunctions() {
-  const fn = builtinSingle(() => RTV.dummyHandle(), {
-    outputType: IType.DummyHandle
-  });
-  for (const name of dummyHandleFunctions) {
-    register(name, fn);
-  }
-}
 var returnDummyStringFunctions = [
   "pwd",
   "datestr",
@@ -34565,41 +34037,9 @@ var returnDummyStringFunctions = [
   "lastwarn",
   "mfilename"
 ];
-function registerDummyStringFunctions() {
-  const fn = builtinSingle(() => RTV.string(""), {
-    outputType: IType.String
-  });
-  for (const name of returnDummyStringFunctions) {
-    register(name, fn);
-  }
-}
 var returnEmptyArrayFunctions = ["who", "xlim", "ylim"];
-function registerDummyArrayFunctions() {
-  const fn = builtinSingle(() => RTV.tensor([], [0, 0]), {
-    outputType: IType.tensor()
-  });
-  for (const name of returnEmptyArrayFunctions) {
-    register(name, fn);
-  }
-}
 var returnDummyBooleanFunctions = ["ispc", "ismac", "isunix"];
-function registerDummyBooleanFunctions() {
-  const fn = builtinSingle(() => RTV.logical(false), {
-    outputType: IType.Logical
-  });
-  for (const name of returnDummyBooleanFunctions) {
-    register(name, fn);
-  }
-}
 var returnDummyCellArrayFunctions = ["listfonts"];
-function registerDummyCellArrayFunctions() {
-  const fn = builtinSingle(() => RTV.cell([], [0, 0]), {
-    outputType: IType.cell(IType.Unknown, "unknown")
-  });
-  for (const name of returnDummyCellArrayFunctions) {
-    register(name, fn);
-  }
-}
 function registerPathFunctions() {
   const dummyStr = builtinSingle(() => RTV.string(""), {
     outputType: IType.String
@@ -34647,11 +34087,28 @@ function registerHandleGetSet() {
   );
 }
 var registerDummyFunctions = () => {
-  registerDummyHandleFunctions();
-  registerDummyStringFunctions();
-  registerDummyArrayFunctions();
-  registerDummyBooleanFunctions();
-  registerDummyCellArrayFunctions();
+  registerDummyGroup(
+    dummyHandleFunctions,
+    builtinSingle(() => RTV.dummyHandle(), { outputType: IType.DummyHandle })
+  );
+  registerDummyGroup(
+    returnDummyStringFunctions,
+    builtinSingle(() => RTV.string(""), { outputType: IType.String })
+  );
+  registerDummyGroup(
+    returnEmptyArrayFunctions,
+    builtinSingle(() => RTV.tensor([], [0, 0]), { outputType: IType.tensor() })
+  );
+  registerDummyGroup(
+    returnDummyBooleanFunctions,
+    builtinSingle(() => RTV.logical(false), { outputType: IType.Logical })
+  );
+  registerDummyGroup(
+    returnDummyCellArrayFunctions,
+    builtinSingle(() => RTV.cell([], [0, 0]), {
+      outputType: IType.cell(IType.Unknown, "unknown")
+    })
+  );
   registerHandleGetSet();
   registerPathFunctions();
   registerFileIOFunctions();
@@ -34789,6 +34246,11 @@ function registerNumericalFunctions() {
         throw new RuntimeError("polyfit: x and y must have the same length");
       if (n < 0) throw new RuntimeError("polyfit: degree must be non-negative");
       const ncols = n + 1;
+      if (ncols > m) {
+        console.warn(
+          "Warning: Polynomial is not unique; degree >= number of data points."
+        );
+      }
       const V = new FloatXArray(m * ncols);
       for (let j = 0; j < ncols; j++) {
         const power = n - j;
@@ -34796,65 +34258,31 @@ function registerNumericalFunctions() {
           V[j * m + i] = Math.pow(xArr[i], power);
         }
       }
-      const VTV = new FloatXArray(ncols * ncols);
+      const B = new FloatXArray(m);
+      for (let i = 0; i < m; i++) B[i] = yArr[i];
+      const X = linsolveLapack(V, m, ncols, B, 1);
+      if (!X) throw new RuntimeError("polyfit: LAPACK bridge unavailable");
+      let badlyConditioned = false;
       for (let i = 0; i < ncols; i++) {
-        for (let j = 0; j < ncols; j++) {
-          let sum = 0;
-          for (let k = 0; k < m; k++) {
-            sum += V[i * m + k] * V[j * m + k];
-          }
-          VTV[j * ncols + i] = sum;
-        }
-      }
-      const VTy = new FloatXArray(ncols);
-      for (let i = 0; i < ncols; i++) {
-        let sum = 0;
-        for (let k = 0; k < m; k++) {
-          sum += V[i * m + k] * yArr[k];
+        if (!isFinite(X[i])) {
+          badlyConditioned = true;
+          break;
         }
-        VTy[i] = sum;
       }
-      const aug = new FloatXArray(ncols * (ncols + 1));
-      for (let i = 0; i < ncols; i++) {
-        for (let j = 0; j < ncols; j++) {
-          aug[j * ncols + i] = VTV[j * ncols + i];
-        }
-        aug[ncols * ncols + i] = VTy[i];
+      if (!badlyConditioned) {
+        let maxX = 0;
+        for (let i = 0; i < ncols; i++) maxX = Math.max(maxX, Math.abs(X[i]));
+        let maxY = 0;
+        for (let i = 0; i < m; i++) maxY = Math.max(maxY, Math.abs(yArr[i]));
+        if (maxY > 0 && maxX / maxY > 1e10) badlyConditioned = true;
       }
-      for (let col = 0; col < ncols; col++) {
-        let maxVal = Math.abs(aug[col * ncols + col]);
-        let maxRow = col;
-        for (let row = col + 1; row < ncols; row++) {
-          const val = Math.abs(aug[col * ncols + row]);
-          if (val > maxVal) {
-            maxVal = val;
-            maxRow = row;
-          }
-        }
-        if (maxRow !== col) {
-          for (let j = 0; j <= ncols; j++) {
-            const tmp = aug[j * ncols + col];
-            aug[j * ncols + col] = aug[j * ncols + maxRow];
-            aug[j * ncols + maxRow] = tmp;
-          }
-        }
-        const pivot = aug[col * ncols + col];
-        if (Math.abs(pivot) < 1e-14) continue;
-        for (let j = 0; j <= ncols; j++) {
-          aug[j * ncols + col] /= pivot;
-        }
-        for (let row = 0; row < ncols; row++) {
-          if (row === col) continue;
-          const factor = aug[col * ncols + row];
-          for (let j = 0; j <= ncols; j++) {
-            aug[j * ncols + row] -= factor * aug[j * ncols + col];
-          }
-        }
+      if (badlyConditioned) {
+        console.warn(
+          "Warning: Polynomial is badly conditioned. Add points with distinct X values, reduce the degree of the polynomial, or try centering and scaling as described in HELP POLYFIT."
+        );
       }
       const result = new FloatXArray(ncols);
-      for (let i = 0; i < ncols; i++) {
-        result[i] = aug[ncols * ncols + i];
-      }
+      for (let i = 0; i < ncols; i++) result[i] = X[i];
       return RTV.tensor(result, [1, ncols]);
     })
   );
@@ -36328,6 +35756,65 @@ function switchMatch(control, caseVal) {
 }
 
 // src/numbl-core/runtime/runtimeDispatch.ts
+function dispatchPlotCall(rt, name, args) {
+  switch (name) {
+    case "plot":
+      return rt.plot_call(args.map((a) => ensureRuntimeValue(a)));
+    case "plot3":
+      return rt.plot3_call(args.map((a) => ensureRuntimeValue(a)));
+    case "surf":
+      return rt.surf_call(args.map((a) => ensureRuntimeValue(a)));
+    case "scatter":
+      return rt.scatter_call(args.map((a) => ensureRuntimeValue(a)));
+    case "imagesc":
+      return rt.imagesc_call(args.map((a) => ensureRuntimeValue(a)));
+    case "contour":
+      return rt.contour_call(
+        args.map((a) => ensureRuntimeValue(a)),
+        false
+      );
+    case "contourf":
+      return rt.contour_call(
+        args.map((a) => ensureRuntimeValue(a)),
+        true
+      );
+    case "mesh":
+    case "waterfall":
+      return rt.mesh_call(args.map((a) => ensureRuntimeValue(a)));
+    default:
+      return void 0;
+  }
+}
+function packResults(results, shape) {
+  const allScalar = results.every(
+    (r) => isRuntimeNumber(r) || isRuntimeLogical(r) || isRuntimeTensor(r) && r.data.length === 1
+  );
+  if (allScalar) {
+    const data = new FloatXArray(results.length);
+    const allLogical = results.every((r) => isRuntimeLogical(r));
+    for (let i = 0; i < results.length; i++) {
+      data[i] = toNumber(results[i]);
+    }
+    const result = RTV.tensor(data, [...shape]);
+    if (allLogical) result._isLogical = true;
+    return result;
+  }
+  return RTV.cell(results, [...shape]);
+}
+function coerceToTensor(v, fnName, which) {
+  if (isRuntimeNumber(v)) {
+    return RTV.tensor(new FloatXArray([v]), [1, 1]);
+  }
+  if (isRuntimeComplexNumber(v)) {
+    return RTV.tensor(new FloatXArray([v.re]), [1, 1], new FloatXArray([v.im]));
+  }
+  if (isRuntimeTensor(v)) {
+    return v;
+  }
+  throw new RuntimeError(
+    `${fnName}: unsupported type for ${which} input argument: ${kstr(v)}`
+  );
+}
 function getFuncHandle(name) {
   const handle = RTV.func(name, isBuiltin(name) ? "builtin" : "user");
   const nargin = getBuiltinNargin(name);
@@ -36426,39 +35913,8 @@ function dispatch(rt, name, nargout, args, targetClassName) {
   const callerLine = rt.$line;
   try {
     if (!targetClassName) {
-      if (name === "plot") {
-        return rt.plot_call(args.map((a) => ensureRuntimeValue(a)));
-      }
-      if (name === "plot3") {
-        return rt.plot3_call(args.map((a) => ensureRuntimeValue(a)));
-      }
-      if (name === "surf") {
-        return rt.surf_call(args.map((a) => ensureRuntimeValue(a)));
-      }
-      if (name === "scatter") {
-        return rt.scatter_call(args.map((a) => ensureRuntimeValue(a)));
-      }
-      if (name === "imagesc") {
-        return rt.imagesc_call(args.map((a) => ensureRuntimeValue(a)));
-      }
-      if (name === "contour") {
-        return rt.contour_call(
-          args.map((a) => ensureRuntimeValue(a)),
-          false
-        );
-      }
-      if (name === "contourf") {
-        return rt.contour_call(
-          args.map((a) => ensureRuntimeValue(a)),
-          true
-        );
-      }
-      if (name === "mesh") {
-        return rt.mesh_call(args.map((a) => ensureRuntimeValue(a)));
-      }
-      if (name === "waterfall") {
-        return rt.mesh_call(args.map((a) => ensureRuntimeValue(a)));
-      }
+      const plotResult = dispatchPlotCall(rt, name, args);
+      if (plotResult !== void 0) return plotResult;
     }
     if (rt.compileSpecialized) {
       const argTypes = args.map(
@@ -36497,77 +35953,15 @@ function dispatch(rt, name, nargout, args, targetClassName) {
   }
 }
 function callBuiltin(rt, name, nargout, args) {
-  if (name === "plot") {
-    return rt.plot_call(args.map((a) => ensureRuntimeValue(a)));
-  }
-  if (name === "plot3") {
-    return rt.plot3_call(args.map((a) => ensureRuntimeValue(a)));
-  }
-  if (name === "surf") {
-    return rt.surf_call(args.map((a) => ensureRuntimeValue(a)));
-  }
-  if (name === "scatter") {
-    return rt.scatter_call(args.map((a) => ensureRuntimeValue(a)));
-  }
-  if (name === "imagesc") {
-    return rt.imagesc_call(args.map((a) => ensureRuntimeValue(a)));
-  }
-  if (name === "contour") {
-    return rt.contour_call(
-      args.map((a) => ensureRuntimeValue(a)),
-      false
-    );
-  }
-  if (name === "contourf") {
-    return rt.contour_call(
-      args.map((a) => ensureRuntimeValue(a)),
-      true
-    );
-  }
-  if (name === "mesh") {
-    return rt.mesh_call(args.map((a) => ensureRuntimeValue(a)));
-  }
-  if (name === "waterfall") {
-    return rt.mesh_call(args.map((a) => ensureRuntimeValue(a)));
-  }
+  const plotResult = dispatchPlotCall(rt, name, args);
+  if (plotResult !== void 0) return plotResult;
   const builtin = rt.builtins[name];
   if (builtin) return builtin(nargout, args);
   throw new RuntimeError(`'${name}' is not a builtin function`);
 }
 function callBuiltinSync(rt, name, nargout, args) {
-  if (name === "plot") {
-    return rt.plot_call(args.map((a) => ensureRuntimeValue(a)));
-  }
-  if (name === "plot3") {
-    return rt.plot3_call(args.map((a) => ensureRuntimeValue(a)));
-  }
-  if (name === "surf") {
-    return rt.surf_call(args.map((a) => ensureRuntimeValue(a)));
-  }
-  if (name === "scatter") {
-    return rt.scatter_call(args.map((a) => ensureRuntimeValue(a)));
-  }
-  if (name === "imagesc") {
-    return rt.imagesc_call(args.map((a) => ensureRuntimeValue(a)));
-  }
-  if (name === "contour") {
-    return rt.contour_call(
-      args.map((a) => ensureRuntimeValue(a)),
-      false
-    );
-  }
-  if (name === "contourf") {
-    return rt.contour_call(
-      args.map((a) => ensureRuntimeValue(a)),
-      true
-    );
-  }
-  if (name === "mesh") {
-    return rt.mesh_call(args.map((a) => ensureRuntimeValue(a)));
-  }
-  if (name === "waterfall") {
-    return rt.mesh_call(args.map((a) => ensureRuntimeValue(a)));
-  }
+  const plotResult = dispatchPlotCall(rt, name, args);
+  if (plotResult !== void 0) return plotResult;
   const builtin = rt.builtins[name];
   if (builtin) return builtin(nargout, args);
   throw new RuntimeError(`'${name}' is not a builtin function`);
@@ -36752,28 +36146,12 @@ function arrayfunCellfunImpl(rt, name, nargout, args) {
         }
       }
       if (!uniformOutput) {
-        const outputs2 = allResults.map(
+        const outputs = allResults.map(
           (results2) => RTV.cell(results2, [...shape])
         );
-        return outputs2;
+        return outputs;
       }
-      const outputs = allResults.map((results2) => {
-        const allScalar2 = results2.every(
-          (r2) => isRuntimeNumber(r2) || isRuntimeLogical(r2) || isRuntimeTensor(r2) && r2.data.length === 1
-        );
-        if (allScalar2) {
-          const data = new FloatXArray(results2.length);
-          const allLogical = results2.every((r2) => isRuntimeLogical(r2));
-          for (let j = 0; j < results2.length; j++) {
-            data[j] = toNumber(results2[j]);
-          }
-          const result = RTV.tensor(data, [...shape]);
-          if (allLogical) result._isLogical = true;
-          return result;
-        }
-        return RTV.cell(results2, [...shape]);
-      });
-      return outputs;
+      return allResults.map((results2) => packResults(results2, shape));
     }
     const results = [];
     for (let i = 0; i < len; i++) {
@@ -36783,20 +36161,7 @@ function arrayfunCellfunImpl(rt, name, nargout, args) {
     if (!uniformOutput) {
       return RTV.cell(results, [...shape]);
     }
-    const allScalar = results.every(
-      (r2) => isRuntimeNumber(r2) || isRuntimeLogical(r2) || isRuntimeTensor(r2) && r2.data.length === 1
-    );
-    if (allScalar) {
-      const data = new FloatXArray(results.length);
-      const allLogical = results.every((r2) => isRuntimeLogical(r2));
-      for (let i = 0; i < results.length; i++) {
-        data[i] = toNumber(results[i]);
-      }
-      const result = RTV.tensor(data, [...shape]);
-      if (allLogical) result._isLogical = true;
-      return result;
-    }
-    return RTV.cell(results, [...shape]);
+    return packResults(results, shape);
   }
   const r = callFn(collectArgs(0));
   if (typeof r === "number") return r;
@@ -36906,38 +36271,8 @@ function bsxfunImpl(rt, _nargout, args) {
   }
   const rawA = ensureRuntimeValue(args[1]);
   const rawB = ensureRuntimeValue(args[2]);
-  let a;
-  let b;
-  if (isRuntimeNumber(rawA)) {
-    a = RTV.tensor(new FloatXArray([rawA]), [1, 1]);
-  } else if (isRuntimeComplexNumber(rawA)) {
-    a = RTV.tensor(
-      new FloatXArray([rawA.re]),
-      [1, 1],
-      new FloatXArray([rawA.im])
-    );
-  } else if (isRuntimeTensor(rawA)) {
-    a = rawA;
-  } else {
-    throw new RuntimeError(
-      `bsxfun: unsupported type for first input argument: ${kstr(rawA)}`
-    );
-  }
-  if (isRuntimeNumber(rawB)) {
-    b = RTV.tensor(new FloatXArray([rawB]), [1, 1]);
-  } else if (isRuntimeComplexNumber(rawB)) {
-    b = RTV.tensor(
-      new FloatXArray([rawB.re]),
-      [1, 1],
-      new FloatXArray([rawB.im])
-    );
-  } else if (isRuntimeTensor(rawB)) {
-    b = rawB;
-  } else {
-    throw new RuntimeError(
-      `bsxfun: unsupported type for second input argument: ${kstr(rawB)}`
-    );
-  }
+  const a = coerceToTensor(rawA, "bsxfun", "first");
+  const b = coerceToTensor(rawB, "bsxfun", "second");
   const outShape = getBroadcastShape(a.shape, b.shape);
   if (!outShape)
     throw new RuntimeError(
@@ -37028,6 +36363,20 @@ function extractSubsIndices(subs) {
   }
   return [subs];
 }
+function applySubsEntry(rt, entry, target, nargout, fnName) {
+  if (entry.type === ".") {
+    return rt.getMember(target, extractSubsType(entry.subs));
+  }
+  if (entry.type === "()") {
+    return rt.index(target, extractSubsIndices(entry.subs), nargout);
+  }
+  if (entry.type === "{}") {
+    return rt.indexCell(target, extractSubsIndices(entry.subs));
+  }
+  throw new RuntimeError(
+    `${fnName}: unsupported subscript type '${entry.type}'`
+  );
+}
 function subsrefBuiltin(rt, nargout, args) {
   if (args.length !== 2)
     throw new RuntimeError("subsref requires exactly 2 arguments");
@@ -37055,20 +36404,7 @@ function subsrefBuiltin(rt, nargout, args) {
   }
   let result = obj;
   for (const entry of elements) {
-    if (entry.type === ".") {
-      const fieldName = extractSubsType(entry.subs);
-      result = rt.getMember(result, fieldName);
-    } else if (entry.type === "()") {
-      const indices = extractSubsIndices(entry.subs);
-      result = rt.index(result, indices, nargout);
-    } else if (entry.type === "{}") {
-      const indices = extractSubsIndices(entry.subs);
-      result = rt.indexCell(result, indices);
-    } else {
-      throw new RuntimeError(
-        `subsref: unsupported subscript type '${entry.type}'`
-      );
-    }
+    result = applySubsEntry(rt, entry, result, nargout, "subsref");
   }
   return result;
 }
@@ -37103,21 +36439,7 @@ function subsasgnBuiltin(rt, _nargout, args) {
   const intermediates = [obj];
   let current = obj;
   for (let i = 0; i < elements.length - 1; i++) {
-    const entry = elements[i];
-    if (entry.type === ".") {
-      const fieldName = extractSubsType(entry.subs);
-      current = rt.getMember(current, fieldName);
-    } else if (entry.type === "()") {
-      const indices = extractSubsIndices(entry.subs);
-      current = rt.index(current, indices, 1);
-    } else if (entry.type === "{}") {
-      const indices = extractSubsIndices(entry.subs);
-      current = rt.indexCell(current, indices);
-    } else {
-      throw new RuntimeError(
-        `subsasgn: unsupported subscript type '${entry.type}'`
-      );
-    }
+    current = applySubsEntry(rt, elements[i], current, 1, "subsasgn");
     intermediates.push(current);
   }
   const last = elements[elements.length - 1];
@@ -42418,42 +41740,37 @@ function genFuncCall(cg, kind) {
       }
     }
   }
-  if (kind.name === "figure")
-    return `$rt.plot_instr({type: "set_figure_handle", handle: ${args[0] ?? "1"}})`;
-  if (kind.name === "hold")
-    return `$rt.plot_instr({type: "set_hold", value: ${args[0]}})`;
-  if (kind.name === "ishold") return `$rt.ishold()`;
-  if (kind.name === "clf") return `$rt.plot_instr({type: "clf"})`;
-  if (kind.name === "title")
-    return `$rt.plot_instr({type: "set_title", text: ${args[0] ?? '""'}})`;
-  if (kind.name === "xlabel")
-    return `$rt.plot_instr({type: "set_xlabel", text: ${args[0] ?? '""'}})`;
-  if (kind.name === "ylabel")
-    return `$rt.plot_instr({type: "set_ylabel", text: ${args[0] ?? '""'}})`;
-  if (kind.name === "shading")
-    return `$rt.plot_instr({type: "set_shading", shading: ${args[0] ?? '"faceted"'}})`;
-  if (kind.name === "close") {
-    if (args.length > 0) {
-      return `$rt.plot_instr({type: "close_all"})`;
-    }
-    return `$rt.plot_instr({type: "close"})`;
-  }
-  if (kind.name === "subplot")
-    return `$rt.plot_instr({type: "set_subplot", rows: ${args[0] ?? "1"}, cols: ${args[1] ?? "1"}, index: ${args[2] ?? "1"}})`;
-  if (kind.name === "legend") return `$rt.legend_call([${args.join(", ")}])`;
-  if (kind.name === "sgtitle")
-    return `$rt.plot_instr({type: "set_sgtitle", text: ${args[0] ?? '""'}})`;
-  if (kind.name === "grid")
-    return `$rt.plot_instr({type: "set_grid", value: ${args[0] ?? "true"}})`;
-  if (kind.name === "zlabel")
-    return `$rt.plot_instr({type: "set_zlabel", text: ${args[0] ?? '""'}})`;
-  if (kind.name === "colorbar")
-    return `$rt.plot_instr({type: "set_colorbar", value: ${args[0] ?? '"on"'}})`;
-  if (kind.name === "colormap")
-    return `$rt.plot_instr({type: "set_colormap", name: ${args[0] ?? '"parula"'}})`;
-  if (kind.name === "axis")
-    return `$rt.plot_instr({type: "set_axis", value: ${args[0] ?? '"auto"'}})`;
-  if (kind.name === "view") return `$rt.view_call([${args.join(", ")}])`;
+  {
+    const plotInstrTable = {
+      figure: ["set_figure_handle", "handle", "1"],
+      hold: ["set_hold", "value", "true"],
+      clf: ["clf", "", ""],
+      title: ["set_title", "text", '""'],
+      xlabel: ["set_xlabel", "text", '""'],
+      ylabel: ["set_ylabel", "text", '""'],
+      zlabel: ["set_zlabel", "text", '""'],
+      shading: ["set_shading", "shading", '"faceted"'],
+      sgtitle: ["set_sgtitle", "text", '""'],
+      grid: ["set_grid", "value", "true"],
+      colorbar: ["set_colorbar", "value", '"on"'],
+      colormap: ["set_colormap", "name", '"parula"'],
+      axis: ["set_axis", "value", '"auto"']
+    };
+    const entry = Object.hasOwn(plotInstrTable, kind.name) ? plotInstrTable[kind.name] : void 0;
+    if (entry) {
+      const [instrType, paramName, defaultVal] = entry;
+      if (!paramName) return `$rt.plot_instr({type: "${instrType}"})`;
+      return `$rt.plot_instr({type: "${instrType}", ${paramName}: ${args[0] ?? defaultVal}})`;
+    }
+    if (kind.name === "ishold") return `$rt.ishold()`;
+    if (kind.name === "close") {
+      return args.length > 0 ? `$rt.plot_instr({type: "close_all"})` : `$rt.plot_instr({type: "close"})`;
+    }
+    if (kind.name === "subplot")
+      return `$rt.plot_instr({type: "set_subplot", rows: ${args[0] ?? "1"}, cols: ${args[1] ?? "1"}, index: ${args[2] ?? "1"}})`;
+    if (kind.name === "legend") return `$rt.legend_call([${args.join(", ")}])`;
+    if (kind.name === "view") return `$rt.view_call([${args.join(", ")}])`;
+  }
   if (cg.nestedFunctionNames.has(kind.name)) {
     return buildSpecializedCall(
       cg,