numbl 0.4.0 → 0.4.2

package/dist-lib/lib.js

@@ -287,10 +287,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) {
@@ -797,7 +799,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) => {
@@ -20391,10 +20393,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 = [];
@@ -20404,7 +20407,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;
@@ -22513,12 +22516,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);
@@ -22529,6 +22544,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);
@@ -25213,6 +25230,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);
@@ -25236,6 +25307,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) {
@@ -25280,6 +25360,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]]));
   }
@@ -30124,6 +30210,27 @@ function toNumArray(v, name) {
   throw new RuntimeError(`${name}: arguments must be numeric arrays`);
 }
 
+// src/numbl-core/helpers/effectively-real.ts
+function imagAllZero(imag2) {
+  if (!imag2) return true;
+  for (let i = 0; i < imag2.length; i++) {
+    if (imag2[i] !== 0) return false;
+  }
+  return true;
+}
+function stripZeroImagTensor(t) {
+  if (t.imag && imagAllZero(t.imag)) {
+    const out = RTV.tensor(t.data, t.shape);
+    if (t._isLogical) out._isLogical = true;
+    return out;
+  }
+  return t;
+}
+function stripZeroImagValue(v) {
+  if (isRuntimeTensor(v)) return stripZeroImagTensor(v);
+  return v;
+}
+
 // src/numbl-core/helpers/reduction/min-max.ts
 function minMaxScan(data, imag2, indices, initial, isBetter, complexIsBetter) {
   let mRe = initial, mIm = 0, mIdx = 0;
@@ -30308,6 +30415,7 @@ function minMaxImpl(name, args, nargout, initial, isBetter, twoArgFn) {
     return isBetter(Math.atan2(imA, reA), Math.atan2(imB, reB));
   };
   args = args.map((a) => isRuntimeSparseMatrix(a) ? sparseToDense(a) : a);
+  args = args.map(stripZeroImagValue);
   if (args.length === 1) {
     const v = args[0];
     if (isRuntimeNumber(v) || isRuntimeLogical(v) || isRuntimeComplexNumber(v)) {
@@ -30795,8 +30903,8 @@ defineBuiltin({
         if (typeof v === "number") return true;
         if (typeof v === "boolean") return true;
         if (isRuntimeComplexNumber(v)) return v.im === 0;
-        if (isRuntimeTensor(v)) return !v.imag;
-        if (isRuntimeSparseMatrix(v)) return !v.pi;
+        if (isRuntimeTensor(v)) return imagAllZero(v.imag);
+        if (isRuntimeSparseMatrix(v)) return !v.pi || imagAllZero(v.pi);
         return true;
       }
     }
@@ -31218,7 +31326,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({
@@ -31396,7 +31504,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;
       }
     }
@@ -31509,8 +31618,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");
       }
     }
@@ -33915,7 +34031,7 @@ defineBuiltin({
           return v;
         }
         if (isRuntimeTensor(v)) {
-          return sortTensor(v, dim, descend, nargout);
+          return sortTensor(stripZeroImagTensor(v), dim, descend, nargout);
         }
         if (isRuntimeCell(v)) {
           return sortCell(v, descend, nargout);
@@ -36551,6 +36667,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;
@@ -37919,6 +38036,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)) {
@@ -43992,6 +44124,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: () => ({
@@ -44146,7 +44285,6 @@ registerIBuiltin({
   })
 });
 for (const cm of [
-  "parula",
   "jet",
   "hsv",
   "hot",
@@ -44168,6 +44306,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();
@@ -46222,6 +46398,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."
@@ -46258,6 +46438,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."
@@ -46310,6 +46494,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."
@@ -47434,6 +47622,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;
@@ -47447,8 +47641,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;
@@ -47469,15 +47662,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);
@@ -48425,6 +48747,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;
@@ -48516,6 +49045,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",
@@ -48600,6 +49132,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 });
@@ -48852,6 +49388,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++) {
@@ -49100,6 +49640,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;
@@ -49179,6 +49722,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;
@@ -49244,6 +49790,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] });
@@ -49421,6 +49979,7 @@ var PLOT_DISPATCH_NAMES = [
   "plot",
   "plot3",
   "surf",
+  "surface",
   "scatter",
   "imagesc",
   "pcolor",
@@ -49448,6 +50007,7 @@ var PLOT_DISPATCH_NAMES = [
   "donutchart",
   "heatmap",
   "quiver",
+  "quiver3",
   "view",
   "legend",
   "figure",
@@ -49463,6 +50023,7 @@ var PLOT_DISPATCH_NAMES = [
   "grid",
   "close",
   "clf",
+  "cla",
   "shading",
   "colorbar",
   "colormap",
@@ -49986,6 +50547,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "plot",
   "plot3",
   "surf",
+  "surface",
   "scatter",
   "imagesc",
   "pcolor",
@@ -50015,6 +50577,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "donutchart",
   "heatmap",
   "quiver",
+  "quiver3",
   "streamline",
   "stream2",
   "ishold",
@@ -50032,6 +50595,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "sgtitle",
   "shading",
   "clf",
+  "cla",
   "colormap",
   "view",
   "zlabel",
@@ -50924,13 +51488,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));
     }
   });
@@ -51399,7 +51971,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(
@@ -52240,7 +52812,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)) {
@@ -53223,45 +53796,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;
-  }
-  if (typeof idx === "number") {
-    const i = Math.round(idx) - 1;
-    if (i < 0 || i >= mv.elements.length)
-      throw new RuntimeError("Index exceeds array bounds");
-    return mv.elements[i];
+    return makeObjResult(mv.className, mv.elements.slice(), [total, 1]);
   }
-  const rv = ensureRuntimeValue(idx);
-  if (isRuntimeLogical(rv)) {
-    const i = rv ? 0 : -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];
+    selected.push(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
-    };
-  }
-  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;
@@ -53958,6 +54556,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));
     };
@@ -54505,14 +55140,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);
@@ -54596,7 +55232,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);
       }
@@ -54609,7 +55247,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);
       }
@@ -54621,7 +55261,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;
         }
@@ -54932,31 +55572,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/jsUserFunctions.ts
@@ -58647,16 +59322,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);
@@ -58676,6 +59362,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) {
@@ -58919,12 +59606,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];
@@ -58998,7 +59686,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;
@@ -59019,48 +59707,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
@@ -63176,6 +63843,15 @@ function mtoc2_tensor_flip_complex(a, dimIdx) {
   return r;
 }
 
+// src/numbl-core/jit/builtins/runtime/tensor_ops/tensor_imag_all_zero.js
+function mtoc2_tensor_imag_all_zero(a) {
+  if (a.imag === void 0) return true;
+  for (let i = 0; i < a.imag.length; i++) {
+    if (a.imag[i] !== 0) return false;
+  }
+  return true;
+}
+
 // src/numbl-core/jit/builtins/runtime/tensor_ops/tensor_linspace.js
 function mtoc2_tensor_linspace(a, b, n) {
   if (n < 0) n = 0;
@@ -63477,6 +64153,13 @@ function cSqueezeTrailing(dims) {
 function cReduceLaneIm(t, i) {
   return t.imag !== void 0 ? t.imag[i] : 0;
 }
+function cReduceAllImagZero(t) {
+  if (t.imag === void 0) return true;
+  for (let i = 0; i < t.imag.length; i++) {
+    if (t.imag[i] !== 0) return false;
+  }
+  return true;
+}
 function complexAccumAll(t, init, accum, finalize) {
   let acc = { ...init };
   for (let i = 0; i < t.data.length; i++) {
@@ -63534,6 +64217,7 @@ var mtoc2_prod_complex_dim = (t, d) => complexAccumDim(t, d, cProdInit, cProdAcc
 var mtoc2_mean_complex_all = (t) => complexAccumAll(t, cSumInit, cSumAccum, cMeanFinalize);
 var mtoc2_mean_complex_dim = (t, d) => complexAccumDim(t, d, cSumInit, cSumAccum, cMeanFinalize);
 function complexMinmaxAll(t, cmp) {
+  const realMode = cReduceAllImagZero(t);
   let found = false;
   let mRe = NaN;
   let mIm = 0;
@@ -63541,7 +64225,8 @@ function complexMinmaxAll(t, cmp) {
     const xr = t.data[i];
     const xi = cReduceLaneIm(t, i);
     if (xr !== xr || xi !== xi) continue;
-    if (!found || complexBetter(xr, xi, mRe, mIm, cmp)) {
+    const better = realMode ? cmp === "<" ? xr < mRe : xr > mRe : complexBetter(xr, xi, mRe, mIm, cmp);
+    if (!found || better) {
       mRe = xr;
       mIm = xi;
       found = true;
@@ -63564,6 +64249,7 @@ function complexMinmaxDim(t, dim, cmp) {
     return out2;
   }
   const dimIdx = dim - 1;
+  const realMode = cReduceAllImagZero(t);
   const axis = t.shape[dimIdx];
   let before = 1;
   for (let i = 0; i < dimIdx; i++) before *= t.shape[i];
@@ -63584,7 +64270,8 @@ function complexMinmaxDim(t, dim, cmp) {
         const xr = t.data[off];
         const xi = cReduceLaneIm(t, off);
         if (xr !== xr || xi !== xi) continue;
-        if (!found || complexBetter(xr, xi, mRe, mIm, cmp)) {
+        const better = realMode ? cmp === "<" ? xr < mRe : xr > mRe : complexBetter(xr, xi, mRe, mIm, cmp);
+        if (!found || better) {
           mRe = xr;
           mIm = xi;
           found = true;
@@ -64064,6 +64751,35 @@ function complex_sort_indices(a, descending) {
   const n = a.data.length;
   const im = a.imag;
   const idx = new Array(n);
+  for (let i = 0; i < n; i++) idx[i] = i;
+  let realMode = true;
+  if (im !== void 0) {
+    for (let i = 0; i < n; i++) {
+      if (im[i] !== 0) {
+        realMode = false;
+        break;
+      }
+    }
+  }
+  if (realMode) {
+    const re = a.data;
+    idx.sort((p2, q) => {
+      const rp = re[p2];
+      const rq = re[q];
+      const pNaN = rp !== rp;
+      const qNaN = rq !== rq;
+      if (pNaN && qNaN) return 0;
+      if (descending) {
+        if (pNaN) return -1;
+        if (qNaN) return 1;
+        return rp < rq ? 1 : rp > rq ? -1 : 0;
+      }
+      if (pNaN) return 1;
+      if (qNaN) return -1;
+      return rp < rq ? -1 : rp > rq ? 1 : 0;
+    });
+    return idx;
+  }
   const mag = new Float64Array(n);
   const ph = new Float64Array(n);
   for (let i = 0; i < n; i++) {
@@ -64071,7 +64787,6 @@ function complex_sort_indices(a, descending) {
     const xi = im !== void 0 ? im[i] : 0;
     mag[i] = Math.hypot(re, xi);
     ph[i] = Math.atan2(xi, re);
-    idx[i] = i;
   }
   idx.sort((p2, q) => {
     if (mag[p2] < mag[q]) return descending ? 1 : -1;
@@ -65341,6 +66056,7 @@ static void mtoc2__format_walk(mtoc2__writer_fn writer, void *ctx,
   "tensor_fill_nd.h": "/* mtoc2 runtime helper: build an N-D tensor filled with `v`. Real\n * variant allocates a real tensor; complex variant takes `(re, im)`\n * and fills both lanes.\n *\n * Parameterized companion to `mtoc2_tensor_zeros_nd` / `_ones_nd`;\n * activated by the `nan` / `NaN` / `Inf` / `inf` shape-constructor\n * builtins (which would otherwise need their own per-constant fill\n * helpers) and by `repmat(scalar, ...)`. The returned tensor is\n * freshly owned.\n */\n\nstatic mtoc2_tensor_t mtoc2_tensor_fill_nd(double v, int ndim,\n                                           const long *dims) {\n  mtoc2_tensor_t out = mtoc2_tensor_alloc_nd(ndim, dims);\n  size_t n = 1;\n  for (int i = 0; i < ndim; i++) n *= (size_t)out.dims[i];\n  for (size_t i = 0; i < n; i++) out.real[i] = v;\n  return out;\n}\n\nstatic mtoc2_tensor_t mtoc2_tensor_fill_nd_complex(double re, double im,\n                                                   int ndim,\n                                                   const long *dims) {\n  mtoc2_tensor_t out = mtoc2_tensor_alloc_nd_complex(ndim, dims);\n  size_t n = 1;\n  for (int i = 0; i < ndim; i++) n *= (size_t)out.dims[i];\n  for (size_t i = 0; i < n; i++) {\n    out.real[i] = re;\n    out.imag[i] = im;\n  }\n  return out;\n}\n",
   "tensor_fill_square.h": "/* mtoc2 runtime helper: build an n\xD7n real tensor filled with `v`.\n *\n * Single-eval companion to `mtoc2_tensor_fill_nd` for the MATLAB\n * `nan(n)` / `Inf(n)` shorthand when `n` is a runtime expression.\n * See `mtoc2_tensor_zeros_square` for the rationale.\n */\n\nstatic mtoc2_tensor_t mtoc2_tensor_fill_square(double v, long n) {\n  long dims[2] = {n, n};\n  return mtoc2_tensor_fill_nd(v, 2, dims);\n}\n",
   "tensor_flip.h": "/* mtoc2 runtime helper: `flip(t, dimIdx)` \u2014 return a freshly-owned\n * tensor with `t.real` mirrored along axis `dimIdx` (0-based).\n *\n * Numbl's reference is `flipAlongDim` in\n * `interpreter/builtins/array-manipulation.ts` line ~41. Same\n * column-major slab math: stride = product of dims below the axis,\n * outer = product of dims above. For each outer slab, we walk the\n * axis backwards on the source and forward on the destination,\n * copying `strideDim`-element contiguous blocks.\n *\n * `flipud(t)` lowers to `mtoc2_tensor_flip(t, 0)`; `fliplr(t)` to\n * `mtoc2_tensor_flip(t, 1)`; `flip(t, k)` to\n * `mtoc2_tensor_flip(t, k - 1)`. The `dimIdx` is 0-based at the C\n * boundary so the runtime stays uniform across the three source-\n * level builtins. mtoc2 codegen converts MATLAB's 1-based `k` to\n * 0-based at the call site.\n *\n * Out-of-range `dimIdx` (\u2265 ndim) is a no-op flip \u2014 numbl returns\n * the input unchanged in that case (the \"axis is size 1\" rule). We\n * still allocate a fresh copy so the owned-value invariant holds.\n *\n * `mtoc2_tensor_flip_complex` is the sibling that walks both lanes;\n * it tolerates `a.imag == NULL` (a real tensor that flowed in via a\n * complex-typed route) by zero-filling the output imag lane.\n */\n\n#include <string.h>\n#include <stdlib.h>\n\nstatic mtoc2_tensor_t mtoc2_tensor_flip(mtoc2_tensor_t a, long dimIdx) {\n  long total = 1;\n  for (int i = 0; i < a.ndim; i++) total *= a.dims[i];\n  mtoc2_tensor_t r;\n  r.real = mtoc2_alloc((size_t)total * sizeof(double));\n  r.imag = NULL;\n  r.ndim = a.ndim;\n  for (int i = 0; i < a.ndim; i++) r.dims[i] = a.dims[i];\n\n  long axisSize = (dimIdx >= 0 && dimIdx < (long)a.ndim) ? a.dims[dimIdx] : 1;\n  // total==0 (empty along some axis) must short-circuit BEFORE the slab math:\n  // if a dim below the axis is 0, slabSize becomes 0 and total/slabSize is a\n  // 0/0 integer division (SIGILL). An empty result needs no copy anyway.\n  if (axisSize <= 1 || total == 0) {\n    // Nothing to flip \u2014 just deep-copy the buffer.\n    if (total > 0) memcpy(r.real, a.real, (size_t)total * sizeof(double));\n    return r;\n  }\n\n  long strideDim = 1;\n  for (long d = 0; d < dimIdx; d++) strideDim *= a.dims[d];\n  long slabSize = strideDim * axisSize;\n  long numOuter = total / slabSize;\n\n  for (long outer = 0; outer < numOuter; outer++) {\n    long base = outer * slabSize;\n    for (long k = 0; k < axisSize; k++) {\n      long srcOff = base + k * strideDim;\n      long dstOff = base + (axisSize - 1 - k) * strideDim;\n      memcpy(\n        r.real + dstOff,\n        a.real + srcOff,\n        (size_t)strideDim * sizeof(double)\n      );\n    }\n  }\n  return r;\n}\n\nstatic mtoc2_tensor_t mtoc2_tensor_flip_complex(mtoc2_tensor_t a, long dimIdx) {\n  long total = 1;\n  for (int i = 0; i < a.ndim; i++) total *= a.dims[i];\n  mtoc2_tensor_t r = mtoc2_tensor_alloc_nd_complex(a.ndim, a.dims);\n  int srcHasImag = (a.imag != NULL);\n\n  long axisSize = (dimIdx >= 0 && dimIdx < (long)a.ndim) ? a.dims[dimIdx] : 1;\n  // See mtoc2_tensor_flip: total==0 must short-circuit before slab math to\n  // avoid a 0/0 division when a dim below the axis is 0.\n  if (axisSize <= 1 || total == 0) {\n    if (total > 0) {\n      memcpy(r.real, a.real, (size_t)total * sizeof(double));\n      if (srcHasImag) {\n        memcpy(r.imag, a.imag, (size_t)total * sizeof(double));\n      } else {\n        memset(r.imag, 0, (size_t)total * sizeof(double));\n      }\n    }\n    return r;\n  }\n\n  if (!srcHasImag && total > 0) {\n    memset(r.imag, 0, (size_t)total * sizeof(double));\n  }\n\n  long strideDim = 1;\n  for (long d = 0; d < dimIdx; d++) strideDim *= a.dims[d];\n  long slabSize = strideDim * axisSize;\n  long numOuter = total / slabSize;\n\n  for (long outer = 0; outer < numOuter; outer++) {\n    long base = outer * slabSize;\n    for (long k = 0; k < axisSize; k++) {\n      long srcOff = base + k * strideDim;\n      long dstOff = base + (axisSize - 1 - k) * strideDim;\n      memcpy(r.real + dstOff, a.real + srcOff,\n             (size_t)strideDim * sizeof(double));\n      if (srcHasImag) {\n        memcpy(r.imag + dstOff, a.imag + srcOff,\n               (size_t)strideDim * sizeof(double));\n      }\n    }\n  }\n  return r;\n}\n",
+  "tensor_imag_all_zero.h": "/* mtoc2 runtime helper: true (1.0) when a tensor carries no imaginary\n * content \u2014 NULL imag lane, or every imag element exactly zero. `isreal`\n * uses this for complex-typed tensors the JIT could not prove real at\n * compile time, reporting realness by value (matching the interpreter\n * and the complex-scalar `cimag(z) == 0` rule). Returns a logical double. */\n\nstatic double mtoc2_tensor_imag_all_zero(mtoc2_tensor_t a) {\n  if (a.imag == NULL) return 1.0;\n  long n = 1;\n  for (int i = 0; i < a.ndim; i++) n *= a.dims[i];\n  for (long i = 0; i < n; i++) {\n    if (a.imag[i] != 0.0) return 0.0;\n  }\n  return 1.0;\n}\n",
   "tensor_linspace.h": "/* mtoc2 runtime helper: build a 1\xD7n row tensor of n linearly-spaced\n * values from `a` to `b` inclusive. Matches numbl's `linspace` byte-\n * for-byte:\n *\n *   - n <= 0  \u2192 1\xD70 empty tensor.\n *   - n == 1  \u2192 just `[b]` (matches MATLAB; not the midpoint).\n *   - n  > 1  \u2192 first/last slots pinned at `a`/`b` exactly so a NaN\n *               or Inf endpoint doesn't contaminate the other end;\n *               inner values are `a + (b - a) * i / (n - 1)`.\n *\n * Opposite-sign infinite endpoints place 0 at the exact center for\n * odd n (e.g. `linspace(-Inf, Inf, 5)` \u2192 `[-Inf, ?, 0, ?, Inf]`).\n */\n\n#include <math.h>\n\nstatic mtoc2_tensor_t mtoc2_tensor_linspace(double a, double b, long n) {\n  if (n < 0) n = 0;\n  mtoc2_tensor_t out = mtoc2_tensor_alloc(1, n);\n  if (n == 0) return out;\n  if (n == 1) {\n    out.real[0] = b;\n    return out;\n  }\n  out.real[0] = a;\n  out.real[n - 1] = b;\n  for (long i = 1; i < n - 1; i++) {\n    out.real[i] = a + (b - a) * (double)i / (double)(n - 1);\n  }\n  if ((n & 1) == 1 && !isfinite(a) && !isfinite(b)) {\n    double sa = (a > 0) - (a < 0);\n    double sb = (b > 0) - (b < 0);\n    if (sa != sb) {\n      out.real[(n - 1) / 2] = 0.0;\n    }\n  }\n  return out;\n}\n",
   "tensor_logical_mask.h": '/* mtoc2 runtime helper: logical-mask indexing support.\n *\n * `mtoc2_logical_mask_indices` scans `mask` column-major and fills\n * `out_indices` with the 0-based positions where the mask is truthy.\n * Each truthy position must be less than `axis_len`; otherwise this\n * aborts with a numbl-style "Index exceeds array bounds" message via\n * `mtoc2_oob_abort`. Returns the truthy count, which is also the\n * number of entries written into `out_indices`. `out_indices` must\n * have room for at least `mask.numel()` longs.\n *\n * `axis` is the axis number for the diagnostic (0-based) when this\n * helper is called for a per-axis slot (`M(:, mask)` \u2192 axis = 1), or\n * `-1` for the linear single-slot form (`a(mask)`).\n *\n * Used by both reads (`IndexSlice` with a `LogicalMask` slot) and\n * linear-form writes (`IndexSliceStore` with a single `LogicalMask`\n * slot). The caller allocates the index buffer with `mtoc2_alloc`,\n * passes it in, and frees it after the iteration that consumes it.\n */\n\nstatic long mtoc2_logical_mask_indices(\n  mtoc2_tensor_t mask, long axis_len, int axis, const char *loc,\n  long *out_indices\n) {\n  long mask_n = 1;\n  for (int d = 0; d < mask.ndim; d++) mask_n *= mask.dims[d];\n  long count = 0;\n  for (long i = 0; i < mask_n; i++) {\n    if (mask.real[i] != 0.0) {\n      if (i >= axis_len) {\n        mtoc2_oob_abort(loc, axis, i + 1, 1, axis_len);\n      }\n      out_indices[count++] = i;\n    }\n  }\n  return count;\n}\n',
   "tensor_logical_real.h": '/* mtoc2 runtime helpers: elementwise logical ops on tensors.\n *\n * Same allocate-and-fill pattern as tensor_unary_real_math.h, but the\n * per-element kernel is a logical predicate that returns 0.0 or 1.0.\n *\n * `mtoc2_tensor_not` mirrors numbl\'s `not(v)` (runtimeOperators.ts):\n * a real-tensor input produces a freshly-owned logical-typed tensor\n * of the same shape with `out[i] = (in[i] == 0.0) ? 1.0 : 0.0`. The\n * complex sibling fires "true" iff both lanes are exactly zero. The\n * result is a real (logical-typed) tensor in both cases \u2014 the type\n * system records `elem: "logical"` so disp / downstream consumers\n * know how to interpret the doubles.\n */\n#include <stdlib.h>\n\nstatic mtoc2_tensor_t mtoc2_tensor_not(mtoc2_tensor_t a) {\n  long n = 1;\n  for (int i = 0; i < a.ndim; i++) n *= a.dims[i];\n  mtoc2_tensor_t r;\n  r.real = mtoc2_alloc((size_t)n * sizeof(double));\n  r.imag = NULL;\n  r.ndim = a.ndim;\n  for (int i = 0; i < a.ndim; i++) r.dims[i] = a.dims[i];\n  for (long i = 0; i < n; i++) r.real[i] = (a.real[i] == 0.0) ? 1.0 : 0.0;\n  return r;\n}\n\nstatic mtoc2_tensor_t mtoc2_tensor_not_complex(mtoc2_tensor_t a) {\n  long n = 1;\n  for (int i = 0; i < a.ndim; i++) n *= a.dims[i];\n  mtoc2_tensor_t r;\n  r.real = mtoc2_alloc((size_t)n * sizeof(double));\n  r.imag = NULL;\n  r.ndim = a.ndim;\n  for (int i = 0; i < a.ndim; i++) r.dims[i] = a.dims[i];\n  int srcHasImag = (a.imag != NULL);\n  for (long i = 0; i < n; i++) {\n    double re = a.real[i];\n    double im = srcHasImag ? a.imag[i] : 0.0;\n    r.real[i] = (re == 0.0 && im == 0.0) ? 1.0 : 0.0;\n  }\n  return r;\n}\n',
@@ -65352,13 +66068,13 @@ static void mtoc2__format_walk(mtoc2__writer_fn writer, void *ctx,
   "tensor_ones_nd.h": "/* mtoc2 runtime helper: build a real N-D tensor filled with ones.\n *\n * Allocates via `mtoc2_tensor_alloc_nd`, then fills the `real` buffer\n * with `1.0` via a plain element loop (`memset` only works for byte\n * patterns; `1.0` is not such a pattern). The returned tensor is\n * freshly owned; `imag` is NULL.\n */\n\nstatic mtoc2_tensor_t mtoc2_tensor_ones_nd(int ndim, const long *dims) {\n  mtoc2_tensor_t out = mtoc2_tensor_alloc_nd(ndim, dims);\n  size_t n = 1;\n  for (int i = 0; i < ndim; i++) n *= (size_t)out.dims[i];\n  for (size_t i = 0; i < n; i++) out.real[i] = 1.0;\n  return out;\n}\n",
   "tensor_ones_square.h": "/* mtoc2 runtime helper: build an n\xD7n real tensor filled with ones.\n *\n * Single-eval companion to `mtoc2_tensor_ones_nd` for the MATLAB\n * `ones(n)` shorthand when `n` is a runtime expression. See the\n * `mtoc2_tensor_zeros_square` header for the rationale.\n */\n\nstatic mtoc2_tensor_t mtoc2_tensor_ones_square(long n) {\n  long dims[2] = {n, n};\n  return mtoc2_tensor_ones_nd(2, dims);\n}\n",
   "tensor_predicate.h": "/* mtoc2 runtime helpers: elementwise tensor \u2192 logical-tensor\n * predicates (`isnan`, `isinf`, `isfinite`, `logical`). Same\n * allocate-and-fill shape as `tensor_unary_real_math.h`; each element\n * maps to 1.0 / 0.0. The result is logical at the source level (the\n * buffer is the usual Float64 lane, `imag == NULL`).\n *\n * The `_complex` siblings operate per-element on `(re, im)`; for\n * `isnan` / `isinf` the predicate fires if either component\n * triggers, for `isfinite` both must be finite. They tolerate\n * `a.imag == NULL` (a real tensor that flowed through a\n * complex-typed route) by treating the imag input as zero.\n */\n#include <math.h>\n#include <stdlib.h>\n\n#define MTOC2_DEFINE_UNARY_PRED(name, EXPR)              \\\n  static mtoc2_tensor_t name(mtoc2_tensor_t a) {         \\\n    long n = 1;                                          \\\n    for (int i = 0; i < a.ndim; i++) n *= a.dims[i];     \\\n    mtoc2_tensor_t r;                                    \\\n    r.real = mtoc2_alloc((size_t)n * sizeof(double));    \\\n    r.imag = NULL;                                       \\\n    r.ndim = a.ndim;                                     \\\n    for (int i = 0; i < a.ndim; i++) r.dims[i] = a.dims[i]; \\\n    MTOC2_OMP_PARFOR_N                                   \\\n    for (long i = 0; i < n; i++) {                       \\\n      double x = a.real[i];                              \\\n      r.real[i] = (EXPR) ? 1.0 : 0.0;                    \\\n    }                                                    \\\n    return r;                                            \\\n  }\n\nMTOC2_DEFINE_UNARY_PRED(mtoc2_tensor_isnan, isnan(x))\nMTOC2_DEFINE_UNARY_PRED(mtoc2_tensor_logical, x != 0.0)\nMTOC2_DEFINE_UNARY_PRED(mtoc2_tensor_isinf, isinf(x))\nMTOC2_DEFINE_UNARY_PRED(mtoc2_tensor_isfinite, isfinite(x))\n\n#undef MTOC2_DEFINE_UNARY_PRED\n\n#define MTOC2_DEFINE_UNARY_PRED_COMPLEX(name, EXPR)         \\\n  static mtoc2_tensor_t name(mtoc2_tensor_t a) {            \\\n    long n = 1;                                             \\\n    for (int i = 0; i < a.ndim; i++) n *= a.dims[i];        \\\n    mtoc2_tensor_t r;                                       \\\n    r.real = mtoc2_alloc((size_t)n * sizeof(double));       \\\n    r.imag = NULL;                                          \\\n    r.ndim = a.ndim;                                        \\\n    for (int i = 0; i < a.ndim; i++) r.dims[i] = a.dims[i]; \\\n    MTOC2_OMP_PARFOR_N                                      \\\n    for (long i = 0; i < n; i++) {                          \\\n      double re = a.real[i];                                \\\n      double im = (a.imag != NULL) ? a.imag[i] : 0.0;       \\\n      r.real[i] = (EXPR) ? 1.0 : 0.0;                       \\\n    }                                                       \\\n    return r;                                               \\\n  }\n\nMTOC2_DEFINE_UNARY_PRED_COMPLEX(mtoc2_tensor_isnan_complex,\n                                isnan(re) || isnan(im))\nMTOC2_DEFINE_UNARY_PRED_COMPLEX(mtoc2_tensor_isinf_complex,\n                                isinf(re) || isinf(im))\nMTOC2_DEFINE_UNARY_PRED_COMPLEX(mtoc2_tensor_isfinite_complex,\n                                isfinite(re) && isfinite(im))\n\n#undef MTOC2_DEFINE_UNARY_PRED_COMPLEX\n",
-  "tensor_reduce_complex.h": '/* mtoc2 runtime helpers: complex-tensor reductions.\n *\n * Sibling of `tensor_reduce_real.h`. Same `_all` / `_dim` shape per\n * op; each kernel walks both lanes and builds intermediate\n * `double _Complex` values through `mtoc2_cmake` / `mtoc2_c*` so the\n * c2js backend can translate the bodies straight (no bare\n * `<complex.h>` operators).\n *\n * Result types per op:\n *   sum / prod / mean         \u2192 complex (lane-pair accumulator)\n *   min / max                 \u2192 complex (magnitude compare, atan2\n *                                tiebreak \u2014 matches numbl\'s\n *                                `complexIsBetter`)\n *   any / all                 \u2192 real (toBool: `re != 0 || im != 0`,\n *                                then aggregate via OR/AND)\n *\n * Input tolerance: `imag == NULL` (a real tensor flowing in through\n * a complex-typed route) is treated as zero on every cell.\n *\n * `_all` returns a `double _Complex` for the numeric reducers and a\n * `double` for the logical reducers. `_dim` returns a freshly-owned\n * complex tensor (numeric reducers) or a real tensor (logical\n * reducers) of the reduced shape \u2014 same trailing-singleton squeeze\n * rule as the real helper.\n */\n\n#include <math.h>\n#include <stdlib.h>\n#include <string.h>\n\n/* Shared with the real helper; defined inline here so this file is\n * standalone-includable (the runtime activator may pull the complex\n * snippet in independently of the real one). */\nstatic void mtoc2__squeeze_trailing_c(int *ndim, long *dims) {\n  while (*ndim > 2 && dims[*ndim - 1] == 1) {\n    (*ndim)--;\n  }\n}\n\n/* Numeric (sum/prod/mean) reduction template \u2014 complex accumulator. */\n#define MTOC2_DEFINE_CACCUM_REDUCTION(name, INIT, ACCUM, FINALIZE)            \\\n  static double _Complex mtoc2_##name##_complex_all(mtoc2_tensor_t a) {       \\\n    long n = 1;                                                               \\\n    for (int i = 0; i < a.ndim; i++) n *= a.dims[i];                          \\\n    double _Complex acc = (INIT);                                             \\\n    for (long i = 0; i < n; i++) {                                            \\\n      double aim = (a.imag != NULL) ? a.imag[i] : 0.0;                        \\\n      double _Complex x = mtoc2_cmake(a.real[i], aim);                        \\\n      acc = ACCUM(acc, x);                                                    \\\n    }                                                                         \\\n    return FINALIZE(acc, n);                                                  \\\n  }                                                                           \\\n                                                                              \\\n  static mtoc2_tensor_t mtoc2_##name##_complex_dim(                           \\\n      mtoc2_tensor_t a, int dim) {                                            \\\n    if (dim < 1) {                                                            \\\n      fprintf(stderr, "mtoc2: " #name "_complex_dim: dim must be >= 1 (got %d)\\n", dim); \\\n      abort();                                                                \\\n    }                                                                         \\\n    if (dim > a.ndim) {                                                       \\\n      long total = 1;                                                         \\\n      for (int i = 0; i < a.ndim; i++) total *= a.dims[i];                    \\\n      mtoc2_tensor_t out = mtoc2_tensor_alloc_nd_complex(a.ndim, a.dims);     \\\n      memcpy(out.real, a.real, (size_t)total * sizeof(double));               \\\n      if (a.imag != NULL) {                                                   \\\n        memcpy(out.imag, a.imag, (size_t)total * sizeof(double));             \\\n      } else {                                                                \\\n        memset(out.imag, 0, (size_t)total * sizeof(double));                  \\\n      }                                                                       \\\n      return out;                                                             \\\n    }                                                                         \\\n    int dimIdx = dim - 1;                                                     \\\n    long axis = a.dims[dimIdx];                                               \\\n    long before = 1;                                                          \\\n    for (int i = 0; i < dimIdx; i++) before *= a.dims[i];                     \\\n    long after = 1;                                                           \\\n    for (int i = dimIdx + 1; i < a.ndim; i++) after *= a.dims[i];             \\\n    long out_dims[MTOC2_MAX_NDIM];                                            \\\n    int out_ndim = a.ndim;                                                    \\\n    for (int i = 0; i < a.ndim; i++) out_dims[i] = a.dims[i];                 \\\n    out_dims[dimIdx] = 1;                                                     \\\n    mtoc2__squeeze_trailing_c(&out_ndim, out_dims);                           \\\n    mtoc2_tensor_t out = mtoc2_tensor_alloc_nd_complex(out_ndim, out_dims);   \\\n    long slab = before * axis;                                                \\\n    for (long outer = 0; outer < after; outer++) {                            \\\n      long slabBase = outer * slab;                                           \\\n      for (long inner = 0; inner < before; inner++) {                         \\\n        double _Complex acc = (INIT);                                         \\\n        for (long k = 0; k < axis; k++) {                                     \\\n          long off = slabBase + inner + k * before;                           \\\n          double aim = (a.imag != NULL) ? a.imag[off] : 0.0;                  \\\n          double _Complex x = mtoc2_cmake(a.real[off], aim);                  \\\n          acc = ACCUM(acc, x);                                                \\\n        }                                                                     \\\n        double _Complex fin = FINALIZE(acc, axis);                            \\\n        long dst = outer * before + inner;                                    \\\n        out.real[dst] = mtoc2_creal(fin);                                     \\\n        out.imag[dst] = mtoc2_cimag(fin);                                     \\\n      }                                                                       \\\n    }                                                                         \\\n    return out;                                                               \\\n  }\n\n/* min/max template \u2014 complex compare via magnitude + atan2 tiebreak.\n * NaN-skip on either lane. Accumulator seed is NaN+NaN; first non-\n * NaN element captures, later non-NaN elements compare. */\n#define MTOC2_DEFINE_CMINMAX_REDUCTION(name, CMP)                              \\\n  static int mtoc2__##name##_complex_better(                                  \\\n      double aRe, double aIm, double bRe, double bIm) {                       \\\n    double absA = hypot(aRe, aIm);                                            \\\n    double absB = hypot(bRe, bIm);                                            \\\n    if (absA != absB) return absA CMP absB;                                   \\\n    return atan2(aIm, aRe) CMP atan2(bIm, bRe);                               \\\n  }                                                                           \\\n  static double _Complex mtoc2_##name##_complex_all(mtoc2_tensor_t a) {       \\\n    long n = 1;                                                               \\\n    for (int i = 0; i < a.ndim; i++) n *= a.dims[i];                          \\\n    int found = 0;                                                            \\\n    double mRe = NAN, mIm = 0.0;                                              \\\n    for (long i = 0; i < n; i++) {                                            \\\n      double xr = a.real[i];                                                  \\\n      double xi = (a.imag != NULL) ? a.imag[i] : 0.0;                         \\\n      if (xr != xr || xi != xi) continue;                                     \\\n      if (!found || mtoc2__##name##_complex_better(xr, xi, mRe, mIm)) {       \\\n        mRe = xr;                                                             \\\n        mIm = xi;                                                             \\\n        found = 1;                                                            \\\n      }                                                                       \\\n    }                                                                         \\\n    return mtoc2_cmake(mRe, mIm);                                             \\\n  }                                                                           \\\n                                                                              \\\n  static mtoc2_tensor_t mtoc2_##name##_complex_dim(                           \\\n      mtoc2_tensor_t a, int dim) {                                            \\\n    if (dim < 1) {                                                            \\\n      fprintf(stderr, "mtoc2: " #name "_complex_dim: dim must be >= 1 (got %d)\\n", dim); \\\n      abort();                                                                \\\n    }                                                                         \\\n    if (dim > a.ndim) {                                                       \\\n      long total = 1;                                                         \\\n      for (int i = 0; i < a.ndim; i++) total *= a.dims[i];                    \\\n      mtoc2_tensor_t out = mtoc2_tensor_alloc_nd_complex(a.ndim, a.dims);     \\\n      memcpy(out.real, a.real, (size_t)total * sizeof(double));               \\\n      if (a.imag != NULL) {                                                   \\\n        memcpy(out.imag, a.imag, (size_t)total * sizeof(double));             \\\n      } else {                                                                \\\n        memset(out.imag, 0, (size_t)total * sizeof(double));                  \\\n      }                                                                       \\\n      return out;                                                             \\\n    }                                                                         \\\n    int dimIdx = dim - 1;                                                     \\\n    long axis = a.dims[dimIdx];                                               \\\n    long before = 1;                                                          \\\n    for (int i = 0; i < dimIdx; i++) before *= a.dims[i];                     \\\n    long after = 1;                                                           \\\n    for (int i = dimIdx + 1; i < a.ndim; i++) after *= a.dims[i];             \\\n    long out_dims[MTOC2_MAX_NDIM];                                            \\\n    int out_ndim = a.ndim;                                                    \\\n    for (int i = 0; i < a.ndim; i++) out_dims[i] = a.dims[i];                 \\\n    out_dims[dimIdx] = 1;                                                     \\\n    mtoc2__squeeze_trailing_c(&out_ndim, out_dims);                           \\\n    mtoc2_tensor_t out = mtoc2_tensor_alloc_nd_complex(out_ndim, out_dims);   \\\n    long slab = before * axis;                                                \\\n    for (long outer = 0; outer < after; outer++) {                            \\\n      long slabBase = outer * slab;                                           \\\n      for (long inner = 0; inner < before; inner++) {                         \\\n        int found = 0;                                                        \\\n        double mRe = NAN, mIm = 0.0;                                          \\\n        for (long k = 0; k < axis; k++) {                                     \\\n          long off = slabBase + inner + k * before;                           \\\n          double xr = a.real[off];                                            \\\n          double xi = (a.imag != NULL) ? a.imag[off] : 0.0;                   \\\n          if (xr != xr || xi != xi) continue;                                 \\\n          if (!found || mtoc2__##name##_complex_better(xr, xi, mRe, mIm)) {   \\\n            mRe = xr;                                                         \\\n            mIm = xi;                                                         \\\n            found = 1;                                                        \\\n          }                                                                   \\\n        }                                                                     \\\n        long dst = outer * before + inner;                                    \\\n        out.real[dst] = mRe;                                                  \\\n        out.imag[dst] = mIm;                                                  \\\n      }                                                                       \\\n    }                                                                         \\\n    return out;                                                               \\\n  }\n\n/* any/all template \u2014 real result; toBool per element (either lane\n * nonzero). Mirrors `MTOC2_DEFINE_LOGICAL_REDUCTION` shape. */\n#define MTOC2_DEFINE_CLOGICAL_REDUCTION(name, EMPTY_RESULT, SHORT_BODY)        \\\n  static double mtoc2_##name##_complex_all(mtoc2_tensor_t a) {                \\\n    long n = 1;                                                               \\\n    for (int i = 0; i < a.ndim; i++) n *= a.dims[i];                          \\\n    if (n == 0) return (double)(EMPTY_RESULT);                                \\\n    double acc = (double)(EMPTY_RESULT);                                      \\\n    for (long i = 0; i < n; i++) {                                            \\\n      double xr = a.real[i];                                                  \\\n      double xi = (a.imag != NULL) ? a.imag[i] : 0.0;                         \\\n      int x = (xr != 0.0 || xi != 0.0);                                       \\\n      SHORT_BODY;                                                             \\\n    }                                                                         \\\n    return acc;                                                               \\\n  }                                                                           \\\n                                                                              \\\n  static mtoc2_tensor_t mtoc2_##name##_complex_dim(                           \\\n      mtoc2_tensor_t a, int dim) {                                            \\\n    if (dim < 1) {                                                            \\\n      fprintf(stderr, "mtoc2: " #name "_complex_dim: dim must be >= 1 (got %d)\\n", dim); \\\n      abort();                                                                \\\n    }                                                                         \\\n    if (dim > a.ndim) {                                                       \\\n      long total = 1;                                                         \\\n      for (int i = 0; i < a.ndim; i++) total *= a.dims[i];                    \\\n      long out_dims[MTOC2_MAX_NDIM];                                          \\\n      int out_ndim = a.ndim;                                                  \\\n      for (int i = 0; i < a.ndim; i++) out_dims[i] = a.dims[i];               \\\n      mtoc2_tensor_t out = mtoc2_tensor_alloc_nd(out_ndim, out_dims);         \\\n      for (long i = 0; i < total; i++) {                                      \\\n        double xr = a.real[i];                                                \\\n        double xi = (a.imag != NULL) ? a.imag[i] : 0.0;                       \\\n        out.real[i] = (xr != 0.0 || xi != 0.0) ? 1.0 : 0.0;                   \\\n      }                                                                       \\\n      return out;                                                             \\\n    }                                                                         \\\n    int dimIdx = dim - 1;                                                     \\\n    long axis = a.dims[dimIdx];                                               \\\n    long before = 1;                                                          \\\n    for (int i = 0; i < dimIdx; i++) before *= a.dims[i];                     \\\n    long after = 1;                                                           \\\n    for (int i = dimIdx + 1; i < a.ndim; i++) after *= a.dims[i];             \\\n    long out_dims[MTOC2_MAX_NDIM];                                            \\\n    int out_ndim = a.ndim;                                                    \\\n    for (int i = 0; i < a.ndim; i++) out_dims[i] = a.dims[i];                 \\\n    out_dims[dimIdx] = 1;                                                     \\\n    mtoc2__squeeze_trailing_c(&out_ndim, out_dims);                           \\\n    mtoc2_tensor_t out = mtoc2_tensor_alloc_nd(out_ndim, out_dims);           \\\n    long slab = before * axis;                                                \\\n    for (long outer = 0; outer < after; outer++) {                            \\\n      long slabBase = outer * slab;                                           \\\n      for (long inner = 0; inner < before; inner++) {                         \\\n        double acc = (double)(EMPTY_RESULT);                                  \\\n        for (long k = 0; k < axis; k++) {                                     \\\n          long off = slabBase + inner + k * before;                           \\\n          double xr = a.real[off];                                            \\\n          double xi = (a.imag != NULL) ? a.imag[off] : 0.0;                   \\\n          int x = (xr != 0.0 || xi != 0.0);                                   \\\n          SHORT_BODY;                                                         \\\n        }                                                                     \\\n        out.real[outer * before + inner] = acc;                               \\\n      }                                                                       \\\n    }                                                                         \\\n    return out;                                                               \\\n  }\n\n/* Accumulator-statement macros. */\n#define MTOC2_CACC_SUM(acc, x) mtoc2_cadd((acc), (x))\n#define MTOC2_CACC_PROD(acc, x) mtoc2_cmul((acc), (x))\n#define MTOC2_CFIN_ID(acc, n) (acc)\n#define MTOC2_CFIN_MEAN(acc, n) mtoc2_cdiv((acc), mtoc2_cmake((double)(n), 0.0))\n\nMTOC2_DEFINE_CACCUM_REDUCTION(sum, mtoc2_cmake(0.0, 0.0), MTOC2_CACC_SUM, MTOC2_CFIN_ID)\nMTOC2_DEFINE_CACCUM_REDUCTION(prod, mtoc2_cmake(1.0, 0.0), MTOC2_CACC_PROD, MTOC2_CFIN_ID)\nMTOC2_DEFINE_CACCUM_REDUCTION(mean, mtoc2_cmake(0.0, 0.0), MTOC2_CACC_SUM, MTOC2_CFIN_MEAN)\n\nMTOC2_DEFINE_CMINMAX_REDUCTION(min, <)\nMTOC2_DEFINE_CMINMAX_REDUCTION(max, >)\n\nMTOC2_DEFINE_CLOGICAL_REDUCTION(any, 0,\n  if (x) { acc = 1.0; break; })\nMTOC2_DEFINE_CLOGICAL_REDUCTION(all, 1,\n  if (!x) { acc = 0.0; break; })\n',
+  "tensor_reduce_complex.h": '/* mtoc2 runtime helpers: complex-tensor reductions.\n *\n * Sibling of `tensor_reduce_real.h`. Same `_all` / `_dim` shape per\n * op; each kernel walks both lanes and builds intermediate\n * `double _Complex` values through `mtoc2_cmake` / `mtoc2_c*` so the\n * c2js backend can translate the bodies straight (no bare\n * `<complex.h>` operators).\n *\n * Result types per op:\n *   sum / prod / mean         \u2192 complex (lane-pair accumulator)\n *   min / max                 \u2192 complex (magnitude compare, atan2\n *                                tiebreak \u2014 matches numbl\'s\n *                                `complexIsBetter`)\n *   any / all                 \u2192 real (toBool: `re != 0 || im != 0`,\n *                                then aggregate via OR/AND)\n *\n * Input tolerance: `imag == NULL` (a real tensor flowing in through\n * a complex-typed route) is treated as zero on every cell.\n *\n * `_all` returns a `double _Complex` for the numeric reducers and a\n * `double` for the logical reducers. `_dim` returns a freshly-owned\n * complex tensor (numeric reducers) or a real tensor (logical\n * reducers) of the reduced shape \u2014 same trailing-singleton squeeze\n * rule as the real helper.\n */\n\n#include <math.h>\n#include <stdlib.h>\n#include <string.h>\n\n/* Shared with the real helper; defined inline here so this file is\n * standalone-includable (the runtime activator may pull the complex\n * snippet in independently of the real one). */\nstatic void mtoc2__squeeze_trailing_c(int *ndim, long *dims) {\n  while (*ndim > 2 && dims[*ndim - 1] == 1) {\n    (*ndim)--;\n  }\n}\n\n/* Numeric (sum/prod/mean) reduction template \u2014 complex accumulator. */\n#define MTOC2_DEFINE_CACCUM_REDUCTION(name, INIT, ACCUM, FINALIZE)            \\\n  static double _Complex mtoc2_##name##_complex_all(mtoc2_tensor_t a) {       \\\n    long n = 1;                                                               \\\n    for (int i = 0; i < a.ndim; i++) n *= a.dims[i];                          \\\n    double _Complex acc = (INIT);                                             \\\n    for (long i = 0; i < n; i++) {                                            \\\n      double aim = (a.imag != NULL) ? a.imag[i] : 0.0;                        \\\n      double _Complex x = mtoc2_cmake(a.real[i], aim);                        \\\n      acc = ACCUM(acc, x);                                                    \\\n    }                                                                         \\\n    return FINALIZE(acc, n);                                                  \\\n  }                                                                           \\\n                                                                              \\\n  static mtoc2_tensor_t mtoc2_##name##_complex_dim(                           \\\n      mtoc2_tensor_t a, int dim) {                                            \\\n    if (dim < 1) {                                                            \\\n      fprintf(stderr, "mtoc2: " #name "_complex_dim: dim must be >= 1 (got %d)\\n", dim); \\\n      abort();                                                                \\\n    }                                                                         \\\n    if (dim > a.ndim) {                                                       \\\n      long total = 1;                                                         \\\n      for (int i = 0; i < a.ndim; i++) total *= a.dims[i];                    \\\n      mtoc2_tensor_t out = mtoc2_tensor_alloc_nd_complex(a.ndim, a.dims);     \\\n      memcpy(out.real, a.real, (size_t)total * sizeof(double));               \\\n      if (a.imag != NULL) {                                                   \\\n        memcpy(out.imag, a.imag, (size_t)total * sizeof(double));             \\\n      } else {                                                                \\\n        memset(out.imag, 0, (size_t)total * sizeof(double));                  \\\n      }                                                                       \\\n      return out;                                                             \\\n    }                                                                         \\\n    int dimIdx = dim - 1;                                                     \\\n    long axis = a.dims[dimIdx];                                               \\\n    long before = 1;                                                          \\\n    for (int i = 0; i < dimIdx; i++) before *= a.dims[i];                     \\\n    long after = 1;                                                           \\\n    for (int i = dimIdx + 1; i < a.ndim; i++) after *= a.dims[i];             \\\n    long out_dims[MTOC2_MAX_NDIM];                                            \\\n    int out_ndim = a.ndim;                                                    \\\n    for (int i = 0; i < a.ndim; i++) out_dims[i] = a.dims[i];                 \\\n    out_dims[dimIdx] = 1;                                                     \\\n    mtoc2__squeeze_trailing_c(&out_ndim, out_dims);                           \\\n    mtoc2_tensor_t out = mtoc2_tensor_alloc_nd_complex(out_ndim, out_dims);   \\\n    long slab = before * axis;                                                \\\n    for (long outer = 0; outer < after; outer++) {                            \\\n      long slabBase = outer * slab;                                           \\\n      for (long inner = 0; inner < before; inner++) {                         \\\n        double _Complex acc = (INIT);                                         \\\n        for (long k = 0; k < axis; k++) {                                     \\\n          long off = slabBase + inner + k * before;                           \\\n          double aim = (a.imag != NULL) ? a.imag[off] : 0.0;                  \\\n          double _Complex x = mtoc2_cmake(a.real[off], aim);                  \\\n          acc = ACCUM(acc, x);                                                \\\n        }                                                                     \\\n        double _Complex fin = FINALIZE(acc, axis);                            \\\n        long dst = outer * before + inner;                                    \\\n        out.real[dst] = mtoc2_creal(fin);                                     \\\n        out.imag[dst] = mtoc2_cimag(fin);                                     \\\n      }                                                                       \\\n    }                                                                         \\\n    return out;                                                               \\\n  }\n\n/* True when the tensor carries no imaginary content (NULL lane or every\n * element zero). Such a tensor is real in value \u2014 min/max must order by\n * value, not magnitude, to match the interpreter and MATLAB on real data. */\nstatic int mtoc2__creduce_all_imag_zero(mtoc2_tensor_t a) {\n  if (a.imag == NULL) return 1;\n  long n = 1;\n  for (int i = 0; i < a.ndim; i++) n *= a.dims[i];\n  for (long i = 0; i < n; i++) {\n    if (a.imag[i] != 0.0) return 0;\n  }\n  return 1;\n}\n\n/* min/max template \u2014 complex compare via magnitude + atan2 tiebreak.\n * When the whole tensor is real (all-zero imag) we order by value\n * instead. NaN-skip on either lane. Accumulator seed is NaN+NaN; first\n * non-NaN element captures, later non-NaN elements compare. */\n#define MTOC2_DEFINE_CMINMAX_REDUCTION(name, CMP)                              \\\n  static int mtoc2__##name##_complex_better(                                  \\\n      double aRe, double aIm, double bRe, double bIm) {                       \\\n    double absA = hypot(aRe, aIm);                                            \\\n    double absB = hypot(bRe, bIm);                                            \\\n    if (absA != absB) return absA CMP absB;                                   \\\n    return atan2(aIm, aRe) CMP atan2(bIm, bRe);                               \\\n  }                                                                           \\\n  static double _Complex mtoc2_##name##_complex_all(mtoc2_tensor_t a) {       \\\n    long n = 1;                                                               \\\n    for (int i = 0; i < a.ndim; i++) n *= a.dims[i];                          \\\n    int realMode = mtoc2__creduce_all_imag_zero(a);                           \\\n    int found = 0;                                                            \\\n    double mRe = NAN, mIm = 0.0;                                              \\\n    for (long i = 0; i < n; i++) {                                            \\\n      double xr = a.real[i];                                                  \\\n      double xi = (a.imag != NULL) ? a.imag[i] : 0.0;                         \\\n      if (xr != xr || xi != xi) continue;                                     \\\n      int better = realMode ? (xr CMP mRe)                                    \\\n                            : mtoc2__##name##_complex_better(xr, xi, mRe, mIm); \\\n      if (!found || better) {                                                 \\\n        mRe = xr;                                                             \\\n        mIm = xi;                                                             \\\n        found = 1;                                                            \\\n      }                                                                       \\\n    }                                                                         \\\n    return mtoc2_cmake(mRe, mIm);                                             \\\n  }                                                                           \\\n                                                                              \\\n  static mtoc2_tensor_t mtoc2_##name##_complex_dim(                           \\\n      mtoc2_tensor_t a, int dim) {                                            \\\n    if (dim < 1) {                                                            \\\n      fprintf(stderr, "mtoc2: " #name "_complex_dim: dim must be >= 1 (got %d)\\n", dim); \\\n      abort();                                                                \\\n    }                                                                         \\\n    if (dim > a.ndim) {                                                       \\\n      long total = 1;                                                         \\\n      for (int i = 0; i < a.ndim; i++) total *= a.dims[i];                    \\\n      mtoc2_tensor_t out = mtoc2_tensor_alloc_nd_complex(a.ndim, a.dims);     \\\n      memcpy(out.real, a.real, (size_t)total * sizeof(double));               \\\n      if (a.imag != NULL) {                                                   \\\n        memcpy(out.imag, a.imag, (size_t)total * sizeof(double));             \\\n      } else {                                                                \\\n        memset(out.imag, 0, (size_t)total * sizeof(double));                  \\\n      }                                                                       \\\n      return out;                                                             \\\n    }                                                                         \\\n    int dimIdx = dim - 1;                                                     \\\n    long axis = a.dims[dimIdx];                                               \\\n    long before = 1;                                                          \\\n    for (int i = 0; i < dimIdx; i++) before *= a.dims[i];                     \\\n    long after = 1;                                                           \\\n    for (int i = dimIdx + 1; i < a.ndim; i++) after *= a.dims[i];             \\\n    long out_dims[MTOC2_MAX_NDIM];                                            \\\n    int out_ndim = a.ndim;                                                    \\\n    for (int i = 0; i < a.ndim; i++) out_dims[i] = a.dims[i];                 \\\n    out_dims[dimIdx] = 1;                                                     \\\n    mtoc2__squeeze_trailing_c(&out_ndim, out_dims);                           \\\n    mtoc2_tensor_t out = mtoc2_tensor_alloc_nd_complex(out_ndim, out_dims);   \\\n    long slab = before * axis;                                                \\\n    int realMode = mtoc2__creduce_all_imag_zero(a);                           \\\n    for (long outer = 0; outer < after; outer++) {                            \\\n      long slabBase = outer * slab;                                           \\\n      for (long inner = 0; inner < before; inner++) {                         \\\n        int found = 0;                                                        \\\n        double mRe = NAN, mIm = 0.0;                                          \\\n        for (long k = 0; k < axis; k++) {                                     \\\n          long off = slabBase + inner + k * before;                           \\\n          double xr = a.real[off];                                            \\\n          double xi = (a.imag != NULL) ? a.imag[off] : 0.0;                   \\\n          if (xr != xr || xi != xi) continue;                                 \\\n          int better = realMode ? (xr CMP mRe)                                \\\n                                : mtoc2__##name##_complex_better(xr, xi, mRe, mIm); \\\n          if (!found || better) {                                             \\\n            mRe = xr;                                                         \\\n            mIm = xi;                                                         \\\n            found = 1;                                                        \\\n          }                                                                   \\\n        }                                                                     \\\n        long dst = outer * before + inner;                                    \\\n        out.real[dst] = mRe;                                                  \\\n        out.imag[dst] = mIm;                                                  \\\n      }                                                                       \\\n    }                                                                         \\\n    return out;                                                               \\\n  }\n\n/* any/all template \u2014 real result; toBool per element (either lane\n * nonzero). Mirrors `MTOC2_DEFINE_LOGICAL_REDUCTION` shape. */\n#define MTOC2_DEFINE_CLOGICAL_REDUCTION(name, EMPTY_RESULT, SHORT_BODY)        \\\n  static double mtoc2_##name##_complex_all(mtoc2_tensor_t a) {                \\\n    long n = 1;                                                               \\\n    for (int i = 0; i < a.ndim; i++) n *= a.dims[i];                          \\\n    if (n == 0) return (double)(EMPTY_RESULT);                                \\\n    double acc = (double)(EMPTY_RESULT);                                      \\\n    for (long i = 0; i < n; i++) {                                            \\\n      double xr = a.real[i];                                                  \\\n      double xi = (a.imag != NULL) ? a.imag[i] : 0.0;                         \\\n      int x = (xr != 0.0 || xi != 0.0);                                       \\\n      SHORT_BODY;                                                             \\\n    }                                                                         \\\n    return acc;                                                               \\\n  }                                                                           \\\n                                                                              \\\n  static mtoc2_tensor_t mtoc2_##name##_complex_dim(                           \\\n      mtoc2_tensor_t a, int dim) {                                            \\\n    if (dim < 1) {                                                            \\\n      fprintf(stderr, "mtoc2: " #name "_complex_dim: dim must be >= 1 (got %d)\\n", dim); \\\n      abort();                                                                \\\n    }                                                                         \\\n    if (dim > a.ndim) {                                                       \\\n      long total = 1;                                                         \\\n      for (int i = 0; i < a.ndim; i++) total *= a.dims[i];                    \\\n      long out_dims[MTOC2_MAX_NDIM];                                          \\\n      int out_ndim = a.ndim;                                                  \\\n      for (int i = 0; i < a.ndim; i++) out_dims[i] = a.dims[i];               \\\n      mtoc2_tensor_t out = mtoc2_tensor_alloc_nd(out_ndim, out_dims);         \\\n      for (long i = 0; i < total; i++) {                                      \\\n        double xr = a.real[i];                                                \\\n        double xi = (a.imag != NULL) ? a.imag[i] : 0.0;                       \\\n        out.real[i] = (xr != 0.0 || xi != 0.0) ? 1.0 : 0.0;                   \\\n      }                                                                       \\\n      return out;                                                             \\\n    }                                                                         \\\n    int dimIdx = dim - 1;                                                     \\\n    long axis = a.dims[dimIdx];                                               \\\n    long before = 1;                                                          \\\n    for (int i = 0; i < dimIdx; i++) before *= a.dims[i];                     \\\n    long after = 1;                                                           \\\n    for (int i = dimIdx + 1; i < a.ndim; i++) after *= a.dims[i];             \\\n    long out_dims[MTOC2_MAX_NDIM];                                            \\\n    int out_ndim = a.ndim;                                                    \\\n    for (int i = 0; i < a.ndim; i++) out_dims[i] = a.dims[i];                 \\\n    out_dims[dimIdx] = 1;                                                     \\\n    mtoc2__squeeze_trailing_c(&out_ndim, out_dims);                           \\\n    mtoc2_tensor_t out = mtoc2_tensor_alloc_nd(out_ndim, out_dims);           \\\n    long slab = before * axis;                                                \\\n    for (long outer = 0; outer < after; outer++) {                            \\\n      long slabBase = outer * slab;                                           \\\n      for (long inner = 0; inner < before; inner++) {                         \\\n        double acc = (double)(EMPTY_RESULT);                                  \\\n        for (long k = 0; k < axis; k++) {                                     \\\n          long off = slabBase + inner + k * before;                           \\\n          double xr = a.real[off];                                            \\\n          double xi = (a.imag != NULL) ? a.imag[off] : 0.0;                   \\\n          int x = (xr != 0.0 || xi != 0.0);                                   \\\n          SHORT_BODY;                                                         \\\n        }                                                                     \\\n        out.real[outer * before + inner] = acc;                               \\\n      }                                                                       \\\n    }                                                                         \\\n    return out;                                                               \\\n  }\n\n/* Accumulator-statement macros. */\n#define MTOC2_CACC_SUM(acc, x) mtoc2_cadd((acc), (x))\n#define MTOC2_CACC_PROD(acc, x) mtoc2_cmul((acc), (x))\n#define MTOC2_CFIN_ID(acc, n) (acc)\n#define MTOC2_CFIN_MEAN(acc, n) mtoc2_cdiv((acc), mtoc2_cmake((double)(n), 0.0))\n\nMTOC2_DEFINE_CACCUM_REDUCTION(sum, mtoc2_cmake(0.0, 0.0), MTOC2_CACC_SUM, MTOC2_CFIN_ID)\nMTOC2_DEFINE_CACCUM_REDUCTION(prod, mtoc2_cmake(1.0, 0.0), MTOC2_CACC_PROD, MTOC2_CFIN_ID)\nMTOC2_DEFINE_CACCUM_REDUCTION(mean, mtoc2_cmake(0.0, 0.0), MTOC2_CACC_SUM, MTOC2_CFIN_MEAN)\n\nMTOC2_DEFINE_CMINMAX_REDUCTION(min, <)\nMTOC2_DEFINE_CMINMAX_REDUCTION(max, >)\n\nMTOC2_DEFINE_CLOGICAL_REDUCTION(any, 0,\n  if (x) { acc = 1.0; break; })\nMTOC2_DEFINE_CLOGICAL_REDUCTION(all, 1,\n  if (!x) { acc = 0.0; break; })\n',
   "tensor_reduce_real.h": '/* mtoc2 runtime helpers: real-tensor reductions.\n *\n * One macro per op generates two helpers:\n *\n *   mtoc2_<name>_all(a)       \u2014 reduce every element to a scalar.\n *   mtoc2_<name>_dim(a, dim)  \u2014 reduce along the 1-based axis `dim`,\n *                               returning a freshly-owned tensor.\n *\n * The `_dim` template mirrors numbl\'s `forEachSlice`: compute\n * `before = prod(dims[0..dim-2])`, `axis = dims[dim-1]`,\n * `after = prod(dims[dim..ndim-1])`. Walk the column-major buffer in\n * `(after \xD7 before)` fiber order with stride `before` between\n * elements along the reduced axis. Output dims are the input dims\n * with `dims[dim-1] = 1`, then trailing singletons stripped subject\n * to a 2-axis floor (matches the type system\'s\n * `tensorDoubleFromDims` rule).\n *\n * If `dim > a.ndim` the runtime emits a per-op no-op: every reducer\n * (sum/prod/mean/min/max) copies `a` as-is; the logical reducers\n * (any/all) emit an elementwise cast to {0, 1}. The transfer step\n * already proved the output shape, so this branch only fires when\n * the type-side dim/shape analysis can\'t fold to AxisAll.\n *\n * Real-only \u2014 complex is out of scope. Same-shape and column-major\n * conventions match the rest of mtoc2\'s tensor runtime.\n */\n\n#include <math.h>\n#include <stdlib.h>\n#include <string.h>\n\n/* Strip trailing singleton axes down to a 2-axis floor. Updates\n * `*ndim` in place; `dims` is the row buffer. */\nstatic void mtoc2__squeeze_trailing(int *ndim, long *dims) {\n  while (*ndim > 2 && dims[*ndim - 1] == 1) {\n    (*ndim)--;\n  }\n}\n\n/* Helper: reduce-all loop for accumulator-based reducers\n * (sum, prod, mean). `INIT` seeds the accumulator; `ACCUM(acc, x)`\n * is a C statement updating `acc`; `FINALIZE(acc, n)` is the final\n * transformation given the count. */\n#define MTOC2_DEFINE_ACCUM_REDUCTION(name, INIT, ACCUM, FINALIZE)             \\\n  static double mtoc2_##name##_all(mtoc2_tensor_t a) {                        \\\n    long n = 1;                                                               \\\n    for (int i = 0; i < a.ndim; i++) n *= a.dims[i];                          \\\n    double acc = (INIT);                                                      \\\n    for (long i = 0; i < n; i++) {                                            \\\n      double x = a.real[i];                                                   \\\n      ACCUM(acc, x);                                                          \\\n    }                                                                         \\\n    return FINALIZE(acc, n);                                                  \\\n  }                                                                           \\\n                                                                              \\\n  static mtoc2_tensor_t mtoc2_##name##_dim(mtoc2_tensor_t a, int dim) {       \\\n    if (dim < 1) {                                                            \\\n      fprintf(stderr, "mtoc2: " #name "_dim: dim must be >= 1 (got %d)\\n",    \\\n              dim);                                                           \\\n      abort();                                                                \\\n    }                                                                         \\\n    if (dim > a.ndim) {                                                       \\\n      /* No-op axis: output is same shape/data as input (fresh copy). */      \\\n      long total = 1;                                                         \\\n      for (int i = 0; i < a.ndim; i++) total *= a.dims[i];                    \\\n      mtoc2_tensor_t out;                                                     \\\n      out.ndim = a.ndim;                                                      \\\n      for (int i = 0; i < a.ndim; i++) out.dims[i] = a.dims[i];               \\\n      out.real = mtoc2_alloc((size_t)total * sizeof(double));                 \\\n      out.imag = NULL;                                                        \\\n      memcpy(out.real, a.real, (size_t)total * sizeof(double));               \\\n      return out;                                                             \\\n    }                                                                         \\\n    int dimIdx = dim - 1;                                                     \\\n    long axis = a.dims[dimIdx];                                               \\\n    long before = 1;                                                          \\\n    for (int i = 0; i < dimIdx; i++) before *= a.dims[i];                     \\\n    long after = 1;                                                           \\\n    for (int i = dimIdx + 1; i < a.ndim; i++) after *= a.dims[i];             \\\n    long out_total = before * after;                                          \\\n    long out_dims[MTOC2_MAX_NDIM];                                            \\\n    int out_ndim = a.ndim;                                                    \\\n    for (int i = 0; i < a.ndim; i++) out_dims[i] = a.dims[i];                 \\\n    out_dims[dimIdx] = 1;                                                     \\\n    mtoc2__squeeze_trailing(&out_ndim, out_dims);                             \\\n    mtoc2_tensor_t out = mtoc2_tensor_alloc_nd(out_ndim, out_dims);           \\\n    long slab = before * axis;                                                \\\n    for (long outer = 0; outer < after; outer++) {                            \\\n      long slabBase = outer * slab;                                           \\\n      for (long inner = 0; inner < before; inner++) {                         \\\n        double acc = (INIT);                                                  \\\n        for (long k = 0; k < axis; k++) {                                     \\\n          double x = a.real[slabBase + inner + k * before];                   \\\n          ACCUM(acc, x);                                                      \\\n        }                                                                     \\\n        out.real[outer * before + inner] = FINALIZE(acc, axis);               \\\n      }                                                                       \\\n    }                                                                         \\\n    (void)out_total;                                                          \\\n    return out;                                                               \\\n  }\n\n/* Helper: reduce-all loop for min/max. Seed is NaN; first non-NaN\n * element captures, later non-NaN elements compare via CMP.\n * Mirrors numbl\'s NaN-skip convention. */\n#define MTOC2_DEFINE_MINMAX_REDUCTION(name, CMP)                              \\\n  static double mtoc2_##name##_all(mtoc2_tensor_t a) {                        \\\n    long n = 1;                                                               \\\n    for (int i = 0; i < a.ndim; i++) n *= a.dims[i];                          \\\n    double acc = NAN;                                                         \\\n    for (long i = 0; i < n; i++) {                                            \\\n      double x = a.real[i];                                                   \\\n      if (x != x) continue; /* skip NaN */                                    \\\n      if (acc != acc || (x CMP acc)) acc = x;                                 \\\n    }                                                                         \\\n    return acc;                                                               \\\n  }                                                                           \\\n                                                                              \\\n  static mtoc2_tensor_t mtoc2_##name##_dim(mtoc2_tensor_t a, int dim) {       \\\n    if (dim < 1) {                                                            \\\n      fprintf(stderr, "mtoc2: " #name "_dim: dim must be >= 1 (got %d)\\n",    \\\n              dim);                                                           \\\n      abort();                                                                \\\n    }                                                                         \\\n    if (dim > a.ndim) {                                                       \\\n      long total = 1;                                                         \\\n      for (int i = 0; i < a.ndim; i++) total *= a.dims[i];                    \\\n      mtoc2_tensor_t out;                                                     \\\n      out.ndim = a.ndim;                                                      \\\n      for (int i = 0; i < a.ndim; i++) out.dims[i] = a.dims[i];               \\\n      out.real = mtoc2_alloc((size_t)total * sizeof(double));                 \\\n      out.imag = NULL;                                                        \\\n      memcpy(out.real, a.real, (size_t)total * sizeof(double));               \\\n      return out;                                                             \\\n    }                                                                         \\\n    int dimIdx = dim - 1;                                                     \\\n    long axis = a.dims[dimIdx];                                               \\\n    long before = 1;                                                          \\\n    for (int i = 0; i < dimIdx; i++) before *= a.dims[i];                     \\\n    long after = 1;                                                           \\\n    for (int i = dimIdx + 1; i < a.ndim; i++) after *= a.dims[i];             \\\n    long out_dims[MTOC2_MAX_NDIM];                                            \\\n    int out_ndim = a.ndim;                                                    \\\n    for (int i = 0; i < a.ndim; i++) out_dims[i] = a.dims[i];                 \\\n    out_dims[dimIdx] = 1;                                                     \\\n    mtoc2__squeeze_trailing(&out_ndim, out_dims);                             \\\n    mtoc2_tensor_t out = mtoc2_tensor_alloc_nd(out_ndim, out_dims);           \\\n    long slab = before * axis;                                                \\\n    for (long outer = 0; outer < after; outer++) {                            \\\n      long slabBase = outer * slab;                                           \\\n      for (long inner = 0; inner < before; inner++) {                         \\\n        double acc = NAN;                                                     \\\n        for (long k = 0; k < axis; k++) {                                     \\\n          double x = a.real[slabBase + inner + k * before];                   \\\n          if (x != x) continue;                                               \\\n          if (acc != acc || (x CMP acc)) acc = x;                             \\\n        }                                                                     \\\n        out.real[outer * before + inner] = acc;                               \\\n      }                                                                       \\\n    }                                                                         \\\n    return out;                                                               \\\n  }\n\n/* Helper: any/all reduction. Short-circuits per fiber.\n * `EMPTY_RESULT` is the value when the reduced fiber is empty:\n *  - any: 0 (no element is nonzero in an empty set)\n *  - all: 1 (vacuously true)\n * `SHORT(acc, x)` updates `acc` if `x` triggers the short-circuit;\n * `done` short-circuits the inner loop once `acc` settles. */\n#define MTOC2_DEFINE_LOGICAL_REDUCTION(name, EMPTY_RESULT, SHORT_BODY)        \\\n  static double mtoc2_##name##_all(mtoc2_tensor_t a) {                        \\\n    long n = 1;                                                               \\\n    for (int i = 0; i < a.ndim; i++) n *= a.dims[i];                          \\\n    if (n == 0) return (double)(EMPTY_RESULT);                                \\\n    double acc = (double)(EMPTY_RESULT);                                      \\\n    for (long i = 0; i < n; i++) {                                            \\\n      double x = a.real[i];                                                   \\\n      SHORT_BODY;                                                             \\\n    }                                                                         \\\n    return acc;                                                               \\\n  }                                                                           \\\n                                                                              \\\n  static mtoc2_tensor_t mtoc2_##name##_dim(mtoc2_tensor_t a, int dim) {       \\\n    if (dim < 1) {                                                            \\\n      fprintf(stderr, "mtoc2: " #name "_dim: dim must be >= 1 (got %d)\\n",    \\\n              dim);                                                           \\\n      abort();                                                                \\\n    }                                                                         \\\n    if (dim > a.ndim) {                                                       \\\n      /* Numbl\'s `logicalAlongDim` with `dim > ndims` does an elementwise   \\\n       * cast to logical: each element becomes 1.0 if nonzero else 0.0. */   \\\n      long total = 1;                                                         \\\n      for (int i = 0; i < a.ndim; i++) total *= a.dims[i];                    \\\n      long out_dims[MTOC2_MAX_NDIM];                                          \\\n      int out_ndim = a.ndim;                                                  \\\n      for (int i = 0; i < a.ndim; i++) out_dims[i] = a.dims[i];               \\\n      mtoc2_tensor_t out = mtoc2_tensor_alloc_nd(out_ndim, out_dims);         \\\n      for (long i = 0; i < total; i++) {                                      \\\n        out.real[i] = (a.real[i] != 0.0) ? 1.0 : 0.0;                         \\\n      }                                                                       \\\n      return out;                                                             \\\n    }                                                                         \\\n    int dimIdx = dim - 1;                                                     \\\n    long axis = a.dims[dimIdx];                                               \\\n    long before = 1;                                                          \\\n    for (int i = 0; i < dimIdx; i++) before *= a.dims[i];                     \\\n    long after = 1;                                                           \\\n    for (int i = dimIdx + 1; i < a.ndim; i++) after *= a.dims[i];             \\\n    long out_dims[MTOC2_MAX_NDIM];                                            \\\n    int out_ndim = a.ndim;                                                    \\\n    for (int i = 0; i < a.ndim; i++) out_dims[i] = a.dims[i];                 \\\n    out_dims[dimIdx] = 1;                                                     \\\n    mtoc2__squeeze_trailing(&out_ndim, out_dims);                             \\\n    mtoc2_tensor_t out = mtoc2_tensor_alloc_nd(out_ndim, out_dims);           \\\n    long slab = before * axis;                                                \\\n    for (long outer = 0; outer < after; outer++) {                            \\\n      long slabBase = outer * slab;                                           \\\n      for (long inner = 0; inner < before; inner++) {                         \\\n        double acc = (double)(EMPTY_RESULT);                                  \\\n        for (long k = 0; k < axis; k++) {                                     \\\n          double x = a.real[slabBase + inner + k * before];                   \\\n          SHORT_BODY;                                                         \\\n        }                                                                     \\\n        out.real[outer * before + inner] = acc;                               \\\n      }                                                                       \\\n    }                                                                         \\\n    return out;                                                               \\\n  }\n\n/* Identity finalizer (sum, prod): pass the accumulator through. */\n#define MTOC2_FIN_ID(acc, n) (acc)\n/* Mean finalizer: divide by element count. Empty fiber \u2192 0/0 = NaN. */\n#define MTOC2_FIN_MEAN(acc, n) ((double)(acc) / (double)(n))\n\n/* Accumulator-statement macros. Wrapped in `do {} while(0)` to keep\n * them safe inside any single-statement context the templates use. */\n#define MTOC2_ACC_SUM(acc, x) do { (acc) += (x); } while (0)\n#define MTOC2_ACC_PROD(acc, x) do { (acc) *= (x); } while (0)\n\nMTOC2_DEFINE_ACCUM_REDUCTION(sum, 0.0, MTOC2_ACC_SUM, MTOC2_FIN_ID)\nMTOC2_DEFINE_ACCUM_REDUCTION(prod, 1.0, MTOC2_ACC_PROD, MTOC2_FIN_ID)\nMTOC2_DEFINE_ACCUM_REDUCTION(mean, 0.0, MTOC2_ACC_SUM, MTOC2_FIN_MEAN)\n\nMTOC2_DEFINE_MINMAX_REDUCTION(min, <)\nMTOC2_DEFINE_MINMAX_REDUCTION(max, >)\n\n/* `any` ignores NaN (MATLAB: any(NaN) is 0); `x == x` excludes it so a\n * NaN doesn\'t wrongly short-circuit to true. `all` tests `x == 0.0`,\n * which NaN already fails, so it needs no guard. */\nMTOC2_DEFINE_LOGICAL_REDUCTION(any, 0,\n  if (x != 0.0 && x == x) { acc = 1.0; break; })\nMTOC2_DEFINE_LOGICAL_REDUCTION(all, 1,\n  if (x == 0.0) { acc = 0.0; break; })\n',
   "tensor_repmat.h": '/* mtoc2 runtime helper: `repmat(A, reps)` \u2014 tile a tensor by\n * replicating it along each axis.\n *\n * Numbl\'s reference is the `repmat` builtin in\n * `interpreter/builtins/array-manipulation.ts` (the tensor branch).\n *\n * Contract:\n *   - `in` is the source tensor (real, owned-value invariant unchanged).\n *   - `nreps` is the number of replication factors supplied (1..MTOC2_MAX_NDIM).\n *   - `reps_in[i]` is the per-axis replication factor; negative values\n *     clamp to 0 (yielding an empty axis), matching numbl/MATLAB.\n *\n * Output shape is `padShape[i] * padReps[i]` where the input\'s shape\n * and the reps vector are both right-padded with 1s to a common rank\n * `max(in.ndim, nreps)`. Result is freshly owned; `imag` is NULL.\n *\n * Algorithm: copy the input data into the start of the output buffer\n * (column-major flat layout is preserved when trailing dims are 1),\n * then iteratively expand along each axis. For axis `d` with rep > 1,\n * we walk the existing blocks of size `blockSize = prod(curShape[0..d])`\n * in reverse order and replicate each block `rep` times consecutively.\n * Reverse order avoids overwriting source data; `memmove` covers the\n * b=0 in-place case where the block stays at its original offset.\n */\n\n#include <string.h>\n#include <stdio.h>\n#include <stdlib.h>\n\nstatic mtoc2_tensor_t mtoc2_tensor_repmat(mtoc2_tensor_t in, int nreps,\n                                          const long *reps_in) {\n  if (nreps < 1 || nreps > MTOC2_MAX_NDIM) {\n    fprintf(stderr,\n      "mtoc2: repmat nreps %d out of range [1, %d]\\n", nreps, MTOC2_MAX_NDIM);\n    abort();\n  }\n  long reps[MTOC2_MAX_NDIM];\n  for (int i = 0; i < nreps; i++) reps[i] = reps_in[i] < 0 ? 0 : reps_in[i];\n\n  int in_ndim = in.ndim;\n  int out_ndim = nreps > in_ndim ? nreps : in_ndim;\n  if (out_ndim > MTOC2_MAX_NDIM) {\n    fprintf(stderr,\n      "mtoc2: repmat output ndim %d exceeds %d\\n", out_ndim, MTOC2_MAX_NDIM);\n    abort();\n  }\n\n  long padShape[MTOC2_MAX_NDIM];\n  long padReps[MTOC2_MAX_NDIM];\n  long outDims[MTOC2_MAX_NDIM];\n  for (int i = 0; i < out_ndim; i++) {\n    padShape[i] = i < in_ndim ? in.dims[i] : 1;\n    padReps[i] = i < nreps ? reps[i] : 1;\n    outDims[i] = padShape[i] * padReps[i];\n  }\n\n  mtoc2_tensor_t out = mtoc2_tensor_alloc_nd(out_ndim, outDims);\n\n  size_t outTotal = 1;\n  for (int i = 0; i < out_ndim; i++) outTotal *= (size_t)outDims[i];\n  if (outTotal == 0) return out;\n\n  size_t inTotal = 1;\n  for (int i = 0; i < in_ndim; i++) inTotal *= (size_t)in.dims[i];\n  if (inTotal == 0) return out;\n\n  /* Initial copy: input\'s data laid out in column-major with shape\n   * `in.dims` matches the same flat layout under `padShape` (trailing\n   * 1s don\'t change flat indexing). */\n  memcpy(out.real, in.real, inTotal * sizeof(double));\n\n  long curShape[MTOC2_MAX_NDIM];\n  for (int i = 0; i < out_ndim; i++) curShape[i] = padShape[i];\n  size_t curTotal = inTotal;\n\n  for (int d = 0; d < out_ndim; d++) {\n    long rep = padReps[d];\n    if (rep == 1) continue;\n\n    size_t blockSize = 1;\n    for (int i = 0; i <= d; i++) blockSize *= (size_t)curShape[i];\n\n    if (rep == 0 || blockSize == 0) {\n      curShape[d] *= rep;\n      curTotal = 0;\n      /* Once curTotal is 0, no further work needed \u2014 outTotal is also\n       * 0 (because outDims[d] = padShape[d] * 0 = 0). The alloc above\n       * already produced a zero-element tensor; bail out. */\n      return out;\n    }\n\n    size_t numBlocks = curTotal / blockSize;\n    /* Walk blocks in reverse so writes don\'t clobber as-yet-unread\n     * source blocks. Each block of `blockSize` doubles to `blockSize\n     * * rep` consecutive slots at offset `b * blockSize * rep`. */\n    for (size_t b = numBlocks; b > 0;) {\n      b--;\n      size_t srcOff = b * blockSize;\n      size_t dstBase = b * blockSize * (size_t)rep;\n      if (dstBase != srcOff) {\n        memmove(out.real + dstBase, out.real + srcOff,\n                blockSize * sizeof(double));\n      }\n      for (long r = 1; r < rep; r++) {\n        memcpy(out.real + dstBase + (size_t)r * blockSize,\n               out.real + dstBase,\n               blockSize * sizeof(double));\n      }\n    }\n\n    curShape[d] *= rep;\n    curTotal *= (size_t)rep;\n  }\n\n  return out;\n}\n\n/* Complex-input sibling: tiles both lanes. Tolerates `in.imag == NULL`\n * (a real tensor that flowed in via a complex-typed route) by zero-\n * filling the output imag lane. */\nstatic mtoc2_tensor_t mtoc2_tensor_repmat_complex(mtoc2_tensor_t in,\n                                                  int nreps,\n                                                  const long *reps_in) {\n  if (nreps < 1 || nreps > MTOC2_MAX_NDIM) {\n    fprintf(stderr,\n      "mtoc2: repmat_complex nreps %d out of range [1, %d]\\n",\n      nreps, MTOC2_MAX_NDIM);\n    abort();\n  }\n  long reps[MTOC2_MAX_NDIM];\n  for (int i = 0; i < nreps; i++) reps[i] = reps_in[i] < 0 ? 0 : reps_in[i];\n\n  int in_ndim = in.ndim;\n  int out_ndim = nreps > in_ndim ? nreps : in_ndim;\n  if (out_ndim > MTOC2_MAX_NDIM) {\n    fprintf(stderr,\n      "mtoc2: repmat_complex output ndim %d exceeds %d\\n",\n      out_ndim, MTOC2_MAX_NDIM);\n    abort();\n  }\n\n  long padShape[MTOC2_MAX_NDIM];\n  long padReps[MTOC2_MAX_NDIM];\n  long outDims[MTOC2_MAX_NDIM];\n  for (int i = 0; i < out_ndim; i++) {\n    padShape[i] = i < in_ndim ? in.dims[i] : 1;\n    padReps[i] = i < nreps ? reps[i] : 1;\n    outDims[i] = padShape[i] * padReps[i];\n  }\n\n  mtoc2_tensor_t out = mtoc2_tensor_alloc_nd_complex(out_ndim, outDims);\n\n  size_t outTotal = 1;\n  for (int i = 0; i < out_ndim; i++) outTotal *= (size_t)outDims[i];\n  if (outTotal == 0) return out;\n\n  size_t inTotal = 1;\n  for (int i = 0; i < in_ndim; i++) inTotal *= (size_t)in.dims[i];\n  if (inTotal == 0) {\n    memset(out.imag, 0, outTotal * sizeof(double));\n    return out;\n  }\n\n  int srcHasImag = (in.imag != NULL);\n\n  memcpy(out.real, in.real, inTotal * sizeof(double));\n  if (srcHasImag) {\n    memcpy(out.imag, in.imag, inTotal * sizeof(double));\n  } else {\n    memset(out.imag, 0, inTotal * sizeof(double));\n  }\n\n  long curShape[MTOC2_MAX_NDIM];\n  for (int i = 0; i < out_ndim; i++) curShape[i] = padShape[i];\n  size_t curTotal = inTotal;\n\n  for (int d = 0; d < out_ndim; d++) {\n    long rep = padReps[d];\n    if (rep == 1) continue;\n\n    size_t blockSize = 1;\n    for (int i = 0; i <= d; i++) blockSize *= (size_t)curShape[i];\n\n    if (rep == 0 || blockSize == 0) {\n      curShape[d] *= rep;\n      curTotal = 0;\n      return out;\n    }\n\n    size_t numBlocks = curTotal / blockSize;\n    for (size_t b = numBlocks; b > 0;) {\n      b--;\n      size_t srcOff = b * blockSize;\n      size_t dstBase = b * blockSize * (size_t)rep;\n      if (dstBase != srcOff) {\n        memmove(out.real + dstBase, out.real + srcOff,\n                blockSize * sizeof(double));\n        memmove(out.imag + dstBase, out.imag + srcOff,\n                blockSize * sizeof(double));\n      }\n      for (long r = 1; r < rep; r++) {\n        memcpy(out.real + dstBase + (size_t)r * blockSize,\n               out.real + dstBase,\n               blockSize * sizeof(double));\n        memcpy(out.imag + dstBase + (size_t)r * blockSize,\n               out.imag + dstBase,\n               blockSize * sizeof(double));\n      }\n    }\n\n    curShape[d] *= rep;\n    curTotal *= (size_t)rep;\n  }\n\n  return out;\n}\n',
   "tensor_reshape_nd.h": '/* mtoc2 runtime helper: reshape a real tensor to an N-D shape.\n *\n * Receives the input tensor by value (`mtoc2_tensor_t`) plus a\n * caller-supplied dim list (`ndim`, `dims`). Allocates a fresh\n * output tensor via `mtoc2_tensor_alloc_nd` and copies the input\'s\n * column-major buffer wholesale \u2014 reshape is a layout reinterpret,\n * so the linear element order is unchanged.\n *\n * `dims[i] == -1` is the MATLAB `[]` auto-infer slot: the helper\n * scans for a single -1 and fills it from `in_total / prod(others)`.\n * Two or more sentinels, or an `in_total` not divisible by the\n * explicit dims, abort with a clear message.\n *\n * Element-count check: the lowerer enforces `prod(input.dims) ==\n * prod(dims)` at translate time when the input shape is statically\n * known. This helper is the fallback when the input shape only\n * appears at runtime (e.g. a tensor function param whose\n * specialization arg type came in without a concrete shape). On\n * mismatch it prints to stderr and aborts, matching numbl\'s\n * runtime-error surface.\n *\n * Real-only \u2014 mtoc2\'s tensor side is real-only today; the type\n * lattice rejects complex inputs at lowering. The output\'s `imag`\n * is NULL, set by `mtoc2_tensor_alloc_nd`.\n */\n\n#include <string.h>\n#include <stdio.h>\n#include <stdlib.h>\n\nstatic mtoc2_tensor_t mtoc2_reshape_nd(\n    mtoc2_tensor_t in, int ndim, const long *dims) {\n  size_t in_total = 1;\n  for (int i = 0; i < in.ndim; i++) in_total *= (size_t)in.dims[i];\n  /* Scan for at most one `-1` infer slot and the product of the\n   * remaining explicit dims. */\n  int infer_idx = -1;\n  size_t explicit_prod = 1;\n  for (int i = 0; i < ndim; i++) {\n    if (dims[i] == -1) {\n      if (infer_idx != -1) {\n        fprintf(stderr,\n          "mtoc2: reshape: at most one \'[]\' auto-infer slot allowed\\n");\n        abort();\n      }\n      infer_idx = i;\n    } else if (dims[i] < 0) {\n      fprintf(stderr,\n        "mtoc2: reshape: dim %d must be a non-negative integer "\n        "(got %ld)\\n", i + 1, dims[i]);\n      abort();\n    } else {\n      explicit_prod *= (size_t)dims[i];\n    }\n  }\n  long resolved_dims[MTOC2_MAX_NDIM];\n  for (int i = 0; i < ndim; i++) resolved_dims[i] = dims[i];\n  size_t out_total;\n  if (infer_idx != -1) {\n    if (explicit_prod == 0 && in_total != 0) {\n      fprintf(stderr,\n        "mtoc2: reshape: input has %zu elements but the explicit dims "\n        "around \'[]\' multiply to 0\\n", in_total);\n      abort();\n    }\n    if (explicit_prod > 0 && in_total % explicit_prod != 0) {\n      fprintf(stderr,\n        "mtoc2: reshape: input has %zu elements, not divisible by %zu "\n        "(the explicit dims around \'[]\')\\n", in_total, explicit_prod);\n      abort();\n    }\n    resolved_dims[infer_idx] =\n      (explicit_prod == 0) ? 0 : (long)(in_total / explicit_prod);\n    out_total = in_total;\n  } else {\n    out_total = explicit_prod;\n    if (in_total != out_total) {\n      fprintf(stderr,\n        "mtoc2: reshape: number of elements must not change "\n        "(in=%zu, out=%zu)\\n", in_total, out_total);\n      abort();\n    }\n  }\n  mtoc2_tensor_t out = mtoc2_tensor_alloc_nd(ndim, resolved_dims);\n  if (out_total > 0)\n    memcpy(out.real, in.real, out_total * sizeof(double));\n  return out;\n}\n',
   "tensor_reshape_nd_complex.h": '/* mtoc2 runtime helper: reshape a complex tensor to an N-D shape.\n *\n * Sibling of `mtoc2_reshape_nd`. Same `-1` auto-infer slot, same\n * element-count check, same runtime-error surface \u2014 the only\n * difference is the output is allocated via\n * `mtoc2_tensor_alloc_nd_complex` (both lanes) and both lanes get\n * memcpy\'d from the input. Reshape is a layout reinterpret, so the\n * linear element order is unchanged on either lane.\n *\n * Tolerates `in.imag == NULL` (a real tensor flowing through a\n * complex-typed reshape route) by zeroing the output imag lane.\n */\n\n#include <string.h>\n#include <stdio.h>\n#include <stdlib.h>\n\nstatic mtoc2_tensor_t mtoc2_reshape_nd_complex(\n    mtoc2_tensor_t in, int ndim, const long *dims) {\n  size_t in_total = 1;\n  for (int i = 0; i < in.ndim; i++) in_total *= (size_t)in.dims[i];\n  int infer_idx = -1;\n  size_t explicit_prod = 1;\n  for (int i = 0; i < ndim; i++) {\n    if (dims[i] == -1) {\n      if (infer_idx != -1) {\n        fprintf(stderr,\n          "mtoc2: reshape: at most one \'[]\' auto-infer slot allowed\\n");\n        abort();\n      }\n      infer_idx = i;\n    } else if (dims[i] < 0) {\n      fprintf(stderr,\n        "mtoc2: reshape: dim %d must be a non-negative integer "\n        "(got %ld)\\n", i + 1, dims[i]);\n      abort();\n    } else {\n      explicit_prod *= (size_t)dims[i];\n    }\n  }\n  long resolved_dims[MTOC2_MAX_NDIM];\n  for (int i = 0; i < ndim; i++) resolved_dims[i] = dims[i];\n  size_t out_total;\n  if (infer_idx != -1) {\n    if (explicit_prod == 0 && in_total != 0) {\n      fprintf(stderr,\n        "mtoc2: reshape: input has %zu elements but the explicit dims "\n        "around \'[]\' multiply to 0\\n", in_total);\n      abort();\n    }\n    if (explicit_prod > 0 && in_total % explicit_prod != 0) {\n      fprintf(stderr,\n        "mtoc2: reshape: input has %zu elements, not divisible by %zu "\n        "(the explicit dims around \'[]\')\\n", in_total, explicit_prod);\n      abort();\n    }\n    resolved_dims[infer_idx] =\n      (explicit_prod == 0) ? 0 : (long)(in_total / explicit_prod);\n    out_total = in_total;\n  } else {\n    out_total = explicit_prod;\n    if (in_total != out_total) {\n      fprintf(stderr,\n        "mtoc2: reshape: number of elements must not change "\n        "(in=%zu, out=%zu)\\n", in_total, out_total);\n      abort();\n    }\n  }\n  mtoc2_tensor_t out = mtoc2_tensor_alloc_nd_complex(ndim, resolved_dims);\n  if (out_total > 0) {\n    memcpy(out.real, in.real, out_total * sizeof(double));\n    if (in.imag != NULL) {\n      memcpy(out.imag, in.imag, out_total * sizeof(double));\n    } else {\n      memset(out.imag, 0, out_total * sizeof(double));\n    }\n  }\n  return out;\n}\n',
   "tensor_size.h": "/* mtoc2 runtime helper: `size(t)` \u2014 returns a freshly-owned 1\xD7ndim\n * row tensor whose elements are the input's dim sizes as doubles.\n * MATLAB / numbl semantics: scalars and vectors return at least a\n * 2-element row (the type system already pads to ndim \u2265 2; this\n * helper just copies dims[] into a row vector).\n *\n * For `size(t, k)` mtoc2 emits a scalar `(double)t.dims[k-1]` inline\n * \u2014 no runtime helper needed for that form.\n */\n\n#include <stdlib.h>\n\nstatic mtoc2_tensor_t mtoc2_tensor_size_row(mtoc2_tensor_t a) {\n  long n = a.ndim;\n  mtoc2_tensor_t r;\n  r.real = mtoc2_alloc((size_t)n * sizeof(double));\n  r.imag = NULL;\n  r.ndim = 2;\n  r.dims[0] = 1;\n  r.dims[1] = n;\n  for (long i = 0; i < n; i++) r.real[i] = (double)a.dims[i];\n  return r;\n}\n",
-  "tensor_sort_real.h": '/* mtoc2 runtime helper: stable sort on a tensor.\n *\n *   mtoc2_sort_real(a, descending)\n *     `b = sort(a)` / `sort(a, \'ascend\'|\'descend\')` \u2014 returns a\n *     freshly-owned tensor of the same shape as `a`, with the flat\n *     (column-major) entries sorted in the requested direction.\n *\n *   mtoc2_sort_real_2(a, descending, &out_v, &out_i)\n *     `[v, i] = sort(...)` \u2014 fills `*out_v` with the sorted values\n *     and `*out_i` with 1-based original positions.\n *\n *   mtoc2_sort_complex / mtoc2_sort_complex_2\n *     Complex-input siblings. Numbl / MATLAB sort complex by\n *     magnitude (hypot), tiebreak by phase (atan2). Tolerates\n *     `a.imag == NULL` (real-input flowed through a complex route)\n *     by treating imag as zero.\n *\n * Sort is stable in both directions: ties resolve by ascending\n * original index, matching numbl\'s behaviour (verified against\n * `sort([5 2 8 1 2], \'descend\')` \u2192 indices `3 1 2 5 4`).\n *\n * The lowering layer restricts the input to a 1\xD7N row vector or N\xD71\n * column vector for v1; the helper itself walks the column-major\n * flat buffer and would handle any rank, but the type system rejects\n * the higher-rank cases until the per-axis form is plumbed through.\n */\n\n#include <math.h>\n#include <stdlib.h>\n#include <string.h>\n\ntypedef struct {\n  double v;\n  long ix;\n} mtoc2_sort_pair_t;\n\n/* NaN ranks as the maximum (MATLAB): last when ascending, first when\n * descending. Without this, NaN compares false both ways and falls to\n * the index tie-break, leaving the comparator non-transitive \u2014 which is\n * undefined behavior for qsort and corrupts the array. */\nstatic int mtoc2_sort_cmp_asc(const void *pa, const void *pb) {\n  const mtoc2_sort_pair_t *a = (const mtoc2_sort_pair_t *)pa;\n  const mtoc2_sort_pair_t *b = (const mtoc2_sort_pair_t *)pb;\n  int an = a->v != a->v, bn = b->v != b->v;\n  if (an || bn) {\n    if (!(an && bn)) return an ? 1 : -1; /* NaN sorts last */\n  } else {\n    if (a->v < b->v) return -1;\n    if (a->v > b->v) return 1;\n  }\n  if (a->ix < b->ix) return -1;\n  if (a->ix > b->ix) return 1;\n  return 0;\n}\n\nstatic int mtoc2_sort_cmp_desc(const void *pa, const void *pb) {\n  const mtoc2_sort_pair_t *a = (const mtoc2_sort_pair_t *)pa;\n  const mtoc2_sort_pair_t *b = (const mtoc2_sort_pair_t *)pb;\n  int an = a->v != a->v, bn = b->v != b->v;\n  if (an || bn) {\n    if (!(an && bn)) return an ? -1 : 1; /* NaN sorts first */\n  } else {\n    if (a->v > b->v) return -1;\n    if (a->v < b->v) return 1;\n  }\n  /* Tie-break still by ascending original index \u2014 both numbl and\n   * MATLAB keep ties in original order in either direction. */\n  if (a->ix < b->ix) return -1;\n  if (a->ix > b->ix) return 1;\n  return 0;\n}\n\nstatic mtoc2_tensor_t mtoc2_sort_real(mtoc2_tensor_t a, int descending) {\n  long n = 1;\n  for (int i = 0; i < a.ndim; i++) n *= a.dims[i];\n  mtoc2_tensor_t r;\n  r.real = mtoc2_alloc((size_t)n * sizeof(double));\n  r.imag = NULL;\n  r.ndim = a.ndim;\n  for (int i = 0; i < a.ndim; i++) r.dims[i] = a.dims[i];\n  if (n == 0) return r;\n  mtoc2_sort_pair_t *buf =\n    (mtoc2_sort_pair_t *)malloc((size_t)n * sizeof(mtoc2_sort_pair_t));\n  if (!buf) {\n    fprintf(stderr, "mtoc2: out of memory (sort buffer)\\n");\n    abort();\n  }\n  for (long i = 0; i < n; i++) {\n    buf[i].v = a.real[i];\n    buf[i].ix = i;\n  }\n  qsort(buf, (size_t)n, sizeof(mtoc2_sort_pair_t),\n        descending ? mtoc2_sort_cmp_desc : mtoc2_sort_cmp_asc);\n  for (long i = 0; i < n; i++) r.real[i] = buf[i].v;\n  free(buf);\n  return r;\n}\n\nstatic void mtoc2_sort_real_2(mtoc2_tensor_t a, int descending,\n                              mtoc2_tensor_t *out_v, mtoc2_tensor_t *out_i) {\n  long n = 1;\n  for (int i = 0; i < a.ndim; i++) n *= a.dims[i];\n  mtoc2_tensor_t v;\n  mtoc2_tensor_t ix;\n  v.real = mtoc2_alloc((size_t)n * sizeof(double));\n  v.imag = NULL;\n  v.ndim = a.ndim;\n  for (int i = 0; i < a.ndim; i++) v.dims[i] = a.dims[i];\n  ix.real = mtoc2_alloc((size_t)n * sizeof(double));\n  ix.imag = NULL;\n  ix.ndim = a.ndim;\n  for (int i = 0; i < a.ndim; i++) ix.dims[i] = a.dims[i];\n  if (n > 0) {\n    mtoc2_sort_pair_t *buf =\n      (mtoc2_sort_pair_t *)malloc((size_t)n * sizeof(mtoc2_sort_pair_t));\n    if (!buf) {\n      fprintf(stderr, "mtoc2: out of memory (sort buffer)\\n");\n      abort();\n    }\n    for (long i = 0; i < n; i++) {\n      buf[i].v = a.real[i];\n      buf[i].ix = i;\n    }\n    qsort(buf, (size_t)n, sizeof(mtoc2_sort_pair_t),\n          descending ? mtoc2_sort_cmp_desc : mtoc2_sort_cmp_asc);\n    for (long i = 0; i < n; i++) {\n      v.real[i] = buf[i].v;\n      ix.real[i] = (double)(buf[i].ix + 1);\n    }\n    free(buf);\n  }\n  mtoc2_tensor_assign(out_v, v);\n  mtoc2_tensor_assign(out_i, ix);\n}\n\ntypedef struct {\n  double mag;\n  double phase;\n  long ix;\n} mtoc2_sort_complex_pair_t;\n\nstatic int mtoc2_sort_cmp_complex_asc(const void *pa, const void *pb) {\n  const mtoc2_sort_complex_pair_t *a = (const mtoc2_sort_complex_pair_t *)pa;\n  const mtoc2_sort_complex_pair_t *b = (const mtoc2_sort_complex_pair_t *)pb;\n  if (a->mag < b->mag) return -1;\n  if (a->mag > b->mag) return 1;\n  if (a->phase < b->phase) return -1;\n  if (a->phase > b->phase) return 1;\n  if (a->ix < b->ix) return -1;\n  if (a->ix > b->ix) return 1;\n  return 0;\n}\n\nstatic int mtoc2_sort_cmp_complex_desc(const void *pa, const void *pb) {\n  const mtoc2_sort_complex_pair_t *a = (const mtoc2_sort_complex_pair_t *)pa;\n  const mtoc2_sort_complex_pair_t *b = (const mtoc2_sort_complex_pair_t *)pb;\n  if (a->mag > b->mag) return -1;\n  if (a->mag < b->mag) return 1;\n  if (a->phase > b->phase) return -1;\n  if (a->phase < b->phase) return 1;\n  if (a->ix < b->ix) return -1;\n  if (a->ix > b->ix) return 1;\n  return 0;\n}\n\nstatic mtoc2_tensor_t mtoc2_sort_complex(mtoc2_tensor_t a, int descending) {\n  long n = 1;\n  for (int i = 0; i < a.ndim; i++) n *= a.dims[i];\n  mtoc2_tensor_t r = mtoc2_tensor_alloc_nd_complex(a.ndim, a.dims);\n  if (n == 0) return r;\n  int srcHasImag = (a.imag != NULL);\n  if (!srcHasImag) memset(r.imag, 0, (size_t)n * sizeof(double));\n  mtoc2_sort_complex_pair_t *buf =\n    (mtoc2_sort_complex_pair_t *)malloc(\n      (size_t)n * sizeof(mtoc2_sort_complex_pair_t));\n  if (!buf) {\n    fprintf(stderr, "mtoc2: out of memory (sort complex buffer)\\n");\n    abort();\n  }\n  for (long i = 0; i < n; i++) {\n    double re = a.real[i];\n    double im = srcHasImag ? a.imag[i] : 0.0;\n    buf[i].mag = hypot(re, im);\n    buf[i].phase = atan2(im, re);\n    buf[i].ix = i;\n  }\n  qsort(buf, (size_t)n, sizeof(mtoc2_sort_complex_pair_t),\n        descending ? mtoc2_sort_cmp_complex_desc\n                   : mtoc2_sort_cmp_complex_asc);\n  for (long i = 0; i < n; i++) {\n    r.real[i] = a.real[buf[i].ix];\n    r.imag[i] = srcHasImag ? a.imag[buf[i].ix] : 0.0;\n  }\n  free(buf);\n  return r;\n}\n\nstatic void mtoc2_sort_complex_2(mtoc2_tensor_t a, int descending,\n                                 mtoc2_tensor_t *out_v, mtoc2_tensor_t *out_i) {\n  long n = 1;\n  for (int i = 0; i < a.ndim; i++) n *= a.dims[i];\n  mtoc2_tensor_t v = mtoc2_tensor_alloc_nd_complex(a.ndim, a.dims);\n  mtoc2_tensor_t ix;\n  ix.real = mtoc2_alloc((size_t)n * sizeof(double));\n  ix.imag = NULL;\n  ix.ndim = a.ndim;\n  for (int i = 0; i < a.ndim; i++) ix.dims[i] = a.dims[i];\n  if (n > 0) {\n    int srcHasImag = (a.imag != NULL);\n    if (!srcHasImag) memset(v.imag, 0, (size_t)n * sizeof(double));\n    mtoc2_sort_complex_pair_t *buf =\n      (mtoc2_sort_complex_pair_t *)malloc(\n        (size_t)n * sizeof(mtoc2_sort_complex_pair_t));\n    if (!buf) {\n      fprintf(stderr, "mtoc2: out of memory (sort complex buffer)\\n");\n      abort();\n    }\n    for (long i = 0; i < n; i++) {\n      double re = a.real[i];\n      double im = srcHasImag ? a.imag[i] : 0.0;\n      buf[i].mag = hypot(re, im);\n      buf[i].phase = atan2(im, re);\n      buf[i].ix = i;\n    }\n    qsort(buf, (size_t)n, sizeof(mtoc2_sort_complex_pair_t),\n          descending ? mtoc2_sort_cmp_complex_desc\n                     : mtoc2_sort_cmp_complex_asc);\n    for (long i = 0; i < n; i++) {\n      v.real[i] = a.real[buf[i].ix];\n      v.imag[i] = srcHasImag ? a.imag[buf[i].ix] : 0.0;\n      ix.real[i] = (double)(buf[i].ix + 1);\n    }\n    free(buf);\n  }\n  mtoc2_tensor_assign(out_v, v);\n  mtoc2_tensor_assign(out_i, ix);\n}\n',
+  "tensor_sort_real.h": "/* mtoc2 runtime helper: stable sort on a tensor.\n *\n *   mtoc2_sort_real(a, descending)\n *     `b = sort(a)` / `sort(a, 'ascend'|'descend')` \u2014 returns a\n *     freshly-owned tensor of the same shape as `a`, with the flat\n *     (column-major) entries sorted in the requested direction.\n *\n *   mtoc2_sort_real_2(a, descending, &out_v, &out_i)\n *     `[v, i] = sort(...)` \u2014 fills `*out_v` with the sorted values\n *     and `*out_i` with 1-based original positions.\n *\n *   mtoc2_sort_complex / mtoc2_sort_complex_2\n *     Complex-input siblings. Numbl / MATLAB sort complex by\n *     magnitude (hypot), tiebreak by phase (atan2). Tolerates\n *     `a.imag == NULL` (real-input flowed through a complex route)\n *     by treating imag as zero.\n *\n * Sort is stable in both directions: ties resolve by ascending\n * original index, matching numbl's behaviour (verified against\n * `sort([5 2 8 1 2], 'descend')` \u2192 indices `3 1 2 5 4`).\n *\n * The lowering layer restricts the input to a 1\xD7N row vector or N\xD71\n * column vector for v1; the helper itself walks the column-major\n * flat buffer and would handle any rank, but the type system rejects\n * the higher-rank cases until the per-axis form is plumbed through.\n */\n\n#include <math.h>\n#include <stdlib.h>\n#include <string.h>\n\ntypedef struct {\n  double v;\n  long ix;\n} mtoc2_sort_pair_t;\n\n/* NaN ranks as the maximum (MATLAB): last when ascending, first when\n * descending. Without this, NaN compares false both ways and falls to\n * the index tie-break, leaving the comparator non-transitive \u2014 which is\n * undefined behavior for qsort and corrupts the array. */\nstatic int mtoc2_sort_cmp_asc(const void *pa, const void *pb) {\n  const mtoc2_sort_pair_t *a = (const mtoc2_sort_pair_t *)pa;\n  const mtoc2_sort_pair_t *b = (const mtoc2_sort_pair_t *)pb;\n  int an = a->v != a->v, bn = b->v != b->v;\n  if (an || bn) {\n    if (!(an && bn)) return an ? 1 : -1; /* NaN sorts last */\n  } else {\n    if (a->v < b->v) return -1;\n    if (a->v > b->v) return 1;\n  }\n  if (a->ix < b->ix) return -1;\n  if (a->ix > b->ix) return 1;\n  return 0;\n}\n\nstatic int mtoc2_sort_cmp_desc(const void *pa, const void *pb) {\n  const mtoc2_sort_pair_t *a = (const mtoc2_sort_pair_t *)pa;\n  const mtoc2_sort_pair_t *b = (const mtoc2_sort_pair_t *)pb;\n  int an = a->v != a->v, bn = b->v != b->v;\n  if (an || bn) {\n    if (!(an && bn)) return an ? -1 : 1; /* NaN sorts first */\n  } else {\n    if (a->v > b->v) return -1;\n    if (a->v < b->v) return 1;\n  }\n  /* Tie-break still by ascending original index \u2014 both numbl and\n   * MATLAB keep ties in original order in either direction. */\n  if (a->ix < b->ix) return -1;\n  if (a->ix > b->ix) return 1;\n  return 0;\n}\n\nstatic mtoc2_tensor_t mtoc2_sort_real(mtoc2_tensor_t a, int descending) {\n  long n = 1;\n  for (int i = 0; i < a.ndim; i++) n *= a.dims[i];\n  mtoc2_tensor_t r;\n  r.real = mtoc2_alloc((size_t)n * sizeof(double));\n  r.imag = NULL;\n  r.ndim = a.ndim;\n  for (int i = 0; i < a.ndim; i++) r.dims[i] = a.dims[i];\n  if (n == 0) return r;\n  mtoc2_sort_pair_t *buf =\n    (mtoc2_sort_pair_t *)malloc((size_t)n * sizeof(mtoc2_sort_pair_t));\n  if (!buf) {\n    fprintf(stderr, \"mtoc2: out of memory (sort buffer)\\n\");\n    abort();\n  }\n  for (long i = 0; i < n; i++) {\n    buf[i].v = a.real[i];\n    buf[i].ix = i;\n  }\n  qsort(buf, (size_t)n, sizeof(mtoc2_sort_pair_t),\n        descending ? mtoc2_sort_cmp_desc : mtoc2_sort_cmp_asc);\n  for (long i = 0; i < n; i++) r.real[i] = buf[i].v;\n  free(buf);\n  return r;\n}\n\nstatic void mtoc2_sort_real_2(mtoc2_tensor_t a, int descending,\n                              mtoc2_tensor_t *out_v, mtoc2_tensor_t *out_i) {\n  long n = 1;\n  for (int i = 0; i < a.ndim; i++) n *= a.dims[i];\n  mtoc2_tensor_t v;\n  mtoc2_tensor_t ix;\n  v.real = mtoc2_alloc((size_t)n * sizeof(double));\n  v.imag = NULL;\n  v.ndim = a.ndim;\n  for (int i = 0; i < a.ndim; i++) v.dims[i] = a.dims[i];\n  ix.real = mtoc2_alloc((size_t)n * sizeof(double));\n  ix.imag = NULL;\n  ix.ndim = a.ndim;\n  for (int i = 0; i < a.ndim; i++) ix.dims[i] = a.dims[i];\n  if (n > 0) {\n    mtoc2_sort_pair_t *buf =\n      (mtoc2_sort_pair_t *)malloc((size_t)n * sizeof(mtoc2_sort_pair_t));\n    if (!buf) {\n      fprintf(stderr, \"mtoc2: out of memory (sort buffer)\\n\");\n      abort();\n    }\n    for (long i = 0; i < n; i++) {\n      buf[i].v = a.real[i];\n      buf[i].ix = i;\n    }\n    qsort(buf, (size_t)n, sizeof(mtoc2_sort_pair_t),\n          descending ? mtoc2_sort_cmp_desc : mtoc2_sort_cmp_asc);\n    for (long i = 0; i < n; i++) {\n      v.real[i] = buf[i].v;\n      ix.real[i] = (double)(buf[i].ix + 1);\n    }\n    free(buf);\n  }\n  mtoc2_tensor_assign(out_v, v);\n  mtoc2_tensor_assign(out_i, ix);\n}\n\ntypedef struct {\n  double mag;\n  double phase;\n  long ix;\n} mtoc2_sort_complex_pair_t;\n\nstatic int mtoc2_sort_cmp_complex_asc(const void *pa, const void *pb) {\n  const mtoc2_sort_complex_pair_t *a = (const mtoc2_sort_complex_pair_t *)pa;\n  const mtoc2_sort_complex_pair_t *b = (const mtoc2_sort_complex_pair_t *)pb;\n  if (a->mag < b->mag) return -1;\n  if (a->mag > b->mag) return 1;\n  if (a->phase < b->phase) return -1;\n  if (a->phase > b->phase) return 1;\n  if (a->ix < b->ix) return -1;\n  if (a->ix > b->ix) return 1;\n  return 0;\n}\n\nstatic int mtoc2_sort_cmp_complex_desc(const void *pa, const void *pb) {\n  const mtoc2_sort_complex_pair_t *a = (const mtoc2_sort_complex_pair_t *)pa;\n  const mtoc2_sort_complex_pair_t *b = (const mtoc2_sort_complex_pair_t *)pb;\n  if (a->mag > b->mag) return -1;\n  if (a->mag < b->mag) return 1;\n  if (a->phase > b->phase) return -1;\n  if (a->phase < b->phase) return 1;\n  if (a->ix < b->ix) return -1;\n  if (a->ix > b->ix) return 1;\n  return 0;\n}\n\n/* Real-value comparators used when the input's imaginary lane is all\n * zero: order by signed value (the `mag` field holds the signed real\n * part in that mode), NaNs last (asc) / first (desc), tiebreak by index.\n * Matches the interpreter and MATLAB on real data. */\nstatic int mtoc2_sort_cmp_real_asc(const void *pa, const void *pb) {\n  const mtoc2_sort_complex_pair_t *a = (const mtoc2_sort_complex_pair_t *)pa;\n  const mtoc2_sort_complex_pair_t *b = (const mtoc2_sort_complex_pair_t *)pb;\n  int aNaN = a->mag != a->mag;\n  int bNaN = b->mag != b->mag;\n  if (!(aNaN && bNaN)) {\n    if (aNaN) return 1;\n    if (bNaN) return -1;\n    if (a->mag < b->mag) return -1;\n    if (a->mag > b->mag) return 1;\n  }\n  if (a->ix < b->ix) return -1;\n  if (a->ix > b->ix) return 1;\n  return 0;\n}\n\nstatic int mtoc2_sort_cmp_real_desc(const void *pa, const void *pb) {\n  const mtoc2_sort_complex_pair_t *a = (const mtoc2_sort_complex_pair_t *)pa;\n  const mtoc2_sort_complex_pair_t *b = (const mtoc2_sort_complex_pair_t *)pb;\n  int aNaN = a->mag != a->mag;\n  int bNaN = b->mag != b->mag;\n  if (!(aNaN && bNaN)) {\n    if (aNaN) return -1;\n    if (bNaN) return 1;\n    if (a->mag > b->mag) return -1;\n    if (a->mag < b->mag) return 1;\n  }\n  if (a->ix < b->ix) return -1;\n  if (a->ix > b->ix) return 1;\n  return 0;\n}\n\n/* True when the tensor carries no imaginary content (NULL lane or all\n * elements zero) \u2014 then sort orders by signed real value. */\nstatic int mtoc2_sort_all_imag_zero(mtoc2_tensor_t a) {\n  if (a.imag == NULL) return 1;\n  long n = 1;\n  for (int i = 0; i < a.ndim; i++) n *= a.dims[i];\n  for (long i = 0; i < n; i++) {\n    if (a.imag[i] != 0.0) return 0;\n  }\n  return 1;\n}\n\nstatic mtoc2_tensor_t mtoc2_sort_complex(mtoc2_tensor_t a, int descending) {\n  long n = 1;\n  for (int i = 0; i < a.ndim; i++) n *= a.dims[i];\n  mtoc2_tensor_t r = mtoc2_tensor_alloc_nd_complex(a.ndim, a.dims);\n  if (n == 0) return r;\n  int srcHasImag = (a.imag != NULL);\n  if (!srcHasImag) memset(r.imag, 0, (size_t)n * sizeof(double));\n  int realMode = mtoc2_sort_all_imag_zero(a);\n  mtoc2_sort_complex_pair_t *buf =\n    (mtoc2_sort_complex_pair_t *)malloc(\n      (size_t)n * sizeof(mtoc2_sort_complex_pair_t));\n  if (!buf) {\n    fprintf(stderr, \"mtoc2: out of memory (sort complex buffer)\\n\");\n    abort();\n  }\n  for (long i = 0; i < n; i++) {\n    double re = a.real[i];\n    double im = srcHasImag ? a.imag[i] : 0.0;\n    buf[i].mag = realMode ? re : hypot(re, im);\n    buf[i].phase = realMode ? 0.0 : atan2(im, re);\n    buf[i].ix = i;\n  }\n  qsort(buf, (size_t)n, sizeof(mtoc2_sort_complex_pair_t),\n        realMode ? (descending ? mtoc2_sort_cmp_real_desc\n                               : mtoc2_sort_cmp_real_asc)\n                 : (descending ? mtoc2_sort_cmp_complex_desc\n                               : mtoc2_sort_cmp_complex_asc));\n  for (long i = 0; i < n; i++) {\n    r.real[i] = a.real[buf[i].ix];\n    r.imag[i] = srcHasImag ? a.imag[buf[i].ix] : 0.0;\n  }\n  free(buf);\n  return r;\n}\n\nstatic void mtoc2_sort_complex_2(mtoc2_tensor_t a, int descending,\n                                 mtoc2_tensor_t *out_v, mtoc2_tensor_t *out_i) {\n  long n = 1;\n  for (int i = 0; i < a.ndim; i++) n *= a.dims[i];\n  mtoc2_tensor_t v = mtoc2_tensor_alloc_nd_complex(a.ndim, a.dims);\n  mtoc2_tensor_t ix;\n  ix.real = mtoc2_alloc((size_t)n * sizeof(double));\n  ix.imag = NULL;\n  ix.ndim = a.ndim;\n  for (int i = 0; i < a.ndim; i++) ix.dims[i] = a.dims[i];\n  if (n > 0) {\n    int srcHasImag = (a.imag != NULL);\n    if (!srcHasImag) memset(v.imag, 0, (size_t)n * sizeof(double));\n    int realMode = mtoc2_sort_all_imag_zero(a);\n    mtoc2_sort_complex_pair_t *buf =\n      (mtoc2_sort_complex_pair_t *)malloc(\n        (size_t)n * sizeof(mtoc2_sort_complex_pair_t));\n    if (!buf) {\n      fprintf(stderr, \"mtoc2: out of memory (sort complex buffer)\\n\");\n      abort();\n    }\n    for (long i = 0; i < n; i++) {\n      double re = a.real[i];\n      double im = srcHasImag ? a.imag[i] : 0.0;\n      buf[i].mag = realMode ? re : hypot(re, im);\n      buf[i].phase = realMode ? 0.0 : atan2(im, re);\n      buf[i].ix = i;\n    }\n    qsort(buf, (size_t)n, sizeof(mtoc2_sort_complex_pair_t),\n          realMode ? (descending ? mtoc2_sort_cmp_real_desc\n                                 : mtoc2_sort_cmp_real_asc)\n                   : (descending ? mtoc2_sort_cmp_complex_desc\n                                 : mtoc2_sort_cmp_complex_asc));\n    for (long i = 0; i < n; i++) {\n      v.real[i] = a.real[buf[i].ix];\n      v.imag[i] = srcHasImag ? a.imag[buf[i].ix] : 0.0;\n      ix.real[i] = (double)(buf[i].ix + 1);\n    }\n    free(buf);\n  }\n  mtoc2_tensor_assign(out_v, v);\n  mtoc2_tensor_assign(out_i, ix);\n}\n",
   "tensor_transpose.h": "/* mtoc2 runtime helper: real-tensor non-conjugate transpose for 2-D\n * inputs. Returns a freshly-owned tensor with `dims` swapped. The\n * 2-D restriction is enforced at lowering; by the time this helper\n * runs, `a.ndim` is always 2.\n *\n * Column-major in, column-major out. Source `a` has shape (m \xD7 n);\n * destination has shape (n \xD7 m). Source element at (sr, sc) lives at\n * `a.real[sr + sc*m]`; destination element at (sc, sr) \u2014 the transpose\n * mapping \u2014 lives at `out.real[sc + sr*n]`. The inner loop walks the\n * source's column-major buffer linearly to keep the read stride\n * unit-stride.\n *\n * For complex support (not yet a thing in mtoc2), the conjugate\n * variant would negate `a.imag` while copying; the non-conjugate\n * variant just copies. Mirrors numbl's `transposeCore` in\n * `helpers/arithmetic.ts`.\n */\n\n#include <stdlib.h>\n\nstatic mtoc2_tensor_t mtoc2_tensor_transpose(mtoc2_tensor_t a) {\n  long m = a.dims[0];\n  long n = a.dims[1];\n  mtoc2_tensor_t r;\n  r.real = mtoc2_alloc((size_t)m * (size_t)n * sizeof(double));\n  r.imag = NULL;\n  r.ndim = 2;\n  r.dims[0] = n;\n  r.dims[1] = m;\n  for (long sc = 0; sc < n; sc++) {\n    for (long sr = 0; sr < m; sr++) {\n      r.real[sc + sr * n] = a.real[sr + sc * m];\n    }\n  }\n  return r;\n}\n",
   "tensor_transpose_complex.h": "/* mtoc2 runtime helper: complex-tensor non-conjugate transpose for\n * 2-D inputs. Sibling of `mtoc2_tensor_transpose` \u2014 same shape\n * permutation, but copies BOTH lanes (no conjugation, the `.'`\n * operator). The `'` (conjugate transpose) operator lowers to\n * `transpose(conj(z))` at the lowering layer, so this helper only\n * sees the non-conjugating case.\n *\n * Tolerates `a.imag == NULL` (real-tensor flowing through a\n * complex-typed transpose route) by zeroing the result's imag lane.\n */\n\n#include <stdlib.h>\n#include <string.h>\n\nstatic mtoc2_tensor_t mtoc2_tensor_transpose_complex(mtoc2_tensor_t a) {\n  long m = a.dims[0];\n  long n = a.dims[1];\n  long dims[2];\n  dims[0] = n;\n  dims[1] = m;\n  mtoc2_tensor_t r = mtoc2_tensor_alloc_nd_complex(2, dims);\n  if (a.imag == NULL) {\n    /* Defensive: zero the imag lane so the transposed result is a\n     * well-formed complex tensor with re-only content. */\n    memset(r.imag, 0, (size_t)m * (size_t)n * sizeof(double));\n  }\n  for (long sc = 0; sc < n; sc++) {\n    for (long sr = 0; sr < m; sr++) {\n      r.real[sc + sr * n] = a.real[sr + sc * m];\n      if (a.imag != NULL) {\n        r.imag[sc + sr * n] = a.imag[sr + sc * m];\n      }\n    }\n  }\n  return r;\n}\n",
   "tensor_triangular.h": "/* mtoc2 runtime helper: `triu` / `tril` \u2014 extract upper / lower\n * triangular part of a 2-D matrix around the k-th diagonal. Mirrors\n * numbl's `triPart` in `interpreter/builtins/array-extras.ts`.\n *\n *   - `mtoc2_tensor_triu(A, k)` returns a fresh `rows \xD7 cols` tensor\n *     equal to `A` where `j - i >= k` (column - row), zero elsewhere.\n *     `k = 0` is the main diagonal; `k > 0` selects a super-diagonal;\n *     `k < 0` selects a sub-diagonal.\n *   - `mtoc2_tensor_tril(A, k)` is the mirror: keep entries where\n *     `i - j >= -k` (equivalently `j - i <= k`), zero elsewhere.\n *   - `*_complex` siblings walk both lanes; tolerate `a.imag == NULL`\n *     (real-input flowed through a complex route).\n *\n * Storage column-major to match `mtoc2_tensor_t`. Result is freshly\n * owned.\n */\n\n#include <string.h>\n#include <stdlib.h>\n\nstatic mtoc2_tensor_t mtoc2_tensor_triu(mtoc2_tensor_t a, long k) {\n  long rows = a.dims[0];\n  long cols = a.dims[1];\n  mtoc2_tensor_t out = mtoc2_tensor_alloc(rows, cols);\n  if (rows > 0 && cols > 0)\n    memset(out.real, 0, (size_t)rows * (size_t)cols * sizeof(double));\n  for (long j = 0; j < cols; j++) {\n    for (long i = 0; i < rows; i++) {\n      if (j - i >= k) {\n        long idx = i + j * rows;\n        out.real[idx] = a.real[idx];\n      }\n    }\n  }\n  return out;\n}\n\nstatic mtoc2_tensor_t mtoc2_tensor_tril(mtoc2_tensor_t a, long k) {\n  long rows = a.dims[0];\n  long cols = a.dims[1];\n  mtoc2_tensor_t out = mtoc2_tensor_alloc(rows, cols);\n  if (rows > 0 && cols > 0)\n    memset(out.real, 0, (size_t)rows * (size_t)cols * sizeof(double));\n  for (long j = 0; j < cols; j++) {\n    for (long i = 0; i < rows; i++) {\n      if (i - j >= -k) {\n        long idx = i + j * rows;\n        out.real[idx] = a.real[idx];\n      }\n    }\n  }\n  return out;\n}\n\nstatic mtoc2_tensor_t mtoc2_tensor_triu_complex(mtoc2_tensor_t a, long k) {\n  long rows = a.dims[0];\n  long cols = a.dims[1];\n  long dims2[2] = {rows, cols};\n  mtoc2_tensor_t out = mtoc2_tensor_alloc_nd_complex(2, dims2);\n  if (rows > 0 && cols > 0) {\n    memset(out.real, 0, (size_t)rows * (size_t)cols * sizeof(double));\n    memset(out.imag, 0, (size_t)rows * (size_t)cols * sizeof(double));\n  }\n  int srcHasImag = (a.imag != NULL);\n  for (long j = 0; j < cols; j++) {\n    for (long i = 0; i < rows; i++) {\n      if (j - i >= k) {\n        long idx = i + j * rows;\n        out.real[idx] = a.real[idx];\n        if (srcHasImag) out.imag[idx] = a.imag[idx];\n      }\n    }\n  }\n  return out;\n}\n\nstatic mtoc2_tensor_t mtoc2_tensor_tril_complex(mtoc2_tensor_t a, long k) {\n  long rows = a.dims[0];\n  long cols = a.dims[1];\n  long dims2[2] = {rows, cols};\n  mtoc2_tensor_t out = mtoc2_tensor_alloc_nd_complex(2, dims2);\n  if (rows > 0 && cols > 0) {\n    memset(out.real, 0, (size_t)rows * (size_t)cols * sizeof(double));\n    memset(out.imag, 0, (size_t)rows * (size_t)cols * sizeof(double));\n  }\n  int srcHasImag = (a.imag != NULL);\n  for (long j = 0; j < cols; j++) {\n    for (long i = 0; i < rows; i++) {\n      if (i - j >= -k) {\n        long idx = i + j * rows;\n        out.real[idx] = a.real[idx];\n        if (srcHasImag) out.imag[idx] = a.imag[idx];\n      }\n    }\n  }\n  return out;\n}\n",
@@ -65430,6 +66146,7 @@ var JS_SNIPPETS = {
   "tensor_fill_nd.js": "// JS sibling of `tensor_fill_nd.h`. Like zeros/ones but takes the\n// fill value as a leading argument \u2014 used by the `nan` / `Inf` shape-\n// constructor branches and by `repmat(scalar, ...)`. Complex variant\n// takes `(re, im)` and fills both lanes.\n\n\n\nfunction mtoc2_tensor_fill_nd(value, ndim, dims) {\n  const t = mtoc2_tensor_alloc_nd(ndim, dims);\n  t.data.fill(value);\n  return t;\n}\n\nfunction mtoc2_tensor_fill_nd_complex(re, im, ndim, dims) {\n  const t = mtoc2_tensor_alloc_nd_complex(ndim, dims);\n  t.data.fill(re);\n  t.imag.fill(im);\n  return t;\n}\n",
   "tensor_fill_square.js": "// JS sibling of `tensor_fill_square.h`. Single-eval helper for\n// `nan(n)` / `Inf(n)` style square-fill constructors.\n\n\nfunction mtoc2_tensor_fill_square(value, n) {\n  return mtoc2_tensor_fill_nd(value, 2, [n, n]);\n}\n",
   "tensor_flip.js": "// JS sibling of `tensor_flip.h`. Two helpers:\n//   - `mtoc2_tensor_flip(t, dimIdx)` \u2014 real-input variant.\n//   - `mtoc2_tensor_flip_complex(t, dimIdx)` \u2014 walks both lanes;\n//     if `imag` is undefined the output imag stays zero.\n// Out-of-range axis acts as a deep-copy no-op in both.\n\n\n\nfunction mtoc2_tensor_flip(a, dimIdx) {\n  const r = mtoc2_tensor_alloc_nd(a.shape.length, a.shape);\n  const axisSize = dimIdx >= 0 && dimIdx < a.shape.length ? a.shape[dimIdx] : 1;\n  if (axisSize <= 1) {\n    r.data.set(a.data);\n    return r;\n  }\n  let strideDim = 1;\n  for (let d = 0; d < dimIdx; d++) strideDim *= a.shape[d];\n  const slabSize = strideDim * axisSize;\n  const total = r.data.length;\n  const numOuter = total / slabSize;\n  for (let outer = 0; outer < numOuter; outer++) {\n    const base = outer * slabSize;\n    for (let k = 0; k < axisSize; k++) {\n      const srcOff = base + k * strideDim;\n      const dstOff = base + (axisSize - 1 - k) * strideDim;\n      for (let i = 0; i < strideDim; i++) {\n        r.data[dstOff + i] = a.data[srcOff + i];\n      }\n    }\n  }\n  return r;\n}\n\nfunction mtoc2_tensor_flip_complex(a, dimIdx) {\n  const r = mtoc2_tensor_alloc_nd_complex(a.shape.length, a.shape);\n  const im = a.imag;\n  const axisSize = dimIdx >= 0 && dimIdx < a.shape.length ? a.shape[dimIdx] : 1;\n  if (axisSize <= 1) {\n    r.data.set(a.data);\n    if (im !== undefined) r.imag.set(im);\n    return r;\n  }\n  let strideDim = 1;\n  for (let d = 0; d < dimIdx; d++) strideDim *= a.shape[d];\n  const slabSize = strideDim * axisSize;\n  const total = r.data.length;\n  const numOuter = total / slabSize;\n  for (let outer = 0; outer < numOuter; outer++) {\n    const base = outer * slabSize;\n    for (let k = 0; k < axisSize; k++) {\n      const srcOff = base + k * strideDim;\n      const dstOff = base + (axisSize - 1 - k) * strideDim;\n      for (let i = 0; i < strideDim; i++) {\n        r.data[dstOff + i] = a.data[srcOff + i];\n        if (im !== undefined) r.imag[dstOff + i] = im[srcOff + i];\n      }\n    }\n  }\n  return r;\n}\n",
+  "tensor_imag_all_zero.js": "// JS sibling of `tensor_imag_all_zero.h`. True when a tensor carries no\n// imaginary content (no imag lane, or every imag element exactly zero).\n// `isreal` uses this for complex-typed tensors the JIT could not prove\n// real at compile time, so it reports realness by value \u2014 matching the\n// interpreter and the complex-scalar `v.im === 0` rule.\nfunction mtoc2_tensor_imag_all_zero(a) {\n  if (a.imag === undefined) return true;\n  for (let i = 0; i < a.imag.length; i++) {\n    if (a.imag[i] !== 0) return false;\n  }\n  return true;\n}\n",
   "tensor_linspace.js": "// JS sibling of `tensor_linspace.h`. Build a 1\xD7n row tensor of n\n// linearly-spaced values from `a` to `b`.\n\n\nfunction mtoc2_tensor_linspace(a, b, n) {\n  if (n < 0) n = 0;\n  const out = mtoc2_tensor_alloc(1, n);\n  if (n === 0) return out;\n  if (n === 1) {\n    out.data[0] = b;\n    return out;\n  }\n  out.data[0] = a;\n  out.data[n - 1] = b;\n  for (let i = 1; i < n - 1; i++) {\n    out.data[i] = a + ((b - a) * i) / (n - 1);\n  }\n  if ((n & 1) === 1 && !Number.isFinite(a) && !Number.isFinite(b)) {\n    const sa = Math.sign(a);\n    const sb = Math.sign(b);\n    if (sa !== sb) out.data[(n - 1) / 2] = 0;\n  }\n  return out;\n}\n",
   "tensor_logical_real.js": '// JS sibling of `tensor_logical_real.h`. Elementwise logical NOT on\n// real and complex tensors. Real input: `out[i] = (in[i] == 0) ? 1 : 0`.\n// Complex input: fires "true" iff both lanes are exactly zero.\n// Result is logical-tagged in both cases.\n\n\nfunction mtoc2_tensor_not(a) {\n  const r = mtoc2_tensor_alloc_nd(a.shape.length, a.shape);\n  for (let i = 0; i < r.data.length; i++) {\n    r.data[i] = a.data[i] === 0 ? 1 : 0;\n  }\n  // Tag as logical so `a(mask)` / `M(:, mask)` etc. take the mask\n  // path in the interpreter (and js-aot, when wired). The tensor\n  // alloc helpers return plain numeric tensors; we mutate the field\n  // here rather than threading a parameter through every allocator.\n  r.isLogical = true;\n  return r;\n}\n\nfunction mtoc2_tensor_not_complex(a) {\n  const r = mtoc2_tensor_alloc_nd(a.shape.length, a.shape);\n  const im = a.imag;\n  for (let i = 0; i < r.data.length; i++) {\n    const re = a.data[i];\n    const v = im !== undefined ? im[i] : 0;\n    r.data[i] = re === 0 && v === 0 ? 1 : 0;\n  }\n  r.isLogical = true;\n  return r;\n}\n',
   "tensor_logspace.js": "// JS sibling of `tensor_logspace.h`. Build a 1\xD7n row tensor of n\n// logarithmically-spaced values from 10^a to 10^b. Byte-for-byte with\n// numbl's interpreter `logspace`, including the MATLAB special case\n// where an upper limit of exactly `pi` makes the last point `pi`.\n\n\nfunction mtoc2_tensor_logspace(a, b, n) {\n  if (n <= 0) return mtoc2_tensor_alloc(1, 0);\n  const isPi = b === Math.PI;\n  const endVal = isPi ? Math.PI : Math.pow(10, b);\n  const out = mtoc2_tensor_alloc(1, n);\n  if (n === 1) {\n    out.data[0] = endVal;\n    return out;\n  }\n  if (isPi) {\n    const logStart = Math.log10(Math.pow(10, a));\n    const logEnd = Math.log10(Math.PI);\n    for (let i = 0; i < n; i++) {\n      const t = logStart + ((logEnd - logStart) * i) / (n - 1);\n      out.data[i] = Math.pow(10, t);\n    }\n  } else {\n    for (let i = 0; i < n; i++) {\n      const t = a + ((b - a) * i) / (n - 1);\n      out.data[i] = Math.pow(10, t);\n    }\n  }\n  return out;\n}\n",
@@ -65440,13 +66157,13 @@ var JS_SNIPPETS = {
   "tensor_ones_nd.js": "// JS sibling of `tensor_ones_nd.h`. Fill the freshly-allocated\n// tensor with `1.0`.\n\n\nfunction mtoc2_tensor_ones_nd(ndim, dims) {\n  const t = mtoc2_tensor_alloc_nd(ndim, dims);\n  t.data.fill(1);\n  return t;\n}\n",
   "tensor_ones_square.js": "// JS sibling of `tensor_ones_square.h`. See `tensor_zeros_square.js`\n// for the rationale.\n\n\nfunction mtoc2_tensor_ones_square(n) {\n  return mtoc2_tensor_ones_nd(2, [n, n]);\n}\n",
   "tensor_predicate.js": '// JS sibling of `tensor_predicate.h`. Real-tensor \u2192 logical-tensor\n// predicate kernels for the js-aot backend, plus their `_complex`\n// siblings (each reads `imag[i]` when defined, treats it as 0\n// otherwise). Result carries `isLogical: true` so downstream index-\n// slot resolution treats it as a mask.\n\nfunction pred_kernel(a, fn) {\n  const out = new Float64Array(a.data.length);\n  for (let i = 0; i < a.data.length; i++) out[i] = fn(a.data[i]) ? 1 : 0;\n  return {\n    mtoc2Tag: "tensor",\n    shape: a.shape.slice(),\n    data: out,\n    isLogical: true,\n  };\n}\n\nfunction pred_kernel_complex(a, fn) {\n  const out = new Float64Array(a.data.length);\n  const im = a.imag;\n  for (let i = 0; i < a.data.length; i++) {\n    out[i] = fn(a.data[i], im !== undefined ? im[i] : 0) ? 1 : 0;\n  }\n  return {\n    mtoc2Tag: "tensor",\n    shape: a.shape.slice(),\n    data: out,\n    isLogical: true,\n  };\n}\n\nfunction mtoc2_tensor_isnan(a) {\n  return pred_kernel(a, Number.isNaN);\n}\n\nfunction mtoc2_tensor_logical(a) {\n  return pred_kernel(a, x => x !== 0);\n}\n\nfunction mtoc2_tensor_isinf(a) {\n  return pred_kernel(a, x => x === Infinity || x === -Infinity);\n}\n\nfunction mtoc2_tensor_isfinite(a) {\n  return pred_kernel(a, Number.isFinite);\n}\n\nfunction mtoc2_tensor_isnan_complex(a) {\n  return pred_kernel_complex(\n    a,\n    (re, im) => Number.isNaN(re) || Number.isNaN(im)\n  );\n}\n\nfunction mtoc2_tensor_isinf_complex(a) {\n  const isInf = x => x === Infinity || x === -Infinity;\n  return pred_kernel_complex(a, (re, im) => isInf(re) || isInf(im));\n}\n\nfunction mtoc2_tensor_isfinite_complex(a) {\n  return pred_kernel_complex(\n    a,\n    (re, im) => Number.isFinite(re) && Number.isFinite(im)\n  );\n}\n',
-  "tensor_reduce_complex.js": '// JS sibling of `tensor_reduce_complex.h`. Complex-tensor reductions.\n// Mirrors the real reducer shape (sum/prod/mean \u2192 complex; min/max\n// \u2192 complex via magnitude+atan2 tiebreak; any/all \u2192 real).\n\n\n\nfunction cSqueezeTrailing(dims) {\n  while (dims.length > 2 && dims[dims.length - 1] === 1) dims.pop();\n  return dims;\n}\n\nfunction cReduceLaneIm(t, i) {\n  return t.imag !== undefined ? t.imag[i] : 0;\n}\n\n// Numeric (sum/prod/mean) \u2014 complex accumulator { re, im }.\nfunction complexAccumAll(t, init, accum, finalize) {\n  let acc = { ...init };\n  for (let i = 0; i < t.data.length; i++) {\n    acc = accum(acc, { re: t.data[i], im: cReduceLaneIm(t, i) });\n  }\n  return finalize(acc, t.data.length);\n}\n\nfunction complexAccumDim(t, dim, init, accum, finalize) {\n  if (dim < 1) throw new Error(`reducer _dim: dim must be >= 1 (got ${dim})`);\n  if (dim > t.shape.length) {\n    // No-op axis: return a fresh complex copy.\n    const out = mtoc2_tensor_alloc_nd_complex(t.shape.length, t.shape.slice());\n    out.data.set(t.data);\n    if (t.imag !== undefined) out.imag.set(t.imag);\n    return out;\n  }\n  const dimIdx = dim - 1;\n  const axis = t.shape[dimIdx];\n  let before = 1;\n  for (let i = 0; i < dimIdx; i++) before *= t.shape[i];\n  let after = 1;\n  for (let i = dimIdx + 1; i < t.shape.length; i++) after *= t.shape[i];\n  const outDims = t.shape.slice();\n  outDims[dimIdx] = 1;\n  cSqueezeTrailing(outDims);\n  const out = mtoc2_tensor_alloc_nd_complex(outDims.length, outDims);\n  for (let aft = 0; aft < after; aft++) {\n    for (let bef = 0; bef < before; bef++) {\n      const base = aft * before * axis + bef;\n      let acc = { ...init };\n      for (let k = 0; k < axis; k++) {\n        const off = base + k * before;\n        acc = accum(acc, { re: t.data[off], im: cReduceLaneIm(t, off) });\n      }\n      const fin = finalize(acc, axis);\n      const dst = aft * before + bef;\n      out.data[dst] = fin.re;\n      out.imag[dst] = fin.im;\n    }\n  }\n  return out;\n}\n\nconst cSumInit = { re: 0, im: 0 };\nconst cProdInit = { re: 1, im: 0 };\nconst cSumAccum = (a, x) => ({ re: a.re + x.re, im: a.im + x.im });\nconst cProdAccum = (a, x) => ({\n  re: a.re * x.re - a.im * x.im,\n  im: a.re * x.im + a.im * x.re,\n});\nconst cIdFinalize = a => a;\nconst cMeanFinalize = (a, n) =>\n  n === 0 ? { re: NaN, im: NaN } : { re: a.re / n, im: a.im / n };\n\nconst mtoc2_sum_complex_all = t =>\n  complexAccumAll(t, cSumInit, cSumAccum, cIdFinalize);\nconst mtoc2_sum_complex_dim = (t, d) =>\n  complexAccumDim(t, d, cSumInit, cSumAccum, cIdFinalize);\nconst mtoc2_prod_complex_all = t =>\n  complexAccumAll(t, cProdInit, cProdAccum, cIdFinalize);\nconst mtoc2_prod_complex_dim = (t, d) =>\n  complexAccumDim(t, d, cProdInit, cProdAccum, cIdFinalize);\nconst mtoc2_mean_complex_all = t =>\n  complexAccumAll(t, cSumInit, cSumAccum, cMeanFinalize);\nconst mtoc2_mean_complex_dim = (t, d) =>\n  complexAccumDim(t, d, cSumInit, cSumAccum, cMeanFinalize);\n\n// Min / max \u2014 magnitude compare with atan2 tiebreak (numbl\'s\n// complexIsBetter). Skip NaN-lane elements; result is complex.\nfunction complexMinmaxAll(t, cmp) {\n  let found = false;\n  let mRe = NaN;\n  let mIm = 0;\n  for (let i = 0; i < t.data.length; i++) {\n    const xr = t.data[i];\n    const xi = cReduceLaneIm(t, i);\n    if (xr !== xr || xi !== xi) continue;\n    if (!found || complexBetter(xr, xi, mRe, mIm, cmp)) {\n      mRe = xr;\n      mIm = xi;\n      found = true;\n    }\n  }\n  return { re: mRe, im: mIm };\n}\n\nfunction complexBetter(aRe, aIm, bRe, bIm, cmp) {\n  const absA = Math.hypot(aRe, aIm);\n  const absB = Math.hypot(bRe, bIm);\n  if (absA !== absB) return cmp === "<" ? absA < absB : absA > absB;\n  return cmp === "<"\n    ? Math.atan2(aIm, aRe) < Math.atan2(bIm, bRe)\n    : Math.atan2(aIm, aRe) > Math.atan2(bIm, bRe);\n}\n\nfunction complexMinmaxDim(t, dim, cmp) {\n  if (dim < 1) throw new Error(`reducer _dim: dim must be >= 1 (got ${dim})`);\n  if (dim > t.shape.length) {\n    const out = mtoc2_tensor_alloc_nd_complex(t.shape.length, t.shape.slice());\n    out.data.set(t.data);\n    if (t.imag !== undefined) out.imag.set(t.imag);\n    return out;\n  }\n  const dimIdx = dim - 1;\n  const axis = t.shape[dimIdx];\n  let before = 1;\n  for (let i = 0; i < dimIdx; i++) before *= t.shape[i];\n  let after = 1;\n  for (let i = dimIdx + 1; i < t.shape.length; i++) after *= t.shape[i];\n  const outDims = t.shape.slice();\n  outDims[dimIdx] = 1;\n  cSqueezeTrailing(outDims);\n  const out = mtoc2_tensor_alloc_nd_complex(outDims.length, outDims);\n  for (let aft = 0; aft < after; aft++) {\n    for (let bef = 0; bef < before; bef++) {\n      const base = aft * before * axis + bef;\n      let found = false;\n      let mRe = NaN;\n      let mIm = 0;\n      for (let k = 0; k < axis; k++) {\n        const off = base + k * before;\n        const xr = t.data[off];\n        const xi = cReduceLaneIm(t, off);\n        if (xr !== xr || xi !== xi) continue;\n        if (!found || complexBetter(xr, xi, mRe, mIm, cmp)) {\n          mRe = xr;\n          mIm = xi;\n          found = true;\n        }\n      }\n      const dst = aft * before + bef;\n      out.data[dst] = mRe;\n      out.imag[dst] = mIm;\n    }\n  }\n  return out;\n}\n\nconst mtoc2_min_complex_all = t => complexMinmaxAll(t, "<");\nconst mtoc2_min_complex_dim = (t, d) => complexMinmaxDim(t, d, "<");\nconst mtoc2_max_complex_all = t => complexMinmaxAll(t, ">");\nconst mtoc2_max_complex_dim = (t, d) => complexMinmaxDim(t, d, ">");\n\n// any / all \u2014 real result; toBool per element (either lane nonzero).\nfunction complexLogicalAll(t, emptyResult, shortPredicate) {\n  if (t.data.length === 0) return emptyResult;\n  for (let i = 0; i < t.data.length; i++) {\n    const xr = t.data[i];\n    const xi = cReduceLaneIm(t, i);\n    const x = xr !== 0 || xi !== 0;\n    if (shortPredicate(x)) return emptyResult === 1 ? 0 : 1;\n  }\n  return emptyResult;\n}\n\nfunction complexLogicalDim(t, dim, emptyResult, shortPredicate) {\n  if (dim < 1) throw new Error(`reducer _dim: dim must be >= 1 (got ${dim})`);\n  if (dim > t.shape.length) {\n    const out = mtoc2_tensor_alloc_nd(t.shape.length, t.shape.slice());\n    for (let i = 0; i < t.data.length; i++) {\n      const xr = t.data[i];\n      const xi = cReduceLaneIm(t, i);\n      out.data[i] = xr !== 0 || xi !== 0 ? 1 : 0;\n    }\n    return out;\n  }\n  const dimIdx = dim - 1;\n  const axis = t.shape[dimIdx];\n  let before = 1;\n  for (let i = 0; i < dimIdx; i++) before *= t.shape[i];\n  let after = 1;\n  for (let i = dimIdx + 1; i < t.shape.length; i++) after *= t.shape[i];\n  const outDims = t.shape.slice();\n  outDims[dimIdx] = 1;\n  cSqueezeTrailing(outDims);\n  const out = mtoc2_tensor_alloc_nd(outDims.length, outDims);\n  for (let aft = 0; aft < after; aft++) {\n    for (let bef = 0; bef < before; bef++) {\n      const base = aft * before * axis + bef;\n      let res = emptyResult;\n      for (let k = 0; k < axis; k++) {\n        const off = base + k * before;\n        const x = t.data[off] !== 0 || cReduceLaneIm(t, off) !== 0;\n        if (shortPredicate(x)) {\n          res = emptyResult === 1 ? 0 : 1;\n          break;\n        }\n      }\n      out.data[aft * before + bef] = res;\n    }\n  }\n  return out;\n}\n\nconst cAnyShort = x => x;\nconst cAllShort = x => !x;\nconst mtoc2_any_complex_all = t => complexLogicalAll(t, 0, cAnyShort);\nconst mtoc2_any_complex_dim = (t, d) =>\n  complexLogicalDim(t, d, 0, cAnyShort);\nconst mtoc2_all_complex_all = t => complexLogicalAll(t, 1, cAllShort);\nconst mtoc2_all_complex_dim = (t, d) =>\n  complexLogicalDim(t, d, 1, cAllShort);\n',
+  "tensor_reduce_complex.js": '// JS sibling of `tensor_reduce_complex.h`. Complex-tensor reductions.\n// Mirrors the real reducer shape (sum/prod/mean \u2192 complex; min/max\n// \u2192 complex via magnitude+atan2 tiebreak; any/all \u2192 real).\n\n\n\nfunction cSqueezeTrailing(dims) {\n  while (dims.length > 2 && dims[dims.length - 1] === 1) dims.pop();\n  return dims;\n}\n\nfunction cReduceLaneIm(t, i) {\n  return t.imag !== undefined ? t.imag[i] : 0;\n}\n\n// True when the tensor carries no imaginary content (no lane, or every\n// element zero). Such a tensor is real in value \u2014 min/max must order by\n// value, not magnitude, to match the interpreter and MATLAB on real data.\nfunction cReduceAllImagZero(t) {\n  if (t.imag === undefined) return true;\n  for (let i = 0; i < t.imag.length; i++) {\n    if (t.imag[i] !== 0) return false;\n  }\n  return true;\n}\n\n// Numeric (sum/prod/mean) \u2014 complex accumulator { re, im }.\nfunction complexAccumAll(t, init, accum, finalize) {\n  let acc = { ...init };\n  for (let i = 0; i < t.data.length; i++) {\n    acc = accum(acc, { re: t.data[i], im: cReduceLaneIm(t, i) });\n  }\n  return finalize(acc, t.data.length);\n}\n\nfunction complexAccumDim(t, dim, init, accum, finalize) {\n  if (dim < 1) throw new Error(`reducer _dim: dim must be >= 1 (got ${dim})`);\n  if (dim > t.shape.length) {\n    // No-op axis: return a fresh complex copy.\n    const out = mtoc2_tensor_alloc_nd_complex(t.shape.length, t.shape.slice());\n    out.data.set(t.data);\n    if (t.imag !== undefined) out.imag.set(t.imag);\n    return out;\n  }\n  const dimIdx = dim - 1;\n  const axis = t.shape[dimIdx];\n  let before = 1;\n  for (let i = 0; i < dimIdx; i++) before *= t.shape[i];\n  let after = 1;\n  for (let i = dimIdx + 1; i < t.shape.length; i++) after *= t.shape[i];\n  const outDims = t.shape.slice();\n  outDims[dimIdx] = 1;\n  cSqueezeTrailing(outDims);\n  const out = mtoc2_tensor_alloc_nd_complex(outDims.length, outDims);\n  for (let aft = 0; aft < after; aft++) {\n    for (let bef = 0; bef < before; bef++) {\n      const base = aft * before * axis + bef;\n      let acc = { ...init };\n      for (let k = 0; k < axis; k++) {\n        const off = base + k * before;\n        acc = accum(acc, { re: t.data[off], im: cReduceLaneIm(t, off) });\n      }\n      const fin = finalize(acc, axis);\n      const dst = aft * before + bef;\n      out.data[dst] = fin.re;\n      out.imag[dst] = fin.im;\n    }\n  }\n  return out;\n}\n\nconst cSumInit = { re: 0, im: 0 };\nconst cProdInit = { re: 1, im: 0 };\nconst cSumAccum = (a, x) => ({ re: a.re + x.re, im: a.im + x.im });\nconst cProdAccum = (a, x) => ({\n  re: a.re * x.re - a.im * x.im,\n  im: a.re * x.im + a.im * x.re,\n});\nconst cIdFinalize = a => a;\nconst cMeanFinalize = (a, n) =>\n  n === 0 ? { re: NaN, im: NaN } : { re: a.re / n, im: a.im / n };\n\nconst mtoc2_sum_complex_all = t =>\n  complexAccumAll(t, cSumInit, cSumAccum, cIdFinalize);\nconst mtoc2_sum_complex_dim = (t, d) =>\n  complexAccumDim(t, d, cSumInit, cSumAccum, cIdFinalize);\nconst mtoc2_prod_complex_all = t =>\n  complexAccumAll(t, cProdInit, cProdAccum, cIdFinalize);\nconst mtoc2_prod_complex_dim = (t, d) =>\n  complexAccumDim(t, d, cProdInit, cProdAccum, cIdFinalize);\nconst mtoc2_mean_complex_all = t =>\n  complexAccumAll(t, cSumInit, cSumAccum, cMeanFinalize);\nconst mtoc2_mean_complex_dim = (t, d) =>\n  complexAccumDim(t, d, cSumInit, cSumAccum, cMeanFinalize);\n\n// Min / max \u2014 magnitude compare with atan2 tiebreak (numbl\'s\n// complexIsBetter). Skip NaN-lane elements; result is complex.\nfunction complexMinmaxAll(t, cmp) {\n  const realMode = cReduceAllImagZero(t);\n  let found = false;\n  let mRe = NaN;\n  let mIm = 0;\n  for (let i = 0; i < t.data.length; i++) {\n    const xr = t.data[i];\n    const xi = cReduceLaneIm(t, i);\n    if (xr !== xr || xi !== xi) continue;\n    const better = realMode\n      ? cmp === "<"\n        ? xr < mRe\n        : xr > mRe\n      : complexBetter(xr, xi, mRe, mIm, cmp);\n    if (!found || better) {\n      mRe = xr;\n      mIm = xi;\n      found = true;\n    }\n  }\n  return { re: mRe, im: mIm };\n}\n\nfunction complexBetter(aRe, aIm, bRe, bIm, cmp) {\n  const absA = Math.hypot(aRe, aIm);\n  const absB = Math.hypot(bRe, bIm);\n  if (absA !== absB) return cmp === "<" ? absA < absB : absA > absB;\n  return cmp === "<"\n    ? Math.atan2(aIm, aRe) < Math.atan2(bIm, bRe)\n    : Math.atan2(aIm, aRe) > Math.atan2(bIm, bRe);\n}\n\nfunction complexMinmaxDim(t, dim, cmp) {\n  if (dim < 1) throw new Error(`reducer _dim: dim must be >= 1 (got ${dim})`);\n  if (dim > t.shape.length) {\n    const out = mtoc2_tensor_alloc_nd_complex(t.shape.length, t.shape.slice());\n    out.data.set(t.data);\n    if (t.imag !== undefined) out.imag.set(t.imag);\n    return out;\n  }\n  const dimIdx = dim - 1;\n  const realMode = cReduceAllImagZero(t);\n  const axis = t.shape[dimIdx];\n  let before = 1;\n  for (let i = 0; i < dimIdx; i++) before *= t.shape[i];\n  let after = 1;\n  for (let i = dimIdx + 1; i < t.shape.length; i++) after *= t.shape[i];\n  const outDims = t.shape.slice();\n  outDims[dimIdx] = 1;\n  cSqueezeTrailing(outDims);\n  const out = mtoc2_tensor_alloc_nd_complex(outDims.length, outDims);\n  for (let aft = 0; aft < after; aft++) {\n    for (let bef = 0; bef < before; bef++) {\n      const base = aft * before * axis + bef;\n      let found = false;\n      let mRe = NaN;\n      let mIm = 0;\n      for (let k = 0; k < axis; k++) {\n        const off = base + k * before;\n        const xr = t.data[off];\n        const xi = cReduceLaneIm(t, off);\n        if (xr !== xr || xi !== xi) continue;\n        const better = realMode\n          ? cmp === "<"\n            ? xr < mRe\n            : xr > mRe\n          : complexBetter(xr, xi, mRe, mIm, cmp);\n        if (!found || better) {\n          mRe = xr;\n          mIm = xi;\n          found = true;\n        }\n      }\n      const dst = aft * before + bef;\n      out.data[dst] = mRe;\n      out.imag[dst] = mIm;\n    }\n  }\n  return out;\n}\n\nconst mtoc2_min_complex_all = t => complexMinmaxAll(t, "<");\nconst mtoc2_min_complex_dim = (t, d) => complexMinmaxDim(t, d, "<");\nconst mtoc2_max_complex_all = t => complexMinmaxAll(t, ">");\nconst mtoc2_max_complex_dim = (t, d) => complexMinmaxDim(t, d, ">");\n\n// any / all \u2014 real result; toBool per element (either lane nonzero).\nfunction complexLogicalAll(t, emptyResult, shortPredicate) {\n  if (t.data.length === 0) return emptyResult;\n  for (let i = 0; i < t.data.length; i++) {\n    const xr = t.data[i];\n    const xi = cReduceLaneIm(t, i);\n    const x = xr !== 0 || xi !== 0;\n    if (shortPredicate(x)) return emptyResult === 1 ? 0 : 1;\n  }\n  return emptyResult;\n}\n\nfunction complexLogicalDim(t, dim, emptyResult, shortPredicate) {\n  if (dim < 1) throw new Error(`reducer _dim: dim must be >= 1 (got ${dim})`);\n  if (dim > t.shape.length) {\n    const out = mtoc2_tensor_alloc_nd(t.shape.length, t.shape.slice());\n    for (let i = 0; i < t.data.length; i++) {\n      const xr = t.data[i];\n      const xi = cReduceLaneIm(t, i);\n      out.data[i] = xr !== 0 || xi !== 0 ? 1 : 0;\n    }\n    return out;\n  }\n  const dimIdx = dim - 1;\n  const axis = t.shape[dimIdx];\n  let before = 1;\n  for (let i = 0; i < dimIdx; i++) before *= t.shape[i];\n  let after = 1;\n  for (let i = dimIdx + 1; i < t.shape.length; i++) after *= t.shape[i];\n  const outDims = t.shape.slice();\n  outDims[dimIdx] = 1;\n  cSqueezeTrailing(outDims);\n  const out = mtoc2_tensor_alloc_nd(outDims.length, outDims);\n  for (let aft = 0; aft < after; aft++) {\n    for (let bef = 0; bef < before; bef++) {\n      const base = aft * before * axis + bef;\n      let res = emptyResult;\n      for (let k = 0; k < axis; k++) {\n        const off = base + k * before;\n        const x = t.data[off] !== 0 || cReduceLaneIm(t, off) !== 0;\n        if (shortPredicate(x)) {\n          res = emptyResult === 1 ? 0 : 1;\n          break;\n        }\n      }\n      out.data[aft * before + bef] = res;\n    }\n  }\n  return out;\n}\n\nconst cAnyShort = x => x;\nconst cAllShort = x => !x;\nconst mtoc2_any_complex_all = t => complexLogicalAll(t, 0, cAnyShort);\nconst mtoc2_any_complex_dim = (t, d) =>\n  complexLogicalDim(t, d, 0, cAnyShort);\nconst mtoc2_all_complex_all = t => complexLogicalAll(t, 1, cAllShort);\nconst mtoc2_all_complex_dim = (t, d) =>\n  complexLogicalDim(t, d, 1, cAllShort);\n',
   "tensor_reduce_real.js": '// JS sibling of `tensor_reduce_real.h`. Real-tensor reductions \u2014\n// `_all` returns a scalar; `_dim` returns a freshly-allocated tensor\n// reduced along the 1-based `dim` axis. Mirrors numbl\'s\n// `forEachSlice` semantics with column-major (before \xD7 axis \xD7 after)\n// traversal.\n//\n// Output shape rule for `_dim`: input dims with `dims[dim-1] = 1`,\n// then trailing singletons stripped subject to a 2-axis floor.\n\n\nfunction squeeze_trailing(dims) {\n  while (dims.length > 2 && dims[dims.length - 1] === 1) dims.pop();\n  return dims;\n}\n\n// Accumulator-based reducer (`sum`, `prod`, `mean`). `init` seeds\n// the running value; `accum(a, x)` is the per-element step;\n// `finalize(a, n)` is the post-loop transform.\nfunction accum_all(t, init, accum, finalize) {\n  let acc = init;\n  for (let i = 0; i < t.data.length; i++) acc = accum(acc, t.data[i]);\n  return finalize(acc, t.data.length);\n}\n\nfunction accum_dim(t, dim, init, accum, finalize) {\n  if (dim < 1) {\n    throw new Error(`reducer _dim: dim must be >= 1 (got ${dim})`);\n  }\n  if (dim > t.shape.length) {\n    // Reducing along a trailing singleton axis is the identity: every\n    // fiber has length 1, so sum/prod/mean each yield that single\n    // element unchanged. Return a same-shape COPY of the data (the C\n    // kernel memcpy\'s here too); allocating without copying left a\n    // zero-filled tensor \u2014 the original opt1 bug.\n    const out = mtoc2_tensor_alloc_nd(t.shape.length, t.shape.slice());\n    out.data.set(t.data);\n    return out;\n  }\n  const dimIdx = dim - 1;\n  const axis = t.shape[dimIdx];\n  let before = 1;\n  for (let i = 0; i < dimIdx; i++) before *= t.shape[i];\n  let after = 1;\n  for (let i = dimIdx + 1; i < t.shape.length; i++) after *= t.shape[i];\n  const outDims = squeeze_trailing(t.shape.slice());\n  outDims[dimIdx] = 1;\n  // Re-squeeze after the in-place axis update (the original `out_dims\n  // = a.shape.slice(); out_dims[dimIdx] = 1` then squeeze pattern).\n  squeeze_trailing(outDims);\n  const out = mtoc2_tensor_alloc_nd(outDims.length, outDims);\n  for (let aft = 0; aft < after; aft++) {\n    for (let bef = 0; bef < before; bef++) {\n      const base = aft * before * axis + bef;\n      let acc = init;\n      for (let k = 0; k < axis; k++) {\n        acc = accum(acc, t.data[base + k * before]);\n      }\n      out.data[aft * before + bef] = finalize(acc, axis);\n    }\n  }\n  return out;\n}\n\n// Min/max reducer. Ignores NaN like numbl/MATLAB: NaN entries are\n// skipped, and the result is NaN only when every element is NaN.\n// Mirrors the interpreter\'s `minMaxScan` (helpers/reduction/min-max.ts)\n// and the C kernel \u2014 seeding with data[0] would let a *leading* NaN\n// poison the result (`x < NaN` / `x > NaN` are always false).\nfunction minmax_all(t, op /* "min" | "max" */) {\n  if (t.data.length === 0) return op === "min" ? Infinity : -Infinity;\n  let best = NaN;\n  let found = false;\n  for (let i = 0; i < t.data.length; i++) {\n    const x = t.data[i];\n    if (x !== x) continue; // skip NaN\n    if (!found || (op === "min" ? x < best : x > best)) {\n      best = x;\n      found = true;\n    }\n  }\n  return found ? best : NaN;\n}\n\nfunction minmax_dim(t, dim, op) {\n  if (dim < 1) throw new Error(`reducer _dim: dim must be >= 1 (got ${dim})`);\n  if (dim > t.shape.length) {\n    const out = mtoc2_tensor_alloc_nd(t.shape.length, t.shape.slice());\n    out.data.set(t.data);\n    return out;\n  }\n  const dimIdx = dim - 1;\n  const axis = t.shape[dimIdx];\n  let before = 1;\n  for (let i = 0; i < dimIdx; i++) before *= t.shape[i];\n  let after = 1;\n  for (let i = dimIdx + 1; i < t.shape.length; i++) after *= t.shape[i];\n  const outDims = t.shape.slice();\n  outDims[dimIdx] = 1;\n  squeeze_trailing(outDims);\n  const out = mtoc2_tensor_alloc_nd(outDims.length, outDims);\n  for (let aft = 0; aft < after; aft++) {\n    for (let bef = 0; bef < before; bef++) {\n      const base = aft * before * axis + bef;\n      let best = NaN;\n      let found = false;\n      for (let k = 0; k < axis; k++) {\n        const x = t.data[base + k * before];\n        if (x !== x) continue; // skip NaN\n        if (!found || (op === "min" ? x < best : x > best)) {\n          best = x;\n          found = true;\n        }\n      }\n      out.data[aft * before + bef] = found ? best : NaN;\n    }\n  }\n  return out;\n}\n\n// Logical reducer (`any`, `all`). `emptyResult` is the value for a\n// 0-element reduction; `short` is the early-exit predicate.\nfunction logical_all(t, emptyResult, shortPredicate) {\n  if (t.data.length === 0) return emptyResult;\n  for (let i = 0; i < t.data.length; i++) {\n    if (shortPredicate(t.data[i])) return emptyResult === 1 ? 0 : 1;\n  }\n  return emptyResult;\n}\n\nfunction logical_dim(t, dim, emptyResult, shortPredicate) {\n  if (dim < 1) throw new Error(`reducer _dim: dim must be >= 1 (got ${dim})`);\n  if (dim > t.shape.length) {\n    // No-op axis: emit a logical cast of the input (each element \u2192\n    // 1 if nonzero, 0 otherwise).\n    const out = mtoc2_tensor_alloc_nd(t.shape.length, t.shape.slice());\n    for (let i = 0; i < t.data.length; i++) {\n      out.data[i] = t.data[i] !== 0 ? 1 : 0;\n    }\n    return out;\n  }\n  const dimIdx = dim - 1;\n  const axis = t.shape[dimIdx];\n  let before = 1;\n  for (let i = 0; i < dimIdx; i++) before *= t.shape[i];\n  let after = 1;\n  for (let i = dimIdx + 1; i < t.shape.length; i++) after *= t.shape[i];\n  const outDims = t.shape.slice();\n  outDims[dimIdx] = 1;\n  squeeze_trailing(outDims);\n  const out = mtoc2_tensor_alloc_nd(outDims.length, outDims);\n  for (let aft = 0; aft < after; aft++) {\n    for (let bef = 0; bef < before; bef++) {\n      const base = aft * before * axis + bef;\n      let res = emptyResult;\n      for (let k = 0; k < axis; k++) {\n        if (shortPredicate(t.data[base + k * before])) {\n          res = emptyResult === 1 ? 0 : 1;\n          break;\n        }\n      }\n      out.data[aft * before + bef] = res;\n    }\n  }\n  return out;\n}\n\n// \u2500\u2500 Sum \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nconst sumInit = 0;\nconst sumAccum = (a, x) => a + x;\nconst idFinalize = a => a;\nconst mtoc2_sum_all = t => accum_all(t, sumInit, sumAccum, idFinalize);\nconst mtoc2_sum_dim = (t, d) =>\n  accum_dim(t, d, sumInit, sumAccum, idFinalize);\n\n// \u2500\u2500 Prod \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nconst prodInit = 1;\nconst prodAccum = (a, x) => a * x;\nconst mtoc2_prod_all = t =>\n  accum_all(t, prodInit, prodAccum, idFinalize);\nconst mtoc2_prod_dim = (t, d) =>\n  accum_dim(t, d, prodInit, prodAccum, idFinalize);\n\n// \u2500\u2500 Mean \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nconst meanFinalize = (a, n) => (n === 0 ? NaN : a / n);\nconst mtoc2_mean_all = t =>\n  accum_all(t, sumInit, sumAccum, meanFinalize);\nconst mtoc2_mean_dim = (t, d) =>\n  accum_dim(t, d, sumInit, sumAccum, meanFinalize);\n\n// \u2500\u2500 Min / max \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nconst mtoc2_min_all = t => minmax_all(t, "min");\nconst mtoc2_min_dim = (t, d) => minmax_dim(t, d, "min");\nconst mtoc2_max_all = t => minmax_all(t, "max");\nconst mtoc2_max_dim = (t, d) => minmax_dim(t, d, "max");\n\n// \u2500\u2500 Any / all \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// any: short-circuits on a non-NaN nonzero; emptyResult = 0. NaN is\n// ignored (MATLAB: any(NaN) is 0, any([0 NaN]) is 0), so `x === x`\n// excludes it \u2014 without that, NaN wrongly short-circuited to true.\n// (`all` needs no such guard: allShort tests `x === 0`, which NaN\n// already fails, so a NaN simply doesn\'t force all to false.)\nconst anyShort = x => x !== 0 && x === x;\nconst mtoc2_any_all = t => logical_all(t, 0, anyShort);\nconst mtoc2_any_dim = (t, d) => logical_dim(t, d, 0, anyShort);\n// all: short-circuits on zero; emptyResult = 1.\nconst allShort = x => x === 0;\nconst mtoc2_all_all = t => logical_all(t, 1, allShort);\nconst mtoc2_all_dim = (t, d) => logical_dim(t, d, 1, allShort);\n',
   "tensor_repmat.js": "// JS sibling of `tensor_repmat.h`. Two helpers:\n//   - `mtoc2_tensor_repmat(in, nreps, reps)` \u2014 tile a real tensor.\n//   - `mtoc2_tensor_repmat_complex(in, nreps, reps)` \u2014 tile both\n//     lanes of a complex tensor (zero imag when input is real).\n// Negative reps clamp to 0; input shape and reps are right-padded\n// with 1s to a common rank.\n\n\n\nfunction mtoc2_tensor_repmat(input, nreps, repsIn) {\n  const reps = [];\n  for (let i = 0; i < nreps; i++) {\n    const r = repsIn[i] < 0 ? 0 : repsIn[i];\n    reps.push(r);\n  }\n  const inShape = input.shape;\n  const inNdim = inShape.length;\n  const outNdim = Math.max(nreps, inNdim);\n  const padShape = [];\n  const padReps = [];\n  const outDims = [];\n  for (let i = 0; i < outNdim; i++) {\n    padShape.push(i < inNdim ? inShape[i] : 1);\n    padReps.push(i < nreps ? reps[i] : 1);\n    outDims.push(padShape[i] * padReps[i]);\n  }\n  const out = mtoc2_tensor_alloc_nd(outNdim, outDims);\n  let outTotal = 1;\n  for (const d of outDims) outTotal *= d;\n  if (outTotal === 0) return out;\n  let inTotal = 1;\n  for (const d of inShape) inTotal *= d;\n  if (inTotal === 0) return out;\n\n  // Initial copy: trailing-1 padding doesn't change column-major layout.\n  out.data.set(input.data.subarray(0, inTotal), 0);\n\n  const curShape = padShape.slice();\n  let curTotal = inTotal;\n\n  for (let d = 0; d < outNdim; d++) {\n    const rep = padReps[d];\n    if (rep === 1) continue;\n    let blockSize = 1;\n    for (let i = 0; i <= d; i++) blockSize *= curShape[i];\n    if (rep === 0 || blockSize === 0) {\n      // outTotal will be 0; the alloc above already produced an empty\n      // tensor. Done.\n      return out;\n    }\n    const numBlocks = curTotal / blockSize;\n    // Walk blocks in reverse to avoid overwriting source data.\n    for (let b = numBlocks - 1; b >= 0; b--) {\n      const srcOff = b * blockSize;\n      const dstBase = b * blockSize * rep;\n      if (dstBase !== srcOff) {\n        // copyWithin handles overlapping moves correctly.\n        out.data.copyWithin(dstBase, srcOff, srcOff + blockSize);\n      }\n      for (let r = 1; r < rep; r++) {\n        out.data.copyWithin(\n          dstBase + r * blockSize,\n          dstBase,\n          dstBase + blockSize\n        );\n      }\n    }\n    curShape[d] *= rep;\n    curTotal *= rep;\n  }\n  return out;\n}\n\nfunction mtoc2_tensor_repmat_complex(input, nreps, repsIn) {\n  const reps = [];\n  for (let i = 0; i < nreps; i++) {\n    const r = repsIn[i] < 0 ? 0 : repsIn[i];\n    reps.push(r);\n  }\n  const inShape = input.shape;\n  const inNdim = inShape.length;\n  const outNdim = Math.max(nreps, inNdim);\n  const padShape = [];\n  const padReps = [];\n  const outDims = [];\n  for (let i = 0; i < outNdim; i++) {\n    padShape.push(i < inNdim ? inShape[i] : 1);\n    padReps.push(i < nreps ? reps[i] : 1);\n    outDims.push(padShape[i] * padReps[i]);\n  }\n  const out = mtoc2_tensor_alloc_nd_complex(outNdim, outDims);\n  let outTotal = 1;\n  for (const d of outDims) outTotal *= d;\n  if (outTotal === 0) return out;\n  let inTotal = 1;\n  for (const d of inShape) inTotal *= d;\n  if (inTotal === 0) return out;\n\n  const im = input.imag;\n  out.data.set(input.data.subarray(0, inTotal), 0);\n  if (im !== undefined) out.imag.set(im.subarray(0, inTotal), 0);\n\n  const curShape = padShape.slice();\n  let curTotal = inTotal;\n\n  for (let d = 0; d < outNdim; d++) {\n    const rep = padReps[d];\n    if (rep === 1) continue;\n    let blockSize = 1;\n    for (let i = 0; i <= d; i++) blockSize *= curShape[i];\n    if (rep === 0 || blockSize === 0) return out;\n    const numBlocks = curTotal / blockSize;\n    for (let b = numBlocks - 1; b >= 0; b--) {\n      const srcOff = b * blockSize;\n      const dstBase = b * blockSize * rep;\n      if (dstBase !== srcOff) {\n        out.data.copyWithin(dstBase, srcOff, srcOff + blockSize);\n        out.imag.copyWithin(dstBase, srcOff, srcOff + blockSize);\n      }\n      for (let r = 1; r < rep; r++) {\n        out.data.copyWithin(\n          dstBase + r * blockSize,\n          dstBase,\n          dstBase + blockSize\n        );\n        out.imag.copyWithin(\n          dstBase + r * blockSize,\n          dstBase,\n          dstBase + blockSize\n        );\n      }\n    }\n    curShape[d] *= rep;\n    curTotal *= rep;\n  }\n  return out;\n}\n",
   "tensor_reshape_nd.js": "// JS sibling of `tensor_reshape_nd.h`. Reshape a real tensor to an\n// N-D shape, supporting one `-1` auto-infer slot. Same error\n// behaviour as the C side: throws (instead of `abort()`) on bad\n// inputs.\n\n\nfunction mtoc2_reshape_nd(input, ndim, dims) {\n  let inTotal = 1;\n  for (const d of input.shape) inTotal *= d;\n  let inferIdx = -1;\n  let explicitProd = 1;\n  for (let i = 0; i < ndim; i++) {\n    if (dims[i] === -1) {\n      if (inferIdx !== -1) {\n        throw new Error(\"reshape: at most one '[]' auto-infer slot allowed\");\n      }\n      inferIdx = i;\n    } else if (dims[i] < 0) {\n      throw new Error(\n        `reshape: dim ${i + 1} must be a non-negative integer (got ${dims[i]})`\n      );\n    } else {\n      explicitProd *= dims[i];\n    }\n  }\n  const resolved = new Array(ndim);\n  for (let i = 0; i < ndim; i++) resolved[i] = dims[i];\n  let outTotal;\n  if (inferIdx !== -1) {\n    if (explicitProd === 0 && inTotal !== 0) {\n      throw new Error(\n        `reshape: input has ${inTotal} elements but explicit dims around '[]' multiply to 0`\n      );\n    }\n    if (explicitProd > 0 && inTotal % explicitProd !== 0) {\n      throw new Error(\n        `reshape: input has ${inTotal} elements, not divisible by ${explicitProd}`\n      );\n    }\n    resolved[inferIdx] = explicitProd === 0 ? 0 : inTotal / explicitProd;\n    outTotal = inTotal;\n  } else {\n    outTotal = explicitProd;\n    if (inTotal !== outTotal) {\n      throw new Error(\n        `reshape: number of elements must not change (in=${inTotal}, out=${outTotal})`\n      );\n    }\n  }\n  const out = mtoc2_tensor_alloc_nd(ndim, resolved);\n  if (outTotal > 0) out.data.set(input.data.subarray(0, outTotal));\n  return out;\n}\n",
   "tensor_reshape_nd_complex.js": "// JS sibling of `tensor_reshape_nd_complex.h`. Reshape a complex\n// tensor to an N-D shape. Same auto-infer / element-count rules as\n// the real reshape; both lanes are reinterpreted (no rearrangement).\n\n\nfunction mtoc2_reshape_nd_complex(input, ndim, dims) {\n  let inTotal = 1;\n  for (const d of input.shape) inTotal *= d;\n  let inferIdx = -1;\n  let explicitProd = 1;\n  for (let i = 0; i < ndim; i++) {\n    if (dims[i] === -1) {\n      if (inferIdx !== -1) {\n        throw new Error(\"reshape: at most one '[]' auto-infer slot allowed\");\n      }\n      inferIdx = i;\n    } else if (dims[i] < 0) {\n      throw new Error(\n        `reshape: dim ${i + 1} must be a non-negative integer (got ${dims[i]})`\n      );\n    } else {\n      explicitProd *= dims[i];\n    }\n  }\n  const resolved = new Array(ndim);\n  for (let i = 0; i < ndim; i++) resolved[i] = dims[i];\n  let outTotal;\n  if (inferIdx !== -1) {\n    if (explicitProd === 0 && inTotal !== 0) {\n      throw new Error(\n        `reshape: input has ${inTotal} elements but explicit dims around '[]' multiply to 0`\n      );\n    }\n    if (explicitProd > 0 && inTotal % explicitProd !== 0) {\n      throw new Error(\n        `reshape: input has ${inTotal} elements, not divisible by ${explicitProd}`\n      );\n    }\n    resolved[inferIdx] = explicitProd === 0 ? 0 : inTotal / explicitProd;\n    outTotal = inTotal;\n  } else {\n    outTotal = explicitProd;\n    if (inTotal !== outTotal) {\n      throw new Error(\n        `reshape: number of elements must not change (in=${inTotal}, out=${outTotal})`\n      );\n    }\n  }\n  const out = mtoc2_tensor_alloc_nd_complex(ndim, resolved);\n  if (outTotal > 0) {\n    out.data.set(input.data.subarray(0, outTotal));\n    if (input.imag !== undefined) {\n      out.imag.set(input.imag.subarray(0, outTotal));\n    }\n  }\n  return out;\n}\n",
   "tensor_size.js": "// JS sibling of `tensor_size.h`. Build a 1\xD7ndim row tensor whose\n// elements are the input's dim sizes.\n\n\nfunction mtoc2_tensor_size_row(a) {\n  const n = a.shape.length;\n  const r = mtoc2_tensor_alloc(1, n);\n  for (let i = 0; i < n; i++) r.data[i] = a.shape[i];\n  return r;\n}\n",
-  "tensor_sort_real.js": "// JS sibling of `tensor_sort_real.h`. Stable sort on real and\n// complex tensors. The descending flag flips the comparator while\n// keeping the tie-break on ascending original index. Complex sort\n// orders by magnitude then phase (matches numbl).\n\n\n\nfunction pair_sort_indices(a, descending) {\n  const n = a.data.length;\n  const idx = new Array(n);\n  for (let i = 0; i < n; i++) idx[i] = i;\n  idx.sort((p, q) => {\n    const av = a.data[p];\n    const bv = a.data[q];\n    // NaN ranks as the maximum (MATLAB): last when ascending, first\n    // when descending. Without this, NaN compares false both ways and\n    // falls through to the index tie-break, making the comparator\n    // non-transitive and corrupting the whole array.\n    const an = av !== av;\n    const bn = bv !== bv;\n    if (an || bn) {\n      if (an && bn) return p - q;\n      if (an) return descending ? -1 : 1;\n      return descending ? 1 : -1;\n    }\n    if (av < bv) return descending ? 1 : -1;\n    if (av > bv) return descending ? -1 : 1;\n    return p - q;\n  });\n  return idx;\n}\n\nfunction complex_sort_indices(a, descending) {\n  const n = a.data.length;\n  const im = a.imag;\n  const idx = new Array(n);\n  const mag = new Float64Array(n);\n  const ph = new Float64Array(n);\n  for (let i = 0; i < n; i++) {\n    const re = a.data[i];\n    const xi = im !== undefined ? im[i] : 0;\n    mag[i] = Math.hypot(re, xi);\n    ph[i] = Math.atan2(xi, re);\n    idx[i] = i;\n  }\n  idx.sort((p, q) => {\n    if (mag[p] < mag[q]) return descending ? 1 : -1;\n    if (mag[p] > mag[q]) return descending ? -1 : 1;\n    if (ph[p] < ph[q]) return descending ? 1 : -1;\n    if (ph[p] > ph[q]) return descending ? -1 : 1;\n    return p - q;\n  });\n  return idx;\n}\n\nfunction mtoc2_sort_real(a, descending) {\n  const v = mtoc2_tensor_alloc_nd(a.shape.length, a.shape);\n  if (a.data.length === 0) return v;\n  const sorted = pair_sort_indices(a, descending);\n  for (let i = 0; i < sorted.length; i++) v.data[i] = a.data[sorted[i]];\n  return v;\n}\n\nfunction mtoc2_sort_real_2(a, descending) {\n  const v = mtoc2_tensor_alloc_nd(a.shape.length, a.shape);\n  const ix = mtoc2_tensor_alloc_nd(a.shape.length, a.shape);\n  if (a.data.length === 0) return { v, ix };\n  const sorted = pair_sort_indices(a, descending);\n  for (let i = 0; i < sorted.length; i++) {\n    v.data[i] = a.data[sorted[i]];\n    ix.data[i] = sorted[i] + 1;\n  }\n  return { v, ix };\n}\n\nfunction mtoc2_sort_complex(a, descending) {\n  const v = mtoc2_tensor_alloc_nd_complex(a.shape.length, a.shape);\n  if (a.data.length === 0) return v;\n  const sorted = complex_sort_indices(a, descending);\n  const im = a.imag;\n  for (let i = 0; i < sorted.length; i++) {\n    v.data[i] = a.data[sorted[i]];\n    if (im !== undefined) v.imag[i] = im[sorted[i]];\n  }\n  return v;\n}\n\nfunction mtoc2_sort_complex_2(a, descending) {\n  const v = mtoc2_tensor_alloc_nd_complex(a.shape.length, a.shape);\n  const ix = mtoc2_tensor_alloc_nd(a.shape.length, a.shape);\n  if (a.data.length === 0) return { v, ix };\n  const sorted = complex_sort_indices(a, descending);\n  const im = a.imag;\n  for (let i = 0; i < sorted.length; i++) {\n    v.data[i] = a.data[sorted[i]];\n    if (im !== undefined) v.imag[i] = im[sorted[i]];\n    ix.data[i] = sorted[i] + 1;\n  }\n  return { v, ix };\n}\n",
+  "tensor_sort_real.js": "// JS sibling of `tensor_sort_real.h`. Stable sort on real and\n// complex tensors. The descending flag flips the comparator while\n// keeping the tie-break on ascending original index. Complex sort\n// orders by magnitude then phase (matches numbl).\n\n\n\nfunction pair_sort_indices(a, descending) {\n  const n = a.data.length;\n  const idx = new Array(n);\n  for (let i = 0; i < n; i++) idx[i] = i;\n  idx.sort((p, q) => {\n    const av = a.data[p];\n    const bv = a.data[q];\n    // NaN ranks as the maximum (MATLAB): last when ascending, first\n    // when descending. Without this, NaN compares false both ways and\n    // falls through to the index tie-break, making the comparator\n    // non-transitive and corrupting the whole array.\n    const an = av !== av;\n    const bn = bv !== bv;\n    if (an || bn) {\n      if (an && bn) return p - q;\n      if (an) return descending ? -1 : 1;\n      return descending ? 1 : -1;\n    }\n    if (av < bv) return descending ? 1 : -1;\n    if (av > bv) return descending ? -1 : 1;\n    return p - q;\n  });\n  return idx;\n}\n\nfunction complex_sort_indices(a, descending) {\n  const n = a.data.length;\n  const im = a.imag;\n  const idx = new Array(n);\n  for (let i = 0; i < n; i++) idx[i] = i;\n\n  // All-zero imaginary lane \u2192 order by signed real value (matches the\n  // interpreter and MATLAB on real data), not by magnitude. NaNs sort\n  // last when ascending, first when descending.\n  let realMode = true;\n  if (im !== undefined) {\n    for (let i = 0; i < n; i++) {\n      if (im[i] !== 0) {\n        realMode = false;\n        break;\n      }\n    }\n  }\n  if (realMode) {\n    const re = a.data;\n    idx.sort((p, q) => {\n      const rp = re[p];\n      const rq = re[q];\n      const pNaN = rp !== rp;\n      const qNaN = rq !== rq;\n      if (pNaN && qNaN) return 0;\n      if (descending) {\n        if (pNaN) return -1;\n        if (qNaN) return 1;\n        return rp < rq ? 1 : rp > rq ? -1 : 0;\n      }\n      if (pNaN) return 1;\n      if (qNaN) return -1;\n      return rp < rq ? -1 : rp > rq ? 1 : 0;\n    });\n    return idx;\n  }\n\n  const mag = new Float64Array(n);\n  const ph = new Float64Array(n);\n  for (let i = 0; i < n; i++) {\n    const re = a.data[i];\n    const xi = im !== undefined ? im[i] : 0;\n    mag[i] = Math.hypot(re, xi);\n    ph[i] = Math.atan2(xi, re);\n  }\n  idx.sort((p, q) => {\n    if (mag[p] < mag[q]) return descending ? 1 : -1;\n    if (mag[p] > mag[q]) return descending ? -1 : 1;\n    if (ph[p] < ph[q]) return descending ? 1 : -1;\n    if (ph[p] > ph[q]) return descending ? -1 : 1;\n    return p - q;\n  });\n  return idx;\n}\n\nfunction mtoc2_sort_real(a, descending) {\n  const v = mtoc2_tensor_alloc_nd(a.shape.length, a.shape);\n  if (a.data.length === 0) return v;\n  const sorted = pair_sort_indices(a, descending);\n  for (let i = 0; i < sorted.length; i++) v.data[i] = a.data[sorted[i]];\n  return v;\n}\n\nfunction mtoc2_sort_real_2(a, descending) {\n  const v = mtoc2_tensor_alloc_nd(a.shape.length, a.shape);\n  const ix = mtoc2_tensor_alloc_nd(a.shape.length, a.shape);\n  if (a.data.length === 0) return { v, ix };\n  const sorted = pair_sort_indices(a, descending);\n  for (let i = 0; i < sorted.length; i++) {\n    v.data[i] = a.data[sorted[i]];\n    ix.data[i] = sorted[i] + 1;\n  }\n  return { v, ix };\n}\n\nfunction mtoc2_sort_complex(a, descending) {\n  const v = mtoc2_tensor_alloc_nd_complex(a.shape.length, a.shape);\n  if (a.data.length === 0) return v;\n  const sorted = complex_sort_indices(a, descending);\n  const im = a.imag;\n  for (let i = 0; i < sorted.length; i++) {\n    v.data[i] = a.data[sorted[i]];\n    if (im !== undefined) v.imag[i] = im[sorted[i]];\n  }\n  return v;\n}\n\nfunction mtoc2_sort_complex_2(a, descending) {\n  const v = mtoc2_tensor_alloc_nd_complex(a.shape.length, a.shape);\n  const ix = mtoc2_tensor_alloc_nd(a.shape.length, a.shape);\n  if (a.data.length === 0) return { v, ix };\n  const sorted = complex_sort_indices(a, descending);\n  const im = a.imag;\n  for (let i = 0; i < sorted.length; i++) {\n    v.data[i] = a.data[sorted[i]];\n    if (im !== undefined) v.imag[i] = im[sorted[i]];\n    ix.data[i] = sorted[i] + 1;\n  }\n  return { v, ix };\n}\n",
   "tensor_transpose.js": "// JS sibling of `tensor_transpose.h`. Real 2-D non-conjugate\n// transpose. Mirrors `transposeCore` semantics: column-major in,\n// column-major out.\n\n\nfunction mtoc2_tensor_transpose(a) {\n  const m = a.shape[0];\n  const n = a.shape[1];\n  const r = mtoc2_tensor_alloc(n, m);\n  for (let sc = 0; sc < n; sc++) {\n    for (let sr = 0; sr < m; sr++) {\n      r.data[sc + sr * n] = a.data[sr + sc * m];\n    }\n  }\n  return r;\n}\n",
   "tensor_transpose_complex.js": "// JS sibling of `tensor_transpose_complex.h`. Real 2-D non-conjugate\n// transpose for a complex tensor \u2014 both lanes get the same index\n// permutation. `'` (conjugate transpose) lowers to\n// `transpose(conj(z))` upstream, so this helper isn't responsible\n// for negating the imag lane.\n\n\nfunction mtoc2_tensor_transpose_complex(a) {\n  const m = a.shape[0];\n  const n = a.shape[1];\n  const r = mtoc2_tensor_alloc_complex(n, m);\n  const aim = a.imag;\n  for (let sc = 0; sc < n; sc++) {\n    for (let sr = 0; sr < m; sr++) {\n      r.data[sc + sr * n] = a.data[sr + sc * m];\n      r.imag[sc + sr * n] = aim !== undefined ? aim[sr + sc * m] : 0;\n    }\n  }\n  return r;\n}\n",
   "tensor_triangular.js": "// JS sibling of `tensor_triangular.h`. Four helpers: `triu` / `tril`\n// keep entries where `j - i >= k` / `i - j >= -k`; their `_complex`\n// siblings walk both lanes. Mirrors `triPart` in numbl's\n// `interpreter/builtins/array-extras.ts`.\n\n\n\nfunction mtoc2_tensor_triu(a, k) {\n  const rows = a.shape[0];\n  const cols = a.shape[1];\n  const out = mtoc2_tensor_alloc(rows, cols);\n  for (let j = 0; j < cols; j++) {\n    for (let i = 0; i < rows; i++) {\n      if (j - i >= k) {\n        const idx = i + j * rows;\n        out.data[idx] = a.data[idx];\n      }\n    }\n  }\n  return out;\n}\n\nfunction mtoc2_tensor_tril(a, k) {\n  const rows = a.shape[0];\n  const cols = a.shape[1];\n  const out = mtoc2_tensor_alloc(rows, cols);\n  for (let j = 0; j < cols; j++) {\n    for (let i = 0; i < rows; i++) {\n      if (i - j >= -k) {\n        const idx = i + j * rows;\n        out.data[idx] = a.data[idx];\n      }\n    }\n  }\n  return out;\n}\n\nfunction mtoc2_tensor_triu_complex(a, k) {\n  const rows = a.shape[0];\n  const cols = a.shape[1];\n  const out = mtoc2_tensor_alloc_nd_complex(2, [rows, cols]);\n  const im = a.imag;\n  for (let j = 0; j < cols; j++) {\n    for (let i = 0; i < rows; i++) {\n      if (j - i >= k) {\n        const idx = i + j * rows;\n        out.data[idx] = a.data[idx];\n        if (im !== undefined) out.imag[idx] = im[idx];\n      }\n    }\n  }\n  return out;\n}\n\nfunction mtoc2_tensor_tril_complex(a, k) {\n  const rows = a.shape[0];\n  const cols = a.shape[1];\n  const out = mtoc2_tensor_alloc_nd_complex(2, [rows, cols]);\n  const im = a.imag;\n  for (let j = 0; j < cols; j++) {\n    for (let i = 0; i < rows; i++) {\n      if (i - j >= -k) {\n        const idx = i + j * rows;\n        out.data[idx] = a.data[idx];\n        if (im !== undefined) out.imag[idx] = im[idx];\n      }\n    }\n  }\n  return out;\n}\n",
@@ -65509,6 +66226,7 @@ var JS_IMPORTS = {
   "tensor_fill_nd.js": ["tensor_alloc_nd.js", "tensor_alloc_nd_complex.js"],
   "tensor_fill_square.js": ["tensor_fill_nd.js"],
   "tensor_flip.js": ["tensor_alloc_nd.js", "tensor_alloc_nd_complex.js"],
+  "tensor_imag_all_zero.js": [],
   "tensor_linspace.js": ["tensor_alloc.js"],
   "tensor_logical_real.js": ["tensor_alloc_nd.js"],
   "tensor_logspace.js": ["tensor_alloc.js"],
@@ -73131,7 +73849,7 @@ function checkArity2(argTypes, nargout) {
 function staticVerdict(t) {
   if (!isNumeric2(t)) return true;
   if (!t.isComplex) return true;
-  if (!isScalar(t)) return false;
+  if (!isScalar(t)) return "runtime";
   const ex = t.exact;
   if (ex !== void 0 && typeof ex === "object" && "im" in ex) {
     const im = ex.im;
@@ -73148,23 +73866,33 @@ var isreal = {
     return [scalarLogical(v)];
   },
   emitC({ argTypes, argsC, useRuntime }) {
-    const v = staticVerdict(argTypes[0]);
+    const t = argTypes[0];
+    const v = staticVerdict(t);
     if (v === true) return "1.0";
     if (v === false) return "0.0";
+    if (isNumeric2(t) && t.isComplex && !isScalar(t)) {
+      useRuntime("mtoc2_tensor_imag_all_zero");
+      return `mtoc2_tensor_imag_all_zero(${argsC[0]})`;
+    }
     useRuntime("mtoc2_cscalar");
     return `(cimag(${argsC[0]}) == 0.0)`;
   },
-  emitJs({ argTypes, argsJs }) {
-    const v = staticVerdict(argTypes[0]);
+  emitJs({ argTypes, argsJs, useRuntime }) {
+    const t = argTypes[0];
+    const v = staticVerdict(t);
     if (v === true) return "true";
     if (v === false) return "false";
+    if (isNumeric2(t) && t.isComplex && !isScalar(t)) {
+      useRuntime("mtoc2_tensor_imag_all_zero");
+      return `mtoc2_tensor_imag_all_zero(${argsJs[0]})`;
+    }
     return `(${argsJs[0]}.im === 0)`;
   },
   call({ args }) {
     const v = args[0];
     if (typeof v === "number" || typeof v === "boolean") return [true];
     if (isComplexValue(v)) return [v.im === 0];
-    if (isTensor(v)) return [!v.imag];
+    if (isTensor(v)) return [mtoc2_tensor_imag_all_zero(v)];
     return [true];
   }
 };
@@ -81324,6 +82052,13 @@ var REGISTRY2 = /* @__PURE__ */ new Map([
       "mtoc2_cdiv"
     ])
   ],
+  // `isreal` on a complex-typed tensor: scan the imag lane (true iff all
+  // zero). Lets the JIT report realness by value, matching the
+  // interpreter on tensors the type system could not prove real.
+  [
+    "mtoc2_tensor_imag_all_zero",
+    loadSnippet("tensor_imag_all_zero.h", ["mtoc2_tensor_t"])
+  ],
   // ── Elementwise binary/unary on real tensors ──────────────────────
   // One snippet covers all 11 funcs (4×_tt, 4×_ts, 2×_st, 1×uminus).
   // Builtins activate by op-specific synthetic name; all map to the
@@ -86363,15 +87098,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
         );
       }