numbl 0.1.2 → 0.1.4

package/dist-lib/lib.js

@@ -18259,6 +18259,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);
@@ -18271,6 +18293,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());
@@ -18759,6 +18789,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 };
@@ -18934,6 +19216,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) {
@@ -18974,7 +19268,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;
@@ -19004,6 +19317,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) {
@@ -19036,6 +19356,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) {
@@ -19052,6 +19379,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) {
@@ -19084,6 +19418,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) {
@@ -19122,6 +19463,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) {
@@ -19834,6 +20182,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) {
@@ -19887,17 +20236,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 {
@@ -20234,6 +20601,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);
@@ -20245,6 +20629,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]);
   }
@@ -20273,6 +20673,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)
@@ -20283,7 +20688,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;
@@ -20295,7 +20700,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);
@@ -20317,7 +20722,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;
@@ -20365,7 +20770,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) {
@@ -20530,6 +20941,7 @@ function indexIntoLogical(base, indices) {
   return base;
 }
 function indexIntoTensorWithTensor(base, idx) {
+  const baseLogical = base._isLogical === true;
   if (idx._isLogical) {
     const selected = [];
     const selectedIm = [];
@@ -20543,12 +20955,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;
@@ -20564,7 +20983,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)) {
@@ -20914,10 +21339,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);
@@ -21345,6 +21778,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) {
@@ -21356,8 +21792,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)) {
@@ -21965,7 +22440,7 @@ var token_config_default = {
     stripUnderscores: true,
     integerToken: "Integer",
     floatToken: "Float",
-    exponentChars: ["e", "E"],
+    exponentChars: ["e", "E", "d", "D"],
     decimalPoint: ".",
     dotOperatorPrefixes: ["*", "/", "\\", "^"]
   },
@@ -22270,6 +22745,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 });
@@ -27430,224 +27908,88 @@ defineBuiltin({
   }
 });
 
-// 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+$/, "");
+// 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 }];
   }
-  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;
+  if (argTypes[0].kind === "sparse_matrix" || argTypes[1].kind === "sparse_matrix") {
+    return [{ kind: "tensor", isComplex: false, isLogical: true }];
   }
-  return " ".repeat(padLen) + str;
+  return [{ kind: "boolean" }];
 }
-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);
-    }
+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);
   }
-  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];
+  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 }];
         }
-        i++;
-      } else {
-        result += fmt[i];
-        i++;
-      }
+        return [{ kind: "boolean" }];
+      },
+      apply: (args) => not(args[0])
     }
-    if (argIdx === startArgIdx) break;
-  } while (argIdx < flatArgs.length);
-  return result;
-}
+  ]
+});
 
 // src/numbl-core/interpreter/builtins/utility.ts
 function sparseToDense2(S) {
@@ -27757,7 +28099,7 @@ defineBuiltin({
     {
       match: (argTypes) => {
         if (argTypes.length < 1) return null;
-        return [{ kind: "number" }];
+        return [];
       },
       apply: (args) => {
         const v = args[0];
@@ -27778,7 +28120,7 @@ defineBuiltin({
           const msg = args.length > 1 ? textValue(args[1]) ?? String(args[1]) : "Assertion failed";
           throw new Error(msg);
         }
-        return 0;
+        return void 0;
       }
     }
   ]
@@ -27789,7 +28131,7 @@ defineBuiltin({
     {
       match: (argTypes) => {
         if (argTypes.length === 0) return null;
-        return [{ kind: "number" }];
+        return [];
       },
       apply: (args) => {
         const first = textValue(args[0]) ?? String(args[0]);
@@ -28461,6 +28803,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(
@@ -29298,19 +29653,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)
     };
   };
 }
@@ -31361,7 +31730,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];
@@ -31478,7 +31847,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];
@@ -31557,7 +31926,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");
@@ -31641,7 +32010,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];
@@ -31753,7 +32122,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];
       },
@@ -31778,7 +32147,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;
@@ -31844,7 +32213,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];
@@ -31957,11 +32326,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) };
   }
@@ -31972,7 +32341,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]),
@@ -31999,7 +32368,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 [
@@ -32020,7 +32389,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 [
@@ -32090,12 +32459,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 {
@@ -32112,7 +32481,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]),
@@ -32145,7 +32514,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),
@@ -32171,7 +32540,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 [
@@ -32214,7 +32583,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++)
@@ -32430,11 +32799,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) };
@@ -32453,7 +32822,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]);
@@ -32491,7 +32860,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],
@@ -32567,11 +32936,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) };
@@ -32585,7 +32954,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)];
@@ -32614,7 +32983,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];
@@ -32627,7 +32996,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];
@@ -32651,11 +33020,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) };
@@ -32816,7 +33185,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()];
@@ -32859,7 +33228,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];
@@ -32920,7 +33289,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];
@@ -32968,7 +33337,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];
@@ -33065,7 +33434,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()];
@@ -33073,11 +33442,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;
@@ -33101,7 +33474,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()];
       },
@@ -33144,7 +33517,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]))
@@ -33273,7 +33646,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)];
       },
@@ -35395,6 +35768,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,
@@ -36524,6 +36956,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: [
@@ -37135,9 +37692,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;
@@ -37153,6 +37712,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) {
@@ -37179,10 +37739,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]);
@@ -37250,7 +37860,7 @@ registerIBuiltin({
     };
   }
 });
-function registerRandBuiltin(name, gen) {
+function registerRandBuiltin(name, gen, bulkFill) {
   defineBuiltin({
     name,
     cases: [
@@ -37289,7 +37899,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);
         }
       }
@@ -37297,7 +37911,7 @@ function registerRandBuiltin(name, gen) {
   });
 }
 registerRandBuiltin("rand", rngRandom);
-registerRandBuiltin("randn", boxMullerRandom);
+registerRandBuiltin("randn", boxMullerRandom, fillRandn);
 defineBuiltin({
   name: "randi",
   cases: [
@@ -37744,6 +38358,9 @@ registerIBuiltin({
 
 // src/numbl-core/interpreter/builtins/time-system.ts
 var ticTime = 0;
+function getTicTime() {
+  return ticTime;
+}
 defineBuiltin({
   name: "tic",
   cases: [
@@ -37756,15 +38373,6 @@ defineBuiltin({
     }
   ]
 });
-defineBuiltin({
-  name: "toc",
-  cases: [
-    {
-      match: (argTypes) => argTypes.length === 0 ? [{ kind: "number" }] : null,
-      apply: () => RTV.num((performance.now() - ticTime) / 1e3)
-    }
-  ]
-});
 defineBuiltin({
   name: "clock",
   cases: [
@@ -37855,6 +38463,24 @@ registerIBuiltin({
     }
   })
 });
+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"],
@@ -38753,6 +39379,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: () => ({
@@ -38862,7 +39526,7 @@ for (const name of ["clear", "clc", "clf"]) {
     name,
     resolve: () => ({
       outputTypes: [],
-      apply: () => 0
+      apply: () => void 0
     })
   });
 }
@@ -38996,7 +39660,7 @@ registerIBuiltin({
   name: "set",
   resolve: () => ({
     outputTypes: [],
-    apply: () => 0
+    apply: () => void 0
   })
 });
 for (const name of [
@@ -39018,7 +39682,7 @@ for (const name of [
     name,
     resolve: () => ({
       outputTypes: [],
-      apply: () => 0
+      apply: () => void 0
     })
   });
 }
@@ -43738,6 +44402,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",
@@ -43826,6 +44598,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "webread",
   "delete",
   "rmdir",
+  "movefile",
   "unzip",
   "dir",
   "warning",
@@ -43838,7 +44611,9 @@ var SPECIAL_BUILTIN_NAMES = [
   "cd",
   "ode45",
   "ode23",
-  "deval"
+  "deval",
+  "toc",
+  "quadgk"
 ];
 
 // src/numbl-core/runtime/specialBuiltins.ts
@@ -43852,49 +44627,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")],
@@ -43923,9 +44723,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));
@@ -43936,27 +44736,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 {
@@ -43967,7 +44747,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);
@@ -43999,6 +44779,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);
   });
@@ -44527,6 +45356,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));
@@ -44536,8 +45399,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}`);
@@ -44546,7 +45415,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) => {
@@ -44557,8 +45426,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}`);
@@ -44567,7 +45442,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);
@@ -44575,7 +45450,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");
@@ -44585,7 +45460,6 @@ function registerSpecialBuiltins(rt) {
     for (const arg of margs) {
       io.deleteFile(toString(arg));
     }
-    return 0;
   });
   registerSpecial("rmdir", (nargout, args) => {
     const io = requireFileIO();
@@ -44608,6 +45482,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)
@@ -44659,7 +45561,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();
@@ -44756,7 +45658,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));
@@ -44771,7 +45673,6 @@ function registerSpecialBuiltins(rt) {
     } else {
       rt.setWorkspaceVariable(varName, args[2]);
     }
-    return 0;
   });
   registerSpecial("evalin", (_nargout, args) => {
     if (args.length < 2)
@@ -44792,13 +45693,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 ?? "";
@@ -44842,7 +45742,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) {
@@ -44862,11 +45762,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));
@@ -44929,11 +45829,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];
@@ -44941,20 +45841,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 {
@@ -44962,15 +45868,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",
@@ -44979,43 +45888,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") {
@@ -45026,26 +45933,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);
@@ -45590,6 +46496,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) {
@@ -46158,6 +47087,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) {
@@ -46166,7 +47096,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)
@@ -46176,6 +47113,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) {
@@ -46566,14 +47504,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];
@@ -46800,6 +47744,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
@@ -47079,23 +48025,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()]
       ])
     );
   }
@@ -47927,6 +48876,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/jsUserFunctions.ts
 function funcNameFromFile(fileName) {
@@ -49175,9 +50181,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;
@@ -49252,11 +50256,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;
@@ -50325,10 +51324,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);
       }
@@ -50349,19 +51352,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") {
@@ -50378,10 +51387,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;
@@ -50738,6 +51749,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);
@@ -50763,6 +51786,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) {
@@ -50902,7 +51932,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;
         }
@@ -51161,7 +52195,6 @@ function switchMatch2(switchVal, caseVal) {
   return switchMatch(switchVal, caseVal);
 }
 function isOutputExpr(expr) {
-  if (expr.type !== "FuncCall") return false;
   const outputFunctions = [
     "disp",
     "display",
@@ -51169,9 +52202,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
@@ -51380,6 +52416,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;
@@ -51482,6 +52529,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 {
@@ -51493,6 +52543,9 @@ register("run", (ctx, args) => {
         sys.chdir(oldCwd);
       } catch {
       }
+      if (ctx.rt.onCwdChange) {
+        ctx.rt.onCwdChange(sys.cwd());
+      }
     }
   }
   return void 0;
@@ -51512,7 +52565,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;
@@ -51546,13 +52606,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];
@@ -51644,7 +52709,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) {
@@ -51788,6 +52865,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;
@@ -51837,10 +52919,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(
@@ -53410,10 +54493,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);
@@ -53434,6 +54524,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,
@@ -53451,6 +54566,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) {
@@ -53484,6 +54602,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) {
@@ -53525,13 +54648,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) {
@@ -53549,10 +54698,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);
@@ -53592,26 +54745,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,
       {
@@ -53619,11 +54822,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,
+      nativeBridge
     );
+    if (evalResult.implicitCwdPath !== void 0) {
+      implicitCwdPath = evalResult.implicitCwdPath;
+    }
     return {
       returnValue: evalResult.returnValue,
       variableValues: evalResult.variableValues,
@@ -53639,7 +54849,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(),
@@ -53655,17 +54865,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;
@@ -53696,6 +54907,9 @@ ${jitSections.join("\n\n")}` : "// interpreted mode \u2014 no JS generated";
         unregisterIBuiltin(ib.name);
       }
     }
+    for (const [, ib] of savedSpecialBuiltins) {
+      registerDynamicIBuiltin(ib);
+    }
   }
 }
 export {