numbl 0.0.15 → 0.0.16

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", "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);
+    }
+  }
+  /** 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);
     }
-    this.pos++;
-    const rhs = this.parseUnary();
-    return this.makeBinary(node, op, rhs);
+    return this.parsePostfix();
   }
   parsePostfixWithBase(expr) {
     while (true) {
@@ -21560,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;
   }
@@ -33809,6 +33845,12 @@ function registerMiscFunctions() {
       return RTV.num(0);
     })
   );
+  register(
+    "clc",
+    builtinSingle(() => {
+      return RTV.num(0);
+    })
+  );
   register(
     "clf",
     builtinSingle(() => {
@@ -34257,6 +34299,62 @@ function registerGraphicsFunctions() {
     "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))
@@ -34265,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
@@ -34436,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()
@@ -36298,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(
@@ -36345,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`);
@@ -36359,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`);
@@ -38238,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": {
@@ -38282,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;
@@ -38307,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",
@@ -38349,7 +38736,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 +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]);
@@ -38475,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;
@@ -39065,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);
@@ -40637,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);
@@ -40778,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.
@@ -41895,6 +42438,22 @@ function genFuncCall(cg, kind) {
     }
     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,
@@ -43626,9 +44185,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 +44237,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 +44245,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 +44263,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 +44282,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 +44435,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 +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 {
@@ -43983,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) {
@@ -44126,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(
@@ -44140,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`
@@ -44380,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];
@@ -44439,7 +45058,8 @@ async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths) {
           },
           workspaceFiles,
           "repl",
-          searchPaths
+          searchPaths,
+          nativeBridge2
         );
         variableValues = result.variableValues;
         holdState = result.holdState;
@@ -44547,7 +45167,8 @@ async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths) {
         },
         workspaceFiles,
         "repl",
-        searchPaths
+        searchPaths,
+        nativeBridge2
       );
       variableValues = result.variableValues;
       holdState = result.holdState;
@@ -44989,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 = 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 +45650,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 +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);
@@ -45377,7 +46014,8 @@ async function executeWithOptions(code, mainFileName, workspaceFiles, opts, sear
           },
           workspaceFiles,
           mainFileName,
-          searchPaths
+          searchPaths,
+          nativeBridge
         );
         if (result.plotInstructions.length > 0) {
           streamLine({
@@ -45425,7 +46063,8 @@ async function executeWithOptions(code, mainFileName, workspaceFiles, opts, sear
         },
         workspaceFiles,
         mainFileName,
-        searchPaths
+        searchPaths,
+        nativeBridge
       );
       writeProfileIfNeeded(result);
       if (opts.dumpJs) {
@@ -45453,7 +46092,8 @@ async function executeWithOptions(code, mainFileName, workspaceFiles, opts, sear
         },
         workspaceFiles,
         mainFileName,
-        searchPaths
+        searchPaths,
+        nativeBridge
       );
       writeProfileIfNeeded(result);
       if (opts.dumpJs) {
@@ -45538,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) {