numbl 0.1.3 → 0.1.5

package/dist-lib/lib.js

@@ -18789,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 };
@@ -19016,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;
@@ -19911,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) {
@@ -19964,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 {
@@ -20311,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);
@@ -20322,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]);
   }
@@ -20350,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)
@@ -20360,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;
@@ -20372,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);
@@ -20394,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;
@@ -20442,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) {
@@ -20607,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 = [];
@@ -20620,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;
@@ -20641,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)) {
@@ -20991,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);
@@ -21422,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) {
@@ -21433,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)) {
@@ -22042,7 +22440,7 @@ var token_config_default = {
     stripUnderscores: true,
     integerToken: "Integer",
     floatToken: "Float",
-    exponentChars: ["e", "E"],
+    exponentChars: ["e", "E", "d", "D"],
     decimalPoint: ".",
     dotOperatorPrefixes: ["*", "/", "\\", "^"]
   },
@@ -22347,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 });
@@ -27507,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) {
@@ -27834,7 +28099,7 @@ defineBuiltin({
     {
       match: (argTypes) => {
         if (argTypes.length < 1) return null;
-        return [{ kind: "number" }];
+        return [];
       },
       apply: (args) => {
         const v = args[0];
@@ -27855,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;
       }
     }
   ]
@@ -27866,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]);
@@ -28538,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(
@@ -29375,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)
     };
   };
 }
@@ -29765,6 +30057,150 @@ registerIBuiltin({
     };
   }
 });
+var RE_ALPHA = /\p{L}/u;
+var RE_ALPHANUM = /[\p{L}\p{N}]/u;
+var RE_CNTRL = /\p{Cc}/u;
+var RE_GRAPHIC = /[\p{L}\p{N}\p{P}\p{S}\p{M}]/u;
+var RE_LOWER = /\p{Ll}/u;
+var RE_PUNCT = /\p{P}/u;
+var RE_UPPER = /\p{Lu}/u;
+var RE_WSPACE = /\s/u;
+function isstrpropPredicate(category) {
+  switch (category) {
+    case "alpha":
+      return (cp) => RE_ALPHA.test(String.fromCodePoint(cp));
+    case "alphanum":
+      return (cp) => RE_ALPHANUM.test(String.fromCodePoint(cp));
+    case "cntrl":
+      return (cp) => RE_CNTRL.test(String.fromCodePoint(cp));
+    case "digit":
+      return (cp) => cp >= 48 && cp <= 57;
+    case "graphic":
+      return (cp) => RE_GRAPHIC.test(String.fromCodePoint(cp));
+    case "lower":
+      return (cp) => RE_LOWER.test(String.fromCodePoint(cp));
+    case "print":
+      return (cp) => cp === 32 || RE_GRAPHIC.test(String.fromCodePoint(cp));
+    case "punct":
+      return (cp) => RE_PUNCT.test(String.fromCodePoint(cp));
+    case "wspace":
+      return (cp) => RE_WSPACE.test(String.fromCodePoint(cp));
+    case "upper":
+      return (cp) => RE_UPPER.test(String.fromCodePoint(cp));
+    case "xdigit":
+      return (cp) => cp >= 48 && cp <= 57 || cp >= 65 && cp <= 70 || cp >= 97 && cp <= 102;
+    default:
+      return null;
+  }
+}
+function stringCodePoints(s) {
+  const out = [];
+  for (const ch of s) out.push(ch.codePointAt(0));
+  return out;
+}
+function logicalRowFromString(s, pred, shape) {
+  const cps = stringCodePoints(s);
+  const data = new FloatXArray(cps.length);
+  for (let i = 0; i < cps.length; i++) data[i] = pred(cps[i]) ? 1 : 0;
+  return {
+    kind: "tensor",
+    data,
+    shape: shape ?? [1, cps.length],
+    _isLogical: true,
+    _rc: 1
+  };
+}
+function logicalFromNumericTensor(data, shape, pred) {
+  const out = new FloatXArray(data.length);
+  for (let i = 0; i < data.length; i++) {
+    out[i] = pred(Math.round(data[i])) ? 1 : 0;
+  }
+  return {
+    kind: "tensor",
+    data: out,
+    shape: [...shape],
+    _isLogical: true,
+    _rc: 1
+  };
+}
+function isstrpropApply(args) {
+  const v = args[0];
+  const category = toString(args[1]);
+  const pred = isstrpropPredicate(category);
+  if (!pred) {
+    throw new RuntimeError(`isstrprop: unknown category '${category}'`);
+  }
+  let forceCell = false;
+  if (args.length >= 3) {
+    const flagName = toString(args[2]).toLowerCase();
+    if (flagName !== "forcecelloutput") {
+      throw new RuntimeError(`isstrprop: unknown name '${toString(args[2])}'`);
+    }
+    if (args.length < 4) {
+      throw new RuntimeError("isstrprop: 'ForceCellOutput' requires a value");
+    }
+    forceCell = toNumber(args[3]) !== 0;
+  }
+  if (isRuntimeCell(v)) {
+    const out = new Array(v.data.length);
+    for (let i = 0; i < v.data.length; i++) {
+      const elem = v.data[i];
+      const s = isText(elem) ? toString(elem) : "";
+      out[i] = logicalRowFromString(s, pred);
+    }
+    return RTV.cell(out, [...v.shape]);
+  }
+  let result;
+  if (isRuntimeString(v)) {
+    result = logicalRowFromString(toString(v), pred);
+  } else if (isRuntimeChar(v)) {
+    const c = v;
+    result = logicalRowFromString(
+      c.value,
+      pred,
+      c.shape ? [...c.shape] : void 0
+    );
+  } else if (isRuntimeTensor(v)) {
+    result = logicalFromNumericTensor(v.data, v.shape, pred);
+  } else if (isRuntimeNumber(v) || isRuntimeLogical(v)) {
+    const cp = Math.round(toNumber(v));
+    const data = new FloatXArray(1);
+    data[0] = pred(cp) ? 1 : 0;
+    result = { kind: "tensor", data, shape: [1, 1], _isLogical: true, _rc: 1 };
+  } else {
+    throw new RuntimeError("isstrprop: unsupported input type");
+  }
+  if (forceCell) return RTV.cell([result], [1, 1]);
+  return result;
+}
+registerIBuiltin({
+  name: "isstrprop",
+  help: {
+    signatures: [
+      "TF = isstrprop(str, category)",
+      "TF = isstrprop(str, category, 'ForceCellOutput', tf)"
+    ],
+    description: "Test which characters in str belong to a category (alpha, alphanum, cntrl, digit, graphic, lower, print, punct, upper, wspace, xdigit). Returns a logical array, or a cell of logical vectors when str is a cell array or ForceCellOutput is true. Numeric input is treated as Unicode code points."
+  },
+  resolve: (argTypes) => {
+    if (argTypes.length < 2 || argTypes.length > 4) return null;
+    if (!isTextType(argTypes[1])) return null;
+    if (argTypes.length >= 3 && !isTextType(argTypes[2])) return null;
+    if (argTypes.length === 4) {
+      const k = argTypes[3].kind;
+      if (k !== "number" && k !== "boolean") return null;
+    }
+    const t0 = argTypes[0];
+    if (t0.kind !== "char" && t0.kind !== "string" && t0.kind !== "number" && t0.kind !== "boolean" && t0.kind !== "tensor" && t0.kind !== "cell") {
+      return null;
+    }
+    const isCell = t0.kind === "cell";
+    return {
+      outputTypes: isCell ? [{ kind: "cell" }] : [{ kind: "tensor", isComplex: false, isLogical: true }],
+      apply: (args) => isstrpropApply(args)
+    };
+  }
+});
 registerIBuiltin({
   name: "contains",
   resolve: (argTypes) => {
@@ -33150,11 +33586,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;
@@ -35472,6 +35912,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,
@@ -36601,6 +37100,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: [
@@ -37983,6 +38607,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"],
@@ -39028,7 +39670,7 @@ for (const name of ["clear", "clc", "clf"]) {
     name,
     resolve: () => ({
       outputTypes: [],
-      apply: () => 0
+      apply: () => void 0
     })
   });
 }
@@ -39162,7 +39804,7 @@ registerIBuiltin({
   name: "set",
   resolve: () => ({
     outputTypes: [],
-    apply: () => 0
+    apply: () => void 0
   })
 });
 for (const name of [
@@ -39184,7 +39826,7 @@ for (const name of [
     name,
     resolve: () => ({
       outputTypes: [],
-      apply: () => 0
+      apply: () => void 0
     })
   });
 }
@@ -40992,6 +41634,15 @@ var H = {
     signatures: ["TF = isequal(A, B, ...)"],
     description: "True if all inputs are equal (NaN ~= NaN)."
   },
+  // ── Dynamic evaluation ────────────────────────────────────────────────
+  evalin: {
+    signatures: ["V = evalin(WS, EXPR)", "V = evalin(WS, EXPR, DEFAULT)"],
+    description: "Evaluate EXPR in workspace WS ('caller' or 'base'/'workspace').\n\nnumbl-specific note: variables read by evalin must be declared in the\nfunction that owns them with a `% external-access:` comment, e.g.\n    function out = f()\n        % external-access: x y\n        x = 1; y = 2;\n        ...\n    end\nVariables not listed in `% external-access` are stored in a separate\ndynamic map and are only reachable through evalin/assignin. The\ndirective is a comment, so MATLAB ignores it."
+  },
+  assignin: {
+    signatures: ["assignin(WS, NAME, VALUE)"],
+    description: "Assign VALUE to variable NAME in workspace WS ('caller' or 'base'/'workspace').\n\nnumbl-specific note: variables written by assignin must be declared in\nthe function that owns them with a `% external-access:` comment, e.g.\n    function out = f()\n        % external-access: x y\n        x = 1; y = 2;\n        ...\n    end\nVariables not listed in `% external-access` are stored in a separate\ndynamic map and are only reachable through evalin/assignin. The\ndirective is a comment, so MATLAB ignores it."
+  },
   // ── Misc ──────────────────────────────────────────────────────────────
   disp: {
     signatures: ["disp(X)"],
@@ -43904,6 +44555,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",
@@ -43992,6 +44751,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "webread",
   "delete",
   "rmdir",
+  "movefile",
   "unzip",
   "dir",
   "warning",
@@ -44005,7 +44765,8 @@ var SPECIAL_BUILTIN_NAMES = [
   "ode45",
   "ode23",
   "deval",
-  "toc"
+  "toc",
+  "quadgk"
 ];
 
 // src/numbl-core/runtime/specialBuiltins.ts
@@ -44019,42 +44780,58 @@ 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("toc", (nargout) => {
     const elapsed = (performance.now() - getTicTime()) / 1e3;
@@ -44064,12 +44841,13 @@ function registerSpecialBuiltins(rt) {
     }
     return RTV.num(elapsed);
   });
-  registerSpecial("warning", (_nargout, args) => {
-    if (args.length === 0) return RTV.num(0);
+  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")],
@@ -44098,9 +44876,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));
@@ -44111,27 +44889,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 {
@@ -44142,7 +44900,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);
@@ -44174,6 +44932,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);
   });
@@ -44796,7 +45603,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");
@@ -44806,7 +45613,6 @@ function registerSpecialBuiltins(rt) {
     for (const arg of margs) {
       io.deleteFile(toString(arg));
     }
-    return 0;
   });
   registerSpecial("rmdir", (nargout, args) => {
     const io = requireFileIO();
@@ -44829,6 +45635,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)
@@ -44880,7 +45714,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();
@@ -44977,7 +45811,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));
@@ -44992,7 +45826,6 @@ function registerSpecialBuiltins(rt) {
     } else {
       rt.setWorkspaceVariable(varName, args[2]);
     }
-    return 0;
   });
   registerSpecial("evalin", (_nargout, args) => {
     if (args.length < 2)
@@ -45013,13 +45846,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 ?? "";
@@ -45063,7 +45895,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) {
@@ -45083,11 +45915,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));
@@ -45150,11 +45982,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];
@@ -45162,20 +45994,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 {
@@ -45183,15 +46021,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",
@@ -45200,43 +46041,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") {
@@ -45247,26 +46086,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);
@@ -45811,6 +46649,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) {
@@ -46379,6 +47240,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) {
@@ -46387,7 +47249,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)
@@ -46397,6 +47266,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) {
@@ -46787,14 +47657,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];
@@ -47021,6 +47897,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
@@ -47300,23 +48178,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()]
       ])
     );
   }
@@ -48148,6 +49029,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) {
@@ -50541,6 +51479,9 @@ function execStmt(stmt) {
     case "ExprStmt": {
       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);
@@ -50564,19 +51505,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") {
@@ -51138,7 +52085,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;
         }
@@ -51618,6 +52569,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;
@@ -51720,6 +52682,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 {
@@ -51731,6 +52696,9 @@ register("run", (ctx, args) => {
         sys.chdir(oldCwd);
       } catch {
       }
+      if (ctx.rt.onCwdChange) {
+        ctx.rt.onCwdChange(sys.cwd());
+      }
     }
   }
   return void 0;
@@ -51750,7 +52718,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;
@@ -51784,13 +52759,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];
@@ -51882,7 +52862,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) {
@@ -52026,6 +53018,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;
@@ -52075,7 +53072,7 @@ 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 = [];
@@ -53680,6 +54677,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,
@@ -53697,6 +54719,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) {
@@ -53730,6 +54755,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) {
@@ -53771,13 +54801,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) {
@@ -53795,10 +54851,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);
@@ -53838,26 +54898,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,
       {
@@ -53865,11 +54975,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,
@@ -53901,12 +55018,13 @@ ${jitSections.join("\n\n")}` : "// 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:
@@ -53942,6 +55060,9 @@ ${jitSections.join("\n\n")}` : "// No JS generated";
         unregisterIBuiltin(ib.name);
       }
     }
+    for (const [, ib] of savedSpecialBuiltins) {
+      registerDynamicIBuiltin(ib);
+    }
   }
 }
 export {