numbl 0.0.21 → 0.0.23

package/dist-cli/cli.js

@@ -1214,6 +1214,10 @@ var RTV = {
     while (s.length > 2 && s[s.length - 1] === 1) s.pop();
     return { kind: "tensor", data: d, imag: im, shape: s, _rc: 1 };
   },
+  /** Fast tensor constructor — data must be FloatXArray, shape already normalized (no trailing singletons). */
+  tensorRaw(data, shape) {
+    return { kind: "tensor", data, imag: void 0, shape, _rc: 1 };
+  },
   /** Create a scalar tensor (1x1) */
   scalar(value) {
     return value;
@@ -1352,6 +1356,7 @@ var getItemTypeFromRuntimeValue = (value) => {
 };
 
 // src/numbl-core/native/lapack-bridge.ts
+var NATIVE_ADDON_EXPECTED_VERSION = 1;
 var _bridge = null;
 function setLapackBridge(bridge) {
   _bridge = bridge;
@@ -19027,7 +19032,91 @@ function complexBinaryOp(a, b, op) {
     `Matrix dimensions must agree: [${at.shape.join(",")}] vs [${bt.shape.join(",")}]`
   );
 }
+var ELEMWISE_ADD = 0;
+var ELEMWISE_SUB = 1;
+var ELEMWISE_MUL = 2;
+var ELEMWISE_DIV = 3;
+function matchSameShapeTensors(a, b) {
+  if (typeof a !== "object" || a === null || a.kind !== "tensor" || typeof b !== "object" || b === null || b.kind !== "tensor")
+    return null;
+  const at = a;
+  const bt = b;
+  if (at.data.length !== bt.data.length || at.shape.length !== bt.shape.length || at.shape.some((d, i) => d !== bt.shape[i]))
+    return null;
+  return [at, bt];
+}
+function tryNativeElemwiseReal(at, bt, opCode) {
+  const bridge = getLapackBridge();
+  if (!bridge?.elemwise) return null;
+  const result = bridge.elemwise(
+    at.data,
+    bt.data,
+    opCode
+  );
+  return RTV.tensorRaw(result, at.shape);
+}
+function tensorElemwiseComplex(at, bt, opCode, jsOp) {
+  const bridge = getLapackBridge();
+  if (bridge?.elemwiseComplex) {
+    const r = bridge.elemwiseComplex(
+      at.data,
+      at.imag ?? null,
+      bt.data,
+      bt.imag ?? null,
+      opCode
+    );
+    if (r.im) return RTV.tensor(r.re, at.shape, r.im);
+    return RTV.tensorRaw(r.re, at.shape);
+  }
+  const len = at.data.length;
+  const aIm = at.imag;
+  const bIm = bt.imag;
+  const resultRe = new FloatXArray(len);
+  const resultIm = new FloatXArray(len);
+  if (aIm && bIm) {
+    for (let i = 0; i < len; i++) {
+      const r = jsOp(at.data[i], aIm[i], bt.data[i], bIm[i]);
+      resultRe[i] = r.re;
+      resultIm[i] = r.im;
+    }
+  } else if (aIm) {
+    for (let i = 0; i < len; i++) {
+      const r = jsOp(at.data[i], aIm[i], bt.data[i], 0);
+      resultRe[i] = r.re;
+      resultIm[i] = r.im;
+    }
+  } else {
+    for (let i = 0; i < len; i++) {
+      const r = jsOp(at.data[i], 0, bt.data[i], bIm[i]);
+      resultRe[i] = r.re;
+      resultIm[i] = r.im;
+    }
+  }
+  const isReal = resultIm.every((x) => x === 0);
+  return RTV.tensor(resultRe, at.shape, isReal ? void 0 : resultIm);
+}
 function mAdd(a, b) {
+  const m = matchSameShapeTensors(a, b);
+  if (m) {
+    const [at, bt] = m;
+    if (!at.imag && !bt.imag) {
+      const nr = tryNativeElemwiseReal(at, bt, ELEMWISE_ADD);
+      if (nr) return nr;
+      const len = at.data.length;
+      const result = new FloatXArray(len);
+      for (let i = 0; i < len; i++) result[i] = at.data[i] + bt.data[i];
+      return RTV.tensorRaw(result, at.shape);
+    }
+    return tensorElemwiseComplex(
+      at,
+      bt,
+      ELEMWISE_ADD,
+      (aRe, aIm, bRe, bIm) => ({
+        re: aRe + bRe,
+        im: aIm + bIm
+      })
+    );
+  }
   if (isRuntimeSparseMatrix(a) || isRuntimeSparseMatrix(b))
     return mAddSparse(a, b);
   if (isComplexOrMixed(a, b)) {
@@ -19039,6 +19128,27 @@ function mAdd(a, b) {
   return binaryOp(a, b, (x, y) => x + y);
 }
 function mSub(a, b) {
+  const m = matchSameShapeTensors(a, b);
+  if (m) {
+    const [at, bt] = m;
+    if (!at.imag && !bt.imag) {
+      const nr = tryNativeElemwiseReal(at, bt, ELEMWISE_SUB);
+      if (nr) return nr;
+      const len = at.data.length;
+      const result = new FloatXArray(len);
+      for (let i = 0; i < len; i++) result[i] = at.data[i] - bt.data[i];
+      return RTV.tensorRaw(result, at.shape);
+    }
+    return tensorElemwiseComplex(
+      at,
+      bt,
+      ELEMWISE_SUB,
+      (aRe, aIm, bRe, bIm) => ({
+        re: aRe - bRe,
+        im: aIm - bIm
+      })
+    );
+  }
   if (isRuntimeSparseMatrix(a) || isRuntimeSparseMatrix(b))
     return mSubSparse(a, b);
   if (isComplexOrMixed(a, b)) {
@@ -19064,6 +19174,27 @@ function mMul(a, b) {
   return binaryOp(a, b, (x, y) => x * y);
 }
 function mElemMul(a, b) {
+  const m = matchSameShapeTensors(a, b);
+  if (m) {
+    const [at, bt] = m;
+    if (!at.imag && !bt.imag) {
+      const nr = tryNativeElemwiseReal(at, bt, ELEMWISE_MUL);
+      if (nr) return nr;
+      const len = at.data.length;
+      const result = new FloatXArray(len);
+      for (let i = 0; i < len; i++) result[i] = at.data[i] * bt.data[i];
+      return RTV.tensorRaw(result, at.shape);
+    }
+    return tensorElemwiseComplex(
+      at,
+      bt,
+      ELEMWISE_MUL,
+      (aRe, aIm, bRe, bIm) => ({
+        re: aRe * bRe - aIm * bIm,
+        im: aRe * bIm + aIm * bRe
+      })
+    );
+  }
   if (isRuntimeSparseMatrix(a) || isRuntimeSparseMatrix(b))
     return mElemMulSparse(a, b);
   if (isComplexOrMixed(a, b)) {
@@ -19090,6 +19221,19 @@ function mDiv(a, b) {
   return binaryOp(a, b, (x, y) => x / y);
 }
 function mElemDiv(a, b) {
+  const m = matchSameShapeTensors(a, b);
+  if (m) {
+    const [at, bt] = m;
+    if (!at.imag && !bt.imag) {
+      const nr = tryNativeElemwiseReal(at, bt, ELEMWISE_DIV);
+      if (nr) return nr;
+      const len = at.data.length;
+      const result = new FloatXArray(len);
+      for (let i = 0; i < len; i++) result[i] = at.data[i] / bt.data[i];
+      return RTV.tensorRaw(result, at.shape);
+    }
+    return tensorElemwiseComplex(at, bt, ELEMWISE_DIV, complexDivide);
+  }
   if (isRuntimeSparseMatrix(a) || isRuntimeSparseMatrix(b))
     return mElemDivSparse(a, b);
   if (isComplexOrMixed(a, b)) {
@@ -19189,6 +19333,31 @@ function mPow(a, b) {
   return binaryOp(a, b, (x, y) => Math.pow(x, y));
 }
 function mElemPow(a, b) {
+  if (isRuntimeTensor(a) && !a.imag && isRuntimeNumber(b)) {
+    const exp = b;
+    if (exp === 2) {
+      const result = new FloatXArray(a.data.length);
+      for (let i = 0; i < result.length; i++) result[i] = a.data[i] * a.data[i];
+      return RTV.tensor(result, a.shape);
+    }
+    if (Number.isInteger(exp) || exp >= 0) {
+      let hasNeg2 = false;
+      if (!Number.isInteger(exp)) {
+        for (let i = 0; i < a.data.length; i++) {
+          if (a.data[i] < 0) {
+            hasNeg2 = true;
+            break;
+          }
+        }
+      }
+      if (!hasNeg2) {
+        const result = new FloatXArray(a.data.length);
+        for (let i = 0; i < result.length; i++)
+          result[i] = Math.pow(a.data[i], exp);
+        return RTV.tensor(result, a.shape);
+      }
+    }
+  }
   const complexPow = (aRe, aIm, bRe, bIm) => {
     const r = Math.sqrt(aRe * aRe + aIm * aIm);
     if (r === 0) {
@@ -19239,17 +19408,22 @@ function mElemPow(a, b) {
   return binaryOp(a, b, (x, y) => Math.pow(x, y));
 }
 function mNeg(v) {
-  if (isRuntimeSparseMatrix(v)) return sparseNeg(v);
-  if (isRuntimeComplexNumber(v)) return RTV.complex(-v.re, -v.im);
-  if (isRuntimeTensor(v) && v.imag !== void 0) {
-    const resultRe = new FloatXArray(v.data.length);
-    const resultIm = new FloatXArray(v.imag.length);
-    for (let i = 0; i < v.data.length; i++) {
-      resultRe[i] = -v.data[i];
-      resultIm[i] = -v.imag[i];
+  if (isRuntimeTensor(v)) {
+    if (v.imag !== void 0) {
+      const resultRe2 = new FloatXArray(v.data.length);
+      const resultIm = new FloatXArray(v.imag.length);
+      for (let i = 0; i < v.data.length; i++) {
+        resultRe2[i] = -v.data[i];
+        resultIm[i] = -v.imag[i];
+      }
+      return RTV.tensor(resultRe2, v.shape, resultIm);
     }
-    return RTV.tensor(resultRe, v.shape, resultIm);
+    const resultRe = new FloatXArray(v.data.length);
+    for (let i = 0; i < v.data.length; i++) resultRe[i] = -v.data[i];
+    return RTV.tensor(resultRe, v.shape);
   }
+  if (isRuntimeSparseMatrix(v)) return sparseNeg(v);
+  if (isRuntimeComplexNumber(v)) return RTV.complex(-v.re, -v.im);
   return unaryOp(v, (x) => -x);
 }
 function transposeCellArray(v) {
@@ -19524,6 +19698,40 @@ function broadcastComparison(a, b, outShape, op) {
   return t;
 }
 function binaryOp(a, b, op) {
+  if (isRuntimeTensor(a) && a.data.length > 1) {
+    if (isRuntimeTensor(b) && b.data.length > 1) {
+      if (a.data.length === b.data.length && a.shape.length === b.shape.length && a.shape.every((d, i) => d === b.shape[i])) {
+        const result = new FloatXArray(a.data.length);
+        for (let i = 0; i < result.length; i++) {
+          result[i] = op(a.data[i], b.data[i]);
+        }
+        return RTV.tensor(result, a.shape);
+      }
+      const broadcastShape2 = getBroadcastShape(a.shape, b.shape);
+      if (broadcastShape2 !== null) {
+        return broadcastBinary(a, b, broadcastShape2, op);
+      }
+      throw new RuntimeError(
+        `Matrix dimensions must agree: [${a.shape.join(",")}] vs [${b.shape.join(",")}]`
+      );
+    }
+    if (isRuntimeNumber(b)) {
+      const result = new FloatXArray(a.data.length);
+      const sv = b;
+      for (let i = 0; i < result.length; i++) {
+        result[i] = op(a.data[i], sv);
+      }
+      return RTV.tensor(result, a.shape);
+    }
+  }
+  if (isRuntimeTensor(b) && b.data.length > 1 && isRuntimeNumber(a)) {
+    const result = new FloatXArray(b.data.length);
+    const sv = a;
+    for (let i = 0; i < result.length; i++) {
+      result[i] = op(sv, b.data[i]);
+    }
+    return RTV.tensor(result, b.shape);
+  }
   const an = asNumeric(a);
   const bn = asNumeric(b);
   if (an.scalar && bn.scalar) {
@@ -19567,6 +19775,13 @@ function binaryOp(a, b, op) {
   );
 }
 function unaryOp(v, op) {
+  if (isRuntimeTensor(v) && v.data.length > 1) {
+    const result2 = new FloatXArray(v.data.length);
+    for (let i = 0; i < result2.length; i++) {
+      result2[i] = op(v.data[i]);
+    }
+    return RTV.tensor(result2, v.shape);
+  }
   const n = asNumeric(v);
   if (n.scalar) {
     const val = n.isComplex ? n.re : n.value;
@@ -19645,14 +19860,37 @@ function matMul(a, b) {
   }
   const isComplex2 = a.imag !== void 0 || b.imag !== void 0;
   if (!isComplex2) {
-    const bridge = getEffectiveBridge("matmul", "matmul");
+    const bridge2 = getEffectiveBridge("matmul", "matmul");
     const f64A = a.data instanceof Float64Array ? a.data : new Float64Array(a.data);
     const f64B = b.data instanceof Float64Array ? b.data : new Float64Array(b.data);
-    const raw = bridge.matmul(f64A, aRows, aCols, f64B, bCols);
+    const raw = bridge2.matmul(f64A, aRows, aCols, f64B, bCols);
     return unwrap1x1(RTV.tensor(new FloatXArray(raw), [aRows, bCols]));
   }
   const aIm = a.imag || new FloatXArray(a.data.length);
   const bIm = b.imag || new FloatXArray(b.data.length);
+  const bridge = getEffectiveBridge("matmul", "matmulComplex");
+  if (bridge.matmulComplex) {
+    const f64ARe = a.data instanceof Float64Array ? a.data : new Float64Array(a.data);
+    const f64AIm = aIm instanceof Float64Array ? aIm : new Float64Array(aIm);
+    const f64BRe = b.data instanceof Float64Array ? b.data : new Float64Array(b.data);
+    const f64BIm = bIm instanceof Float64Array ? bIm : new Float64Array(bIm);
+    const raw = bridge.matmulComplex(
+      f64ARe,
+      f64AIm,
+      aRows,
+      aCols,
+      f64BRe,
+      f64BIm,
+      bCols
+    );
+    return unwrap1x1(
+      RTV.tensor(
+        new FloatXArray(raw.re),
+        [aRows, bCols],
+        raw.im ? new FloatXArray(raw.im) : void 0
+      )
+    );
+  }
   const resultRe = new FloatXArray(aRows * bCols);
   const resultIm = new FloatXArray(aRows * bCols);
   for (let i = 0; i < aRows; i++) {
@@ -20148,6 +20386,30 @@ function indexIntoTensor1D(base, idx) {
 }
 function indexIntoTensor2D(base, rowIdx, colIdx) {
   const [rows, cols] = tensorSize2D(base);
+  if (isRuntimeNumber(rowIdx) && isColonIndex(colIdx)) {
+    const r = Math.round(rowIdx) - 1;
+    if (r < 0 || r >= rows)
+      throw new RuntimeError("Index exceeds array bounds");
+    const resultData2 = new FloatXArray(cols);
+    const resultImag2 = base.imag ? new FloatXArray(cols) : void 0;
+    for (let ci = 0; ci < cols; ci++) {
+      resultData2[ci] = base.data[r + ci * rows];
+      if (resultImag2 && base.imag) resultImag2[ci] = base.imag[r + ci * rows];
+    }
+    return RTV.tensor(resultData2, [1, cols], resultImag2);
+  }
+  if (isColonIndex(rowIdx) && isRuntimeNumber(colIdx)) {
+    const c = Math.round(colIdx) - 1;
+    if (c < 0 || c >= cols)
+      throw new RuntimeError("Index exceeds array bounds");
+    const offset = c * rows;
+    const resultData2 = new FloatXArray(rows);
+    for (let ri = 0; ri < rows; ri++) resultData2[ri] = base.data[offset + ri];
+    const resultImag2 = base.imag ? new FloatXArray(rows) : void 0;
+    if (resultImag2 && base.imag)
+      for (let ri = 0; ri < rows; ri++) resultImag2[ri] = base.imag[offset + ri];
+    return RTV.tensor(resultData2, [rows, 1], resultImag2);
+  }
   const rowIdxArr = resolveIndex(rowIdx, rows);
   const colIdxArr = resolveIndex(colIdx, cols);
   const numR = rowIdxArr.length;
@@ -20486,6 +20748,11 @@ function storeIntoTensor(base, indices, rhs) {
     return deleteTensorElements(base, indices[0]);
   }
   if (isRuntimeTensor(rhs) && rhs.data.length === 0 && indices.length === 2) {
+    const nrows = base.shape[0] ?? 1;
+    const ncols = base.shape.length >= 2 ? base.shape[1] : 1;
+    const rowCount = isColonIndex(indices[0]) ? nrows : resolveIndex(indices[0], nrows).length;
+    const colCount = isColonIndex(indices[1]) ? ncols : resolveIndex(indices[1], ncols).length;
+    if (rowCount === 0 || colCount === 0) return base;
     return deleteTensorRowsOrCols(base, indices);
   }
   if (base._rc > 1) {
@@ -20983,7 +21250,7 @@ function storeIntoTensorND(base, indices, rhs) {
   }
   return base;
 }
-function storeIntoCell(base, indices, rhs) {
+function storeIntoCell(base, indices, rhs, parenAssign = false) {
   if (base._rc > 1) {
     base._rc--;
     const sharedData = base.data.map((elem) => shareRuntimeValue(elem));
@@ -20997,14 +21264,20 @@ function storeIntoCell(base, indices, rhs) {
     c.shape = isColVec ? [newLen, 1] : [1, newLen];
   };
   if (indices.length === 1) {
-    return storeIntoCell1D(base, indices[0], rhs, updateShapeAfterLinearAssign);
+    return storeIntoCell1D(
+      base,
+      indices[0],
+      rhs,
+      updateShapeAfterLinearAssign,
+      parenAssign
+    );
   }
   if (indices.length === 2) {
-    return storeIntoCell2D(base, indices, rhs);
+    return storeIntoCell2D(base, indices, rhs, parenAssign);
   }
   throw new RuntimeError(`Cannot index-assign into cell`);
 }
-function storeIntoCell1D(base, idx, rhs, updateShape) {
+function storeIntoCell1D(base, idx, rhs, updateShape, parenAssign = false) {
   if (isRuntimeTensor(idx)) {
     let positions;
     if (idx._isLogical) {
@@ -21052,11 +21325,11 @@ function storeIntoCell1D(base, idx, rhs, updateShape) {
     while (base.data.length <= i)
       base.data.push(RTV.tensor(new FloatXArray(0), [0, 0]));
   }
-  base.data[i] = isRuntimeCell(rhs) && rhs.data.length === 1 ? rhs.data[0] : rhs;
+  base.data[i] = parenAssign && isRuntimeCell(rhs) && rhs.data.length === 1 ? rhs.data[0] : rhs;
   updateShape(oldLen);
   return base;
 }
-function storeIntoCell2D(base, indices, rhs) {
+function storeIntoCell2D(base, indices, rhs, parenAssign = false) {
   let rows = base.shape[0];
   let cols = base.shape.length >= 2 ? base.shape[1] : 1;
   const rowIndices = resolveIndex(indices[0], rows, 0);
@@ -21082,7 +21355,7 @@ function storeIntoCell2D(base, indices, rhs) {
   const nSelectedRows = rowIndices.length;
   const nSelectedCols = colIndices.length;
   const totalSelected = nSelectedRows * nSelectedCols;
-  if (isRuntimeCell(rhs)) {
+  if (parenAssign && isRuntimeCell(rhs)) {
     if (rhs.data.length !== totalSelected && rhs.data.length !== 1) {
       throw new RuntimeError("Subscripted assignment dimension mismatch");
     }
@@ -21100,7 +21373,7 @@ function storeIntoCell2D(base, indices, rhs) {
   }
   return base;
 }
-function storeIntoRTValueIndex(base, indices, rhs) {
+function storeIntoRTValueIndex(base, indices, rhs, parenAssign = false) {
   if (isRuntimeSparseMatrix(base)) {
     return storeIntoSparse(base, indices, rhs);
   }
@@ -21121,7 +21394,7 @@ function storeIntoRTValueIndex(base, indices, rhs) {
     return storeIntoTensor(base, indices, rhs);
   }
   if (isRuntimeCell(base)) {
-    return storeIntoCell(base, indices, rhs);
+    return storeIntoCell(base, indices, rhs, parenAssign);
   }
   throw new RuntimeError(`Cannot index-assign into ${kstr(base)}`);
 }
@@ -23031,11 +23304,8 @@ var CommandParser = class extends ExpressionParser {
         scanPos++;
         continue;
       }
-      if (ch === "\n" || ch === "\r" || ch === ";" || ch === "%") break;
-      if (ch === ",") {
-        scanPos++;
-        continue;
-      }
+      if (ch === "\n" || ch === "\r" || ch === ";" || ch === "%" || ch === ",")
+        break;
       if (ch === "." && scanPos + 2 < this.input.length && this.input[scanPos + 1] === "." && this.input[scanPos + 2] === ".") {
         scanPos += 3;
         while (scanPos < this.input.length && this.input[scanPos] !== "\n") {
@@ -25256,6 +25526,13 @@ function complexElemwise(realFn, complexFn, complexOutKind, o) {
         const isReal = complexOutKind === "Number" || resultIm2.every((x) => x === 0);
         return RTV.tensor(resultRe2, v.shape, isReal ? void 0 : resultIm2);
       }
+      if (o?.realSafe) {
+        const resultRe2 = new FloatXArray(v.data.length);
+        for (let i = 0; i < v.data.length; i++) {
+          resultRe2[i] = realFn(v.data[i]);
+        }
+        return RTV.tensor(resultRe2, v.shape);
+      }
       const resultRe = new FloatXArray(v.data.length);
       const resultIm = new FloatXArray(v.data.length);
       let hasImag = false;
@@ -25430,7 +25707,7 @@ function registerMathFunctions() {
         im: Math.cos(re) * Math.sinh(im)
       }),
       "ComplexNumber",
-      { nativeJs: "Math.sin" }
+      { nativeJs: "Math.sin", realSafe: true }
     ),
     1
   );
@@ -25443,7 +25720,7 @@ function registerMathFunctions() {
         im: -Math.sin(re) * Math.sinh(im)
       }),
       "ComplexNumber",
-      { nativeJs: "Math.cos" }
+      { nativeJs: "Math.cos", realSafe: true }
     ),
     1
   );
@@ -25456,7 +25733,7 @@ function registerMathFunctions() {
         return { re: Math.sin(2 * re) / denom, im: Math.sinh(2 * im) / denom };
       },
       "ComplexNumber",
-      { nativeJs: "Math.tan" }
+      { nativeJs: "Math.tan", realSafe: true }
     ),
     1
   );
@@ -25502,7 +25779,7 @@ function registerMathFunctions() {
         im: Math.cosh(re) * Math.sin(im)
       }),
       "ComplexNumber",
-      { nativeJs: "Math.sinh" }
+      { nativeJs: "Math.sinh", realSafe: true }
     ),
     1
   );
@@ -25515,7 +25792,7 @@ function registerMathFunctions() {
         im: Math.sinh(re) * Math.sin(im)
       }),
       "ComplexNumber",
-      { nativeJs: "Math.cosh" }
+      { nativeJs: "Math.cosh", realSafe: true }
     ),
     1
   );
@@ -25531,7 +25808,7 @@ function registerMathFunctions() {
         };
       },
       "ComplexNumber",
-      { nativeJs: "Math.tanh" }
+      { nativeJs: "Math.tanh", realSafe: true }
     ),
     1
   );
@@ -25581,7 +25858,7 @@ function registerMathFunctions() {
         im: Math.exp(re) * Math.sin(im)
       }),
       "ComplexNumber",
-      { nativeJs: "Math.exp" }
+      { nativeJs: "Math.exp", realSafe: true }
     ),
     1
   );
@@ -25683,7 +25960,7 @@ function registerMathFunctions() {
       Math.abs,
       (re, im) => ({ re: Math.sqrt(re * re + im * im), im: 0 }),
       "Number",
-      { nativeJs: "Math.abs" }
+      { nativeJs: "Math.abs", realSafe: true }
     ),
     1
   );
@@ -27476,6 +27753,19 @@ function registerArrayManipulationFunctions() {
       if (n !== data.length) {
         throw new RuntimeError("reshape: number of elements must not change");
       }
+      if (isRuntimeTensor(v)) {
+        v._rc++;
+        const s = [...shape];
+        while (s.length > 2 && s[s.length - 1] === 1) s.pop();
+        return {
+          kind: "tensor",
+          data,
+          imag,
+          shape: s,
+          _isLogical: v._isLogical,
+          _rc: v._rc
+        };
+      }
       return RTV.tensor(
         new FloatXArray(data),
         shape,
@@ -29011,6 +29301,27 @@ function dimReduce(v, dim, reduceFn, initialValue, finalizeFn) {
   const imOut = resultImag && resultImag.some((x) => x !== 0) ? resultImag : void 0;
   return RTV.tensor(result, info.resultShape, imOut);
 }
+function dimReduceOmitNaN(v, dim, reduceFn, initialValue, finalizeFn) {
+  if (!isRuntimeTensor(v))
+    throw new RuntimeError("dimReduceOmitNaN: argument must be a tensor");
+  const info = forEachSlice(v.shape, dim, () => {
+  });
+  if (!info) return copyTensor(v);
+  const result = new FloatXArray(info.totalElems);
+  forEachSlice(v.shape, dim, (outIdx, srcIndices) => {
+    let acc = initialValue;
+    let count = 0;
+    for (let k = 0; k < srcIndices.length; k++) {
+      const val = v.data[srcIndices[k]];
+      if (!isNaN(val)) {
+        acc = reduceFn(acc, val);
+        count++;
+      }
+    }
+    result[outIdx] = finalizeFn ? finalizeFn(acc, count) : acc;
+  });
+  return RTV.tensor(result, info.resultShape);
+}
 function sliceDimReduce(v, dim, sliceFn) {
   const info = forEachSlice(v.shape, dim, () => {
   });
@@ -29236,23 +29547,44 @@ function preserveTypeCheck(argTypes, nargout) {
   if (nargout === 2) return { outputTypes: [outType, outType] };
   return null;
 }
-function makeReduction(name, kernel) {
+function parseNanFlag(args) {
+  if (args.length >= 2) {
+    const last = args[args.length - 1];
+    if (isRuntimeChar(last)) {
+      const s = toString(last).toLowerCase();
+      if (s === "omitnan") return { args: args.slice(0, -1), omitNaN: true };
+      if (s === "includenan")
+        return { args: args.slice(0, -1), omitNaN: false };
+    }
+  }
+  return { args, omitNaN: false };
+}
+function filterNaN(arr) {
+  const out2 = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (!isNaN(arr[i])) out2.push(arr[i]);
+  }
+  return new Float64Array(out2);
+}
+function makeReduction(name, kernel, omitNaNKernel) {
   return {
     check: reductionCheck,
-    apply: (args) => {
-      if (args.length < 1)
+    apply: (rawArgs) => {
+      if (rawArgs.length < 1)
         throw new RuntimeError(`${name} requires at least 1 argument`);
+      const { args, omitNaN } = parseNanFlag(rawArgs);
+      const k = omitNaN && omitNaNKernel ? omitNaNKernel : kernel;
       const v = args[0];
       if (isRuntimeNumber(v)) return v;
       if (isRuntimeLogical(v)) return RTV.num(v ? 1 : 0);
       if (isRuntimeTensor(v)) {
         if (args.length >= 2) {
           if (isRuntimeChar(args[1]) && toString(args[1]) === "all")
-            return kernel.reduceAll(v);
-          return kernel.reduceDim(v, Math.round(toNumber(args[1])));
+            return k.reduceAll(v);
+          return k.reduceDim(v, Math.round(toNumber(args[1])));
         }
         const d = firstReduceDim(v.shape);
-        return d === 0 ? kernel.reduceAll(v) : kernel.reduceDim(v, d);
+        return d === 0 ? k.reduceAll(v) : k.reduceDim(v, d);
       }
       throw new RuntimeError(`${name}: argument must be numeric`);
     }
@@ -29282,6 +29614,42 @@ function sliceKernel(sliceFn) {
     reduceDim: (v, dim) => sliceDimReduce(v, dim, sliceFn)
   };
 }
+function accumKernelOmitNaN(reduceFn, initial, finalizeFn) {
+  return {
+    reduceAll: (v) => {
+      let acc = initial;
+      let count = 0;
+      for (let i = 0; i < v.data.length; i++) {
+        if (!isNaN(v.data[i])) {
+          acc = reduceFn(acc, v.data[i]);
+          count++;
+        }
+      }
+      const re = finalizeFn ? finalizeFn(acc, count) : acc;
+      if (v.imag) {
+        let accIm = initial;
+        let countIm = 0;
+        for (let i = 0; i < v.imag.length; i++) {
+          if (!isNaN(v.imag[i])) {
+            accIm = reduceFn(accIm, v.imag[i]);
+            countIm++;
+          }
+        }
+        const im = finalizeFn ? finalizeFn(accIm, countIm) : accIm;
+        if (im !== 0) return RTV.complex(re, im);
+      }
+      return RTV.num(re);
+    },
+    reduceDim: (v, dim) => dimReduceOmitNaN(v, dim, reduceFn, initial, finalizeFn)
+  };
+}
+function sliceKernelOmitNaN(sliceFn) {
+  const filteredFn = (slice) => sliceFn(filterNaN(slice));
+  return {
+    reduceAll: (v) => RTV.num(filteredFn(v.data)),
+    reduceDim: (v, dim) => sliceDimReduce(v, dim, filteredFn)
+  };
+}
 function toNumArray(v, name) {
   if (isRuntimeNumber(v)) return [v];
   if (isRuntimeTensor(v)) return Array.from(v.data);
@@ -29293,15 +29661,16 @@ function registerBasicReductions() {
   register("sum", [
     {
       check: reductionCheck,
-      apply: (args) => {
-        if (args.length < 1)
+      apply: (rawArgs) => {
+        if (rawArgs.length < 1)
           throw new RuntimeError("sum requires at least 1 argument");
+        const { args, omitNaN } = parseNanFlag(rawArgs);
         const v = args[0];
         if (isRuntimeSparseMatrix(v)) {
           const dim = args.length >= 2 ? Math.round(toNumber(args[1])) : v.m > 1 ? 1 : v.n > 1 ? 2 : 1;
           return sparseSum(v, dim);
         }
-        const kernel = accumKernel((acc, val) => acc + val, 0);
+        const kernel = omitNaN ? accumKernelOmitNaN((acc, val) => acc + val, 0) : accumKernel((acc, val) => acc + val, 0);
         if (isRuntimeNumber(v)) return v;
         if (isRuntimeLogical(v)) return RTV.num(v ? 1 : 0);
         if (isRuntimeTensor(v)) {
@@ -29317,13 +29686,14 @@ function registerBasicReductions() {
       }
     }
   ]);
-  const prodKernel = accumKernel((acc, val) => acc * val, 1);
   register("prod", [
     {
       check: reductionCheck,
-      apply: (args) => {
-        if (args.length < 1)
+      apply: (rawArgs) => {
+        if (rawArgs.length < 1)
           throw new RuntimeError("prod requires at least 1 argument");
+        const { args: parsedArgs, omitNaN } = parseNanFlag(rawArgs);
+        let args = parsedArgs;
         let v = args[0];
         if (isRuntimeSparseMatrix(v)) {
           v = sparseToDense(v);
@@ -29337,13 +29707,14 @@ function registerBasicReductions() {
               args.length >= 2 ? Math.round(toNumber(args[1])) : void 0
             );
           }
+          const kernel = omitNaN ? accumKernelOmitNaN((acc, val) => acc * val, 1) : accumKernel((acc, val) => acc * val, 1);
           if (args.length >= 2) {
             if (isRuntimeChar(args[1]) && toString(args[1]) === "all")
-              return prodKernel.reduceAll(v);
-            return prodKernel.reduceDim(v, Math.round(toNumber(args[1])));
+              return kernel.reduceAll(v);
+            return kernel.reduceDim(v, Math.round(toNumber(args[1])));
           }
           const d = firstReduceDim(v.shape);
-          return d === 0 ? prodKernel.reduceAll(v) : prodKernel.reduceDim(v, d);
+          return d === 0 ? kernel.reduceAll(v) : kernel.reduceDim(v, d);
         }
         throw new RuntimeError("prod: argument must be numeric");
       }
@@ -29356,31 +29727,40 @@ function registerBasicReductions() {
         (acc, val) => acc + val,
         0,
         (sum, count) => sum / count
+      ),
+      accumKernelOmitNaN(
+        (acc, val) => acc + val,
+        0,
+        (sum, count) => count === 0 ? NaN : sum / count
       )
     )
   ]);
-  const varianceOf = (slice, w) => {
-    const n = slice.length;
+  const varianceOf = (slice, w, omitNaN) => {
+    let data = slice;
+    if (omitNaN) data = filterNaN(slice);
+    const n = data.length;
+    if (n === 0) return NaN;
     if (n <= 1 && w === 0) return 0;
     let s = 0;
-    for (let i = 0; i < n; i++) s += slice[i];
+    for (let i = 0; i < n; i++) s += data[i];
     const m = s / n;
     let ss = 0;
-    for (let i = 0; i < n; i++) ss += (slice[i] - m) ** 2;
+    for (let i = 0; i < n; i++) ss += (data[i] - m) ** 2;
     const denom = w === 1 ? n : n - 1;
     return ss / denom;
   };
   const stdVarApply = (name, transform) => {
-    return (args) => {
-      if (args.length < 1)
+    return (rawArgs) => {
+      if (rawArgs.length < 1)
         throw new RuntimeError(`${name} requires at least 1 argument`);
+      const { args, omitNaN } = parseNanFlag(rawArgs);
       const v = args[0];
       const w = args.length >= 2 ? toNumber(args[1]) : 0;
       const dimArg = args.length >= 3 ? Math.round(toNumber(args[2])) : 0;
       if (isRuntimeNumber(v)) return RTV.num(0);
       if (isRuntimeTensor(v)) {
         const kernel = sliceKernel(
-          (slice) => transform(varianceOf(slice, w))
+          (slice) => transform(varianceOf(slice, w, omitNaN))
         );
         if (dimArg > 0) return kernel.reduceDim(v, dimArg);
         const d = firstReduceDim(v.shape);
@@ -29408,7 +29788,13 @@ function registerBasicReductions() {
     if (n % 2 === 1) return sorted[(n - 1) / 2];
     return (sorted[n / 2 - 1] + sorted[n / 2]) / 2;
   };
-  register("median", [makeReduction("median", sliceKernel(medianOf))]);
+  register("median", [
+    makeReduction(
+      "median",
+      sliceKernel(medianOf),
+      sliceKernelOmitNaN(medianOf)
+    )
+  ]);
   const modeOf = (arr) => {
     const counts = /* @__PURE__ */ new Map();
     for (let i = 0; i < arr.length; i++) {
@@ -29423,7 +29809,9 @@ function registerBasicReductions() {
     }
     return bestVal;
   };
-  register("mode", [makeReduction("mode", sliceKernel(modeOf))]);
+  register("mode", [
+    makeReduction("mode", sliceKernel(modeOf), sliceKernelOmitNaN(modeOf))
+  ]);
 }
 
 // src/numbl-core/builtins/reduction/min-max.ts
@@ -30051,6 +30439,11 @@ function registerSortUnique() {
             dim = idx >= 0 ? idx + 1 : 1;
           }
           const dimIdx = dim - 1;
+          if (!im && !descend && nargout <= 1 && re.length === shape[dimIdx]) {
+            const sorted2 = new FloatXArray(re);
+            sorted2.sort();
+            return RTV.tensor(sorted2, [...shape]);
+          }
           if (dimIdx >= shape.length) {
             const cp = RTV.tensor(
               new FloatXArray(re),
@@ -30265,10 +30658,10 @@ function registerSortUnique() {
 }
 function uniqueByRows(v, nargout, stable) {
   const [rows, cols] = tensorSize2D(v);
-  const rowKey = (r) => {
-    const parts = [];
-    for (let c = 0; c < cols; c++) parts.push(v.data[c * rows + r]);
-    return parts.join(",");
+  const rowKey = cols === 2 ? (r) => v.data[r] + "," + v.data[rows + r] : (r) => {
+    let key = "" + v.data[r];
+    for (let c = 1; c < cols; c++) key += "," + v.data[c * rows + r];
+    return key;
   };
   const rowHasNaN = (r) => {
     for (let c = 0; c < cols; c++) {
@@ -30321,10 +30714,21 @@ function uniqueByRows(v, nargout, stable) {
     1
   ]);
   if (!stable) {
-    const sortedKeyOrder = uniqueRowOrder.map((r) => rowKey(r));
+    const sortedKeyToPos = /* @__PURE__ */ new Map();
+    for (let u = 0; u < nUnique; u++) {
+      sortedKeyToPos.set(rowKey(uniqueRowOrder[u]), u + 1);
+    }
     for (let r = 0; r < rows; r++) {
-      const key = rowKey(r);
-      ic[r] = sortedKeyOrder.indexOf(key) + 1;
+      if (rowHasNaN(r)) {
+        for (let u = 0; u < nUnique; u++) {
+          if (uniqueRowOrder[u] === r) {
+            ic[r] = u + 1;
+            break;
+          }
+        }
+      } else {
+        ic[r] = sortedKeyToPos.get(rowKey(r));
+      }
     }
   }
   const icTensor = RTV.tensor(ic, [rows, 1]);
@@ -32884,51 +33288,61 @@ function registerDet() {
   register("cross", [
     {
       check: (argTypes, nargout) => {
-        if (argTypes.length !== 2 || nargout !== 1) return null;
+        if (argTypes.length !== 2 && argTypes.length !== 3 || nargout !== 1)
+          return null;
         return { outputTypes: [IType.Unknown] };
       },
       apply: (args) => {
-        if (args.length !== 2)
-          throw new RuntimeError("cross requires 2 arguments");
+        if (args.length < 2 || args.length > 3)
+          throw new RuntimeError("cross requires 2 or 3 arguments");
         const a = args[0], b = args[1];
         if (!isRuntimeTensor(a) || !isRuntimeTensor(b))
-          throw new RuntimeError("cross: arguments must be vectors");
-        const aRows = a.shape[0];
-        const aCols = a.shape.length >= 2 ? a.shape[1] : 1;
-        const bRows = b.shape[0];
-        const bCols = b.shape.length >= 2 ? b.shape[1] : 1;
-        const isColVector = aRows === 3 && aCols === 1;
-        const isRowVector = aRows === 1 && aCols === 3;
-        const isMatrix = aRows === 3 && aCols > 1;
-        if (isColVector || isRowVector) {
-          if (a.data.length !== 3 || b.data.length !== 3)
-            throw new RuntimeError("cross: vectors must have 3 elements");
-          const ax = a.data[0], ay = a.data[1], az = a.data[2];
-          const bx = b.data[0], by = b.data[1], bz = b.data[2];
-          const result = new FloatXArray(3);
-          result[0] = ay * bz - az * by;
-          result[1] = az * bx - ax * bz;
-          result[2] = ax * by - ay * bx;
-          return RTV.tensor(result, isColVector ? [3, 1] : [1, 3]);
-        } else if (isMatrix) {
-          if (bRows !== 3 || bCols !== aCols)
-            throw new RuntimeError("cross: matrix dimensions must agree");
-          const cols = aCols;
-          const result = new FloatXArray(3 * cols);
-          for (let c = 0; c < cols; c++) {
-            const off = c * 3;
-            const ax = a.data[off], ay = a.data[off + 1], az = a.data[off + 2];
-            const bx = b.data[off], by = b.data[off + 1], bz = b.data[off + 2];
-            result[off] = ay * bz - az * by;
-            result[off + 1] = az * bx - ax * bz;
-            result[off + 2] = ax * by - ay * bx;
-          }
-          return RTV.tensor(result, [3, cols]);
+          throw new RuntimeError("cross: arguments must be vectors or arrays");
+        const shape = a.shape;
+        if (shape.length !== b.shape.length || shape.some((s, i) => s !== b.shape[i]))
+          throw new RuntimeError("cross: A and B must have the same size");
+        let dim;
+        if (args.length === 3) {
+          dim = toNumber(args[2]);
+          if (!Number.isInteger(dim) || dim < 1)
+            throw new RuntimeError("cross: dim must be a positive integer");
         } else {
+          dim = shape.indexOf(3) + 1;
+          if (dim === 0)
+            throw new RuntimeError(
+              "cross: A and B must have at least one dimension of length 3"
+            );
+        }
+        const dimIdx = dim - 1;
+        if (dimIdx >= shape.length || shape[dimIdx] !== 3)
           throw new RuntimeError(
-            "cross: inputs must be 3-element vectors or 3xN matrices"
+            `cross: size(A,${dim}) and size(B,${dim}) must be 3`
           );
-        }
+        const totalLen = a.data.length;
+        const result = new FloatXArray(totalLen);
+        const strides = new Array(shape.length);
+        strides[0] = 1;
+        for (let d = 1; d < shape.length; d++)
+          strides[d] = strides[d - 1] * shape[d - 1];
+        const dimStride = strides[dimIdx];
+        const outerStride = dimIdx + 1 < shape.length ? strides[dimIdx + 1] : totalLen;
+        const innerSize = dimStride;
+        const numOuter = totalLen / outerStride;
+        for (let outer = 0; outer < numOuter; outer++) {
+          const blockBase = outer * outerStride;
+          for (let inner = 0; inner < innerSize; inner++) {
+            const base = blockBase + inner;
+            const i0 = base;
+            const i1 = base + dimStride;
+            const i2 = base + 2 * dimStride;
+            const ax = a.data[i0], ay = a.data[i1], az = a.data[i2];
+            const bx = b.data[i0], by = b.data[i1], bz = b.data[i2];
+            result[i0] = ay * bz - az * by;
+            result[i1] = az * bx - ax * bz;
+            result[i2] = ax * by - ay * bx;
+          }
+        }
+        return RTV.tensor(result, [...shape]);
       }
     }
   ]);
@@ -37301,56 +37715,61 @@ function not(v) {
   return RTV.logical(false);
 }
 function binop(op, a, b) {
-  const an = asNumber(a);
-  const bn = asNumber(b);
-  if (an !== null && bn !== null) {
+  if (typeof a === "number" && typeof b === "number") {
     switch (op) {
       case "Add" /* Add */:
-        return an + bn;
+        return a + b;
       case "Sub" /* Sub */:
-        return an - bn;
+        return a - b;
       case "Mul" /* Mul */:
-        return an * bn;
+        return a * b;
       case "Div" /* Div */:
-        return an / bn;
+        return a / b;
       case "Pow" /* Pow */: {
-        const r = Math.pow(an, bn);
-        if (isNaN(r) && !isNaN(an) && !isNaN(bn)) break;
+        const r = Math.pow(a, b);
+        if (isNaN(r) && !isNaN(a) && !isNaN(b)) break;
         return r;
       }
       case "ElemMul" /* ElemMul */:
-        return an * bn;
+        return a * b;
       case "ElemDiv" /* ElemDiv */:
-        return an / bn;
+        return a / b;
       case "ElemPow" /* ElemPow */: {
-        const r = Math.pow(an, bn);
-        if (isNaN(r) && !isNaN(an) && !isNaN(bn)) break;
+        const r = Math.pow(a, b);
+        if (isNaN(r) && !isNaN(a) && !isNaN(b)) break;
         return r;
       }
       case "LeftDiv" /* LeftDiv */:
-        return bn / an;
+        return b / a;
       case "ElemLeftDiv" /* ElemLeftDiv */:
-        return bn / an;
+        return b / a;
       case "Equal" /* Equal */:
-        return RTV.logical(an === bn);
+        return RTV.logical(a === b);
       case "NotEqual" /* NotEqual */:
-        return RTV.logical(an !== bn);
+        return RTV.logical(a !== b);
       case "Less" /* Less */:
-        return RTV.logical(an < bn);
+        return RTV.logical(a < b);
       case "LessEqual" /* LessEqual */:
-        return RTV.logical(an <= bn);
+        return RTV.logical(a <= b);
       case "Greater" /* Greater */:
-        return RTV.logical(an > bn);
+        return RTV.logical(a > b);
       case "GreaterEqual" /* GreaterEqual */:
-        return RTV.logical(an >= bn);
+        return RTV.logical(a >= b);
       case "BitAnd" /* BitAnd */:
-        return RTV.logical(an !== 0 && bn !== 0);
+        return RTV.logical(a !== 0 && b !== 0);
       case "BitOr" /* BitOr */:
-        return RTV.logical(an !== 0 || bn !== 0);
+        return RTV.logical(a !== 0 || b !== 0);
+    }
+  }
+  if (typeof a !== "object" || typeof b !== "object") {
+    const an = asNumber(a);
+    const bn = asNumber(b);
+    if (an !== null && bn !== null) {
+      return binop(op, an, bn);
     }
   }
-  const ma = ensureRuntimeValue(a);
-  const mb = ensureRuntimeValue(b);
+  const ma = typeof a === "object" && a !== null && "kind" in a ? a : ensureRuntimeValue(a);
+  const mb = typeof b === "object" && b !== null && "kind" in b ? b : ensureRuntimeValue(b);
   let result;
   switch (op) {
     case "Add" /* Add */:
@@ -37794,13 +38213,6 @@ function callBuiltin(rt, name, nargout, args) {
   if (builtin) return builtin(nargout, args);
   throw new RuntimeError(`'${name}' is not a builtin function`);
 }
-function callBuiltinSync(rt, name, nargout, args) {
-  const plotResult = dispatchPlotCall(rt, name, args);
-  if (plotResult !== void 0) return plotResult;
-  const builtin = rt.builtins[name];
-  if (builtin) return builtin(nargout, args);
-  throw new RuntimeError(`'${name}' is not a builtin function`);
-}
 function callClassMethod(rt, className, methodName, nargout, args) {
   return dispatch(rt, methodName, nargout, args, className);
 }
@@ -38087,6 +38499,22 @@ function structfunImpl(rt, _nargout, args) {
     return RTV.struct(fields);
   }
 }
+var bsxfunOpMap = {
+  plus: mAdd,
+  minus: mSub,
+  times: mElemMul,
+  rdivide: mElemDiv
+};
+function resolveKnownBsxfunOp(fnArg) {
+  if (typeof fnArg === "function") {
+    return void 0;
+  }
+  const mv = ensureRuntimeValue(fnArg);
+  if (isRuntimeFunction(mv) && mv.impl === "builtin") {
+    return bsxfunOpMap[mv.name];
+  }
+  return void 0;
+}
 function bsxfunImpl(rt, _nargout, args) {
   if (args.length !== 3)
     throw new RuntimeError("bsxfun requires exactly 3 arguments");
@@ -38104,6 +38532,10 @@ function bsxfunImpl(rt, _nargout, args) {
       );
     }
   }
+  const knownOp = resolveKnownBsxfunOp(fnArg);
+  if (knownOp) {
+    return knownOp(ensureRuntimeValue(args[1]), ensureRuntimeValue(args[2]));
+  }
   const rawA = ensureRuntimeValue(args[1]);
   const rawB = ensureRuntimeValue(args[2]);
   const a = coerceToTensor2(rawA, "bsxfun", "first");
@@ -38367,6 +38799,67 @@ function endResolver(mv, numIndices) {
   };
 }
 function index(rt, base, indices, nargout = 1, skipSubsref = false) {
+  if (typeof base === "object" && base !== null && base.kind === "tensor") {
+    const t = base;
+    const nIdx = indices.length;
+    if (nIdx === 1) {
+      const idx = indices[0];
+      if (typeof idx === "number") {
+        const i = Math.round(idx) - 1;
+        if (i < 0 || i >= t.data.length)
+          throw new RuntimeError("Index exceeds array bounds");
+        if (t.imag !== void 0) {
+          const im = t.imag[i];
+          return im === 0 ? t.data[i] : RTV.complex(t.data[i], im);
+        }
+        return t.data[i];
+      }
+    } else if (nIdx === 2) {
+      const ri = indices[0];
+      const ci = indices[1];
+      if (typeof ri === "number" && typeof ci === "number") {
+        const s = t.shape;
+        const rows = s.length === 0 ? 1 : s.length === 1 ? 1 : s[0];
+        const cols = s.length === 0 ? 1 : s.length === 1 ? s[0] : s[1];
+        const r = Math.round(ri) - 1;
+        const c = Math.round(ci) - 1;
+        if (r < 0 || r >= rows || c < 0 || c >= cols)
+          throw new RuntimeError("Index exceeds array bounds");
+        const lin = c * rows + r;
+        if (t.imag !== void 0) {
+          const im = t.imag[lin];
+          return im === 0 ? t.data[lin] : RTV.complex(t.data[lin], im);
+        }
+        return t.data[lin];
+      }
+    } else if (nIdx >= 3) {
+      let allNumeric = true;
+      for (let k = 0; k < nIdx; k++) {
+        if (typeof indices[k] !== "number") {
+          allNumeric = false;
+          break;
+        }
+      }
+      if (allNumeric) {
+        const s = t.shape;
+        let lin = 0;
+        let stride = 1;
+        for (let k = 0; k < nIdx; k++) {
+          const dimSize = k < s.length ? s[k] : 1;
+          const sub = Math.round(indices[k]) - 1;
+          if (sub < 0 || sub >= dimSize)
+            throw new RuntimeError("Index exceeds array bounds");
+          lin += sub * stride;
+          stride *= dimSize;
+        }
+        if (t.imag !== void 0) {
+          const im = t.imag[lin];
+          return im === 0 ? t.data[lin] : RTV.complex(t.data[lin], im);
+        }
+        return t.data[lin];
+      }
+    }
+  }
   if (typeof base === "function") {
     return base(...indices);
   }
@@ -38451,6 +38944,13 @@ function resolveIndicesForClassInstance(rt, mv, base, indices) {
   });
 }
 function indexCell(rt, base, indices) {
+  if (indices.length === 1 && typeof indices[0] === "number" && typeof base === "object" && base !== null && base.kind === "cell") {
+    const cell = base;
+    const i = Math.round(indices[0]) - 1;
+    if (i < 0 || i >= cell.data.length)
+      throw new RuntimeError("Cell index exceeds bounds");
+    return cell.data[i];
+  }
   const mv = ensureRuntimeValue(base);
   if (isRuntimeClassInstance(mv)) {
     const subsrefFn = rt.cachedResolveClassMethod(mv.className, "subsref");
@@ -38589,7 +39089,7 @@ function indexStore(rt, base, indices, rhs, skipSubsasgn = false) {
   if (isRuntimeCell(mv)) {
     const idxMvals2 = resolveIndices(indices, endResolver(mv, indices.length));
     const rhsMv2 = ensureRuntimeValue(rhs);
-    return storeIntoRTValueIndex(mv, idxMvals2, rhsMv2);
+    return storeIntoRTValueIndex(mv, idxMvals2, rhsMv2, true);
   }
   if (isRuntimeStruct(mv)) {
     return ensureRuntimeValue(rhs);
@@ -38802,7 +39302,7 @@ function registerSpecialBuiltins(rt) {
     if (fn) {
       return fn(nargout, args.slice(1));
     }
-    return rt.callBuiltinSync(fnName, nargout, args.slice(1));
+    return rt.callBuiltin(fnName, nargout, args.slice(1));
   };
   const requireFileIO = () => {
     if (!rt.fileIO)
@@ -40148,15 +40648,23 @@ var Runtime = class _Runtime {
   // ── Builtin initialization ──────────────────────────────────────────
   initBuiltins() {
     for (const name of getAllBuiltinNames()) {
+      const builtin = getBuiltin(name);
+      const singleBranch = builtin.length === 1 ? builtin[0] : null;
       this.builtins[name] = (nargout, args) => {
-        const builtin = getBuiltin(name);
         const margs = args.map((a) => ensureRuntimeValue(a));
-        const argItemTypes = margs.map((arg) => getItemTypeFromRuntimeValue(arg));
-        let branch = builtin[0];
-        for (let i = 0; i < builtin.length; i++) {
-          if (builtin[i].check(argItemTypes, nargout)) {
-            branch = builtin[i];
-            break;
+        let branch;
+        if (singleBranch) {
+          branch = singleBranch;
+        } else {
+          const argItemTypes = margs.map(
+            (arg) => getItemTypeFromRuntimeValue(arg)
+          );
+          branch = builtin[0];
+          for (let i = 0; i < builtin.length; i++) {
+            if (builtin[i].check(argItemTypes, nargout)) {
+              branch = builtin[i];
+              break;
+            }
           }
         }
         if (this.profilingEnabled) {
@@ -40788,9 +41296,6 @@ var Runtime = class _Runtime {
     }
     return binop(op, a, b);
   }
-  binopSync(op, a, b) {
-    return binop(op, a, b);
-  }
   range(start, step, end) {
     return range(start, step, end);
   }
@@ -40910,9 +41415,6 @@ var Runtime = class _Runtime {
   callBuiltin(name, nargout, args) {
     return callBuiltin(this, name, nargout, args);
   }
-  callBuiltinSync(name, nargout, args) {
-    return callBuiltinSync(this, name, nargout, args);
-  }
   callClassMethod(className, methodName, nargout, args) {
     return callClassMethod(this, className, methodName, nargout, args);
   }
@@ -44052,9 +44554,6 @@ function genBinary(cg, kind) {
         break;
     }
   }
-  if (leftType.kind !== "Unknown" && rightType.kind !== "Unknown" && leftType.kind !== "ClassInstance" && rightType.kind !== "ClassInstance") {
-    return `$rt.binopSync(${JSON.stringify(kind.op)}, ${left}, ${right})`;
-  }
   return `$rt.binop(${JSON.stringify(kind.op)}, ${left}, ${right})`;
 }
 function genTensor(cg, kind) {
@@ -44579,8 +45078,6 @@ function genClassInstantiation(cg, kind) {
   return createExpr;
 }
 var NATIVE_MATH_1 = {
-  // Note: sqrt, asin, acos, log are NOT here because they can produce
-  // complex results from real inputs (e.g., sqrt(-1) = 1i).
   abs: "Math.abs",
   floor: "Math.floor",
   ceil: "Math.ceil",
@@ -44594,6 +45091,14 @@ var NATIVE_MATH_1 = {
   log10: "Math.log10",
   sign: "Math.sign"
 };
+var GUARDED_MATH_1 = {
+  sqrt: { fn: "Math.sqrt", guard: "$x >= 0" },
+  log: { fn: "Math.log", guard: "$x > 0" },
+  asin: { fn: "Math.asin", guard: "$x >= -1 && $x <= 1" },
+  acos: { fn: "Math.acos", guard: "$x >= -1 && $x <= 1" },
+  acosh: { fn: "Math.acosh", guard: "$x >= 1" },
+  atanh: { fn: "Math.atanh", guard: "$x > -1 && $x < 1" }
+};
 var NATIVE_MATH_2 = {
   // Note: max/min are NOT here because Math.max/Math.min propagate NaN,
   // but max/min ignore NaN (returning the non-NaN value).
@@ -44605,6 +45110,15 @@ function tryNativeMathCodegen(cg, name, nargout, irArgs, jsArgs) {
   if (jsArgs.length === 1 && itemTypeForExprKind(irArgs[0].kind, cg.typeEnv).kind === "Number") {
     const fn = NATIVE_MATH_1[name];
     if (fn) return `${fn}(${jsArgs[0]})`;
+    const guarded = GUARDED_MATH_1[name];
+    if (guarded) {
+      const arg = jsArgs[0];
+      const tmp = cg.freshTemp("$gm");
+      cg.emit(`var ${tmp};`);
+      const guard = guarded.guard.replace(/\$x/g, tmp);
+      const fallback = `${cg.useBuiltin(name)}(1, [${tmp}])`;
+      return `(${tmp} = ${arg}, ${guard} ? ${guarded.fn}(${tmp}) : ${fallback})`;
+    }
   }
   if (jsArgs.length === 2 && itemTypeForExprKind(irArgs[0].kind, cg.typeEnv).kind === "Number" && itemTypeForExprKind(irArgs[1].kind, cg.typeEnv).kind === "Number") {
     const fn = NATIVE_MATH_2[name];
@@ -46318,6 +46832,21 @@ function instantiateWasm(wasmData) {
   }
   return new WebAssembly.Instance(wasmModule, importObject);
 }
+function resolveBindings(file, directives, getWasmInstance, nativeBridge2) {
+  const wasmInstance = directives.wasm ? getWasmInstance(directives.wasm) : void 0;
+  let nativeLib;
+  if (directives.native && nativeBridge2) {
+    const libFile = nativeLibFilename(directives.native);
+    const dir = file.name.substring(0, file.name.lastIndexOf("/") + 1);
+    const libPath = dir + libFile;
+    try {
+      nativeLib = nativeBridge2.load(libPath);
+    } catch {
+    }
+  }
+  return { wasmInstance, nativeLib };
+}
+var LOADING = /* @__PURE__ */ Symbol("loading");
 function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge2) {
   const result = /* @__PURE__ */ new Map();
   const wasmMap = wasmFiles ? buildWasmMap(wasmFiles) : /* @__PURE__ */ new Map();
@@ -46331,7 +46860,68 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge2) {
     wasmInstanceCache.set(name, instance);
     return instance;
   }
+  const libraryFiles = /* @__PURE__ */ new Map();
+  const functionFiles = [];
   for (const file of jsFiles) {
+    const base = file.name.split("/").pop();
+    if (base.startsWith("_")) {
+      const libName = base.replace(/\.js$/, "");
+      libraryFiles.set(libName, file);
+    } else {
+      functionFiles.push(file);
+    }
+  }
+  const libCache = /* @__PURE__ */ new Map();
+  function importJS(name) {
+    const cached = libCache.get(name);
+    if (cached === LOADING) {
+      throw new RuntimeError(`Circular dependency detected: ${name}.js`);
+    }
+    if (libCache.has(name)) return cached;
+    const libFile = libraryFiles.get(name);
+    if (!libFile) {
+      throw new RuntimeError(
+        `importJS: library '${name}.js' not found in workspace`
+      );
+    }
+    libCache.set(name, LOADING);
+    const directives = parseDirectives(libFile.source);
+    const { wasmInstance, nativeLib } = resolveBindings(
+      libFile,
+      directives,
+      getWasmInstance,
+      nativeBridge2
+    );
+    const dummyRegister = () => {
+      throw new RuntimeError(
+        `Library file '${name}.js' must not call register(). Use return {...} to export values.`
+      );
+    };
+    const factory = new Function(
+      "RTV",
+      "RuntimeError",
+      "FloatXArray",
+      "IType",
+      "register",
+      "wasm",
+      "native",
+      "importJS",
+      libFile.source
+    );
+    const exports = factory(
+      RTV,
+      RuntimeError,
+      FloatXArray,
+      IType,
+      dummyRegister,
+      wasmInstance,
+      nativeLib,
+      importJS
+    );
+    libCache.set(name, exports);
+    return exports;
+  }
+  for (const file of functionFiles) {
     const funcName = funcNameFromFile(file.name);
     try {
       const branches = [];
@@ -46345,17 +46935,12 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge2) {
         });
       };
       const directives = parseDirectives(file.source);
-      const wasmInstance = directives.wasm ? getWasmInstance(directives.wasm) : void 0;
-      let nativeLib;
-      if (directives.native && nativeBridge2) {
-        const libFile = nativeLibFilename(directives.native);
-        const dir = file.name.substring(0, file.name.lastIndexOf("/") + 1);
-        const libPath = dir + libFile;
-        try {
-          nativeLib = nativeBridge2.load(libPath);
-        } catch {
-        }
-      }
+      const { wasmInstance, nativeLib } = resolveBindings(
+        file,
+        directives,
+        getWasmInstance,
+        nativeBridge2
+      );
       const factory = new Function(
         "RTV",
         "RuntimeError",
@@ -46364,6 +46949,7 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge2) {
         "register",
         "wasm",
         "native",
+        "importJS",
         file.source
       );
       factory(
@@ -46373,7 +46959,8 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge2) {
         IType,
         registerFn,
         wasmInstance,
-        nativeLib
+        nativeLib,
+        importJS
       );
       if (branches.length === 0) {
         throw new Error(
@@ -47189,7 +47776,7 @@ Call stack (most recent call first):`;
 }
 
 // src/numbl-core/version.ts
-var NUMBL_VERSION = "0.0.21";
+var NUMBL_VERSION = "0.0.23";
 
 // src/cli-repl.ts
 import { createInterface } from "readline";
@@ -47820,16 +48407,26 @@ var NodeFileIOAdapter = class {
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname = dirname3(__filename);
 var packageDir2 = join6(__dirname, "..");
-var addonPath = join6(packageDir2, "build", "Release", "lapack_addon.node");
+var addonPath = join6(packageDir2, "build", "Release", "numbl_addon.node");
 var nativeAddonLoaded = false;
 if (!process.env.NUMBL_NO_NATIVE) {
   try {
     const req = createRequire(import.meta.url);
     const addon = req(addonPath);
-    setLapackBridge(addon);
-    setLapackBridge(addon);
-    nativeAddonLoaded = true;
+    const addonVer = typeof addon.addonVersion === "function" ? addon.addonVersion() : 0;
+    if (addonVer !== NATIVE_ADDON_EXPECTED_VERSION) {
+      console.error(
+        `Warning: native addon version mismatch (got ${addonVer}, expected ${NATIVE_ADDON_EXPECTED_VERSION}). Run "npx numbl build-addon" to rebuild. Using JS fallbacks.`
+      );
+    } else {
+      setLapackBridge(addon);
+      setLapackBridge(addon);
+      nativeAddonLoaded = true;
+    }
   } catch {
+    console.error(
+      `Warning: native addon not found. Run "npx numbl build-addon" to build it. Using JS fallbacks.`
+    );
   }
 }
 var nativeBridge;