numbl 0.4.0 → 0.4.1

package/dist-cli/cli.js

@@ -786,10 +786,12 @@ var RuntimeClassInstanceArray = class extends Refcounted {
   kind = "class_instance_array";
   className;
   elements;
-  constructor(className, elements) {
+  shape;
+  constructor(className, elements, shape) {
     super();
     this.className = className;
     this.elements = elements;
+    this.shape = shape ?? [1, elements.length];
     for (const el of elements) incref(el);
   }
   _destroy(rt) {
@@ -3547,10 +3549,11 @@ function sparseElemMul(a, b) {
 }
 function sparseElemMulDense(S, D) {
   const [dRows, dCols] = tensorSize2D(D);
-  if (S.m !== dRows || S.n !== dCols)
+  if (!(dRows === S.m || dRows === 1) || !(dCols === S.n || dCols === 1))
     throw new RuntimeError(
       `Matrix dimensions must agree: [${S.m},${S.n}] vs [${dRows},${dCols}]`
     );
+  const denseIdx = (row, col) => (dCols === 1 ? 0 : col) * dRows + (dRows === 1 ? 0 : row);
   const hasImag = isComplexSparse(S) || D.imag !== void 0;
   const irList = [];
   const prList = [];
@@ -3560,7 +3563,7 @@ function sparseElemMulDense(S, D) {
     jc[col] = irList.length;
     for (let k = S.jc[col]; k < S.jc[col + 1]; k++) {
       const row = S.ir[k];
-      const idx = col * S.m + row;
+      const idx = denseIdx(row, col);
       const aRe = S.pr[k], aIm = S.pi ? S.pi[k] : 0;
       const bRe = D.data[idx], bIm = D.imag ? D.imag[idx] : 0;
       const re = aRe * bRe - aIm * bIm;
@@ -20924,7 +20927,7 @@ function displayValue(v) {
     case "dictionary":
       return formatDictionary(v);
     case "class_instance_array":
-      return `  1x${v.elements.length} ${v.className} array`;
+      return `  ${v.shape[0]}x${v.shape[1]} ${v.className} array`;
   }
 }
 var formatStructArray = (v) => {
@@ -23337,6 +23340,60 @@ function cellCatAlongDim(values, dimIdx) {
 }
 
 // src/numbl-core/runtime/struct-access.ts
+function handlePropToRuntime(v) {
+  if (typeof v === "number") return RTV.num(v);
+  if (typeof v === "boolean") return RTV.logical(v);
+  if (typeof v === "string") return RTV.char(v);
+  if (Array.isArray(v)) {
+    const data = allocFloat64Array(v);
+    return RTV.tensor(data, [1, v.length]);
+  }
+  return v;
+}
+var HANDLE_DEFAULTS = {
+  quiver3: {
+    LineWidth: 0.5,
+    LineStyle: "-",
+    ShowArrowHead: true,
+    AutoScale: true,
+    AutoScaleFactor: 0.9,
+    Marker: "none",
+    Color: [0, 0.447, 0.741]
+  }
+};
+function resolveHandleKey(trace, field) {
+  if (field in trace) return field;
+  const camel = field.charAt(0).toLowerCase() + field.slice(1);
+  if (camel in trace) return camel;
+  if (field.endsWith("Data")) {
+    const base = field.slice(0, -4);
+    const short = base.charAt(0).toLowerCase() + base.slice(1);
+    if (short in trace) return short;
+  }
+  return null;
+}
+function runtimeToHandleValue(value, current) {
+  if (typeof current === "boolean") {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "number") return value !== 0;
+    if (isRuntimeString(value) || isRuntimeChar(value)) {
+      const s = (isRuntimeChar(value) ? value.value : value).toLowerCase();
+      return !(s === "off" || s === "false" || s === "0");
+    }
+    return true;
+  }
+  if (typeof current === "string") {
+    return isRuntimeChar(value) ? value.value : isRuntimeString(value) ? value : String(value);
+  }
+  if (typeof current === "number" || current === void 0) {
+    if (typeof value === "number") return value;
+    if (isRuntimeNumber(value)) return value;
+  }
+  if (Array.isArray(current) && isRuntimeTensor(value)) {
+    return Array.from(value.data);
+  }
+  return value;
+}
 function getRTValueField(base, field) {
   if (isRuntimeStruct(base) || isRuntimeClassInstance(base)) {
     const val = base.fields.get(field);
@@ -23360,6 +23417,15 @@ function getRTValueField(base, field) {
     });
     return horzcat(...values);
   }
+  if (isRuntimeGraphicsHandle(base)) {
+    const key = resolveHandleKey(base._trace, field);
+    if (key !== null) return handlePropToRuntime(base._trace[key]);
+    const dflt = HANDLE_DEFAULTS[base._traceType]?.[field];
+    if (dflt !== void 0) return handlePropToRuntime(dflt);
+    throw new RuntimeError(
+      `No property '${field}' on ${base._traceType} handle`
+    );
+  }
   throw new RuntimeError(`Cannot access field ${field} on ${kstr(base)}`);
 }
 function setRTValueField(base, field, value, rt) {
@@ -23404,6 +23470,12 @@ function setRTValueField(base, field, value, rt) {
       `Cannot assign field '${field}' on a non-scalar struct array without indexing`
     );
   }
+  if (isRuntimeGraphicsHandle(base)) {
+    const key = resolveHandleKey(base._trace, field) ?? field.charAt(0).toLowerCase() + field.slice(1);
+    const current = base._trace[key] ?? HANDLE_DEFAULTS[base._traceType]?.[field];
+    base._trace[key] = runtimeToHandleValue(value, current);
+    return base;
+  }
   if (isRuntimeNumber(base) && base === 0) {
     return RTV.struct(/* @__PURE__ */ new Map([[field, value]]));
   }
@@ -24669,12 +24741,24 @@ function transposeCore(v, conjugate) {
   if (v._isLogical) t._isLogical = true;
   return t;
 }
+function transposeClassInstanceArray(v) {
+  const [r, c] = v.shape;
+  const out = new Array(v.elements.length);
+  for (let i = 0; i < r; i++) {
+    for (let j = 0; j < c; j++) {
+      out[i * c + j] = v.elements[j * r + i];
+    }
+  }
+  return new RuntimeClassInstanceArray(v.className, out, [c, r]);
+}
 function mTranspose(v) {
   if (isRuntimeSparseMatrix(v)) return sparseTranspose(v);
   if (isRuntimeComplexNumber(v)) return v;
   if (isRuntimeNumber(v) || isRuntimeLogical(v)) return v;
   if (isRuntimeCell(v)) return transposeCellArray(v);
   if (isRuntimeChar(v)) return v;
+  if (isRuntimeClassInstance(v)) return v;
+  if (isRuntimeClassInstanceArray(v)) return transposeClassInstanceArray(v);
   if (!isRuntimeTensor(v))
     throw new RuntimeError("Cannot transpose non-numeric value");
   return transposeCore(v, false);
@@ -24685,6 +24769,8 @@ function mConjugateTranspose(v) {
   if (isRuntimeNumber(v) || isRuntimeLogical(v)) return v;
   if (isRuntimeCell(v)) return transposeCellArray(v);
   if (isRuntimeChar(v)) return v;
+  if (isRuntimeClassInstance(v)) return v;
+  if (isRuntimeClassInstanceArray(v)) return transposeClassInstanceArray(v);
   if (!isRuntimeTensor(v))
     throw new RuntimeError("Cannot transpose non-numeric value");
   return transposeCore(v, true);
@@ -31042,6 +31128,12 @@ function parseContourArgs(args, filled) {
   let rows;
   let cols;
   let nLevels = 10;
+  let levels;
+  const applyLevelArg = (arg) => {
+    const vals = toNumberArray(arg);
+    if (vals.length <= 1) nLevels = vals.length === 1 ? vals[0] : nLevels;
+    else levels = vals;
+  };
   if (numericCount === 1) {
     const info = getMatrixInfo(args[pos++]);
     rows = info.rows;
@@ -31055,8 +31147,7 @@ function parseContourArgs(args, filled) {
     rows = info.rows;
     cols = info.cols;
     zData = info.data;
-    nLevels = typeof args[pos] === "number" ? args[pos] : toNumber(args[pos]);
-    pos++;
+    applyLevelArg(args[pos++]);
     const gen = generateMeshgrid(rows, cols);
     xData = gen.x;
     yData = gen.y;
@@ -31077,15 +31168,144 @@ function parseContourArgs(args, filled) {
     rows = zInfo.rows;
     cols = zInfo.cols;
     zData = zInfo.data;
-    nLevels = typeof args[pos] === "number" ? args[pos] : toNumber(args[pos]);
-    pos++;
+    applyLevelArg(args[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 };
+  let lineWidth;
+  let lineStyle;
+  let lineColor;
+  for (; pos + 1 < args.length; pos += 2) {
+    if (!isStringArg(args[pos])) break;
+    const name = getStringValue(args[pos]).toLowerCase();
+    const val = args[pos + 1];
+    switch (name) {
+      case "linewidth":
+        lineWidth = toNumber(val);
+        break;
+      case "linestyle":
+        lineStyle = getStringValue(val);
+        break;
+      case "linecolor":
+      case "color":
+        lineColor = isStringArg(val) ? getStringValue(val) : toNumberArray(val);
+        break;
+      case "levellist":
+      case "levels": {
+        const vals = toNumberArray(val);
+        if (vals.length >= 1) levels = vals;
+        break;
+      }
+    }
+  }
+  if (levels) nLevels = levels.length;
+  return {
+    x: xData,
+    y: yData,
+    z: zData,
+    rows,
+    cols,
+    nLevels,
+    ...levels ? { levels } : {},
+    ...lineWidth !== void 0 ? { lineWidth } : {},
+    ...lineStyle !== void 0 ? { lineStyle } : {},
+    ...lineColor !== void 0 ? { lineColor } : {},
+    filled
+  };
+}
+function marchingSquaresCell(z00, z10, z01, z11, x00, y00, x10, y10, x01, y01, x11, y11, level) {
+  const code = (z00 >= level ? 1 : 0) | (z10 >= level ? 2 : 0) | (z01 >= level ? 4 : 0) | (z11 >= level ? 8 : 0);
+  if (code === 0 || code === 15) return [];
+  const lerp = (a, b, za, zb) => a + (level - za) / (zb - za || 1) * (b - a);
+  const bx = lerp(x00, x10, z00, z10), by = lerp(y00, y10, z00, z10);
+  const rx = lerp(x10, x11, z10, z11), ry = lerp(y10, y11, z10, z11);
+  const tx = lerp(x01, x11, z01, z11), ty = lerp(y01, y11, z01, z11);
+  const lx = lerp(x00, x01, z00, z01), ly = lerp(y00, y01, z00, z01);
+  const segs = [];
+  switch (code) {
+    case 1:
+    case 14:
+      segs.push([bx, by, lx, ly]);
+      break;
+    case 2:
+    case 13:
+      segs.push([bx, by, rx, ry]);
+      break;
+    case 3:
+    case 12:
+      segs.push([lx, ly, rx, ry]);
+      break;
+    case 4:
+    case 11:
+      segs.push([lx, ly, tx, ty]);
+      break;
+    case 5:
+    case 10:
+      segs.push([bx, by, tx, ty]);
+      break;
+    case 6:
+    case 9:
+      segs.push([bx, by, lx, ly]);
+      segs.push([tx, ty, rx, ry]);
+      break;
+    case 7:
+    case 8:
+      segs.push([tx, ty, rx, ry]);
+      break;
+  }
+  return segs;
+}
+function computeContourMatrix(trace) {
+  const { x, y, z, rows, cols } = trace;
+  const at = (a, i, j) => a[j * rows + i];
+  let zMin = Infinity;
+  let zMax = -Infinity;
+  for (const v of z) {
+    if (Number.isFinite(v)) {
+      if (v < zMin) zMin = v;
+      if (v > zMax) zMax = v;
+    }
+  }
+  let levelList;
+  if (trace.levels && trace.levels.length > 0) {
+    levelList = trace.levels.filter((v) => Number.isFinite(v));
+  } else {
+    const n = Math.max(1, Math.round(trace.nLevels));
+    levelList = [];
+    if (Number.isFinite(zMin) && Number.isFinite(zMax) && zMax > zMin) {
+      const step = (zMax - zMin) / (n + 1);
+      for (let k = 1; k <= n; k++) levelList.push(zMin + k * step);
+    }
+  }
+  const data = [];
+  for (const level of levelList) {
+    for (let j = 0; j < cols - 1; j++) {
+      for (let i = 0; i < rows - 1; i++) {
+        const segs = marchingSquaresCell(
+          at(z, i, j),
+          at(z, i + 1, j),
+          at(z, i, j + 1),
+          at(z, i + 1, j + 1),
+          at(x, i, j),
+          at(y, i, j),
+          at(x, i + 1, j),
+          at(y, i + 1, j),
+          at(x, i, j + 1),
+          at(y, i, j + 1),
+          at(x, i + 1, j + 1),
+          at(y, i + 1, j + 1),
+          level
+        );
+        for (const [x1, y1, x2, y2] of segs) {
+          data.push(level, 2, x1, y1, x2, y2);
+        }
+      }
+    }
+  }
+  return { data, n: data.length / 2, levelList };
 }
 function parseMeshArgs(args) {
   const trace = parseSurfArgs(args);
@@ -32033,6 +32253,213 @@ function computeQuiverAutoScale(x, y, u, v, rows, cols, factor) {
   if (maxMag === 0) return 1;
   return factor * spacing / maxMag;
 }
+function parseQuiver3Args(args) {
+  if (args.length < 4) throw new Error("quiver3 requires at least 4 arguments");
+  let numericCount = 0;
+  for (let i = 0; i < args.length; i++) {
+    if (isNumericArg(args[i])) numericCount++;
+    else break;
+  }
+  let pos = 0;
+  let xData;
+  let yData;
+  let zData;
+  let uData;
+  let vData;
+  let wData;
+  let rows;
+  let cols;
+  const arity = numericCount >= 6 ? 6 : 4;
+  if (arity === 4) {
+    const zInfo = getMatrixInfo(args[pos++]);
+    rows = zInfo.rows;
+    cols = zInfo.cols;
+    zData = zInfo.data;
+    uData = getMatrixInfo(args[pos++]).data;
+    vData = getMatrixInfo(args[pos++]).data;
+    wData = getMatrixInfo(args[pos++]).data;
+    const n = zData.length;
+    if (rows === 1 || cols === 1) {
+      xData = new Array(n);
+      yData = new Array(n);
+      for (let i = 0; i < n; i++) {
+        xData[i] = i + 1;
+        yData[i] = 1;
+      }
+    } else {
+      const gen = generateMeshgrid(rows, n / rows);
+      xData = gen.x;
+      yData = gen.y;
+    }
+  } else {
+    const X = args[pos++];
+    const Y = args[pos++];
+    const zInfo = getMatrixInfo(args[pos++]);
+    rows = zInfo.rows;
+    cols = zInfo.cols;
+    zData = zInfo.data;
+    uData = getMatrixInfo(args[pos++]).data;
+    vData = getMatrixInfo(args[pos++]).data;
+    wData = getMatrixInfo(args[pos++]).data;
+    const n = uData.length;
+    const xFlat = toNumberArray(X);
+    const yFlat = toNumberArray(Y);
+    if (xFlat.length === n && yFlat.length === n) {
+      xData = xFlat;
+      yData = yFlat;
+    } else {
+      const expanded = expandXY(X, Y, rows, cols);
+      xData = expanded.x;
+      yData = expanded.y;
+    }
+  }
+  let autoScale = true;
+  let autoScaleFactor = 0.9;
+  let reportedASF = 0.9;
+  if (pos < args.length && isNumericArg(args[pos]) && !isStringArg(args[pos])) {
+    const s = toNumber(args[pos]);
+    if (s === 0) {
+      autoScale = false;
+    } else {
+      autoScaleFactor = s * 0.9;
+      reportedASF = s;
+    }
+    pos++;
+  }
+  const trace = {
+    x: xData,
+    y: yData,
+    z: zData,
+    u: uData,
+    v: vData,
+    w: wData,
+    showArrowHead: true
+  };
+  while (pos < args.length && isStringArg(args[pos]) && !isQuiverNameValueKey(args[pos])) {
+    const s = getStringIfString(args[pos]);
+    if (s === void 0) break;
+    if (s === "off") {
+      autoScale = false;
+      pos++;
+      continue;
+    }
+    if (s === "filled") {
+      trace.markerFilled = true;
+      pos++;
+      continue;
+    }
+    const spec = parseLineSpec(s);
+    if (spec) {
+      if (spec.color) trace.color = COLOR_SHORT[spec.color];
+      if (spec.lineStyle) trace.lineStyle = spec.lineStyle;
+      if (spec.marker) {
+        trace.marker = spec.marker;
+        trace.showArrowHead = false;
+      }
+      pos++;
+      continue;
+    }
+    const c = resolveColor(s);
+    if (c) {
+      trace.color = c;
+      pos++;
+      continue;
+    }
+    break;
+  }
+  while (pos < args.length) {
+    const key = isQuiverNameValueKey(args[pos]);
+    if (!key) break;
+    pos++;
+    if (pos >= args.length) break;
+    const value = args[pos++];
+    switch (key) {
+      case "color": {
+        const c = resolveColor(value);
+        if (c) trace.color = c;
+        break;
+      }
+      case "linestyle":
+        trace.lineStyle = getStringValue(value);
+        break;
+      case "linewidth":
+        trace.lineWidth = typeof value === "number" ? value : toNumber(value);
+        break;
+      case "marker": {
+        const s = getStringValue(value);
+        trace.marker = s === "none" ? void 0 : s;
+        break;
+      }
+      case "showarrowhead": {
+        const s = getStringValue(value).toLowerCase();
+        trace.showArrowHead = !(s === "off" || s === "false" || s === "0");
+        break;
+      }
+      case "autoscale": {
+        const s = getStringValue(value).toLowerCase();
+        autoScale = !(s === "off" || s === "false" || s === "0");
+        break;
+      }
+      case "autoscalefactor": {
+        const n = typeof value === "number" ? value : toNumber(value);
+        autoScaleFactor = n * 0.9;
+        reportedASF = n;
+        break;
+      }
+    }
+  }
+  trace.autoScale = autoScale;
+  trace.autoScaleFactor = reportedASF;
+  if (autoScale) {
+    const factor = computeQuiver3AutoScale(
+      xData,
+      yData,
+      zData,
+      uData,
+      vData,
+      wData,
+      autoScaleFactor
+    );
+    if (factor !== 1) {
+      trace.u = uData.map((x) => x * factor);
+      trace.v = vData.map((x) => x * factor);
+      trace.w = wData.map((x) => x * factor);
+    }
+  }
+  return trace;
+}
+function computeQuiver3AutoScale(x, y, z, u, v, w, factor) {
+  const n = u.length;
+  if (n === 0) return 1;
+  const range2 = (a) => {
+    let lo = Infinity;
+    let hi = -Infinity;
+    for (const t of a) {
+      if (isFinite(t)) {
+        if (t < lo) lo = t;
+        if (t > hi) hi = t;
+      }
+    }
+    return hi > lo ? hi - lo : 0;
+  };
+  const xr = range2(x);
+  const yr = range2(y);
+  const zr = range2(z);
+  const dims = [xr, yr, zr].filter((d) => d > 0);
+  let spacing;
+  if (dims.length === 3) spacing = Math.cbrt(xr * yr * zr / n);
+  else if (dims.length === 2) spacing = Math.sqrt(dims[0] * dims[1] / n);
+  else if (dims.length === 1) spacing = dims[0] / Math.max(1, n - 1);
+  else spacing = 1;
+  spacing = spacing || 1;
+  let maxMag = 0;
+  for (let i = 0; i < n; i++) {
+    const m = Math.sqrt(u[i] * u[i] + v[i] * v[i] + w[i] * w[i]);
+    if (isFinite(m) && m > maxMag) maxMag = m;
+  }
+  if (maxMag === 0) return 1;
+  return factor * spacing / maxMag;
+}
 
 // src/numbl-core/runtime/syncChannel.ts
 var syncSleepWarned = false;
@@ -32124,6 +32551,9 @@ function plotInstr(plotInstructions, instr) {
     case "clf":
       plotInstructions.push({ type: instr.type });
       break;
+    case "cla":
+      plotInstructions.push({ type: "cla", reset: instr.reset });
+      break;
     case "set_subplot":
       plotInstructions.push({
         type: "set_subplot",
@@ -32208,6 +32638,10 @@ function surfCall(plotInstructions, args) {
   const trace = parseSurfArgs(args);
   plotInstructions.push({ type: "surf", trace });
 }
+function surfaceCall(plotInstructions, args) {
+  const trace = parseSurfArgs(args);
+  plotInstructions.push({ type: "surface", trace });
+}
 function imagescCall(plotInstructions, args) {
   const trace = parseImagescArgs(args);
   plotInstructions.push({ type: "imagesc", trace });
@@ -32460,6 +32894,10 @@ function quiverCall(plotInstructions, args) {
     plotInstructions.push({ type: "quiver", traces });
   }
 }
+function quiver3Call(plotInstructions, args) {
+  const trace = parseQuiver3Args(args);
+  plotInstructions.push({ type: "quiver3", trace });
+}
 function legendCall(plotInstructions, args) {
   const labels = [];
   for (let i = 0; i < args.length; i++) {
@@ -32708,6 +33146,9 @@ function dispatchPlotBuiltin(name, args, instructions, state) {
     case "surf":
       surfCall(instructions, args);
       return true;
+    case "surface":
+      surfaceCall(instructions, args);
+      return true;
     case "scatter":
       scatterCall(instructions, args);
       return true;
@@ -32787,6 +33228,9 @@ function dispatchPlotBuiltin(name, args, instructions, state) {
     case "quiver":
       quiverCall(instructions, args);
       return true;
+    case "quiver3":
+      quiver3Call(instructions, args);
+      return true;
     case "view":
       viewCall(instructions, args);
       return true;
@@ -32852,6 +33296,18 @@ function dispatchPlotBuiltin(name, args, instructions, state) {
     case "clf":
       plotInstr(instructions, { type: "clf" });
       return true;
+    case "cla": {
+      let reset = false;
+      for (const a of args) {
+        try {
+          if (toString(a).toLowerCase().replace(/^["']|["']$/g, "") === "reset")
+            reset = true;
+        } catch {
+        }
+      }
+      plotInstr(instructions, { type: "cla", reset });
+      return true;
+    }
     case "shading": {
       if (args.length > 0) {
         plotInstr(instructions, { type: "set_shading", shading: args[0] });
@@ -33029,6 +33485,7 @@ var PLOT_DISPATCH_NAMES = [
   "plot",
   "plot3",
   "surf",
+  "surface",
   "scatter",
   "imagesc",
   "pcolor",
@@ -33056,6 +33513,7 @@ var PLOT_DISPATCH_NAMES = [
   "donutchart",
   "heatmap",
   "quiver",
+  "quiver3",
   "view",
   "legend",
   "figure",
@@ -33071,6 +33529,7 @@ var PLOT_DISPATCH_NAMES = [
   "grid",
   "close",
   "clf",
+  "cla",
   "shading",
   "colorbar",
   "colormap",
@@ -33128,7 +33587,8 @@ var PLOT_DISPATCH_NAMES_JIT = /* @__PURE__ */ new Set([
   "piechart",
   "donutchart",
   "heatmap",
-  "quiver"
+  "quiver",
+  "quiver3"
 ]);
 function dispatchPlotCall(rt, name, args) {
   if (PLOT_DISPATCH_NAMES_JIT.has(name)) {
@@ -34497,45 +34957,70 @@ function classInstanceParenIndex(rt, mv, base, indices, nargout, skipSubsref) {
   }
   throw new RuntimeError(`Index exceeds class instance dimensions`);
 }
+function resolveObjSubscript(raw, dimSize) {
+  if (raw === COLON_SENTINEL) {
+    return Array.from({ length: dimSize }, (_, i) => i);
+  }
+  if (typeof raw === "number") return [Math.round(raw) - 1];
+  const rv = ensureRuntimeValue(raw);
+  if (isRuntimeNumber(rv)) return [Math.round(toNumber(rv)) - 1];
+  if (isRuntimeLogical(rv)) return rv ? [0] : [];
+  if (isRuntimeTensor(rv)) {
+    if (rv._isLogical) {
+      const out = [];
+      for (let k = 0; k < rv.data.length; k++) if (rv.data[k]) out.push(k);
+      return out;
+    }
+    return Array.from(rv.data, (x) => Math.round(x) - 1);
+  }
+  throw new RuntimeError("Invalid index type for class instance array");
+}
+function makeObjResult(className, elements, shape) {
+  if (elements.length === 1) return elements[0];
+  return {
+    kind: "class_instance_array",
+    className,
+    elements,
+    shape
+  };
+}
 function classInstanceArrayParenIndex(mv, indices) {
+  const [rows, cols] = mv.shape;
+  const total = mv.elements.length;
+  if (indices.length === 2) {
+    const ri = resolveObjSubscript(indices[0], rows);
+    const ci = resolveObjSubscript(indices[1], cols);
+    const selected2 = [];
+    for (const j of ci) {
+      if (j < 0 || j >= cols)
+        throw new RuntimeError("Index exceeds array bounds");
+      for (const i of ri) {
+        if (i < 0 || i >= rows)
+          throw new RuntimeError("Index exceeds array bounds");
+        selected2.push(mv.elements[j * rows + i]);
+      }
+    }
+    return makeObjResult(mv.className, selected2, [ri.length, ci.length]);
+  }
   if (indices.length !== 1) {
     throw new RuntimeError(
-      "Class instance arrays only support single-subscript indexing"
+      "Class instance arrays support one- or two-subscript indexing"
     );
   }
   const idx = indices[0];
   if (idx === COLON_SENTINEL) {
-    return mv;
+    return makeObjResult(mv.className, mv.elements.slice(), [total, 1]);
   }
-  if (typeof idx === "number") {
-    const i = Math.round(idx) - 1;
-    if (i < 0 || i >= mv.elements.length)
+  const linear = resolveObjSubscript(idx, total);
+  const selected = [];
+  for (const i of linear) {
+    if (i < 0 || i >= total)
       throw new RuntimeError("Index exceeds array bounds");
-    return mv.elements[i];
-  }
-  const rv = ensureRuntimeValue(idx);
-  if (isRuntimeLogical(rv)) {
-    const i = rv ? 0 : -1;
-    if (i < 0 || i >= mv.elements.length)
-      throw new RuntimeError("Index exceeds array bounds");
-    return mv.elements[i];
-  }
-  if (isRuntimeTensor(rv)) {
-    const selected = [];
-    for (let k = 0; k < rv.data.length; k++) {
-      const i = Math.round(rv.data[k]) - 1;
-      if (i < 0 || i >= mv.elements.length)
-        throw new RuntimeError("Index exceeds array bounds");
-      selected.push(mv.elements[i]);
-    }
-    if (selected.length === 1) return selected[0];
-    return {
-      kind: "class_instance_array",
-      className: mv.className,
-      elements: selected
-    };
+    selected.push(mv.elements[i]);
   }
-  throw new RuntimeError("Invalid index type for class instance array");
+  const isColumn = cols === 1 && rows !== 1;
+  const shape = isColumn ? [selected.length, 1] : [1, selected.length];
+  return makeObjResult(mv.className, selected, shape);
 }
 function resolveIndicesForClassInstance(rt, mv, base, indices) {
   const numIndices = indices.length;
@@ -35479,6 +35964,13 @@ for (const name of ["groot", "gcf", "gca", "shg", "newplot"]) {
     })
   });
 }
+registerIBuiltin({
+  name: "camlight",
+  resolve: () => ({
+    outputTypes: [{ kind: "unknown" }],
+    apply: (_args, nargout) => nargout >= 1 ? RTV.dummyHandle() : void 0
+  })
+});
 registerIBuiltin({
   name: "get",
   resolve: () => ({
@@ -35633,7 +36125,6 @@ registerIBuiltin({
   })
 });
 for (const cm of [
-  "parula",
   "jet",
   "hsv",
   "hot",
@@ -35655,6 +36146,44 @@ for (const cm of [
     })
   });
 }
+var PARULA_ANCHORS = [
+  [0.2422, 0.1504, 0.6603],
+  [0.278, 0.3556, 0.9777],
+  [0.1085, 0.5267, 0.8943],
+  [0.0469, 0.6353, 0.7861],
+  [0.2161, 0.7269, 0.6499],
+  [0.5044, 0.7993, 0.4519],
+  [0.8328, 0.8056, 0.2008],
+  [0.9871, 0.8092, 0.1432],
+  [0.9763, 0.9831, 0.0538]
+];
+function parulaColormap(m) {
+  const data = allocFloat64Array(m * 3);
+  const last = PARULA_ANCHORS.length - 1;
+  for (let i = 0; i < m; i++) {
+    const t = m <= 1 ? 0 : i / (m - 1) * last;
+    const k = Math.min(last - 1, Math.floor(t));
+    const f = t - k;
+    const a = PARULA_ANCHORS[k];
+    const b = PARULA_ANCHORS[Math.min(last, k + 1)];
+    for (let c = 0; c < 3; c++) {
+      data[c * m + i] = a[c] + f * (b[c] - a[c]);
+    }
+  }
+  return RTV.tensor(data, [m, 3]);
+}
+registerIBuiltin({
+  name: "parula",
+  resolve: () => ({
+    outputTypes: [{ kind: "unknown" }],
+    apply: (args) => {
+      if (args.length >= 1 && (isRuntimeNumber(args[0]) || isRuntimeTensor(args[0]))) {
+        return parulaColormap(Math.max(0, Math.round(toNumber(args[0]))));
+      }
+      return RTV.char("parula");
+    }
+  })
+});
 var appdataStore = /* @__PURE__ */ new Map();
 function resetAppdataStore() {
   const rt = getCurrentRuntime();
@@ -36512,6 +37041,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "plot",
   "plot3",
   "surf",
+  "surface",
   "scatter",
   "imagesc",
   "pcolor",
@@ -36541,6 +37071,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "donutchart",
   "heatmap",
   "quiver",
+  "quiver3",
   "streamline",
   "stream2",
   "ishold",
@@ -36558,6 +37089,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "sgtitle",
   "shading",
   "clf",
+  "cla",
   "colormap",
   "view",
   "zlabel",
@@ -37450,13 +37982,21 @@ function registerSpecialBuiltins(rt) {
     }
   });
   registerSpecialVoid("delete", (args) => {
-    const io = requireFileIO();
-    if (!io.deleteFile)
-      throw new RuntimeError("delete is not available in this environment");
     const margs = args.map((a) => ensureRuntimeValue(a));
     if (margs.length < 1)
       throw new RuntimeError("delete requires at least 1 argument");
     for (const arg of margs) {
+      if (isRuntimeGraphicsHandle(arg)) {
+        const instr = arg._trace.__instruction;
+        if (instr) {
+          const idx = rt.plotInstructions.indexOf(instr);
+          if (idx >= 0) rt.plotInstructions.splice(idx, 1);
+        }
+        continue;
+      }
+      const io = requireFileIO();
+      if (!io.deleteFile)
+        throw new RuntimeError("delete is not available in this environment");
       io.deleteFile(toString(arg));
     }
   });
@@ -37925,7 +38465,7 @@ function registerSpecialBuiltins(rt) {
       return nargout >= 1 ? RTV.num(1) : void 0;
     });
   }
-  const PLOT_VOID = ["hold", "grid", "shading"];
+  const PLOT_VOID = ["hold", "grid", "shading", "cla"];
   for (const name of PLOT_VOID) {
     registerSpecialVoid(name, (args) => {
       dispatchPlotBuiltin(
@@ -39088,6 +39628,43 @@ var Runtime = class _Runtime {
         return RTV.dummyHandle();
       }
     };
+    const contourOverride = (filled) => (_nargout, args) => {
+      const margs = args.map((a) => ensureRuntimeValue(a));
+      contourCall(this.plotInstructions, margs, filled);
+      if (_nargout < 1) return void 0;
+      const last = this.plotInstructions[this.plotInstructions.length - 1];
+      if (!last || last.type !== "contour") return RTV.dummyHandle();
+      const trace = last.trace;
+      const cm = computeContourMatrix(trace);
+      const C = RTV.tensor(allocFloat64Array(cm.data), [2, cm.n]);
+      if (_nargout < 2) return C;
+      const H2 = RTV.graphicsHandle(
+        {
+          LineWidth: trace.lineWidth ?? 0.5,
+          LineStyle: trace.lineStyle ?? "-",
+          LineColor: trace.lineColor ?? "flat",
+          LevelList: cm.levelList,
+          __instruction: last
+        },
+        "contour"
+      );
+      return [C, H2];
+    };
+    this.builtins["contour"] = contourOverride(false);
+    this.builtins["contourf"] = contourOverride(true);
+    this.builtins["quiver3"] = (_nargout, args) => {
+      const margs = args.map((a) => ensureRuntimeValue(a));
+      quiver3Call(this.plotInstructions, margs);
+      if (_nargout < 1) return void 0;
+      const last = this.plotInstructions[this.plotInstructions.length - 1];
+      if (last && last.type === "quiver3") {
+        return RTV.graphicsHandle(
+          last.trace,
+          "quiver3"
+        );
+      }
+      return RTV.dummyHandle();
+    };
     this.builtins["fplot"] = (_nargout, args) => {
       fplotCall(this, this.plotInstructions, args.map(ensureRuntimeValue));
     };
@@ -39635,14 +40212,15 @@ var Runtime = class _Runtime {
   transpose(v) {
     if (typeof v !== "number") {
       const mv = ensureRuntimeValue(v);
-      if (isRuntimeClassInstance(mv)) return this.dispatch("transpose", 1, [v]);
+      if (isRuntimeClassInstance(mv) || isRuntimeClassInstanceArray(mv))
+        return this.dispatch("transpose", 1, [v]);
     }
     return transpose(v);
   }
   ctranspose(v) {
     if (typeof v !== "number") {
       const mv = ensureRuntimeValue(v);
-      if (isRuntimeClassInstance(mv))
+      if (isRuntimeClassInstance(mv) || isRuntimeClassInstanceArray(mv))
         return this.dispatch("ctranspose", 1, [v]);
     }
     return ctranspose(v);
@@ -39726,7 +40304,9 @@ var Runtime = class _Runtime {
     const mvals = flat.map(
       (e) => typeof e === "number" ? null : ensureRuntimeValue(e)
     );
-    if (mvals.some((v) => v && isRuntimeClassInstance(v))) {
+    if (mvals.some(
+      (v) => v && (isRuntimeClassInstance(v) || isRuntimeClassInstanceArray(v))
+    )) {
       if (this._classHasMethod(mvals, "horzcat")) {
         return this.dispatch("horzcat", 1, flat);
       }
@@ -39739,7 +40319,9 @@ var Runtime = class _Runtime {
     const mvals = rows.map(
       (r) => typeof r === "number" ? null : ensureRuntimeValue(r)
     );
-    if (mvals.some((v) => v && isRuntimeClassInstance(v))) {
+    if (mvals.some(
+      (v) => v && (isRuntimeClassInstance(v) || isRuntimeClassInstanceArray(v))
+    )) {
       if (this._classHasMethod(mvals, "vertcat")) {
         return this.dispatch("vertcat", 1, rows);
       }
@@ -39751,7 +40333,7 @@ var Runtime = class _Runtime {
   _classHasMethod(mvals, methodName) {
     if (!this.resolveClassMethod) return false;
     for (const v of mvals) {
-      if (v && isRuntimeClassInstance(v)) {
+      if (v && (isRuntimeClassInstance(v) || isRuntimeClassInstanceArray(v))) {
         if (this.resolveClassMethod(v.className, methodName) !== null) {
           return true;
         }
@@ -40062,31 +40644,66 @@ function buildStackField(e) {
   }
   return RTV.structArray(fieldNames, elements);
 }
-function collectClassInstances(items) {
-  const out = [];
-  for (const item of items) {
-    const rv = ensureRuntimeValue(item);
-    if (isRuntimeClassInstance(rv)) {
-      out.push(rv);
-    } else if (isRuntimeClassInstanceArray(rv)) {
-      out.push(...rv.elements);
-    } else {
+function asObjArrayParts(item) {
+  const rv = ensureRuntimeValue(item);
+  if (isRuntimeClassInstance(rv))
+    return { rows: 1, cols: 1, elements: [rv], className: rv.className };
+  if (isRuntimeClassInstanceArray(rv))
+    return {
+      rows: rv.shape[0],
+      cols: rv.shape[1],
+      elements: rv.elements,
+      className: rv.className
+    };
+  if (isRuntimeTensor(rv) && rv.data.length === 0) return null;
+  throw new RuntimeError(`Cannot concatenate ${kstr(rv)} with class instances`);
+}
+function objColumn(p2, j) {
+  return p2.elements.slice(j * p2.rows, j * p2.rows + p2.rows);
+}
+function defaultClassInstanceHorzcat(items) {
+  const parts = items.map(asObjArrayParts).filter((p2) => p2 !== null && p2.elements.length > 0);
+  if (parts.length === 0)
+    throw new RuntimeError("Cannot concatenate empty class instances");
+  const rows = parts[0].rows;
+  let cols = 0;
+  const elements = [];
+  for (const p2 of parts) {
+    if (p2.rows !== rows)
       throw new RuntimeError(
-        `Cannot concatenate ${kstr(rv)} with class instances`
+        "Dimensions of arrays being concatenated are not consistent"
       );
-    }
+    elements.push(...p2.elements);
+    cols += p2.cols;
   }
-  return out;
-}
-function defaultClassInstanceHorzcat(items) {
-  const elements = collectClassInstances(items);
   if (elements.length === 1) return elements[0];
-  return new RuntimeClassInstanceArray(elements[0].className, elements);
+  return new RuntimeClassInstanceArray(parts[0].className, elements, [
+    rows,
+    cols
+  ]);
 }
 function defaultClassInstanceVertcat(rows) {
-  const elements = collectClassInstances(rows);
+  const parts = rows.map(asObjArrayParts).filter((p2) => p2 !== null && p2.elements.length > 0);
+  if (parts.length === 0)
+    throw new RuntimeError("Cannot concatenate empty class instances");
+  const cols = parts[0].cols;
+  let totalRows = 0;
+  for (const p2 of parts) {
+    if (p2.cols !== cols)
+      throw new RuntimeError(
+        "Dimensions of arrays being concatenated are not consistent"
+      );
+    totalRows += p2.rows;
+  }
+  const elements = [];
+  for (let j = 0; j < cols; j++) {
+    for (const p2 of parts) elements.push(...objColumn(p2, j));
+  }
   if (elements.length === 1) return elements[0];
-  return new RuntimeClassInstanceArray(elements[0].className, elements);
+  return new RuntimeClassInstanceArray(parts[0].className, elements, [
+    totalRows,
+    cols
+  ]);
 }
 
 // src/numbl-core/helpers/reduction-helpers.ts
@@ -41598,7 +42215,7 @@ function getShape(v) {
   if (isRuntimeSparseMatrix(v)) return [v.m, v.n];
   if (isRuntimeCell(v)) return v.shape;
   if (isRuntimeStructArray(v)) return [1, v.elements.length];
-  if (isRuntimeClassInstanceArray(v)) return [1, v.elements.length];
+  if (isRuntimeClassInstanceArray(v)) return [...v.shape];
   return [1, 1];
 }
 defineBuiltin({
@@ -41776,7 +42393,8 @@ defineBuiltin({
         }
         if (isRuntimeString(v)) return 1;
         if (isRuntimeStructArray(v)) return v.elements.length;
-        if (isRuntimeClassInstanceArray(v)) return v.elements.length;
+        if (isRuntimeClassInstanceArray(v))
+          return v.elements.length === 0 ? 0 : Math.max(...v.shape);
         return 1;
       }
     }
@@ -41889,8 +42507,15 @@ defineBuiltin({
         if (isRuntimeClassInstanceArray(v)) return mkChar(v.className);
         if (isRuntimeFunction(v)) return mkChar("function_handle");
         if (isRuntimeDummyHandle(v)) return mkChar("dummy_handle");
-        if (isRuntimeGraphicsHandle(v))
-          return mkChar("matlab.graphics.primitive.Surface");
+        if (isRuntimeGraphicsHandle(v)) {
+          const handleClass = {
+            contour: "matlab.graphics.chart.primitive.Contour",
+            quiver3: "matlab.graphics.chart.primitive.Quiver"
+          };
+          return mkChar(
+            handleClass[v._traceType] ?? "matlab.graphics.primitive.Surface"
+          );
+        }
         return mkChar("unknown");
       }
     }
@@ -46931,6 +47556,7 @@ defineBuiltin({
         const blocks = args.map((a) => {
           if (isRuntimeNumber(a))
             return RTV.tensor(allocFloat64Array([a]), [1, 1]);
+          if (isRuntimeSparseMatrix(a)) return sparseToDense(a);
           if (!isRuntimeTensor(a))
             throw new RuntimeError("blkdiag: arguments must be numeric");
           return a;
@@ -48299,6 +48925,21 @@ defineBuiltin({
           const shape = reps.length >= 2 ? reps : [reps[0], reps[0]];
           return RTV.tensor(data, shape, imag2);
         }
+        if (isRuntimeCell(v)) {
+          const srcShape2 = v.shape.length >= 2 ? v.shape : [1, v.shape[0] ?? v.data.length];
+          const [sm, sn] = [srcShape2[0], srcShape2[1]];
+          const r0 = reps[0] ?? 1;
+          const r1 = reps.length >= 2 ? reps[1] : reps[0] ?? 1;
+          const om = sm * r0;
+          const on = sn * r1;
+          const out2 = new Array(om * on);
+          for (let J = 0; J < on; J++) {
+            for (let I = 0; I < om; I++) {
+              out2[I + J * om] = v.data[I % sm + J % sn * sm];
+            }
+          }
+          return RTV.cell(out2, [om, on]);
+        }
         if (!isRuntimeTensor(v))
           throw new RuntimeError("repmat: first argument must be numeric");
         if (reps.every((r) => r === 1)) {
@@ -55076,6 +55717,10 @@ var H = {
     signatures: ["nexttile", "nexttile(IDX)"],
     description: "Advance to the next tile in the current tiled layout, or move to tile IDX. Auto-creates a flow layout if none exists."
   },
+  surface: {
+    signatures: ["surface(X,Y,Z)", "surface(Z)", "surface(X,Y,Z,C)"],
+    description: "Primitive surface plot. Like surf, but adds to the current axes without clearing existing objects (does not respect hold)."
+  },
   title: {
     signatures: ["title(TXT)"],
     description: "Set title of current axes."
@@ -55112,6 +55757,10 @@ var H = {
     signatures: ["clf"],
     description: "Clear current figure."
   },
+  cla: {
+    signatures: ["cla", "cla(ax)", "cla reset", "cla(ax,'reset')"],
+    description: "Clear current axes. With 'reset', also reset axes properties to defaults."
+  },
   sgtitle: {
     signatures: ["sgtitle(TXT)"],
     description: "Set super-title for subplot grid."
@@ -55164,6 +55813,10 @@ var H = {
     signatures: ["shg"],
     description: "Show current figure."
   },
+  camlight: {
+    signatures: ["camlight", "camlight(position)", "cl = camlight(___)"],
+    description: "Create a light in camera coordinates. Stub in numbl (no lighting model): accepts all arguments and returns a placeholder handle."
+  },
   newplot: {
     signatures: ["newplot"],
     description: "Prepare axes for new plot."
@@ -55689,7 +56342,7 @@ function getSourceLine(getSource, file, line) {
 }
 
 // src/numbl-core/version.ts
-var NUMBL_VERSION = "0.4.0";
+var NUMBL_VERSION = "0.4.1";
 
 // src/cli-repl.ts
 import { createInterface } from "readline";
@@ -59392,16 +60045,27 @@ function callUserFunction(fn, args, nargout, narginOverride) {
   const fnEnv = new Environment();
   fnEnv.rt = this.rt;
   fnEnv.persistentFuncId = `${this.currentFile}:${fn.name}`;
-  const processedArgs = this.processArgumentsBlocks(fn, sharedArgs);
   const hasVarargin = fn.params.length > 0 && fn.params[fn.params.length - 1] === "varargin";
   const regularParams = hasVarargin ? fn.params.slice(0, -1) : fn.params;
-  for (let i = 0; i < regularParams.length; i++) {
-    if (i < processedArgs.length) {
-      fnEnv.set(regularParams[i], ensureRuntimeValue(processedArgs[i]));
+  let numPositional = regularParams.length;
+  const inputBlocks = (fn.argumentsBlocks ?? []).filter(
+    (b) => b.kind !== "Output"
+  );
+  for (const block of inputBlocks) {
+    for (const e of block.entries) {
+      const dot2 = e.name.indexOf(".");
+      if (dot2 < 0) continue;
+      const idx = fn.params.indexOf(e.name.slice(0, dot2));
+      if (idx >= 0 && idx < numPositional) numPositional = idx;
+    }
+  }
+  for (let i = 0; i < numPositional && i < regularParams.length; i++) {
+    if (i < sharedArgs.length && sharedArgs[i] !== void 0) {
+      fnEnv.set(regularParams[i], ensureRuntimeValue(sharedArgs[i]));
     }
   }
   if (hasVarargin) {
-    const extraArgs = processedArgs.slice(regularParams.length).map((a) => ensureRuntimeValue(a));
+    const extraArgs = sharedArgs.slice(regularParams.length).map((a) => ensureRuntimeValue(a));
     fnEnv.set("varargin", RTV.cell(extraArgs, [1, extraArgs.length]));
   }
   fnEnv.set("$nargin", narginOverride ?? args.length);
@@ -59421,6 +60085,7 @@ function callUserFunction(fn, args, nargout, narginOverride) {
   this.rt.pushCallFrame(fn.name);
   this.rt.pushCleanupScope();
   try {
+    this.processArgumentsBlocks(fn, sharedArgs);
     this.execStmts(fn.body);
     if (fnEnv.persistentFuncId) {
       for (const name of fnEnv.persistentNames) {
@@ -59664,12 +60329,13 @@ function findExternalMethod(classInfo, methodName) {
     return null;
   }
   const ast = this.ctx.getCachedAST(mf.fileName);
+  let primary = null;
   for (const stmt of ast.body) {
-    if (stmt.type === "Function" && stmt.name === methodName) {
-      return funcDefFromStmt(stmt);
-    }
+    if (stmt.type !== "Function") continue;
+    if (stmt.name === methodName) return funcDefFromStmt(stmt);
+    if (!primary) primary = funcDefFromStmt(stmt);
   }
-  return null;
+  return primary;
 }
 function collectClassProperties(classInfo) {
   const propertyNames = [...classInfo.propertyNames];
@@ -59743,7 +60409,7 @@ function evalInLocalScope(codeArg, fileName) {
 }
 function processArgumentsBlocks(fn, args) {
   const argBlocks = fn.argumentsBlocks;
-  if (!argBlocks || argBlocks.length === 0) return args;
+  if (!argBlocks || argBlocks.length === 0) return;
   for (const block of argBlocks) {
     if (block.kind === "Output") continue;
     const entries = block.entries;
@@ -59764,48 +60430,27 @@ function processArgumentsBlocks(fn, args) {
       }
       return true;
     });
-    if (nvGroups.size > 0) {
-      const processedArgs2 = [...args];
-      const nvParamIndex = regularEntries.length;
-      for (const [paramName, fields] of nvGroups) {
-        const nvArgs = args.slice(nvParamIndex);
-        const defaults = {};
-        for (const { field, defaultExpr } of fields) {
-          if (defaultExpr) {
-            try {
-              defaults[field] = this.evalExpr(defaultExpr);
-            } catch {
-            }
-          }
-        }
-        const struct = this.rt.buildNameValueStruct(nvArgs, defaults);
-        const paramIdx = fn.params.indexOf(paramName);
-        const targetIdx = paramIdx >= 0 ? paramIdx : nvParamIndex;
-        processedArgs2.length = Math.max(processedArgs2.length, targetIdx + 1);
-        processedArgs2[targetIdx] = struct;
-      }
-      for (let i = 0; i < regularEntries.length; i++) {
-        if (processedArgs2[i] === void 0 && regularEntries[i].defaultValue) {
-          try {
-            processedArgs2[i] = this.evalExpr(regularEntries[i].defaultValue);
-          } catch {
-          }
-        }
+    for (const entry of regularEntries) {
+      const pIdx = fn.params.indexOf(entry.name);
+      if (pIdx < 0) continue;
+      const provided = pIdx < args.length && args[pIdx] !== void 0;
+      if (!provided && entry.defaultValue) {
+        this.env.set(
+          entry.name,
+          ensureRuntimeValue(this.evalExpr(entry.defaultValue))
+        );
       }
-      return processedArgs2;
     }
-    const processedArgs = [...args];
-    for (let i = 0; i < entries.length; i++) {
-      if (processedArgs[i] === void 0 && entries[i].defaultValue) {
-        try {
-          processedArgs[i] = this.evalExpr(entries[i].defaultValue);
-        } catch {
-        }
+    for (const [paramName, fields] of nvGroups) {
+      const pIdx = fn.params.indexOf(paramName);
+      const nvArgs = args.slice(pIdx >= 0 ? pIdx : args.length);
+      const defaults = {};
+      for (const { field, defaultExpr } of fields) {
+        if (defaultExpr) defaults[field] = this.evalExpr(defaultExpr);
       }
+      this.env.set(paramName, this.rt.buildNameValueStruct(nvArgs, defaults));
     }
-    return processedArgs;
   }
-  return args;
 }
 
 // src/numbl-core/interpreter/interpreter.ts
@@ -87108,15 +87753,18 @@ var Workspace = class _Workspace {
         );
       }
       let primary = null;
+      let firstFn = null;
       for (const stmt of ast.body) {
         if (stmt.type !== "Function") continue;
+        if (!firstFn) firstFn = stmt;
         if (stmt.name === methodName) {
           primary = stmt;
         }
       }
+      primary ??= firstFn;
       if (!primary) {
         throw new UnsupportedConstruct(
-          `external method file '${mf.fileName}' has no function named '${methodName}'`,
+          `external method file '${mf.fileName}' has no function`,
           info.ast.span
         );
       }