numbl 0.0.15 → 0.0.17

package/dist-cli/cli.js

@@ -158,17 +158,17 @@ async function fetchPackageIndex(backend, indexUrl = DEFAULT_INDEX_URL) {
   return backend.fetchJson(indexUrl);
 }
 function findPackageEntry(index2, packageName, arch) {
-  const exact = index2.packages.find(
-    (p) => p.name === packageName && p.architecture === arch
-  );
-  if (exact) return exact;
-  return index2.packages.find(
-    (p) => p.name === packageName && p.architecture === "any"
-  );
+  for (const candidate of ["numbl_" + arch, "numbl_wasm", "any"]) {
+    const entry = index2.packages.find(
+      (p) => p.name === packageName && p.architecture === candidate
+    );
+    if (entry) return entry;
+  }
+  return void 0;
 }
 function listAvailablePackages(index2, arch) {
   return index2.packages.filter(
-    (p) => p.architecture === arch || p.architecture === "any"
+    (p) => p.architecture === "numbl_" + arch || p.architecture === "numbl_wasm" || p.architecture === "any"
   );
 }
 
@@ -181,7 +181,9 @@ function resolveDependencies(index2, packageName, arch) {
     visited.add(name);
     const entry = findPackageEntry(index2, name, arch);
     if (!entry) {
-      throw new Error(`Package "${name}" not found for architecture "${arch}"`);
+      throw new Error(
+        `Package "${name}" not found for architecture "${arch}" (tried ${arch}, wasm, all)`
+      );
     }
     for (const dep of entry.dependencies) {
       visit(dep);
@@ -210,13 +212,13 @@ function computeRequiredPackages(directlyInstalled, index2, arch) {
 
 // src/mip/mip-manager.ts
 function packagesDir(mipDir) {
-  return `${mipDir}/packages`;
+  return `${mipDir}/numbl_packages`;
 }
 function packageDir(mipDir, name) {
-  return `${mipDir}/packages/${name}`;
+  return `${mipDir}/numbl_packages/${name}`;
 }
 function directlyInstalledPath(mipDir) {
-  return `${mipDir}/packages/directly_installed.txt`;
+  return `${mipDir}/numbl_packages/directly_installed.txt`;
 }
 var MipManager = class {
   constructor(backend) {
@@ -17430,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");
@@ -17445,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", [
@@ -17600,6 +17616,22 @@ function complexComparisonOp(a, b, op) {
     `Matrix dimensions must agree for comparison: [${at.shape.join(",")}] vs [${bt.shape.join(",")}]`
   );
 }
+function signedInf(x) {
+  return x > 0 ? Infinity : x < 0 ? -Infinity : 0;
+}
+function complexDivide(aRe, aIm, bRe, bIm) {
+  const denom = bRe * bRe + bIm * bIm;
+  if (denom === 0) {
+    if (aRe === 0 && aIm === 0) {
+      return { re: NaN, im: 0 };
+    }
+    return { re: signedInf(aRe), im: signedInf(aIm) };
+  }
+  return {
+    re: (aRe * bRe + aIm * bIm) / denom,
+    im: (aIm * bRe - aRe * bIm) / denom
+  };
+}
 function complexBinaryOp(a, b, op) {
   const ac = toComplexParts(a);
   const bc = toComplexParts(b);
@@ -17702,25 +17734,13 @@ function mDiv(a, b) {
     return mConjugateTranspose(result);
   }
   if (isComplexOrMixed(a, b)) {
-    return complexBinaryOp(a, b, (aRe, aIm, bRe, bIm) => {
-      const denom = bRe * bRe + bIm * bIm;
-      return {
-        re: (aRe * bRe + aIm * bIm) / denom,
-        im: (aIm * bRe - aRe * bIm) / denom
-      };
-    });
+    return complexBinaryOp(a, b, complexDivide);
   }
   return binaryOp(a, b, (x, y) => x / y);
 }
 function mElemDiv(a, b) {
   if (isComplexOrMixed(a, b)) {
-    return complexBinaryOp(a, b, (aRe, aIm, bRe, bIm) => {
-      const denom = bRe * bRe + bIm * bIm;
-      return {
-        re: (aRe * bRe + aIm * bIm) / denom,
-        im: (aIm * bRe - aRe * bIm) / denom
-      };
-    });
+    return complexBinaryOp(a, b, complexDivide);
   }
   return binaryOp(a, b, (x, y) => x / y);
 }
@@ -20603,7 +20623,8 @@ var COMMAND_VERBS = [
         "square",
         "vis3d"
       ],
-      optional: false
+      optional: false,
+      multiKeyword: true
     }
   },
   { name: "clear", argKind: { type: "Any" } },
@@ -20965,19 +20986,41 @@ var ExpressionParser = class extends ParserBase {
     }
   }
   parsePow() {
-    const node = this.parsePostfix();
-    const tok = this.peekToken();
-    let op;
-    if (tok === 36 /* Caret */) {
-      op = "Pow" /* Pow */;
-    } else if (tok === 58 /* DotCaret */) {
-      op = "ElemPow" /* ElemPow */;
-    } else {
-      return node;
+    let node = this.parsePostfix();
+    while (true) {
+      const tok = this.peekToken();
+      let op;
+      if (tok === 36 /* Caret */) {
+        op = "Pow" /* Pow */;
+      } else if (tok === 58 /* DotCaret */) {
+        op = "ElemPow" /* ElemPow */;
+      } else {
+        return node;
+      }
+      this.pos++;
+      const rhs = this.parsePowRHS();
+      node = this.makeBinary(node, op, rhs);
     }
-    this.pos++;
-    const rhs = this.parseUnary();
-    return this.makeBinary(node, op, rhs);
+  }
+  /** Parse the right-hand side of a ^ or .^ operator: unary prefixes then postfix. */
+  parsePowRHS() {
+    if (this.peekToken() === 31 /* Plus */) {
+      const start = this.tokens[this.pos].position;
+      this.pos++;
+      const expr = this.parsePowRHS();
+      return this.makeUnary("Plus" /* Plus */, expr, start);
+    } else if (this.peekToken() === 32 /* Minus */) {
+      const start = this.tokens[this.pos].position;
+      this.pos++;
+      const expr = this.parsePowRHS();
+      return this.makeUnary("Minus" /* Minus */, expr, start);
+    } else if (this.peekToken() === 39 /* Tilde */) {
+      const start = this.tokens[this.pos].position;
+      this.pos++;
+      const expr = this.parsePowRHS();
+      return this.makeUnary("Not" /* Not */, expr, start);
+    }
+    return this.parsePostfix();
   }
   parsePostfixWithBase(expr) {
     while (true) {
@@ -21560,25 +21603,32 @@ var CommandParser = class extends ExpressionParser {
         }
         return args;
       }
-      if (args.length > 1) {
+      if (args.length > 1 && !command.argKind.multiKeyword) {
         throw this.error(
           `'${command.name}' command syntax accepts only one argument`
         );
       }
-      const keyword = extractKeyword(args[0]);
-      if (!keyword) {
-        throw this.error(
-          `'${command.name}' command syntax expects a keyword argument`
-        );
+      const keywords = [];
+      for (const arg of args) {
+        const keyword = extractKeyword(arg);
+        if (!keyword) {
+          throw this.error(
+            `'${command.name}' command syntax expects a keyword argument`
+          );
+        }
+        if (allowed !== void 0 && !allowed.some((a) => a.toLowerCase() === keyword.toLowerCase())) {
+          throw this.error(
+            `'${command.name}' command syntax does not support '${keyword}'`
+          );
+        }
+        keywords.push(keyword);
       }
-      if (allowed === void 0 || allowed.some((a) => a.toLowerCase() === keyword.toLowerCase())) {
-        const span = args[0].span;
-        return [{ type: "String", value: `"${keyword}"`, span }];
-      } else {
-        throw this.error(
-          `'${command.name}' command syntax does not support '${keyword}'`
-        );
+      if (keywords.length === 1) {
+        const span2 = args[0].span;
+        return [{ type: "String", value: `"${keywords[0]}"`, span: span2 }];
       }
+      const span = args[0].span;
+      return [{ type: "String", value: `"${keywords.join(" ")}"`, span }];
     }
     return args;
   }
@@ -24487,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) => {
@@ -24879,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) {
@@ -25342,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) => {
@@ -25421,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
@@ -25520,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;
@@ -25540,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(
@@ -27173,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");
@@ -27205,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);
 }
@@ -27258,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);
   }
@@ -27330,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;
@@ -27480,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) => ({
@@ -27752,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,
@@ -27793,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)];
@@ -27878,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(
@@ -28290,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;
@@ -28673,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;
@@ -30640,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", [
@@ -30866,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);
@@ -31104,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));
       }
     }
   ]);
@@ -31199,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", [
@@ -31822,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";
@@ -31929,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
@@ -32020,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");
         }
@@ -32414,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);
@@ -32439,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() {
@@ -32655,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;
@@ -32820,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;
@@ -33002,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);
 }
@@ -33779,42 +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(
-    "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) => {
@@ -33864,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) => {
@@ -33898,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],
@@ -33968,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(
@@ -33991,279 +33726,158 @@ 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",
+    "legend",
+    "sgtitle",
+    "zlabel",
+    "colorbar",
+    "colormap",
+    "axis",
+    "view",
+    "imagesc",
+    "contour",
+    "contourf",
+    "mesh",
+    "waterfall",
+    "scatter",
     "drawnow",
-    builtinSingle(() => RTV.num(0))
+    "pause"
+  ];
+  const placeholder = builtinSingle(() => RTV.num(0));
+  for (const name of placeholderNames) {
+    register(name, placeholder);
+  }
+  register(
+    "ishold",
+    builtinSingle(() => RTV.logical(false), { outputType: IType.Logical })
   );
+  const colormapNames = [
+    "parula",
+    "jet",
+    "hsv",
+    "hot",
+    "cool",
+    "spring",
+    "summer",
+    "autumn",
+    "winter",
+    "gray",
+    "bone",
+    "copper",
+    "pink"
+  ];
+  for (const cm of colormapNames) {
+    register(
+      cm,
+      builtinSingle(() => RTV.char(cm))
+    );
+  }
   register(
-    "pause",
-    builtinSingle(() => RTV.num(0))
+    "peaks",
+    builtinSingle((args) => {
+      const n = args.length > 0 ? isRuntimeNumber(args[0]) ? args[0] : toNumber(args[0]) : 49;
+      const data = new FloatXArray(n * n);
+      for (let j = 0; j < n; j++) {
+        const y = -3 + 6 * j / (n - 1);
+        for (let i = 0; i < n; i++) {
+          const x = -3 + 6 * i / (n - 1);
+          const x2 = x * x;
+          const y2 = y * y;
+          const z = 3 * Math.pow(1 - x, 2) * Math.exp(-x2 - Math.pow(y + 1, 2)) - 10 * (x / 5 - x * x2 - Math.pow(y, 5)) * Math.exp(-x2 - y2) - 1 / 3 * Math.exp(-Math.pow(x + 1, 2) - y2);
+          data[j * n + i] = z;
+        }
+      }
+      return RTV.tensor(data, [n, n]);
+    })
   );
 }
 
@@ -34402,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",
@@ -34413,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",
@@ -34428,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", "jet", "hot"];
-function registerDummyArrayFunctions() {
-  const fn = builtinSingle(() => RTV.tensor([], [0, 0]), {
-    outputType: IType.tensor()
-  });
-  for (const name of returnEmptyArrayFunctions) {
-    register(name, fn);
-  }
-}
+var returnEmptyArrayFunctions = ["who", "xlim", "ylim"];
 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
@@ -34510,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();
@@ -34652,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;
@@ -34659,65 +34258,31 @@ function registerNumericalFunctions() {
           V[j * m + i] = Math.pow(xArr[i], power);
         }
       }
-      const VTV = new FloatXArray(ncols * ncols);
-      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);
+      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++) {
-        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]);
     })
   );
@@ -36191,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);
@@ -36289,15 +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)));
-      }
+      const plotResult = dispatchPlotCall(rt, name, args);
+      if (plotResult !== void 0) return plotResult;
     }
     if (rt.compileSpecialized) {
       const argTypes = args.map(
@@ -36336,29 +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)));
-  }
+  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)));
-  }
+  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`);
@@ -36543,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++) {
@@ -36574,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;
@@ -36697,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(
@@ -36819,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");
@@ -36846,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;
 }
@@ -36894,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];
@@ -38238,6 +37769,88 @@ function getStringValueIfString(v) {
   if (isRuntimeChar(v)) return v.value;
   return void 0;
 }
+function parseScatterArgs(args) {
+  if (args.length < 2) throw new Error("scatter requires at least 2 arguments");
+  const xData = toNumberArray(args[0]);
+  const yData = toNumberArray(args[1]);
+  const trace = {
+    x: xData,
+    y: yData,
+    marker: "o",
+    lineStyle: "none"
+  };
+  let pos = 2;
+  let filled = false;
+  if (pos < args.length && isNumericArg(args[pos])) {
+    const sz = args[pos];
+    if (isRuntimeNumber(sz)) {
+      trace.markerSize = Math.sqrt(sz) * 0.5;
+    } else if (isRuntimeTensor(sz)) {
+      const sArr = toNumberArray(sz);
+      if (sArr.length === 1 || new Set(sArr).size === 1) {
+        trace.markerSize = Math.sqrt(sArr[0]) * 0.5;
+      }
+    }
+    pos++;
+  }
+  if (pos < args.length && !isNameValueKey(args[pos])) {
+    if (isStringArg(args[pos])) {
+      const s = getStringValue(args[pos]);
+      if (s === "filled") {
+        filled = true;
+        pos++;
+      } else {
+        const c = resolveColor(s);
+        if (c) {
+          trace.color = c;
+          pos++;
+        } else {
+          const spec = parseLineSpec(s);
+          if (spec?.marker) {
+            trace.marker = spec.marker;
+            if (spec.color) trace.color = COLOR_SHORT[spec.color];
+            pos++;
+          }
+        }
+      }
+    } else if (isNumericArg(args[pos])) {
+      const c = resolveColor(args[pos]);
+      if (c) {
+        trace.color = c;
+        pos++;
+      }
+    }
+  }
+  while (pos < args.length && isStringArg(args[pos]) && !isNameValueKey(args[pos])) {
+    const s = getStringValue(args[pos]);
+    if (s === "filled") {
+      filled = true;
+      pos++;
+    } else {
+      const spec = parseLineSpec(s);
+      if (spec?.marker) {
+        trace.marker = spec.marker;
+        if (spec.color) trace.color = COLOR_SHORT[spec.color];
+        pos++;
+      } else {
+        break;
+      }
+    }
+  }
+  if (filled) {
+    trace.markerFaceColor = trace.color || [0, 0, 1];
+  }
+  while (pos < args.length) {
+    const key = isNameValueKey(args[pos]);
+    if (!key) break;
+    pos++;
+    if (pos >= args.length) break;
+    const value = args[pos];
+    pos++;
+    applyNameValue([trace], key, value);
+  }
+  return [trace];
+}
 function applyNameValue(traces, key, value) {
   switch (key) {
     case "color": {
@@ -38282,6 +37895,95 @@ function applyNameValue(traces, key, value) {
     }
   }
 }
+function parseImagescArgs(args) {
+  if (args.length === 1) {
+    const info = getMatrixInfo(args[0]);
+    return {
+      x: [1, info.cols],
+      y: [1, info.rows],
+      z: info.data,
+      rows: info.rows,
+      cols: info.cols
+    };
+  }
+  if (args.length >= 3) {
+    const xArr = toNumberArray(args[0]);
+    const yArr = toNumberArray(args[1]);
+    const info = getMatrixInfo(args[2]);
+    return {
+      x: [xArr[0], xArr[xArr.length - 1]],
+      y: [yArr[0], yArr[yArr.length - 1]],
+      z: info.data,
+      rows: info.rows,
+      cols: info.cols
+    };
+  }
+  throw new Error("imagesc requires 1 or 3+ arguments");
+}
+function parseContourArgs(args, filled) {
+  let pos = 0;
+  let numericCount = 0;
+  for (let i = pos; i < args.length; i++) {
+    if (isNumericArg(args[i])) numericCount++;
+    else break;
+  }
+  let xData;
+  let yData;
+  let zData;
+  let rows;
+  let cols;
+  let nLevels = 10;
+  if (numericCount === 1) {
+    const info = getMatrixInfo(args[pos++]);
+    rows = info.rows;
+    cols = info.cols;
+    zData = info.data;
+    const gen = generateMeshgrid(rows, cols);
+    xData = gen.x;
+    yData = gen.y;
+  } else if (numericCount === 2) {
+    const info = getMatrixInfo(args[pos++]);
+    rows = info.rows;
+    cols = info.cols;
+    zData = info.data;
+    nLevels = typeof args[pos] === "number" ? args[pos] : toNumber(args[pos]);
+    pos++;
+    const gen = generateMeshgrid(rows, cols);
+    xData = gen.x;
+    yData = gen.y;
+  } else if (numericCount === 3) {
+    const x = args[pos++];
+    const y = args[pos++];
+    const zInfo = getMatrixInfo(args[pos++]);
+    rows = zInfo.rows;
+    cols = zInfo.cols;
+    zData = zInfo.data;
+    const expanded = expandXY(x, y, rows, cols);
+    xData = expanded.x;
+    yData = expanded.y;
+  } else if (numericCount >= 4) {
+    const x = args[pos++];
+    const y = args[pos++];
+    const zInfo = getMatrixInfo(args[pos++]);
+    rows = zInfo.rows;
+    cols = zInfo.cols;
+    zData = zInfo.data;
+    nLevels = typeof args[pos] === "number" ? args[pos] : toNumber(args[pos]);
+    pos++;
+    const expanded = expandXY(x, y, rows, cols);
+    xData = expanded.x;
+    yData = expanded.y;
+  } else {
+    throw new Error("contour requires at least 1 argument");
+  }
+  return { x: xData, y: yData, z: zData, rows, cols, nLevels, filled };
+}
+function parseMeshArgs(args) {
+  const trace = parseSurfArgs(args);
+  if (!trace.edgeColor) trace.edgeColor = "flat";
+  if (!trace.faceColor) trace.faceColor = "none";
+  return trace;
+}
 
 // src/numbl-core/runtime/syncChannel.ts
 var syncSleepWarned = false;
@@ -38307,10 +38009,17 @@ function syncSleep(ms) {
 // src/numbl-core/runtime/runtimePlot.ts
 function plotInstr(plotInstructions, instr) {
   if (instr.type === "set_figure_handle") {
-    plotInstructions.push({
-      type: "set_figure_handle",
-      handle: typeof instr.handle === "number" ? instr.handle : toNumber(ensureRuntimeValue(instr.handle))
-    });
+    let handle;
+    if (typeof instr.handle === "number") {
+      handle = instr.handle;
+    } else {
+      try {
+        handle = toNumber(ensureRuntimeValue(instr.handle));
+      } catch {
+        handle = 1;
+      }
+    }
+    plotInstructions.push({ type: "set_figure_handle", handle });
   } else if (instr.type === "plot") {
     plotInstructions.push({
       type: "plot",
@@ -38349,7 +38058,63 @@ function plotInstr(plotInstructions, instr) {
     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, "")
+    });
+  }
+}
+function viewCall(plotInstructions, args) {
+  let az;
+  let el;
+  if (args.length === 1) {
+    const n = typeof args[0] === "number" ? args[0] : toNumber(args[0]);
+    if (n === 2) {
+      az = 0;
+      el = 90;
+    } else {
+      az = -37.5;
+      el = 30;
+    }
+  } else if (args.length >= 2) {
+    az = typeof args[0] === "number" ? args[0] : toNumber(args[0]);
+    el = typeof args[1] === "number" ? args[1] : toNumber(args[1]);
+  } else {
+    return;
   }
+  plotInstructions.push({ type: "set_view", az, el });
 }
 function plotCall(plotInstructions, args) {
   const traces = parsePlotArgs(args);
@@ -38367,6 +38132,38 @@ function surfCall(plotInstructions, args) {
   const trace = parseSurfArgs(args);
   plotInstructions.push({ type: "surf", trace });
 }
+function imagescCall(plotInstructions, args) {
+  const trace = parseImagescArgs(args);
+  plotInstructions.push({ type: "imagesc", trace });
+}
+function contourCall(plotInstructions, args, filled) {
+  const trace = parseContourArgs(args, filled);
+  plotInstructions.push({ type: "contour", trace });
+}
+function meshCall(plotInstructions, args) {
+  const trace = parseMeshArgs(args);
+  plotInstructions.push({ type: "mesh", trace });
+}
+function scatterCall(plotInstructions, args) {
+  const traces = parseScatterArgs(args);
+  if (traces.length > 0) {
+    plotInstructions.push({ type: "plot", traces });
+  }
+}
+function legendCall(plotInstructions, args) {
+  const labels = [];
+  for (let i = 0; i < args.length; i++) {
+    const s = toString(args[i]);
+    if (s === "Location" || s === "Orientation" || s === "FontSize" || s === "Box" || s === "Color" || s === "EdgeColor" || s === "TextColor") {
+      i++;
+      continue;
+    }
+    labels.push(s);
+  }
+  if (labels.length > 0) {
+    plotInstructions.push({ type: "set_legend", labels });
+  }
+}
 function drawnow(plotInstructions, options) {
   if (options.onDrawnow && plotInstructions.length > 0) {
     options.onDrawnow([...plotInstructions]);
@@ -38475,6 +38272,61 @@ var Runtime = class _Runtime {
     this.builtins["surf"] = (_nargout, args) => {
       this.surf_call(args.map((a) => ensureRuntimeValue(a)));
     };
+    this.builtins["scatter"] = (_nargout, args) => {
+      this.scatter_call(args.map((a) => ensureRuntimeValue(a)));
+    };
+    this.builtins["imagesc"] = (_nargout, args) => {
+      this.imagesc_call(args.map((a) => ensureRuntimeValue(a)));
+    };
+    this.builtins["contour"] = (_nargout, args) => {
+      this.contour_call(
+        args.map((a) => ensureRuntimeValue(a)),
+        false
+      );
+    };
+    this.builtins["contourf"] = (_nargout, args) => {
+      this.contour_call(
+        args.map((a) => ensureRuntimeValue(a)),
+        true
+      );
+    };
+    this.builtins["mesh"] = (_nargout, args) => {
+      this.mesh_call(args.map((a) => ensureRuntimeValue(a)));
+    };
+    this.builtins["waterfall"] = (_nargout, args) => {
+      this.mesh_call(args.map((a) => ensureRuntimeValue(a)));
+    };
+    this.builtins["colormap"] = (_nargout, args) => {
+      if (args.length > 0) {
+        const rv = ensureRuntimeValue(args[0]);
+        const name = toString(rv).replace(/^"|"$/g, "");
+        plotInstr(this.plotInstructions, { type: "set_colormap", name });
+      }
+    };
+    this.builtins["view"] = (_nargout, args) => {
+      this.view_call(args.map((a) => ensureRuntimeValue(a)));
+    };
+    this.builtins["zlabel"] = (_nargout, args) => {
+      if (args.length > 0) {
+        plotInstr(this.plotInstructions, {
+          type: "set_zlabel",
+          text: args[0]
+        });
+      }
+    };
+    this.builtins["colorbar"] = (_nargout, args) => {
+      const val = args.length > 0 ? toString(ensureRuntimeValue(args[0])) : "on";
+      plotInstr(this.plotInstructions, { type: "set_colorbar", value: val });
+    };
+    this.builtins["axis"] = (_nargout, args) => {
+      if (args.length > 0) {
+        const val = toString(ensureRuntimeValue(args[0])).replace(
+          /^"|"$/g,
+          ""
+        );
+        plotInstr(this.plotInstructions, { type: "set_axis", value: val });
+      }
+    };
   }
   profileEnter(key) {
     if (!this.profilingEnabled) return;
@@ -39065,6 +38917,24 @@ var Runtime = class _Runtime {
   surf_call(args) {
     surfCall(this.plotInstructions, args);
   }
+  scatter_call(args) {
+    scatterCall(this.plotInstructions, args);
+  }
+  imagesc_call(args) {
+    imagescCall(this.plotInstructions, args);
+  }
+  contour_call(args, filled) {
+    contourCall(this.plotInstructions, args, filled);
+  }
+  mesh_call(args) {
+    meshCall(this.plotInstructions, args);
+  }
+  view_call(args) {
+    viewCall(this.plotInstructions, args);
+  }
+  legend_call(args) {
+    legendCall(this.plotInstructions, args);
+  }
   // ── Drawnow / Pause ─────────────────────────────────────────────────
   drawnow() {
     return drawnow(this.plotInstructions, this.options);
@@ -40637,13 +40507,6 @@ var LoweringContext = class _LoweringContext {
     }
     for (const [className, group] of classFolderGroups) {
       if (!group.classDefFile) {
-        for (const mf of group.methodFiles) {
-          const baseName = mf.name.split("/").pop().replace(/\.m$/, "");
-          this.registry.filesByFuncName.set(baseName, {
-            fileName: mf.name,
-            source: mf.source
-          });
-        }
         continue;
       }
       this.registerWorkspaceClass(className, group.classDefFile);
@@ -40778,7 +40641,9 @@ var LoweringContext = class _LoweringContext {
       file.name,
       file.source
     );
-    this.registry.classesByName.set(qualifiedName, info);
+    if (!this.registry.classesByName.has(qualifiedName)) {
+      this.registry.classesByName.set(qualifiedName, info);
+    }
   }
   /**
    * Register a classdef statement found in the local (main) file.
@@ -41875,25 +41740,36 @@ 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"})`;
+  {
+    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"})`;
     }
-    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 === "view") return `$rt.view_call([${args.join(", ")}])`;
   }
   if (cg.nestedFunctionNames.has(kind.name)) {
     return buildSpecializedCall(
@@ -43626,9 +43502,28 @@ function buildWasmMap(wasmFiles) {
   }
   return map;
 }
-function parseWasmDirective(source) {
-  const match = source.match(/^\s*\/\/\s*wasm:\s*(\S+)/);
-  return match ? match[1] : null;
+function parseDirectives(source) {
+  const directives = {};
+  const lines = source.split("\n");
+  for (const line of lines) {
+    const match = line.match(/^\s*\/\/\s*(\w+):\s*(\S+)/);
+    if (!match) break;
+    const key = match[1];
+    const value = match[2];
+    if (key === "wasm") directives.wasm = value;
+    else if (key === "native") directives.native = value;
+  }
+  return directives;
+}
+function nativeLibFilename(baseName) {
+  switch (process.platform) {
+    case "win32":
+      return `${baseName}.dll`;
+    case "darwin":
+      return `${baseName}.dylib`;
+    default:
+      return `${baseName}.so`;
+  }
 }
 function instantiateWasm(wasmData) {
   const wasmModule = new WebAssembly.Module(wasmData);
@@ -43659,7 +43554,7 @@ function instantiateWasm(wasmData) {
   }
   return new WebAssembly.Instance(wasmModule, importObject);
 }
-function loadJsUserFunctions(jsFiles, wasmFiles) {
+function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge2) {
   const result = /* @__PURE__ */ new Map();
   const wasmMap = wasmFiles ? buildWasmMap(wasmFiles) : /* @__PURE__ */ new Map();
   const wasmInstanceCache = /* @__PURE__ */ new Map();
@@ -43667,7 +43562,7 @@ function loadJsUserFunctions(jsFiles, wasmFiles) {
     const cached = wasmInstanceCache.get(name);
     if (cached) return cached;
     const data = wasmMap.get(name);
-    if (!data) return null;
+    if (!data) return void 0;
     const instance = instantiateWasm(data);
     wasmInstanceCache.set(name, instance);
     return instance;
@@ -43685,8 +43580,18 @@ function loadJsUserFunctions(jsFiles, wasmFiles) {
           apply: branch.apply
         });
       };
-      const wasmName = parseWasmDirective(file.source) ?? funcName;
-      const wasmInstance = getWasmInstance(wasmName);
+      const directives = parseDirectives(file.source);
+      const wasmInstance = directives.wasm ? getWasmInstance(directives.wasm) : void 0;
+      let nativeLib;
+      if (directives.native && nativeBridge2) {
+        const libFile = nativeLibFilename(directives.native);
+        const dir = file.name.substring(0, file.name.lastIndexOf("/") + 1);
+        const libPath = dir + libFile;
+        try {
+          nativeLib = nativeBridge2.load(libPath);
+        } catch {
+        }
+      }
       const factory = new Function(
         "RTV",
         "RuntimeError",
@@ -43694,14 +43599,44 @@ function loadJsUserFunctions(jsFiles, wasmFiles) {
         "IType",
         "register",
         "wasm",
+        "native",
         file.source
       );
-      factory(RTV, RuntimeError, FloatXArray, IType, registerFn, wasmInstance);
+      factory(
+        RTV,
+        RuntimeError,
+        FloatXArray,
+        IType,
+        registerFn,
+        wasmInstance,
+        nativeLib
+      );
       if (branches.length === 0) {
         throw new Error(
           `JS user function '${funcName}' (${file.name}) must call register() at least once`
         );
       }
+      if (directives.native || directives.wasm) {
+        const parts = [];
+        if (directives.native) {
+          parts.push(nativeLib ? "native: loaded" : "native: not found");
+        }
+        if (directives.wasm) {
+          parts.push(wasmInstance ? "wasm: loaded" : "wasm: not found");
+        }
+        const statusMsg = `${funcName}: ${parts.join(", ")}`;
+        let logged = false;
+        for (const branch of branches) {
+          const origApply = branch.apply;
+          branch.apply = (...applyArgs) => {
+            if (!logged) {
+              logged = true;
+              console.log(statusMsg);
+            }
+            return origApply(...applyArgs);
+          };
+        }
+      }
       result.set(funcName, branches);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
@@ -43817,7 +43752,8 @@ function generateMainScriptCode(source, mainFileName = "script.m", workspaceFile
   _t0 = performance.now();
   const jsUserFunctions = loadJsUserFunctions(
     jsWorkspaceFiles,
-    wasmWorkspaceFiles
+    wasmWorkspaceFiles,
+    opts?.nativeBridge
   );
   const _loadJsUserFunctionsMs = performance.now() - _t0;
   _t0 = performance.now();
@@ -43959,7 +43895,7 @@ function generateMainScriptCode(source, mainFileName = "script.m", workspaceFile
 }
 
 // src/numbl-core/executeCode.ts
-function executeCode(source, options = {}, workspaceFiles, mainFileName = "script.m", searchPaths) {
+function executeCode(source, options = {}, workspaceFiles, mainFileName = "script.m", searchPaths, nativeBridge2) {
   const initialVariableNames = options.initialVariableValues ? Object.keys(options.initialVariableValues) : void 0;
   const codegenStart = performance.now();
   const {
@@ -43983,7 +43919,7 @@ function executeCode(source, options = {}, workspaceFiles, mainFileName = "scrip
     workspaceFiles,
     initialVariableNames,
     searchPaths,
-    { noLineTracking: options.noLineTracking }
+    { noLineTracking: options.noLineTracking, nativeBridge: nativeBridge2 }
   );
   const codegenTimeMs = performance.now() - codegenStart;
   if (options.log) {
@@ -44126,7 +44062,7 @@ function processMipLoad(packageName, _visited) {
   if (visited.has(packageName)) return [];
   visited.add(packageName);
   const mipDir = process.env.MIP_DIR || join3(homedir2(), ".mip");
-  const pkgDir = join3(mipDir, "packages", packageName);
+  const pkgDir = join3(mipDir, "numbl_packages", packageName);
   const loadScript = join3(pkgDir, "load_package.m");
   if (!existsSync3(loadScript)) {
     throw new Error(
@@ -44140,7 +44076,7 @@ function processMipLoad(packageName, _visited) {
       const mipJson = JSON.parse(readFileSync3(mipJsonPath, "utf-8"));
       const deps = mipJson.dependencies ?? [];
       for (const dep of deps) {
-        const depPkgDir = join3(mipDir, "packages", dep);
+        const depPkgDir = join3(mipDir, "numbl_packages", dep);
         if (!existsSync3(depPkgDir)) {
           console.warn(
             `Warning: dependency "${dep}" of "${packageName}" is not installed; skipping`
@@ -44380,7 +44316,7 @@ function saveHistoryEntry(entry, hist) {
   } catch {
   }
 }
-async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths) {
+async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths, nativeBridge2) {
   let variableValues = {};
   let holdState = false;
   const workspaceFiles = [...initialWorkspaceFiles];
@@ -44439,7 +44375,8 @@ async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths) {
           },
           workspaceFiles,
           "repl",
-          searchPaths
+          searchPaths,
+          nativeBridge2
         );
         variableValues = result.variableValues;
         holdState = result.holdState;
@@ -44547,7 +44484,8 @@ async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths) {
         },
         workspaceFiles,
         "repl",
-        searchPaths
+        searchPaths,
+        nativeBridge2
       );
       variableValues = result.variableValues;
       holdState = result.holdState;
@@ -44989,15 +44927,27 @@ try {
   nativeAddonLoaded = true;
 } catch {
 }
+var nativeBridge;
+try {
+  const req = createRequire(import.meta.url);
+  const koffi = req("koffi");
+  nativeBridge = { load: (path) => koffi.load(path) };
+} catch {
+}
 function scanMFiles(dirPath, excludeFile) {
   const files = [];
+  let entries;
   try {
-    const entries = readdirSync2(dirPath);
-    for (const entry of entries) {
-      const fullPath = join6(dirPath, entry);
-      if (excludeFile && fullPath === excludeFile) {
-        continue;
-      }
+    entries = readdirSync2(dirPath);
+  } catch {
+    return files;
+  }
+  for (const entry of entries) {
+    const fullPath = join6(dirPath, entry);
+    if (excludeFile && fullPath === excludeFile) {
+      continue;
+    }
+    try {
       const stat = statSync2(fullPath);
       if (stat.isDirectory()) {
         if (entry.startsWith("@") || entry.startsWith("+") || entry === "private") {
@@ -45017,8 +44967,11 @@ function scanMFiles(dirPath, excludeFile) {
           data: new Uint8Array(data)
         });
       }
+    } catch (err) {
+      console.warn(
+        `Warning: could not read ${fullPath}: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
-  } catch {
   }
   return files;
 }
@@ -45078,7 +45031,8 @@ async function runTests(dir) {
         { displayResults: true },
         workspaceFiles,
         mainFileName,
-        searchPaths
+        searchPaths,
+        nativeBridge
       );
       const outputText = result.output.join("");
       const lines = outputText.split("\n").filter((l) => l.length > 0);
@@ -45377,7 +45331,8 @@ async function executeWithOptions(code, mainFileName, workspaceFiles, opts, sear
           },
           workspaceFiles,
           mainFileName,
-          searchPaths
+          searchPaths,
+          nativeBridge
         );
         if (result.plotInstructions.length > 0) {
           streamLine({
@@ -45425,7 +45380,8 @@ async function executeWithOptions(code, mainFileName, workspaceFiles, opts, sear
         },
         workspaceFiles,
         mainFileName,
-        searchPaths
+        searchPaths,
+        nativeBridge
       );
       writeProfileIfNeeded(result);
       if (opts.dumpJs) {
@@ -45453,7 +45409,8 @@ async function executeWithOptions(code, mainFileName, workspaceFiles, opts, sear
         },
         workspaceFiles,
         mainFileName,
-        searchPaths
+        searchPaths,
+        nativeBridge
       );
       writeProfileIfNeeded(result);
       if (opts.dumpJs) {
@@ -45538,7 +45495,7 @@ async function cmdRepl(args) {
     !opts.plot,
     replPlotOpts
   );
-  await runRepl(replFiles, replDrawnow, replSearchPaths);
+  await runRepl(replFiles, replDrawnow, replSearchPaths, nativeBridge);
 }
 function createPlotHandler(disabled, plotOpts) {
   if (disabled) {