numbl 0.1.2 → 0.1.4

package/dist-cli/cli.js

@@ -195,6 +195,179 @@ var kstr = (value) => {
   return "unknown";
 };
 
+// src/numbl-core/native/lapack-bridge.ts
+var NATIVE_ADDON_EXPECTED_VERSION = 1;
+var _bridge = null;
+function setLapackBridge(bridge) {
+  _bridge = bridge;
+}
+function getLapackBridge() {
+  return _bridge;
+}
+
+// src/numbl-core/runtime/constructors.ts
+var RTV = {
+  num(value) {
+    return value;
+  },
+  tensor(data, shape, imag) {
+    const d = data instanceof FloatXArray ? data : new FloatXArray(data);
+    const im2 = imag ? imag instanceof FloatXArray ? imag : new FloatXArray(imag) : void 0;
+    const s = [...shape];
+    while (s.length > 2 && s[s.length - 1] === 1) s.pop();
+    return { kind: "tensor", data: d, imag: im2, 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;
+  },
+  /** Create a row vector [1 x n] */
+  row(data, imag) {
+    const im2 = imag ? new FloatXArray(imag) : void 0;
+    return {
+      kind: "tensor",
+      data: new FloatXArray(data),
+      imag: im2,
+      shape: [1, data.length],
+      _rc: 1
+    };
+  },
+  /** Create a column vector [n x 1] */
+  col(data, imag) {
+    const im2 = imag ? new FloatXArray(imag) : void 0;
+    return {
+      kind: "tensor",
+      data: new FloatXArray(data),
+      imag: im2,
+      shape: [data.length, 1],
+      _rc: 1
+    };
+  },
+  /** Create a matrix from row-major data */
+  matrix(rows, cols, data, imag) {
+    const d = data instanceof FloatXArray ? data : new FloatXArray(data);
+    const im2 = imag ? imag instanceof FloatXArray ? imag : new FloatXArray(imag) : void 0;
+    return { kind: "tensor", data: d, imag: im2, shape: [rows, cols], _rc: 1 };
+  },
+  string(value) {
+    return value;
+  },
+  char(value) {
+    return { kind: "char", value };
+  },
+  logical(value) {
+    return value;
+  },
+  cell(data, shape) {
+    return { kind: "cell", data, shape: [...shape], _rc: 1 };
+  },
+  struct(fields) {
+    const map = fields instanceof Map ? fields : new Map(Object.entries(fields));
+    return { kind: "struct", fields: map };
+  },
+  func(name, impl, captures = []) {
+    return { kind: "function", name, impl, captures };
+  },
+  classInstance(className, propertyNames, isHandleClass2 = false, defaults) {
+    const fields = /* @__PURE__ */ new Map();
+    for (const name of propertyNames) {
+      fields.set(
+        name,
+        defaults?.get(name) ?? RTV.tensor(new FloatXArray(0), [0, 0])
+      );
+    }
+    return {
+      kind: "class_instance",
+      className,
+      fields,
+      isHandleClass: isHandleClass2
+    };
+  },
+  complex(re2, im2) {
+    return { kind: "complex_number", re: re2, im: im2 };
+  },
+  dummyHandle() {
+    return { kind: "dummy_handle" };
+  },
+  structArray(fieldNames, elements) {
+    return { kind: "struct_array", fieldNames, elements };
+  },
+  sparseMatrix(m, n, ir, jc, pr, pi) {
+    return { kind: "sparse_matrix", m, n, ir, jc, pr, pi, _rc: 1 };
+  },
+  dictionary(entries, keyType, valueType) {
+    return {
+      kind: "dictionary",
+      entries: entries ?? /* @__PURE__ */ new Map(),
+      keyType,
+      valueType
+    };
+  }
+};
+var getItemTypeFromRuntimeValue = (value) => {
+  if (isRuntimeNumber(value)) {
+    return { kind: "Number" };
+  }
+  if (isRuntimeLogical(value)) {
+    return { kind: "Boolean" };
+  }
+  if (isRuntimeString(value)) {
+    return { kind: "String" };
+  }
+  switch (value.kind) {
+    case "complex_number":
+      return { kind: "ComplexNumber" };
+    case "char":
+      return { kind: "Char" };
+    case "tensor":
+      return {
+        kind: "Tensor",
+        isComplex: value.imag !== void 0,
+        isLogical: value._isLogical || void 0
+      };
+    case "cell":
+      return {
+        kind: "Cell",
+        elementType: value.data.length > 0 ? getItemTypeFromRuntimeValue(value.data[0]) : { kind: "Unknown" },
+        // length: value.shape.reduce((a, b) => a * b, 1),
+        length: "unknown"
+        // do not include length or we get too many jits
+      };
+    case "struct": {
+      const knownFields = {};
+      for (const [k, v] of value.fields) {
+        knownFields[k] = getItemTypeFromRuntimeValue(v);
+      }
+      return { kind: "Struct", knownFields };
+    }
+    case "function":
+      return {
+        kind: "Function",
+        params: [],
+        returns: { kind: "Unknown" }
+      };
+    case "class_instance":
+      return {
+        kind: "ClassInstance",
+        className: value.className
+      };
+    case "dummy_handle":
+      return { kind: "DummyHandle" };
+    case "struct_array":
+      return { kind: "Unknown" };
+    case "sparse_matrix":
+      return { kind: "SparseMatrix", isComplex: value.pi !== void 0 };
+    case "dictionary":
+      return { kind: "Dictionary" };
+    default:
+      return { kind: "Unknown" };
+  }
+};
+
 // src/numbl-core/interpreter/jit/jitTypes.ts
 function signFromNumber(v) {
   if (v > 0) return "positive";
@@ -637,169 +810,6 @@ function extractSnippet(source, offset, contextLines = 2) {
   return snippetLines.join("\n");
 }
 
-// src/numbl-core/runtime/constructors.ts
-var RTV = {
-  num(value) {
-    return value;
-  },
-  tensor(data, shape, imag) {
-    const d = data instanceof FloatXArray ? data : new FloatXArray(data);
-    const im2 = imag ? imag instanceof FloatXArray ? imag : new FloatXArray(imag) : void 0;
-    const s = [...shape];
-    while (s.length > 2 && s[s.length - 1] === 1) s.pop();
-    return { kind: "tensor", data: d, imag: im2, 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;
-  },
-  /** Create a row vector [1 x n] */
-  row(data, imag) {
-    const im2 = imag ? new FloatXArray(imag) : void 0;
-    return {
-      kind: "tensor",
-      data: new FloatXArray(data),
-      imag: im2,
-      shape: [1, data.length],
-      _rc: 1
-    };
-  },
-  /** Create a column vector [n x 1] */
-  col(data, imag) {
-    const im2 = imag ? new FloatXArray(imag) : void 0;
-    return {
-      kind: "tensor",
-      data: new FloatXArray(data),
-      imag: im2,
-      shape: [data.length, 1],
-      _rc: 1
-    };
-  },
-  /** Create a matrix from row-major data */
-  matrix(rows, cols, data, imag) {
-    const d = data instanceof FloatXArray ? data : new FloatXArray(data);
-    const im2 = imag ? imag instanceof FloatXArray ? imag : new FloatXArray(imag) : void 0;
-    return { kind: "tensor", data: d, imag: im2, shape: [rows, cols], _rc: 1 };
-  },
-  string(value) {
-    return value;
-  },
-  char(value) {
-    return { kind: "char", value };
-  },
-  logical(value) {
-    return value;
-  },
-  cell(data, shape) {
-    return { kind: "cell", data, shape: [...shape], _rc: 1 };
-  },
-  struct(fields) {
-    const map = fields instanceof Map ? fields : new Map(Object.entries(fields));
-    return { kind: "struct", fields: map };
-  },
-  func(name, impl, captures = []) {
-    return { kind: "function", name, impl, captures };
-  },
-  classInstance(className, propertyNames, isHandleClass2 = false, defaults) {
-    const fields = /* @__PURE__ */ new Map();
-    for (const name of propertyNames) {
-      fields.set(
-        name,
-        defaults?.get(name) ?? RTV.tensor(new FloatXArray(0), [0, 0])
-      );
-    }
-    return {
-      kind: "class_instance",
-      className,
-      fields,
-      isHandleClass: isHandleClass2
-    };
-  },
-  complex(re2, im2) {
-    return { kind: "complex_number", re: re2, im: im2 };
-  },
-  dummyHandle() {
-    return { kind: "dummy_handle" };
-  },
-  structArray(fieldNames, elements) {
-    return { kind: "struct_array", fieldNames, elements };
-  },
-  sparseMatrix(m, n, ir, jc, pr, pi) {
-    return { kind: "sparse_matrix", m, n, ir, jc, pr, pi, _rc: 1 };
-  },
-  dictionary(entries, keyType, valueType) {
-    return {
-      kind: "dictionary",
-      entries: entries ?? /* @__PURE__ */ new Map(),
-      keyType,
-      valueType
-    };
-  }
-};
-var getItemTypeFromRuntimeValue = (value) => {
-  if (isRuntimeNumber(value)) {
-    return { kind: "Number" };
-  }
-  if (isRuntimeLogical(value)) {
-    return { kind: "Boolean" };
-  }
-  if (isRuntimeString(value)) {
-    return { kind: "String" };
-  }
-  switch (value.kind) {
-    case "complex_number":
-      return { kind: "ComplexNumber" };
-    case "char":
-      return { kind: "Char" };
-    case "tensor":
-      return {
-        kind: "Tensor",
-        isComplex: value.imag !== void 0,
-        isLogical: value._isLogical || void 0
-      };
-    case "cell":
-      return {
-        kind: "Cell",
-        elementType: value.data.length > 0 ? getItemTypeFromRuntimeValue(value.data[0]) : { kind: "Unknown" },
-        // length: value.shape.reduce((a, b) => a * b, 1),
-        length: "unknown"
-        // do not include length or we get too many jits
-      };
-    case "struct": {
-      const knownFields = {};
-      for (const [k, v] of value.fields) {
-        knownFields[k] = getItemTypeFromRuntimeValue(v);
-      }
-      return { kind: "Struct", knownFields };
-    }
-    case "function":
-      return {
-        kind: "Function",
-        params: [],
-        returns: { kind: "Unknown" }
-      };
-    case "class_instance":
-      return {
-        kind: "ClassInstance",
-        className: value.className
-      };
-    case "dummy_handle":
-      return { kind: "DummyHandle" };
-    case "struct_array":
-      return { kind: "Unknown" };
-    case "sparse_matrix":
-      return { kind: "SparseMatrix", isComplex: value.pi !== void 0 };
-    case "dictionary":
-      return { kind: "Dictionary" };
-    default:
-      return { kind: "Unknown" };
-  }
-};
-
 // src/numbl-core/runtime/utils.ts
 function tensorSize2D(t) {
   const s = t.shape;
@@ -1718,6 +1728,28 @@ function binaryNumberOnly(argTypes) {
     return null;
   return [{ kind: "number" }];
 }
+var nativeUnaryOpCode = /* @__PURE__ */ new Map([
+  [Math.exp, 0],
+  [Math.log, 1],
+  [Math.log2, 2],
+  [Math.log10, 3],
+  [Math.sqrt, 4],
+  [Math.abs, 5],
+  [Math.floor, 6],
+  [Math.ceil, 7],
+  [Math.round, 8],
+  [Math.trunc, 9],
+  [Math.sin, 10],
+  [Math.cos, 11],
+  [Math.tan, 12],
+  [Math.asin, 13],
+  [Math.acos, 14],
+  [Math.atan, 15],
+  [Math.sinh, 16],
+  [Math.cosh, 17],
+  [Math.tanh, 18],
+  [Math.sign, 19]
+]);
 function applyUnaryElemwise(v, realFn, complexFn, name) {
   if (isRuntimeSparseMatrix(v))
     return applyUnaryElemwise(sparseToDense(v), realFn, complexFn, name);
@@ -1730,6 +1762,14 @@ function applyUnaryElemwise(v, realFn, complexFn, name) {
   if (isRuntimeTensor(v)) {
     const n = v.data.length;
     if (!v.imag) {
+      const opCode = nativeUnaryOpCode.get(realFn);
+      if (opCode !== void 0) {
+        const bridge = getLapackBridge();
+        if (bridge?.unaryElemwise && v.data instanceof Float64Array) {
+          const result = bridge.unaryElemwise(v.data, opCode);
+          return RTV.tensorRaw(result, v.shape.slice());
+        }
+      }
       const out = new FloatXArray(n);
       for (let i = 0; i < n; i++) out[i] = realFn(v.data[i]);
       return makeTensor(out, void 0, v.shape.slice());
@@ -3618,16 +3658,6 @@ function toString(v) {
   }
 }
 
-// src/numbl-core/native/lapack-bridge.ts
-var NATIVE_ADDON_EXPECTED_VERSION = 1;
-var _bridge = null;
-function setLapackBridge(bridge) {
-  _bridge = bridge;
-}
-function getLapackBridge() {
-  return _bridge;
-}
-
 // src/ts-lapack/src/utils/xerbla.ts
 function xerbla(srname, info) {
   throw new Error(
@@ -20268,6 +20298,7 @@ function extractTensorElement(base, i) {
     const im2 = base.imag[i];
     return im2 === 0 ? RTV.num(base.data[i]) : RTV.complex(base.data[i], im2);
   }
+  if (base._isLogical === true) return base.data[i] !== 0;
   return RTV.num(base.data[i]);
 }
 function resolveIndex(idx, dimSize, boundsLimit = dimSize) {
@@ -20321,17 +20352,35 @@ function growTensor2D(base, newRows, newCols) {
 }
 function assignSlice(base, rowIndices, colIndices, rhs, curRows) {
   if (isRuntimeTensor(rhs)) {
+    const nR = rowIndices.length;
+    const nC = colIndices.length;
     const [rhsRows, rhsCols] = tensorSize2D(rhs);
-    if (rhsRows !== rowIndices.length || rhsCols !== colIndices.length) {
+    const shapeMatches = rhsRows === nR && rhsCols === nC;
+    const sliceIsVector = nR === 1 || nC === 1;
+    const rhsIsVector = rhsRows === 1 || rhsCols === 1;
+    const countMatches = rhs.data.length === nR * nC;
+    if (!shapeMatches && !(sliceIsVector && rhsIsVector && countMatches)) {
       throw new RuntimeError("Subscripted assignment dimension mismatch");
     }
     if (rhs.imag || base.imag) ensureImag(base);
-    for (let ri = 0; ri < rowIndices.length; ri++) {
-      for (let ci = 0; ci < colIndices.length; ci++) {
-        const dstLi = colMajorIndex(rowIndices[ri], colIndices[ci], curRows);
-        const srcLi = colMajorIndex(ri, ci, rhsRows);
-        base.data[dstLi] = rhs.data[srcLi];
-        if (base.imag) base.imag[dstLi] = rhs.imag ? rhs.imag[srcLi] : 0;
+    if (shapeMatches) {
+      for (let ri = 0; ri < nR; ri++) {
+        for (let ci = 0; ci < nC; ci++) {
+          const dstLi = colMajorIndex(rowIndices[ri], colIndices[ci], curRows);
+          const srcLi = colMajorIndex(ri, ci, rhsRows);
+          base.data[dstLi] = rhs.data[srcLi];
+          if (base.imag) base.imag[dstLi] = rhs.imag ? rhs.imag[srcLi] : 0;
+        }
+      }
+    } else {
+      let k = 0;
+      for (let ci = 0; ci < nC; ci++) {
+        for (let ri = 0; ri < nR; ri++) {
+          const dstLi = colMajorIndex(rowIndices[ri], colIndices[ci], curRows);
+          base.data[dstLi] = rhs.data[k];
+          if (base.imag) base.imag[dstLi] = rhs.imag ? rhs.imag[k] : 0;
+          k++;
+        }
       }
     }
   } else {
@@ -20668,6 +20717,23 @@ function indexIntoScalar(base, indices) {
       return RTV.tensor(out, [1, count]);
     }
   }
+  if (indices.length === 1 && isRuntimeTensor(indices[0])) {
+    const idx = indices[0];
+    for (let i = 0; i < idx.data.length; i++) {
+      const k = Math.round(idx.data[i]);
+      if (k !== 1) throw new RuntimeError("Index exceeds array bounds");
+    }
+    const n = idx.data.length;
+    const scalarRe = isRuntimeNumber(base) ? base : base.re;
+    const data = new FloatXArray(n);
+    data.fill(scalarRe);
+    if (isRuntimeComplexNumber(base) && base.im !== 0) {
+      const im2 = new FloatXArray(n);
+      im2.fill(base.im);
+      return RTV.tensor(data, [...idx.shape], im2);
+    }
+    return RTV.tensor(data, [...idx.shape]);
+  }
   for (const idx of indices) {
     if (isColonIndex(idx)) continue;
     const i = toNumber(idx);
@@ -20679,6 +20745,22 @@ function indexIntoTensor(base, indices) {
   if (indices.length === 1) {
     return indexIntoTensor1D(base, indices[0]);
   }
+  if (base.shape.length > indices.length) {
+    const collapsedShape = [];
+    for (let d = 0; d < indices.length - 1; d++) {
+      collapsedShape.push(base.shape[d]);
+    }
+    let tail = 1;
+    for (let d = indices.length - 1; d < base.shape.length; d++) {
+      tail *= base.shape[d];
+    }
+    collapsedShape.push(tail);
+    const view = { ...base, shape: collapsedShape };
+    if (indices.length === 2) {
+      return indexIntoTensor2D(view, indices[0], indices[1]);
+    }
+    return indexIntoTensorND(view, indices);
+  }
   if (indices.length === 2) {
     return indexIntoTensor2D(base, indices[0], indices[1]);
   }
@@ -20707,6 +20789,11 @@ function indexIntoTensor1D(base, idx) {
 }
 function indexIntoTensor2D(base, rowIdx, colIdx) {
   const [rows, cols] = tensorSize2D(base);
+  const baseLogical = base._isLogical === true;
+  const markLogical = (t) => {
+    if (baseLogical && isRuntimeTensor(t)) t._isLogical = true;
+    return t;
+  };
   if (isRuntimeNumber(rowIdx) && isColonIndex(colIdx)) {
     const r = Math.round(rowIdx) - 1;
     if (r < 0 || r >= rows)
@@ -20717,7 +20804,7 @@ function indexIntoTensor2D(base, rowIdx, colIdx) {
       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);
+    return markLogical(RTV.tensor(resultData2, [1, cols], resultImag2));
   }
   if (isColonIndex(rowIdx) && isRuntimeNumber(colIdx)) {
     const c = Math.round(colIdx) - 1;
@@ -20729,7 +20816,7 @@ function indexIntoTensor2D(base, rowIdx, colIdx) {
     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);
+    return markLogical(RTV.tensor(resultData2, [rows, 1], resultImag2));
   }
   const rowIdxArr = resolveIndex(rowIdx, rows);
   const colIdxArr = resolveIndex(colIdx, cols);
@@ -20751,7 +20838,7 @@ function indexIntoTensor2D(base, rowIdx, colIdx) {
       }
     }
   }
-  return RTV.tensor(resultData, [numR, numC], resultImag);
+  return markLogical(RTV.tensor(resultData, [numR, numC], resultImag));
 }
 function indexIntoTensorND(base, indices) {
   const shape = base.shape;
@@ -20799,7 +20886,13 @@ function indexIntoTensorND(base, indices) {
       subs[d] = 0;
     }
   }
-  return RTV.tensor(resultData, resultShape, resultImag);
+  const result = RTV.tensor(
+    resultData,
+    resultShape,
+    resultImag
+  );
+  if (base._isLogical === true) result._isLogical = true;
+  return result;
 }
 function indexIntoCell(base, indices) {
   if (indices.length === 1) {
@@ -20964,6 +21057,7 @@ function indexIntoLogical(base, indices) {
   return base;
 }
 function indexIntoTensorWithTensor(base, idx) {
+  const baseLogical = base._isLogical === true;
   if (idx._isLogical) {
     const selected = [];
     const selectedIm = [];
@@ -20977,12 +21071,19 @@ function indexIntoTensorWithTensor(base, idx) {
     if (selected.length === 1) {
       if (hasImag2 && selectedIm[0] !== 0)
         return RTV.complex(selected[0], selectedIm[0]);
+      if (baseLogical) return selected[0] !== 0;
       return RTV.num(selected[0]);
     }
     const imOut2 = hasImag2 && selectedIm.some((x) => x !== 0) ? new FloatXArray(selectedIm) : void 0;
     const isRow = base.shape.length === 2 && base.shape[0] === 1;
     const outShape2 = isRow ? [1, selected.length] : [selected.length, 1];
-    return RTV.tensor(new FloatXArray(selected), outShape2, imOut2);
+    const result2 = RTV.tensor(
+      new FloatXArray(selected),
+      outShape2,
+      imOut2
+    );
+    if (baseLogical) result2._isLogical = true;
+    return result2;
   }
   const resultData = [];
   const hasImag = base.imag !== void 0;
@@ -20998,7 +21099,13 @@ function indexIntoTensorWithTensor(base, idx) {
   const baseIsVector = base.shape.length <= 2 && (base.shape[0] === 1 || base.shape[1] === 1 || base.shape.length === 1);
   const outShape = idxIs0x0 ? [0, 0] : baseIsVector ? base.shape[0] === 1 ? [1, resultData.length] : [resultData.length, 1] : idx.shape;
   const imOut = hasImag && imIndices.some((x) => x !== 0) ? new FloatXArray(imIndices) : void 0;
-  return RTV.tensor(new FloatXArray(resultData), outShape, imOut);
+  const result = RTV.tensor(
+    new FloatXArray(resultData),
+    outShape,
+    imOut
+  );
+  if (baseLogical) result._isLogical = true;
+  return result;
 }
 function indexIntoRTValue(base, indices) {
   if (isRuntimeNumber(base) || isRuntimeComplexNumber(base)) {
@@ -21348,10 +21455,18 @@ function storeIntoTensor2D(base, indices, rhs) {
     return storeIntoTensorColonCol(base, indices[0], rhs, rows, cols);
   }
   if (rowIsTensor || colIsTensor) {
-    const rowIndices = resolveIndex(indices[0], rows, 0);
-    const colIndices = resolveIndex(indices[1], cols, 0);
-    const maxRow = rowIndices.length > 0 ? Math.max(...rowIndices) + 1 : rows;
-    const maxCol = colIndices.length > 0 ? Math.max(...colIndices) + 1 : cols;
+    const isEmpty = base.data.length === 0;
+    let effectiveCols = cols;
+    let effectiveRows = rows;
+    if (isEmpty && isRuntimeTensor(rhs)) {
+      const [rhsRowsG, rhsColsG] = tensorSize2D(rhs);
+      if (rowIsColon && !colIsColon) effectiveRows = rhsRowsG;
+      if (colIsColon && !rowIsColon) effectiveCols = rhsColsG;
+    }
+    const rowIndices = rowIsColon ? Array.from({ length: effectiveRows }, (_, i) => i) : resolveIndex(indices[0], rows, 0);
+    const colIndices = colIsColon ? Array.from({ length: effectiveCols }, (_, i) => i) : resolveIndex(indices[1], cols, 0);
+    const maxRow = rowIndices.length > 0 ? Math.max(...rowIndices) + 1 : effectiveRows;
+    const maxCol = colIndices.length > 0 ? Math.max(...colIndices) + 1 : effectiveCols;
     base = growTensor2D(base, maxRow, maxCol);
     const [curRows] = tensorSize2D(base);
     assignSlice(base, rowIndices, colIndices, rhs, curRows);
@@ -21779,6 +21894,9 @@ function horzcat(...values) {
   if (values.some((v) => isRuntimeCell(v))) {
     return cellCatAlongDim(values, 1);
   }
+  if (values.some((v) => isRuntimeStruct(v) || isRuntimeStructArray(v))) {
+    return structCat(values);
+  }
   return catAlongDim(values, 1);
 }
 function vertcat(...values) {
@@ -21790,8 +21908,47 @@ function vertcat(...values) {
   if (values.some((v) => isRuntimeCell(v))) {
     return cellCatAlongDim(values, 0);
   }
+  if (values.some((v) => isRuntimeStruct(v) || isRuntimeStructArray(v))) {
+    return structCat(values);
+  }
   return catAlongDim(values, 0);
 }
+function structCat(values) {
+  const elements = [];
+  let fieldNames = null;
+  for (const v of values) {
+    if (isRuntimeStruct(v)) {
+      const keys = Array.from(v.fields.keys());
+      if (fieldNames === null) fieldNames = keys;
+      else if (!arraysEqual(fieldNames, keys)) {
+        throw new RuntimeError(
+          "Cannot concatenate structs with different field names"
+        );
+      }
+      elements.push(v);
+    } else if (isRuntimeStructArray(v)) {
+      if (fieldNames === null) fieldNames = [...v.fieldNames];
+      else if (!arraysEqual(fieldNames, v.fieldNames)) {
+        throw new RuntimeError(
+          "Cannot concatenate struct arrays with different field names"
+        );
+      }
+      for (const e of v.elements) elements.push(e);
+    } else {
+      if (isRuntimeTensor(v) && v.data.length === 0 && v.shape.every((d) => d === 0)) {
+        continue;
+      }
+      throw new RuntimeError(`Cannot concatenate ${kstr(v)} into struct`);
+    }
+  }
+  if (fieldNames === null) fieldNames = [];
+  return RTV.structArray(fieldNames, elements);
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
 function toSparseForCat(v) {
   if (isRuntimeSparseMatrix(v)) return v;
   if (isRuntimeNumber(v)) {
@@ -22286,6 +22443,258 @@ function coerceToTensor(v, name) {
   throw new RuntimeError(`${name}: argument must be numeric`);
 }
 
+// src/numbl-core/helpers/string.ts
+function numStr(n) {
+  if (n === Infinity) return "Inf";
+  if (n === -Infinity) return "-Inf";
+  if (isNaN(n)) return "NaN";
+  if (n === 0) return "0";
+  const prec = 5;
+  const exp = Math.floor(Math.log10(Math.abs(n)));
+  let s;
+  if (exp < -4 || exp >= prec) {
+    s = n.toExponential(prec - 1);
+    const ePos = s.indexOf("e");
+    let mantissa = s.slice(0, ePos);
+    const expPart0 = s.slice(ePos);
+    if (mantissa.includes(".")) mantissa = mantissa.replace(/\.?0+$/, "");
+    const expPart = expPart0.replace(/([eE][+-])(\d)$/, "$10$2");
+    s = mantissa + expPart;
+  } else {
+    if (Number.isInteger(n)) return String(n);
+    s = n.toPrecision(prec);
+    if (s.includes(".")) s = s.replace(/\.?0+$/, "");
+  }
+  return s;
+}
+function num2strScalar(n) {
+  if (n === Infinity) return "Inf";
+  if (n === -Infinity) return "-Inf";
+  if (isNaN(n)) return "NaN";
+  if (n === 0) return "0";
+  if (Number.isInteger(n)) return String(n);
+  const prec = 5;
+  const exp = Math.floor(Math.log10(Math.abs(n)));
+  let s;
+  if (exp < -4 || exp >= prec) {
+    s = n.toExponential(prec - 1);
+    const ePos = s.indexOf("e");
+    let mantissa = s.slice(0, ePos);
+    const expPart0 = s.slice(ePos);
+    if (mantissa.includes(".")) mantissa = mantissa.replace(/\.?0+$/, "");
+    const expPart = expPart0.replace(/([eE][+-])(\d)$/, "$10$2");
+    s = mantissa + expPart;
+  } else {
+    s = n.toPrecision(prec);
+    if (s.includes(".")) s = s.replace(/\.?0+$/, "");
+  }
+  return s;
+}
+function applyWidth(spec, str) {
+  const m = spec.match(/^%([-+ #]*)0?(\d+)?/);
+  if (!m) return str;
+  const explicitFlags = m[1] || "";
+  const leftAlign = explicitFlags.includes("-");
+  const afterPercent = spec.slice(1);
+  const flagAndWidth = afterPercent.match(/^([-+ #]*)(0?)(\d+)?/);
+  const zeroFlag = flagAndWidth ? flagAndWidth[2] === "0" : false;
+  const width = flagAndWidth && flagAndWidth[3] ? parseInt(flagAndWidth[3]) : 0;
+  if (width <= str.length) return str;
+  const zeroPad = !leftAlign && zeroFlag;
+  const padLen = width - str.length;
+  if (leftAlign) return str + " ".repeat(padLen);
+  if (zeroPad) {
+    if (str[0] === "-" || str[0] === "+") {
+      return str[0] + "0".repeat(padLen) + str.slice(1);
+    }
+    return "0".repeat(padLen) + str;
+  }
+  return " ".repeat(padLen) + str;
+}
+function sprintfFormat(fmt, args) {
+  const flatArgs = [];
+  for (const arg of args) {
+    if (isRuntimeTensor(arg)) {
+      for (let k = 0; k < arg.data.length; k++) {
+        flatArgs.push(arg.data[k]);
+      }
+    } else {
+      flatArgs.push(arg);
+    }
+  }
+  let result = "";
+  let argIdx = 0;
+  do {
+    const startArgIdx = argIdx;
+    let outOfArgs = false;
+    let i = 0;
+    while (i < fmt.length && !outOfArgs) {
+      if (fmt[i] === "%" && i + 1 < fmt.length) {
+        i++;
+        let spec = "%";
+        while (i < fmt.length && !"dfigeEsoxXuc%".includes(fmt[i])) {
+          if (fmt[i] === "*") {
+            if (argIdx >= flatArgs.length) {
+              outOfArgs = true;
+              break;
+            }
+            spec += String(Math.round(toNumber(flatArgs[argIdx++])));
+            i++;
+          } else {
+            spec += fmt[i];
+            i++;
+          }
+        }
+        if (outOfArgs) break;
+        if (i < fmt.length) {
+          const ch = fmt[i];
+          i++;
+          if (ch === "%") {
+            result += "%";
+          } else if (argIdx >= flatArgs.length) {
+            outOfArgs = true;
+          } else if (ch === "d" || ch === "i" || ch === "u") {
+            const raw = toNumber(flatArgs[argIdx++]);
+            const isInt = Number.isInteger(raw);
+            const canPrintAsInt = ch === "u" ? isInt && raw >= 0 : isInt;
+            if (!canPrintAsInt) {
+              let eStr = raw.toExponential(6);
+              eStr = eStr.replace(/e([+-])(\d)$/, "e$10$2");
+              result += applyWidth(spec, eStr);
+            } else {
+              const n = raw;
+              const flags = spec.slice(1);
+              const hasPlus = flags.includes("+");
+              const leftAlign = flags.includes("-");
+              const widthMatch = spec.match(/^%[^0-9]*(\d+)/);
+              const width = widthMatch ? parseInt(widthMatch[1]) : 0;
+              const zeroPad = !leftAlign && /^[-+ ]*0/.test(spec.slice(1));
+              const s = String(Math.abs(n));
+              const sign = n < 0 ? "-" : hasPlus ? "+" : "";
+              if (width > 0) {
+                const padChar = zeroPad ? "0" : " ";
+                const padLen = Math.max(0, width - sign.length - s.length);
+                const pad = padChar.repeat(padLen);
+                result += leftAlign ? sign + s + " ".repeat(padLen) : zeroPad ? sign + pad + s : pad + sign + s;
+              } else {
+                result += sign + s;
+              }
+            }
+          } else if (ch === "f") {
+            const n = toNumber(flatArgs[argIdx++]);
+            if (!isFinite(n) || isNaN(n)) {
+              result += applyWidth(spec, numStr(n));
+            } else {
+              const fFlags = spec.slice(1);
+              const fHasPlus = fFlags.includes("+");
+              const precMatch = spec.match(/\.(\d+)/);
+              const prec = precMatch ? parseInt(precMatch[1]) : 6;
+              const formatted = n.toFixed(prec);
+              const fSign = n < 0 ? "" : fHasPlus ? "+" : "";
+              result += applyWidth(spec, fSign + formatted);
+            }
+          } else if (ch === "e" || ch === "E") {
+            const n = toNumber(flatArgs[argIdx++]);
+            if (!isFinite(n) || isNaN(n)) {
+              result += applyWidth(spec, numStr(n));
+            } else {
+              const precMatch = spec.match(/\.(\d+)/);
+              const prec = precMatch ? parseInt(precMatch[1]) : 6;
+              let eStr = n.toExponential(prec);
+              eStr = eStr.replace(/e([+-])(\d)$/, "e$10$2");
+              if (ch === "E") eStr = eStr.toUpperCase();
+              result += applyWidth(spec, eStr);
+            }
+          } else if (ch === "x" || ch === "X") {
+            const n = Math.round(toNumber(flatArgs[argIdx++]));
+            let s = Math.abs(n).toString(16);
+            if (ch === "X") s = s.toUpperCase();
+            result += applyWidth(spec, s);
+          } else if (ch === "o") {
+            const n = Math.round(toNumber(flatArgs[argIdx++]));
+            result += applyWidth(spec, Math.abs(n).toString(8));
+          } else if (ch === "g" || ch === "G") {
+            const gVal = toNumber(flatArgs[argIdx++]);
+            if (!isFinite(gVal) || isNaN(gVal)) {
+              result += applyWidth(spec, numStr(gVal));
+            } else {
+              const precMatch = spec.match(/\.(\d+)/);
+              const gPrec = precMatch ? parseInt(precMatch[1]) : 6;
+              let gStr;
+              if (gVal === 0) {
+                gStr = "0";
+              } else {
+                const exp = Math.floor(Math.log10(Math.abs(gVal)));
+                if (exp < -4 || exp >= gPrec) {
+                  gStr = gVal.toExponential(gPrec - 1);
+                  const ePos = gStr.indexOf("e");
+                  let mantissa = gStr.slice(0, ePos);
+                  let expPart = gStr.slice(ePos);
+                  if (mantissa.includes(".")) {
+                    mantissa = mantissa.replace(/\.?0+$/, "");
+                  }
+                  expPart = expPart.replace(/e([+-])(\d)$/, "e$10$2");
+                  gStr = mantissa + expPart;
+                } else {
+                  gStr = gVal.toPrecision(gPrec);
+                  if (gStr.includes(".")) {
+                    gStr = gStr.replace(/\.?0+$/, "");
+                  }
+                  if (gStr.includes("e")) {
+                    gStr = String(parseFloat(gStr));
+                  }
+                }
+              }
+              if (ch === "G") gStr = gStr.toUpperCase();
+              result += applyWidth(spec, gStr);
+            }
+          } else if (ch === "s") {
+            const sVal = toString(flatArgs[argIdx++]);
+            const sFlags = spec.slice(1);
+            const sLeftAlign = sFlags.includes("-");
+            const sWidthMatch = spec.match(/^%[^0-9]*(\d+)/);
+            const sWidth = sWidthMatch ? parseInt(sWidthMatch[1]) : 0;
+            if (sWidth > sVal.length) {
+              const sPad = " ".repeat(sWidth - sVal.length);
+              result += sLeftAlign ? sVal + sPad : sPad + sVal;
+            } else {
+              result += sVal;
+            }
+          } else if (ch === "c") {
+            result += String.fromCharCode(
+              Math.round(toNumber(flatArgs[argIdx++]))
+            );
+          } else {
+            result += spec + ch;
+            argIdx++;
+          }
+        }
+      } else if (fmt[i] === "\\" && i + 1 < fmt.length) {
+        i++;
+        switch (fmt[i]) {
+          case "n":
+            result += "\n";
+            break;
+          case "t":
+            result += "	";
+            break;
+          case "\\":
+            result += "\\";
+            break;
+          default:
+            result += "\\" + fmt[i];
+        }
+        i++;
+      } else {
+        result += fmt[i];
+        i++;
+      }
+    }
+    if (argIdx === startArgIdx) break;
+  } while (argIdx < flatArgs.length);
+  return result;
+}
+
 // src/numbl-core/helpers/arithmetic.ts
 function toComplex(v) {
   if (isRuntimeComplexNumber(v)) return { re: v.re, im: v.im };
@@ -22461,6 +22870,18 @@ function tryNativeElemwiseReal(at, bt, opCode) {
   );
   return RTV.tensorRaw(result, at.shape);
 }
+function tryNativeElemwiseScalar(scalar, tensor, opCode, scalarOnLeft) {
+  if (tensor.imag) return null;
+  const bridge = getLapackBridge();
+  if (!bridge?.elemwiseScalar) return null;
+  const result = bridge.elemwiseScalar(
+    scalar,
+    tensor.data,
+    opCode,
+    scalarOnLeft
+  );
+  return RTV.tensorRaw(result, tensor.shape);
+}
 function tensorElemwiseComplex(at, bt, opCode, jsOp) {
   const bridge = getLapackBridge();
   if (bridge?.elemwiseComplex) {
@@ -22501,7 +22922,26 @@ function tensorElemwiseComplex(at, bt, opCode, jsOp) {
   const isReal = resultIm.every((x) => x === 0);
   return RTV.tensor(resultRe, at.shape, isReal ? void 0 : resultIm);
 }
+function coerceToConcatString(v) {
+  if (isRuntimeString(v)) return v;
+  if (isRuntimeChar(v)) return v.value;
+  if (isRuntimeLogical(v)) return v ? "true" : "false";
+  if (isRuntimeNumber(v)) return num2strScalar(v);
+  if (isRuntimeTensor(v) && v.data.length === 1 && !v.imag) {
+    const x = v.data[0];
+    if (v._isLogical === true) return x ? "true" : "false";
+    return num2strScalar(x);
+  }
+  return null;
+}
 function mAdd(a, b) {
+  if (isRuntimeString(a) || isRuntimeString(b)) {
+    const aStr = coerceToConcatString(a);
+    const bStr = coerceToConcatString(b);
+    if (aStr !== null && bStr !== null) {
+      return RTV.string(aStr + bStr);
+    }
+  }
   const m = matchSameShapeTensors(a, b);
   if (m) {
     const [at, bt] = m;
@@ -22531,6 +22971,13 @@ function mAdd(a, b) {
       im: aIm + bIm
     }));
   }
+  if (isRuntimeNumber(a) && isRuntimeTensor(b)) {
+    const nr = tryNativeElemwiseScalar(a, b, ELEMWISE_ADD, true);
+    if (nr) return nr;
+  } else if (isRuntimeTensor(a) && isRuntimeNumber(b)) {
+    const nr = tryNativeElemwiseScalar(b, a, ELEMWISE_ADD, false);
+    if (nr) return nr;
+  }
   return binaryOp(a, b, (x, y) => x + y);
 }
 function mSub(a, b) {
@@ -22563,6 +23010,13 @@ function mSub(a, b) {
       im: aIm - bIm
     }));
   }
+  if (isRuntimeNumber(a) && isRuntimeTensor(b)) {
+    const nr = tryNativeElemwiseScalar(a, b, ELEMWISE_SUB, true);
+    if (nr) return nr;
+  } else if (isRuntimeTensor(a) && isRuntimeNumber(b)) {
+    const nr = tryNativeElemwiseScalar(b, a, ELEMWISE_SUB, false);
+    if (nr) return nr;
+  }
   return binaryOp(a, b, (x, y) => x - y);
 }
 function mMul(a, b) {
@@ -22579,6 +23033,13 @@ function mMul(a, b) {
       im: aRe * bIm + aIm * bRe
     }));
   }
+  if (isRuntimeNumber(a) && isRuntimeTensor(b)) {
+    const nr = tryNativeElemwiseScalar(a, b, ELEMWISE_MUL, true);
+    if (nr) return nr;
+  } else if (isRuntimeTensor(a) && isRuntimeNumber(b)) {
+    const nr = tryNativeElemwiseScalar(b, a, ELEMWISE_MUL, false);
+    if (nr) return nr;
+  }
   return binaryOp(a, b, (x, y) => x * y);
 }
 function mElemMul(a, b) {
@@ -22611,6 +23072,13 @@ function mElemMul(a, b) {
       im: aRe * bIm + aIm * bRe
     }));
   }
+  if (isRuntimeNumber(a) && isRuntimeTensor(b)) {
+    const nr = tryNativeElemwiseScalar(a, b, ELEMWISE_MUL, true);
+    if (nr) return nr;
+  } else if (isRuntimeTensor(a) && isRuntimeNumber(b)) {
+    const nr = tryNativeElemwiseScalar(b, a, ELEMWISE_MUL, false);
+    if (nr) return nr;
+  }
   return binaryOp(a, b, (x, y) => x * y);
 }
 function mDiv(a, b) {
@@ -22649,6 +23117,13 @@ function mElemDiv(a, b) {
   if (isComplexOrMixed(a, b)) {
     return complexBinaryOp(a, b, complexDivide);
   }
+  if (isRuntimeNumber(a) && isRuntimeTensor(b)) {
+    const nr = tryNativeElemwiseScalar(a, b, ELEMWISE_DIV, true);
+    if (nr) return nr;
+  } else if (isRuntimeTensor(a) && isRuntimeNumber(b)) {
+    const nr = tryNativeElemwiseScalar(b, a, ELEMWISE_DIV, false);
+    if (nr) return nr;
+  }
   return binaryOp(a, b, (x, y) => x / y);
 }
 function mLeftDiv(a, b) {
@@ -23618,7 +24093,7 @@ var token_config_default = {
     stripUnderscores: true,
     integerToken: "Integer",
     floatToken: "Float",
-    exponentChars: ["e", "E"],
+    exponentChars: ["e", "E", "d", "D"],
     decimalPoint: ".",
     dotOperatorPrefixes: ["*", "/", "\\", "^"]
   },
@@ -23923,6 +24398,9 @@ function tokenizeDetailed(input) {
       if (numCfg.stripUnderscores) {
         lexeme = lexeme.replace(/_/g, "");
       }
+      if (isFloat) {
+        lexeme = lexeme.replace(/[dD]/g, "e");
+      }
       const tok = isFloat ? Token[numCfg.floatToken] : Token[numCfg.integerToken];
       lineStart = false;
       out.push({ token: tok, lexeme, start, end: pos });
@@ -26914,6 +27392,29 @@ function methodDispatch(rt, name, nargout, args) {
           }
           return fieldVal;
         }
+        {
+          const accessorKey = `${firstRV.className}.get.${name}`;
+          if (!rt.activeAccessors.has(accessorKey)) {
+            const getter = rt.cachedResolveClassMethod(
+              firstRV.className,
+              `get.${name}`
+            );
+            if (getter) {
+              rt.activeAccessors.add(accessorKey);
+              let gotVal;
+              try {
+                gotVal = getter(1, first);
+              } finally {
+                rt.activeAccessors.delete(accessorKey);
+              }
+              const remaining = args.slice(1);
+              if (remaining.length > 0) {
+                return rt.index(gotVal, remaining, nargout);
+              }
+              return gotVal;
+            }
+          }
+        }
         try {
           return callClassMethod(rt, firstRV.className, name, nargout, args);
         } catch (e) {
@@ -27868,6 +28369,7 @@ function index(rt, base, indices, nargout = 1, skipSubsref = false) {
           const im2 = t.imag[i];
           return im2 === 0 ? t.data[i] : RTV.complex(t.data[i], im2);
         }
+        if (t._isLogical === true) return t.data[i] !== 0;
         return t.data[i];
       }
     } else if (nIdx === 2) {
@@ -27876,7 +28378,14 @@ function index(rt, base, indices, nargout = 1, skipSubsref = false) {
       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];
+        let cols;
+        if (s.length === 0) cols = 1;
+        else if (s.length === 1) cols = s[0];
+        else if (s.length === 2) cols = s[1];
+        else {
+          cols = 1;
+          for (let k = 1; k < s.length; k++) cols *= s[k];
+        }
         const r = Math.round(ri) - 1;
         const c = Math.round(ci) - 1;
         if (r < 0 || r >= rows || c < 0 || c >= cols)
@@ -27886,6 +28395,7 @@ function index(rt, base, indices, nargout = 1, skipSubsref = false) {
           const im2 = t.imag[lin];
           return im2 === 0 ? t.data[lin] : RTV.complex(t.data[lin], im2);
         }
+        if (t._isLogical === true) return t.data[lin] !== 0;
         return t.data[lin];
       }
     } else if (nIdx >= 3) {
@@ -28276,14 +28786,20 @@ function multiOutputCellAssign(base, indices, results) {
   if (base === void 0 || base === null) base = RTV.cell([], [0, 0]);
   let mv = ensureRuntimeValue(base);
   if (!isRuntimeCell(mv)) mv = RTV.cell([], [0, 0]);
-  const idxMv = ensureRuntimeValue(indices);
   let idxArray;
-  if (isRuntimeTensor(idxMv)) {
-    idxArray = Array.from(idxMv.data);
-  } else if (isRuntimeNumber(idxMv)) {
-    idxArray = [idxMv];
+  if (indices === COLON_SENTINEL) {
+    const n = mv.data.length;
+    idxArray = [];
+    for (let i = 1; i <= n; i++) idxArray.push(i);
   } else {
-    idxArray = [1];
+    const idxMv = ensureRuntimeValue(indices);
+    if (isRuntimeTensor(idxMv)) {
+      idxArray = Array.from(idxMv.data);
+    } else if (isRuntimeNumber(idxMv)) {
+      idxArray = [idxMv];
+    } else {
+      idxArray = [1];
+    }
   }
   for (let i = 0; i < idxArray.length && i < results.length; i++) {
     const idx = idxArray[i];
@@ -28294,225 +28810,6 @@ function multiOutputCellAssign(base, indices, results) {
   return mv;
 }
 
-// src/numbl-core/helpers/string.ts
-function numStr(n) {
-  if (n === Infinity) return "Inf";
-  if (n === -Infinity) return "-Inf";
-  if (isNaN(n)) return "NaN";
-  if (n === 0) return "0";
-  const prec = 5;
-  const exp = Math.floor(Math.log10(Math.abs(n)));
-  let s;
-  if (exp < -4 || exp >= prec) {
-    s = n.toExponential(prec - 1);
-    const ePos = s.indexOf("e");
-    let mantissa = s.slice(0, ePos);
-    const expPart0 = s.slice(ePos);
-    if (mantissa.includes(".")) mantissa = mantissa.replace(/\.?0+$/, "");
-    const expPart = expPart0.replace(/([eE][+-])(\d)$/, "$10$2");
-    s = mantissa + expPart;
-  } else {
-    if (Number.isInteger(n)) return String(n);
-    s = n.toPrecision(prec);
-    if (s.includes(".")) s = s.replace(/\.?0+$/, "");
-  }
-  return s;
-}
-function applyWidth(spec, str) {
-  const m = spec.match(/^%([-+ #]*)0?(\d+)?/);
-  if (!m) return str;
-  const explicitFlags = m[1] || "";
-  const leftAlign = explicitFlags.includes("-");
-  const afterPercent = spec.slice(1);
-  const flagAndWidth = afterPercent.match(/^([-+ #]*)(0?)(\d+)?/);
-  const zeroFlag = flagAndWidth ? flagAndWidth[2] === "0" : false;
-  const width = flagAndWidth && flagAndWidth[3] ? parseInt(flagAndWidth[3]) : 0;
-  if (width <= str.length) return str;
-  const zeroPad = !leftAlign && zeroFlag;
-  const padLen = width - str.length;
-  if (leftAlign) return str + " ".repeat(padLen);
-  if (zeroPad) {
-    if (str[0] === "-" || str[0] === "+") {
-      return str[0] + "0".repeat(padLen) + str.slice(1);
-    }
-    return "0".repeat(padLen) + str;
-  }
-  return " ".repeat(padLen) + str;
-}
-function sprintfFormat(fmt, args) {
-  const flatArgs = [];
-  for (const arg of args) {
-    if (isRuntimeTensor(arg)) {
-      for (let k = 0; k < arg.data.length; k++) {
-        flatArgs.push(arg.data[k]);
-      }
-    } else {
-      flatArgs.push(arg);
-    }
-  }
-  let result = "";
-  let argIdx = 0;
-  do {
-    const startArgIdx = argIdx;
-    let outOfArgs = false;
-    let i = 0;
-    while (i < fmt.length && !outOfArgs) {
-      if (fmt[i] === "%" && i + 1 < fmt.length) {
-        i++;
-        let spec = "%";
-        while (i < fmt.length && !"dfigeEsoxXuc%".includes(fmt[i])) {
-          spec += fmt[i];
-          i++;
-        }
-        if (i < fmt.length) {
-          const ch = fmt[i];
-          i++;
-          if (ch === "%") {
-            result += "%";
-          } else if (argIdx >= flatArgs.length) {
-            outOfArgs = true;
-          } else if (ch === "d" || ch === "i" || ch === "u") {
-            const raw = toNumber(flatArgs[argIdx++]);
-            const isInt = Number.isInteger(raw);
-            const canPrintAsInt = ch === "u" ? isInt && raw >= 0 : isInt;
-            if (!canPrintAsInt) {
-              let eStr = raw.toExponential(6);
-              eStr = eStr.replace(/e([+-])(\d)$/, "e$10$2");
-              result += applyWidth(spec, eStr);
-            } else {
-              const n = raw;
-              const flags = spec.slice(1);
-              const hasPlus = flags.includes("+");
-              const leftAlign = flags.includes("-");
-              const widthMatch = spec.match(/^%[^0-9]*(\d+)/);
-              const width = widthMatch ? parseInt(widthMatch[1]) : 0;
-              const zeroPad = !leftAlign && /^[-+ ]*0/.test(spec.slice(1));
-              const s = String(Math.abs(n));
-              const sign = n < 0 ? "-" : hasPlus ? "+" : "";
-              if (width > 0) {
-                const padChar = zeroPad ? "0" : " ";
-                const padLen = Math.max(0, width - sign.length - s.length);
-                const pad = padChar.repeat(padLen);
-                result += leftAlign ? sign + s + " ".repeat(padLen) : zeroPad ? sign + pad + s : pad + sign + s;
-              } else {
-                result += sign + s;
-              }
-            }
-          } else if (ch === "f") {
-            const n = toNumber(flatArgs[argIdx++]);
-            if (!isFinite(n) || isNaN(n)) {
-              result += applyWidth(spec, numStr(n));
-            } else {
-              const fFlags = spec.slice(1);
-              const fHasPlus = fFlags.includes("+");
-              const precMatch = spec.match(/\.(\d+)/);
-              const prec = precMatch ? parseInt(precMatch[1]) : 6;
-              const formatted = n.toFixed(prec);
-              const fSign = n < 0 ? "" : fHasPlus ? "+" : "";
-              result += applyWidth(spec, fSign + formatted);
-            }
-          } else if (ch === "e" || ch === "E") {
-            const n = toNumber(flatArgs[argIdx++]);
-            if (!isFinite(n) || isNaN(n)) {
-              result += applyWidth(spec, numStr(n));
-            } else {
-              const precMatch = spec.match(/\.(\d+)/);
-              const prec = precMatch ? parseInt(precMatch[1]) : 6;
-              let eStr = n.toExponential(prec);
-              eStr = eStr.replace(/e([+-])(\d)$/, "e$10$2");
-              if (ch === "E") eStr = eStr.toUpperCase();
-              result += applyWidth(spec, eStr);
-            }
-          } else if (ch === "x" || ch === "X") {
-            const n = Math.round(toNumber(flatArgs[argIdx++]));
-            let s = Math.abs(n).toString(16);
-            if (ch === "X") s = s.toUpperCase();
-            result += applyWidth(spec, s);
-          } else if (ch === "o") {
-            const n = Math.round(toNumber(flatArgs[argIdx++]));
-            result += applyWidth(spec, Math.abs(n).toString(8));
-          } else if (ch === "g" || ch === "G") {
-            const gVal = toNumber(flatArgs[argIdx++]);
-            if (!isFinite(gVal) || isNaN(gVal)) {
-              result += applyWidth(spec, numStr(gVal));
-            } else {
-              const precMatch = spec.match(/\.(\d+)/);
-              const gPrec = precMatch ? parseInt(precMatch[1]) : 6;
-              let gStr;
-              if (gVal === 0) {
-                gStr = "0";
-              } else {
-                const exp = Math.floor(Math.log10(Math.abs(gVal)));
-                if (exp < -4 || exp >= gPrec) {
-                  gStr = gVal.toExponential(gPrec - 1);
-                  const ePos = gStr.indexOf("e");
-                  let mantissa = gStr.slice(0, ePos);
-                  let expPart = gStr.slice(ePos);
-                  if (mantissa.includes(".")) {
-                    mantissa = mantissa.replace(/\.?0+$/, "");
-                  }
-                  expPart = expPart.replace(/e([+-])(\d)$/, "e$10$2");
-                  gStr = mantissa + expPart;
-                } else {
-                  gStr = gVal.toPrecision(gPrec);
-                  if (gStr.includes(".")) {
-                    gStr = gStr.replace(/\.?0+$/, "");
-                  }
-                  if (gStr.includes("e")) {
-                    gStr = String(parseFloat(gStr));
-                  }
-                }
-              }
-              if (ch === "G") gStr = gStr.toUpperCase();
-              result += applyWidth(spec, gStr);
-            }
-          } else if (ch === "s") {
-            const sVal = toString(flatArgs[argIdx++]);
-            const sFlags = spec.slice(1);
-            const sLeftAlign = sFlags.includes("-");
-            const sWidthMatch = spec.match(/^%[^0-9]*(\d+)/);
-            const sWidth = sWidthMatch ? parseInt(sWidthMatch[1]) : 0;
-            if (sWidth > sVal.length) {
-              const sPad = " ".repeat(sWidth - sVal.length);
-              result += sLeftAlign ? sVal + sPad : sPad + sVal;
-            } else {
-              result += sVal;
-            }
-          } else if (ch === "c") {
-            result += String.fromCharCode(
-              Math.round(toNumber(flatArgs[argIdx++]))
-            );
-          } else {
-            result += spec + ch;
-            argIdx++;
-          }
-        }
-      } else if (fmt[i] === "\\" && i + 1 < fmt.length) {
-        i++;
-        switch (fmt[i]) {
-          case "n":
-            result += "\n";
-            break;
-          case "t":
-            result += "	";
-            break;
-          case "\\":
-            result += "\\";
-            break;
-          default:
-            result += "\\" + fmt[i];
-        }
-        i++;
-      } else {
-        result += fmt[i];
-        i++;
-      }
-    }
-    if (argIdx === startArgIdx) break;
-  } while (argIdx < flatArgs.length);
-  return result;
-}
-
 // src/numbl-core/interpreter/builtins/misc.ts
 registerIBuiltin({
   name: "substruct",
@@ -28565,6 +28862,44 @@ registerIBuiltin({
     }
   })
 });
+var WEBOPTIONS_DEFAULTS = {
+  CharacterEncoding: RTV.char("auto"),
+  UserAgent: RTV.char("numbl"),
+  Timeout: 5,
+  Username: RTV.char(""),
+  Password: RTV.char(""),
+  KeyName: RTV.char(""),
+  KeyValue: RTV.char(""),
+  ContentType: RTV.char("auto"),
+  MediaType: RTV.char("auto"),
+  RequestMethod: RTV.char("auto"),
+  ArrayFormat: RTV.char("csv"),
+  CertificateFilename: RTV.char("default")
+};
+registerIBuiltin({
+  name: "weboptions",
+  resolve: () => ({
+    outputTypes: [{ kind: "struct" }],
+    apply: (args) => {
+      const fields = /* @__PURE__ */ new Map();
+      for (const [k, v] of Object.entries(WEBOPTIONS_DEFAULTS)) {
+        fields.set(k, v);
+      }
+      if (args.length % 2 !== 0)
+        throw new RuntimeError("weboptions: expected name-value pairs");
+      for (let i = 0; i < args.length; i += 2) {
+        const key = args[i];
+        if (!isRuntimeChar(key) && !isRuntimeString(key))
+          throw new RuntimeError("weboptions: option name must be a string");
+        const name = isRuntimeChar(key) ? key.value : key;
+        if (!(name in WEBOPTIONS_DEFAULTS))
+          throw new RuntimeError(`weboptions: unknown option '${name}'`);
+        fields.set(name, args[i + 1]);
+      }
+      return RTV.struct(Object.fromEntries(fields));
+    }
+  })
+});
 registerIBuiltin({
   name: "odeget",
   resolve: () => ({
@@ -28674,7 +29009,7 @@ for (const name of ["clear", "clc", "clf"]) {
     name,
     resolve: () => ({
       outputTypes: [],
-      apply: () => 0
+      apply: () => void 0
     })
   });
 }
@@ -28808,7 +29143,7 @@ registerIBuiltin({
   name: "set",
   resolve: () => ({
     outputTypes: [],
-    apply: () => 0
+    apply: () => void 0
   })
 });
 for (const name of [
@@ -28830,7 +29165,7 @@ for (const name of [
     name,
     resolve: () => ({
       outputTypes: [],
-      apply: () => 0
+      apply: () => void 0
     })
   });
 }
@@ -29119,6 +29454,148 @@ registerIBuiltin({
   }
 });
 
+// src/numbl-core/interpreter/builtins/time-system.ts
+var ticTime = 0;
+function getTicTime() {
+  return ticTime;
+}
+defineBuiltin({
+  name: "tic",
+  cases: [
+    {
+      match: (argTypes) => argTypes.length === 0 ? [{ kind: "number" }] : null,
+      apply: () => {
+        ticTime = performance.now();
+        return RTV.num(ticTime / 1e3);
+      }
+    }
+  ]
+});
+defineBuiltin({
+  name: "clock",
+  cases: [
+    {
+      match: (argTypes) => argTypes.length === 0 ? [{ kind: "tensor", isComplex: false, shape: [1, 6] }] : null,
+      apply: () => {
+        const now = /* @__PURE__ */ new Date();
+        return RTV.tensor(
+          new FloatXArray([
+            now.getFullYear(),
+            now.getMonth() + 1,
+            now.getDate(),
+            now.getHours(),
+            now.getMinutes(),
+            now.getSeconds() + now.getMilliseconds() / 1e3
+          ]),
+          [1, 6]
+        );
+      }
+    }
+  ]
+});
+defineBuiltin({
+  name: "etime",
+  cases: [
+    {
+      match: (argTypes) => argTypes.length === 2 ? [{ kind: "number" }] : null,
+      apply: (args) => {
+        const t1 = args[0];
+        const t0 = args[1];
+        if (!isRuntimeTensor(t1) || !isRuntimeTensor(t0))
+          throw new RuntimeError("etime: arguments must be clock vectors");
+        const toMs = (t) => {
+          const d = new Date(
+            t.data[0],
+            t.data[1] - 1,
+            t.data[2],
+            t.data[3],
+            t.data[4],
+            Math.floor(t.data[5]),
+            t.data[5] % 1 * 1e3
+          );
+          return d.getTime();
+        };
+        return RTV.num((toMs(t1) - toMs(t0)) / 1e3);
+      }
+    }
+  ]
+});
+defineBuiltin({
+  name: "version",
+  cases: [
+    {
+      match: (argTypes) => argTypes.length === 0 ? [{ kind: "char" }] : null,
+      apply: () => RTV.char("9.14.0")
+    }
+  ]
+});
+function getComputerStrings() {
+  if (typeof process === "undefined") {
+    return { str: "BROWSER", arch: "browser" };
+  }
+  const platform = process.platform;
+  const cpuArch = process.arch;
+  if (platform === "win32") return { str: "PCWIN64", arch: "win64" };
+  if (platform === "darwin") {
+    if (cpuArch === "arm64") return { str: "MACA64", arch: "maca64" };
+    return { str: "MACI64", arch: "maci64" };
+  }
+  return { str: "GLNXA64", arch: "glnxa64" };
+}
+registerIBuiltin({
+  name: "computer",
+  resolve: () => ({
+    outputTypes: [{ kind: "unknown" }],
+    apply: (args, nargout) => {
+      const info = getComputerStrings();
+      if (args.length >= 1 && isRuntimeChar(args[0])) {
+        const arg = toString(args[0]);
+        if (arg === "arch") return RTV.char(info.arch);
+        throw new RuntimeError(`computer: unknown argument '${arg}'`);
+      }
+      const maxsize = 2 ** 48 - 1;
+      const endian = RTV.char("L");
+      if (nargout <= 1) return RTV.char(info.str);
+      if (nargout === 2) return [RTV.char(info.str), RTV.num(maxsize)];
+      return [RTV.char(info.str), RTV.num(maxsize), endian];
+    }
+  })
+});
+function getMexExt() {
+  if (typeof process === "undefined") return "";
+  const platform = process.platform;
+  const cpuArch = process.arch;
+  if (platform === "win32") return "mexw64";
+  if (platform === "darwin")
+    return cpuArch === "arm64" ? "mexmaca64" : "mexmaci64";
+  return "mexa64";
+}
+defineBuiltin({
+  name: "mexext",
+  cases: [
+    {
+      match: (argTypes) => argTypes.length === 0 ? [{ kind: "char" }] : null,
+      apply: () => RTV.char(getMexExt())
+    }
+  ]
+});
+var _platform = typeof process !== "undefined" ? process.platform : "linux";
+for (const [name, val] of [
+  ["ismac", _platform === "darwin"],
+  ["ispc", _platform === "win32"],
+  ["isunix", _platform !== "win32"]
+]) {
+  defineBuiltin({
+    name,
+    cases: [
+      {
+        match: (argTypes) => argTypes.length === 0 ? [{ kind: "boolean" }] : null,
+        apply: () => RTV.logical(val)
+      }
+    ]
+  });
+}
+
 // src/numbl-core/runtime/plotUtils.ts
 var COLOR_SHORT = {
   r: [1, 0, 0],
@@ -31351,6 +31828,114 @@ function bisectEvent(eventIdx, step, events) {
   return [tOld + xFinal * h, denseOutputEval(yOld, Q, h, xFinal)];
 }
 
+// src/numbl-core/helpers/quadgk.ts
+var XK = [
+  -0.9914553711208126,
+  -0.9491079123427585,
+  -0.8648644233597691,
+  -0.7415311855993945,
+  -0.586087235467691,
+  -0.4058451513773972,
+  -0.2077849550078985,
+  0,
+  0.2077849550078985,
+  0.4058451513773972,
+  0.586087235467691,
+  0.7415311855993945,
+  0.8648644233597691,
+  0.9491079123427585,
+  0.9914553711208126
+];
+var WK = [
+  0.0229353220105292,
+  0.0630920926299786,
+  0.1047900103222502,
+  0.1406532597155259,
+  0.1690047266392679,
+  0.1903505780647854,
+  0.2044329400752989,
+  0.2094821410847278,
+  0.2044329400752989,
+  0.1903505780647854,
+  0.1690047266392679,
+  0.1406532597155259,
+  0.1047900103222502,
+  0.0630920926299786,
+  0.0229353220105292
+];
+var WG = [
+  0.1294849661688697,
+  0.2797053914892767,
+  0.3818300505051189,
+  0.4179591836734694,
+  0.3818300505051189,
+  0.2797053914892767,
+  0.1294849661688697
+];
+function kronrodNodes(lo, hi) {
+  const m = (lo + hi) / 2;
+  const h = (hi - lo) / 2;
+  const out = new Array(15);
+  for (let i = 0; i < 15; i++) out[i] = m + h * XK[i];
+  return out;
+}
+function segmentEstimate(lo, hi, fv) {
+  const h = (hi - lo) / 2;
+  let K = 0;
+  let G = 0;
+  for (let i = 0; i < 15; i++) K += WK[i] * fv[i];
+  for (let i = 0; i < 7; i++) G += WG[i] * fv[2 * i + 1];
+  K *= h;
+  G *= h;
+  return { K, err: Math.abs(K - G) };
+}
+function quadgkAdaptive(integrand, a, b, opts = {}) {
+  const relTol = opts.relTol ?? 1e-6;
+  const absTol = opts.absTol ?? 1e-10;
+  const maxIntervals = opts.maxIntervalCount ?? 650;
+  if (a === b) return { value: 0, errbnd: 0, intervalsUsed: 0 };
+  const sign = a < b ? 1 : -1;
+  const lo0 = Math.min(a, b);
+  const hi0 = Math.max(a, b);
+  const segmentOn = (lo, hi) => {
+    const pts = kronrodNodes(lo, hi);
+    const fv = integrand(pts);
+    if (fv.length !== 15) {
+      throw new Error(
+        `quadgk: integrand must return 15 values for 15 nodes, got ${fv.length}`
+      );
+    }
+    return segmentEstimate(lo, hi, fv);
+  };
+  const initial = segmentOn(lo0, hi0);
+  let totalK = initial.K;
+  let totalErr = initial.err;
+  const worklist = [{ lo: lo0, hi: hi0, ...initial }];
+  const converged = () => totalErr <= Math.max(absTol, relTol * Math.abs(totalK));
+  let iters = 0;
+  while (!converged() && worklist.length < maxIntervals && iters < 1e4) {
+    iters++;
+    let worstIdx = 0;
+    for (let i = 1; i < worklist.length; i++) {
+      if (worklist[i].err > worklist[worstIdx].err) worstIdx = i;
+    }
+    const worst = worklist[worstIdx];
+    if (worst.hi - worst.lo <= 1e-15 * (hi0 - lo0)) break;
+    const mid = (worst.lo + worst.hi) / 2;
+    const s1 = segmentOn(worst.lo, mid);
+    const s2 = segmentOn(mid, worst.hi);
+    totalK += s1.K + s2.K - worst.K;
+    totalErr += s1.err + s2.err - worst.err;
+    worklist[worstIdx] = { lo: worst.lo, hi: mid, ...s1 };
+    worklist.push({ lo: mid, hi: worst.hi, ...s2 });
+  }
+  return {
+    value: sign * totalK,
+    errbnd: totalErr,
+    intervalsUsed: worklist.length
+  };
+}
+
 // src/numbl-core/runtime/specialBuiltinNames.ts
 var SPECIAL_BUILTIN_NAMES = [
   "help",
@@ -31439,6 +32024,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "webread",
   "delete",
   "rmdir",
+  "movefile",
   "unzip",
   "dir",
   "warning",
@@ -31451,7 +32037,9 @@ var SPECIAL_BUILTIN_NAMES = [
   "cd",
   "ode45",
   "ode23",
-  "deval"
+  "deval",
+  "toc",
+  "quadgk"
 ];
 
 // src/numbl-core/runtime/specialBuiltins.ts
@@ -31465,49 +32053,74 @@ function registerSpecial(name, fn) {
     })
   });
 }
+function registerSpecialVoid(name, fn) {
+  registerDynamicIBuiltin({
+    name,
+    resolve: () => ({
+      outputTypes: [],
+      apply: (args) => {
+        fn(args);
+        return void 0;
+      }
+    })
+  });
+}
 function registerSpecialBuiltins(rt) {
-  registerSpecial("help", (_nargout, args) => {
+  registerSpecial("help", (nargout, args) => {
+    let text = "";
+    const emit = (s) => {
+      text += s;
+      if (nargout === 0) rt.output(s);
+    };
     if (args.length === 0) {
       const names = getAllBuiltinNames().sort();
-      rt.output("Available builtins:\n");
-      rt.output("  " + names.join(", ") + "\n");
-      rt.output("\nType 'help <name>' for help on a specific builtin.\n");
-      return 0;
-    }
-    const name = toString(args[0]);
-    const h = getIBuiltinHelp(name);
-    if (!h) {
-      const allNames = getAllBuiltinNames();
-      if (allNames.includes(name)) {
-        rt.output(`No help available for '${name}'.
+      emit("Available builtins:\n");
+      emit("  " + names.join(", ") + "\n");
+      emit("\nType 'help <name>' for help on a specific builtin.\n");
+    } else {
+      const name = toString(args[0]);
+      const h = getIBuiltinHelp(name);
+      if (!h) {
+        const allNames = getAllBuiltinNames();
+        if (allNames.includes(name)) {
+          emit(`No help available for '${name}'.
 `);
-      } else {
-        rt.output(`Unknown function '${name}'.
+        } else {
+          emit(`Unknown function '${name}'.
 `);
-      }
-      return 0;
-    }
-    rt.output(`  ${h.signatures.join("\n  ")}
+        }
+      } else {
+        emit(`  ${h.signatures.join("\n  ")}
 
 `);
-    rt.output(`${h.description}
+        emit(`${h.description}
 `);
-    return 0;
+      }
+    }
+    return nargout >= 1 ? RTV.char(text) : void 0;
   });
-  registerSpecial("disp", (_nargout, args) => {
+  registerSpecialVoid("disp", (args) => {
     if (args.length >= 1) {
       const mv = ensureRuntimeValue(args[0]);
-      if (isRuntimeTensor(mv) && mv.data.length === 0) return 0;
+      if (isRuntimeTensor(mv) && mv.data.length === 0) return;
       rt.output(displayValue(mv) + "\n");
     }
-    return 0;
   });
-  registerSpecial("warning", (_nargout, args) => {
-    if (args.length === 0) return RTV.num(0);
+  registerSpecial("toc", (nargout) => {
+    const elapsed = (performance.now() - getTicTime()) / 1e3;
+    if (nargout === 0) {
+      rt.output(`Elapsed time is ${elapsed.toFixed(6)} seconds.
+`);
+    }
+    return RTV.num(elapsed);
+  });
+  registerSpecial("warning", (nargout, args) => {
+    if (args.length === 0) return nargout >= 1 ? RTV.num(0) : void 0;
     const margs = args.map((a) => ensureRuntimeValue(a));
     if (margs.length === 2 && isRuntimeChar(margs[0]) && isRuntimeChar(margs[1])) {
       const state = toString(margs[0]);
       if (state === "on" || state === "off") {
+        if (nargout === 0) return void 0;
         return RTV.struct(
           /* @__PURE__ */ new Map([
             ["state", RTV.char("on")],
@@ -31536,9 +32149,9 @@ function registerSpecialBuiltins(rt) {
     } else {
       rt.output("Warning: " + sprintfFormat(fmt, fmtArgs) + "\n");
     }
-    return RTV.num(0);
+    return nargout >= 1 ? RTV.num(0) : void 0;
   });
-  registerSpecial("fprintf", (_nargout, args) => {
+  registerSpecial("fprintf", (nargout, args) => {
     let output = "";
     if (args.length >= 1) {
       const margs = args.map((a) => ensureRuntimeValue(a));
@@ -31549,27 +32162,7 @@ function registerSpecialBuiltins(rt) {
         fmtIdx = 1;
       }
       const fmt = toString(margs[fmtIdx]);
-      const scalarArgs = [];
-      for (let i = fmtIdx + 1; i < margs.length; i++) {
-        const a = margs[i];
-        if (isRuntimeTensor(a)) {
-          for (let j = 0; j < a.data.length; j++)
-            scalarArgs.push(RTV.num(a.data[j]));
-        } else {
-          scalarArgs.push(a);
-        }
-      }
-      const specCount = (fmt.match(/%[^%]/g) || []).length;
-      if (specCount === 0 || scalarArgs.length === 0) {
-        output = sprintfFormat(fmt, scalarArgs);
-      } else {
-        let idx = 0;
-        while (idx < scalarArgs.length) {
-          const batch = scalarArgs.slice(idx, idx + specCount);
-          output += sprintfFormat(fmt, batch);
-          idx += specCount;
-        }
-      }
+      output = sprintfFormat(fmt, margs.slice(fmtIdx + 1));
       if (fid === 1 || fid === 2) {
         rt.output(output);
       } else {
@@ -31580,7 +32173,7 @@ function registerSpecialBuiltins(rt) {
         rt.fileIO.fwrite(fid, output);
       }
     }
-    return output.length;
+    return nargout >= 1 ? output.length : void 0;
   });
   registerSpecial("arrayfun", (nargout, args) => {
     return arrayfunImpl(rt, nargout, args);
@@ -31612,6 +32205,55 @@ function registerSpecialBuiltins(rt) {
   registerSpecial("bsxfun", (nargout, args) => {
     return bsxfunImpl(rt, nargout, args);
   });
+  registerSpecial("quadgk", (nargout, args) => {
+    if (args.length < 3)
+      throw new RuntimeError(
+        "quadgk: requires at least 3 arguments (fun, a, b)"
+      );
+    const fnArg = ensureRuntimeValue(args[0]);
+    if (!isRuntimeFunction(fnArg))
+      throw new RuntimeError("quadgk: first argument must be a function");
+    const a = toNumber(ensureRuntimeValue(args[1]));
+    const b = toNumber(ensureRuntimeValue(args[2]));
+    let relTol;
+    let absTol;
+    let maxIntervalCount;
+    for (let i = 3; i + 1 < args.length; i += 2) {
+      const keyRv = ensureRuntimeValue(args[i]);
+      const key = isRuntimeChar(keyRv) ? keyRv.value : isRuntimeString(keyRv) ? keyRv : "";
+      const lowerKey = key.toLowerCase();
+      const valRv = ensureRuntimeValue(args[i + 1]);
+      if (lowerKey === "reltol") relTol = toNumber(valRv);
+      else if (lowerKey === "abstol") absTol = toNumber(valRv);
+      else if (lowerKey === "maxintervalcount")
+        maxIntervalCount = toNumber(valRv);
+    }
+    const integrand = (pts) => {
+      const vecData = new FloatXArray(pts);
+      const vec = RTV.tensor(vecData, [1, pts.length]);
+      const resultRaw = rt.index(fnArg, [vec], 1);
+      const rv = ensureRuntimeValue(resultRaw);
+      if (isRuntimeNumber(rv)) {
+        return new Array(pts.length).fill(rv);
+      }
+      if (isRuntimeTensor(rv)) {
+        if (rv.data.length !== pts.length) {
+          throw new RuntimeError(
+            `quadgk: integrand returned ${rv.data.length} values for ${pts.length} nodes`
+          );
+        }
+        return Array.from(rv.data);
+      }
+      throw new RuntimeError("quadgk: integrand must return a numeric vector");
+    };
+    const result = quadgkAdaptive(integrand, a, b, {
+      relTol,
+      absTol,
+      maxIntervalCount
+    });
+    if (nargout >= 2) return [result.value, result.errbnd];
+    return result.value;
+  });
   registerSpecial("subsref", (nargout, args) => {
     return subsrefBuiltin(rt, nargout, args);
   });
@@ -32140,6 +32782,40 @@ function registerSpecialBuiltins(rt) {
       RTV.char("")
     ];
   });
+  function extractWebOptions(arg) {
+    if (!isRuntimeStruct(arg)) return void 0;
+    const s = arg;
+    if (!s.fields.has("Timeout")) return void 0;
+    const opts = {};
+    const t = s.fields.get("Timeout");
+    if (t !== void 0) opts.timeout = toNumber(t);
+    const rm = s.fields.get("RequestMethod");
+    if (rm !== void 0) {
+      const v = toString(rm);
+      if (v !== "auto") opts.requestMethod = v;
+    }
+    const un = s.fields.get("Username");
+    if (un !== void 0) {
+      const v = toString(un);
+      if (v) opts.username = v;
+    }
+    const pw = s.fields.get("Password");
+    if (pw !== void 0) {
+      const v = toString(pw);
+      if (v) opts.password = v;
+    }
+    const kn = s.fields.get("KeyName");
+    if (kn !== void 0) {
+      const v = toString(kn);
+      if (v) opts.keyName = v;
+    }
+    const kv = s.fields.get("KeyValue");
+    if (kv !== void 0) {
+      const v = toString(kv);
+      if (v) opts.keyValue = v;
+    }
+    return opts;
+  }
   registerSpecial("websave", (_nargout, args) => {
     const io = requireFileIO();
     const margs = args.map((a) => ensureRuntimeValue(a));
@@ -32149,8 +32825,14 @@ function registerSpecialBuiltins(rt) {
       throw new RuntimeError("websave is not available in this environment");
     const filename = toString(margs[0]);
     let url = toString(margs[1]);
+    let webOpts;
+    let queryEnd = margs.length;
+    if (margs.length > 2) {
+      webOpts = extractWebOptions(margs[margs.length - 1]);
+      if (webOpts) queryEnd = margs.length - 1;
+    }
     const queryParts = [];
-    for (let i = 2; i + 1 < margs.length; i += 2) {
+    for (let i = 2; i + 1 < queryEnd; i += 2) {
       const name = encodeURIComponent(toString(margs[i]));
       const value = encodeURIComponent(toString(margs[i + 1]));
       queryParts.push(`${name}=${value}`);
@@ -32159,7 +32841,7 @@ function registerSpecialBuiltins(rt) {
       const sep = url.includes("?") ? "&" : "?";
       url += sep + queryParts.join("&");
     }
-    io.websave(url, filename);
+    io.websave(url, filename, webOpts);
     return RTV.char(filename);
   });
   registerSpecial("webread", (_nargout, args) => {
@@ -32170,8 +32852,14 @@ function registerSpecialBuiltins(rt) {
     if (!io.webread)
       throw new RuntimeError("webread is not available in this environment");
     let url = toString(margs[0]);
+    let webOpts;
+    let queryEnd = margs.length;
+    if (margs.length > 1) {
+      webOpts = extractWebOptions(margs[margs.length - 1]);
+      if (webOpts) queryEnd = margs.length - 1;
+    }
     const queryParts = [];
-    for (let i = 1; i + 1 < margs.length; i += 2) {
+    for (let i = 1; i + 1 < queryEnd; i += 2) {
       const name = encodeURIComponent(toString(margs[i]));
       const value = encodeURIComponent(toString(margs[i + 1]));
       queryParts.push(`${name}=${value}`);
@@ -32180,7 +32868,7 @@ function registerSpecialBuiltins(rt) {
       const sep = url.includes("?") ? "&" : "?";
       url += sep + queryParts.join("&");
     }
-    const text = io.webread(url);
+    const text = io.webread(url, webOpts);
     try {
       const parsed = JSON.parse(text);
       return convertJsonValue(parsed);
@@ -32188,7 +32876,7 @@ function registerSpecialBuiltins(rt) {
       return RTV.char(text);
     }
   });
-  registerSpecial("delete", (_nargout, args) => {
+  registerSpecialVoid("delete", (args) => {
     const io = requireFileIO();
     if (!io.deleteFile)
       throw new RuntimeError("delete is not available in this environment");
@@ -32198,7 +32886,6 @@ function registerSpecialBuiltins(rt) {
     for (const arg of margs) {
       io.deleteFile(toString(arg));
     }
-    return 0;
   });
   registerSpecial("rmdir", (nargout, args) => {
     const io = requireFileIO();
@@ -32221,6 +32908,34 @@ function registerSpecialBuiltins(rt) {
       RTV.char("")
     ];
   });
+  registerSpecial("movefile", (nargout, args) => {
+    const io = requireFileIO();
+    if (!io.movefile)
+      throw new RuntimeError("movefile is not available in this environment");
+    const margs = args.map((a) => ensureRuntimeValue(a));
+    if (margs.length < 1)
+      throw new RuntimeError("movefile requires at least 1 argument");
+    const source = toString(margs[0]);
+    const destination = margs.length >= 2 ? toString(margs[1]) : rt.system?.cwd() ?? ".";
+    let force = false;
+    if (margs.length >= 3) {
+      const third = toString(margs[2]);
+      if (third.toLowerCase() === "f") force = true;
+    }
+    const ok = io.movefile(source, destination, force);
+    if (nargout === 0) {
+      if (!ok)
+        throw new RuntimeError(
+          `movefile: cannot move '${source}' to '${destination}'`
+        );
+      return void 0;
+    }
+    return nargout <= 1 ? RTV.num(ok ? 1 : 0) : [
+      RTV.num(ok ? 1 : 0),
+      RTV.char(ok ? "" : `Cannot move '${source}' to '${destination}'`),
+      RTV.char("")
+    ];
+  });
   registerSpecial("unzip", (nargout, args) => {
     const io = requireFileIO();
     if (!io.unzip)
@@ -32272,7 +32987,7 @@ function registerSpecialBuiltins(rt) {
       const cellData = extracted.map((f) => RTV.char(f));
       return RTV.cell(cellData, [1, cellData.length]);
     }
-    return 0;
+    return void 0;
   });
   registerSpecial("dir", (nargout, args) => {
     const io = requireFileIO();
@@ -32369,7 +33084,7 @@ function registerSpecialBuiltins(rt) {
     const parts = margs.map((a) => toString(a));
     return RTV.char(parts.join("/"));
   });
-  registerSpecial("assignin", (_nargout, args) => {
+  registerSpecialVoid("assignin", (args) => {
     if (args.length < 3)
       throw new RuntimeError("assignin requires 3 arguments");
     const margs = args.map((a) => ensureRuntimeValue(a));
@@ -32384,7 +33099,6 @@ function registerSpecialBuiltins(rt) {
     } else {
       rt.setWorkspaceVariable(varName, args[2]);
     }
-    return 0;
   });
   registerSpecial("evalin", (_nargout, args) => {
     if (args.length < 2)
@@ -32405,13 +33119,12 @@ function registerSpecialBuiltins(rt) {
     }
     return val;
   });
-  registerSpecial("drawnow", () => {
+  registerSpecialVoid("drawnow", () => {
     rt.drawnow();
-    return 0;
   });
-  registerSpecial("pause", (_nargout, args) => {
+  registerSpecial("pause", (nargout, args) => {
     rt.pause(args[0] ?? 0);
-    return 0;
+    return nargout >= 1 ? RTV.char("on") : void 0;
   });
   registerSpecial("mfilename", (_nargout, args) => {
     const file = rt.$file ?? "";
@@ -32455,7 +33168,7 @@ function registerSpecialBuiltins(rt) {
       }
     }
     if (nargout >= 1) return RTV.char(rt.searchPaths.join(";"));
-    return 0;
+    return void 0;
   });
   registerSpecial("rmpath", (nargout, args) => {
     if (!rt.onPathChange) {
@@ -32475,11 +33188,11 @@ function registerSpecialBuiltins(rt) {
       }
     }
     if (nargout >= 1) return RTV.char(rt.searchPaths.join(";"));
-    return 0;
+    return void 0;
   });
-  registerSpecial("savepath", () => {
+  registerSpecial("savepath", (nargout) => {
     rt.output("Warning: savepath is a no-op in numbl\n");
-    return 0;
+    return nargout >= 1 ? RTV.num(0) : void 0;
   });
   registerSpecial("input", (_nargout, args) => {
     const margs = args.map((a) => ensureRuntimeValue(a));
@@ -32542,11 +33255,11 @@ function registerSpecialBuiltins(rt) {
     }
     return RTV.char(sys?.getEnv(toString(args[0])) ?? "");
   });
-  registerSpecial("setenv", (_nargout, args) => {
+  registerSpecialVoid("setenv", (args) => {
     const sys = rt.system;
     if (args.length === 2) {
       sys?.setEnv(toString(args[0]), toString(args[1]));
-      return 0;
+      return;
     }
     if (args.length === 1) {
       const d = args[0];
@@ -32554,20 +33267,26 @@ function registerSpecialBuiltins(rt) {
         for (const { key, value } of d.entries.values()) {
           sys?.setEnv(toString(key), toString(value));
         }
-        return 0;
+        return;
       }
       sys?.setEnv(toString(d), "");
-      return 0;
+      return;
     }
     throw new RuntimeError("setenv: invalid arguments");
   });
   registerSpecial("pwd", () => {
     return RTV.char(rt.system?.cwd() ?? "/");
   });
-  registerSpecial("cd", (_nargout, args) => {
+  registerSpecial("cd", (nargout, args) => {
     const sys = rt.system;
     const curDir = sys?.cwd() ?? "/";
-    if (args.length === 0) return RTV.char(curDir);
+    if (args.length === 0) {
+      if (nargout === 0) {
+        rt.output(curDir + "\n");
+        return void 0;
+      }
+      return RTV.char(curDir);
+    }
     const target = toString(args[0]);
     if (sys) {
       try {
@@ -32575,15 +33294,18 @@ function registerSpecialBuiltins(rt) {
       } catch {
         throw new RuntimeError(`Cannot change directory to '${target}'`);
       }
+      if (rt.onCwdChange) {
+        rt.onCwdChange(sys.cwd());
+      }
     }
-    return RTV.char(curDir);
+    return nargout >= 1 ? RTV.char(curDir) : void 0;
   });
-  registerSpecial("figure", (_nargout, args) => {
+  registerSpecial("figure", (nargout, args) => {
     const handle = args.length > 0 ? args[0] : 1;
     plotInstr(rt.plotInstructions, { type: "set_figure_handle", handle });
-    return 0;
+    return nargout >= 1 ? RTV.num(toNumber(ensureRuntimeValue(handle))) : void 0;
   });
-  registerSpecial("subplot", (_nargout, args) => {
+  registerSpecial("subplot", (nargout, args) => {
     if (args.length >= 3) {
       plotInstr(rt.plotInstructions, {
         type: "set_subplot",
@@ -32592,43 +33314,41 @@ function registerSpecialBuiltins(rt) {
         index: args[2]
       });
     }
-    return 0;
+    return nargout >= 1 ? RTV.num(0) : void 0;
   });
-  registerSpecial("title", (_nargout, args) => {
+  registerSpecial("title", (nargout, args) => {
     if (args.length > 0) {
       plotInstr(rt.plotInstructions, { type: "set_title", text: args[0] });
     }
-    return 0;
+    return nargout >= 1 ? RTV.num(0) : void 0;
   });
-  registerSpecial("xlabel", (_nargout, args) => {
+  registerSpecial("xlabel", (nargout, args) => {
     if (args.length > 0) {
       plotInstr(rt.plotInstructions, { type: "set_xlabel", text: args[0] });
     }
-    return 0;
+    return nargout >= 1 ? RTV.num(0) : void 0;
   });
-  registerSpecial("ylabel", (_nargout, args) => {
+  registerSpecial("ylabel", (nargout, args) => {
     if (args.length > 0) {
       plotInstr(rt.plotInstructions, { type: "set_ylabel", text: args[0] });
     }
-    return 0;
+    return nargout >= 1 ? RTV.num(0) : void 0;
   });
-  registerSpecial("hold", (_nargout, args) => {
+  registerSpecialVoid("hold", (args) => {
     if (args.length > 0) {
       plotInstr(rt.plotInstructions, { type: "set_hold", value: args[0] });
     }
-    return 0;
   });
-  registerSpecial("grid", (_nargout, args) => {
+  registerSpecialVoid("grid", (args) => {
     if (args.length > 0) {
       plotInstr(rt.plotInstructions, { type: "set_grid", value: args[0] });
     }
-    return 0;
   });
-  registerSpecial("legend", (_nargout, args) => {
+  registerSpecial("legend", (nargout, args) => {
     legendCall(rt.plotInstructions, args);
-    return 0;
+    return nargout >= 1 ? RTV.num(0) : void 0;
   });
-  registerSpecial("close", (_nargout, args) => {
+  registerSpecial("close", (nargout, args) => {
     if (args.length > 0) {
       const val = toString(args[0]);
       if (val === "all") {
@@ -32639,26 +33359,25 @@ function registerSpecialBuiltins(rt) {
     } else {
       plotInstr(rt.plotInstructions, { type: "close" });
     }
-    return 0;
+    return nargout >= 1 ? RTV.num(1) : void 0;
   });
-  registerSpecial("sgtitle", (_nargout, args) => {
+  registerSpecial("sgtitle", (nargout, args) => {
     if (args.length > 0) {
       plotInstr(rt.plotInstructions, { type: "set_sgtitle", text: args[0] });
     }
-    return 0;
+    return nargout >= 1 ? RTV.num(0) : void 0;
   });
-  registerSpecial("shading", (_nargout, args) => {
+  registerSpecialVoid("shading", (args) => {
     if (args.length > 0) {
       plotInstr(rt.plotInstructions, {
         type: "set_shading",
         shading: args[0]
       });
     }
-    return 0;
   });
-  registerSpecial("clf", () => {
+  registerSpecial("clf", (nargout) => {
     plotInstr(rt.plotInstructions, { type: "clf" });
-    return 0;
+    return nargout >= 1 ? RTV.num(1) : void 0;
   });
   registerSpecial("ode45", (nargout, args) => {
     return _ode45Impl(rt, nargout, args, dormandPrince45);
@@ -33114,6 +33833,8 @@ var Runtime = class _Runtime {
   classMethodCache = /* @__PURE__ */ new Map();
   /** Callback for addpath/rmpath — mutates search paths and rebuilds function index. */
   onPathChange = null;
+  /** Callback invoked after cd() to update the implicit cwd search path. */
+  onCwdChange = null;
   /** Reference to the active search paths (set by executeCode). */
   searchPaths = [];
   // Workspace accessors: varName → { get, set } closures over script-level vars
@@ -33393,23 +34114,26 @@ var Runtime = class _Runtime {
     if (e instanceof RuntimeError) {
       return RTV.struct(
         /* @__PURE__ */ new Map([
-          ["message", RTV.string(e.message)],
-          ["identifier", RTV.string(e.identifier)]
+          ["message", RTV.char(e.message)],
+          ["identifier", RTV.char(e.identifier)],
+          ["stack", buildStackField(e)]
         ])
       );
     }
     if (e instanceof Error) {
       return RTV.struct(
         /* @__PURE__ */ new Map([
-          ["message", RTV.string(e.message)],
-          ["identifier", RTV.string("")]
+          ["message", RTV.char(e.message)],
+          ["identifier", RTV.char("")],
+          ["stack", emptyStackField()]
         ])
       );
     }
     return RTV.struct(
       /* @__PURE__ */ new Map([
-        ["message", RTV.string(String(e))],
-        ["identifier", RTV.string("")]
+        ["message", RTV.char(String(e))],
+        ["identifier", RTV.char("")],
+        ["stack", emptyStackField()]
       ])
     );
   }
@@ -34241,6 +34965,63 @@ var rstr = (s) => {
   if (isRuntimeChar(s)) return s.value;
   throw new RuntimeError(`Expected string or char, got ${kstr(s)}`);
 };
+function emptyStackField() {
+  return RTV.structArray(["file", "name", "line"], []);
+}
+function buildStackField(e) {
+  const fieldNames = ["file", "name", "line"];
+  const frames = e.callStack;
+  if (!frames || frames.length === 0) {
+    if (e.file || e.line !== null) {
+      return RTV.structArray(fieldNames, [
+        RTV.struct(
+          /* @__PURE__ */ new Map([
+            ["file", RTV.char(e.file ?? "")],
+            ["name", RTV.char("")],
+            ["line", e.line ?? 0]
+          ])
+        )
+      ]);
+    }
+    return emptyStackField();
+  }
+  const elements = [];
+  const N = frames.length;
+  for (let i = N - 1; i >= 0; i--) {
+    let frameFile;
+    let frameLine;
+    if (i === N - 1) {
+      frameFile = e.file;
+      frameLine = e.line ?? 0;
+    } else {
+      const callerFrame = frames[i + 1];
+      frameFile = callerFrame.callerFile;
+      frameLine = callerFrame.callerLine;
+    }
+    elements.push(
+      RTV.struct(
+        /* @__PURE__ */ new Map([
+          ["file", RTV.char(frameFile ?? "")],
+          ["name", RTV.char(frames[i].name)],
+          ["line", frameLine]
+        ])
+      )
+    );
+  }
+  const outermost = frames[0];
+  if (outermost.callerFile && outermost.callerLine > 0) {
+    elements.push(
+      RTV.struct(
+        /* @__PURE__ */ new Map([
+          ["file", RTV.char(outermost.callerFile)],
+          ["name", RTV.char("")],
+          ["line", outermost.callerLine]
+        ])
+      )
+    );
+  }
+  return RTV.structArray(fieldNames, elements);
+}
 
 // src/numbl-core/helpers/reduction-helpers.ts
 function squeezeTrailing(shape) {
@@ -35248,6 +36029,89 @@ defineBuiltin({
   }
 });
 
+// src/numbl-core/interpreter/builtins/logical.ts
+var LOGICAL_KINDS = /* @__PURE__ */ new Set([
+  "number",
+  "boolean",
+  "tensor",
+  "sparse_matrix"
+]);
+function binaryLogicalMatch(argTypes) {
+  if (argTypes.length !== 2) return null;
+  if (!LOGICAL_KINDS.has(argTypes[0].kind)) return null;
+  if (!LOGICAL_KINDS.has(argTypes[1].kind)) return null;
+  if (argTypes[0].kind === "tensor" || argTypes[1].kind === "tensor") {
+    return [{ kind: "tensor", isComplex: false, isLogical: true }];
+  }
+  if (argTypes[0].kind === "sparse_matrix" || argTypes[1].kind === "sparse_matrix") {
+    return [{ kind: "tensor", isComplex: false, isLogical: true }];
+  }
+  return [{ kind: "boolean" }];
+}
+function isTensorLike(v) {
+  return isRuntimeTensor(v) || isRuntimeSparseMatrix(v);
+}
+function applyBinaryLogical(args, op, scalarFn) {
+  const a = args[0];
+  const b = args[1];
+  if (isTensorLike(a) || isTensorLike(b)) {
+    return elementWiseLogicalOp(a, b, op);
+  }
+  return RTV.logical(scalarFn(toBool(a), toBool(b)));
+}
+var orCase = {
+  match: binaryLogicalMatch,
+  apply: (args) => applyBinaryLogical(
+    args,
+    (x, y) => x !== 0 || y !== 0 ? 1 : 0,
+    (a, b) => a || b
+  )
+};
+defineBuiltin({
+  name: "or",
+  help: {
+    signatures: ["TF = or(A, B)"],
+    description: "Logical OR. Functional form of A | B; returns a logical scalar or tensor."
+  },
+  cases: [orCase]
+});
+var andCase = {
+  match: binaryLogicalMatch,
+  apply: (args) => applyBinaryLogical(
+    args,
+    (x, y) => x !== 0 && y !== 0 ? 1 : 0,
+    (a, b) => a && b
+  )
+};
+defineBuiltin({
+  name: "and",
+  help: {
+    signatures: ["TF = and(A, B)"],
+    description: "Logical AND. Functional form of A & B; returns a logical scalar or tensor."
+  },
+  cases: [andCase]
+});
+defineBuiltin({
+  name: "not",
+  help: {
+    signatures: ["TF = not(A)"],
+    description: "Logical negation. Functional form of ~A; returns a logical scalar or tensor."
+  },
+  cases: [
+    {
+      match: (argTypes) => {
+        if (argTypes.length !== 1) return null;
+        if (!LOGICAL_KINDS.has(argTypes[0].kind)) return null;
+        if (argTypes[0].kind === "tensor" || argTypes[0].kind === "sparse_matrix") {
+          return [{ kind: "tensor", isComplex: false, isLogical: true }];
+        }
+        return [{ kind: "boolean" }];
+      },
+      apply: (args) => not(args[0])
+    }
+  ]
+});
+
 // src/numbl-core/interpreter/builtins/utility.ts
 function sparseToDense2(S) {
   const data = new FloatXArray(S.m * S.n);
@@ -35356,7 +36220,7 @@ defineBuiltin({
     {
       match: (argTypes) => {
         if (argTypes.length < 1) return null;
-        return [{ kind: "number" }];
+        return [];
       },
       apply: (args) => {
         const v = args[0];
@@ -35377,7 +36241,7 @@ defineBuiltin({
           const msg = args.length > 1 ? textValue(args[1]) ?? String(args[1]) : "Assertion failed";
           throw new Error(msg);
         }
-        return 0;
+        return void 0;
       }
     }
   ]
@@ -35388,7 +36252,7 @@ defineBuiltin({
     {
       match: (argTypes) => {
         if (argTypes.length === 0) return null;
-        return [{ kind: "number" }];
+        return [];
       },
       apply: (args) => {
         const first = textValue(args[0]) ?? String(args[0]);
@@ -36060,6 +36924,19 @@ defineBuiltin({
   name: "NaN",
   cases: arrayConstructorCases(nanFill, NaN)
 });
+function infFill(shape) {
+  const data = new FloatXArray(numel(shape));
+  data.fill(Infinity);
+  return makeTensor(data, void 0, shape);
+}
+defineBuiltin({
+  name: "inf",
+  cases: arrayConstructorCases(infFill, Infinity)
+});
+defineBuiltin({
+  name: "Inf",
+  cases: arrayConstructorCases(infFill, Infinity)
+});
 defineBuiltin({
   name: "eye",
   cases: arrayConstructorCases(
@@ -36897,19 +37774,33 @@ function preserveTextType(t) {
   if (t.kind === "string") return { kind: "string" };
   return null;
 }
+function applyTextFn(v, fn) {
+  if (isRuntimeCell(v)) {
+    const out = new Array(v.data.length);
+    for (let i = 0; i < v.data.length; i++) {
+      out[i] = applyTextFn(v.data[i], fn);
+    }
+    return RTV.cell(out, [...v.shape]);
+  }
+  if (isRuntimeChar(v)) return RTV.char(fn(v.value));
+  if (isRuntimeString(v)) return RTV.string(fn(toString(v)));
+  return v;
+}
 function textPreserveResolve(fn) {
   return (argTypes) => {
     if (argTypes.length !== 1) return null;
-    const out = preserveTextType(argTypes[0]);
+    const t = argTypes[0];
+    if (t.kind === "cell") {
+      return {
+        outputTypes: [{ kind: "cell" }],
+        apply: (args) => applyTextFn(args[0], fn)
+      };
+    }
+    const out = preserveTextType(t);
     if (!out) return null;
     return {
       outputTypes: [out],
-      apply: (args) => {
-        const v = args[0];
-        const s = toString(v);
-        const result = fn(s);
-        return isRuntimeChar(v) ? RTV.char(result) : RTV.string(result);
-      }
+      apply: (args) => applyTextFn(args[0], fn)
     };
   };
 }
@@ -38960,7 +39851,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (nargout !== 1 || argTypes.length < 1 || argTypes.length > 2)
+        if (nargout > 1 || argTypes.length < 1 || argTypes.length > 2)
           return null;
         if (!isNumericJitType(argTypes[0])) return null;
         return [NUM];
@@ -39077,7 +39968,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (nargout !== 1 || argTypes.length < 1 || argTypes.length > 3)
+        if (nargout > 1 || argTypes.length < 1 || argTypes.length > 3)
           return null;
         if (!isNumericJitType(argTypes[0])) return null;
         const a = argTypes[0];
@@ -39156,7 +40047,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (nargout !== 1 || argTypes.length !== 2) return null;
+        if (nargout > 1 || argTypes.length !== 2) return null;
         if (!isNumericJitType(argTypes[0]) || !isNumericJitType(argTypes[1]))
           return null;
         const hasTensor = argTypes.some((t) => t.kind === "tensor");
@@ -39240,7 +40131,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (argTypes.length !== 1 || nargout !== 1) return null;
+        if (argTypes.length !== 1 || nargout > 1) return null;
         if (!isNumericJitType(argTypes[0])) return null;
         const hasComplex = argTypes[0].kind === "complex_or_number" || argTypes[0].kind === "tensor" && argTypes[0].isComplex;
         return [hasComplex ? COMPLEX_OR_NUM : NUM];
@@ -39352,7 +40243,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (argTypes.length !== 1 || nargout !== 1) return null;
+        if (argTypes.length !== 1 || nargout > 1) return null;
         if (!isNumericJitType(argTypes[0])) return null;
         return [NUM];
       },
@@ -39377,7 +40268,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (nargout !== 1) return null;
+        if (nargout > 1) return null;
         if (argTypes.length !== 2 && argTypes.length !== 3) return null;
         if (!isNumericJitType(argTypes[0]) || !isNumericJitType(argTypes[1]))
           return null;
@@ -39443,7 +40334,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (argTypes.length !== 1 || nargout !== 1) return null;
+        if (argTypes.length !== 1 || nargout > 1) return null;
         if (!isNumericJitType(argTypes[0])) return null;
         const a = argTypes[0];
         if (a.kind === "number" || a.kind === "boolean") return [NUM];
@@ -39556,11 +40447,11 @@ function invComplexJS(dataRe, dataIm, n) {
 registerIBuiltin({
   name: "svd",
   resolve: (argTypes, nargout) => {
-    if (nargout < 1 || nargout > 3 || argTypes.length < 1 || argTypes.length > 2)
+    if (nargout < 0 || nargout > 3 || argTypes.length < 1 || argTypes.length > 2)
       return null;
     if (!isNumericJitType(argTypes[0])) return null;
     const c = tensorType();
-    if (nargout === 1)
+    if (nargout <= 1)
       return { outputTypes: [c], apply: (args, n) => svdApply(args, n) };
     return { outputTypes: [c, c, c], apply: (args, n) => svdApply(args, n) };
   }
@@ -39571,7 +40462,7 @@ function svdApply(args, nargout) {
   const A = args[0];
   if (isRuntimeNumber(A)) {
     const val = Math.abs(A);
-    if (nargout === 1) return RTV.tensor(new FloatXArray([val]), [1, 1]);
+    if (nargout <= 1) return RTV.tensor(new FloatXArray([val]), [1, 1]);
     return [
       RTV.tensor(new FloatXArray([A >= 0 ? 1 : -1]), [1, 1]),
       RTV.tensor(new FloatXArray([val]), [1, 1]),
@@ -39598,7 +40489,7 @@ function svdApply(args, nargout) {
       nargout === 3
     );
     if (!result) throw new RuntimeError("svd: complex SVD failed");
-    if (nargout === 1) return RTV.tensor(new FloatXArray(result.S), [k, 1]);
+    if (nargout <= 1) return RTV.tensor(new FloatXArray(result.S), [k, 1]);
     const uCols = econ ? k : m;
     const vCols = econ ? k : n;
     return [
@@ -39619,7 +40510,7 @@ function svdApply(args, nargout) {
   if (bridge?.svd) {
     const result = bridge.svd(toF64(A.data), m, n, econ, nargout === 3);
     if (result) {
-      if (nargout === 1) return RTV.tensor(new FloatXArray(result.S), [k, 1]);
+      if (nargout <= 1) return RTV.tensor(new FloatXArray(result.S), [k, 1]);
       const uCols = econ ? k : m;
       const vCols = econ ? k : n;
       return [
@@ -39689,12 +40580,12 @@ function powerIterationEigenvalues(A_data, n, numEigenvalues) {
 registerIBuiltin({
   name: "qr",
   resolve: (argTypes, nargout) => {
-    if (nargout < 1 || nargout > 3 || argTypes.length < 1 || argTypes.length > 2)
+    if (nargout < 0 || nargout > 3 || argTypes.length < 1 || argTypes.length > 2)
       return null;
     if (!isNumericJitType(argTypes[0])) return null;
     const isComplex2 = argTypes[0].kind === "tensor" && argTypes[0].isComplex;
     const t = tensorType(isComplex2 || void 0);
-    if (nargout === 1)
+    if (nargout <= 1)
       return { outputTypes: [t], apply: (args, n) => qrApply(args, n) };
     if (nargout === 3)
       return {
@@ -39711,7 +40602,7 @@ function qrApply(args, nargout) {
   if (isRuntimeNumber(A)) {
     const val = A;
     const s = val >= 0 ? 1 : -1;
-    if (nargout === 1) return RTV.tensor(new FloatXArray([s * val]), [1, 1]);
+    if (nargout <= 1) return RTV.tensor(new FloatXArray([s * val]), [1, 1]);
     if (nargout === 3)
       return [
         RTV.tensor(new FloatXArray([s]), [1, 1]),
@@ -39744,7 +40635,7 @@ function qrApply(args, nargout) {
       nargout === 2
     );
     if (!result) throw new RuntimeError("qr: complex QR failed");
-    if (nargout === 1) {
+    if (nargout <= 1) {
       const rRows = econ ? k : m;
       return RTV.tensor(
         new FloatXArray(result.RRe),
@@ -39770,7 +40661,7 @@ function qrApply(args, nargout) {
   if (bridge?.qr) {
     const result = bridge.qr(toF64(A.data), m, n, econ, nargout === 2);
     if (result) {
-      if (nargout === 1)
+      if (nargout <= 1)
         return RTV.tensor(new FloatXArray(result.R), [econ ? k : m, n]);
       const qCols = econ ? k : m;
       return [
@@ -39813,7 +40704,7 @@ function qrApply(args, nargout) {
         R_data[colMajorIndex(j + i, c, m)] -= scale * v[i];
     }
   }
-  if (nargout === 1) {
+  if (nargout <= 1) {
     if (econ) {
       const R_econ = new FloatXArray(k * n);
       for (let r = 0; r < k; r++)
@@ -40029,11 +40920,11 @@ function qrPivotApply(A, m, n, k, econ) {
 registerIBuiltin({
   name: "lu",
   resolve: (argTypes, nargout) => {
-    if (nargout < 1 || nargout > 3) return null;
+    if (nargout < 0 || nargout > 3) return null;
     if (argTypes.length < 1 || argTypes.length > 2) return null;
     if (!isNumericJitType(argTypes[0])) return null;
     const t = tensorType();
-    if (nargout === 1)
+    if (nargout <= 1)
       return { outputTypes: [t], apply: (args, n) => luApply(args, n) };
     if (nargout === 2)
       return { outputTypes: [t, t], apply: (args, n) => luApply(args, n) };
@@ -40052,7 +40943,7 @@ function luApply(args, nargout) {
     if (nargout <= 2) {
       const L2 = RTV.tensor(new FloatXArray([1]), [1, 1]);
       const U2 = RTV.tensor(new FloatXArray([val]), [1, 1]);
-      if (nargout === 1) return L2;
+      if (nargout <= 1) return L2;
       return [L2, U2];
     }
     const L = RTV.tensor(new FloatXArray([1]), [1, 1]);
@@ -40090,7 +40981,7 @@ function luApply(args, nargout) {
       if (U_im && LU_im) U_im[i + j * k] = LU_im[i + j * m];
     }
   }
-  if (nargout === 1)
+  if (nargout <= 1)
     return RTV.tensor(
       new FloatXArray(LU_re),
       [m, n],
@@ -40166,11 +41057,11 @@ function ipivToPermVector(ipiv, m) {
 registerIBuiltin({
   name: "eig",
   resolve: (argTypes, nargout) => {
-    if (nargout < 1 || nargout > 3 || argTypes.length < 1 || argTypes.length > 3)
+    if (nargout < 0 || nargout > 3 || argTypes.length < 1 || argTypes.length > 3)
       return null;
     if (!isNumericJitType(argTypes[0])) return null;
     const c = tensorType(true);
-    if (nargout === 1)
+    if (nargout <= 1)
       return { outputTypes: [c], apply: (args, n) => eigApply(args, n) };
     if (nargout === 2)
       return { outputTypes: [c, c], apply: (args, n) => eigApply(args, n) };
@@ -40184,7 +41075,7 @@ function eigApply(args, nargout) {
   const { balance, outputForm } = parseEigOptionsRuntime(args);
   if (isRuntimeNumber(A)) {
     const val = A;
-    if (nargout === 1) return RTV.num(val);
+    if (nargout <= 1) return RTV.num(val);
     const V = RTV.tensor(new FloatXArray([1]), [1, 1]);
     if (nargout === 2) {
       if (outputForm === "vector") return [V, RTV.num(val)];
@@ -40213,7 +41104,7 @@ function eigApply(args, nargout) {
     );
     if (!result2) throw new RuntimeError("eig: complex eig failed");
     const { wRe, wIm, VLRe, VLIm, VRRe, VRIm } = result2;
-    if (nargout === 1) return maybeComplexTensor(wRe, [n, 1], wIm);
+    if (nargout <= 1) return maybeComplexTensor(wRe, [n, 1], wIm);
     const Vout2 = computeVR && VRRe && VRIm ? maybeComplexTensor(VRRe, [n, n], VRIm) : RTV.tensor(new FloatXArray(n * n), [n, n]);
     const Dout2 = outputForm === "vector" ? maybeComplexTensor(wRe, [n, 1], wIm) : buildDiagMatrix(wRe, wIm, n);
     if (nargout === 2) return [Vout2, Dout2];
@@ -40226,7 +41117,7 @@ function eigApply(args, nargout) {
   if (!result) throw new RuntimeError("eig: LAPACK eig failed");
   const { wr, wi, VL, VR } = result;
   const hasComplex = wi.some((v) => v !== 0);
-  if (nargout === 1) return maybeComplexTensor(wr, [n, 1], wi);
+  if (nargout <= 1) return maybeComplexTensor(wr, [n, 1], wi);
   const Vout = computeVR && VR ? buildEigenvectorMatrix(VR, wi, n, hasComplex) : RTV.tensor(new FloatXArray(n * n), [n, n]);
   const Dout = outputForm === "vector" ? maybeComplexTensor(wr, [n, 1], wi) : buildDiagMatrix(wr, wi, n);
   if (nargout === 2) return [Vout, Dout];
@@ -40250,11 +41141,11 @@ function parseEigOptionsRuntime(args) {
 registerIBuiltin({
   name: "chol",
   resolve: (argTypes, nargout) => {
-    if (nargout < 1 || nargout > 3 || argTypes.length < 1 || argTypes.length > 3)
+    if (nargout < 0 || nargout > 3 || argTypes.length < 1 || argTypes.length > 3)
       return null;
     if (!isNumericJitType(argTypes[0])) return null;
     const t = tensorType();
-    if (nargout === 1)
+    if (nargout <= 1)
       return { outputTypes: [t], apply: (args, n) => cholApply(args, n) };
     if (nargout === 2)
       return { outputTypes: [t, NUM], apply: (args, n) => cholApply(args, n) };
@@ -40415,7 +41306,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (argTypes.length !== 2 || nargout !== 1) return null;
+        if (argTypes.length !== 2 || nargout > 1) return null;
         if (!isNumericJitType(argTypes[0]) || !isNumericJitType(argTypes[1]))
           return null;
         return [tensorType()];
@@ -40458,7 +41349,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (nargout !== 1 || argTypes.length < 1 || argTypes.length > 2)
+        if (nargout > 1 || argTypes.length < 1 || argTypes.length > 2)
           return null;
         if (!isNumericJitType(argTypes[0])) return null;
         return [NUM];
@@ -40519,7 +41410,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (nargout !== 1 || argTypes.length < 1 || argTypes.length > 2)
+        if (nargout > 1 || argTypes.length < 1 || argTypes.length > 2)
           return null;
         if (!isNumericJitType(argTypes[0])) return null;
         return [NUM];
@@ -40567,7 +41458,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (nargout !== 1 || argTypes.length < 1 || argTypes.length > 2)
+        if (nargout > 1 || argTypes.length < 1 || argTypes.length > 2)
           return null;
         if (!isNumericJitType(argTypes[0])) return null;
         const a = argTypes[0];
@@ -40664,7 +41555,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (nargout !== 1 || argTypes.length !== 2) return null;
+        if (nargout > 1 || argTypes.length !== 2) return null;
         if (!isNumericJitType(argTypes[0]) || !isNumericJitType(argTypes[1]))
           return null;
         return [tensorType()];
@@ -40672,11 +41563,15 @@ defineBuiltin({
       apply: (args) => {
         if (args.length !== 2)
           throw new RuntimeError("kron requires 2 arguments");
-        const a = args[0], b = args[1];
-        const A = isRuntimeNumber(a) ? RTV.tensor(new FloatXArray([a]), [1, 1]) : a;
-        const B = isRuntimeNumber(b) ? RTV.tensor(new FloatXArray([b]), [1, 1]) : b;
-        if (!isRuntimeTensor(A) || !isRuntimeTensor(B))
+        const coerce = (v) => {
+          if (isRuntimeNumber(v))
+            return RTV.tensor(new FloatXArray([v]), [1, 1]);
+          if (isRuntimeSparseMatrix(v)) return sparseToDense(v);
+          if (isRuntimeTensor(v)) return v;
           throw new RuntimeError("kron: arguments must be numeric");
+        };
+        const A = coerce(args[0]);
+        const B = coerce(args[1]);
         const [m, n] = tensorSize2D(A);
         const [p2, q] = tensorSize2D(B);
         const rows = m * p2, cols = n * q;
@@ -40700,7 +41595,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (nargout !== 1 || argTypes.length === 0) return null;
+        if (nargout > 1 || argTypes.length === 0) return null;
         if (!argTypes.every(isNumericJitType)) return null;
         return [tensorType()];
       },
@@ -40743,7 +41638,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (nargout !== 1) return null;
+        if (nargout > 1) return null;
         if (argTypes.length !== 2 && argTypes.length !== 4) return null;
         const xIdx = 0, yIdx = argTypes.length === 4 ? 2 : 1;
         if (!isNumericJitType(argTypes[xIdx]) || !isNumericJitType(argTypes[yIdx]))
@@ -40872,7 +41767,7 @@ defineBuiltin({
   cases: [
     {
       match: (argTypes, nargout) => {
-        if (nargout !== 1 || argTypes.length !== 1) return null;
+        if (nargout > 1 || argTypes.length !== 1) return null;
         if (argTypes[0].kind !== "tensor") return null;
         return [tensorType(argTypes[0].isComplex)];
       },
@@ -42994,6 +43889,65 @@ defineBuiltin({
     }
   ]
 });
+defineBuiltin({
+  name: "bitget",
+  cases: [
+    {
+      match: (argTypes) => {
+        if (argTypes.length !== 2) return null;
+        return [{ kind: "unknown" }];
+      },
+      // bitget(A, bit) returns bit number `bit` (1-based, 1 = LSB) of each
+      // element of A.  MATLAB supports vector `bit` with broadcasting; we
+      // match the scalar-or-same-shape rules used by the other bitwise ops.
+      apply: (args) => bitwiseOp(
+        args[0],
+        args[1],
+        (a, bit) => {
+          const b = Math.round(bit);
+          if (b < 1) return 0;
+          if (b <= 31) return a >>> b - 1 & 1;
+          const bi = BigInt(a);
+          return Number(bi >> BigInt(b - 1) & 1n);
+        },
+        "bitget"
+      )
+    }
+  ]
+});
+defineBuiltin({
+  name: "bitset",
+  cases: [
+    {
+      match: (argTypes) => {
+        if (argTypes.length < 2 || argTypes.length > 3) return null;
+        return [{ kind: "unknown" }];
+      },
+      // bitset(A, bit)     → set bit to 1
+      // bitset(A, bit, v)  → set bit to v (0 or 1)
+      apply: (args) => {
+        const v = args.length >= 3 ? Math.round(toNumber(args[2])) : 1;
+        return bitwiseOp(
+          args[0],
+          args[1],
+          (a, bit) => {
+            const b = Math.round(bit);
+            if (b < 1) return a;
+            if (b <= 31) {
+              const mask2 = 1 << b - 1;
+              return v ? a | mask2 : a & ~mask2;
+            }
+            const bi = BigInt(a);
+            const mask = 1n << BigInt(b - 1);
+            const out = v ? bi | mask : bi & ~mask;
+            return Number(out);
+          },
+          "bitset"
+        );
+      }
+    }
+  ]
+});
 function coordTransform(name, nArgs, nOut, fn) {
   defineBuiltin({
     name,
@@ -44123,6 +45077,131 @@ defineBuiltin({
     }
   ]
 });
+var INT_RANGES = [
+  { name: "int8", min: -128, max: 127 },
+  { name: "int16", min: -32768, max: 32767 },
+  { name: "int32", min: -2147483648, max: 2147483647 },
+  // int64/uint64 can't represent their full native range as doubles;
+  // clamp at Number.MAX_SAFE_INTEGER to avoid silent precision loss.
+  {
+    name: "int64",
+    min: -Number.MAX_SAFE_INTEGER,
+    max: Number.MAX_SAFE_INTEGER
+  },
+  { name: "uint8", min: 0, max: 255 },
+  { name: "uint16", min: 0, max: 65535 },
+  { name: "uint32", min: 0, max: 4294967295 },
+  { name: "uint64", min: 0, max: Number.MAX_SAFE_INTEGER }
+];
+function saturateRoundToward(x, min, max) {
+  if (isNaN(x)) return 0;
+  const r = x >= 0 ? Math.floor(x + 0.5) : -Math.floor(-x + 0.5);
+  if (r < min) return min;
+  if (r > max) return max;
+  return r;
+}
+for (const { name, min, max } of INT_RANGES) {
+  defineBuiltin({
+    name,
+    cases: [
+      {
+        match: (argTypes) => {
+          if (argTypes.length !== 1) return null;
+          const a = argTypes[0];
+          if (a.kind === "number" || a.kind === "boolean" || a.kind === "char" || a.kind === "complex_or_number")
+            return [{ kind: "number" }];
+          if (a.kind === "tensor")
+            return [
+              {
+                kind: "tensor",
+                isComplex: false,
+                shape: a.shape,
+                ndim: a.ndim
+              }
+            ];
+          return null;
+        },
+        apply: (args) => {
+          const v = args[0];
+          if (isRuntimeNumber(v))
+            return RTV.num(saturateRoundToward(v, min, max));
+          if (isRuntimeLogical(v)) return RTV.num(v ? 1 : 0);
+          if (isRuntimeComplexNumber(v))
+            return RTV.num(saturateRoundToward(v.re, min, max));
+          if (isRuntimeChar(v)) {
+            if (v.value.length === 0)
+              return RTV.tensor(new FloatXArray(0), [0, 0]);
+            if (v.value.length === 1)
+              return RTV.num(
+                saturateRoundToward(v.value.charCodeAt(0), min, max)
+              );
+            const out = new FloatXArray(v.value.length);
+            for (let i = 0; i < v.value.length; i++) {
+              out[i] = saturateRoundToward(v.value.charCodeAt(i), min, max);
+            }
+            return RTV.row(Array.from(out));
+          }
+          if (isRuntimeTensor(v)) {
+            const data = new FloatXArray(v.data.length);
+            for (let i = 0; i < v.data.length; i++) {
+              data[i] = saturateRoundToward(v.data[i], min, max);
+            }
+            return RTV.tensor(data, [...v.shape]);
+          }
+          return RTV.num(saturateRoundToward(toNumber(v), min, max));
+        }
+      }
+    ]
+  });
+}
+defineBuiltin({
+  name: "idivide",
+  cases: [
+    {
+      match: (argTypes) => {
+        if (argTypes.length < 2 || argTypes.length > 3) return null;
+        return [{ kind: "unknown" }];
+      },
+      apply: (args) => {
+        const divFix = (a2, b2) => {
+          if (b2 === 0) {
+            return 0;
+          }
+          const q = a2 / b2;
+          return q >= 0 ? Math.floor(q) : -Math.floor(-q);
+        };
+        const a = args[0];
+        const b = args[1];
+        if (isRuntimeNumber(a) && isRuntimeNumber(b)) {
+          return RTV.num(divFix(a, b));
+        }
+        if (isRuntimeTensor(a) && isRuntimeNumber(b)) {
+          const bv = b;
+          const data = new FloatXArray(a.data.length);
+          for (let i = 0; i < a.data.length; i++)
+            data[i] = divFix(a.data[i], bv);
+          return RTV.tensor(data, [...a.shape]);
+        }
+        if (isRuntimeNumber(a) && isRuntimeTensor(b)) {
+          const av = a;
+          const data = new FloatXArray(b.data.length);
+          for (let i = 0; i < b.data.length; i++)
+            data[i] = divFix(av, b.data[i]);
+          return RTV.tensor(data, [...b.shape]);
+        }
+        if (isRuntimeTensor(a) && isRuntimeTensor(b)) {
+          if (a.data.length !== b.data.length)
+            throw new RuntimeError("idivide: arrays must be the same size");
+          const data = new FloatXArray(a.data.length);
+          for (let i = 0; i < a.data.length; i++)
+            data[i] = divFix(a.data[i], b.data[i]);
+          return RTV.tensor(data, [...a.shape]);
+        }
+        throw new RuntimeError("idivide: arguments must be numeric");
+      }
+    }
+  ]
+});
 defineBuiltin({
   name: "logical",
   cases: [
@@ -44734,9 +45813,11 @@ registerIBuiltin({
 // src/numbl-core/helpers/prng.ts
 var _rngState = null;
 var _rngSeed = 0;
+var _bmSpare = null;
 function setRngShuffle() {
   _rngState = null;
   _rngSeed = 0;
+  _bmSpare = null;
 }
 function setRngSeed(seed) {
   _rngSeed = seed;
@@ -44752,6 +45833,7 @@ function splitmix32(seed) {
   };
 }
 function seedRng(seed) {
+  _bmSpare = null;
   const sm = splitmix32(seed);
   _rngState = new Uint32Array([sm(), sm(), sm(), sm()]);
   if (_rngState[0] === 0 && _rngState[1] === 0 && _rngState[2] === 0 && _rngState[3] === 0) {
@@ -44778,10 +45860,60 @@ function rngRandom() {
   return (xoshiro128ss() >>> 0) / 4294967296;
 }
 function boxMullerRandom() {
-  let u = 0, v = 0;
-  while (u === 0) u = rngRandom();
-  while (v === 0) v = rngRandom();
-  return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+  if (_bmSpare !== null) {
+    const s2 = _bmSpare;
+    _bmSpare = null;
+    return s2;
+  }
+  let u, v, s;
+  do {
+    u = 2 * rngRandom() - 1;
+    v = 2 * rngRandom() - 1;
+    s = u * u + v * v;
+  } while (s >= 1 || s === 0);
+  const mul = Math.sqrt(-2 * Math.log(s) / s);
+  _bmSpare = v * mul;
+  return u * mul;
+}
+function fillRandn(data) {
+  if (_rngState !== null) {
+    const bridge = getLapackBridge();
+    if (bridge?.fillRandn) {
+      const r = bridge.fillRandn(
+        _rngState,
+        data.length,
+        _bmSpare ?? 0,
+        _bmSpare !== null
+      );
+      _bmSpare = r.hasSpare ? r.spare : null;
+      if (data instanceof Float64Array) {
+        data.set(r.data);
+      } else {
+        for (let i2 = 0; i2 < data.length; i2++) data[i2] = r.data[i2];
+      }
+      return;
+    }
+  }
+  const n = data.length;
+  let i = 0;
+  if (_bmSpare !== null && i < n) {
+    data[i++] = _bmSpare;
+    _bmSpare = null;
+  }
+  for (; i + 1 < n; i += 2) {
+    let u, v, s;
+    do {
+      u = 2 * rngRandom() - 1;
+      v = 2 * rngRandom() - 1;
+      s = u * u + v * v;
+    } while (s >= 1 || s === 0);
+    const mul = Math.sqrt(-2 * Math.log(s) / s);
+    data[i] = u * mul;
+    data[i + 1] = v * mul;
+  }
+  if (i < n) {
+    data[i] = boxMullerRandom();
+  }
 }
 function getRngStateStruct() {
   const stateArray = _rngState ? RTV.tensor(new FloatXArray(Array.from(_rngState).map((v) => v)), [4, 1]) : RTV.tensor(new FloatXArray(0), [0, 1]);
@@ -44849,7 +45981,7 @@ registerIBuiltin({
     };
   }
 });
-function registerRandBuiltin(name, gen) {
+function registerRandBuiltin(name, gen, bulkFill) {
   defineBuiltin({
     name,
     cases: [
@@ -44888,7 +46020,11 @@ function registerRandBuiltin(name, gen) {
           if (shape.length === 1) shape.push(shape[0]);
           const n = numel(shape);
           const data = new FloatXArray(n);
-          for (let i = 0; i < n; i++) data[i] = gen();
+          if (bulkFill) {
+            bulkFill(data);
+          } else {
+            for (let i = 0; i < n; i++) data[i] = gen();
+          }
           return RTV.tensor(data, shape);
         }
       }
@@ -44896,7 +46032,7 @@ function registerRandBuiltin(name, gen) {
   });
 }
 registerRandBuiltin("rand", rngRandom);
-registerRandBuiltin("randn", boxMullerRandom);
+registerRandBuiltin("randn", boxMullerRandom, fillRandn);
 defineBuiltin({
   name: "randi",
   cases: [
@@ -45341,136 +46477,6 @@ registerIBuiltin({
   }
 });
 
-// src/numbl-core/interpreter/builtins/time-system.ts
-var ticTime = 0;
-defineBuiltin({
-  name: "tic",
-  cases: [
-    {
-      match: (argTypes) => argTypes.length === 0 ? [{ kind: "number" }] : null,
-      apply: () => {
-        ticTime = performance.now();
-        return RTV.num(ticTime / 1e3);
-      }
-    }
-  ]
-});
-defineBuiltin({
-  name: "toc",
-  cases: [
-    {
-      match: (argTypes) => argTypes.length === 0 ? [{ kind: "number" }] : null,
-      apply: () => RTV.num((performance.now() - ticTime) / 1e3)
-    }
-  ]
-});
-defineBuiltin({
-  name: "clock",
-  cases: [
-    {
-      match: (argTypes) => argTypes.length === 0 ? [{ kind: "tensor", isComplex: false, shape: [1, 6] }] : null,
-      apply: () => {
-        const now = /* @__PURE__ */ new Date();
-        return RTV.tensor(
-          new FloatXArray([
-            now.getFullYear(),
-            now.getMonth() + 1,
-            now.getDate(),
-            now.getHours(),
-            now.getMinutes(),
-            now.getSeconds() + now.getMilliseconds() / 1e3
-          ]),
-          [1, 6]
-        );
-      }
-    }
-  ]
-});
-defineBuiltin({
-  name: "etime",
-  cases: [
-    {
-      match: (argTypes) => argTypes.length === 2 ? [{ kind: "number" }] : null,
-      apply: (args) => {
-        const t1 = args[0];
-        const t0 = args[1];
-        if (!isRuntimeTensor(t1) || !isRuntimeTensor(t0))
-          throw new RuntimeError("etime: arguments must be clock vectors");
-        const toMs = (t) => {
-          const d = new Date(
-            t.data[0],
-            t.data[1] - 1,
-            t.data[2],
-            t.data[3],
-            t.data[4],
-            Math.floor(t.data[5]),
-            t.data[5] % 1 * 1e3
-          );
-          return d.getTime();
-        };
-        return RTV.num((toMs(t1) - toMs(t0)) / 1e3);
-      }
-    }
-  ]
-});
-defineBuiltin({
-  name: "version",
-  cases: [
-    {
-      match: (argTypes) => argTypes.length === 0 ? [{ kind: "char" }] : null,
-      apply: () => RTV.char("9.14.0")
-    }
-  ]
-});
-function getComputerStrings() {
-  if (typeof process === "undefined") {
-    return { str: "BROWSER", arch: "browser" };
-  }
-  const platform = process.platform;
-  const cpuArch = process.arch;
-  if (platform === "win32") return { str: "PCWIN64", arch: "win64" };
-  if (platform === "darwin") {
-    if (cpuArch === "arm64") return { str: "MACA64", arch: "maca64" };
-    return { str: "MACI64", arch: "maci64" };
-  }
-  return { str: "GLNXA64", arch: "glnxa64" };
-}
-registerIBuiltin({
-  name: "computer",
-  resolve: () => ({
-    outputTypes: [{ kind: "unknown" }],
-    apply: (args, nargout) => {
-      const info = getComputerStrings();
-      if (args.length >= 1 && isRuntimeChar(args[0])) {
-        const arg = toString(args[0]);
-        if (arg === "arch") return RTV.char(info.arch);
-        throw new RuntimeError(`computer: unknown argument '${arg}'`);
-      }
-      const maxsize = 2 ** 48 - 1;
-      const endian = RTV.char("L");
-      if (nargout <= 1) return RTV.char(info.str);
-      if (nargout === 2) return [RTV.char(info.str), RTV.num(maxsize)];
-      return [RTV.char(info.str), RTV.num(maxsize), endian];
-    }
-  })
-});
-var _platform = typeof process !== "undefined" ? process.platform : "linux";
-for (const [name, val] of [
-  ["ismac", _platform === "darwin"],
-  ["ispc", _platform === "win32"],
-  ["isunix", _platform !== "win32"]
-]) {
-  defineBuiltin({
-    name,
-    cases: [
-      {
-        match: (argTypes) => argTypes.length === 0 ? [{ kind: "boolean" }] : null,
-        apply: () => RTV.logical(val)
-      }
-    ]
-  });
-}
-
 // src/numbl-core/interpreter/builtins/sparse.ts
 function toNumericArray(v, name) {
   if (isRuntimeNumber(v)) return [v];
@@ -48330,7 +49336,7 @@ function getSourceLine(getSource, file, line) {
 }
 
 // src/numbl-core/version.ts
-var NUMBL_VERSION = "0.1.2";
+var NUMBL_VERSION = "0.1.4";
 
 // src/cli-repl.ts
 import { createInterface } from "readline";
@@ -49592,9 +50598,7 @@ function lowerStmt(ctx, stmt) {
       result = lowerAssign(ctx, stmt);
       break;
     case "ExprStmt":
-      if (!stmt.suppressed) return null;
-      result = lowerExprStmt(ctx, stmt);
-      break;
+      return null;
     case "If":
       result = lowerIf(ctx, stmt);
       break;
@@ -49669,11 +50673,6 @@ function lowerMultiAssign(ctx, stmt) {
     }
   ];
 }
-function lowerExprStmt(ctx, stmt) {
-  const expr = lowerExpr(ctx, stmt.expr);
-  if (!expr) return null;
-  return [{ tag: "ExprStmt", expr }];
-}
 function lowerIf(ctx, stmt) {
   const cond = lowerExpr(ctx, stmt.cond);
   if (!cond) return null;
@@ -50742,10 +51741,14 @@ function execStmt(stmt) {
   }
   switch (stmt.type) {
     case "ExprStmt": {
-      const val = this.evalExpr(stmt.expr);
+      const val = this.evalExprNargout(stmt.expr, 0);
       const singleVal = Array.isArray(val) ? val[0] : val;
+      if (singleVal === void 0) {
+        return null;
+      }
       const rv = ensureRuntimeValue(singleVal);
       this.ans = rv;
+      this.env.set("ans", rv);
       if (!stmt.suppressed && !this.isOutputExpr(stmt.expr)) {
         this.rt.displayResult(rv);
       }
@@ -50766,19 +51769,25 @@ function execStmt(stmt) {
       if (stmt.lvalues.length === 1 && stmt.lvalues[0].type === "IndexCell") {
         const lv = stmt.lvalues[0];
         const cellBase = lv.base.type === "Ident" ? this.env.get(lv.base.name) ?? RTV.cell([], [0, 0]) : this.evalExpr(lv.base);
-        const indices = lv.indices.map((idx) => this.evalExpr(idx));
-        const idxVal = ensureRuntimeValue(indices[0]);
+        const indices = this.evalIndicesWithEnd(cellBase, lv.indices);
         let expandedCount = 1;
-        if (isRuntimeTensor(idxVal)) {
-          expandedCount = idxVal.data.length;
-        } else if (typeof idxVal === "number") {
-          expandedCount = 1;
+        const idx0 = indices[0];
+        if (idx0 === COLON_SENTINEL) {
+          const baseRv = ensureRuntimeValue(cellBase);
+          expandedCount = isRuntimeCell(baseRv) ? baseRv.data.length : 0;
+        } else {
+          const idxVal = ensureRuntimeValue(idx0);
+          if (isRuntimeTensor(idxVal)) {
+            expandedCount = idxVal.data.length;
+          } else if (typeof idxVal === "number") {
+            expandedCount = 1;
+          }
         }
         const val2 = this.evalExprNargout(stmt.expr, expandedCount);
         const values2 = Array.isArray(val2) ? val2 : [val2];
         const result = this.rt.multiOutputCellAssign(
           cellBase,
-          indices[0],
+          idx0,
           values2.map((v) => ensureRuntimeValue(v))
         );
         if (lv.base.type === "Ident") {
@@ -50795,10 +51804,12 @@ function execStmt(stmt) {
         const rv = this.rt.share(i < values.length ? values[i] : void 0);
         this.assignLValue(lv, rv);
       }
-      if (!stmt.suppressed && values.length > 0) {
-        const firstLv = stmt.lvalues[0];
-        if (firstLv.type === "Var") {
-          this.rt.displayAssign(firstLv.name, ensureRuntimeValue(values[0]));
+      if (!stmt.suppressed) {
+        for (let i = 0; i < stmt.lvalues.length; i++) {
+          const lv = stmt.lvalues[i];
+          if (lv.type === "Var" && i < values.length) {
+            this.rt.displayAssign(lv.name, ensureRuntimeValue(values[i]));
+          }
         }
       }
       return null;
@@ -51155,6 +52166,18 @@ function evalArgs(argExprs) {
   }
   return args;
 }
+var binopProfileName = {
+  ["Add" /* Add */]: "plus",
+  ["Sub" /* Sub */]: "minus",
+  ["Mul" /* Mul */]: "mtimes",
+  ["ElemMul" /* ElemMul */]: "times",
+  ["Div" /* Div */]: "mrdivide",
+  ["ElemDiv" /* ElemDiv */]: "rdivide",
+  ["LeftDiv" /* LeftDiv */]: "mldivide",
+  ["ElemLeftDiv" /* ElemLeftDiv */]: "ldivide",
+  ["Pow" /* Pow */]: "mpower",
+  ["ElemPow" /* ElemPow */]: "power"
+};
 function evalBinary(expr) {
   if (expr.op === "AndAnd" /* AndAnd */) {
     const left2 = this.evalExpr(expr.left);
@@ -51180,6 +52203,13 @@ function evalBinary(expr) {
     if (!isNaN(r)) return r;
     return mPow(ensureRuntimeValue(left), ensureRuntimeValue(right));
   }
+  if (this.rt.profilingEnabled && (typeof left !== "number" || typeof right !== "number")) {
+    const opName = binopProfileName[expr.op] ?? expr.op;
+    this.rt.profileEnter("builtin:interp:" + opName);
+    const result = binop(expr.op, left, right);
+    this.rt.profileLeave();
+    return result;
+  }
   return binop(expr.op, left, right);
 }
 function evalUnary(expr) {
@@ -51319,7 +52349,11 @@ function evalAnonFunc(expr) {
       capturedMethodName,
       () => {
         try {
-          return this.evalExprNargout(bodyExpr, narg);
+          const result = this.evalExprNargout(bodyExpr, narg);
+          if (narg > 1 && !(Array.isArray(result) && result.length >= narg)) {
+            throw new RuntimeError("Too many output arguments.");
+          }
+          return result;
         } finally {
           this.env = savedEnv;
         }
@@ -51578,7 +52612,6 @@ function switchMatch2(switchVal, caseVal) {
   return switchMatch(switchVal, caseVal);
 }
 function isOutputExpr(expr) {
-  if (expr.type !== "FuncCall") return false;
   const outputFunctions = [
     "disp",
     "display",
@@ -51586,9 +52619,12 @@ function isOutputExpr(expr) {
     "warning",
     "assert",
     "tic",
+    "toc",
     "help"
   ];
-  return outputFunctions.includes(expr.name);
+  if (expr.type === "FuncCall") return outputFunctions.includes(expr.name);
+  if (expr.type === "Ident") return outputFunctions.includes(expr.name);
+  return false;
 }
 
 // src/numbl-core/interpreter/interpreterFunctions.ts
@@ -51797,6 +52833,17 @@ register("exist", (ctx, args) => {
   }
   return FALL_THROUGH;
 });
+register("which", (ctx, args) => {
+  if (args.length < 1) return FALL_THROUGH;
+  const nameArg = toString(ensureRuntimeValue(args[0]));
+  if (ctx.env.has(nameArg)) return RTV.char("variable");
+  const filePath = ctx.lookupWorkspaceFile(nameArg);
+  if (filePath) return RTV.char(filePath);
+  if (ctx.rt.builtins[nameArg] || getIBuiltin(nameArg)) {
+    return RTV.char("built-in");
+  }
+  return RTV.char("");
+});
 register("isfolder", (ctx, args) => {
   if (args.length < 1) return FALL_THROUGH;
   const fio = ctx.rt.fileIO;
@@ -51899,6 +52946,9 @@ register("run", (ctx, args) => {
     } catch {
       throw new RuntimeError(`Cannot change directory to '${scriptDir}'`);
     }
+    if (ctx.rt.onCwdChange) {
+      ctx.rt.onCwdChange(sys.cwd());
+    }
   }
   const cwdAfterCd = sys?.cwd() ?? "/";
   try {
@@ -51910,6 +52960,9 @@ register("run", (ctx, args) => {
         sys.chdir(oldCwd);
       } catch {
       }
+      if (ctx.rt.onCwdChange) {
+        ctx.rt.onCwdChange(sys.cwd());
+      }
     }
   }
   return void 0;
@@ -51929,7 +52982,14 @@ function callFunction(name, args, nargout) {
       workspaceEnv: this.workspaceEnv,
       evalInLocalScope: (codeArg, fileName) => this.evalInLocalScope(codeArg, fileName),
       callFunction: (n, a, no) => this.callFunction(n, a, no),
-      rt: this.rt
+      rt: this.rt,
+      lookupWorkspaceFile: (n) => {
+        const entry = this.ctx.registry.filesByFuncName.get(n);
+        if (entry) return entry.fileName;
+        const classInfo = this.ctx.getClassInfo(n);
+        if (classInfo) return classInfo.fileName;
+        return void 0;
+      }
     };
     const result = specialHandler(ctx, args, nargout);
     if (result !== FALL_THROUGH) return result;
@@ -51963,13 +53023,18 @@ function interpretTarget(target, args, nargout) {
         const argTypes = margs.map(inferJitType);
         const resolution = ib.resolve(argTypes, nargout);
         if (resolution) {
+          const isVoid = resolution.outputTypes.length === 0;
+          if (isVoid && nargout > 0) {
+            throw new RuntimeError("Too many output arguments.");
+          }
           if (this.rt.profilingEnabled) {
             this.rt.profileEnter("builtin:interp:" + target.name);
-            const result = resolution.apply(margs, nargout);
+            const result2 = resolution.apply(margs, nargout);
             this.rt.profileLeave();
-            return result;
+            return isVoid ? void 0 : result2;
           }
-          return resolution.apply(margs, nargout);
+          const result = resolution.apply(margs, nargout);
+          return isVoid ? void 0 : result;
         }
       }
       const builtin = this.rt.builtins[target.name];
@@ -52061,7 +53126,19 @@ function interpretLocalFunction(target, args, nargout) {
 function interpretWorkspaceFunction(target, args, nargout) {
   const dotIdx = target.name.lastIndexOf(".");
   const primaryName = dotIdx >= 0 ? target.name.slice(dotIdx + 1) : target.name;
-  const fn = this.findFunctionInWorkspaceFile(target.name, primaryName);
+  let fn = this.findFunctionInWorkspaceFile(target.name, primaryName);
+  if (!fn) {
+    const entry = this.ctx.registry.filesByFuncName.get(target.name);
+    if (entry) {
+      const ast = this.ctx.getCachedAST(entry.fileName);
+      for (const stmt of ast.body) {
+        if (stmt.type === "Function") {
+          fn = funcDefFromStmt(stmt);
+          break;
+        }
+      }
+    }
+  }
   if (!fn) {
     const entry = this.ctx.registry.filesByFuncName.get(target.name);
     if (entry) {
@@ -52205,6 +53282,11 @@ function interpretConstructor(classInfo, args, nargout) {
   return args[0];
 }
 function callUserFunction(fn, args, nargout, narginOverride) {
+  const hasVarargoutDecl = fn.outputs.length > 0 && fn.outputs[fn.outputs.length - 1] === "varargout";
+  const declaredRegularOutputs = hasVarargoutDecl ? fn.outputs.length - 1 : fn.outputs.length;
+  if (!hasVarargoutDecl && nargout > declaredRegularOutputs) {
+    throw new RuntimeError("Too many output arguments.");
+  }
   if (this.optimization >= 1 && narginOverride === void 0) {
     const jitResult = tryJitCall(this, fn, args, nargout);
     if (jitResult !== JIT_SKIP) return jitResult;
@@ -52254,10 +53336,11 @@ function callUserFunction(fn, args, nargout, narginOverride) {
         }
       }
     }
-    const hasVarargout = fn.outputs.length > 0 && fn.outputs[fn.outputs.length - 1] === "varargout";
+    const hasVarargout = hasVarargoutDecl;
     const regularOutputs = hasVarargout ? fn.outputs.slice(0, -1) : fn.outputs;
+    const collectCount = nargout === 0 && regularOutputs.length > 0 ? 1 : Math.min(regularOutputs.length, nargout);
     const outputs = [];
-    for (let i = 0; i < Math.min(regularOutputs.length, nargout); i++) {
+    for (let i = 0; i < collectCount; i++) {
       const val = this.env.get(regularOutputs[i]);
       if (val === void 0 && nargout >= i + 1) {
         throw new RuntimeError(
@@ -53827,10 +54910,17 @@ function executeCode(source, options = {}, workspaceFiles, mainFileName = "scrip
   if (options.log) {
     options.log("AST parsed, starting interpretation");
   }
+  const isRepl = mainFileName === "repl";
   const localFunctions = [];
   const localClasses = [];
   for (const stmt of ast.body) {
     if (stmt.type === "Function") {
+      if (isRepl) {
+        throw new RuntimeError(
+          "Function definitions are not supported in the REPL. Save the function to a .m file instead.",
+          stmt.span
+        );
+      }
       localFunctions.push(stmt);
     } else if (stmt.type === "ClassDef") {
       localClasses.push(stmt);
@@ -53851,6 +54941,31 @@ function executeCode(source, options = {}, workspaceFiles, mainFileName = "scrip
       }
     }
   }
+  let implicitCwdPath = null;
+  if (options.implicitCwdPath !== null && options.system && options.fileIO?.scanDirectory) {
+    try {
+      const cwd = options.implicitCwdPath ?? options.system.cwd();
+      const absCwd = options.fileIO.resolvePath?.(cwd) ?? cwd;
+      const explicitPaths = searchPaths ?? [];
+      if (!explicitPaths.includes(absCwd)) {
+        implicitCwdPath = absCwd;
+        const prefix = absCwd.endsWith("/") ? absCwd : absCwd + "/";
+        const alreadyHave = mWorkspaceFiles.some(
+          (f) => f.name === absCwd || f.name.startsWith(prefix)
+        );
+        if (!alreadyHave) {
+          const cwdFiles = options.fileIO.scanDirectory(absCwd);
+          for (const f of cwdFiles) {
+            if (f.name.endsWith(".m")) {
+              mWorkspaceFiles.push(f);
+            }
+          }
+        }
+      }
+    } catch {
+      implicitCwdPath = null;
+    }
+  }
   const jsUserFunctions = loadJsUserFunctions(
     jsWorkspaceFiles,
     wasmWorkspaceFiles,
@@ -53868,6 +54983,9 @@ function executeCode(source, options = {}, workspaceFiles, mainFileName = "scrip
     stdlibShimNames.add(shimName);
   }
   ctx.registry.searchPaths = [...searchPaths ?? [], SHIM_SEARCH_PATH];
+  if (implicitCwdPath !== null) {
+    ctx.registry.searchPaths.unshift(implicitCwdPath);
+  }
   ctx.fileASTCache.set(mainFileName, ast);
   const skippedFiles = /* @__PURE__ */ new Set();
   for (const f of mWorkspaceFiles) {
@@ -53901,6 +55019,11 @@ function executeCode(source, options = {}, workspaceFiles, mainFileName = "scrip
     ctx.registerWorkspaceFiles(mWorkspaceFiles);
   }
   const functionIndex = ctx.buildFunctionIndex(jsUserFunctionNames);
+  const savedSpecialBuiltins = /* @__PURE__ */ new Map();
+  for (const name of SPECIAL_BUILTIN_NAMES) {
+    const existing = getIBuiltin(name);
+    if (existing) savedSpecialBuiltins.set(name, existing);
+  }
   const rt = new Runtime(options, options.initialVariableValues);
   const savedIBuiltins = /* @__PURE__ */ new Map();
   for (const ib of jsUserFunctions) {
@@ -53942,13 +55065,39 @@ ${jsCode}`
   interpreter.installRuntimeCallbacks();
   rt.searchPaths = ctx.registry.searchPaths;
   let pathsModified = false;
+  const rebuildWorkspace = () => {
+    const paths = ctx.registry.searchPaths;
+    const priorityOf = (name) => {
+      let bestIdx = paths.length;
+      let bestLen = -1;
+      for (let i = 0; i < paths.length; i++) {
+        const p2 = paths[i];
+        const withSep = p2.endsWith("/") ? p2 : p2 + "/";
+        if (name === p2 || name.startsWith(withSep)) {
+          if (p2.length > bestLen) {
+            bestLen = p2.length;
+            bestIdx = i;
+          }
+        }
+      }
+      return bestIdx;
+    };
+    mWorkspaceFiles.sort((a, b) => priorityOf(a.name) - priorityOf(b.name));
+    ctx.clearWorkspaceRegistrations();
+    ctx.registerWorkspaceFiles(mWorkspaceFiles);
+    const newIndex = ctx.buildFunctionIndex(jsUserFunctionNames);
+    interpreter.functionIndex = newIndex;
+    interpreter.clearAllCaches();
+    pathsModified = true;
+  };
   rt.onPathChange = (action, dir, position) => {
     const fileIO = options.fileIO;
     const absDir = fileIO?.resolvePath?.(dir) ?? dir;
     if (action === "add") {
       if (ctx.registry.searchPaths.includes(absDir)) return;
       if (position === "begin") {
-        ctx.registry.searchPaths.unshift(absDir);
+        const cwdIsFirst = implicitCwdPath !== null && ctx.registry.searchPaths[0] === implicitCwdPath;
+        ctx.registry.searchPaths.splice(cwdIsFirst ? 1 : 0, 0, absDir);
       } else {
         const shimIdx = ctx.registry.searchPaths.indexOf(SHIM_SEARCH_PATH);
         if (shimIdx >= 0) {
@@ -53966,10 +55115,14 @@ ${jsCode}`
             try {
               ctx.fileASTCache.set(f.name, parseMFile(f.source, f.name));
             } catch (e) {
-              if (e instanceof SyntaxError && e.file === null) {
-                e.file = f.name;
+              if (e instanceof SyntaxError) {
+                console.warn(
+                  `Warning: skipping ${f.name} (syntax error at line ${e.line ?? "?"})`
+                );
+              } else {
+                console.warn(`Warning: skipping ${f.name} (parse error)`);
               }
-              throw e;
+              continue;
             }
             interpreter.fileSources.set(f.name, f.source);
             mWorkspaceFiles.push(f);
@@ -54009,26 +55162,76 @@ ${jsCode}`
         }
       }
     }
-    const paths = ctx.registry.searchPaths;
-    mWorkspaceFiles.sort((a, b) => {
-      const ai = paths.findIndex(
-        (p2) => a.name.startsWith(p2.endsWith("/") ? p2 : p2 + "/") || a.name === p2
-      );
-      const bi = paths.findIndex(
-        (p2) => b.name.startsWith(p2.endsWith("/") ? p2 : p2 + "/") || b.name === p2
+    rebuildWorkspace();
+  };
+  rt.onCwdChange = (newCwd) => {
+    const fileIO = options.fileIO;
+    const absNewCwd = fileIO?.resolvePath?.(newCwd) ?? newCwd;
+    if (implicitCwdPath === absNewCwd) return;
+    if (implicitCwdPath !== null) {
+      const oldPrefix = implicitCwdPath.endsWith("/") ? implicitCwdPath : implicitCwdPath + "/";
+      const deeperPaths = ctx.registry.searchPaths.filter(
+        (p2) => p2 !== implicitCwdPath && p2 !== SHIM_SEARCH_PATH && (p2 === implicitCwdPath || p2.startsWith(oldPrefix))
       );
-      const aPri = ai >= 0 ? ai : paths.length;
-      const bPri = bi >= 0 ? bi : paths.length;
-      return aPri - bPri;
-    });
-    ctx.clearWorkspaceRegistrations();
-    ctx.registerWorkspaceFiles(mWorkspaceFiles);
-    const newIndex = ctx.buildFunctionIndex(jsUserFunctionNames);
-    interpreter.functionIndex = newIndex;
-    interpreter.clearAllCaches();
-    pathsModified = true;
+      const fileBelongsToDeeperPath = (fname) => {
+        for (const p2 of deeperPaths) {
+          const withSep = p2.endsWith("/") ? p2 : p2 + "/";
+          if (fname === p2 || fname.startsWith(withSep)) return true;
+        }
+        return false;
+      };
+      for (let i = mWorkspaceFiles.length - 1; i >= 0; i--) {
+        const fname = mWorkspaceFiles[i].name;
+        if ((fname === implicitCwdPath || fname.startsWith(oldPrefix)) && !fileBelongsToDeeperPath(fname)) {
+          ctx.fileASTCache.delete(fname);
+          interpreter.fileSources.delete(fname);
+          mWorkspaceFiles.splice(i, 1);
+        }
+      }
+      const oldIdx = ctx.registry.searchPaths.indexOf(implicitCwdPath);
+      if (oldIdx >= 0) ctx.registry.searchPaths.splice(oldIdx, 1);
+      implicitCwdPath = null;
+    }
+    if (ctx.registry.searchPaths.includes(absNewCwd)) {
+      rebuildWorkspace();
+      return;
+    }
+    ctx.registry.searchPaths.unshift(absNewCwd);
+    implicitCwdPath = absNewCwd;
+    if (fileIO?.scanDirectory) {
+      let newFiles = [];
+      try {
+        newFiles = fileIO.scanDirectory(absNewCwd);
+      } catch {
+      }
+      for (const f of newFiles) {
+        if (f.name.endsWith(".m") && !ctx.fileASTCache.has(f.name)) {
+          try {
+            ctx.fileASTCache.set(f.name, parseMFile(f.source, f.name));
+          } catch (e) {
+            if (e instanceof SyntaxError) {
+              console.warn(
+                `Warning: skipping ${f.name} (syntax error at line ${e.line ?? "?"})`
+              );
+            } else {
+              console.warn(`Warning: skipping ${f.name} (parse error)`);
+            }
+            continue;
+          }
+          interpreter.fileSources.set(f.name, f.source);
+          mWorkspaceFiles.push(f);
+        }
+      }
+    }
+    rebuildWorkspace();
   };
   rt.evalLocalCallback = (code, initialVars, onOutput, fileName) => {
+    const nestedSearchPaths = ctx.registry.searchPaths.filter(
+      (p2) => p2 !== SHIM_SEARCH_PATH && p2 !== implicitCwdPath
+    );
+    const nestedWorkspaceFiles = mWorkspaceFiles.filter(
+      (f) => !stdlibShimNames.has(f.name)
+    );
     const evalResult = executeCode(
       code,
       {
@@ -54036,11 +55239,18 @@ ${jsCode}`
         displayResults: false,
         initialVariableValues: initialVars,
         fileIO: options.fileIO,
-        onInput: options.onInput
+        system: options.system,
+        onInput: options.onInput,
+        implicitCwdPath
       },
-      void 0,
-      fileName
+      nestedWorkspaceFiles,
+      fileName,
+      nestedSearchPaths,
+      nativeBridge2
     );
+    if (evalResult.implicitCwdPath !== void 0) {
+      implicitCwdPath = evalResult.implicitCwdPath;
+    }
     return {
       returnValue: evalResult.returnValue,
       variableValues: evalResult.variableValues,
@@ -54056,7 +55266,7 @@ ${jsCode}`
       output: rt.outputLines,
       generatedJS: jitSections.length > 0 ? `// Interpreter mode \u2014 JIT compiled sections:
 
-${jitSections.join("\n\n")}` : "// interpreted mode \u2014 no JS generated",
+${jitSections.join("\n\n")}` : "// No JS generated",
       plotInstructions: rt.plotInstructions,
       returnValue: interpreter.ans ?? RTV.num(0),
       variableValues: interpreter.getVariableValues(),
@@ -54072,17 +55282,18 @@ ${jitSections.join("\n\n")}` : "// interpreted mode \u2014 no JS generated",
     }
     if (pathsModified) {
       result.searchPaths = ctx.registry.searchPaths.filter(
-        (p2) => p2 !== SHIM_SEARCH_PATH
+        (p2) => p2 !== SHIM_SEARCH_PATH && p2 !== implicitCwdPath
       );
       result.workspaceFiles = mWorkspaceFiles.filter(
         (f) => !stdlibShimNames.has(f.name)
       );
     }
+    result.implicitCwdPath = implicitCwdPath;
     return result;
   } catch (e) {
     const generatedJS = jitSections.length > 0 ? `// Interpreter mode \u2014 JIT compiled sections:
 
-${jitSections.join("\n\n")}` : "// interpreted mode \u2014 no JS generated";
+${jitSections.join("\n\n")}` : "// No JS generated";
     if (e instanceof RuntimeError) {
       if (e.line === null && rt.$file && rt.$line > 0) {
         e.file = rt.$file;
@@ -54113,6 +55324,9 @@ ${jitSections.join("\n\n")}` : "// interpreted mode \u2014 no JS generated";
         unregisterIBuiltin(ib.name);
       }
     }
+    for (const [, ib] of savedSpecialBuiltins) {
+      registerDynamicIBuiltin(ib);
+    }
   }
 }
 
@@ -54130,9 +55344,11 @@ import {
   unlinkSync,
   readdirSync as readdirSync2,
   rmSync,
-  rmdirSync
+  rmdirSync,
+  renameSync,
+  chmodSync
 } from "fs";
-import { inflateRawSync } from "zlib";
+import { unzipSync } from "fflate";
 import { execFileSync } from "child_process";
 import { homedir, tmpdir } from "os";
 import { join as join3, resolve, dirname, basename } from "path";
@@ -54189,6 +55405,18 @@ function expandTilde(filepath) {
   }
   return filepath;
 }
+function copyDirRecursive(src, dst) {
+  mkdirSync(dst, { recursive: true });
+  for (const entry of readdirSync2(src, { withFileTypes: true })) {
+    const s = join3(src, entry.name);
+    const d = join3(dst, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(s, d);
+    } else {
+      writeFileSync(d, readFileSync3(s));
+    }
+  }
+}
 function permissionToFlags(permission) {
   switch (permission) {
     case "r":
@@ -54208,6 +55436,21 @@ function permissionToFlags(permission) {
   }
 }
 var READ_CHUNK_SIZE = 8192;
+function buildFetchOptions(options) {
+  const init = {};
+  if (options?.requestMethod) {
+    init.method = options.requestMethod.toUpperCase();
+  }
+  const headers = {};
+  if (options?.username && options?.password) {
+    headers["Authorization"] = "Basic " + Buffer.from(`${options.username}:${options.password}`).toString("base64");
+  }
+  if (options?.keyName && options?.keyValue) {
+    headers[options.keyName] = options.keyValue;
+  }
+  if (Object.keys(headers).length > 0) init.headers = headers;
+  return init;
+}
 var NodeFileIOAdapter = class {
   nextFid = 3;
   // 0=stdin, 1=stdout, 2=stderr reserved
@@ -54381,35 +55624,43 @@ var NodeFileIOAdapter = class {
   tempdir() {
     return tmpdir();
   }
-  websave(url, filename) {
+  websave(url, filename, options) {
     const dest = expandTilde(filename);
+    const timeoutMs = options?.timeout ? Math.round(options.timeout * 1e3) : 3e4;
+    const fetchOpts = buildFetchOptions(options);
     const script = `
-      fetch(${JSON.stringify(url)})
-        .then(r => { if (!r.ok) throw new Error('HTTP ' + r.status); return r.arrayBuffer(); })
+      const ac = new AbortController();
+      const t = setTimeout(() => ac.abort(), ${timeoutMs});
+      fetch(${JSON.stringify(url)}, { ...${JSON.stringify(fetchOpts)}, signal: ac.signal })
+        .then(r => { clearTimeout(t); if (!r.ok) throw new Error('HTTP ' + r.status); return r.arrayBuffer(); })
         .then(buf => require('fs').writeFileSync(${JSON.stringify(dest)}, Buffer.from(buf)))
         .catch(e => { process.stderr.write(e.message + '\\n'); process.exit(1); });
     `;
     try {
       execFileSync(process.execPath, ["-e", script], {
         stdio: ["ignore", "ignore", "pipe"],
-        timeout: 3e4
+        timeout: timeoutMs + 5e3
       });
     } catch (e) {
       const msg = e instanceof Error && "stderr" in e ? e.stderr.toString().trim() : String(e);
       throw new Error(`websave: failed to download ${url}: ${msg}`);
     }
   }
-  webread(url) {
+  webread(url, options) {
+    const timeoutMs = options?.timeout ? Math.round(options.timeout * 1e3) : 3e4;
+    const fetchOpts = buildFetchOptions(options);
     const script = `
-      fetch(${JSON.stringify(url)})
-        .then(r => { if (!r.ok) throw new Error('HTTP ' + r.status); return r.text(); })
+      const ac = new AbortController();
+      const t = setTimeout(() => ac.abort(), ${timeoutMs});
+      fetch(${JSON.stringify(url)}, { ...${JSON.stringify(fetchOpts)}, signal: ac.signal })
+        .then(r => { clearTimeout(t); if (!r.ok) throw new Error('HTTP ' + r.status); return r.text(); })
         .then(t => process.stdout.write(t))
         .catch(e => { process.stderr.write(e.message + '\\n'); process.exit(1); });
     `;
     try {
       const result = execFileSync(process.execPath, ["-e", script], {
         stdio: ["ignore", "pipe", "pipe"],
-        timeout: 3e4,
+        timeout: timeoutMs + 5e3,
         maxBuffer: 50 * 1024 * 1024
       });
       return result.toString();
@@ -54431,6 +55682,59 @@ var NodeFileIOAdapter = class {
       return false;
     }
   }
+  movefile(source, destination, force) {
+    try {
+      const src = expandTilde(source);
+      const srcStat = statSync2(src);
+      let dst = expandTilde(destination);
+      let dstType = null;
+      try {
+        const s = statSync2(dst);
+        dstType = s.isDirectory() ? "dir" : "file";
+      } catch {
+        dstType = null;
+      }
+      if (dstType === "dir") {
+        dst = join3(dst, basename(src));
+        try {
+          dstType = statSync2(dst).isDirectory() ? "dir" : "file";
+        } catch {
+          dstType = null;
+        }
+      }
+      if (dstType === "file" && force) {
+        try {
+          chmodSync(dst, 438);
+        } catch {
+        }
+      }
+      if (srcStat.isDirectory() && dstType === "file") {
+        return false;
+      }
+      const parent = dirname(dst);
+      if (parent && parent !== "." && parent !== "/") {
+        try {
+          mkdirSync(parent, { recursive: true });
+        } catch {
+        }
+      }
+      try {
+        renameSync(src, dst);
+        return true;
+      } catch {
+        if (srcStat.isDirectory()) {
+          copyDirRecursive(src, dst);
+          rmSync(src, { recursive: true });
+        } else {
+          writeFileSync(dst, readFileSync3(src));
+          unlinkSync(src);
+        }
+        return true;
+      }
+    } catch {
+      return false;
+    }
+  }
   deleteFile(pattern) {
     const p2 = expandTilde(pattern);
     if (p2.includes("*") || p2.includes("?")) {
@@ -54466,56 +55770,18 @@ var NodeFileIOAdapter = class {
     const dest = resolve(expandTilde(outputfolder));
     mkdirSync(dest, { recursive: true });
     const buf = readFileSync3(src);
-    let eocdOffset = -1;
-    for (let i = buf.length - 22; i >= 0; i--) {
-      if (buf[i] === 80 && buf[i + 1] === 75 && buf[i + 2] === 5 && buf[i + 3] === 6) {
-        eocdOffset = i;
-        break;
-      }
-    }
-    if (eocdOffset === -1) throw new Error("unzip: invalid ZIP file");
-    const cdOffset = buf.readUInt32LE(eocdOffset + 16);
-    const cdEntries = buf.readUInt16LE(eocdOffset + 10);
+    const files = unzipSync(
+      new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength)
+    );
     const extracted = [];
-    let pos = cdOffset;
-    for (let i = 0; i < cdEntries; i++) {
-      if (buf.readUInt32LE(pos) !== 33639248)
-        throw new Error("unzip: corrupt central directory");
-      const method = buf.readUInt16LE(pos + 10);
-      const nameLen = buf.readUInt16LE(pos + 28);
-      const extraLen = buf.readUInt16LE(pos + 30);
-      const commentLen = buf.readUInt16LE(pos + 32);
-      const localHeaderOffset = buf.readUInt32LE(pos + 42);
-      const entryName = buf.toString("utf-8", pos + 46, pos + 46 + nameLen);
-      pos += 46 + nameLen + extraLen + commentLen;
+    for (const [entryName, data] of Object.entries(files)) {
       if (entryName.endsWith("/")) {
         mkdirSync(join3(dest, entryName), { recursive: true });
         continue;
       }
-      const localPos = localHeaderOffset;
-      if (buf.readUInt32LE(localPos) !== 67324752)
-        throw new Error("unzip: corrupt local header");
-      const localNameLen = buf.readUInt16LE(localPos + 26);
-      const localExtraLen = buf.readUInt16LE(localPos + 28);
-      const compressedSize = buf.readUInt32LE(localPos + 18);
-      const dataStart = localPos + 30 + localNameLen + localExtraLen;
-      const compressedData = buf.subarray(
-        dataStart,
-        dataStart + compressedSize
-      );
-      let fileData;
-      if (method === 0) {
-        fileData = Buffer.from(compressedData);
-      } else if (method === 8) {
-        fileData = inflateRawSync(compressedData);
-      } else {
-        throw new Error(
-          `unzip: unsupported compression method ${method} for ${entryName}`
-        );
-      }
       const outPath = join3(dest, entryName);
       mkdirSync(dirname(outPath), { recursive: true });
-      writeFileSync(outPath, fileData);
+      writeFileSync(outPath, data);
       extracted.push(outPath);
     }
     return extracted;
@@ -54796,6 +56062,7 @@ function saveHistoryEntry(entry, hist) {
 async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths, nativeBridge2, optimization) {
   let variableValues = {};
   let holdState = false;
+  let implicitCwdPath;
   const workspaceFiles = [...initialWorkspaceFiles];
   const searchPaths = [...initialSearchPaths ?? []];
   const fileIO = new NodeFileIOAdapter();
@@ -54848,7 +56115,8 @@ async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths, nat
             initialHoldState: holdState,
             optimization,
             fileIO,
-            system
+            system,
+            implicitCwdPath
           },
           workspaceFiles,
           "repl",
@@ -54863,6 +56131,9 @@ async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths, nat
           workspaceFiles.length = 0;
           workspaceFiles.push(...result.workspaceFiles ?? []);
         }
+        if (result.implicitCwdPath !== void 0) {
+          implicitCwdPath = result.implicitCwdPath;
+        }
         if (result.plotInstructions.length > 0 && onDrawnow) {
           onDrawnow(result.plotInstructions);
         }
@@ -54961,7 +56232,8 @@ async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths, nat
           initialHoldState: holdState,
           optimization,
           fileIO,
-          system
+          system,
+          implicitCwdPath
         },
         workspaceFiles,
         "repl",
@@ -54976,6 +56248,9 @@ async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths, nat
         workspaceFiles.length = 0;
         workspaceFiles.push(...result.workspaceFiles ?? []);
       }
+      if (result.implicitCwdPath !== void 0) {
+        implicitCwdPath = result.implicitCwdPath;
+      }
       if (result.plotInstructions.length > 0 && onDrawnow) {
         onDrawnow(result.plotInstructions);
       }
@@ -55241,65 +56516,15 @@ async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths, nat
 }
 
 // src/vfs/unzipToFiles.ts
-import { inflateSync } from "fflate";
-var TEXT_DECODER = new TextDecoder("utf-8");
+import { unzipSync as unzipSync2 } from "fflate";
 function unzipToFiles(zipData) {
-  let eocdOffset = -1;
-  for (let i = zipData.length - 22; i >= 0; i--) {
-    if (zipData[i] === 80 && zipData[i + 1] === 75 && zipData[i + 2] === 5 && zipData[i + 3] === 6) {
-      eocdOffset = i;
-      break;
-    }
-  }
-  if (eocdOffset === -1) throw new Error("Invalid ZIP file");
-  const view = new DataView(
-    zipData.buffer,
-    zipData.byteOffset,
-    zipData.byteLength
-  );
-  const cdOffset = view.getUint32(eocdOffset + 16, true);
-  const cdEntries = view.getUint16(eocdOffset + 10, true);
-  const files = [];
-  let pos = cdOffset;
-  for (let i = 0; i < cdEntries; i++) {
-    if (view.getUint32(pos, true) !== 33639248) {
-      throw new Error("Corrupt ZIP central directory");
-    }
-    const method = view.getUint16(pos + 10, true);
-    const nameLen = view.getUint16(pos + 28, true);
-    const extraLen = view.getUint16(pos + 30, true);
-    const commentLen = view.getUint16(pos + 32, true);
-    const localHeaderOffset = view.getUint32(pos + 42, true);
-    const entryName = TEXT_DECODER.decode(
-      zipData.subarray(pos + 46, pos + 46 + nameLen)
-    );
-    pos += 46 + nameLen + extraLen + commentLen;
-    if (entryName.endsWith("/")) continue;
-    const localPos = localHeaderOffset;
-    if (view.getUint32(localPos, true) !== 67324752) {
-      throw new Error("Corrupt ZIP local header");
-    }
-    const localNameLen = view.getUint16(localPos + 26, true);
-    const localExtraLen = view.getUint16(localPos + 28, true);
-    const compressedSize = view.getUint32(localPos + 18, true);
-    const dataStart = localPos + 30 + localNameLen + localExtraLen;
-    const compressedData = zipData.subarray(
-      dataStart,
-      dataStart + compressedSize
-    );
-    let content;
-    if (method === 0) {
-      content = new Uint8Array(compressedData);
-    } else if (method === 8) {
-      content = inflateSync(compressedData);
-    } else {
-      throw new Error(
-        `Unsupported ZIP compression method ${method} for ${entryName}`
-      );
-    }
-    files.push({ path: entryName, content });
+  const files = unzipSync2(zipData);
+  const out = [];
+  for (const [path, content] of Object.entries(files)) {
+    if (path.endsWith("/")) continue;
+    out.push({ path, content });
   }
-  return files;
+  return out;
 }
 
 // src/cli.ts
@@ -55527,7 +56752,6 @@ Options (for run and eval):
   --path <dir>       Add extra workspace directory
   --plot             Enable plot server
   --plot-port <port> Set plot server port (implies --plot)
-  --add-script-path  Add the script's directory to the workspace (run only)
   --opt <level>      Optimization level (0=none, 1=JIT scalar functions; default: 1)
 
 Environment variables:
@@ -55541,7 +56765,6 @@ function parseOptions(args) {
     stream: false,
     plot: false,
     plotPort: void 0,
-    addScriptPath: false,
     extraPaths: [],
     positional: [],
     profileOutput: void 0,
@@ -55581,9 +56804,6 @@ function parseOptions(args) {
       case "--plot":
         opts.plot = true;
         break;
-      case "--add-script-path":
-        opts.addScriptPath = true;
-        break;
       case "--plot-port":
         i++;
         if (i >= args.length) {
@@ -55649,13 +56869,9 @@ async function cmdRun(args) {
   const filepath = resolve2(process.cwd(), opts.positional[0]);
   const code = readFileSync5(filepath, "utf-8");
   const mainFileName = filepath;
+  process.chdir(dirname2(filepath));
   const searchPaths = [];
-  let workspaceFiles = [];
-  if (opts.addScriptPath) {
-    const scriptDir = dirname2(filepath);
-    searchPaths.push(scriptDir);
-    workspaceFiles = scanMFiles(scriptDir, filepath);
-  }
+  const workspaceFiles = [];
   for (const p2 of opts.extraPaths) {
     searchPaths.push(p2);
     workspaceFiles.push(...scanMFiles(p2));