numbl 0.0.13 → 0.0.16

package/dist-cli/cli.js

@@ -9,7 +9,7 @@ import {
   writeFileSync as writeFileSync3,
   appendFileSync as appendFileSync2
 } from "fs";
-import { delimiter, dirname as dirname3, join as join5, relative, resolve } from "path";
+import { delimiter, dirname as dirname3, join as join6, relative, resolve } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createRequire } from "module";
 import { execSync as execSync2 } from "child_process";
@@ -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", "all"]) {
+    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 === arch || p.architecture === "wasm" || p.architecture === "all"
   );
 }
 
@@ -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) {
@@ -17600,6 +17602,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 +17720,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 +20609,8 @@ var COMMAND_VERBS = [
         "square",
         "vis3d"
       ],
-      optional: false
+      optional: false,
+      multiKeyword: true
     }
   },
   { name: "clear", argKind: { type: "Any" } },
@@ -20965,19 +20972,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) {
@@ -21437,7 +21466,11 @@ var ExpressionParser = class extends ParserBase {
       const nameSpan = this.spanFrom(nameToken.position, nameToken.end);
       this.pos++;
       this.pos++;
-      args.push({ type: "Char", value: `'${nameToken.lexeme}'`, span: nameSpan });
+      args.push({
+        type: "Char",
+        value: `'${nameToken.lexeme}'`,
+        span: nameSpan
+      });
       args.push(this.parseExpr());
     } else {
       args.push(this.parseExpr());
@@ -21556,25 +21589,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;
   }
@@ -25093,6 +25133,125 @@ function registerMathFunctions() {
       return buildResult(snArr, cnArr, dnArr, uT.shape);
     })
   );
+  register(
+    "legendre",
+    builtinSingle((args) => {
+      if (args.length < 2 || args.length > 3) {
+        throw new RuntimeError("legendre requires 2 or 3 arguments");
+      }
+      const n = Math.round(toNumber(args[0]));
+      if (n < 0 || !isFinite(n)) {
+        throw new RuntimeError("Degree n must be a non-negative integer");
+      }
+      let normalization = "unnorm";
+      if (args.length === 3) {
+        const normArg = args[2];
+        if (isRuntimeChar(normArg)) {
+          normalization = normArg.value;
+        } else if (typeof normArg === "string") {
+          normalization = normArg;
+        } else {
+          throw new RuntimeError(
+            "Third argument must be a normalization string"
+          );
+        }
+        if (normalization !== "unnorm" && normalization !== "sch" && normalization !== "norm") {
+          throw new RuntimeError(
+            "Normalization must be 'unnorm', 'sch', or 'norm'"
+          );
+        }
+      }
+      const xArg = args[1];
+      let xValues;
+      let xShape;
+      if (isRuntimeNumber(xArg)) {
+        xValues = [xArg];
+        xShape = [1, 1];
+      } else if (isRuntimeLogical(xArg)) {
+        xValues = [xArg ? 1 : 0];
+        xShape = [1, 1];
+      } else if (isRuntimeTensor(xArg)) {
+        const t = xArg;
+        xValues = Array.from(t.data);
+        xShape = t.shape;
+      } else {
+        throw new RuntimeError("X must be a numeric value");
+      }
+      const numX = xValues.length;
+      const numOrders = n + 1;
+      const outSize = numOrders * numX;
+      const result = new FloatXArray(outSize);
+      for (let xi = 0; xi < numX; xi++) {
+        const x = xValues[xi];
+        const pmn = legendreAllOrders(n, x);
+        for (let m = 0; m <= n; m++) {
+          let val = pmn[m];
+          if (normalization === "sch") {
+            if (m > 0) {
+              const scale = Math.pow(-1, m) * Math.sqrt(2 * factorialVal(n - m) / factorialVal(n + m));
+              val = scale * val;
+            }
+          } else if (normalization === "norm") {
+            const scale = Math.pow(-1, m) * Math.sqrt(
+              (n + 0.5) * factorialVal(n - m) / factorialVal(n + m)
+            );
+            val = scale * val;
+          }
+          result[xi * numOrders + m] = val;
+        }
+      }
+      if (isRuntimeNumber(xArg) || isRuntimeLogical(xArg)) {
+        return RTV.tensor(result, [numOrders, 1]);
+      }
+      if (xShape.length === 2 && (xShape[0] === 1 || xShape[1] === 1)) {
+        return RTV.tensor(result, [numOrders, numX]);
+      }
+      return RTV.tensor(result, [numOrders, ...xShape]);
+    })
+  );
+}
+function factorialVal(n) {
+  if (n <= 1) return 1;
+  let r = 1;
+  for (let i = 2; i <= n; i++) r *= i;
+  return r;
+}
+function legendreAllOrders(n, x) {
+  const result = new Array(n + 1);
+  if (n === 0) {
+    result[0] = 1;
+    return result;
+  }
+  const sqrtFactor = Math.sqrt(1 - x * x);
+  for (let m = 0; m <= n; m++) {
+    let pmm = 1;
+    if (m > 0) {
+      let dblFact = 1;
+      for (let i = 1; i <= m; i++) {
+        dblFact *= 2 * i - 1;
+      }
+      pmm = Math.pow(-1, m) * dblFact * Math.pow(sqrtFactor, m);
+    }
+    if (m === n) {
+      result[m] = pmm;
+      continue;
+    }
+    const pmm1 = x * (2 * m + 1) * pmm;
+    if (m + 1 === n) {
+      result[m] = pmm1;
+      continue;
+    }
+    let pPrev2 = pmm;
+    let pPrev1 = pmm1;
+    let pCurr = 0;
+    for (let l = m + 2; l <= n; l++) {
+      pCurr = (x * (2 * l - 1) * pPrev1 - (l + m - 1) * pPrev2) / (l - m);
+      pPrev2 = pPrev1;
+      pPrev1 = pCurr;
+    }
+    result[m] = pCurr;
+  }
+  return result;
 }
 
 // src/numbl-core/builtins/shape-utils.ts
@@ -33686,6 +33845,12 @@ function registerMiscFunctions() {
       return RTV.num(0);
     })
   );
+  register(
+    "clc",
+    builtinSingle(() => {
+      return RTV.num(0);
+    })
+  );
   register(
     "clf",
     builtinSingle(() => {
@@ -34118,6 +34283,78 @@ function registerGraphicsFunctions() {
     "close",
     builtinSingle(() => RTV.num(0))
   );
+  register(
+    "title",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "xlabel",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "ylabel",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "shading",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "subplot",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "legend",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "sgtitle",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "zlabel",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "colorbar",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "colormap",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "axis",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "view",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "imagesc",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "contour",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "contourf",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "mesh",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "waterfall",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "scatter",
+    builtinSingle(() => RTV.num(0))
+  );
   register(
     "drawnow",
     builtinSingle(() => RTV.num(0))
@@ -34126,6 +34363,45 @@ function registerGraphicsFunctions() {
     "pause",
     builtinSingle(() => RTV.num(0))
   );
+  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(
+    "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]);
+    })
+  );
 }
 
 // src/numbl-core/builtins/validators.ts
@@ -34297,7 +34573,7 @@ function registerDummyStringFunctions() {
     register(name, fn);
   }
 }
-var returnEmptyArrayFunctions = ["who", "xlim", "ylim", "jet", "hot"];
+var returnEmptyArrayFunctions = ["who", "xlim", "ylim"];
 function registerDummyArrayFunctions() {
   const fn = builtinSingle(() => RTV.tensor([], [0, 0]), {
     outputType: IType.tensor()
@@ -36159,6 +36435,30 @@ function dispatch(rt, name, nargout, args, targetClassName) {
       if (name === "surf") {
         return rt.surf_call(args.map((a) => ensureRuntimeValue(a)));
       }
+      if (name === "scatter") {
+        return rt.scatter_call(args.map((a) => ensureRuntimeValue(a)));
+      }
+      if (name === "imagesc") {
+        return rt.imagesc_call(args.map((a) => ensureRuntimeValue(a)));
+      }
+      if (name === "contour") {
+        return rt.contour_call(
+          args.map((a) => ensureRuntimeValue(a)),
+          false
+        );
+      }
+      if (name === "contourf") {
+        return rt.contour_call(
+          args.map((a) => ensureRuntimeValue(a)),
+          true
+        );
+      }
+      if (name === "mesh") {
+        return rt.mesh_call(args.map((a) => ensureRuntimeValue(a)));
+      }
+      if (name === "waterfall") {
+        return rt.mesh_call(args.map((a) => ensureRuntimeValue(a)));
+      }
     }
     if (rt.compileSpecialized) {
       const argTypes = args.map(
@@ -36206,6 +36506,30 @@ function callBuiltin(rt, name, nargout, args) {
   if (name === "surf") {
     return rt.surf_call(args.map((a) => ensureRuntimeValue(a)));
   }
+  if (name === "scatter") {
+    return rt.scatter_call(args.map((a) => ensureRuntimeValue(a)));
+  }
+  if (name === "imagesc") {
+    return rt.imagesc_call(args.map((a) => ensureRuntimeValue(a)));
+  }
+  if (name === "contour") {
+    return rt.contour_call(
+      args.map((a) => ensureRuntimeValue(a)),
+      false
+    );
+  }
+  if (name === "contourf") {
+    return rt.contour_call(
+      args.map((a) => ensureRuntimeValue(a)),
+      true
+    );
+  }
+  if (name === "mesh") {
+    return rt.mesh_call(args.map((a) => ensureRuntimeValue(a)));
+  }
+  if (name === "waterfall") {
+    return rt.mesh_call(args.map((a) => ensureRuntimeValue(a)));
+  }
   const builtin = rt.builtins[name];
   if (builtin) return builtin(nargout, args);
   throw new RuntimeError(`'${name}' is not a builtin function`);
@@ -36220,6 +36544,30 @@ function callBuiltinSync(rt, name, nargout, args) {
   if (name === "surf") {
     return rt.surf_call(args.map((a) => ensureRuntimeValue(a)));
   }
+  if (name === "scatter") {
+    return rt.scatter_call(args.map((a) => ensureRuntimeValue(a)));
+  }
+  if (name === "imagesc") {
+    return rt.imagesc_call(args.map((a) => ensureRuntimeValue(a)));
+  }
+  if (name === "contour") {
+    return rt.contour_call(
+      args.map((a) => ensureRuntimeValue(a)),
+      false
+    );
+  }
+  if (name === "contourf") {
+    return rt.contour_call(
+      args.map((a) => ensureRuntimeValue(a)),
+      true
+    );
+  }
+  if (name === "mesh") {
+    return rt.mesh_call(args.map((a) => ensureRuntimeValue(a)));
+  }
+  if (name === "waterfall") {
+    return rt.mesh_call(args.map((a) => ensureRuntimeValue(a)));
+  }
   const builtin = rt.builtins[name];
   if (builtin) return builtin(nargout, args);
   throw new RuntimeError(`'${name}' is not a builtin function`);
@@ -38099,6 +38447,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": {
@@ -38143,6 +38573,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;
@@ -38168,10 +38687,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",
@@ -38191,13 +38717,82 @@ function plotInstr(plotInstructions, instr) {
       on = toString(mv) === "on";
     }
     plotInstructions.push({ type: "set_hold", value: on });
+  } else if (instr.type === "set_title") {
+    const text = typeof instr.text === "string" ? instr.text : toString(ensureRuntimeValue(instr.text));
+    plotInstructions.push({ type: "set_title", text });
+  } else if (instr.type === "set_xlabel") {
+    const text = typeof instr.text === "string" ? instr.text : toString(ensureRuntimeValue(instr.text));
+    plotInstructions.push({ type: "set_xlabel", text });
+  } else if (instr.type === "set_ylabel") {
+    const text = typeof instr.text === "string" ? instr.text : toString(ensureRuntimeValue(instr.text));
+    plotInstructions.push({ type: "set_ylabel", text });
+  } else if (instr.type === "set_shading") {
+    const raw = typeof instr.shading === "string" ? instr.shading : toString(ensureRuntimeValue(instr.shading));
+    const shading = raw.replace(/^'|'$/g, "");
+    plotInstructions.push({ type: "set_shading", shading });
   } else if (instr.type === "close") {
     plotInstructions.push({ type: "close" });
   } else if (instr.type === "close_all") {
     plotInstructions.push({ type: "close_all" });
   } else if (instr.type === "clf") {
     plotInstructions.push({ type: "clf" });
+  } else if (instr.type === "set_subplot") {
+    const rows = typeof instr.rows === "number" ? instr.rows : toNumber(ensureRuntimeValue(instr.rows));
+    const cols = typeof instr.cols === "number" ? instr.cols : toNumber(ensureRuntimeValue(instr.cols));
+    const index2 = typeof instr.index === "number" ? instr.index : toNumber(ensureRuntimeValue(instr.index));
+    plotInstructions.push({ type: "set_subplot", rows, cols, index: index2 });
+  } else if (instr.type === "set_sgtitle") {
+    const text = typeof instr.text === "string" ? instr.text : toString(ensureRuntimeValue(instr.text));
+    plotInstructions.push({ type: "set_sgtitle", text });
+  } else if (instr.type === "set_grid") {
+    const val = instr.value;
+    let on;
+    if (typeof val === "string") on = val === "on";
+    else if (typeof val === "boolean") on = val;
+    else {
+      const mv = ensureRuntimeValue(val);
+      on = toString(mv) === "on";
+    }
+    plotInstructions.push({ type: "set_grid", value: on });
+  } else if (instr.type === "set_zlabel") {
+    const text = typeof instr.text === "string" ? instr.text : toString(ensureRuntimeValue(instr.text));
+    plotInstructions.push({ type: "set_zlabel", text });
+  } else if (instr.type === "set_colorbar") {
+    const val = typeof instr.value === "string" ? instr.value : toString(ensureRuntimeValue(instr.value));
+    plotInstructions.push({ type: "set_colorbar", value: val });
+  } else if (instr.type === "set_colormap") {
+    const name = typeof instr.name === "string" ? instr.name : toString(ensureRuntimeValue(instr.name));
+    plotInstructions.push({
+      type: "set_colormap",
+      name: name.replace(/^"|"$/g, "")
+    });
+  } else if (instr.type === "set_axis") {
+    const val = typeof instr.value === "string" ? instr.value : toString(ensureRuntimeValue(instr.value));
+    plotInstructions.push({
+      type: "set_axis",
+      value: val.replace(/^"|"$/g, "")
+    });
+  }
+}
+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);
@@ -38215,6 +38810,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]);
@@ -38323,6 +38950,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;
@@ -38913,6 +39595,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);
@@ -39147,6 +39847,61 @@ function getEffectiveDir(fileName, searchPaths) {
   }
   return parts.length > 0 ? parts.join("/") + "/" : "";
 }
+function resolveViaImports(name, argTypes, callSite, index2, wildcardOnly) {
+  const imports = index2.fileImports.get(callSite.file);
+  if (!imports) return null;
+  for (const imp of imports) {
+    if (imp.wildcard !== wildcardOnly) continue;
+    if (imp.wildcard) {
+      const candidateName = `${imp.namespace}.${name}`;
+      if (index2.workspaceFunctions.has(candidateName)) {
+        return { kind: "workspaceFunction", name: candidateName, argTypes };
+      }
+      if (index2.workspaceClasses.has(candidateName)) {
+        return {
+          kind: "workspaceClassConstructor",
+          className: candidateName,
+          argTypes
+        };
+      }
+      if (index2.classStaticMethods.get(imp.namespace)?.has(name)) {
+        return {
+          kind: "classMethod",
+          className: imp.namespace,
+          methodName: name,
+          compileArgTypes: argTypes,
+          stripInstance: false
+        };
+      }
+    } else {
+      if (name !== imp.shortName) continue;
+      if (imp.staticMethod) {
+        return {
+          kind: "classMethod",
+          className: imp.staticMethod.className,
+          methodName: imp.staticMethod.methodName,
+          compileArgTypes: argTypes,
+          stripInstance: false
+        };
+      }
+      if (index2.workspaceFunctions.has(imp.qualifiedName)) {
+        return {
+          kind: "workspaceFunction",
+          name: imp.qualifiedName,
+          argTypes
+        };
+      }
+      if (index2.workspaceClasses.has(imp.qualifiedName)) {
+        return {
+          kind: "workspaceClassConstructor",
+          className: imp.qualifiedName,
+          argTypes
+        };
+      }
+    }
+  }
+  return null;
+}
 function resolveFunction(name, argTypes, callSite, index2) {
   if (callSite.targetClassName) {
     const className = callSite.targetClassName;
@@ -39161,6 +39916,10 @@ function resolveFunction(name, argTypes, callSite, index2) {
       stripInstance
     };
   }
+  {
+    const imported = resolveViaImports(name, argTypes, callSite, index2, false);
+    if (imported) return imported;
+  }
   if (callSite.className) {
     const className = callSite.className;
     const isClassMethod = index2.classInstanceMethods.get(className)?.has(name) || index2.classConstructors.get(className) === name || index2.classStaticMethods.get(className)?.has(name);
@@ -39209,6 +39968,10 @@ function resolveFunction(name, argTypes, callSite, index2) {
       }
     }
   }
+  {
+    const imported = resolveViaImports(name, argTypes, callSite, index2, true);
+    if (imported) return imported;
+  }
   if (callSite.file) {
     const dir = getEffectiveDir(callSite.file, index2.searchPaths);
     if (index2.privateFunctions.get(dir)?.has(name)) {
@@ -39263,6 +40026,9 @@ function resolveFunction(name, argTypes, callSite, index2) {
       argTypes
     };
   }
+  if (index2.jsUserFunctions.has(name)) {
+    return { kind: "builtin", name };
+  }
   if (index2.workspaceClasses.has(name)) {
     return {
       kind: "workspaceClassConstructor",
@@ -39328,12 +40094,17 @@ function resolveFuncCall(ctx, name, args, nargout, span) {
         { type: "userFunction", functionId: `private:${name}` }
       ]);
     case "workspaceFunction":
-      return makeFuncCallExpr(ctx, name, args, nargout, span, [
-        { type: "userFunction", functionId: name }
+      return makeFuncCallExpr(ctx, target.name, args, nargout, span, [
+        { type: "userFunction", functionId: target.name }
       ]);
     case "workspaceClassConstructor":
       return {
-        kind: { type: "ClassInstantiation", className: name, args, nargout },
+        kind: {
+          type: "ClassInstantiation",
+          className: target.className,
+          args,
+          nargout
+        },
         span
       };
     case "builtin":
@@ -40414,13 +41185,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);
@@ -40555,7 +41319,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.
@@ -40720,8 +41486,17 @@ var LoweringContext = class _LoweringContext {
    * Should be called once after registerWorkspaceFiles() and registerLocalFunctionAST().
    * Parses all workspace files eagerly to discover subfunctions.
    */
-  buildFunctionIndex() {
+  buildFunctionIndex(jsUserFunctionNames) {
     const builtins2 = new Set(getAllBuiltinNames());
+    const jsUserFunctions = /* @__PURE__ */ new Set();
+    if (jsUserFunctionNames) {
+      for (const name of jsUserFunctionNames) {
+        if (builtins2.has(name)) {
+          builtins2.delete(name);
+          jsUserFunctions.add(name);
+        }
+      }
+    }
     const mainLocalFunctions = new Set(this.localFunctionASTs.keys());
     const workspaceFunctions = new Set(this.registry.filesByFuncName.keys());
     const workspaceClasses = /* @__PURE__ */ new Set([
@@ -40832,11 +41607,55 @@ var LoweringContext = class _LoweringContext {
         classInferiorClasses.set(className, new Set(info.inferiorClasses));
       }
     }
+    const fileImports = /* @__PURE__ */ new Map();
+    const collectImportsFromBody = (body, fileName) => {
+      const entries = [];
+      for (const stmt of body) {
+        if (stmt.type !== "Import") continue;
+        if (stmt.wildcard) {
+          entries.push({ wildcard: true, namespace: stmt.path.join(".") });
+        } else {
+          const qualifiedName = stmt.path.join(".");
+          const shortName = stmt.path[stmt.path.length - 1];
+          const prefix = stmt.path.slice(0, -1).join(".");
+          const isStaticMethod = prefix.length > 0 && classStaticMethods.get(prefix)?.has(shortName);
+          entries.push({
+            wildcard: false,
+            qualifiedName,
+            shortName,
+            ...isStaticMethod ? { staticMethod: { className: prefix, methodName: shortName } } : {}
+          });
+        }
+      }
+      if (entries.length > 0) {
+        fileImports.set(fileName, entries);
+      }
+    };
+    try {
+      const mainAst = this.getCachedAST(this.mainFileName);
+      collectImportsFromBody(mainAst.body, this.mainFileName);
+    } catch {
+    }
+    for (const [, entry] of this.registry.filesByFuncName) {
+      const ast = this.getCachedAST(entry.fileName);
+      collectImportsFromBody(ast.body, entry.fileName);
+    }
+    for (const [, info] of this.registry.classesByName) {
+      const ast = this.getCachedAST(info.fileName);
+      collectImportsFromBody(ast.body, info.fileName);
+    }
+    for (const [, entries] of this.registry.privateFilesByDir) {
+      for (const [, entry] of entries) {
+        const ast = this.getCachedAST(entry.fileName);
+        collectImportsFromBody(ast.body, entry.fileName);
+      }
+    }
     const index2 = {
       builtins: builtins2,
       mainFileName: this.mainFileName,
       mainLocalFunctions,
       workspaceFunctions,
+      jsUserFunctions,
       workspaceClasses,
       workspaceFileSubfunctions,
       classFileSubfunctions,
@@ -40847,7 +41666,8 @@ var LoweringContext = class _LoweringContext {
       privateFileSubfunctions,
       classInferiorClasses,
       searchPaths: this.registry.searchPaths,
-      fileToFuncName: this.registry.fileToFuncName
+      fileToFuncName: this.registry.fileToFuncName,
+      fileImports
     };
     this.registry.functionIndex = index2;
     return index2;
@@ -41604,12 +42424,36 @@ function genFuncCall(cg, kind) {
     return `$rt.plot_instr({type: "set_hold", value: ${args[0]}})`;
   if (kind.name === "ishold") return `$rt.ishold()`;
   if (kind.name === "clf") return `$rt.plot_instr({type: "clf"})`;
+  if (kind.name === "title")
+    return `$rt.plot_instr({type: "set_title", text: ${args[0] ?? '""'}})`;
+  if (kind.name === "xlabel")
+    return `$rt.plot_instr({type: "set_xlabel", text: ${args[0] ?? '""'}})`;
+  if (kind.name === "ylabel")
+    return `$rt.plot_instr({type: "set_ylabel", text: ${args[0] ?? '""'}})`;
+  if (kind.name === "shading")
+    return `$rt.plot_instr({type: "set_shading", shading: ${args[0] ?? '"faceted"'}})`;
   if (kind.name === "close") {
     if (args.length > 0) {
       return `$rt.plot_instr({type: "close_all"})`;
     }
     return `$rt.plot_instr({type: "close"})`;
   }
+  if (kind.name === "subplot")
+    return `$rt.plot_instr({type: "set_subplot", rows: ${args[0] ?? "1"}, cols: ${args[1] ?? "1"}, index: ${args[2] ?? "1"}})`;
+  if (kind.name === "legend") return `$rt.legend_call([${args.join(", ")}])`;
+  if (kind.name === "sgtitle")
+    return `$rt.plot_instr({type: "set_sgtitle", text: ${args[0] ?? '""'}})`;
+  if (kind.name === "grid")
+    return `$rt.plot_instr({type: "set_grid", value: ${args[0] ?? "true"}})`;
+  if (kind.name === "zlabel")
+    return `$rt.plot_instr({type: "set_zlabel", text: ${args[0] ?? '""'}})`;
+  if (kind.name === "colorbar")
+    return `$rt.plot_instr({type: "set_colorbar", value: ${args[0] ?? '"on"'}})`;
+  if (kind.name === "colormap")
+    return `$rt.plot_instr({type: "set_colormap", name: ${args[0] ?? '"parula"'}})`;
+  if (kind.name === "axis")
+    return `$rt.plot_instr({type: "set_axis", value: ${args[0] ?? '"auto"'}})`;
+  if (kind.name === "view") return `$rt.view_call([${args.join(", ")}])`;
   if (cg.nestedFunctionNames.has(kind.name)) {
     return buildSpecializedCall(
       cg,
@@ -41715,13 +42559,18 @@ function genFuncCall(cg, kind) {
         break;
       }
       case "builtin": {
-        const nativeMath = tryNativeMathCodegen(
-          kind.name,
-          kind.nargout,
-          kind.args,
-          args
+        const isJsUserFunc = cg.loweringCtx.functionIndex.jsUserFunctions.has(
+          kind.name
         );
-        if (nativeMath !== null) return nativeMath;
+        if (!isJsUserFunc) {
+          const nativeMath = tryNativeMathCodegen(
+            kind.name,
+            kind.nargout,
+            kind.args,
+            args
+          );
+          if (nativeMath !== null) return nativeMath;
+        }
         if (hasUnknown) {
           return emitDispatchUnknown(
             cg,
@@ -43327,8 +44176,80 @@ var defaultCheck = (_argTypes, nargout) => ({
     kind: "Unknown"
   })
 });
-function loadJsUserFunctions(jsFiles) {
+function buildWasmMap(wasmFiles) {
+  const map = /* @__PURE__ */ new Map();
+  for (const f of wasmFiles) {
+    if (!f.data) continue;
+    const base = f.name.split("/").pop().replace(/\.wasm$/, "");
+    map.set(base, f.data);
+  }
+  return map;
+}
+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);
+  const moduleImports = WebAssembly.Module.imports(wasmModule);
+  const importObject = {};
+  const neededModules = new Set(moduleImports.map((i) => i.module));
+  if (neededModules.has("wasi_snapshot_preview1")) {
+    importObject.wasi_snapshot_preview1 = {
+      fd_write: () => 0,
+      fd_read: () => 0,
+      fd_close: () => 0,
+      fd_seek: () => 0,
+      fd_fdstat_get: () => 0,
+      proc_exit: () => {
+      },
+      environ_sizes_get: () => 0,
+      environ_get: () => 0,
+      clock_time_get: () => 0,
+      args_sizes_get: () => 0,
+      args_get: () => 0
+    };
+  }
+  if (neededModules.has("env")) {
+    importObject.env = {
+      emscripten_notify_memory_growth: () => {
+      }
+    };
+  }
+  return new WebAssembly.Instance(wasmModule, importObject);
+}
+function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge2) {
   const result = /* @__PURE__ */ new Map();
+  const wasmMap = wasmFiles ? buildWasmMap(wasmFiles) : /* @__PURE__ */ new Map();
+  const wasmInstanceCache = /* @__PURE__ */ new Map();
+  function getWasmInstance(name) {
+    const cached = wasmInstanceCache.get(name);
+    if (cached) return cached;
+    const data = wasmMap.get(name);
+    if (!data) return void 0;
+    const instance = instantiateWasm(data);
+    wasmInstanceCache.set(name, instance);
+    return instance;
+  }
   for (const file of jsFiles) {
     const funcName = funcNameFromFile(file.name);
     try {
@@ -43342,19 +44263,63 @@ function loadJsUserFunctions(jsFiles) {
           apply: branch.apply
         });
       };
+      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",
         "FloatXArray",
+        "IType",
         "register",
+        "wasm",
+        "native",
         file.source
       );
-      factory(RTV, RuntimeError, FloatXArray, registerFn);
+      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);
@@ -43445,10 +44410,13 @@ function generateMainScriptCode(source, mainFileName = "script.m", workspaceFile
   const ctx = new LoweringContext(source, mainFileName);
   const mWorkspaceFiles = [];
   const jsWorkspaceFiles = [];
+  const wasmWorkspaceFiles = [];
   if (workspaceFiles) {
     for (const f of workspaceFiles) {
       if (f.name.endsWith(".js")) {
         jsWorkspaceFiles.push(f);
+      } else if (f.name.endsWith(".wasm")) {
+        wasmWorkspaceFiles.push(f);
       } else {
         mWorkspaceFiles.push(f);
       }
@@ -43465,7 +44433,11 @@ function generateMainScriptCode(source, mainFileName = "script.m", workspaceFile
   }
   ctx.registry.searchPaths = [...searchPaths ?? [], SHIM_SEARCH_PATH];
   _t0 = performance.now();
-  const jsUserFunctions = loadJsUserFunctions(jsWorkspaceFiles);
+  const jsUserFunctions = loadJsUserFunctions(
+    jsWorkspaceFiles,
+    wasmWorkspaceFiles,
+    opts?.nativeBridge
+  );
   const _loadJsUserFunctionsMs = performance.now() - _t0;
   _t0 = performance.now();
   ctx.fileASTCache.set(mainFileName, ast);
@@ -43491,12 +44463,15 @@ function generateMainScriptCode(source, mainFileName = "script.m", workspaceFile
     ctx.registerWorkspaceFiles(mWorkspaceFiles);
   }
   const jsUserFuncNames = [...jsUserFunctions.keys()];
+  const savedBuiltins = /* @__PURE__ */ new Map();
   for (const name of jsUserFuncNames) {
+    const existing = getBuiltin(name);
+    if (existing) savedBuiltins.set(name, existing);
     register(name, jsUserFunctions.get(name));
   }
   const _registrationMs = performance.now() - _t0;
   _t0 = performance.now();
-  const functionIndex = ctx.buildFunctionIndex();
+  const functionIndex = ctx.buildFunctionIndex(jsUserFuncNames);
   const _buildFunctionIndexMs = performance.now() - _t0;
   ctx.isTopLevel = true;
   const initialVarIRVars = [];
@@ -43575,7 +44550,12 @@ function generateMainScriptCode(source, mainFileName = "script.m", workspaceFile
   codegen.emit(`return $ret;`);
   const _codegenMs = performance.now() - _t0;
   for (const name of jsUserFuncNames) {
-    unregister(name);
+    const original = savedBuiltins.get(name);
+    if (original) {
+      register(name, original);
+    } else {
+      unregister(name);
+    }
   }
   return {
     jsCode: codegen.getCode(),
@@ -43598,7 +44578,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 {
@@ -43622,7 +44602,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) {
@@ -43765,7 +44745,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(
@@ -43779,7 +44759,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`
@@ -44019,7 +44999,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];
@@ -44078,7 +45058,8 @@ async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths) {
           },
           workspaceFiles,
           "repl",
-          searchPaths
+          searchPaths,
+          nativeBridge2
         );
         variableValues = result.variableValues;
         holdState = result.holdState;
@@ -44186,7 +45167,8 @@ async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths) {
         },
         workspaceFiles,
         "repl",
-        searchPaths
+        searchPaths,
+        nativeBridge2
       );
       variableValues = result.variableValues;
       holdState = result.holdState;
@@ -44455,6 +45437,14 @@ async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths) {
 
 // src/cli-fileio.ts
 import { openSync, closeSync, readSync, writeSync, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
+function expandTilde(filepath) {
+  if (filepath.startsWith("~/")) {
+    return join5(homedir4(), filepath.slice(2));
+  }
+  return filepath;
+}
 function permissionToFlags(permission) {
   switch (permission) {
     case "r":
@@ -44481,7 +45471,7 @@ var NodeFileIOAdapter = class {
   fopen(filename, permission) {
     try {
       const flags = permissionToFlags(permission);
-      const fd = openSync(filename, flags);
+      const fd = openSync(expandTilde(filename), flags);
       const fid = this.nextFid++;
       this.openFiles.set(fid, {
         fd,
@@ -44527,7 +45517,7 @@ var NodeFileIOAdapter = class {
     return this.readLine(entry, true);
   }
   fileread(filename) {
-    return readFileSync5(filename, "utf-8");
+    return readFileSync5(expandTilde(filename), "utf-8");
   }
   feof(fid) {
     const entry = this.getEntry(fid);
@@ -44609,8 +45599,8 @@ var NodeFileIOAdapter = class {
 // src/cli.ts
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname = dirname3(__filename);
-var packageDir2 = join5(__dirname, "..");
-var addonPath = join5(packageDir2, "build", "Release", "lapack_addon.node");
+var packageDir2 = join6(__dirname, "..");
+var addonPath = join6(packageDir2, "build", "Release", "lapack_addon.node");
 var nativeAddonLoaded = false;
 try {
   const req = createRequire(import.meta.url);
@@ -44620,15 +45610,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 = join5(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") {
@@ -44640,9 +45642,19 @@ function scanMFiles(dirPath, excludeFile) {
           name: fullPath,
           source
         });
+      } else if (stat.isFile() && entry.endsWith(".wasm")) {
+        const data = readFileSync6(fullPath);
+        files.push({
+          name: fullPath,
+          source: "",
+          data: new Uint8Array(data)
+        });
       }
+    } catch (err) {
+      console.warn(
+        `Warning: could not read ${fullPath}: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
-  } catch {
   }
   return files;
 }
@@ -44657,7 +45669,7 @@ function findTestFiles(dir) {
     }
     entries.sort();
     for (const entry of entries) {
-      const fullPath = join5(current, entry);
+      const fullPath = join6(current, entry);
       let stat;
       try {
         stat = statSync2(fullPath);
@@ -44665,7 +45677,7 @@ function findTestFiles(dir) {
         continue;
       }
       if (stat.isDirectory()) {
-        if (!entry.startsWith("@") && !entry.startsWith("+")) {
+        if (!entry.startsWith("@") && !entry.startsWith("+") && entry !== "wasm") {
           walk(fullPath);
         }
       } else if (stat.isFile() && entry.endsWith(".m")) {
@@ -44702,7 +45714,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);
@@ -45001,7 +46014,8 @@ async function executeWithOptions(code, mainFileName, workspaceFiles, opts, sear
           },
           workspaceFiles,
           mainFileName,
-          searchPaths
+          searchPaths,
+          nativeBridge
         );
         if (result.plotInstructions.length > 0) {
           streamLine({
@@ -45049,7 +46063,8 @@ async function executeWithOptions(code, mainFileName, workspaceFiles, opts, sear
         },
         workspaceFiles,
         mainFileName,
-        searchPaths
+        searchPaths,
+        nativeBridge
       );
       writeProfileIfNeeded(result);
       if (opts.dumpJs) {
@@ -45077,7 +46092,8 @@ async function executeWithOptions(code, mainFileName, workspaceFiles, opts, sear
         },
         workspaceFiles,
         mainFileName,
-        searchPaths
+        searchPaths,
+        nativeBridge
       );
       writeProfileIfNeeded(result);
       if (opts.dumpJs) {
@@ -45110,7 +46126,7 @@ function finalizeDumpFile(dumpFile, mainFileName, jsCode) {
   writeFileSync3(dumpFile, header + jsCode + "\n" + jitContent);
 }
 async function cmdBuildAddon() {
-  const bindingGyp = join5(packageDir2, "binding.gyp");
+  const bindingGyp = join6(packageDir2, "binding.gyp");
   if (!existsSync4(bindingGyp)) {
     console.error(
       "Error: binding.gyp not found in package directory: " + packageDir2
@@ -45162,7 +46178,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) {
@@ -45317,7 +46333,7 @@ async function main() {
       await cmdEval(rest);
       break;
     case "run-tests": {
-      const dir = rest.length > 0 ? rest[0] : join5(packageDir2, "numbl_test_scripts");
+      const dir = rest.length > 0 ? rest[0] : join6(packageDir2, "numbl_test_scripts");
       await runTests(dir);
       break;
     }