numbl 0.4.6 → 0.4.7

package/dist-lib/lib.js

@@ -1141,6 +1141,9 @@ var RTV = {
     }
     return new RuntimeClassInstance(className, fields, isHandleClass2);
   },
+  classInstanceArray(className, elements, shape) {
+    return new RuntimeClassInstanceArray(className, elements, shape);
+  },
   complex(re, im) {
     return new RuntimeComplexNumber(re, im);
   },
@@ -18426,6 +18429,24 @@ function lu(data, m, n) {
 }
 function svd(data, m, n, econ, computeUV) {
   const k = Math.min(m, n);
+  let finite = true;
+  for (let i = 0; i < data.length; i++) {
+    if (!Number.isFinite(data[i])) {
+      finite = false;
+      break;
+    }
+  }
+  if (!finite) {
+    const sNan = allocFloat64Array(k).fill(NaN);
+    if (!computeUV) return { S: sNan };
+    const uCols2 = econ ? k : m;
+    const vCols2 = econ ? k : n;
+    return {
+      U: allocFloat64Array(m * uCols2).fill(NaN),
+      S: sNan,
+      V: allocFloat64Array(n * vCols2).fill(NaN)
+    };
+  }
   const a = allocFloat64Array(data);
   const s = allocFloat64Array(k);
   const JOBU_A2 = 0;
@@ -22299,6 +22320,24 @@ function sprintfFormat(fmt, args) {
           case "t":
             result += "	";
             break;
+          case "r":
+            result += "\r";
+            break;
+          case "a":
+            result += "\x07";
+            break;
+          case "b":
+            result += "\b";
+            break;
+          case "f":
+            result += "\f";
+            break;
+          case "v":
+            result += "\v";
+            break;
+          case "0":
+            result += "\0";
+            break;
           case "\\":
             result += "\\";
             break;
@@ -24235,8 +24274,8 @@ function indexIntoScalar(base, indices) {
     const idx = indices[0];
     if (isRuntimeTensor(idx)) {
       const is0x0 = idx.shape.length === 2 && idx.shape[0] === 0 && idx.shape[1] === 0;
-      const outShape = is0x0 ? [0, 0] : [...idx.shape];
-      return RTV.tensor(allocFloat64Array(0), outShape);
+      const outShape2 = is0x0 ? [0, 0] : [...idx.shape];
+      return RTV.tensor(allocFloat64Array(0), outShape2);
     }
   }
   if (indices.length === 1) {
@@ -24266,22 +24305,46 @@ function indexIntoScalar(base, indices) {
       if (k !== 1) throw new RuntimeError("Index exceeds array bounds");
     }
     const n = idx.data.length;
-    const scalarRe = isRuntimeNumber(base) ? base : base.re;
-    const data = allocFloat64Array(n);
-    data.fill(scalarRe);
+    const scalarRe2 = isRuntimeNumber(base) ? base : base.re;
+    const data2 = allocFloat64Array(n);
+    data2.fill(scalarRe2);
     if (isRuntimeComplexNumber(base) && base.im !== 0) {
       const im = allocFloat64Array(n);
       im.fill(base.im);
-      return RTV.tensor(data, [...idx.shape], im);
+      return RTV.tensor(data2, [...idx.shape], im);
     }
-    return RTV.tensor(data, [...idx.shape]);
+    return RTV.tensor(data2, [...idx.shape]);
   }
+  const dimLengths = [];
+  let anyTensor = false;
   for (const idx of indices) {
-    if (isColonIndex(idx)) continue;
-    const i = toNumber(idx);
-    if (i !== 1) throw new RuntimeError("Index exceeds array bounds");
+    if (isColonIndex(idx)) {
+      dimLengths.push(1);
+    } else if (isRuntimeTensor(idx)) {
+      anyTensor = true;
+      for (let i = 0; i < idx.data.length; i++) {
+        if (Math.round(idx.data[i]) !== 1)
+          throw new RuntimeError("Index exceeds array bounds");
+      }
+      dimLengths.push(idx.data.length);
+    } else {
+      if (Math.round(toNumber(idx)) !== 1)
+        throw new RuntimeError("Index exceeds array bounds");
+      dimLengths.push(1);
+    }
   }
-  return base;
+  if (!anyTensor) return base;
+  const total = dimLengths.reduce((a, b) => a * b, 1);
+  const scalarRe = isRuntimeNumber(base) ? base : base.re;
+  const data = allocFloat64Array(total);
+  data.fill(scalarRe);
+  const outShape = dimLengths.length >= 2 ? dimLengths : [dimLengths[0], 1];
+  if (isRuntimeComplexNumber(base) && base.im !== 0) {
+    const im = allocFloat64Array(total);
+    im.fill(base.im);
+    return RTV.tensor(data, outShape, im);
+  }
+  return RTV.tensor(data, outShape);
 }
 function indexIntoTensor(base, indices) {
   if (indices.length === 1) {
@@ -24316,11 +24379,13 @@ function indexIntoTensor(base, indices) {
 function indexIntoTensor1D(base, idx) {
   if (isColonIndex(idx)) {
     const imag2 = base.imag ? allocFloat64Array(base.imag) : void 0;
-    return RTV.tensor(
+    const result = RTV.tensor(
       allocFloat64Array(base.data),
       [base.data.length, 1],
       imag2
     );
+    if (base._isLogical === true) result._isLogical = true;
+    return result;
   }
   if (isRuntimeLogical(idx)) {
     if (!idx) return RTV.tensor(allocFloat64Array(0), [0, 0]);
@@ -24518,6 +24583,17 @@ function indexIntoChar(base, indices) {
   if (indices.length === 1) {
     const idx = indices[0];
     if (isColonIndex(idx)) return base;
+    if (isRuntimeTensor(idx) && idx._isLogical) {
+      let result = "";
+      for (let k = 0; k < idx.data.length; k++) {
+        if (idx.data[k] !== 0) {
+          if (k >= base.value.length)
+            throw new RuntimeError("Index exceeds char array length");
+          result += base.value[k];
+        }
+      }
+      return RTV.char(result);
+    }
     if (isRuntimeTensor(idx)) {
       let result = "";
       for (let k = 0; k < idx.data.length; k++) {
@@ -24536,22 +24612,19 @@ function indexIntoChar(base, indices) {
   if (indices.length === 2) {
     const rowIdx = indices[0];
     const colIdx = indices[1];
-    let rows;
-    if (isColonIndex(rowIdx)) {
-      rows = Array.from({ length: nRows }, (_, i) => i);
-    } else if (isRuntimeTensor(rowIdx)) {
-      rows = Array.from(rowIdx.data, (v) => Math.round(v) - 1);
-    } else {
-      rows = [Math.round(toNumber(rowIdx)) - 1];
-    }
-    let cols;
-    if (isColonIndex(colIdx)) {
-      cols = Array.from({ length: nCols }, (_, i) => i);
-    } else if (isRuntimeTensor(colIdx)) {
-      cols = Array.from(colIdx.data, (v) => Math.round(v) - 1);
-    } else {
-      cols = [Math.round(toNumber(colIdx)) - 1];
-    }
+    const toPositions = (idx) => {
+      if (isRuntimeTensor(idx) && idx._isLogical) {
+        const out = [];
+        for (let i = 0; i < idx.data.length; i++)
+          if (idx.data[i] !== 0) out.push(i);
+        return out;
+      }
+      if (isRuntimeTensor(idx))
+        return Array.from(idx.data, (v) => Math.round(v) - 1);
+      return [Math.round(toNumber(idx)) - 1];
+    };
+    const rows = isColonIndex(rowIdx) ? Array.from({ length: nRows }, (_, i) => i) : toPositions(rowIdx);
+    const cols = isColonIndex(colIdx) ? Array.from({ length: nCols }, (_, i) => i) : toPositions(colIdx);
     let result = "";
     for (const r of rows) {
       for (const c of cols) {
@@ -24577,11 +24650,11 @@ function indexIntoLogical(base, indices) {
         const vi = Math.round(idx.data[i2]);
         if (vi !== 1) throw new RuntimeError("Index exceeds array bounds");
       }
-      const data = allocFloat64Array(idx.data.length);
-      data.fill(base ? 1 : 0);
-      const result = RTV.tensor(data, [1, idx.data.length]);
-      result._isLogical = true;
-      return result;
+      const data2 = allocFloat64Array(idx.data.length);
+      data2.fill(base ? 1 : 0);
+      const result2 = RTV.tensor(data2, [...idx.shape]);
+      result2._isLogical = true;
+      return result2;
     }
     if (isRuntimeLogical(idx)) {
       if (!idx) return RTV.tensor(allocFloat64Array(0), [0, 0]);
@@ -24591,16 +24664,35 @@ function indexIntoLogical(base, indices) {
     if (i !== 1) throw new RuntimeError("Index exceeds array bounds");
     return base;
   }
+  const dimLengths = [];
+  let anyTensor = false;
   for (const idx of indices) {
-    if (isColonIndex(idx)) continue;
-    if (isRuntimeLogical(idx)) {
+    if (isColonIndex(idx)) {
+      dimLengths.push(1);
+    } else if (isRuntimeLogical(idx)) {
       if (!idx) return RTV.tensor(allocFloat64Array(0), [0, 0]);
-      continue;
+      dimLengths.push(1);
+    } else if (isRuntimeTensor(idx)) {
+      anyTensor = true;
+      for (let i = 0; i < idx.data.length; i++) {
+        if (Math.round(idx.data[i]) !== 1)
+          throw new RuntimeError("Index exceeds array bounds");
+      }
+      dimLengths.push(idx.data.length);
+    } else {
+      if (Math.round(toNumber(idx)) !== 1)
+        throw new RuntimeError("Index exceeds array bounds");
+      dimLengths.push(1);
     }
-    const i = Math.round(toNumber(idx));
-    if (i !== 1) throw new RuntimeError("Index exceeds array bounds");
   }
-  return base;
+  if (!anyTensor) return base;
+  const total = dimLengths.reduce((a, b) => a * b, 1);
+  const data = allocFloat64Array(total);
+  data.fill(base ? 1 : 0);
+  const outShape = dimLengths.length >= 2 ? dimLengths : [dimLengths[0], 1];
+  const result = RTV.tensor(data, outShape);
+  result._isLogical = true;
+  return result;
 }
 function indexIntoTensorWithTensor(base, idx) {
   const baseLogical = base._isLogical === true;
@@ -24680,11 +24772,15 @@ function indexIntoRTValue(base, indices) {
     return indexIntoLogical(base, indices);
   }
   if (isRuntimeStruct(base) || isRuntimeClassInstance(base)) {
-    if (indices.length === 1) {
-      const i = Math.round(toNumber(indices[0]));
-      if (i !== 1) throw new RuntimeError("Index exceeds struct dimensions");
-      return base;
-    }
+    const allOnes = indices.length >= 1 && indices.every((idx) => {
+      if (isRuntimeNumber(idx)) return Math.round(idx) === 1;
+      if (isRuntimeLogical(idx)) return idx === true;
+      if (isRuntimeTensor(idx))
+        return idx.data.length === 1 && Math.round(idx.data[0]) === 1;
+      return false;
+    });
+    if (allOnes) return base;
+    throw new RuntimeError("Index exceeds struct dimensions");
   }
   if (isRuntimeSparseMatrix(base)) {
     return indexIntoSparse(base, indices);
@@ -24734,7 +24830,13 @@ function storeIntoTensor(base, indices, rhs, _rt) {
   }
   if (isShared(base)) {
     const cowImag = base.imag ? allocFloat64Array(base.imag) : void 0;
-    base = RTV.tensor(allocFloat64Array(base.data), [...base.shape], cowImag);
+    const copy = RTV.tensor(
+      allocFloat64Array(base.data),
+      [...base.shape],
+      cowImag
+    );
+    copy._isLogical = base._isLogical;
+    base = copy;
   }
   if (indices.length === 1) {
     return storeIntoTensor1D(base, indices[0], rhs);
@@ -24762,7 +24864,9 @@ function deleteTensorElements(base, idx) {
       toDelete.add(Math.round(idx.data[i]) - 1);
     }
   } else if (isColonIndex(idx)) {
-    return RTV.tensor(allocFloat64Array(0), [0, 0]);
+    const empty = RTV.tensor(allocFloat64Array(0), [0, 0]);
+    empty._isLogical = base._isLogical;
+    return empty;
   }
   if (toDelete.size === 0) return base;
   const newData = [];
@@ -24777,7 +24881,9 @@ function deleteTensorElements(base, idx) {
   const baseIsColVec = base.shape.length >= 2 && base.shape[1] === 1 && base.shape[0] !== 1;
   const outShape = baseIsColVec ? [newData.length, 1] : [1, newData.length];
   const imOut = hasImag && newIm.some((x) => x !== 0) ? allocFloat64Array(newIm) : void 0;
-  return RTV.tensor(allocFloat64Array(newData), outShape, imOut);
+  const result = RTV.tensor(allocFloat64Array(newData), outShape, imOut);
+  result._isLogical = base._isLogical;
+  return result;
 }
 function collectDelIndices(idx, dimLen) {
   const s = /* @__PURE__ */ new Set();
@@ -24817,7 +24923,9 @@ function deleteTensorRowsOrCols(base, indices) {
         if (newIm && base.imag) newIm[dstIdx] = base.imag[srcIdx];
       }
     }
-    return RTV.tensor(newData, [newNrows, ncols], newIm);
+    const result = RTV.tensor(newData, [newNrows, ncols], newIm);
+    result._isLogical = base._isLogical;
+    return result;
   }
   if (isColonIndex(indices[0])) {
     const delCols = collectDelIndices(indices[1], ncols);
@@ -24836,7 +24944,9 @@ function deleteTensorRowsOrCols(base, indices) {
         if (newIm && base.imag) newIm[dstIdx] = base.imag[srcIdx];
       }
     }
-    return RTV.tensor(newData, [nrows, newNcols], newIm);
+    const result = RTV.tensor(newData, [nrows, newNcols], newIm);
+    result._isLogical = base._isLogical;
+    return result;
   }
   throw new RuntimeError("Cannot delete from both row and column dimensions");
 }
@@ -24906,6 +25016,9 @@ function storeIntoTensor1D(base, idx, rhs) {
 }
 function storeIntoTensorByVector(base, idx, rhs) {
   if (idx._isLogical) {
+    if (isRuntimeTensor(rhs) && rhs.data.length === 1) {
+      rhs = rhs.imag && rhs.imag[0] !== 0 ? RTV.complex(rhs.data[0], rhs.imag[0]) : RTV.num(rhs.data[0]);
+    }
     const { re: rhsRe, im: rhsIm } = isRuntimeTensor(rhs) ? { re: null, im: null } : toReIm(rhs);
     let maxTruthy = -1;
     for (let i = 0; i < idx.data.length; i++) {
@@ -25155,7 +25268,8 @@ function storeIntoTensorND(base, indices, rhs) {
   const dimIndices = indices.map((idx, dim) => {
     const dimSize = dim < shape.length ? shape[dim] : 1;
     if (isColonIndex(idx)) {
-      if (dimSize === 0 && rhsShape) {
+      const dimSizeUnknown = dimSize === 0 || dim >= shape.length;
+      if (dimSizeUnknown && rhsShape) {
         const rDim = rhsDimCursor < rhsShape.length ? rhsShape[rhsDimCursor] : 1;
         rhsDimCursor++;
         return Array.from({ length: rDim }, (_, i) => i);
@@ -25472,6 +25586,9 @@ function horzcat(...values) {
   if (values.some((v) => isRuntimeSparseMatrix(v))) {
     return sparseCatAlongDim(values, 1);
   }
+  if (values.some((v) => isRuntimeCell(v))) {
+    return cellCatAlongDim(values, 1);
+  }
   if (values.some((v) => isRuntimeChar(v))) {
     let result = "";
     for (const v of values) {
@@ -25492,9 +25609,6 @@ function horzcat(...values) {
     }
     return RTV.string(result);
   }
-  if (values.some((v) => isRuntimeCell(v))) {
-    return cellCatAlongDim(values, 1);
-  }
   if (values.some((v) => isRuntimeStruct(v) || isRuntimeStructArray(v))) {
     return structCat(values);
   }
@@ -25506,12 +25620,12 @@ function vertcat(...values) {
   if (values.some((v) => isRuntimeSparseMatrix(v))) {
     return sparseCatAlongDim(values, 0);
   }
-  if (values.some((v) => isRuntimeChar(v))) {
-    return vertcatChars(values);
-  }
   if (values.some((v) => isRuntimeCell(v))) {
     return cellCatAlongDim(values, 0);
   }
+  if (values.some((v) => isRuntimeChar(v))) {
+    return vertcatChars(values);
+  }
   if (values.some((v) => isRuntimeStruct(v) || isRuntimeStructArray(v))) {
     return structCat(values);
   }
@@ -25857,11 +25971,22 @@ function catAlongDim(values, dimIdx) {
   if (allLogical) result._isLogical = true;
   return result;
 }
+function isEmptyNonCellOperand(v) {
+  if (isRuntimeChar(v)) return v.value.length === 0;
+  if (isRuntimeTensor(v)) return v.data.length === 0;
+  return false;
+}
 function cellCatAlongDim(values, dimIdx) {
-  let cells = values.map((v) => {
-    if (isRuntimeCell(v)) return v;
-    return RTV.cell([v], [1, 1]);
-  });
+  let cells = [];
+  for (const v of values) {
+    if (isRuntimeCell(v)) {
+      cells.push(v);
+    } else if (isEmptyNonCellOperand(v)) {
+      continue;
+    } else {
+      cells.push(RTV.cell([v], [1, 1]));
+    }
+  }
   cells = cells.filter((c) => c.data.length > 0);
   if (cells.length === 0) return RTV.cell([], [0, 0]);
   if (cells.length === 1) return cells[0];
@@ -29760,7 +29885,7 @@ var ExpressionParser = class extends ParserBase {
         }
       } else if (expr.type === "Ident" && this.peekToken() === 41 /* At */ && this.peekTokenAt(1) === 4 /* Ident */) {
         this.pos++;
-        const className = this.expectIdent();
+        const className = this.parseQualifiedName();
         if (!this.consume(50 /* LParen */)) {
           throw this.error("expected '(' after superclass name in super call");
         }
@@ -30361,7 +30486,10 @@ var ControlFlowParser = class extends CommandParser {
     let catchBody = [];
     if (this.consume(27 /* Catch */)) {
       if (this.peekToken() === 4 /* Ident */) {
-        catchVar = this.expectIdent();
+        const after = this.peekTokenAt(1);
+        if (after === void 0 || after === 68 /* Newline */ || after === 49 /* Semicolon */ || after === 47 /* Comma */ || after === 15 /* End */) {
+          catchVar = this.expectIdent();
+        }
       }
       catchBody = this.parseBlock((t) => t === 15 /* End */);
     }
@@ -30486,8 +30614,12 @@ var ArgumentsParser = class extends ControlFlowParser {
       dimensions = this.parseArgDimensions();
     }
     let className = null;
-    if (this.peekToken() === 4 /* Ident */ && this.peekToken() !== 68 /* Newline */ && this.peekToken() !== 49 /* Semicolon */) {
+    if (this.peekToken() === 4 /* Ident */) {
       className = this.next().lexeme;
+      while (this.peekToken() === 45 /* Dot */) {
+        this.consume(45 /* Dot */);
+        className += "." + this.expectIdent();
+      }
     }
     let validators = [];
     if (this.peekToken() === 54 /* LBrace */) {
@@ -30523,18 +30655,28 @@ var ArgumentsParser = class extends ControlFlowParser {
     return dims;
   }
   /**
-   * Parse validator list: {mustBeNumeric, mustBePositive}
+   * Parse validator list: {mustBeNumeric, mustBePositive}. Validators may be
+   * full function calls with arguments, e.g.
+   * `{mustBeMember(x,["a","b"]), mustBeInRange(x,0,7)}`. The validator bodies
+   * are not enforced at runtime, so we capture the top-level validator name
+   * tokens and skip past any nested `(...)`, `[...]`, `{...}` so parsing
+   * resumes correctly at the default value (`= expr`) or end of line.
    */
   parseArgValidators() {
     this.consume(54 /* LBrace */);
     const validators = [];
-    while (this.peekToken() !== 55 /* RBrace */ && this.peekToken() !== void 0) {
-      if (this.consume(47 /* Comma */)) continue;
-      if (this.peekToken() === 4 /* Ident */) {
-        validators.push(this.next().lexeme);
-      } else {
-        break;
+    let depth = 0;
+    while (this.peekToken() !== void 0) {
+      const tok = this.peekToken();
+      if (depth === 0 && tok === 55 /* RBrace */) break;
+      if (tok === 50 /* LParen */ || tok === 52 /* LBracket */ || tok === 54 /* LBrace */) {
+        depth++;
+      } else if (tok === 51 /* RParen */ || tok === 53 /* RBracket */ || tok === 55 /* RBrace */) {
+        depth--;
+      } else if (depth === 0 && tok === 4 /* Ident */) {
+        validators.push(this.peek().lexeme);
       }
+      this.next();
     }
     this.consume(55 /* RBrace */);
     return validators;
@@ -30565,7 +30707,8 @@ var FunctionParser = class extends ArgumentsParser {
     if (this.consume(52 /* LBracket */)) {
       if (this.peekToken() !== 53 /* RBracket */) {
         outputs.push(this.expectIdentOrTilde());
-        while (this.consume(47 /* Comma */)) {
+        while (this.peekToken() === 47 /* Comma */ || this.peekToken() === 4 /* Ident */ || this.peekToken() === 40 /* Tilde */) {
+          this.consume(47 /* Comma */);
           outputs.push(this.expectIdentOrTilde());
         }
       }
@@ -30673,6 +30816,14 @@ var FunctionParser = class extends ArgumentsParser {
 };
 
 // src/numbl-core/parser/ClassParser.ts
+var HANDLE_BASE_CLASSES = /* @__PURE__ */ new Set([
+  "handle",
+  "dynamicprops",
+  "matlab.mixin.Copyable",
+  "matlab.mixin.SetGet",
+  "matlab.mixin.SetGetExactNames",
+  "hgsetget"
+]);
 var ClassParser = class extends FunctionParser {
   // ── Imports & ClassDef ───────────────────────────────────────────────
   parseImport() {
@@ -30707,7 +30858,11 @@ var ClassParser = class extends FunctionParser {
     const name = this.parseQualifiedName();
     let superClass = null;
     if (this.consume(43 /* Less */)) {
-      superClass = this.parseQualifiedName();
+      const supers = [this.parseQualifiedName()];
+      while (this.consume(38 /* And */)) {
+        supers.push(this.parseQualifiedName());
+      }
+      superClass = supers.some((s) => HANDLE_BASE_CLASSES.has(s)) ? "handle" : supers[0];
     }
     const members = [];
     while (true) {
@@ -31582,7 +31737,7 @@ function insertFunctionEndTokens(tokens) {
     }
     if (BLOCK_OPENERS.has(tok.token)) {
       depth++;
-    } else if (tok.token === 15 /* End */ && groupDepth === 0) {
+    } else if (tok.token === 15 /* End */ && groupDepth === 0 && tokens[i - 1]?.token !== 45 /* Dot */) {
       depth--;
       if (depth === 0 && inFunction) {
         inFunction = false;
@@ -34294,6 +34449,8 @@ defineBuiltin({
         if (isRuntimeComplexNumber(v)) return v.im === 0;
         if (isRuntimeTensor(v)) return imagAllZero(v.imag);
         if (isRuntimeSparseMatrix(v)) return !v.pi || imagAllZero(v.pi);
+        if (isRuntimeCell(v) || isRuntimeStruct(v) || isRuntimeStructArray(v) || isRuntimeString(v) || isRuntimeFunction(v))
+          return false;
         return true;
       }
     }
@@ -34765,10 +34922,79 @@ defineBuiltin({
   name: "ischar",
   cases: [anyToLogicalCase((args) => isRuntimeChar(args[0]))]
 });
+defineBuiltin({
+  name: "isstr",
+  cases: [anyToLogicalCase((args) => isRuntimeChar(args[0]))]
+});
 defineBuiltin({
   name: "isstring",
   cases: [anyToLogicalCase((args) => isRuntimeString(args[0]))]
 });
+var MATLAB_KEYWORDS = /* @__PURE__ */ new Set([
+  "break",
+  "case",
+  "catch",
+  "classdef",
+  "continue",
+  "else",
+  "elseif",
+  "end",
+  "for",
+  "function",
+  "global",
+  "if",
+  "otherwise",
+  "parfor",
+  "persistent",
+  "return",
+  "spmd",
+  "switch",
+  "try",
+  "while"
+]);
+function singleRowText(v) {
+  if (isRuntimeChar(v)) {
+    if (v.shape && v.shape.length >= 1 && v.shape[0] > 1) return null;
+    return v.value;
+  }
+  if (isRuntimeString(v)) return v;
+  return null;
+}
+defineBuiltin({
+  name: "isvarname",
+  cases: [
+    anyToLogicalCase((args) => {
+      const s = singleRowText(args[0]);
+      if (s === null || s.length === 0 || s.length > 63) return false;
+      if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(s)) return false;
+      return !MATLAB_KEYWORDS.has(s);
+    })
+  ]
+});
+defineBuiltin({
+  name: "iskeyword",
+  cases: [
+    {
+      // iskeyword() with no args returns the list of keywords (column cell).
+      match: (argTypes) => {
+        if (argTypes.length === 0) return [{ kind: "cell" }];
+        if (argTypes.length === 1) return [{ kind: "boolean" }];
+        return null;
+      },
+      apply: (args) => {
+        if (args.length === 0) {
+          const names = [...MATLAB_KEYWORDS].sort();
+          return RTV.cell(
+            names.map((n) => RTV.char(n)),
+            [names.length, 1]
+          );
+        }
+        const s = singleRowText(args[0]);
+        return RTV.logical(s !== null && MATLAB_KEYWORDS.has(s));
+      }
+    }
+  ]
+});
 defineBuiltin({
   name: "iscell",
   cases: [anyToLogicalCase((args) => isRuntimeCell(args[0]))]
@@ -34785,6 +35011,82 @@ defineBuiltin({
   name: "issparse",
   cases: [anyToLogicalCase((args) => isRuntimeSparseMatrix(args[0]))]
 });
+defineBuiltin({
+  name: "isobject",
+  cases: [
+    anyToLogicalCase(
+      (args) => isRuntimeClassInstance(args[0]) || isRuntimeClassInstanceArray(args[0])
+    )
+  ]
+});
+defineBuiltin({
+  name: "isprop",
+  help: {
+    signatures: ["tf = isprop(obj, PropertyName)"],
+    description: "Return logical 1 where PropertyName is a property of object obj, else 0. The result has the same size as obj. Only class objects have properties: structs (even with that field), numeric, char and other built-in types always return false. Methods are not properties."
+  },
+  cases: [
+    {
+      match: (argTypes) => {
+        if (argTypes.length !== 2) return null;
+        return [{ kind: "boolean" }];
+      },
+      apply: (args) => {
+        const v = args[0];
+        const nameArg = args[1];
+        let propName = null;
+        if (isRuntimeChar(nameArg)) propName = nameArg.value;
+        else if (isRuntimeString(nameArg)) propName = nameArg;
+        let answer = false;
+        if (propName !== null) {
+          if (isRuntimeClassInstance(v)) answer = v.fields.has(propName);
+          else if (isRuntimeClassInstanceArray(v))
+            answer = v.elements.length > 0 && v.elements[0].fields.has(propName);
+        }
+        const shape = getShape(v);
+        const n = shape.reduce((a, b) => a * b, 1);
+        if (n === 1) return RTV.logical(answer);
+        const data = allocFloat64Array(n);
+        if (answer) data.fill(1);
+        return new RuntimeTensor(data, shape, void 0, true);
+      }
+    }
+  ]
+});
+defineBuiltin({
+  name: "addprop",
+  help: {
+    signatures: ["p = addprop(obj, PropertyName)"],
+    description: "Add a dynamic property named PropertyName to the dynamicprops (handle) object obj. The property can then be read and assigned via obj.PropertyName. Returns a meta.DynamicProperty describing the new property."
+  },
+  cases: [
+    {
+      match: (argTypes) => {
+        if (argTypes.length !== 2) return null;
+        return [{ kind: "unknown" }];
+      },
+      apply: (args) => {
+        const obj = args[0];
+        if (!isRuntimeClassInstance(obj))
+          throw new RuntimeError(
+            "addprop: first argument must be a dynamicprops object"
+          );
+        const name = toString(args[1]);
+        if (!obj.fields.has(name)) {
+          const empty = RTV.tensor(allocFloat64Array(0), [0, 0]);
+          incref(empty);
+          obj.fields.set(name, empty);
+        }
+        return RTV.classInstance(
+          "meta.DynamicProperty",
+          ["Name"],
+          true,
+          /* @__PURE__ */ new Map([["Name", RTV.char(name)]])
+        );
+      }
+    }
+  ]
+});
 defineBuiltin({
   name: "isscalar",
   cases: [
@@ -34982,6 +35284,30 @@ function mkChar(value) {
 defineBuiltin({
   name: "class",
   cases: [
+    // Old-style (pre-classdef) constructor form: class(structData, 'ClassName')
+    // builds a value-type instance whose fields are the struct's fields. The
+    // optional class(s,'Name',parent,...) inheritance form is not supported
+    // (returns null → "unsupported argument types").
+    {
+      match: (argTypes) => {
+        if (argTypes.length !== 2) return null;
+        if (argTypes[0].kind !== "struct") return null;
+        const k = argTypes[1].kind;
+        if (k !== "char" && k !== "string") return null;
+        return [{ kind: "unknown" }];
+      },
+      apply: (args) => {
+        const s = args[0];
+        if (!isRuntimeStruct(s))
+          throw new RuntimeError(
+            "class: first argument must be a scalar struct"
+          );
+        const nameVal = args[1];
+        const className = isRuntimeChar(nameVal) ? nameVal.value : isRuntimeString(nameVal) ? nameVal : String(nameVal);
+        const fieldNames = [...s.fields.keys()];
+        return RTV.classInstance(className, fieldNames, false, s.fields);
+      }
+    },
     {
       match: (argTypes) => {
         if (argTypes.length !== 1) return null;
@@ -35019,6 +35345,26 @@ defineBuiltin({
     }
   ]
 });
+for (const name of ["superiorto", "inferiorto"]) {
+  defineBuiltin({
+    name,
+    help: {
+      signatures: [`${name}('Class1', 'Class2', ...)`],
+      description: name === "superiorto" ? "Establish superior class relationship (old-style class precedence). Accepted as a no-op." : "Establish inferior class relationship (old-style class precedence). Accepted as a no-op."
+    },
+    cases: [
+      {
+        match: (argTypes) => {
+          for (const t of argTypes) {
+            if (t.kind !== "char" && t.kind !== "string") return null;
+          }
+          return [];
+        },
+        apply: () => void 0
+      }
+    ]
+  });
+}
 function fieldnamesApply(args) {
   if (args.length !== 1)
     throw new RuntimeError("fieldnames requires 1 argument");
@@ -35134,6 +35480,11 @@ function validateDim(x) {
     throw new RuntimeError("Size inputs must be nonnegative integers.");
   return Math.max(0, x);
 }
+function toScalarDim(v) {
+  if (isRuntimeTensor(v) && v.data.length !== 1)
+    throw new RuntimeError("Size inputs must be scalar.");
+  return validateDim(toNumber(v));
+}
 function parseShapeArgs(args) {
   if (args.length === 1 && isRuntimeTensor(args[0])) {
     const t = args[0];
@@ -35141,7 +35492,7 @@ function parseShapeArgs(args) {
     for (let i = 0; i < t.data.length; i++) shape.push(validateDim(t.data[i]));
     return shape;
   }
-  return args.map((a) => validateDim(toNumber(a)));
+  return args.map(toScalarDim);
 }
 function arrayConstructorCases(fillFn, scalarValue, opts) {
   const cases = [
@@ -35182,12 +35533,14 @@ function arrayConstructorCases(fillFn, scalarValue, opts) {
         return fillFn(shape);
       }
     },
-    // Multiple scalar args
+    // Multiple scalar args. A 1×1 array counts as a scalar dimension, so
+    // accept `tensor` here too (apply-time validates each is scalar).
     {
       match: (argTypes) => {
         if (argTypes.length <= 1) return null;
         for (const a of argTypes) {
-          if (a.kind !== "number" && a.kind !== "boolean") return null;
+          if (a.kind !== "number" && a.kind !== "boolean" && a.kind !== "tensor")
+            return null;
         }
         const shape = argTypes.map(
           (a) => a.kind === "number" && typeof a.exact === "number" ? a.exact : -1
@@ -35852,7 +36205,6 @@ function anyAllApply(name, mode) {
     if (isRuntimeComplexNumber(v)) return RTV.logical(v.re !== 0 || v.im !== 0);
     if (isRuntimeTensor(v)) {
       if (args.length === 1) {
-        if (v.data.length === 0) return RTV.logical(mode === "all");
         const d = firstReduceDim(v.shape);
         if (d === 0) return RTV.logical(scanLogical(v.data, v.imag, mode));
         return logicalAlongDim(v, d, mode);
@@ -36122,7 +36474,12 @@ function applyTextFn(v, fn) {
     }
     return RTV.cell(out, [...v.shape]);
   }
-  if (isRuntimeChar(v)) return RTV.char(fn(v.value));
+  if (isRuntimeChar(v)) {
+    if (v.shape && (v.shape[0] ?? 1) > 1) {
+      return charRowsToMatrix(valueToCharRows(v).map(fn));
+    }
+    return RTV.char(fn(v.value));
+  }
   if (isRuntimeString(v)) return RTV.string(fn(toString(v)));
   return v;
 }
@@ -36274,7 +36631,7 @@ registerIBuiltin({
         const str = toString(args[0]);
         const pat = toString(args[1]);
         const rep = toString(args[2]);
-        let flags = "g";
+        let flags = "gs";
         for (let i = 3; i < args.length; i++) {
           const opt = toString(args[i]).toLowerCase();
           if (opt === "ignorecase") flags += "i";
@@ -36638,6 +36995,38 @@ registerIBuiltin({
     };
   }
 });
+registerIBuiltin({
+  name: "isspace",
+  help: {
+    signatures: ["TF = isspace(str)"],
+    description: "Return a logical array the same size as str, true where the character is whitespace. Numeric input is treated as Unicode code points."
+  },
+  resolve: (argTypes) => {
+    if (argTypes.length !== 1) return null;
+    const k = argTypes[0].kind;
+    if (k !== "char" && k !== "string" && k !== "number" && k !== "boolean" && k !== "tensor") {
+      return null;
+    }
+    const pred = (cp) => RE_WSPACE.test(String.fromCodePoint(cp));
+    return {
+      outputTypes: [{ kind: "tensor", isComplex: false, isLogical: true }],
+      apply: (args) => {
+        const v = args[0];
+        if (isRuntimeChar(v)) {
+          return logicalRowFromString(
+            v.value,
+            pred,
+            v.shape ? [...v.shape] : void 0
+          );
+        }
+        if (isRuntimeString(v)) return logicalRowFromString(toString(v), pred);
+        if (isRuntimeTensor(v))
+          return logicalFromNumericTensor(v.data, v.shape, pred);
+        return logicalFromNumericTensor([toNumber(v)], [1, 1], pred);
+      }
+    };
+  }
+});
 registerIBuiltin({
   name: "contains",
   resolve: (argTypes) => {
@@ -37085,12 +37474,102 @@ registerIBuiltin({
     };
   }
 });
+function collectRows(v) {
+  if (isRuntimeCell(v)) {
+    const rows = [];
+    for (const el of v.data) rows.push(...valueToCharRows(el));
+    return rows;
+  }
+  return valueToCharRows(v);
+}
+registerIBuiltin({
+  name: "strmatch",
+  help: {
+    signatures: [
+      "x = strmatch(str, strarray)",
+      "x = strmatch(str, strarray, 'exact')"
+    ],
+    description: "(Legacy) Find rows of STRARRAY that begin with STR, or that equal STR when 'exact' is given. Returns a column vector of matching row indices."
+  },
+  resolve: (argTypes) => {
+    if (argTypes.length < 2 || argTypes.length > 3) return null;
+    if (!isTextType(argTypes[0])) return null;
+    const sa = argTypes[1];
+    if (sa.kind !== "char" && sa.kind !== "string" && sa.kind !== "cell")
+      return null;
+    return {
+      outputTypes: [{ kind: "tensor", isComplex: false }],
+      apply: (args) => {
+        const str = toString(args[0]);
+        let rows = collectRows(args[1]);
+        const n = rows.length === 0 ? 0 : Math.max(...rows.map((r) => r.length));
+        rows = rows.map((r) => r.padEnd(n, " "));
+        const exactMatch = args.length === 3;
+        let s = str;
+        let len = s.length;
+        if (len > n) {
+          return RTV.tensor(allocFloat64Array(0), [0, 1]);
+        }
+        if (exactMatch && len < n) {
+          const useNull = rows.some((r) => r.charCodeAt(n - 1) === 0);
+          s = s.padEnd(n, useNull ? "\0" : " ");
+          len = n;
+        }
+        const matches2 = [];
+        for (let r = 0; r < rows.length; r++) {
+          let ok = true;
+          for (let i = 0; i < len; i++) {
+            if (rows[r][i] !== s[i]) {
+              ok = false;
+              break;
+            }
+          }
+          if (ok) matches2.push(r + 1);
+        }
+        return RTV.tensor(allocFloat64Array(matches2), [matches2.length, 1]);
+      }
+    };
+  }
+});
+function valueToCharRows(v) {
+  if (isRuntimeChar(v)) {
+    const cols = v.shape ? v.shape[1] ?? v.value.length : v.value.length;
+    const numRows = v.shape ? v.shape[0] ?? 1 : 1;
+    if (numRows <= 1) return [v.value];
+    const out = [];
+    for (let r = 0; r < numRows; r++)
+      out.push(v.value.slice(r * cols, (r + 1) * cols));
+    return out;
+  }
+  if (isRuntimeString(v)) return [v];
+  if (isRuntimeNumber(v)) return [String.fromCharCode(Math.round(v))];
+  if (isRuntimeTensor(v)) {
+    const rows = v.shape.length >= 2 ? v.shape[0] ?? 1 : 1;
+    const cols = v.shape.length >= 2 ? v.shape[1] ?? 0 : v.data.length;
+    const out = [];
+    for (let r = 0; r < rows; r++) {
+      let s = "";
+      for (let c = 0; c < cols; c++)
+        s += String.fromCharCode(Math.round(v.data[c * rows + r]));
+      out.push(s);
+    }
+    return out;
+  }
+  throw new RuntimeError("char: unsupported cell element type");
+}
+function charRowsToMatrix(rows) {
+  if (rows.length === 0) return RTV.char("");
+  const width = Math.max(...rows.map((r) => r.length));
+  const padded = rows.map((r) => r.padEnd(width, " "));
+  if (rows.length === 1) return RTV.char(padded[0]);
+  return new RuntimeChar(padded.join(""), [rows.length, width]);
+}
 registerIBuiltin({
   name: "char",
   resolve: (argTypes) => {
     if (argTypes.length !== 1) return null;
     const a = argTypes[0];
-    if (a.kind !== "char" && a.kind !== "string" && a.kind !== "number" && a.kind !== "tensor")
+    if (a.kind !== "char" && a.kind !== "string" && a.kind !== "number" && a.kind !== "tensor" && a.kind !== "cell")
       return null;
     return {
       outputTypes: [{ kind: "char" }],
@@ -37107,6 +37586,11 @@ registerIBuiltin({
           }
           return RTV.char(chars.join(""));
         }
+        if (isRuntimeCell(v)) {
+          const rows = [];
+          for (const el of v.data) rows.push(...valueToCharRows(el));
+          return charRowsToMatrix(rows);
+        }
         throw new RuntimeError("char: unsupported arguments");
       }
     };
@@ -37174,6 +37658,8 @@ registerIBuiltin({
     if (!isTextType(argTypes[0]) || !isTextType(argTypes[1])) return null;
     const outputTypes = [{ kind: "number" }];
     if (nargout >= 2) outputTypes.push({ kind: "number" });
+    if (nargout >= 3) outputTypes.push({ kind: "char" });
+    if (nargout >= 4) outputTypes.push({ kind: "number" });
     return {
       outputTypes,
       apply: (args, nout) => {
@@ -37183,6 +37669,7 @@ registerIBuiltin({
         const results = [];
         let strPos = 0;
         let fmtPos = 0;
+        let matchFailure = false;
         while (fmtPos < fmt.length && strPos < str.length && results.length < maxCount) {
           if (fmt[fmtPos] === "%") {
             fmtPos++;
@@ -37194,22 +37681,34 @@ registerIBuiltin({
             }
             if (spec === "d" || spec === "i") {
               const m = str.slice(strPos).match(/^[+-]?\d+/);
-              if (!m) break;
+              if (!m) {
+                matchFailure = true;
+                break;
+              }
               results.push(parseInt(m[0], 10));
               strPos += m[0].length;
             } else if (spec === "f" || spec === "e" || spec === "g") {
               const m = str.slice(strPos).match(/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?/);
-              if (!m) break;
+              if (!m) {
+                matchFailure = true;
+                break;
+              }
               results.push(parseFloat(m[0]));
               strPos += m[0].length;
             } else if (spec === "x") {
               const m = str.slice(strPos).match(/^[+-]?[0-9a-fA-F]+/);
-              if (!m) break;
+              if (!m) {
+                matchFailure = true;
+                break;
+              }
               results.push(parseInt(m[0], 16));
               strPos += m[0].length;
             } else if (spec === "o") {
               const m = str.slice(strPos).match(/^[+-]?[0-7]+/);
-              if (!m) break;
+              if (!m) {
+                matchFailure = true;
+                break;
+              }
               results.push(parseInt(m[0], 8));
               strPos += m[0].length;
             } else if (spec === "c") {
@@ -37217,7 +37716,10 @@ registerIBuiltin({
               strPos++;
             } else if (spec === "s") {
               const m = str.slice(strPos).match(/^\S+/);
-              if (!m) break;
+              if (!m) {
+                matchFailure = true;
+                break;
+              }
               for (let ci = 0; ci < m[0].length && results.length < maxCount; ci++) {
                 results.push(m[0].charCodeAt(ci));
               }
@@ -37227,7 +37729,10 @@ registerIBuiltin({
             fmtPos++;
             while (strPos < str.length && /\s/.test(str[strPos])) strPos++;
           } else {
-            if (str[strPos] !== fmt[fmtPos]) break;
+            if (str[strPos] !== fmt[fmtPos]) {
+              matchFailure = true;
+              break;
+            }
             strPos++;
             fmtPos++;
           }
@@ -37237,7 +37742,16 @@ registerIBuiltin({
         }
         const vals = results.length === 1 ? RTV.num(results[0]) : RTV.tensor(allocFloat64Array(results), [results.length, 1]);
         if (nout >= 2) {
-          return [vals, RTV.num(results.length)];
+          const out = [vals, RTV.num(results.length)];
+          if (nout >= 3) {
+            out.push(
+              RTV.char(matchFailure ? "Matching failure in format." : "")
+            );
+          }
+          if (nout >= 4) {
+            out.push(RTV.num(strPos + 1));
+          }
+          return out;
         }
         return vals;
       }
@@ -38648,8 +39162,34 @@ function normImplTensor(v, args) {
     return RTV.num(maxRowSum);
   }
   if (p2 === 2) {
+    let anyNaN = false;
+    let anyInf = false;
+    for (let i = 0; i < v.data.length; i++) {
+      const re = v.data[i];
+      const im = imag2 ? imag2[i] : 0;
+      if (Number.isNaN(re) || Number.isNaN(im)) anyNaN = true;
+      else if (!isFinite(re) || !isFinite(im)) anyInf = true;
+    }
+    if (anyNaN) return RTV.num(NaN);
+    if (anyInf) return RTV.num(Infinity);
     const bridge = getEffectiveBridge("norm", "svd");
     if (bridge && bridge.svd) {
+      if (imag2) {
+        const R = allocFloat64Array(4 * rows * cols);
+        const tm = 2 * rows;
+        for (let j = 0; j < cols; j++) {
+          for (let i = 0; i < rows; i++) {
+            const a = v.data[j * rows + i];
+            const b = imag2[j * rows + i];
+            R[j * tm + i] = a;
+            R[j * tm + (rows + i)] = b;
+            R[(cols + j) * tm + i] = -b;
+            R[(cols + j) * tm + (rows + i)] = a;
+          }
+        }
+        const result2 = bridge.svd(R, tm, 2 * cols, false, false);
+        return RTV.num(result2.S[0]);
+      }
       const f64 = v.data instanceof Float64Array ? v.data : allocFloat64Array(v.data);
       const result = bridge.svd(f64, rows, cols, false, false);
       return RTV.num(result.S[0]);
@@ -39409,6 +39949,100 @@ function svdApply(args, nargout) {
     [k, 1]
   );
 }
+function nullApply(args) {
+  let A = args[0];
+  if (isRuntimeNumber(A) || isRuntimeComplexNumber(A)) {
+    A = isRuntimeNumber(A) ? RTV.tensor(allocFloat64Array([A]), [1, 1]) : RTV.tensor(
+      allocFloat64Array([A.re]),
+      [1, 1],
+      allocFloat64Array([A.im])
+    );
+  }
+  if (!isRuntimeTensor(A))
+    throw new RuntimeError("null: argument must be a numeric matrix");
+  const [m, n] = tensorSize2D(A);
+  const [, Sdiag, V] = svdApply([A], 3);
+  const k = Math.min(m, n);
+  const s = [];
+  for (let i = 0; i < k; i++) s.push(Sdiag.data[colMajorIndex(i, i, m)]);
+  const maxS = s.length > 0 ? Math.max(...s) : 0;
+  const tol = args.length > 1 && args[1] !== void 0 ? toNumber(args[1]) : Math.max(m, n) * epsOf(maxS);
+  let r = 0;
+  for (const sv of s) if (sv > tol) r++;
+  const cols = n - r;
+  const out = allocFloat64Array(n * cols);
+  const outImag = V.imag ? allocFloat64Array(n * cols) : void 0;
+  for (let c = 0; c < cols; c++) {
+    for (let i = 0; i < n; i++) {
+      const src = colMajorIndex(i, r + c, n);
+      out[colMajorIndex(i, c, n)] = V.data[src];
+      if (outImag) outImag[colMajorIndex(i, c, n)] = V.imag[src];
+    }
+  }
+  return RTV.tensor(out, [n, cols], outImag);
+}
+registerIBuiltin({
+  name: "null",
+  resolve: (argTypes, nargout) => {
+    if (nargout > 1 || argTypes.length < 1 || argTypes.length > 2) return null;
+    if (!isNumericJitType(argTypes[0])) return null;
+    const isComplex = argTypes[0].kind === "tensor" && argTypes[0].isComplex;
+    return {
+      outputTypes: [tensorType(isComplex || void 0)],
+      apply: (args) => nullApply(args)
+    };
+  }
+});
+function computeBandwidth(A) {
+  let lower = 0;
+  let upper = 0;
+  const note = (i, j) => {
+    if (i > j) lower = Math.max(lower, i - j);
+    else if (j > i) upper = Math.max(upper, j - i);
+  };
+  if (isRuntimeNumber(A) || isRuntimeComplexNumber(A)) return [0, 0];
+  if (isRuntimeSparseMatrix(A)) {
+    for (let j = 0; j < A.n; j++) {
+      for (let k = A.jc[j]; k < A.jc[j + 1]; k++) {
+        if (A.pr[k] === 0 && (!A.pi || A.pi[k] === 0)) continue;
+        note(A.ir[k], j);
+      }
+    }
+    return [lower, upper];
+  }
+  if (isRuntimeTensor(A)) {
+    const [m, n] = tensorSize2D(A);
+    for (let j = 0; j < n; j++) {
+      for (let i = 0; i < m; i++) {
+        const idx = colMajorIndex(i, j, m);
+        if (A.data[idx] === 0 && (!A.imag || A.imag[idx] === 0)) continue;
+        note(i, j);
+      }
+    }
+    return [lower, upper];
+  }
+  throw new RuntimeError("bandwidth: first argument must be a numeric matrix");
+}
+function bandwidthApply(args, nargout) {
+  const [lower, upper] = computeBandwidth(args[0]);
+  if (args.length >= 2 && args[1] !== void 0) {
+    const type = parseStringArgLower(args[1]);
+    if (type === "lower") return RTV.num(lower);
+    if (type === "upper") return RTV.num(upper);
+    throw new RuntimeError("bandwidth: TYPE must be 'lower' or 'upper'");
+  }
+  if (nargout >= 2) return [RTV.num(lower), RTV.num(upper)];
+  return RTV.num(lower);
+}
+registerIBuiltin({
+  name: "bandwidth",
+  resolve: (argTypes, nargout) => {
+    if (nargout > 2 || argTypes.length < 1 || argTypes.length > 2) return null;
+    if (!isNumericJitType(argTypes[0])) return null;
+    const outs = nargout >= 2 ? [NUM, NUM] : [NUM];
+    return { outputTypes: outs, apply: (args, n) => bandwidthApply(args, n) };
+  }
+});
 function computeATA(A_data, m, n) {
   const result = allocFloat64Array(n * n);
   for (let j = 0; j < n; j++)
@@ -41279,6 +41913,33 @@ function validateSizeArg(x) {
   }
   return x < 0 ? 0 : x;
 }
+function parseReshapeDims(args, total) {
+  let rawDims;
+  if (args.length === 2 && isRuntimeTensor(args[1]) && args[1].data.length > 1) {
+    rawDims = Array.from(args[1].data).map((x) => validateSizeArg(x));
+  } else {
+    rawDims = args.slice(1).map((a) => {
+      if (isRuntimeTensor(a) && a.data.length === 0) return null;
+      return validateSizeArg(toNumber(a));
+    });
+  }
+  const autoCount = rawDims.filter((d) => d === null).length;
+  if (autoCount > 1)
+    throw new RuntimeError("reshape: only one dimension size can be []");
+  let shape;
+  if (autoCount === 1) {
+    const known = rawDims.filter((d) => d !== null);
+    const knownProduct = known.reduce((a, b) => a * b, 1);
+    if (knownProduct === 0 || total % knownProduct !== 0)
+      throw new RuntimeError("reshape: number of elements must not change");
+    shape = rawDims.map((d) => d === null ? total / knownProduct : d);
+  } else {
+    shape = rawDims;
+  }
+  if (numel(shape) !== total)
+    throw new RuntimeError("reshape: number of elements must not change");
+  return shape;
+}
 defineBuiltin({
   name: "reshape",
   cases: [
@@ -41290,31 +41951,31 @@ defineBuiltin({
         const v = args[0];
         if (isRuntimeSparseMatrix(v)) {
           const totalEl = v.m * v.n;
-          let rawDims2;
+          let rawDims;
           if (args.length === 2 && isRuntimeTensor(args[1]) && args[1].data.length > 1) {
-            rawDims2 = Array.from(args[1].data).map((x) => Math.round(x));
+            rawDims = Array.from(args[1].data).map((x) => Math.round(x));
           } else {
-            rawDims2 = args.slice(1).map((a) => {
+            rawDims = args.slice(1).map((a) => {
               if (isRuntimeTensor(a) && a.data.length === 0) return null;
               return Math.round(toNumber(a));
             });
           }
-          const autoCount2 = rawDims2.filter((d) => d === null).length;
-          if (autoCount2 > 1)
+          const autoCount = rawDims.filter((d) => d === null).length;
+          if (autoCount > 1)
             throw new RuntimeError(
               "reshape: only one dimension size can be []"
             );
           let shape2;
-          if (autoCount2 === 1) {
-            const known = rawDims2.filter((d) => d !== null);
+          if (autoCount === 1) {
+            const known = rawDims.filter((d) => d !== null);
             const knownProduct = known.reduce((a, b) => a * b, 1);
             if (totalEl % knownProduct !== 0)
               throw new RuntimeError(
                 "reshape: number of elements must not change"
               );
-            shape2 = rawDims2.map((d) => d === null ? totalEl / knownProduct : d);
+            shape2 = rawDims.map((d) => d === null ? totalEl / knownProduct : d);
           } else {
-            shape2 = rawDims2;
+            shape2 = rawDims;
           }
           if (shape2.length !== 2)
             throw new RuntimeError("reshape: sparse matrices must be 2-D");
@@ -41352,40 +42013,32 @@ defineBuiltin({
           jc[newN] = ti;
           return RTV.sparseMatrix(newM, newN, ir, jc, pr, pi2);
         }
+        if (isRuntimeChar(v)) {
+          const srcRows = v.shape ? v.shape[0] : 1;
+          const srcCols = v.shape ? v.shape[1] ?? 0 : v.value.length;
+          const total = v.value.length;
+          const reqShape = parseReshapeDims(args, total);
+          const s = [...reqShape];
+          while (s.length > 2 && s[s.length - 1] === 1) s.pop();
+          if (s.length > 2)
+            throw new RuntimeError("reshape: char arrays must be 2-D");
+          const nr = s[0];
+          const nc = s.length >= 2 ? s[1] : 1;
+          const linear = new Array(total);
+          for (let j = 0; j < srcCols; j++)
+            for (let i = 0; i < srcRows; i++)
+              linear[j * srcRows + i] = v.value[i * srcCols + j];
+          const chars = new Array(total);
+          for (let j2 = 0; j2 < nc; j2++)
+            for (let i2 = 0; i2 < nr; i2++)
+              chars[i2 * nc + j2] = linear[j2 * nr + i2];
+          return new RuntimeChar(chars.join(""), [nr, nc]);
+        }
         if (!isRuntimeTensor(v) && !isRuntimeNumber(v) && !isRuntimeComplexNumber(v))
           throw new RuntimeError("reshape: first argument must be numeric");
         const data = isRuntimeTensor(v) ? v.data : isRuntimeComplexNumber(v) ? allocFloat64Array([v.re]) : allocFloat64Array([v]);
         const imag2 = isRuntimeTensor(v) ? v.imag : isRuntimeComplexNumber(v) ? allocFloat64Array([v.im]) : void 0;
-        let rawDims;
-        if (args.length === 2 && isRuntimeTensor(args[1]) && args[1].data.length > 1) {
-          rawDims = Array.from(args[1].data).map((x) => validateSizeArg(x));
-        } else {
-          rawDims = args.slice(1).map((a) => {
-            if (isRuntimeTensor(a) && a.data.length === 0) return null;
-            return validateSizeArg(toNumber(a));
-          });
-        }
-        const autoCount = rawDims.filter((d) => d === null).length;
-        if (autoCount > 1)
-          throw new RuntimeError("reshape: only one dimension size can be []");
-        let shape;
-        if (autoCount === 1) {
-          const known = rawDims.filter((d) => d !== null);
-          const knownProduct = known.reduce((a, b) => a * b, 1);
-          if (data.length % knownProduct !== 0)
-            throw new RuntimeError(
-              "reshape: number of elements must not change"
-            );
-          shape = rawDims.map(
-            (d) => d === null ? data.length / knownProduct : d
-          );
-        } else {
-          shape = rawDims;
-        }
-        const n = numel(shape);
-        if (n !== data.length) {
-          throw new RuntimeError("reshape: number of elements must not change");
-        }
+        const shape = parseReshapeDims(args, data.length);
         if (isRuntimeTensor(v)) {
           const dataCopy = allocFloat64Array(data);
           const imagCopy = imag2 ? allocFloat64Array(imag2) : void 0;
@@ -41797,6 +42450,35 @@ defineBuiltin({
     }
   ]
 });
+function repmatObjects(v, repArgs) {
+  const srcElements = isRuntimeClassInstanceArray(v) ? v.elements : [v];
+  const [rows, cols] = isRuntimeClassInstanceArray(v) ? v.shape : [1, 1];
+  const className = v.className;
+  let reps;
+  if (repArgs.length === 1) {
+    const arg1 = repArgs[0];
+    if (isRuntimeTensor(arg1)) {
+      reps = Array.from(arg1.data).map((x) => validateSizeArg(x));
+    } else {
+      const n = validateSizeArg(toNumber(arg1));
+      reps = [n, n];
+    }
+  } else {
+    reps = repArgs.map((a) => validateSizeArg(toNumber(a)));
+  }
+  const rRep = reps[0] ?? 1;
+  const cRep = reps.length >= 2 ? reps[1] : reps[0] ?? 1;
+  const newRows = rows * rRep;
+  const newCols = cols * cRep;
+  const out = new Array(Math.max(0, newRows * newCols));
+  for (let J = 0; J < newCols; J++) {
+    for (let I = 0; I < newRows; I++) {
+      const src = srcElements[I % rows + J % cols * rows];
+      out[I + J * newRows] = copyClassInstance(src);
+    }
+  }
+  return out.length === 1 ? out[0] : RTV.classInstanceArray(className, out, [newRows, newCols]);
+}
 defineBuiltin({
   name: "repmat",
   cases: [
@@ -41821,6 +42503,8 @@ defineBuiltin({
         if (args.length < 2)
           throw new RuntimeError("repmat requires at least 2 arguments");
         let v = args[0];
+        if (isRuntimeClassInstance(v) || isRuntimeClassInstanceArray(v))
+          return repmatObjects(v, args.slice(1));
         if (isRuntimeSparseMatrix(v)) v = sparseToDense(v);
         let reps;
         if (args.length === 2) {
@@ -41985,6 +42669,62 @@ defineBuiltin({
     }
   ]
 });
+function copyClassInstance(inst) {
+  if (inst.isHandleClass) return inst;
+  return new RuntimeClassInstance(
+    inst.className,
+    new Map(inst.fields),
+    inst.isHandleClass,
+    inst._builtinData
+  );
+}
+function repelemObjects(v, repArgs) {
+  const srcElements = isRuntimeClassInstanceArray(v) ? v.elements : [v];
+  const [rows, cols] = isRuntimeClassInstanceArray(v) ? v.shape : [1, 1];
+  const className = v.className;
+  const wrap = (elements, shape) => elements.length === 1 ? elements[0] : RTV.classInstanceArray(className, elements, shape);
+  if (repArgs.length === 1) {
+    const repArg = repArgs[0];
+    if (isRuntimeTensor(repArg) && repArg.data.length > 1) {
+      const counts = repArg.data;
+      if (counts.length !== srcElements.length)
+        throw new RuntimeError(
+          `repelem: counts vector length (${counts.length}) must match the number of elements (${srcElements.length})`
+        );
+      const out3 = [];
+      for (let i = 0; i < srcElements.length; i++) {
+        const c = Math.max(0, Math.round(counts[i]));
+        for (let j = 0; j < c; j++) out3.push(copyClassInstance(srcElements[i]));
+      }
+      const isCol2 = cols === 1 && rows !== 1;
+      return wrap(out3, isCol2 ? [out3.length, 1] : [1, out3.length]);
+    }
+    const n = Math.max(0, Math.round(toNumber(repArg)));
+    const out2 = [];
+    for (const el of srcElements)
+      for (let j = 0; j < n; j++) out2.push(copyClassInstance(el));
+    const isCol = cols === 1 && rows !== 1;
+    return wrap(out2, isCol ? [out2.length, 1] : [1, out2.length]);
+  }
+  const rRep = Math.max(0, Math.round(toNumber(repArgs[0])));
+  const cRep = Math.max(0, Math.round(toNumber(repArgs[1])));
+  const newRows = rows * rRep;
+  const newCols = cols * cRep;
+  const out = new Array(newRows * newCols);
+  for (let c = 0; c < cols; c++) {
+    for (let r = 0; r < rows; r++) {
+      const src = srcElements[c * rows + r];
+      for (let dc = 0; dc < cRep; dc++) {
+        for (let dr = 0; dr < rRep; dr++) {
+          const dstRow = r * rRep + dr;
+          const dstCol = c * cRep + dc;
+          out[dstCol * newRows + dstRow] = copyClassInstance(src);
+        }
+      }
+    }
+  }
+  return wrap(out, [newRows, newCols]);
+}
 defineBuiltin({
   name: "repelem",
   cases: [
@@ -41994,6 +42734,8 @@ defineBuiltin({
         if (args.length < 2)
           throw new RuntimeError("repelem requires at least 2 arguments");
         const v = args[0];
+        if (isRuntimeClassInstance(v) || isRuntimeClassInstanceArray(v))
+          return repelemObjects(v, args.slice(1));
         if (args.length === 2) {
           const repArg = args[1];
           if (isRuntimeTensor(repArg) && repArg.data.length > 1) {
@@ -42116,7 +42858,15 @@ defineBuiltin({
           }
           return RTV.tensor(dataCopy, newShape, imagCopy);
         }
-        throw new RuntimeError("squeeze: argument must be numeric");
+        if (isRuntimeCell(v)) {
+          const shape = [...v.shape];
+          while (shape.length > 2 && shape[shape.length - 1] === 1) shape.pop();
+          if (shape.length <= 2) return RTV.cell(v.data, shape);
+          const newShape = shape.filter((d) => d !== 1);
+          while (newShape.length < 2) newShape.push(1);
+          return RTV.cell(v.data, newShape);
+        }
+        return v;
       }
     }
   ]
@@ -42786,6 +43536,8 @@ defineBuiltin({
   ]
 });
 function bitwiseOp(a, b, op, name) {
+  if (typeof a === "boolean") a = a ? 1 : 0;
+  if (typeof b === "boolean") b = b ? 1 : 0;
   if (isRuntimeNumber(a) && isRuntimeNumber(b)) {
     return RTV.num(op(Math.round(a), Math.round(b)));
   }
@@ -45053,6 +45805,56 @@ defineBuiltin({
     }
   ]
 });
+function froundArray(src) {
+  const out = allocFloat64Array(src.length);
+  for (let i = 0; i < src.length; i++) out[i] = Math.fround(src[i]);
+  return out;
+}
+function singleApply(v) {
+  if (isRuntimeChar(v)) {
+    if (v.value.length === 0) return RTV.tensor(allocFloat64Array(0), [0, 0]);
+    if (v.value.length === 1)
+      return RTV.num(Math.fround(v.value.charCodeAt(0)));
+    return RTV.row(Array.from(v.value).map((c) => Math.fround(c.charCodeAt(0))));
+  }
+  if (isRuntimeLogical(v)) return RTV.num(v ? 1 : 0);
+  if (isRuntimeNumber(v)) return RTV.num(Math.fround(v));
+  if (isRuntimeComplexNumber(v))
+    return RTV.complex(Math.fround(v.re), Math.fround(v.im));
+  if (isRuntimeTensor(v)) {
+    const imag2 = v.imag ? froundArray(v.imag) : void 0;
+    return RTV.tensor(froundArray(v.data), v.shape.slice(), imag2);
+  }
+  if (isRuntimeClassInstance(v) && v._builtinData !== void 0)
+    return singleApply(v._builtinData);
+  return RTV.num(Math.fround(toNumber(v)));
+}
+defineBuiltin({
+  name: "single",
+  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 === "class_instance")
+          return [{ kind: "number" }];
+        if (a.kind === "complex_or_number")
+          return [{ kind: "complex_or_number" }];
+        if (a.kind === "tensor")
+          return [
+            {
+              kind: "tensor",
+              isComplex: a.isComplex,
+              shape: a.shape,
+              ndim: a.ndim
+            }
+          ];
+        return null;
+      },
+      apply: (args) => singleApply(args[0])
+    }
+  ]
+});
 var INT_RANGES = [
   { name: "int8", min: -128, max: 127 },
   { name: "int16", min: -32768, max: 32767 },
@@ -45607,11 +46409,20 @@ defineBuiltin({
       },
       apply: (args) => {
         const v = args[0];
-        if (isRuntimeStructArray(v))
-          return RTV.logical(v.fieldNames.includes(toString(args[1])));
-        if (!isRuntimeStruct(v) && !isRuntimeClassInstance(v))
-          return RTV.logical(false);
-        return RTV.logical(v.fields.has(toString(args[1])));
+        const hasField = (name) => {
+          if (isRuntimeStructArray(v)) return v.fieldNames.includes(name);
+          if (!isRuntimeStruct(v) && !isRuntimeClassInstance(v)) return false;
+          return v.fields.has(name);
+        };
+        if (isRuntimeCell(args[1])) {
+          const cell = args[1];
+          const result = allocFloat64Array(cell.data.length);
+          for (let i = 0; i < cell.data.length; i++) {
+            result[i] = hasField(toString(cell.data[i])) ? 1 : 0;
+          }
+          return new RuntimeTensor(result, cell.shape.slice(), void 0, true);
+        }
+        return RTV.logical(hasField(toString(args[1])));
       }
     }
   ]
@@ -45728,7 +46539,7 @@ function regexpImpl(caseSensitive, name, args, nargout) {
   if (outModes.length === 0) {
     outModes.push("start", "end", "tokenextents", "match", "tokens", "names");
   }
-  const flags = caseSensitive ? "g" : "gi";
+  const flags = caseSensitive ? "gs" : "gis";
   const re = new RegExp(pat, flags);
   const starts = [];
   const ends = [];
@@ -46448,6 +47259,13 @@ registerIBuiltin({
           if (args.length === 1) return RTV.cell([A], [1, 1]);
           A = RTV.tensor(allocFloat64Array([A ? 1 : 0]), [1, 1]);
         }
+        if (isRuntimeStruct(A)) {
+          return RTV.cell([A], [1, 1]);
+        }
+        if (isRuntimeStructArray(A)) {
+          const elems = A.elements;
+          return RTV.cell([...elems], [1, elems.length]);
+        }
         if (!isRuntimeTensor(A))
           throw new RuntimeError(
             "num2cell: first argument must be a numeric array"
@@ -46571,6 +47389,69 @@ registerIBuiltin({
     };
   }
 });
+registerIBuiltin({
+  name: "getfield",
+  resolve: (argTypes) => {
+    if (argTypes.length < 2) return null;
+    return {
+      outputTypes: [{ kind: "unknown" }],
+      apply: (args) => {
+        let v = args[0];
+        for (let i = 1; i < args.length; i++) {
+          if (isRuntimeCell(args[i]))
+            throw new RuntimeError(
+              "getfield: index ({}) subscripts are not supported"
+            );
+          if (!isRuntimeStruct(v))
+            throw new RuntimeError("getfield: argument must be a structure");
+          const name = toString(args[i]);
+          if (!v.fields.has(name))
+            throw new RuntimeError(
+              `Reference to non-existent field '${name}'.`
+            );
+          v = v.fields.get(name);
+        }
+        return v;
+      }
+    };
+  }
+});
+registerIBuiltin({
+  name: "setfield",
+  resolve: (argTypes) => {
+    if (argTypes.length < 3) return null;
+    return {
+      outputTypes: [{ kind: "struct", fields: {} }],
+      apply: (args) => {
+        const value = args[args.length - 1];
+        const fieldArgs = args.slice(1, args.length - 1);
+        const setChain = (s, depth) => {
+          const fa = fieldArgs[depth];
+          if (isRuntimeCell(fa))
+            throw new RuntimeError(
+              "setfield: index ({}) subscripts are not supported"
+            );
+          const name = toString(fa);
+          const base = isRuntimeStruct(s) ? s.fields : /* @__PURE__ */ new Map();
+          if (!isRuntimeStruct(s) && !(isRuntimeTensor(s) && s.data.length === 0))
+            throw new RuntimeError("setfield: argument must be a structure");
+          const newFields = new Map(base);
+          if (depth === fieldArgs.length - 1) {
+            newFields.set(name, value);
+          } else {
+            const child = newFields.get(name);
+            newFields.set(
+              name,
+              setChain(child ?? RTV.struct(/* @__PURE__ */ new Map()), depth + 1)
+            );
+          }
+          return RTV.struct(newFields);
+        };
+        return setChain(args[0], 0);
+      }
+    };
+  }
+});
 registerIBuiltin({
   name: "namedargs2cell",
   resolve: (argTypes) => {
@@ -46592,6 +47473,10 @@ registerIBuiltin({
     };
   }
 });
+function rmfieldNames(arg) {
+  if (isRuntimeCell(arg)) return arg.data.map(toString);
+  return [toString(arg)];
+}
 registerIBuiltin({
   name: "rmfield",
   resolve: (argTypes) => {
@@ -46600,25 +47485,26 @@ registerIBuiltin({
       outputTypes: [{ kind: "struct", fields: {} }],
       apply: (args) => {
         const v = args[0];
+        const names = rmfieldNames(args[1]);
         if (isRuntimeStructArray(v)) {
-          const name2 = toString(args[1]);
-          if (!v.fieldNames.includes(name2))
-            throw new RuntimeError(`rmfield: field '${name2}' does not exist`);
-          const newFieldNames = v.fieldNames.filter((n) => n !== name2);
+          for (const name of names)
+            if (!v.fieldNames.includes(name))
+              throw new RuntimeError(`rmfield: field '${name}' does not exist`);
+          const newFieldNames = v.fieldNames.filter((n) => !names.includes(n));
           const newElements = v.elements.map((el) => {
             const newFields2 = new Map(el.fields);
-            newFields2.delete(name2);
+            for (const name of names) newFields2.delete(name);
             return RTV.struct(newFields2);
           });
           return RTV.structArray(newFieldNames, newElements);
         }
         if (!isRuntimeStruct(v))
           throw new RuntimeError("rmfield: first argument must be a struct");
-        const name = toString(args[1]);
-        if (!v.fields.has(name))
-          throw new RuntimeError(`rmfield: field '${name}' does not exist`);
+        for (const name of names)
+          if (!v.fields.has(name))
+            throw new RuntimeError(`rmfield: field '${name}' does not exist`);
         const newFields = new Map(v.fields);
-        newFields.delete(name);
+        for (const name of names) newFields.delete(name);
         return RTV.struct(newFields);
       }
     };
@@ -47259,6 +48145,23 @@ registerIBuiltin({
     }
   })
 });
+registerIBuiltin({
+  name: "spalloc",
+  resolve: () => ({
+    outputTypes: [{ kind: "unknown" }],
+    apply: (args) => {
+      const m = args.length >= 1 ? Math.round(toNumber(args[0])) : 0;
+      const n = args.length >= 2 ? Math.round(toNumber(args[1])) : 0;
+      return RTV.sparseMatrix(
+        m,
+        n,
+        new Int32Array(0),
+        new Int32Array(n + 1),
+        allocFloat64Array(0)
+      );
+    }
+  })
+});
 registerIBuiltin({
   name: "speye",
   resolve: () => ({
@@ -47544,6 +48447,598 @@ registerIBuiltin({
     }
   })
 });
+var SPPARMS_KEYS = [
+  "spumoni",
+  "thr_rel",
+  "thr_abs",
+  "exact_d",
+  "supernd",
+  "rreduce",
+  "wh_frac",
+  "autommd",
+  "autoamd",
+  "piv_tol",
+  "bandden",
+  "umfpack",
+  "sym_tol",
+  "ldl_tol",
+  "usema57",
+  "spqrtol",
+  "sp_ctor",
+  "reorder",
+  "no_redo"
+];
+var SPPARMS_DEFAULTS = [
+  0,
+  1.1,
+  1,
+  0,
+  3,
+  3,
+  0.5,
+  1,
+  1,
+  0.1,
+  0.5,
+  1,
+  1e-3,
+  0.01,
+  1,
+  -2,
+  0,
+  0,
+  0
+];
+var spparmsState = Float64Array.from(SPPARMS_DEFAULTS);
+function spparmsVector() {
+  return RTV.tensor(allocFloat64Array(Array.from(spparmsState)), [
+    spparmsState.length,
+    1
+  ]);
+}
+registerIBuiltin({
+  name: "spparms",
+  resolve: (argTypes, nargout) => {
+    if (argTypes.length > 2) return null;
+    const tensorOut = { kind: "tensor", isComplex: false };
+    const outputTypes = nargout >= 2 ? [{ kind: "char" }, tensorOut] : [tensorOut];
+    return {
+      outputTypes,
+      apply: (args, n) => {
+        if (args.length === 0) {
+          if (n >= 2) {
+            const width = Math.max(...SPPARMS_KEYS.map((k) => k.length));
+            const padded = SPPARMS_KEYS.map((k) => k.padEnd(width)).join("");
+            return [
+              new RuntimeChar(padded, [SPPARMS_KEYS.length, width]),
+              spparmsVector()
+            ];
+          }
+          return spparmsVector();
+        }
+        const first = args[0];
+        if (isRuntimeChar(first) || isRuntimeString(first)) {
+          const key = parseStringArgLower(first);
+          if (args.length >= 2) {
+            const idx2 = SPPARMS_KEYS.indexOf(key);
+            if (idx2 >= 0) spparmsState[idx2] = toNumber(args[1]);
+            return RTV.num(0);
+          }
+          if (key === "default") {
+            spparmsState = Float64Array.from(SPPARMS_DEFAULTS);
+            return RTV.num(0);
+          }
+          if (key === "tight") {
+            return RTV.num(0);
+          }
+          const idx = SPPARMS_KEYS.indexOf(key);
+          if (idx >= 0) return RTV.num(spparmsState[idx]);
+          throw new RuntimeError(`spparms: unknown parameter '${key}'`);
+        }
+        const vals = isRuntimeNumber(first) ? [first] : isRuntimeTensor(first) ? Array.from(first.data) : null;
+        if (vals === null)
+          throw new RuntimeError(
+            "spparms: argument must be a parameter name or value vector"
+          );
+        const next = Float64Array.from(spparmsState);
+        for (let i = 0; i < Math.min(vals.length, next.length); i++)
+          next[i] = vals[i];
+        spparmsState = next;
+        return RTV.num(0);
+      }
+    };
+  }
+});
+
+// src/numbl-core/interpreter/builtins/graph.ts
+function isGraph(v) {
+  return isRuntimeClassInstance(v) && v.className === "graph";
+}
+function requireGraph(v, fn) {
+  if (!isGraph(v)) {
+    throw new RuntimeError(`${fn}: first argument must be a graph`);
+  }
+  return v;
+}
+function graphN(g) {
+  return toNumber(g.fields.get("_n") ?? 0);
+}
+function graphWeighted(g) {
+  const w = g.fields.get("_weighted");
+  return w === true;
+}
+function graphAdj(g) {
+  const a = g.fields.get("_A");
+  if (a === void 0 || !isRuntimeSparseMatrix(a)) {
+    throw new RuntimeError("graph: corrupt internal adjacency");
+  }
+  return a;
+}
+function buildSymAdj(n, edges) {
+  const triplets = [];
+  for (const e of edges) {
+    if (e.w === 0) continue;
+    const u = e.u - 1;
+    const v = e.v - 1;
+    if (u === v) {
+      triplets.push({ col: u, row: u, val: e.w });
+    } else {
+      triplets.push({ col: v, row: u, val: e.w });
+      triplets.push({ col: u, row: v, val: e.w });
+    }
+  }
+  triplets.sort((a, b) => a.col - b.col || a.row - b.row);
+  const ir = [];
+  const pr = [];
+  const cols = [];
+  let prevCol = -1;
+  let prevRow = -1;
+  for (const t of triplets) {
+    if (t.col === prevCol && t.row === prevRow) {
+      pr[pr.length - 1] += t.val;
+    } else {
+      ir.push(t.row);
+      pr.push(t.val);
+      cols.push(t.col);
+      prevCol = t.col;
+      prevRow = t.row;
+    }
+  }
+  const jc = new Int32Array(n + 1);
+  let ci = 0;
+  for (let c = 0; c < n; c++) {
+    jc[c] = ci;
+    while (ci < cols.length && cols[ci] === c) ci++;
+  }
+  jc[n] = ci;
+  return RTV.sparseMatrix(n, n, new Int32Array(ir), jc, allocFloat64Array(pr));
+}
+function makeGraph(n, edges, weighted) {
+  const fields = /* @__PURE__ */ new Map();
+  fields.set("_n", n);
+  fields.set("_A", buildSymAdj(n, edges));
+  fields.set("_weighted", weighted);
+  return new RuntimeClassInstance("graph", fields, false);
+}
+function eachNeighbor(A, c, cb) {
+  for (let k = A.jc[c]; k < A.jc[c + 1]; k++) {
+    const r = A.ir[k];
+    if (r !== c) cb(r, A.pr[k]);
+  }
+}
+function edgesFromAdj(A) {
+  const edges = [];
+  for (let c = 0; c < A.n; c++) {
+    for (let k = A.jc[c]; k < A.jc[c + 1]; k++) {
+      const r = A.ir[k];
+      if (r < c) edges.push({ u: r + 1, v: c + 1, w: A.pr[k] });
+      else if (r === c) edges.push({ u: r + 1, v: r + 1, w: A.pr[k] });
+    }
+  }
+  return edges;
+}
+function squareDim(A, fn) {
+  if (isRuntimeNumber(A) || isRuntimeLogical(A)) return 1;
+  if (isRuntimeSparseMatrix(A)) {
+    if (A.m !== A.n) throw new RuntimeError(`${fn}: adjacency must be square`);
+    return A.n;
+  }
+  if (isRuntimeTensor(A)) {
+    const rows = A.shape[0] ?? 1;
+    const cols = A.shape[1] ?? 1;
+    if (rows !== cols)
+      throw new RuntimeError(`${fn}: adjacency must be square`);
+    return rows;
+  }
+  throw new RuntimeError(`${fn}: adjacency must be a numeric matrix`);
+}
+function takeEntry(r, c, triangle) {
+  if (r === c) return true;
+  if (triangle === "lower") return r > c;
+  return r < c;
+}
+function adjToEdges(A, omitSelfLoops, triangle, fn) {
+  const n = squareDim(A, fn);
+  const weighted = !(isRuntimeTensor(A) && A._isLogical);
+  const edges = [];
+  const push = (r, c, val) => {
+    if (val === 0) return;
+    if (r === c) {
+      if (!omitSelfLoops) edges.push({ u: r + 1, v: r + 1, w: val });
+    } else if (takeEntry(r, c, triangle)) {
+      edges.push({ u: Math.min(r, c) + 1, v: Math.max(r, c) + 1, w: val });
+    }
+  };
+  if (isRuntimeSparseMatrix(A)) {
+    for (let c = 0; c < A.n; c++) {
+      for (let k = A.jc[c]; k < A.jc[c + 1]; k++) push(A.ir[k], c, A.pr[k]);
+    }
+  } else if (isRuntimeTensor(A)) {
+    const m = A.shape[0] ?? 1;
+    for (let c = 0; c < n; c++) {
+      for (let r = 0; r < n; r++) {
+        const val = A.data[c * m + r];
+        if (val !== 0) push(r, c, val);
+      }
+    }
+  } else if (isRuntimeNumber(A) || isRuntimeLogical(A)) {
+    const val = isRuntimeNumber(A) ? A : A ? 1 : 0;
+    if (val !== 0) push(0, 0, val);
+  }
+  return { n, edges, weighted };
+}
+function isNumericArg2(v) {
+  return isRuntimeNumber(v) || isRuntimeLogical(v) || isRuntimeTensor(v) || isRuntimeSparseMatrix(v);
+}
+function toNumArray2(v) {
+  if (isRuntimeNumber(v)) return [v];
+  if (isRuntimeLogical(v)) return [v ? 1 : 0];
+  if (isRuntimeTensor(v)) return Array.from(v.data);
+  throw new RuntimeError("graph: node/weight arguments must be numeric");
+}
+function argString(v) {
+  if (isRuntimeString(v)) return v;
+  if (isRuntimeChar(v)) return v.value;
+  return null;
+}
+registerIBuiltin({
+  name: "graph",
+  help: {
+    signatures: [
+      "G = graph(A)",
+      "G = graph(A, 'omitselfloops')",
+      "G = graph(A, 'upper' | 'lower')",
+      "G = graph(s, t)",
+      "G = graph(s, t, w)",
+      "G = graph(s, t, w, num)"
+    ],
+    description: "Create an undirected graph from an adjacency matrix A (which must be symmetric) or from edge endpoint lists s and t with optional weights w."
+  },
+  resolve: () => ({
+    outputTypes: [
+      {
+        kind: "class_instance",
+        className: "graph",
+        isHandleClass: false,
+        fields: {}
+      }
+    ],
+    apply: (args) => {
+      if (args.length === 0) return makeGraph(0, [], false);
+      if (args.length >= 2 && isNumericArg2(args[1])) {
+        const s = toNumArray2(args[0]);
+        const t = toNumArray2(args[1]);
+        if (s.length !== t.length) {
+          throw new RuntimeError("graph: s and t must have the same length");
+        }
+        let weighted2 = false;
+        let w = null;
+        let num = null;
+        let omitSelfLoops2 = false;
+        if (args.length >= 3 && isNumericArg2(args[2])) {
+          w = toNumArray2(args[2]);
+          weighted2 = true;
+          if (args.length >= 4 && isNumericArg2(args[3])) {
+            num = Math.floor(toNumber(args[3]));
+          }
+        }
+        for (let i = 2; i < args.length; i++) {
+          const str = argString(args[i]);
+          if (str && str.toLowerCase() === "omitselfloops")
+            omitSelfLoops2 = true;
+        }
+        let n2 = num ?? 0;
+        for (let i = 0; i < s.length; i++) n2 = Math.max(n2, s[i], t[i]);
+        const edges2 = [];
+        for (let i = 0; i < s.length; i++) {
+          const u = Math.min(s[i], t[i]);
+          const v = Math.max(s[i], t[i]);
+          if (omitSelfLoops2 && u === v) continue;
+          edges2.push({ u, v, w: w ? w[w.length === 1 ? 0 : i] : 1 });
+        }
+        return makeGraph(n2, edges2, weighted2);
+      }
+      let omitSelfLoops = false;
+      let triangle = "sym";
+      for (let i = 1; i < args.length; i++) {
+        const str = argString(args[i]);
+        if (!str) continue;
+        const lc = str.toLowerCase();
+        if (lc === "omitselfloops") omitSelfLoops = true;
+        else if (lc === "upper") triangle = "upper";
+        else if (lc === "lower") triangle = "lower";
+      }
+      const { n, edges, weighted } = adjToEdges(
+        args[0],
+        omitSelfLoops,
+        triangle,
+        "graph"
+      );
+      return makeGraph(n, edges, weighted);
+    }
+  })
+});
+registerIBuiltin({
+  name: "conncomp",
+  help: {
+    signatures: ["bins = conncomp(G)", "[bins, binsizes] = conncomp(G)"],
+    description: "Connected components of an undirected graph G. Returns a row vector labeling each node with its component index, and optionally the size of each component."
+  },
+  resolve: () => ({
+    outputTypes: [{ kind: "unknown" }, { kind: "unknown" }],
+    apply: (args, nargout) => {
+      const g = requireGraph(args[0], "conncomp");
+      const n = graphN(g);
+      const A = graphAdj(g);
+      const bins = new Float64Array(n);
+      const sizes = [];
+      let comp = 0;
+      const stack = [];
+      for (let start = 0; start < n; start++) {
+        if (bins[start] !== 0) continue;
+        comp++;
+        let count = 0;
+        bins[start] = comp;
+        stack.length = 0;
+        stack.push(start);
+        while (stack.length > 0) {
+          const node = stack.pop();
+          count++;
+          eachNeighbor(A, node, (r) => {
+            if (bins[r] === 0) {
+              bins[r] = comp;
+              stack.push(r);
+            }
+          });
+        }
+        sizes.push(count);
+      }
+      const binsT = RTV.tensor(bins, [1, n]);
+      if (nargout >= 2) {
+        return [binsT, RTV.tensor(allocFloat64Array(sizes), [1, sizes.length])];
+      }
+      return binsT;
+    }
+  })
+});
+registerIBuiltin({
+  name: "laplacian",
+  help: {
+    signatures: ["L = laplacian(G)"],
+    description: "Graph Laplacian matrix L = D - A of an undirected graph G, where A is the (binary, unweighted) adjacency matrix and D the diagonal node-degree matrix. Returns a sparse matrix."
+  },
+  resolve: () => ({
+    outputTypes: [{ kind: "unknown" }],
+    apply: (args) => {
+      const g = requireGraph(args[0], "laplacian");
+      const n = graphN(g);
+      const A = graphAdj(g);
+      const edges = [];
+      for (let c = 0; c < n; c++) {
+        let degree = 0;
+        eachNeighbor(A, c, (r) => {
+          degree++;
+          if (r < c) edges.push({ u: r + 1, v: c + 1, w: -1 });
+        });
+        edges.push({ u: c + 1, v: c + 1, w: degree });
+      }
+      return buildSymAdj(n, edges);
+    }
+  })
+});
+registerIBuiltin({
+  name: "addedge",
+  help: {
+    signatures: ["H = addedge(G, s, t)", "H = addedge(G, s, t, w)"],
+    description: "Add one or more edges between nodes s and t to graph G, returning a new graph. Weights w are required when G is a weighted graph."
+  },
+  resolve: () => ({
+    outputTypes: [
+      {
+        kind: "class_instance",
+        className: "graph",
+        isHandleClass: false,
+        fields: {}
+      }
+    ],
+    apply: (args) => {
+      const g = requireGraph(args[0], "addedge");
+      if (args.length < 3) {
+        throw new RuntimeError("addedge: requires nodes s and t");
+      }
+      const weighted = graphWeighted(g);
+      const s = toNumArray2(args[1]);
+      const t = toNumArray2(args[2]);
+      if (s.length !== t.length) {
+        throw new RuntimeError("addedge: s and t must have the same length");
+      }
+      let w = null;
+      if (args.length >= 4) {
+        w = toNumArray2(args[3]);
+      } else if (weighted) {
+        throw new RuntimeError(
+          "addedge: Must specify weights when adding an edge to a weighted graph."
+        );
+      }
+      const edges = edgesFromAdj(graphAdj(g));
+      let n = graphN(g);
+      for (let i = 0; i < s.length; i++) {
+        const u = Math.min(s[i], t[i]);
+        const v = Math.max(s[i], t[i]);
+        n = Math.max(n, u, v);
+        edges.push({ u, v, w: w ? w[w.length === 1 ? 0 : i] : 1 });
+      }
+      return makeGraph(n, edges, weighted);
+    }
+  })
+});
+registerIBuiltin({
+  name: "numnodes",
+  help: {
+    signatures: ["n = numnodes(G)"],
+    description: "Number of nodes in graph G."
+  },
+  resolve: () => ({
+    outputTypes: [{ kind: "number" }],
+    apply: (args) => RTV.num(graphN(requireGraph(args[0], "numnodes")))
+  })
+});
+registerIBuiltin({
+  name: "numedges",
+  help: {
+    signatures: ["m = numedges(G)"],
+    description: "Number of edges in graph G."
+  },
+  resolve: () => ({
+    outputTypes: [{ kind: "number" }],
+    apply: (args) => {
+      const g = requireGraph(args[0], "numedges");
+      return RTV.num(edgesFromAdj(graphAdj(g)).length);
+    }
+  })
+});
+registerIBuiltin({
+  name: "degree",
+  help: {
+    signatures: ["d = degree(G)"],
+    description: "Degree of each node in graph G, returned as a column vector of edge counts (self-loops excluded)."
+  },
+  resolve: () => ({
+    outputTypes: [{ kind: "unknown" }],
+    apply: (args) => {
+      const g = requireGraph(args[0], "degree");
+      const n = graphN(g);
+      const A = graphAdj(g);
+      const d = new Float64Array(n);
+      for (let c = 0; c < n; c++) eachNeighbor(A, c, () => d[c] += 1);
+      return RTV.tensor(d, [n, 1]);
+    }
+  })
+});
+
+// src/numbl-core/interpreter/builtins/gallery.ts
+function toNumArray3(v, what) {
+  if (isRuntimeNumber(v)) return [v];
+  if (isRuntimeLogical(v)) return [v ? 1 : 0];
+  if (isRuntimeTensor(v)) return Array.from(v.data);
+  if (isRuntimeComplexNumber(v)) return [v.re];
+  throw new RuntimeError(`gallery: ${what} must be numeric`);
+}
+function buildTridiag(sub2, diag2, sup) {
+  const n = diag2.length;
+  if (sub2.length !== n - 1 || sup.length !== n - 1) {
+    throw new RuntimeError(
+      "gallery: tridiag sub/superdiagonal must have length one less than the diagonal"
+    );
+  }
+  const ir = [];
+  const pr = [];
+  const jc = new Int32Array(n + 1);
+  for (let c = 0; c < n; c++) {
+    jc[c] = ir.length;
+    if (c >= 1 && sup[c - 1] !== 0) {
+      ir.push(c - 1);
+      pr.push(sup[c - 1]);
+    }
+    if (diag2[c] !== 0) {
+      ir.push(c);
+      pr.push(diag2[c]);
+    }
+    if (c <= n - 2 && sub2[c] !== 0) {
+      ir.push(c + 1);
+      pr.push(sub2[c]);
+    }
+  }
+  jc[n] = ir.length;
+  return RTV.sparseMatrix(n, n, new Int32Array(ir), jc, allocFloat64Array(pr));
+}
+function buildTridiagToeplitz(n, c, d, e) {
+  const off = Math.max(0, n - 1);
+  return buildTridiag(
+    new Array(off).fill(c),
+    new Array(n).fill(d),
+    new Array(off).fill(e)
+  );
+}
+function galleryTridiag(rest) {
+  if (rest.length === 1) {
+    return buildTridiagToeplitz(Math.round(toNumber(rest[0])), -1, 2, -1);
+  }
+  if (rest.length === 4) {
+    return buildTridiagToeplitz(
+      Math.round(toNumber(rest[0])),
+      toNumber(rest[1]),
+      toNumber(rest[2]),
+      toNumber(rest[3])
+    );
+  }
+  if (rest.length === 3) {
+    const sub2 = toNumArray3(rest[0], "subdiagonal");
+    const diag2 = toNumArray3(rest[1], "diagonal");
+    const sup = toNumArray3(rest[2], "superdiagonal");
+    if (sub2.length === 1 && diag2.length === 1 && sup.length === 1) {
+      return buildTridiag([], diag2, []);
+    }
+    return buildTridiag(sub2, diag2, sup);
+  }
+  throw new RuntimeError("gallery: tridiag expects (n), (n,c,d,e), or (x,y,z)");
+}
+registerIBuiltin({
+  name: "gallery",
+  help: {
+    signatures: [
+      "A = gallery('tridiag', n)",
+      "A = gallery('tridiag', n, c, d, e)",
+      "A = gallery('tridiag', x, y, z)"
+    ],
+    description: "Test matrices. gallery('tridiag', ...) returns a sparse tridiagonal matrix: gallery('tridiag', n) is the order-n matrix with -1 on the sub/superdiagonals and 2 on the diagonal (the negative second-difference matrix); gallery('tridiag', n, c, d, e) is the order-n Toeplitz tridiagonal with scalar sub c, diagonal d, super e; gallery('tridiag', x, y, z) uses vectors x (subdiagonal), y (diagonal), z (superdiagonal), where x and z have length one less than y."
+  },
+  resolve: () => ({
+    outputTypes: [{ kind: "unknown" }],
+    apply: (args) => {
+      if (args.length < 1) {
+        throw new RuntimeError("gallery: not enough input arguments");
+      }
+      const name = parseStringArgLower(args[0]);
+      let rest = args.slice(1);
+      if (rest.length >= 1) {
+        const last = rest[rest.length - 1];
+        if (isRuntimeString(last) || isRuntimeChar(last)) {
+          const cn = parseStringArgLower(last);
+          if (cn === "single" || cn === "double") rest = rest.slice(0, -1);
+        }
+      }
+      switch (name) {
+        case "tridiag":
+          return galleryTridiag(rest);
+        default:
+          throw new RuntimeError(
+            `gallery: matrix family '${name}' is not supported`
+          );
+      }
+    }
+  })
+});
 
 // src/numbl-core/interpreter/builtins/special-math.ts
 function binaryApply(a, b, fn) {
@@ -48027,12 +49522,19 @@ registerIBuiltin({
 
 // src/numbl-core/native/geometry-bridge.ts
 var backend = null;
+var hullBackend = null;
 function setDelaunayBackend(fn) {
   backend = fn;
 }
 function getDelaunayBackend() {
   return backend;
 }
+function setConvexHullBackend(fn) {
+  hullBackend = fn;
+}
+function getConvexHullBackend() {
+  return hullBackend;
+}
 
 // src/numbl-core/interpreter/builtins/geometry.ts
 function toFlatArray(v, name) {
@@ -48085,7 +49587,7 @@ function simplexVolume(points, cell, dim) {
   for (let k = 2; k <= dim; k++) fact *= k;
   return Math.abs(det) / fact;
 }
-function triangulateToTensor(points, dim) {
+function triangulateToTensor(points, dim, orientCCW = false) {
   const backend2 = getDelaunayBackend();
   if (!backend2)
     throw new RuntimeError(
@@ -48105,6 +49607,16 @@ function triangulateToTensor(points, dim) {
   const cells = volTol > 0 ? raw.filter((cell) => simplexVolume(points, cell, dim) > volTol) : raw;
   const numCells = cells.length;
   const cols = dim + 1;
+  if (orientCCW && dim === 2) {
+    for (const cell of cells) {
+      const [a, b, c] = cell;
+      const signedArea2 = (points[b][0] - points[a][0]) * (points[c][1] - points[a][1]) - (points[c][0] - points[a][0]) * (points[b][1] - points[a][1]);
+      if (signedArea2 < 0) {
+        cell[1] = c;
+        cell[2] = b;
+      }
+    }
+  }
   const out = allocFloat64Array(numCells * cols);
   for (let i = 0; i < numCells; i++) {
     const cell = cells[i];
@@ -48158,7 +49670,7 @@ defineBuiltin({
           throw new RuntimeError(
             `delaunay: need at least ${dim + 1} points for a ${dim}-D triangulation`
           );
-        return triangulateToTensor(points, dim);
+        return triangulateToTensor(points, dim, true);
       }
     }
   ]
@@ -48201,6 +49713,203 @@ defineBuiltin({
     }
   ]
 });
+var CONVHULLN_MAX_DIM = 3;
+function convexHullFacets(points, dim, name) {
+  const backend2 = getConvexHullBackend();
+  if (!backend2)
+    throw new RuntimeError(
+      `${name}: convex-hull backend not initialized. In Node call loadQhullNodeBackend() (the CLI and library do this automatically); in the browser worker it loads on startup.`
+    );
+  return backend2(points, dim);
+}
+function hullInteriorPoint(points, facets, dim) {
+  const used = /* @__PURE__ */ new Set();
+  for (const f of facets) for (const idx of f) used.add(idx);
+  const c = new Array(dim).fill(0);
+  for (const idx of used) {
+    const p2 = points[idx];
+    for (let k = 0; k < dim; k++) c[k] += p2[k];
+  }
+  const m = used.size || 1;
+  for (let k = 0; k < dim; k++) c[k] /= m;
+  return c;
+}
+function hullMeasure(points, facets, dim) {
+  const c = hullInteriorPoint(points, facets, dim);
+  let total = 0;
+  if (dim === 2) {
+    for (const f of facets) {
+      const a = points[f[0]];
+      const b = points[f[1]];
+      const ax = a[0] - c[0], ay = a[1] - c[1];
+      const bx = b[0] - c[0], by = b[1] - c[1];
+      total += Math.abs(ax * by - ay * bx) / 2;
+    }
+  } else {
+    for (const f of facets) {
+      const a = points[f[0]];
+      const b = points[f[1]];
+      const d = points[f[2]];
+      const ax = a[0] - c[0], ay = a[1] - c[1], az = a[2] - c[2];
+      const bx = b[0] - c[0], by = b[1] - c[1], bz = b[2] - c[2];
+      const dx = d[0] - c[0], dy = d[1] - c[1], dz = d[2] - c[2];
+      const det = ax * (by * dz - bz * dy) - ay * (bx * dz - bz * dx) + az * (bx * dy - by * dx);
+      total += Math.abs(det) / 6;
+    }
+  }
+  return total;
+}
+function facetsToTensor(facets, cols) {
+  const n = facets.length;
+  const out = allocFloat64Array(n * cols);
+  for (let i = 0; i < n; i++) {
+    const f = facets[i];
+    for (let j = 0; j < cols; j++) out[j * n + i] = f[j] + 1;
+  }
+  return RTV.tensor(out, [n, cols]);
+}
+function orderHull2D(facets, points) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const [a, b] of facets) {
+    (adj.get(a) ?? adj.set(a, []).get(a)).push(b);
+    (adj.get(b) ?? adj.set(b, []).get(b)).push(a);
+  }
+  const start = facets[0][0];
+  const loop = [start];
+  let prev = -1;
+  let cur = start;
+  for (let guard = 0; guard <= facets.length; guard++) {
+    const nbrs = adj.get(cur);
+    const next = nbrs[0] === prev ? nbrs[1] : nbrs[0];
+    if (next === void 0 || next === start) break;
+    loop.push(next);
+    prev = cur;
+    cur = next;
+  }
+  let signed = 0;
+  for (let i = 0; i < loop.length; i++) {
+    const p2 = points[loop[i]];
+    const q = points[loop[(i + 1) % loop.length]];
+    signed += p2[0] * q[1] - q[0] * p2[1];
+  }
+  if (signed < 0) loop.reverse();
+  loop.push(loop[0]);
+  const out = allocFloat64Array(loop.length);
+  for (let i = 0; i < loop.length; i++) out[i] = loop[i] + 1;
+  return RTV.tensor(out, [loop.length, 1]);
+}
+defineBuiltin({
+  name: "convhull",
+  help: {
+    signatures: [
+      "k = convhull(P)",
+      "k = convhull(x,y)",
+      "k = convhull(x,y,z)",
+      "k = convhull(___,'Simplify',tf)",
+      "[k,av] = convhull(___)"
+    ],
+    description: "Convex hull of a set of 2-D or 3-D points. With a single matrix P (N-by-2 or N-by-3), or coordinate vectors x,y (2-D) or x,y,z (3-D). For 2-D input, k is a column vector of 1-based point indices tracing the hull boundary counter-clockwise (closed: k(1)==k(end)). For 3-D input, k is a numFacets-by-3 matrix of triangle vertex indices. The second output av is the area (2-D) or volume (3-D). The 'Simplify' name-value pair is accepted for compatibility; the hull is always returned in minimal (simplified) form."
+  },
+  cases: [
+    {
+      match: (argTypes, nargout) => {
+        if (nargout > 2) return null;
+        if (argTypes.length < 1 || argTypes.length > 5) return null;
+        const ok = (t) => t.kind === "number" || t.kind === "boolean" || t.kind === "tensor" || t.kind === "string" || t.kind === "char";
+        if (!argTypes.every(ok)) return null;
+        const k = { kind: "tensor", isComplex: false };
+        return nargout > 1 ? [k, { kind: "number" }] : [k];
+      },
+      apply: (args, nargout) => {
+        let coordArgs = args;
+        const tail = args[args.length - 2];
+        const isSimplifyName = (v) => typeof v === "string" && v.toLowerCase() === "simplify" || isRuntimeChar(v) && v.value.toLowerCase() === "simplify";
+        if (args.length >= 3 && isSimplifyName(tail)) {
+          coordArgs = args.slice(0, args.length - 2);
+        }
+        let points;
+        let dim;
+        if (coordArgs.length === 1) {
+          const P = coordArgs[0];
+          if (!isRuntimeTensor(P))
+            throw new RuntimeError(
+              "convhull: P must be an N-by-2 or N-by-3 matrix"
+            );
+          const [, d] = tensorSize2D(P);
+          if (d !== 2 && d !== 3)
+            throw new RuntimeError("convhull: P must have 2 or 3 columns");
+          points = matrixToPoints(P, "convhull");
+          dim = d;
+        } else if (coordArgs.length === 2 || coordArgs.length === 3) {
+          const coords = coordArgs.map((a) => toFlatArray(a, "convhull"));
+          const n = coords[0].length;
+          if (coords.some((c) => c.length !== n))
+            throw new RuntimeError(
+              "convhull: coordinate vectors must have the same length"
+            );
+          points = new Array(n);
+          for (let i = 0; i < n; i++) points[i] = coords.map((c) => c[i]);
+          dim = coordArgs.length;
+        } else {
+          throw new RuntimeError("convhull: invalid arguments");
+        }
+        if (points.length < dim + 1)
+          throw new RuntimeError(
+            `convhull: need at least ${dim + 1} points for a ${dim}-D hull`
+          );
+        const facets = convexHullFacets(points, dim, "convhull");
+        const k = dim === 2 ? orderHull2D(facets, points) : facetsToTensor(facets, 3);
+        if (nargout > 1) return [k, hullMeasure(points, facets, dim)];
+        return k;
+      }
+    }
+  ]
+});
+defineBuiltin({
+  name: "convhulln",
+  help: {
+    signatures: [
+      "k = convhulln(P)",
+      "k = convhulln(P,opts)",
+      "[k,vol] = convhulln(___)"
+    ],
+    description: "N-D convex hull. P is an m-by-n matrix of m points in n-dimensional space. Returns a numFacets-by-n matrix where each row holds the 1-based point indices of one simplicial facet (edges for n=2, triangles for n=3). The second output is the area (n=2) or volume (n=3). The opts argument (Qhull options) is accepted for MATLAB compatibility but ignored. Note: only n = 2 and n = 3 are supported (see source comments)."
+  },
+  cases: [
+    {
+      match: (argTypes, nargout) => {
+        if (nargout > 2) return null;
+        if (argTypes.length < 1 || argTypes.length > 2) return null;
+        const x = argTypes[0];
+        if (x.kind !== "tensor" && x.kind !== "number" && x.kind !== "boolean")
+          return null;
+        const k = { kind: "tensor", isComplex: false };
+        return nargout > 1 ? [k, { kind: "number" }] : [k];
+      },
+      apply: (args, nargout) => {
+        const P = args[0];
+        if (!isRuntimeTensor(P))
+          throw new RuntimeError("convhulln: P must be an m-by-n matrix");
+        const [m, n] = tensorSize2D(P);
+        if (n < 2)
+          throw new RuntimeError("convhulln: P must have at least 2 columns");
+        if (n > CONVHULLN_MAX_DIM)
+          throw new RuntimeError(
+            `convhulln: only 2-D and 3-D hulls are supported (got ${n}-D); higher dimensions are not yet validated`
+          );
+        if (m < n + 1)
+          throw new RuntimeError(
+            `convhulln: need at least ${n + 1} points for a ${n}-D hull`
+          );
+        const points = matrixToPoints(P, "convhulln");
+        const facets = convexHullFacets(points, n, "convhulln");
+        const k = facetsToTensor(facets, n);
+        if (nargout > 1) return [k, hullMeasure(points, facets, n)];
+        return k;
+      }
+    }
+  ]
+});
 function getQueryValues(v, name) {
   if (typeof v === "number") return { data: [v], shape: null };
   if (typeof v === "boolean") return { data: [v ? 1 : 0], shape: null };
@@ -48698,6 +50407,13 @@ registerIBuiltin({
     apply: (_args, nargout) => nargout >= 1 ? RTV.dummyHandle() : void 0
   })
 });
+registerIBuiltin({
+  name: "waitbar",
+  resolve: () => ({
+    outputTypes: [{ kind: "unknown" }],
+    apply: (_args, nargout) => nargout >= 1 ? RTV.dummyHandle() : void 0
+  })
+});
 registerIBuiltin({
   name: "get",
   resolve: () => ({
@@ -49836,6 +51552,10 @@ var H = {
     signatures: ["C = class(A)"],
     description: "Returns the class name of A as a character vector."
   },
+  superclasses: {
+    signatures: ["S = superclasses(ClassName)", "S = superclasses(obj)"],
+    description: "Names of the superclasses of a class, returned as a column cell array of character vectors. Accepts a class name (char/string) or an object. Returns an empty cell for built-in types or classes with no superclasses."
+  },
   fieldnames: {
     signatures: ["F = fieldnames(S)"],
     description: "Returns cell array of field names of struct or object S."
@@ -50239,6 +51959,14 @@ var H = {
     signatures: ["B = pinv(A)", "B = pinv(A, TOL)"],
     description: "Moore-Penrose pseudoinverse."
   },
+  null: {
+    signatures: ["Z = null(A)", "Z = null(A, TOL)"],
+    description: "Orthonormal basis for the null space of A (columns of Z), computed via the SVD. TOL overrides the singular-value tolerance."
+  },
+  bandwidth: {
+    signatures: ["[lower, upper] = bandwidth(A)", "B = bandwidth(A, TYPE)"],
+    description: "Lower and upper matrix bandwidth. TYPE is 'lower' or 'upper'; a single output without TYPE returns the lower bandwidth."
+  },
   cond: {
     signatures: ["C = cond(A)", "C = cond(A, P)"],
     description: "Condition number of matrix."
@@ -50468,6 +52196,10 @@ var H = {
     signatures: ["Y = double(X)"],
     description: "Convert to double precision."
   },
+  single: {
+    signatures: ["Y = single(X)"],
+    description: "Round to single precision. numbl stores all numerics as double, so the result reports class 'double', but the low-order bits are dropped as in MATLAB."
+  },
   logical: {
     signatures: ["Y = logical(X)"],
     description: "Convert to logical (boolean) array."
@@ -50838,6 +52570,18 @@ var H = {
     ],
     description: "Extract or create sparse banded/diagonal matrices."
   },
+  spparms: {
+    signatures: [
+      "spparms",
+      "values = spparms",
+      "[keys, values] = spparms",
+      "value = spparms(KEY)",
+      "spparms(KEY, VALUE)",
+      "spparms('default')",
+      "spparms(values)"
+    ],
+    description: "Get/set sparse direct-solver parameters. numbl's sparse solver ignores these knobs; values are stored so they round-trip through get/set/restore but have no effect."
+  },
   // ── Linear algebra extras ─────────────────────────────────────────────
   qz: {
     signatures: [
@@ -52459,7 +54203,9 @@ function dispatchPlotBuiltin(name, args, instructions, state) {
       return true;
     }
     case "close": {
-      if (args.length > 0 && toString(args[0]) === "all") {
+      const a0 = args[0];
+      const isText3 = a0 !== void 0 && (isRuntimeChar(a0) || isRuntimeString(a0));
+      if (isText3 && toString(a0) === "all") {
         plotInstr(instructions, { type: "close_all" });
       } else {
         plotInstr(instructions, { type: "close" });
@@ -53502,8 +55248,8 @@ function registerSpecialBuiltins(rt) {
     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") {
+      const mode = toString(margs[0]);
+      if (mode === "on" || mode === "off") {
         if (nargout === 0) return void 0;
         return RTV.struct(
           /* @__PURE__ */ new Map([
@@ -53512,6 +55258,14 @@ function registerSpecialBuiltins(rt) {
           ])
         );
       }
+      if (mode === "query") {
+        return RTV.struct(
+          /* @__PURE__ */ new Map([
+            ["state", RTV.char("on")],
+            ["identifier", margs[1]]
+          ])
+        );
+      }
     }
     let fmtIdx = 0;
     if (margs.length >= 2 && isRuntimeChar(margs[0]) && toString(margs[0]).includes(":")) {
@@ -55034,6 +56788,10 @@ function _eigsImpl(rt, nargout, args) {
   const margs = args.map((a) => ensureRuntimeValue(a));
   if (margs.length < 1)
     throw new RuntimeError("eigs requires at least 1 argument");
+  for (let i = 0; i < margs.length; i++) {
+    const mi = margs[i];
+    if (isRuntimeSparseMatrix(mi)) margs[i] = sparseToDense(mi);
+  }
   let afun = null;
   let A = null;
   let n;
@@ -56258,43 +58016,40 @@ function methodDispatch(rt, name, nargout, args) {
             }
           }
         }
-        try {
-          return callClassMethod(rt, firstRV.className, name, nargout, args);
-        } catch (e) {
-          if (e instanceof RuntimeError) {
-            const guardKey = `${firstRV.className}.subsref`;
-            if (!rt.activeAccessors.has(guardKey)) {
-              const subsrefFn = rt.cachedResolveClassMethod(
-                firstRV.className,
-                "subsref"
-              );
-              if (subsrefFn) {
-                const remaining = args.slice(1);
-                const sEntries = [
-                  RTV.struct({
-                    type: RTV.char("."),
-                    subs: RTV.char(name)
-                  }),
-                  RTV.struct({
-                    type: RTV.char("()"),
-                    subs: RTV.cell(
-                      remaining.map((a) => ensureRuntimeValue(a)),
-                      [1, remaining.length]
-                    )
-                  })
-                ];
-                const S = RTV.structArray(["type", "subs"], sEntries);
-                rt.activeAccessors.add(guardKey);
-                try {
-                  return subsrefFn(nargout, first, S);
-                } finally {
-                  rt.activeAccessors.delete(guardKey);
-                }
+        const methodExists = rt.cachedResolveClassMethod(firstRV.className, name) !== null;
+        if (!methodExists) {
+          const guardKey = `${firstRV.className}.subsref`;
+          if (!rt.activeAccessors.has(guardKey)) {
+            const subsrefFn = rt.cachedResolveClassMethod(
+              firstRV.className,
+              "subsref"
+            );
+            if (subsrefFn) {
+              const remaining = args.slice(1);
+              const sEntries = [
+                RTV.struct({
+                  type: RTV.char("."),
+                  subs: RTV.char(name)
+                }),
+                RTV.struct({
+                  type: RTV.char("()"),
+                  subs: RTV.cell(
+                    remaining.map((a) => ensureRuntimeValue(a)),
+                    [1, remaining.length]
+                  )
+                })
+              ];
+              const S = RTV.structArray(["type", "subs"], sEntries);
+              rt.activeAccessors.add(guardKey);
+              try {
+                return subsrefFn(nargout, first, S);
+              } finally {
+                rt.activeAccessors.delete(guardKey);
               }
             }
           }
-          throw e;
         }
+        return callClassMethod(rt, firstRV.className, name, nargout, args);
       }
     }
     const builtin = rt.builtins[name];
@@ -56351,11 +58106,13 @@ function arrayfunCellfunImpl(rt, name, nargout, args) {
   const getElem = (arr, i) => {
     if (isRuntimeCell(arr)) return arr.data[i];
     if (isRuntimeTensor(arr)) return arr.data[i];
+    if (isRuntimeStructArray(arr)) return arr.elements[i];
     return arr;
   };
   const getLen = (arr) => {
     if (isRuntimeCell(arr)) return arr.data.length;
     if (isRuntimeTensor(arr)) return arr.data.length;
+    if (isRuntimeStructArray(arr)) return arr.elements.length;
     return 1;
   };
   const collectArgs = (i) => {
@@ -56391,9 +58148,9 @@ function arrayfunCellfunImpl(rt, name, nargout, args) {
     if (allLogical && arrArg.data.length > 0) result._isLogical = true;
     return result;
   }
-  if (isRuntimeCell(arrArg) || extraInputs.length > 0 || nargout > 1) {
+  if (isRuntimeCell(arrArg) || isRuntimeStructArray(arrArg) || extraInputs.length > 0 || nargout > 1) {
     const len = getLen(arrArg);
-    const shape = isRuntimeCell(arrArg) ? [...arrArg.shape] : isRuntimeTensor(arrArg) ? [...arrArg.shape] : [1, len];
+    const shape = isRuntimeCell(arrArg) || isRuntimeTensor(arrArg) ? [...arrArg.shape] : [1, len];
     if (nargout > 1) {
       const allResults = Array.from(
         { length: nargout },
@@ -57228,6 +58985,28 @@ function indexStore(rt, base, indices, rhs, skipSubsasgn = false) {
   if (isRuntimeStruct(mv)) {
     return ensureRuntimeValue(rhs);
   }
+  if (indices.length === 1 && isRuntimeClassInstance(ensureRuntimeValue(rhs)) && // Object-array growth uses a numeric position. A char/string index (e.g. a
+  // key into a containers.Map whose value happens to be a class instance)
+  // must fall through to the subsasgn dispatch below, not be coerced to a
+  // number — `toNumber` on a multi-char value throws.
+  !isRuntimeChar(ensureRuntimeValue(indices[0]))) {
+    const k = Math.round(toNumber(ensureRuntimeValue(indices[0]))) - 1;
+    const growsArray = isRuntimeClassInstanceArray(mv) || isRuntimeTensor(mv) && mv.data.length === 0 || isRuntimeClassInstance(mv) && k >= 1;
+    if (growsArray) {
+      if (k < 0) throw new RuntimeError("Index must be a positive integer");
+      const rhsInst = ensureRuntimeValue(rhs);
+      const existing = isRuntimeClassInstanceArray(mv) ? [...mv.elements] : isRuntimeClassInstance(mv) ? [mv] : [];
+      const className = isRuntimeClassInstanceArray(mv) ? mv.className : isRuntimeClassInstance(mv) ? mv.className : rhsInst.className;
+      while (existing.length < k) {
+        existing.push(
+          RTV.classInstance(className, [...rhsInst.fields.keys()], false)
+        );
+      }
+      existing[k] = rhsInst;
+      if (existing.length === 1) return existing[0];
+      return RTV.classInstanceArray(className, existing, [1, existing.length]);
+    }
+  }
   if (isRuntimeClassInstance(mv)) {
     const guardKey = `${mv.className}.subsasgn`;
     if (!skipSubsasgn && !rt.activeAccessors.has(guardKey)) {
@@ -57385,12 +59164,17 @@ function getMember(rt, base, name) {
       `No property or method '${name}' for class '${mv.className}'`
     );
   }
+  if (isRuntimeClassInstanceArray(mv)) {
+    const values = mv.elements.map(
+      (el) => ensureRuntimeValue(getMember(rt, el, name))
+    );
+    return horzcat(...values);
+  }
   return getRTValueField(mv, name);
 }
-function getMemberDynamic(base, nameExpr) {
-  const mv = ensureRuntimeValue(base);
+function getMemberDynamic(rt, base, nameExpr) {
   const name = toString(ensureRuntimeValue(nameExpr));
-  return getRTValueField(mv, name);
+  return ensureRuntimeValue(getMember(rt, base, name));
 }
 function getMemberOrEmpty(base, name) {
   try {
@@ -57412,7 +59196,7 @@ function setMemberReturn(rt, base, name, rhs) {
       if (setter) {
         rt.activeAccessors.add(accessorKey);
         try {
-          const result = setter(1, base, rhs);
+          const result = setter(0, base, rhs);
           return result !== void 0 ? result : base;
         } finally {
           rt.activeAccessors.delete(accessorKey);
@@ -57424,10 +59208,8 @@ function setMemberReturn(rt, base, name, rhs) {
   return setRTValueField(mv, name, rhsMv, rt);
 }
 function setMemberDynamicReturn(rt, base, nameExpr, rhs) {
-  const mv = ensureRuntimeValue(base);
   const name = toString(ensureRuntimeValue(nameExpr));
-  const rhsMv = ensureRuntimeValue(rhs);
-  return setRTValueField(mv, name, rhsMv, rt);
+  return ensureRuntimeValue(setMemberReturn(rt, base, name, rhs));
 }
 function subsrefCall(rt, base, names) {
   const mv = ensureRuntimeValue(base);
@@ -58722,7 +60504,7 @@ function marchingCubes(dims, getVal, getCoord, iso, opts) {
   }
   return { vertices, faces, colors };
 }
-function isNumericArg2(v) {
+function isNumericArg3(v) {
   return typeof v === "number" || typeof v === "boolean" || isRuntimeTensor(v);
 }
 function dims3(v) {
@@ -58739,7 +60521,7 @@ function isosurfaceFromArgs(args) {
     if (isRuntimeChar(a) || isRuntimeString(a)) {
       const s = toString(a).toLowerCase();
       if (s === "noshare") share = false;
-    } else if (isNumericArg2(a)) {
+    } else if (isNumericArg3(a)) {
       nums.push(a);
     }
   }
@@ -60076,7 +61858,7 @@ var Runtime = class _Runtime {
     return getMember(this, base, name);
   }
   getMemberDynamic(base, nameExpr) {
-    return getMemberDynamic(base, nameExpr);
+    return getMemberDynamic(this, base, nameExpr);
   }
   getMemberOrEmpty(base, name) {
     return getMemberOrEmpty(base, name);
@@ -60724,6 +62506,7 @@ function resolveFunctionImpl(name, argTypes, callSite, index2) {
     for (const argType of argTypes) {
       if (argType?.kind === "ClassInstance") {
         const className = argType.className;
+        if (index2.classConstructors.get(className) === name) continue;
         if (!candidates.includes(className) && (index2.classInstanceMethods.get(className)?.has(name) || index2.classStaticMethods.get(className)?.has(name))) {
           candidates.push(className);
         }
@@ -60832,12 +62615,25 @@ var Environment = class _Environment {
   }
   /** Function ID for persistent variable storage */
   persistentFuncId;
+  /** Call-site variable names of this frame's arguments, for `inputname`.
+   *  Entry i is the name of the variable passed as argument i+1, or '' if
+   *  that argument was not a plain variable. Undefined when the call did
+   *  not originate from an interpreted call expression (e.g. feval, JIT).
+   *  Read directly off the executing frame — the interpreter has only
+   *  function-level scoping, so `this.env` is the frame while a body runs. */
+  inputArgNames;
   /** Back-reference to the runtime (needed for global/persistent access) */
   rt = null;
   /** Set when a `@nestedFn` handle has been created that captures this env
    *  (or an ancestor). Tells the function-exit cleanup that clearing this
    *  env would strand the handle's closure, so locals must be left alive. */
   nestedHandleCreated = false;
+  /** For a nested-function frame: the names of this function's own formal
+   *  input/output arguments. These are always local — a write must never be
+   *  redirected to a same-named variable in the parent, even before the
+   *  output has been assigned. (MATLAB scopes a nested function's formal
+   *  arguments to that function; only other variables are shared.) */
+  nestedLocalNames;
   get(name) {
     if (this._globalNames !== void 0 && this._globalNames.has(name) && this.rt) {
       const v = this.rt.$g[name];
@@ -60856,7 +62652,7 @@ var Environment = class _Environment {
       if (old !== void 0) decref(this.rt, old);
       return;
     }
-    if (this.isNested && !this.vars.has(name) && this.parent) {
+    if (this.isNested && !this.vars.has(name) && this.parent && !this.nestedLocalNames?.has(name)) {
       const owner = this.findOwner(name);
       if (owner) {
         owner.setLocal(name, value);
@@ -62051,6 +63847,7 @@ function makeRootContext(interp, registry3) {
 var interpreterExec_exports = {};
 __export(interpreterExec_exports, {
   assignLValue: () => assignLValue,
+  computeInputNames: () => computeInputNames,
   evalAnonFunc: () => evalAnonFunc,
   evalArgs: () => evalArgs,
   evalBinary: () => evalBinary,
@@ -62353,6 +64150,11 @@ function execStmtInner(stmt) {
     case "Global": {
       for (const name of stmt.names) {
         this.env.globalNames.add(name);
+        if (this.rt && !(name in this.rt.$g)) {
+          const empty = RTV.tensor(allocFloat64Array(0), [0, 0]);
+          incref(empty);
+          this.rt.$g[name] = empty;
+        }
       }
       return null;
     }
@@ -62464,6 +64266,10 @@ function evalExprNargout(expr, nargout) {
         if (isRuntimeStructArray(rv)) {
           return rv.elements.length;
         }
+        if (isRuntimeClassInstanceArray(rv)) {
+          if (ctx.numIndices === 1) return rv.elements.length;
+          return ctx.dimIndex < rv.shape.length ? rv.shape[ctx.dimIndex] : 1;
+        }
         if (isRuntimeSparseMatrix(rv)) {
           if (ctx.numIndices === 1) return rv.m * rv.n;
           return ctx.dimIndex === 0 ? rv.m : ctx.dimIndex === 1 ? rv.n : 1;
@@ -62624,6 +64430,23 @@ function evalExprNargout(expr, nargout) {
       throw new RuntimeError("Interpreter does not yet support meta.class");
   }
 }
+function computeInputNames(argExprs, callerEnv) {
+  const names = [];
+  let blanked = false;
+  for (const a of argExprs) {
+    if (blanked) {
+      names.push("");
+    } else if (a.type === "Ident" && callerEnv.has(a.name)) {
+      names.push(a.name);
+    } else if (a.type === "IndexCell" || a.type === "Member" || a.type === "MemberDynamic") {
+      names.push("");
+      blanked = true;
+    } else {
+      names.push("");
+    }
+  }
+  return names;
+}
 function evalArgs(argExprs) {
   const args = [];
   for (const a of argExprs) {
@@ -62753,6 +64576,7 @@ function evalFuncCall(expr, nargout) {
     const c = getConstant(expr.name);
     if (c !== void 0) return c;
   }
+  this.pendingInputNames = expr.args.length > 0 ? computeInputNames(expr.args, this.env) : void 0;
   return this.callFunction(expr.name, args, nargout);
 }
 function evalMember(expr, nargout) {
@@ -62932,7 +64756,14 @@ function makeFuncHandle(name) {
     );
   };
   fn.jsFnExpectsNargout = true;
-  const narg = getIBuiltinNargin(name);
+  let narg = getIBuiltinNargin(name);
+  if (narg === void 0) {
+    try {
+      narg = this.declaredNargin(name);
+    } catch {
+      narg = void 0;
+    }
+  }
   if (narg !== void 0) fn.nargin = narg;
   if (isNested) {
     fn.releaseExtra = () => capturedEnv.clearLocals();
@@ -63221,6 +65052,7 @@ __export(interpreterFunctions_exports, {
   callNestedFunction: () => callNestedFunction,
   callUserFunction: () => callUserFunction,
   collectClassProperties: () => collectClassProperties,
+  declaredNargin: () => declaredNargin,
   evalInLocalScope: () => evalInLocalScope,
   findExternalMethod: () => findExternalMethod,
   findFunctionInClassFile: () => findFunctionInClassFile,
@@ -63523,6 +65355,30 @@ register("isa", (ctx, args) => {
   if (args.length !== 2) return FALL_THROUGH;
   return ctx.rt.isa(args[0], args[1]);
 });
+register("superclasses", (ctx, args) => {
+  if (args.length !== 1) return FALL_THROUGH;
+  const v = ensureRuntimeValue(args[0]);
+  let className;
+  if (isRuntimeClassInstance(v) || isRuntimeClassInstanceArray(v)) {
+    className = v.className;
+  } else if (isRuntimeChar(v) || isRuntimeString(v)) {
+    className = toString(v);
+  }
+  const names = [];
+  if (className) {
+    const seen = /* @__PURE__ */ new Set([className]);
+    let current = ctx.rt.getClassParentName(className);
+    while (current && !seen.has(current)) {
+      names.push(current);
+      seen.add(current);
+      current = ctx.rt.getClassParentName(current);
+    }
+  }
+  return RTV.cell(
+    names.map((n) => RTV.string(n)),
+    [names.length, 1]
+  );
+});
 register("__inferred_type_str", (_ctx, args) => {
   if (args.length !== 1) return FALL_THROUGH;
   const rv = ensureRuntimeValue(args[0]);
@@ -63547,6 +65403,44 @@ register("nargout", (ctx, args) => {
   const v = ctx.env.get("$nargout");
   return v !== void 0 ? v : 0;
 });
+register("inputname", (ctx, args) => {
+  if (args.length !== 1) return FALL_THROUGH;
+  const narginVal = ctx.env.get("$nargin");
+  if (typeof narginVal !== "number") {
+    throw new RuntimeError(
+      "You can only call 'inputname' from within a MATLAB function."
+    );
+  }
+  const k = toNumber(ensureRuntimeValue(args[0]));
+  if (!Number.isInteger(k) || k < 1) {
+    throw new RuntimeError(
+      "Argument number must be a positive integer scalar."
+    );
+  }
+  if (k > narginVal) {
+    throw new RuntimeError(
+      "Argument number exceeds number of function input arguments."
+    );
+  }
+  const names = ctx.env.inputArgNames;
+  const name = names && k <= names.length ? names[k - 1] : "";
+  return RTV.char(name);
+});
+register("properties", (ctx, args) => {
+  if (args.length !== 1) return FALL_THROUGH;
+  const v = ensureRuntimeValue(args[0]);
+  let names;
+  if (isRuntimeClassInstance(v) || isRuntimeClassInstanceArray(v)) {
+    names = ctx.classPublicProperties(v.className);
+  } else if (isRuntimeChar(v) || isRuntimeString(v)) {
+    names = ctx.classPublicProperties(toString(v));
+  }
+  if (!names) return RTV.cell([], [0, 1]);
+  return RTV.cell(
+    names.map((n) => RTV.string(n)),
+    [names.length, 1]
+  );
+});
 register("narginchk", (ctx, args) => {
   if (args.length !== 2) return FALL_THROUGH;
   const narginVal = ctx.env.get("$nargin");
@@ -63651,10 +65545,14 @@ function callFunction(name, args, nargout) {
             source: ""
           };
         return void 0;
-      }
+      },
+      classPublicProperties: (n) => classPublicProperties(this, n)
     };
     const result = specialHandler(ctx, args, nargout);
-    if (result !== FALL_THROUGH) return result;
+    if (result !== FALL_THROUGH) {
+      this.pendingInputNames = void 0;
+      return result;
+    }
   }
   const nested = this.env.getNestedFunction(name);
   if (nested) {
@@ -63674,6 +65572,75 @@ function callFunction(name, args, nargout) {
   }
   throw new RuntimeError(`Undefined function or variable '${name}'`);
 }
+function narginFromParams(params) {
+  const hasVarargin = params.length > 0 && params[params.length - 1] === "varargin";
+  return hasVarargin ? -params.length : params.length;
+}
+function paramsInFile(interp, fileName, funcName) {
+  const ast = interp.ctx.getCachedAST(fileName);
+  for (const stmt of ast.body) {
+    if (stmt.type === "Function" && stmt.name === funcName) return stmt.params;
+  }
+  return void 0;
+}
+function declaredNargin(name) {
+  const nested = this.env.getNestedFunction(name);
+  if (nested) return narginFromParams(nested.fn.params);
+  const callSite = {
+    file: this.currentFile,
+    ...this.currentClassName ? { className: this.currentClassName } : {},
+    ...this.currentMethodName ? { methodName: this.currentMethodName } : {}
+  };
+  const target = resolveFunction(name, [], callSite, this.functionIndex);
+  if (!target) return void 0;
+  let params;
+  switch (target.kind) {
+    case "localFunction": {
+      const { source } = target;
+      if (source.from === "main") {
+        params = this.mainLocalFunctions.get(target.name)?.params;
+      } else if (source.from === "workspaceFile") {
+        params = this.findFunctionInWorkspaceFile(source.wsName, target.name)?.params ?? void 0;
+      } else if (source.from === "classFile") {
+        params = this.findFunctionInClassFile(
+          source.className,
+          target.name,
+          source.methodScope
+        )?.params ?? void 0;
+      } else if (source.from === "privateFile") {
+        params = paramsInFile(this, source.callerFile, target.name);
+      }
+      break;
+    }
+    case "workspaceFunction": {
+      const dotIdx = target.name.lastIndexOf(".");
+      const primaryName = dotIdx >= 0 ? target.name.slice(dotIdx + 1) : target.name;
+      params = this.findFunctionInWorkspaceFile(target.name, primaryName)?.params ?? void 0;
+      if (params === void 0) {
+        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") {
+              params = stmt.params;
+              break;
+            }
+          }
+        }
+      }
+      break;
+    }
+    case "privateFunction": {
+      const entry = this.ctx.getPrivateFileEntry(
+        target.callerFile,
+        target.name
+      );
+      if (entry) params = paramsInFile(this, entry.fileName, target.name);
+      break;
+    }
+  }
+  return params !== void 0 ? narginFromParams(params) : void 0;
+}
 function interpretTarget(target, args, nargout) {
   switch (target.kind) {
     case "builtin": {
@@ -63842,18 +65809,12 @@ function interpretWorkspaceFunction(target, args, nargout) {
     if (entry) {
       const ast = this.ctx.getCachedAST(entry.fileName);
       return this.withFileContext(entry.fileName, void 0, void 0, () => {
-        const savedEnv = this.env;
-        this.env = new Environment();
-        try {
-          for (const stmt of ast.body) {
-            if (stmt.type === "Function") continue;
-            const signal = this.execStmt(stmt);
-            if (signal instanceof ReturnSignal) break;
-          }
-          return this.ans;
-        } finally {
-          this.env = savedEnv;
+        for (const stmt of ast.body) {
+          if (stmt.type === "Function") continue;
+          const signal = this.execStmt(stmt);
+          if (signal instanceof ReturnSignal) break;
         }
+        return this.ans;
       });
     }
     throw new RuntimeError(`Workspace function '${target.name}' not found`);
@@ -63920,6 +65881,21 @@ function instantiateClass(className, args, nargout) {
   if (!classInfo) {
     return this.rt.callClassMethod(className, className, nargout, args);
   }
+  if (classInfo.isOldStyle) {
+    const ctorName = classInfo.constructorName ?? className;
+    const ctorFn = this.findExternalMethod(classInfo, ctorName);
+    if (!ctorFn)
+      throw new RuntimeError(
+        `Constructor for old-style class '${className}' not found`
+      );
+    const fileName = classInfo.externalMethodFiles.get(ctorName)?.fileName ?? classInfo.fileName;
+    return this.withFileContext(
+      fileName,
+      className,
+      ctorName,
+      () => this.callUserFunction(ctorFn, args, nargout)
+    );
+  }
   const { propertyNames, propertyDefaults } = this.collectClassProperties(classInfo);
   const defaults = /* @__PURE__ */ new Map();
   for (const [propName, defaultExpr] of propertyDefaults) {
@@ -63943,7 +65919,7 @@ function instantiateClass(className, args, nargout) {
 function interpretConstructor(classInfo, args, nargout) {
   const constructorName = classInfo.constructorName;
   if (!constructorName) return args[0];
-  for (const member of classInfo.ast.members) {
+  for (const member of classInfo.ast?.members ?? []) {
     if (member.type !== "Methods") continue;
     for (const methodStmt of member.body) {
       if (methodStmt.type === "Function" && methodStmt.name === constructorName) {
@@ -63985,6 +65961,8 @@ function callUserFunction(fn, args, nargout, narginOverride) {
   if (!hasVarargoutDecl && nargout > declaredRegularOutputs) {
     throw new RuntimeError("Too many output arguments.");
   }
+  const callInputNames = this.pendingInputNames;
+  this.pendingInputNames = void 0;
   const sharedArgs = args;
   if (narginOverride === void 0 && this.registry.size > 0) {
     const r = this.registry.dispatchCall(fn, sharedArgs, nargout, this);
@@ -64018,6 +65996,7 @@ function callUserFunction(fn, args, nargout, narginOverride) {
   }
   fnEnv.set("$nargin", narginOverride ?? args.length);
   fnEnv.set("$nargout", nargout);
+  fnEnv.inputArgNames = callInputNames;
   for (const stmt of fn.body) {
     if (stmt.type === "Function") {
       fnEnv.nestedFunctions.set(stmt.name, {
@@ -64094,10 +66073,13 @@ function callUserFunction(fn, args, nargout, narginOverride) {
   }
 }
 function callNestedFunction(fn, parentEnv, args, nargout) {
+  const callInputNames = this.pendingInputNames;
+  this.pendingInputNames = void 0;
   const fnEnv = new Environment(parentEnv);
   fnEnv.isNested = true;
   fnEnv.rt = this.rt;
   fnEnv.persistentFuncId = `${this.currentFile}:${fn.name}`;
+  fnEnv.nestedLocalNames = /* @__PURE__ */ new Set([...fn.params, ...fn.outputs]);
   const hasVarargin = fn.params.length > 0 && fn.params[fn.params.length - 1] === "varargin";
   const regularParams = hasVarargin ? fn.params.slice(0, -1) : fn.params;
   for (let i = 0; i < regularParams.length; i++) {
@@ -64111,6 +66093,15 @@ function callNestedFunction(fn, parentEnv, args, nargout) {
   }
   fnEnv.setLocal("$nargin", args.length);
   fnEnv.setLocal("$nargout", nargout);
+  fnEnv.inputArgNames = callInputNames;
+  for (const stmt of fn.body) {
+    if (stmt.type === "Function") {
+      fnEnv.nestedFunctions.set(stmt.name, {
+        fn: funcDefFromStmt(stmt),
+        env: fnEnv
+      });
+    }
+  }
   const savedEnv = this.env;
   this.env = fnEnv;
   this.rt.pushCleanupScope();
@@ -64249,7 +66240,7 @@ function findMethodInClass(classInfo, methodName) {
   const cacheKey = `method:${classInfo.name}:${methodName}`;
   const cached = this.functionDefCache.get(cacheKey);
   if (cached) return cached;
-  for (const member of classInfo.ast.members) {
+  for (const member of classInfo.ast?.members ?? []) {
     if (member.type !== "Methods") continue;
     for (const methodStmt of member.body) {
       if (methodStmt.type === "Function" && methodStmt.name === methodName) {
@@ -64306,6 +66297,36 @@ function collectClassProperties(classInfo) {
   }
   return { propertyNames, propertyDefaults };
 }
+function classPublicProperties(interp, className) {
+  let info = interp.ctx.getClassInfo(className);
+  if (!info) return void 0;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  while (info) {
+    const ast = info.ast;
+    if (ast) {
+      for (const member of ast.members) {
+        if (member.type !== "Properties") continue;
+        const hidden = member.attributes.some((a) => {
+          const n = a.name.toLowerCase();
+          if (n !== "access" && n !== "getaccess") return false;
+          const val = (a.value ?? "").toLowerCase();
+          return val === "private" || val === "protected";
+        });
+        if (hidden) continue;
+        for (const pn of member.names) {
+          if (!seen.has(pn)) {
+            seen.add(pn);
+            out.push(pn);
+          }
+        }
+      }
+    }
+    if (!info.superClass || info.superClass === "handle") break;
+    info = interp.ctx.getClassInfo(info.superClass);
+  }
+  return out;
+}
 function isHandleClass(classInfo) {
   let parentName = classInfo.superClass;
   while (parentName) {
@@ -64424,6 +66445,10 @@ var Interpreter = class {
   workspaceEnv;
   /** @internal The caller's environment — for evalin/assignin('caller', ...) */
   callerEnv;
+  /** @internal Call-site variable names for the next user-function call, set
+   *  by `evalFuncCall` and consumed by `callUserFunction` to support
+   *  `inputname`. One-shot: cleared as soon as it is consumed. */
+  pendingInputNames;
   /** @internal Stack of [base, dimIndex, numIndices] for resolving `end` keyword in indexing. */
   endContextStack = [];
   /** @internal Number of enclosing `for` / `while` loop bodies the
@@ -64685,6 +66710,37 @@ function extractClassInfo(classDef, qualifiedName, fileName, source) {
     externalMethodFiles: /* @__PURE__ */ new Map()
   };
 }
+function makeOldStyleClassInfo(qualifiedName, baseName, constructorFile, methodFiles) {
+  const externalMethodFiles = /* @__PURE__ */ new Map();
+  externalMethodFiles.set(baseName, {
+    fileName: constructorFile.fileName,
+    source: constructorFile.source
+  });
+  const methodNames = /* @__PURE__ */ new Set();
+  for (const mf of methodFiles) {
+    externalMethodFiles.set(mf.name, {
+      fileName: mf.fileName,
+      source: mf.source
+    });
+    methodNames.add(mf.name);
+  }
+  return {
+    name: baseName,
+    qualifiedName,
+    fileName: constructorFile.fileName,
+    source: constructorFile.source,
+    superClass: null,
+    propertyNames: [],
+    propertyDefaults: /* @__PURE__ */ new Map(),
+    methodNames,
+    staticMethodNames: /* @__PURE__ */ new Set(),
+    constructorName: baseName,
+    inferiorClasses: [],
+    ast: null,
+    isOldStyle: true,
+    externalMethodFiles
+  };
+}
 
 // src/numbl-core/lowering/loweringContext.ts
 function createWorkspaceRegistry() {
@@ -64877,8 +66933,41 @@ var LoweringContext = class _LoweringContext {
         }
       }
     }
+    const startsWithClassdef = (source) => {
+      let t = source.trimStart();
+      while (t.startsWith("%")) {
+        const nl = t.indexOf("\n");
+        if (nl < 0) return false;
+        t = t.slice(nl + 1).trimStart();
+      }
+      return t.startsWith("classdef");
+    };
     for (const [className, group] of classFolderGroups) {
-      if (!group.classDefFile) {
+      const hasRealClassdef = !!group.classDefFile && startsWithClassdef(group.classDefFile.source);
+      if (!hasRealClassdef) {
+        const dotIdx = className.lastIndexOf(".");
+        const baseName = dotIdx >= 0 ? className.slice(dotIdx + 1) : className;
+        const methodBase = (f) => f.name.split("/").pop().replace(/\.m$/, "");
+        const ctorFile = group.classDefFile ?? group.methodFiles.find((f) => methodBase(f) === baseName);
+        if (!ctorFile) {
+          continue;
+        }
+        const methodFiles = group.methodFiles.filter((f) => f !== ctorFile).map((f) => ({
+          name: methodBase(f),
+          fileName: f.name,
+          source: f.source
+        }));
+        if (!this.registry.classesByName.has(className)) {
+          this.registry.classesByName.set(
+            className,
+            makeOldStyleClassInfo(
+              className,
+              baseName,
+              { fileName: ctorFile.name, source: ctorFile.source },
+              methodFiles
+            )
+          );
+        }
         continue;
       }
       this.registerWorkspaceClass(className, group.classDefFile);
@@ -65114,7 +67203,7 @@ var LoweringContext = class _LoweringContext {
     if (!info) return null;
     if (info.ctx) return info.ctx;
     const ctx = new _LoweringContext(info.source, info.fileName);
-    for (const member of info.ast.members) {
+    for (const member of info.ast?.members ?? []) {
       if (member.type !== "Methods") continue;
       for (const methodStmt of member.body) {
         if (methodStmt.type !== "Function") continue;
@@ -65273,6 +67362,7 @@ var LoweringContext = class _LoweringContext {
         for (const m of info.methodNames) instanceMethods.add(m);
         for (const m of info.staticMethodNames) staticMethods.add(m);
         for (const m of info.externalMethodFiles.keys()) {
+          if (info.isOldStyle && m === info.constructorName) continue;
           if (!info.staticMethodNames.has(m)) {
             instanceMethods.add(m);
           }
@@ -65316,10 +67406,43 @@ var LoweringContext = class _LoweringContext {
       }
     }
     const fileImports = /* @__PURE__ */ new Map();
+    const gatherImports = (body, out) => {
+      for (const stmt of body) {
+        switch (stmt.type) {
+          case "Import":
+            out.push(stmt);
+            break;
+          case "Function":
+          case "While":
+          case "For":
+            gatherImports(stmt.body, out);
+            break;
+          case "If":
+            gatherImports(stmt.thenBody, out);
+            for (const b of stmt.elseifBlocks) gatherImports(b.body, out);
+            if (stmt.elseBody) gatherImports(stmt.elseBody, out);
+            break;
+          case "Switch":
+            for (const c of stmt.cases) gatherImports(c.body, out);
+            if (stmt.otherwise) gatherImports(stmt.otherwise, out);
+            break;
+          case "TryCatch":
+            gatherImports(stmt.tryBody, out);
+            gatherImports(stmt.catchBody, out);
+            break;
+          case "ClassDef":
+            for (const member of stmt.members) {
+              if (member.type === "Methods") gatherImports(member.body, out);
+            }
+            break;
+        }
+      }
+    };
     const collectImportsFromBody = (body, fileName) => {
       const entries = [];
-      for (const stmt of body) {
-        if (stmt.type !== "Import") continue;
+      const importStmts = [];
+      gatherImports(body, importStmts);
+      for (const stmt of importStmts) {
         if (stmt.wildcard) {
           entries.push({ wildcard: true, namespace: stmt.path.join(".") });
         } else {
@@ -65394,6 +67517,10 @@ var LoweringContext = class _LoweringContext {
 
 // src/numbl-core/stdlib-bundle.ts
 var stdlibFiles = [
+  {
+    name: "TriRep.m",
+    source: "classdef TriRep < triangulation\n    % (Not recommended) Triangulation representation. Provided for legacy\n    % code; use triangulation instead. TriRep inherits freeBoundary,\n    % vertexAttachments, etc. from triangulation and exposes the legacy\n    % property names X (vertex coordinates) and Triangulation (connectivity).\n    %\n    %   TR = TriRep(tri, x, y)\n    %   TR = TriRep(tri, x, y, z)\n    %   TR = TriRep(tri, P)\n    properties\n        X\n        Triangulation\n    end\n    methods\n        function obj = TriRep(tri, varargin)\n            obj = obj@triangulation(tri, varargin{:});\n            obj.X = obj.Points;\n            obj.Triangulation = obj.ConnectivityList;\n        end\n    end\nend\n"
+  },
   {
     name: "addOptional.m",
     source: "function addOptional(obj, name, default, validator)\n    if nargin < 4\n        obj.addOptional(name, default);\n    else\n        obj.addOptional(name, default, validator);\n    end\nend\n"
@@ -65421,6 +67548,10 @@ var stdlibFiles = [
   {
     name: "readmatrix.m",
     source: "function A = readmatrix(filename, varargin)\n    % Parse name-value pairs\n    delimiter = '';\n    numHeaderLines = -1; % -1 means auto-detect\n\n    i = 1;\n    while i <= length(varargin)\n        if ischar(varargin{i}) || isstring(varargin{i})\n            key = lower(char(varargin{i}));\n            if strcmp(key, 'delimiter')\n                delimiter = char(varargin{i+1});\n                i = i + 2;\n            elseif strcmp(key, 'numheaderlines')\n                numHeaderLines = varargin{i+1};\n                i = i + 2;\n            else\n                % Skip unknown name-value pairs\n                i = i + 2;\n            end\n        else\n            i = i + 1;\n        end\n    end\n\n    % Auto-detect delimiter from extension if not specified\n    if isempty(delimiter)\n        [~, ~, ext] = fileparts(filename);\n        if strcmp(ext, '.csv')\n            delimiter = ',';\n        else\n            delimiter = ''; % will split on whitespace\n        end\n    end\n\n    % Read the entire file\n    txt = fileread(filename);\n\n    % Split into lines\n    lines = strsplit(txt, sprintf('\\n'));\n\n    % Remove trailing empty line (from trailing newline)\n    if ~isempty(lines) && strcmp(strtrim(char(lines{end})), '')\n        lines = lines(1:end-1);\n    end\n\n    if isempty(lines)\n        A = [];\n        return;\n    end\n\n    % Auto-detect header lines: skip lines that can't be fully parsed as numbers\n    if numHeaderLines < 0\n        numHeaderLines = 0;\n        for k = 1:length(lines)\n            line = strtrim(char(lines{k}));\n            if strcmp(line, '')\n                numHeaderLines = numHeaderLines + 1;\n                continue;\n            end\n            if ~isempty(delimiter)\n                parts = strsplit(line, delimiter);\n            else\n                parts = strsplit(line);\n            end\n            allNumeric = true;\n            for j = 1:length(parts)\n                val = str2double(strtrim(char(parts{j})));\n                if isnan(val)\n                    token = strtrim(char(parts{j}));\n                    % Allow NaN, Inf, -Inf as valid numeric tokens\n                    if ~strcmpi(token, 'nan') && ~strcmpi(token, 'inf') && ~strcmpi(token, '-inf')\n                        allNumeric = false;\n                        break;\n                    end\n                end\n            end\n            if allNumeric\n                break;\n            else\n                numHeaderLines = numHeaderLines + 1;\n            end\n        end\n    end\n\n    % Parse data lines\n    dataLines = lines(numHeaderLines+1:end);\n    nRows = length(dataLines);\n    if nRows == 0\n        A = [];\n        return;\n    end\n\n    % First pass: determine number of columns from first data line\n    firstLine = strtrim(char(dataLines{1}));\n    if ~isempty(delimiter)\n        parts = strsplit(firstLine, delimiter);\n    else\n        parts = strsplit(firstLine);\n    end\n    nCols = length(parts);\n\n    A = zeros(nRows, nCols);\n    for r = 1:nRows\n        line = strtrim(char(dataLines{r}));\n        if strcmp(line, '')\n            A(r, :) = NaN;\n            continue;\n        end\n        if ~isempty(delimiter)\n            parts = strsplit(line, delimiter);\n        else\n            parts = strsplit(line);\n        end\n        for c = 1:min(length(parts), nCols)\n            val = str2double(strtrim(char(parts{c})));\n            if isnan(val)\n                token = strtrim(char(parts{c}));\n                if strcmpi(token, 'nan')\n                    A(r, c) = NaN;\n                elseif strcmpi(token, 'inf')\n                    A(r, c) = Inf;\n                elseif strcmpi(token, '-inf')\n                    A(r, c) = -Inf;\n                else\n                    A(r, c) = NaN; % non-numeric data becomes NaN\n                end\n            else\n                A(r, c) = val;\n            end\n        end\n        % Fill missing columns with NaN\n        if length(parts) < nCols\n            A(r, length(parts)+1:nCols) = NaN;\n        end\n    end\nend\n"
+  },
+  {
+    name: "triangulation.m",
+    source: "classdef triangulation\n    % Triangulation representation providing topological queries over a\n    % triangle (or tetrahedron) mesh. Mirrors a subset of MATLAB's\n    % triangulation class.\n    %\n    %   TR = triangulation(tri, P)        % P is an n-by-d coordinate matrix\n    %   TR = triangulation(tri, x, y)     % 2-D vertex coordinate columns\n    %   TR = triangulation(tri, x, y, z)  % 3-D vertex coordinate columns\n    properties\n        Points\n        ConnectivityList\n    end\n    methods\n        function obj = triangulation(tri, varargin)\n            if nargin == 0\n                return;\n            end\n            obj.ConnectivityList = tri;\n            if numel(varargin) == 1\n                obj.Points = varargin{1};\n            elseif numel(varargin) >= 2\n                obj.Points = [varargin{:}];\n            else\n                error('triangulation: vertex coordinates are required');\n            end\n        end\n\n        function [F, P] = freeBoundary(obj)\n            % Free boundary facets: the edges referenced by exactly one\n            % triangle, ordered into connected, consistently oriented loops.\n            tri = obj.ConnectivityList;\n            E = [tri(:, [1 2]); tri(:, [2 3]); tri(:, [3 1])];\n            Es = sort(E, 2);\n            [~, ~, ic] = unique(Es, 'rows');\n            counts = accumarray(ic, 1);\n            isB = counts(ic) == 1;\n            bedges = E(isB, :);\n\n            n = size(bedges, 1);\n            F = zeros(n, 2);\n            used = false(n, 1);\n            pos = 1;\n            while pos <= n\n                startRow = find(~used, 1);\n                if isempty(startRow)\n                    break;\n                end\n                cur = startRow;\n                loopStart = bedges(cur, 1);\n                while true\n                    F(pos, :) = bedges(cur, :);\n                    used(cur) = true;\n                    pos = pos + 1;\n                    nextv = bedges(cur, 2);\n                    if nextv == loopStart\n                        break;\n                    end\n                    cand = find(~used & bedges(:, 1) == nextv, 1);\n                    if isempty(cand)\n                        break;\n                    end\n                    cur = cand;\n                end\n            end\n\n            if nargout > 1\n                vid = unique(F(:));\n                P = obj.Points(vid, :);\n                remap = zeros(max(vid), 1);\n                remap(vid) = 1:numel(vid);\n                F = remap(F);\n            end\n        end\n\n        function V = vertexAttachments(obj, id)\n            % IDs of the triangles attached to each vertex, returned as a\n            % cell array with one row vector of triangle IDs per vertex.\n            tri = obj.ConnectivityList;\n            nv = size(obj.Points, 1);\n            if nargin < 2\n                id = (1:nv)';\n            end\n            id = id(:);\n            V = cell(numel(id), 1);\n            for k = 1:numel(id)\n                V{k} = find(any(tri == id(k), 2))';\n            end\n        end\n    end\nend\n"
   }
 ];
 var shimFiles = [
@@ -87684,6 +89815,7 @@ var Workspace = class _Workspace {
       }
     };
     for (const [name, info] of this.ctx.registry.classesByName) {
+      if (info.isOldStyle) continue;
       registerOrDefer(
         name,
         () => registerClassDef(
@@ -87697,7 +89829,7 @@ var Workspace = class _Workspace {
       if (this.classes.has(name) || this.failedClassValidations.has(name)) {
         throw new UnsupportedConstruct(
           `class '${name}' is defined both locally and as a workspace class`,
-          info.ast.span
+          info.ast?.span
         );
       }
       registerOrDefer(name, () => registerClassDef(info.ast, info.fileName));
@@ -87791,7 +89923,7 @@ var Workspace = class _Workspace {
       if (!ast) {
         throw new UnsupportedConstruct(
           `internal: external method file '${mf.fileName}' for '${info.qualifiedName}.${methodName}' was not parsed`,
-          info.ast.span
+          info.ast?.span
         );
       }
       let primary = null;
@@ -87807,7 +89939,7 @@ var Workspace = class _Workspace {
       if (!primary) {
         throw new UnsupportedConstruct(
           `external method file '${mf.fileName}' has no function`,
-          info.ast.span
+          info.ast?.span
         );
       }
       out.set(methodName, primary);
@@ -89191,6 +91323,7 @@ async function load() {
   const { loadQhull } = await import("qhull-wasm");
   const qhull = await loadQhull();
   setDelaunayBackend((points, dim) => qhull.delaunay(points, dim).facets);
+  setConvexHullBackend((points, dim) => qhull.convexHull(points, dim).facets);
 }
 export {
   RTV,