numbl 0.4.8 → 0.4.10

package/dist-cli/cli.js

@@ -678,6 +678,7 @@ var isRuntimeStructArray = (value) => typeof value === "object" && value !== nul
 var isRuntimeClassInstanceArray = (value) => typeof value === "object" && value !== null && value.kind === "class_instance_array";
 var isRuntimeSparseMatrix = (value) => typeof value === "object" && value !== null && value.kind === "sparse_matrix";
 var isRuntimeDictionary = (value) => typeof value === "object" && value !== null && value.kind === "dictionary";
+var isRuntimeStringArray = (value) => typeof value === "object" && value !== null && value.kind === "string_array";
 var kstr = (value) => {
   if (isRuntimeNumber(value)) return "number";
   if (isRuntimeLogical(value)) return "logical";
@@ -696,6 +697,7 @@ var kstr = (value) => {
   if (isRuntimeStructArray(value)) return "struct array";
   if (isRuntimeSparseMatrix(value)) return "sparse matrix";
   if (isRuntimeDictionary(value)) return "dictionary";
+  if (isRuntimeStringArray(value)) return "string array";
   return "unknown";
 };
 var RuntimeTensor = class extends Refcounted {
@@ -727,6 +729,24 @@ var RuntimeChar = class extends Refcounted {
     this.shape = shape;
   }
 };
+var RuntimeStringArray = class extends Refcounted {
+  kind = "string_array";
+  /** Elements in column-major order (plain JS strings). */
+  data;
+  /** 2-D shape [rows, cols]; data.length === rows*cols. A 1x1 string is
+   *  normally represented as a primitive JS string, not a 1x1 array —
+   *  use stringArrayValue() to build results so scalars collapse. */
+  shape;
+  constructor(data, shape) {
+    super();
+    this.data = data;
+    this.shape = shape;
+  }
+};
+function stringArrayValue(data, shape) {
+  if (data.length === 1 && shape[0] === 1 && shape[1] === 1) return data[0];
+  return new RuntimeStringArray(data, shape);
+}
 var RuntimeCell = class extends Refcounted {
   kind = "cell";
   data;
@@ -2603,6 +2623,10 @@ var RTV = {
   string(value) {
     return value;
   },
+  /** String array (does NOT collapse 1x1 — use stringArrayValue for that). */
+  stringArray(data, shape) {
+    return new RuntimeStringArray(data, shape);
+  },
   char(value) {
     return new RuntimeChar(value);
   },
@@ -3237,6 +3261,29 @@ function sub2ind(shape, subs) {
   }
   return idx;
 }
+function matlabNumToString(n) {
+  if (n === Infinity) return "Inf";
+  if (n === -Infinity) return "-Inf";
+  if (isNaN(n)) return "NaN";
+  if (n === 0) return "0";
+  if (Number.isInteger(n)) return String(n);
+  const prec = 5;
+  const exp2 = Math.floor(Math.log10(Math.abs(n)));
+  let s;
+  if (exp2 < -4 || exp2 >= prec) {
+    s = n.toExponential(prec - 1);
+    const ePos = s.indexOf("e");
+    let mantissa = s.slice(0, ePos);
+    const expPart0 = s.slice(ePos);
+    if (mantissa.includes(".")) mantissa = mantissa.replace(/\.?0+$/, "");
+    const expPart = expPart0.replace(/([eE][+-])(\d)$/, "$10$2");
+    s = mantissa + expPart;
+  } else {
+    s = n.toPrecision(prec);
+    if (s.includes(".")) s = s.replace(/\.?0+$/, "");
+  }
+  return s;
+}
 
 // src/numbl-core/helpers/sparse-arithmetic.ts
 function isComplexSparse(S) {
@@ -3993,6 +4040,11 @@ function toString(v) {
   switch (v.kind) {
     case "char":
       return v.value;
+    case "string_array":
+      if (v.data.length === 1) return v.data[0];
+      throw new RuntimeError(
+        "Expected a scalar text value, got a string array"
+      );
     default:
       throw new RuntimeError(`Cannot convert ${kstr(v)} to string`);
   }
@@ -21626,6 +21678,15 @@ var valuesAreEqual = (a, b) => {
     }
     case "dictionary":
       return a === b;
+    case "string_array": {
+      const sb = b;
+      if (a.shape[0] !== sb.shape[0] || a.shape[1] !== sb.shape[1])
+        return false;
+      for (let i = 0; i < a.data.length; i++) {
+        if (a.data[i] !== sb.data[i]) return false;
+      }
+      return true;
+    }
     default:
       return false;
   }
@@ -21678,7 +21739,34 @@ function displayValue(v) {
       return formatDictionary(v);
     case "class_instance_array":
       return `  ${v.shape[0]}x${v.shape[1]} ${v.className} array`;
+    case "string_array":
+      return formatStringArray(v);
+  }
+}
+function formatStringArray(v) {
+  const [rows, cols] = v.shape;
+  if (v.data.length === 0) {
+    return `  ${rows}x${cols} empty string array`;
+  }
+  const quoted = v.data.map((s) => `"${s}"`);
+  const widths = [];
+  for (let c = 0; c < cols; c++) {
+    let w = 0;
+    for (let r = 0; r < rows; r++) {
+      w = Math.max(w, quoted[c * rows + r].length);
+    }
+    widths.push(w);
+  }
+  const lines = [];
+  for (let r = 0; r < rows; r++) {
+    const parts = [];
+    for (let c = 0; c < cols; c++) {
+      const q = quoted[c * rows + r];
+      parts.push(c === cols - 1 ? q : q.padEnd(widths[c]));
+    }
+    lines.push("    " + parts.join("    "));
   }
+  return lines.join("\n");
 }
 var formatStructArray = (v) => {
   const elements = v.elements;
@@ -22799,6 +22887,68 @@ function indexIntoChar(base, indices) {
   }
   throw new RuntimeError("Char indexing supports 1 or 2 dimensions");
 }
+function stringArraySubscript(idx, extent) {
+  if (isColonIndex(idx)) {
+    return Array.from({ length: extent }, (_, i) => i);
+  }
+  if (isRuntimeTensor(idx)) {
+    if (idx._isLogical) {
+      const out = [];
+      for (let i = 0; i < idx.data.length; i++)
+        if (idx.data[i] !== 0) out.push(i);
+      return out;
+    }
+    return Array.from(idx.data, (v) => Math.round(v) - 1);
+  }
+  if (isRuntimeLogical(idx)) return idx ? [0] : [];
+  return [Math.round(toNumber(idx)) - 1];
+}
+function indexIntoStringArray(base, indices) {
+  const [rows, cols] = base.shape;
+  const total = base.data.length;
+  if (indices.length === 2) {
+    const ri = stringArraySubscript(indices[0], rows);
+    const ci = stringArraySubscript(indices[1], cols);
+    const out2 = [];
+    for (const c of ci) {
+      if (c < 0 || c >= cols)
+        throw new RuntimeError("Index exceeds array bounds");
+      for (const r of ri) {
+        if (r < 0 || r >= rows)
+          throw new RuntimeError("Index exceeds array bounds");
+        out2.push(base.data[c * rows + r]);
+      }
+    }
+    return stringArrayValue(out2, [ri.length, ci.length]);
+  }
+  if (indices.length !== 1) {
+    throw new RuntimeError("String array indexing supports 1 or 2 subscripts");
+  }
+  const idx = indices[0];
+  if (isColonIndex(idx)) {
+    return stringArrayValue(base.data.slice(), [total, 1]);
+  }
+  const linear = stringArraySubscript(idx, total);
+  const out = [];
+  for (const i of linear) {
+    if (i < 0 || i >= total)
+      throw new RuntimeError("Index exceeds array bounds");
+    out.push(base.data[i]);
+  }
+  let shape;
+  if (rows === 1 || cols === 1) {
+    shape = rows === 1 ? [1, out.length] : [out.length, 1];
+  } else if (isRuntimeTensor(idx) && !idx._isLogical) {
+    const is = idx.shape;
+    const im = is.length >= 2 ? is[0] : 1;
+    shape = [im, out.length / (im || 1)];
+  } else if (isRuntimeTensor(idx) && idx._isLogical) {
+    shape = [out.length, 1];
+  } else {
+    shape = [1, out.length];
+  }
+  return stringArrayValue(out, shape);
+}
 function indexIntoLogical(base, indices) {
   if (indices.length === 1) {
     const idx = indices[0];
@@ -22929,6 +23079,9 @@ function indexIntoRTValue(base, indices) {
       return base;
     }
   }
+  if (isRuntimeStringArray(base)) {
+    return indexIntoStringArray(base, indices);
+  }
   if (isRuntimeLogical(base)) {
     return indexIntoLogical(base, indices);
   }
@@ -23750,26 +23903,18 @@ function horzcat(...values) {
   if (values.some((v) => isRuntimeCell(v))) {
     return cellCatAlongDim(values, 1);
   }
+  if (values.some((v) => isRuntimeString(v) || isRuntimeStringArray(v))) {
+    return stringCat(values, 1);
+  }
   if (values.some((v) => isRuntimeChar(v))) {
     let result = "";
     for (const v of values) {
       if (isRuntimeChar(v)) result += v.value;
-      else if (isRuntimeString(v)) result += v;
       else if (isRuntimeNumber(v)) result += String.fromCharCode(Math.round(v));
       else throw new RuntimeError(`Cannot concatenate ${kstr(v)} into char`);
     }
     return RTV.char(result);
   }
-  if (values.some((v) => isRuntimeString(v) || isRuntimeChar(v))) {
-    let result = "";
-    for (const v of values) {
-      if (isRuntimeString(v)) result += v;
-      else if (isRuntimeChar(v)) result += v.value;
-      else if (isRuntimeNumber(v)) result += String(v);
-      else throw new RuntimeError(`Cannot concatenate ${v} into string`);
-    }
-    return RTV.string(result);
-  }
   if (values.some((v) => isRuntimeStruct(v) || isRuntimeStructArray(v))) {
     return structCat(values);
   }
@@ -23784,6 +23929,9 @@ function vertcat(...values) {
   if (values.some((v) => isRuntimeCell(v))) {
     return cellCatAlongDim(values, 0);
   }
+  if (values.some((v) => isRuntimeString(v) || isRuntimeStringArray(v))) {
+    return stringCat(values, 0);
+  }
   if (values.some((v) => isRuntimeChar(v))) {
     return vertcatChars(values);
   }
@@ -23792,6 +23940,86 @@ function vertcat(...values) {
   }
   return catAlongDim(values, 0);
 }
+function toStringBlock(v) {
+  if (isRuntimeString(v)) return { data: [v], rows: 1, cols: 1 };
+  if (isRuntimeStringArray(v)) {
+    if (v.data.length === 0) return null;
+    return { data: v.data.slice(), rows: v.shape[0], cols: v.shape[1] };
+  }
+  if (isRuntimeChar(v)) {
+    const rows = v.shape ? v.shape[0] : 1;
+    const width = v.shape ? v.shape[1] : v.value.length;
+    if (rows <= 1) return { data: [v.value], rows: 1, cols: 1 };
+    const out = [];
+    for (let r = 0; r < rows; r++) {
+      out.push(v.value.slice(r * width, (r + 1) * width));
+    }
+    return { data: out, rows, cols: 1 };
+  }
+  if (isRuntimeNumber(v)) {
+    return { data: [matlabNumToString(v)], rows: 1, cols: 1 };
+  }
+  if (isRuntimeLogical(v)) {
+    return { data: [v ? "true" : "false"], rows: 1, cols: 1 };
+  }
+  if (isRuntimeTensor(v)) {
+    if (v.data.length === 0) return null;
+    const rows = v.shape.length >= 2 ? v.shape[0] : 1;
+    const cols = v.data.length / (rows || 1);
+    const out = [];
+    for (let i = 0; i < v.data.length; i++) {
+      out.push(
+        v._isLogical ? v.data[i] ? "true" : "false" : matlabNumToString(v.data[i])
+      );
+    }
+    return { data: out, rows, cols };
+  }
+  throw new RuntimeError(`Cannot concatenate ${kstr(v)} into string array`);
+}
+function stringCat(values, dim) {
+  const blocks = [];
+  for (const v of values) {
+    const b = toStringBlock(v);
+    if (b) blocks.push(b);
+  }
+  if (blocks.length === 0) return RTV.stringArray([], [0, 0]);
+  if (dim === 1) {
+    const rows2 = blocks[0].rows;
+    let cols2 = 0;
+    for (const b of blocks) {
+      if (b.rows !== rows2) {
+        throw new RuntimeError(
+          "Dimensions of arrays being concatenated are not consistent"
+        );
+      }
+      cols2 += b.cols;
+    }
+    const data2 = [];
+    for (const b of blocks) data2.push(...b.data);
+    return stringArrayValue(data2, [rows2, cols2]);
+  }
+  const cols = blocks[0].cols;
+  let rows = 0;
+  for (const b of blocks) {
+    if (b.cols !== cols) {
+      throw new RuntimeError(
+        "Dimensions of arrays being concatenated are not consistent"
+      );
+    }
+    rows += b.rows;
+  }
+  const data = new Array(rows * cols);
+  let rOff = 0;
+  for (const b of blocks) {
+    for (let c = 0; c < cols; c++) {
+      for (let r = 0; r < b.rows; r++) {
+        data[c * rows + rOff + r] = b.data[c * b.rows + r];
+      }
+    }
+    rOff += b.rows;
+  }
+  return stringArrayValue(data, [rows, cols]);
+}
 function vertcatChars(values) {
   let cols = null;
   let totalRows = 0;
@@ -27736,6 +27964,28 @@ function coerceToConcatString(v) {
   return null;
 }
 function mAdd(a, b) {
+  if (isRuntimeStringArray(a) || isRuntimeStringArray(b)) {
+    const sa = isRuntimeStringArray(a) ? a : null;
+    const sb = isRuntimeStringArray(b) ? b : null;
+    if (sa && sb) {
+      if (sa.shape[0] !== sb.shape[0] || sa.shape[1] !== sb.shape[1]) {
+        throw new RuntimeError("Array dimensions must match for string plus");
+      }
+      return stringArrayValue(
+        sa.data.map((s, i) => s + sb.data[i]),
+        sa.shape
+      );
+    }
+    const arr = sa ?? sb;
+    const other = coerceToConcatString(sa ? b : a);
+    if (other === null) {
+      throw new RuntimeError("Cannot concatenate this value with a string");
+    }
+    return stringArrayValue(
+      arr.data.map((s) => sa ? s + other : other + s),
+      arr.shape
+    );
+  }
   if (isRuntimeString(a) || isRuntimeString(b)) {
     const aStr = coerceToConcatString(a);
     const bStr = coerceToConcatString(b);
@@ -28242,12 +28492,24 @@ function transposeClassInstanceArray(v) {
   }
   return new RuntimeClassInstanceArray(v.className, out, [c, r]);
 }
+function transposeStringArray(v) {
+  const [r, c] = v.shape;
+  const out = new Array(r * c);
+  for (let i = 0; i < r; i++) {
+    for (let j = 0; j < c; j++) {
+      out[i * c + j] = v.data[j * r + i];
+    }
+  }
+  return stringArrayValue(out, [c, r]);
+}
 function mTranspose(v) {
   if (isRuntimeSparseMatrix(v)) return sparseTranspose(v);
   if (isRuntimeComplexNumber(v)) return v;
   if (isRuntimeNumber(v) || isRuntimeLogical(v)) return v;
   if (isRuntimeCell(v)) return transposeCellArray(v);
   if (isRuntimeChar(v)) return v;
+  if (isRuntimeString(v)) return v;
+  if (isRuntimeStringArray(v)) return transposeStringArray(v);
   if (isRuntimeClassInstance(v)) return v;
   if (isRuntimeClassInstanceArray(v)) return transposeClassInstanceArray(v);
   if (!isRuntimeTensor(v))
@@ -28260,6 +28522,8 @@ function mConjugateTranspose(v) {
   if (isRuntimeNumber(v) || isRuntimeLogical(v)) return v;
   if (isRuntimeCell(v)) return transposeCellArray(v);
   if (isRuntimeChar(v)) return v;
+  if (isRuntimeString(v)) return v;
+  if (isRuntimeStringArray(v)) return transposeStringArray(v);
   if (isRuntimeClassInstance(v)) return v;
   if (isRuntimeClassInstanceArray(v)) return transposeClassInstanceArray(v);
   if (!isRuntimeTensor(v))
@@ -28272,7 +28536,38 @@ function asStringPair(a, b) {
   if (isRuntimeChar(a) && isRuntimeString(b)) return [a.value, b];
   return null;
 }
+function textOperandElems(v) {
+  if (isRuntimeString(v)) return { data: [v], shape: [1, 1] };
+  if (isRuntimeChar(v)) {
+    const rows = v.shape ? v.shape[0] : 1;
+    if (rows > 1) return null;
+    return { data: [v.value], shape: [1, 1] };
+  }
+  if (isRuntimeStringArray(v)) return { data: v.data, shape: v.shape };
+  return null;
+}
 function stringComparisonOp(a, b, op) {
+  if (isRuntimeStringArray(a) || isRuntimeStringArray(b)) {
+    const ta = textOperandElems(a);
+    const tb = textOperandElems(b);
+    if (ta === null || tb === null) return null;
+    const aScalar = ta.data.length === 1 && ta.shape[0] * ta.shape[1] === 1;
+    const bScalar = tb.data.length === 1 && tb.shape[0] * tb.shape[1] === 1;
+    if (!aScalar && !bScalar && (ta.shape[0] !== tb.shape[0] || ta.shape[1] !== tb.shape[1])) {
+      throw new RuntimeError("Array dimensions must match for comparison");
+    }
+    const shape = aScalar ? tb.shape : ta.shape;
+    const n = aScalar ? tb.data.length : ta.data.length;
+    const out = allocFloat64Array(n);
+    for (let i = 0; i < n; i++) {
+      const x = aScalar ? ta.data[0] : ta.data[i];
+      const y = bScalar ? tb.data[0] : tb.data[i];
+      out[i] = op(x, y) ? 1 : 0;
+    }
+    const t = RTV.tensor(out, [shape[0], shape[1]]);
+    t._isLogical = true;
+    return t;
+  }
   const pair = asStringPair(a, b);
   if (pair === null) return null;
   return RTV.logical(op(pair[0], pair[1]));
@@ -31560,9 +31855,9 @@ var ExpressionParser = class extends ParserBase {
           if (this.consume(50 /* LParen */)) {
             const args = [];
             if (!this.consume(51 /* RParen */)) {
-              args.push(this.parseExpr());
+              this.parseFuncArg(args);
               while (this.consume(47 /* Comma */)) {
-                args.push(this.parseExpr());
+                this.parseFuncArg(args);
               }
               if (!this.consume(51 /* RParen */)) {
                 throw this.error("expected ')' after method arguments");
@@ -31591,9 +31886,9 @@ var ExpressionParser = class extends ParserBase {
         }
         const args = [];
         if (!this.consume(51 /* RParen */)) {
-          args.push(this.parseExpr());
+          this.parseFuncArg(args);
           while (this.consume(47 /* Comma */)) {
-            args.push(this.parseExpr());
+            this.parseFuncArg(args);
           }
           if (!this.consume(51 /* RParen */)) {
             throw this.error("expected ')' after super call arguments");
@@ -32440,13 +32735,8 @@ var FunctionParser = class extends ArgumentsParser {
       }
     }
     const vararginIdx = params.indexOf("varargin");
-    if (vararginIdx !== -1) {
-      if (vararginIdx !== params.length - 1) {
-        throw this.error("'varargin' must be the last input parameter");
-      }
-      if (params.filter((p2) => p2 === "varargin").length > 1) {
-        throw this.error("'varargin' cannot appear more than once");
-      }
+    if (vararginIdx !== -1 && params.filter((p2) => p2 === "varargin").length > 1) {
+      throw this.error("'varargin' cannot appear more than once");
     }
     const varargoutIdx = outputs.indexOf("varargout");
     if (varargoutIdx !== -1) {
@@ -32458,6 +32748,22 @@ var FunctionParser = class extends ArgumentsParser {
       }
     }
     const argumentsBlocks = this.parseArgumentsBlocks();
+    if (vararginIdx !== -1 && vararginIdx !== params.length - 1) {
+      const nvBases = /* @__PURE__ */ new Set();
+      for (const block of argumentsBlocks) {
+        if (block.kind === "Output" || block.kind === "OutputRepeating")
+          continue;
+        for (const e of block.entries) {
+          const dot2 = e.name.indexOf(".");
+          if (dot2 >= 0) nvBases.add(e.name.slice(0, dot2));
+        }
+      }
+      for (const p2 of params.slice(vararginIdx + 1)) {
+        if (!nvBases.has(p2)) {
+          throw this.error("'varargin' must be the last input parameter");
+        }
+      }
+    }
     const body = this.parseBlock((t) => t === 15 /* End */);
     if (!this.consume(15 /* End */)) {
       throw this.error("expected 'end'");
@@ -33870,6 +34176,16 @@ function forIter(v) {
   if (isRuntimeChar(mv)) {
     return Array.from(mv.value).map((c) => RTV.char(c));
   }
+  if (isRuntimeStringArray(mv)) {
+    const [rows, cols] = mv.shape;
+    const out = [];
+    for (let c = 0; c < cols; c++) {
+      out.push(
+        stringArrayValue(mv.data.slice(c * rows, (c + 1) * rows), [rows, 1])
+      );
+    }
+    return out;
+  }
   return [v];
 }
 function emptyTensor() {
@@ -35377,6 +35693,9 @@ function isa(rt, value, classNameArg) {
       case "class_instance_array":
         valueClass = mv.className;
         break;
+      case "string_array":
+        valueClass = "string";
+        break;
       default:
         valueClass = "unknown";
         break;
@@ -35950,6 +36269,8 @@ function numblClass(v) {
       return "double";
     case "class_instance":
       return v.className;
+    case "string_array":
+      return "string";
     default:
       return "unknown";
   }
@@ -36505,6 +36826,10 @@ function endResolver(mv, numIndices) {
     }
     if (isRuntimeStructArray(mv)) return mv.elements.length;
     if (isRuntimeClassInstanceArray(mv)) return mv.elements.length;
+    if (isRuntimeStringArray(mv)) {
+      if (numIndices === 1) return mv.data.length;
+      return dim < 2 ? mv.shape[dim] : 1;
+    }
     if (isRuntimeSparseMatrix(mv)) {
       if (numIndices === 1) return mv.m * mv.n;
       return dim === 0 ? mv.m : dim === 1 ? mv.n : 1;
@@ -36791,6 +37116,28 @@ function indexCell(rt, base, indices) {
     if (isRuntimeCell(val) && val.data.length === 1) return val.data[0];
     return val;
   }
+  if (isRuntimeString(mv) || isRuntimeStringArray(mv)) {
+    const idxMvals2 = resolveIndices(indices, endResolver(mv, indices.length));
+    const elems = isRuntimeString(mv) ? [mv] : mv.data;
+    const shape = isRuntimeString(mv) ? [1, 1] : mv.shape;
+    let lin;
+    if (idxMvals2.length === 1) {
+      lin = Math.round(toNumber(idxMvals2[0])) - 1;
+    } else if (idxMvals2.length === 2) {
+      const r = Math.round(toNumber(idxMvals2[0])) - 1;
+      const c = Math.round(toNumber(idxMvals2[1])) - 1;
+      if (r < 0 || r >= shape[0] || c < 0 || c >= shape[1])
+        throw new RuntimeError("Index exceeds array bounds");
+      lin = c * shape[0] + r;
+    } else {
+      throw new RuntimeError(
+        "String brace indexing supports 1 or 2 subscripts"
+      );
+    }
+    if (lin < 0 || lin >= elems.length)
+      throw new RuntimeError("Index exceeds array bounds");
+    return RTV.char(elems[lin]);
+  }
   if (!isRuntimeCell(mv)) throw new RuntimeError("Cell indexing on non-cell");
   const idxMvals = resolveIndices(indices, endResolver(mv, indices.length));
   if (idxMvals.length === 1) {
@@ -36984,6 +37331,15 @@ function indexStore(rt, base, indices, rhs, skipSubsasgn = false) {
       return rhsMv2;
     }
   }
+  {
+    const rhsMv0 = ensureRuntimeValue(rhs);
+    const baseIsStr = isRuntimeString(mv) || isRuntimeStringArray(mv);
+    const baseEmpty = isRuntimeTensor(mv) && mv.data.length === 0;
+    const rhsIsStr = isRuntimeString(rhsMv0) || isRuntimeStringArray(rhsMv0);
+    if (baseIsStr || baseEmpty && rhsIsStr) {
+      return stringArrayIndexStore(mv, indices, rhsMv0);
+    }
+  }
   let wasScalar = false;
   let wasChar = false;
   if (!isRuntimeTensor(mv)) {
@@ -37027,6 +37383,109 @@ function indexStore(rt, base, indices, rhs, skipSubsasgn = false) {
   }
   return result;
 }
+function rhsToStringElems(rhsMv) {
+  if (isRuntimeString(rhsMv)) return [rhsMv];
+  if (isRuntimeStringArray(rhsMv)) return rhsMv.data.slice();
+  if (isRuntimeChar(rhsMv)) {
+    const rows = rhsMv.shape ? rhsMv.shape[0] : 1;
+    if (rows <= 1) return [rhsMv.value];
+    const width = rhsMv.shape[1];
+    const out = [];
+    for (let r = 0; r < rows; r++)
+      out.push(rhsMv.value.slice(r * width, (r + 1) * width));
+    return out;
+  }
+  if (isRuntimeNumber(rhsMv)) return [matlabNumToString(rhsMv)];
+  if (isRuntimeLogical(rhsMv)) return [rhsMv ? "true" : "false"];
+  if (isRuntimeTensor(rhsMv))
+    return Array.from(rhsMv.data, (d) => matlabNumToString(d));
+  return null;
+}
+function stringArrayIndexStore(mv, indices, rhsMv) {
+  let data;
+  let rows;
+  let cols;
+  if (isRuntimeStringArray(mv)) {
+    data = mv.data.slice();
+    [rows, cols] = mv.shape;
+  } else if (isRuntimeString(mv)) {
+    data = [mv];
+    rows = 1;
+    cols = 1;
+  } else {
+    data = [];
+    rows = 0;
+    cols = 0;
+  }
+  const idxMvals = resolveIndices(indices, endResolver(mv, indices.length));
+  if (isRuntimeTensor(rhsMv) && rhsMv.data.length === 0 && idxMvals.length === 1) {
+    const del = new Set(stringArraySubscript(idxMvals[0], data.length));
+    const kept = data.filter((_, i) => !del.has(i));
+    if (cols === 1 && rows > 1) return stringArrayValue(kept, [kept.length, 1]);
+    return stringArrayValue(kept, [1, kept.length]);
+  }
+  const rhsElems = rhsToStringElems(rhsMv);
+  if (rhsElems === null) {
+    throw new RuntimeError("Cannot assign this value into a string array");
+  }
+  if (idxMvals.length === 1) {
+    const positions = stringArraySubscript(idxMvals[0], data.length);
+    const maxPos = positions.length ? Math.max(...positions) : -1;
+    if (positions.some((p2) => p2 < 0)) {
+      throw new RuntimeError("Index must be a positive integer");
+    }
+    if (maxPos >= data.length) {
+      if (rows > 1 && cols > 1) {
+        throw new RuntimeError("Index exceeds array bounds");
+      }
+      while (data.length <= maxPos) data.push("");
+    }
+    if (rhsElems.length !== 1 && rhsElems.length !== positions.length) {
+      throw new RuntimeError(
+        "Unable to perform assignment because the left and right sides have a different number of elements"
+      );
+    }
+    positions.forEach((p2, k) => {
+      data[p2] = rhsElems.length === 1 ? rhsElems[0] : rhsElems[k];
+    });
+    if (rows > 1 && cols > 1) return stringArrayValue(data, [rows, cols]);
+    if (cols === 1 && rows > 1) return stringArrayValue(data, [data.length, 1]);
+    return stringArrayValue(data, [1, data.length]);
+  }
+  if (idxMvals.length === 2) {
+    const ri = stringArraySubscript(idxMvals[0], rows);
+    const ci = stringArraySubscript(idxMvals[1], cols);
+    if (ri.some((p2) => p2 < 0) || ci.some((p2) => p2 < 0)) {
+      throw new RuntimeError("Index must be a positive integer");
+    }
+    const newRows = Math.max(rows, ri.length ? Math.max(...ri) + 1 : 0);
+    const newCols = Math.max(cols, ci.length ? Math.max(...ci) + 1 : 0);
+    let grid = data;
+    if (newRows !== rows || newCols !== cols) {
+      grid = new Array(newRows * newCols).fill("");
+      for (let c = 0; c < cols; c++) {
+        for (let r = 0; r < rows; r++) {
+          grid[c * newRows + r] = data[c * rows + r];
+        }
+      }
+    }
+    const count = ri.length * ci.length;
+    if (rhsElems.length !== 1 && rhsElems.length !== count) {
+      throw new RuntimeError(
+        "Unable to perform assignment because the left and right sides have a different number of elements"
+      );
+    }
+    let k = 0;
+    for (const c of ci) {
+      for (const r of ri) {
+        grid[c * newRows + r] = rhsElems.length === 1 ? rhsElems[0] : rhsElems[k];
+        k++;
+      }
+    }
+    return stringArrayValue(grid, [newRows, newCols]);
+  }
+  throw new RuntimeError("String array assignment supports 1 or 2 subscripts");
+}
 function indexCellStore(base, indices, rhs, rt) {
   if (base === void 0 || base === null) base = RTV.cell([], [0, 0]);
   let mv = ensureRuntimeValue(base);
@@ -37073,6 +37532,87 @@ function multiOutputCellAssign(base, indices, results, rt) {
   return mv;
 }
 
+// src/numbl-core/helpers/scanFormat.ts
+function scanFormat(str, fmt, maxCount) {
+  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++;
+      if (fmtPos >= fmt.length) break;
+      while (fmtPos < fmt.length && /[\d.]/.test(fmt[fmtPos])) fmtPos++;
+      if (fmtPos >= fmt.length) break;
+      const spec = fmt[fmtPos];
+      fmtPos++;
+      if (spec !== "c" && spec !== "s") {
+        while (strPos < str.length && /\s/.test(str[strPos])) strPos++;
+      }
+      if (spec === "d" || spec === "i" || spec === "u") {
+        const m = str.slice(strPos).match(/^[+-]?\d+/);
+        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) {
+          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) {
+          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) {
+          matchFailure = true;
+          break;
+        }
+        results.push(parseInt(m[0], 8));
+        strPos += m[0].length;
+      } else if (spec === "c") {
+        results.push(str.charCodeAt(strPos));
+        strPos++;
+      } else if (spec === "s") {
+        const m = str.slice(strPos).match(/^\S+/);
+        if (!m) {
+          matchFailure = true;
+          break;
+        }
+        for (let ci = 0; ci < m[0].length && results.length < maxCount; ci++) {
+          results.push(m[0].charCodeAt(ci));
+        }
+        strPos += m[0].length;
+      }
+    } else if (/\s/.test(fmt[fmtPos])) {
+      fmtPos++;
+      while (strPos < str.length && /\s/.test(str[strPos])) strPos++;
+    } else {
+      if (str[strPos] !== fmt[fmtPos]) {
+        matchFailure = true;
+        break;
+      }
+      strPos++;
+      fmtPos++;
+    }
+    if (fmtPos >= fmt.length && results.length < maxCount && strPos < str.length) {
+      fmtPos = 0;
+    }
+  }
+  return { results, consumed: strPos, matchFailure };
+}
+
 // src/numbl-core/interpreter/builtins/datetime.ts
 var MATLAB_EPOCH_DAYS = 719529;
 function makeDatetime(year, month, day, hour, minute, second) {
@@ -39098,6 +39638,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "fclose",
   "fgetl",
   "fgets",
+  "fscanf",
   "fileread",
   "feof",
   "ferror",
@@ -39365,7 +39906,10 @@ function registerSpecialBuiltins(rt) {
         fmtIdx = 1;
       }
       const fmt = toString(margs[fmtIdx]);
-      output = sprintfFormat(fmt, margs.slice(fmtIdx + 1));
+      const rest = margs.slice(fmtIdx + 1).flatMap(
+        (a) => isRuntimeStringArray(a) ? a.data.map((s) => RTV.string(s)) : [a]
+      );
+      output = sprintfFormat(fmt, rest);
       if (fid === 1 || fid === 2) {
         rt.output(output);
       } else {
@@ -39519,6 +40063,53 @@ function registerSpecialBuiltins(rt) {
     const result = io.fgets(toNumber(margs[0]));
     return typeof result === "number" ? RTV.num(result) : RTV.char(result);
   });
+  registerSpecial("fscanf", (nargout, args) => {
+    const io = requireFileIO();
+    const margs = args.map((a) => ensureRuntimeValue(a));
+    if (margs.length < 2)
+      throw new RuntimeError("fscanf requires at least 2 arguments");
+    if (!io.ftell || !io.fseek || !io.freadBytes)
+      throw new RuntimeError("fscanf is not supported in this environment");
+    const fid = toNumber(margs[0]);
+    const fmt = toString(margs[1]);
+    let maxCount = Infinity;
+    let rows = null;
+    if (margs.length >= 3) {
+      const sz = margs[2];
+      if (isRuntimeTensor(sz) && sz.data.length >= 2) {
+        rows = sz.data[0];
+        maxCount = sz.data[0] * sz.data[1];
+      } else {
+        maxCount = toNumber(sz);
+      }
+    }
+    const pos = io.ftell(fid);
+    const CHUNK = 1 << 16;
+    const chunks = [];
+    for (; ; ) {
+      const bytes = io.freadBytes(fid, CHUNK);
+      let s = "";
+      for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i]);
+      chunks.push(s);
+      if (bytes.length < CHUNK) break;
+    }
+    const { results, consumed } = scanFormat(chunks.join(""), fmt, maxCount);
+    io.fseek(fid, pos + consumed, -1);
+    const n = results.length;
+    let out;
+    if (rows !== null && Number.isFinite(rows) && rows > 0) {
+      const cols = Math.ceil(n / rows);
+      const data = allocFloat64Array(rows * cols);
+      for (let i = 0; i < n; i++) data[i] = results[i];
+      out = RTV.tensor(data, [rows, cols]);
+    } else if (n === 1) {
+      out = RTV.num(results[0]);
+    } else {
+      out = RTV.tensor(allocFloat64Array(results), [n, 1]);
+    }
+    if (nargout >= 2) return [out, RTV.num(n)];
+    return out;
+  });
   registerSpecial("fileread", (_nargout, args) => {
     const io = requireFileIO();
     const margs = args.map((a) => ensureRuntimeValue(a));
@@ -43968,6 +44559,7 @@ var Runtime = class _Runtime {
     if (isRuntimeChar(rv))
       return rv.shape ?? (rv.value.length === 0 ? [0, 0] : [1, rv.value.length]);
     if (isRuntimeString(rv)) return [1, 1];
+    if (isRuntimeStringArray(rv)) return [...rv.shape];
     if (isRuntimeClassInstance(rv)) return [1, 1];
     return [1, 1];
   }
@@ -45987,6 +46579,13 @@ function valuesEqualSimple(a, b) {
     }
     return true;
   }
+  if (isRuntimeStringArray(a) && isRuntimeStringArray(b)) {
+    if (a.shape[0] !== b.shape[0] || a.shape[1] !== b.shape[1]) return false;
+    for (let i = 0; i < a.data.length; i++) {
+      if (a.data[i] !== b.data[i]) return false;
+    }
+    return true;
+  }
   return false;
 }
 function textValue(v) {
@@ -46259,6 +46858,7 @@ function getShape(v) {
   if (isRuntimeCell(v)) return v.shape;
   if (isRuntimeStructArray(v)) return [1, v.elements.length];
   if (isRuntimeClassInstanceArray(v)) return [...v.shape];
+  if (isRuntimeStringArray(v)) return [...v.shape];
   return [1, 1];
 }
 defineBuiltin({
@@ -46314,7 +46914,11 @@ defineBuiltin({
 });
 defineBuiltin({
   name: "isstring",
-  cases: [anyToLogicalCase((args) => isRuntimeString(args[0]))]
+  cases: [
+    anyToLogicalCase(
+      (args) => isRuntimeString(args[0]) || isRuntimeStringArray(args[0])
+    )
+  ]
 });
 var MATLAB_KEYWORDS = /* @__PURE__ */ new Set([
   "break",
@@ -46497,6 +47101,7 @@ defineBuiltin({
       if (isRuntimeString(v)) return false;
       if (isRuntimeStructArray(v)) return v.elements.length === 0;
       if (isRuntimeClassInstanceArray(v)) return v.elements.length === 0;
+      if (isRuntimeStringArray(v)) return v.data.length === 0;
       return false;
     })
   ]
@@ -46551,6 +47156,7 @@ defineBuiltin({
         if (isRuntimeString(v)) return 1;
         if (isRuntimeStructArray(v)) return v.elements.length;
         if (isRuntimeClassInstanceArray(v)) return v.elements.length;
+        if (isRuntimeStringArray(v)) return v.data.length;
         return 1;
       }
     }
@@ -46581,6 +47187,8 @@ defineBuiltin({
         if (isRuntimeStructArray(v)) return v.elements.length;
         if (isRuntimeClassInstanceArray(v))
           return v.elements.length === 0 ? 0 : Math.max(...v.shape);
+        if (isRuntimeStringArray(v))
+          return v.data.length === 0 ? 0 : Math.max(...v.shape);
         return 1;
       }
     }
@@ -46708,6 +47316,7 @@ defineBuiltin({
           return mkChar(v._isLogical ? "logical" : "double");
         if (isRuntimeSparseMatrix(v)) return mkChar("double");
         if (isRuntimeString(v)) return mkChar("string");
+        if (isRuntimeStringArray(v)) return mkChar("string");
         if (isRuntimeChar(v)) return mkChar("char");
         if (isRuntimeStruct(v) || isRuntimeStructArray(v))
           return mkChar("struct");
@@ -46758,7 +47367,7 @@ function fieldnamesApply(args) {
   if (isRuntimeStructArray(v)) {
     const names2 = v.fieldNames;
     return RTV.cell(
-      names2.map((n) => RTV.string(n)),
+      names2.map((n) => RTV.char(n)),
       [names2.length, 1]
     );
   }
@@ -46766,7 +47375,7 @@ function fieldnamesApply(args) {
     throw new RuntimeError("fieldnames: argument must be a struct");
   const names = [...v.fields.keys()];
   return RTV.cell(
-    names.map((n) => RTV.string(n)),
+    names.map((n) => RTV.char(n)),
     [names.length, 1]
   );
 }
@@ -47594,6 +48203,9 @@ function applyTextFn(v, fn) {
     return RTV.char(fn(v.value));
   }
   if (isRuntimeString(v)) return RTV.string(fn(toString(v)));
+  if (isRuntimeStringArray(v)) {
+    return RTV.stringArray(v.data.map(fn), [v.shape[0], v.shape[1]]);
+  }
   return v;
 }
 function textPreserveResolve(fn) {
@@ -47606,6 +48218,16 @@ function textPreserveResolve(fn) {
         apply: (args) => applyTextFn(args[0], fn)
       };
     }
+    if (t.kind === "unknown") {
+      return {
+        outputTypes: [{ kind: "unknown" }],
+        apply: (args) => {
+          if (!isRuntimeStringArray(args[0]))
+            throw new RuntimeError("Expected a text input");
+          return applyTextFn(args[0], fn);
+        }
+      };
+    }
     const out = preserveTextType(t);
     if (!out) return null;
     return {
@@ -47695,17 +48317,14 @@ registerIBuiltin({
   name: "erase",
   resolve: (argTypes) => {
     if (argTypes.length !== 2) return null;
-    const out = preserveTextType(argTypes[0]);
+    const out = argTypes[0].kind === "unknown" ? { kind: "unknown" } : preserveTextType(argTypes[0]);
     if (!out) return null;
     if (!isTextType(argTypes[1])) return null;
     return {
       outputTypes: [out],
       apply: (args) => {
-        const v = args[0];
-        const s = toString(v);
         const pat = toString(args[1]);
-        const result = s.split(pat).join("");
-        return isRuntimeChar(v) ? RTV.char(result) : RTV.string(result);
+        return applyTextFn(args[0], (s) => s.split(pat).join(""));
       }
     };
   }
@@ -47713,18 +48332,15 @@ registerIBuiltin({
 function strreplaceResolve() {
   return (argTypes) => {
     if (argTypes.length !== 3) return null;
-    const out = preserveTextType(argTypes[0]);
+    const out = argTypes[0].kind === "unknown" || argTypes[0].kind === "cell" ? { kind: argTypes[0].kind } : preserveTextType(argTypes[0]);
     if (!out) return null;
     if (!isTextType(argTypes[1]) || !isTextType(argTypes[2])) return null;
     return {
       outputTypes: [out],
       apply: (args) => {
-        const v = args[0];
-        const s = toString(v);
         const old = toString(args[1]);
         const rep = toString(args[2]);
-        const result = s.split(old).join(rep);
-        return isRuntimeChar(v) ? RTV.char(result) : RTV.string(result);
+        return applyTextFn(args[0], (s) => s.split(old).join(rep));
       }
     };
   };
@@ -47892,9 +48508,16 @@ registerIBuiltin({
 function isText(v) {
   return isRuntimeChar(v) || isRuntimeString(v);
 }
+function stringArrayToCell(v) {
+  if (!isRuntimeStringArray(v)) return v;
+  return RTV.cell(
+    v.data.map((s) => RTV.string(s)),
+    [v.shape[0], v.shape[1]]
+  );
+}
 function strcmpApply(args, cmp) {
-  const a = args[0];
-  const b = args[1];
+  const a = stringArrayToCell(args[0]);
+  const b = stringArrayToCell(args[1]);
   const aIsCell = isRuntimeCell(a);
   const bIsCell = isRuntimeCell(b);
   if (!aIsCell && !bIsCell) {
@@ -48140,24 +48763,43 @@ registerIBuiltin({
     };
   }
 });
+function patternList(pat) {
+  if (isRuntimeCell(pat)) return pat.data.map((e) => toString(e));
+  if (isRuntimeStringArray(pat)) return pat.data.slice();
+  return [toString(pat)];
+}
+function textSubjectApply(subject, perElem) {
+  if (isRuntimeStringArray(subject)) {
+    return new RuntimeTensor(
+      allocFloat64Array(subject.data.map((s) => perElem(s) ? 1 : 0)),
+      [subject.shape[0], subject.shape[1]],
+      void 0,
+      true
+    );
+  }
+  if (isRuntimeCell(subject)) {
+    return new RuntimeTensor(
+      allocFloat64Array(subject.data.map((e) => perElem(toString(e)) ? 1 : 0)),
+      subject.shape.slice(),
+      void 0,
+      true
+    );
+  }
+  return RTV.logical(perElem(toString(subject)));
+}
+function subjectTypeOk(t) {
+  return isTextType(t) || t.kind === "cell" || t.kind === "unknown";
+}
 registerIBuiltin({
   name: "contains",
   resolve: (argTypes) => {
     if (argTypes.length < 2) return null;
-    if (!isTextType(argTypes[0])) return null;
-    if (argTypes[1].kind === "unknown") return null;
+    if (!subjectTypeOk(argTypes[0])) return null;
     return {
       outputTypes: [{ kind: "boolean" }],
       apply: (args) => {
-        const s = toString(args[0]);
-        const pat = args[1];
-        if (isRuntimeCell(pat)) {
-          for (let i = 0; i < pat.data.length; i++) {
-            if (s.includes(toString(pat.data[i]))) return RTV.logical(true);
-          }
-          return RTV.logical(false);
-        }
-        return RTV.logical(s.includes(toString(pat)));
+        const pats = patternList(args[1]);
+        return textSubjectApply(args[0], (s) => pats.some((p2) => s.includes(p2)));
       }
     };
   }
@@ -48167,7 +48809,7 @@ function resolveStartsEndsWith(name, testFn) {
     name,
     resolve: (argTypes) => {
       if (argTypes.length < 2) return null;
-      if (!isTextType(argTypes[0])) return null;
+      if (!subjectTypeOk(argTypes[0])) return null;
       return {
         outputTypes: [{ kind: "boolean" }],
         apply: (args) => {
@@ -48177,20 +48819,12 @@ function resolveStartsEndsWith(name, testFn) {
               ic = !!toNumber(args[i + 1]);
             }
           }
-          let s = toString(args[0]);
-          if (ic) s = s.toLowerCase();
-          const pat = args[1];
-          if (isRuntimeCell(pat)) {
-            for (let i = 0; i < pat.data.length; i++) {
-              let p3 = toString(pat.data[i]);
-              if (ic) p3 = p3.toLowerCase();
-              if (testFn(s, p3)) return RTV.logical(true);
-            }
-            return RTV.logical(false);
-          }
-          let p2 = toString(pat);
-          if (ic) p2 = p2.toLowerCase();
-          return RTV.logical(testFn(s, p2));
+          let pats = patternList(args[1]);
+          if (ic) pats = pats.map((p2) => p2.toLowerCase());
+          return textSubjectApply(args[0], (s0) => {
+            const s = ic ? s0.toLowerCase() : s0;
+            return pats.some((p2) => testFn(s, p2));
+          });
         }
       };
     }
@@ -48202,13 +48836,19 @@ registerIBuiltin({
   name: "strlength",
   resolve: (argTypes) => {
     if (argTypes.length !== 1) return null;
-    if (!isTextType(argTypes[0])) return null;
+    if (!isTextType(argTypes[0]) && argTypes[0].kind !== "unknown") return null;
     return {
       outputTypes: [{ kind: "number", sign: "nonneg" }],
       apply: (args) => {
         const v = args[0];
         if (isRuntimeString(v)) return RTV.num(v.length);
         if (isRuntimeChar(v)) return RTV.num(v.value.length);
+        if (isRuntimeStringArray(v)) {
+          return RTV.tensor(allocFloat64Array(v.data.map((s) => s.length)), [
+            v.shape[0],
+            v.shape[1]
+          ]);
+        }
         throw new RuntimeError("strlength: argument must be a string or char");
       }
     };
@@ -48264,6 +48904,20 @@ registerIBuiltin({
         }
       };
     }
+    if (t.kind === "unknown") {
+      return {
+        outputTypes: [{ kind: "tensor", isComplex: false }],
+        apply: (args) => {
+          const v = args[0];
+          if (!isRuntimeStringArray(v))
+            throw new RuntimeError("str2double: expected text input");
+          return RTV.tensor(
+            allocFloat64Array(v.data.map((s) => str2doubleScalar(s))),
+            [v.shape[0], v.shape[1]]
+          );
+        }
+      };
+    }
     return null;
   }
 });
@@ -48449,29 +49103,7 @@ registerIBuiltin({
     };
   }
 });
-function numStr2(n) {
-  if (n === Infinity) return "Inf";
-  if (n === -Infinity) return "-Inf";
-  if (isNaN(n)) return "NaN";
-  if (n === 0) return "0";
-  if (Number.isInteger(n)) return String(n);
-  const prec = 5;
-  const exp2 = Math.floor(Math.log10(Math.abs(n)));
-  let s;
-  if (exp2 < -4 || exp2 >= prec) {
-    s = n.toExponential(prec - 1);
-    const ePos = s.indexOf("e");
-    let mantissa = s.slice(0, ePos);
-    const expPart0 = s.slice(ePos);
-    if (mantissa.includes(".")) mantissa = mantissa.replace(/\.?0+$/, "");
-    const expPart = expPart0.replace(/([eE][+-])(\d)$/, "$10$2");
-    s = mantissa + expPart;
-  } else {
-    s = n.toPrecision(prec);
-    if (s.includes(".")) s = s.replace(/\.?0+$/, "");
-  }
-  return s;
-}
+var numStr2 = matlabNumToString;
 registerIBuiltin({
   name: "num2str",
   resolve: (argTypes) => {
@@ -48682,7 +49314,7 @@ registerIBuiltin({
   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" && a.kind !== "cell")
+    if (a.kind !== "char" && a.kind !== "string" && a.kind !== "number" && a.kind !== "tensor" && a.kind !== "cell" && a.kind !== "unknown")
       return null;
     return {
       outputTypes: [{ kind: "char" }],
@@ -48704,6 +49336,9 @@ registerIBuiltin({
           for (const el of v.data) rows.push(...valueToCharRows(el));
           return charRowsToMatrix(rows);
         }
+        if (isRuntimeStringArray(v)) {
+          return charRowsToMatrix(v.data.slice());
+        }
         throw new RuntimeError("char: unsupported arguments");
       }
     };
@@ -48714,14 +49349,260 @@ registerIBuiltin({
   resolve: (argTypes) => {
     if (argTypes.length !== 1) return null;
     const a = argTypes[0];
-    if (a.kind === "unknown") return null;
+    const scalarText = a.kind === "char" || a.kind === "string" || a.kind === "number" || a.kind === "boolean";
     return {
-      outputTypes: [{ kind: "string" }],
+      outputTypes: [scalarText ? { kind: "string" } : { kind: "unknown" }],
+      apply: (args) => {
+        const v = args[0];
+        if (isRuntimeString(v) || isRuntimeStringArray(v)) return v;
+        if (isRuntimeChar(v)) {
+          const rows = v.shape ? v.shape[0] : 1;
+          if (rows <= 1) return RTV.string(v.value);
+          const width = v.shape[1];
+          const out = [];
+          for (let r = 0; r < rows; r++) {
+            out.push(v.value.slice(r * width, (r + 1) * width));
+          }
+          return RTV.stringArray(out, [rows, 1]);
+        }
+        if (isRuntimeNumber(v)) return RTV.string(numStr2(v));
+        if (isRuntimeLogical(v)) return RTV.string(v ? "true" : "false");
+        if (isRuntimeTensor(v)) {
+          const rows = v.shape.length >= 2 ? v.shape[0] : 1;
+          const cols = v.data.length === 0 ? v.shape[1] ?? 0 : v.data.length / (rows || 1);
+          const out = [];
+          for (let i = 0; i < v.data.length; i++) {
+            out.push(
+              v._isLogical ? v.data[i] ? "true" : "false" : numStr2(v.data[i])
+            );
+          }
+          return stringArrayValue(out, [rows, cols]);
+        }
+        if (isRuntimeCell(v)) {
+          const rows = v.shape.length >= 2 ? v.shape[0] : 1;
+          const cols = v.data.length / (rows || 1);
+          const out = v.data.map((el) => {
+            const rv = ensureRuntimeValue(el);
+            if (isRuntimeChar(rv)) return rv.value;
+            if (isRuntimeString(rv)) return rv;
+            if (isRuntimeNumber(rv)) return numStr2(rv);
+            if (isRuntimeLogical(rv)) return rv ? "true" : "false";
+            throw new RuntimeError(
+              "string: cell elements must be text or numbers"
+            );
+          });
+          return stringArrayValue(out, [rows, cols]);
+        }
+        return RTV.string(displayValue(v));
+      }
+    };
+  }
+});
+registerIBuiltin({
+  name: "strings",
+  help: {
+    signatures: ["strings", "strings(n)", "strings(m,n)", "strings([m n])"],
+    description: 'Create a string array with every element set to "" (empty string).'
+  },
+  resolve: (argTypes) => {
+    if (argTypes.some((t) => t.kind !== "number" && t.kind !== "tensor"))
+      return null;
+    return {
+      outputTypes: [{ kind: "unknown" }],
+      apply: (args) => {
+        const dims = [];
+        for (const a of args) {
+          const rv = ensureRuntimeValue(a);
+          if (isRuntimeTensor(rv)) {
+            for (const d of rv.data) dims.push(Math.max(0, Math.round(d)));
+          } else {
+            dims.push(Math.max(0, Math.round(toNumber(rv))));
+          }
+        }
+        if (dims.length === 0) dims.push(1, 1);
+        if (dims.length === 1) dims.push(dims[0]);
+        const m = dims[0];
+        const n = dims.slice(1).reduce((a, b) => a * b, 1);
+        return stringArrayValue(new Array(m * n).fill(""), [m, n]);
+      }
+    };
+  }
+});
+registerIBuiltin({
+  name: "newline",
+  help: {
+    signatures: ["newline"],
+    description: "Newline character, char(10)."
+  },
+  resolve: (argTypes) => {
+    if (argTypes.length !== 0) return null;
+    return {
+      outputTypes: [{ kind: "char" }],
+      apply: () => RTV.char("\n")
+    };
+  }
+});
+registerIBuiltin({
+  name: "split",
+  help: {
+    signatures: ["split(str)", "split(str, delimiter)"],
+    description: "Split text at whitespace (or the given delimiter(s)) into a string array. A scalar input yields a column of parts."
+  },
+  resolve: (argTypes) => {
+    if (argTypes.length < 1 || argTypes.length > 2) return null;
+    const a = argTypes[0];
+    if (!isTextType(a) && a.kind !== "cell" && a.kind !== "unknown")
+      return null;
+    return {
+      outputTypes: [{ kind: "unknown" }],
       apply: (args) => {
+        const delims = args.length >= 2 ? patternList(args[1]) : null;
+        const splitOne = (s) => {
+          if (delims === null) {
+            const trimmed = s.trim();
+            return trimmed.length === 0 ? [""] : trimmed.split(/\s+/);
+          }
+          const escaped = delims.map((d) => d.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+          return s.split(new RegExp(escaped));
+        };
+        const v = args[0];
+        const subjects = isRuntimeStringArray(v) ? v.data.slice() : isRuntimeCell(v) ? v.data.map((e) => toString(e)) : [toString(v)];
+        const partsPer = subjects.map(splitOne);
+        const nParts = partsPer[0].length;
+        if (partsPer.some((p2) => p2.length !== nParts)) {
+          throw new RuntimeError(
+            "split: all elements must split into the same number of parts"
+          );
+        }
+        if (subjects.length === 1) {
+          return stringArrayValue(partsPer[0], [nParts, 1]);
+        }
+        const m = subjects.length;
+        const out = new Array(m * nParts);
+        for (let i = 0; i < m; i++) {
+          for (let j = 0; j < nParts; j++) {
+            out[j * m + i] = partsPer[i][j];
+          }
+        }
+        return stringArrayValue(out, [m, nParts]);
+      }
+    };
+  }
+});
+registerIBuiltin({
+  name: "join",
+  help: {
+    signatures: ["join(str)", "join(str, delimiter)"],
+    description: "Combine the elements of a string array into single strings, separated by a space (or the given delimiter)."
+  },
+  resolve: (argTypes) => {
+    if (argTypes.length < 1 || argTypes.length > 2) return null;
+    const a = argTypes[0];
+    if (!isTextType(a) && a.kind !== "cell" && a.kind !== "unknown")
+      return null;
+    return {
+      outputTypes: [{ kind: "unknown" }],
+      apply: (args) => {
+        const delim = args.length >= 2 ? toString(args[1]) : " ";
         const v = args[0];
         if (isRuntimeString(v)) return v;
         if (isRuntimeChar(v)) return RTV.string(v.value);
-        return RTV.string(displayValue(v));
+        const elems = isRuntimeStringArray(v) ? v.data : isRuntimeCell(v) ? v.data.map((e) => toString(e)) : [toString(v)];
+        const shape = isRuntimeStringArray(v) ? v.shape : [1, elems.length];
+        const [m, n] = shape;
+        if (m === 1 || n === 1) {
+          return RTV.string(elems.join(delim));
+        }
+        const out = [];
+        for (let r = 0; r < m; r++) {
+          const parts = [];
+          for (let c = 0; c < n; c++) parts.push(elems[c * m + r]);
+          out.push(parts.join(delim));
+        }
+        return stringArrayValue(out, [m, 1]);
+      }
+    };
+  }
+});
+registerIBuiltin({
+  name: "cellstr",
+  help: {
+    signatures: ["cellstr(A)"],
+    description: "Convert a string array, char array, or cell array of text to a cell array of character vectors."
+  },
+  resolve: (argTypes) => {
+    if (argTypes.length !== 1) return null;
+    const a = argTypes[0];
+    if (!isTextType(a) && a.kind !== "cell" && a.kind !== "unknown")
+      return null;
+    return {
+      outputTypes: [{ kind: "cell" }],
+      apply: (args) => {
+        const v = args[0];
+        if (isRuntimeCell(v)) {
+          return RTV.cell(
+            v.data.map((e) => RTV.char(toString(e))),
+            [...v.shape]
+          );
+        }
+        if (isRuntimeStringArray(v)) {
+          return RTV.cell(
+            v.data.map((s) => RTV.char(s)),
+            [v.shape[0], v.shape[1]]
+          );
+        }
+        if (isRuntimeString(v)) return RTV.cell([RTV.char(v)], [1, 1]);
+        if (isRuntimeChar(v)) {
+          const rows = v.shape ? v.shape[0] : 1;
+          if (rows <= 1) {
+            return RTV.cell([RTV.char(v.value.replace(/\s+$/, ""))], [1, 1]);
+          }
+          const width = v.shape[1];
+          const out = [];
+          for (let r = 0; r < rows; r++) {
+            out.push(
+              RTV.char(
+                v.value.slice(r * width, (r + 1) * width).replace(/\s+$/, "")
+              )
+            );
+          }
+          return RTV.cell(out, [rows, 1]);
+        }
+        throw new RuntimeError("cellstr: unsupported argument");
+      }
+    };
+  }
+});
+registerIBuiltin({
+  name: "ismissing",
+  help: {
+    signatures: ["ismissing(A)"],
+    description: "Logical array marking missing elements. numbl has no <missing> value, so string inputs return all-false."
+  },
+  resolve: (argTypes) => {
+    if (argTypes.length !== 1) return null;
+    return {
+      outputTypes: [{ kind: "boolean" }],
+      apply: (args) => {
+        const v = args[0];
+        if (isRuntimeStringArray(v)) {
+          const t = RTV.tensor(allocFloat64Array(v.data.length), [
+            v.shape[0],
+            v.shape[1]
+          ]);
+          t._isLogical = true;
+          return t;
+        }
+        if (isRuntimeTensor(v)) {
+          const t = RTV.tensor(
+            allocFloat64Array(v.data.map((x) => isNaN(x) ? 1 : 0)),
+            [...v.shape]
+          );
+          t._isLogical = true;
+          return t;
+        }
+        if (isRuntimeNumber(v)) return RTV.logical(isNaN(v));
+        return RTV.logical(false);
       }
     };
   }
@@ -48758,7 +49639,10 @@ registerIBuiltin({
       outputTypes: [outType],
       apply: (args) => {
         const fmt = toString(args[0]);
-        const result = sprintfFormat(fmt, args.slice(1));
+        const rest = args.slice(1).flatMap(
+          (a) => isRuntimeStringArray(a) ? a.data.map((s) => RTV.string(s)) : [a]
+        );
+        const result = sprintfFormat(fmt, rest);
         return isChar5 ? RTV.char(result) : RTV.string(result);
       }
     };
@@ -48779,80 +49663,11 @@ registerIBuiltin({
         const str = toString(args[0]);
         const fmt = toString(args[1]);
         const maxCount = args.length >= 3 ? toNumber(args[2]) : Infinity;
-        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++;
-            if (fmtPos >= fmt.length) break;
-            const spec = fmt[fmtPos];
-            fmtPos++;
-            if (spec !== "c" && spec !== "s") {
-              while (strPos < str.length && /\s/.test(str[strPos])) strPos++;
-            }
-            if (spec === "d" || spec === "i") {
-              const m = str.slice(strPos).match(/^[+-]?\d+/);
-              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) {
-                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) {
-                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) {
-                matchFailure = true;
-                break;
-              }
-              results.push(parseInt(m[0], 8));
-              strPos += m[0].length;
-            } else if (spec === "c") {
-              results.push(str.charCodeAt(strPos));
-              strPos++;
-            } else if (spec === "s") {
-              const m = str.slice(strPos).match(/^\S+/);
-              if (!m) {
-                matchFailure = true;
-                break;
-              }
-              for (let ci = 0; ci < m[0].length && results.length < maxCount; ci++) {
-                results.push(m[0].charCodeAt(ci));
-              }
-              strPos += m[0].length;
-            }
-          } else if (/\s/.test(fmt[fmtPos])) {
-            fmtPos++;
-            while (strPos < str.length && /\s/.test(str[strPos])) strPos++;
-          } else {
-            if (str[strPos] !== fmt[fmtPos]) {
-              matchFailure = true;
-              break;
-            }
-            strPos++;
-            fmtPos++;
-          }
-          if (fmtPos >= fmt.length && results.length < maxCount && strPos < str.length) {
-            fmtPos = 0;
-          }
-        }
+        const {
+          results,
+          consumed: strPos,
+          matchFailure
+        } = scanFormat(str, fmt, maxCount);
         const vals = results.length === 1 ? RTV.num(results[0]) : RTV.tensor(allocFloat64Array(results), [results.length, 1]);
         if (nout >= 2) {
           const out = [vals, RTV.num(results.length)];
@@ -49131,6 +49946,10 @@ defineBuiltin({
           };
           return nargout > 1 ? [out, idx] : [out];
         }
+        if (a.kind === "string" || a.kind === "unknown") {
+          const out = { kind: "unknown" };
+          return nargout > 1 ? [out, { kind: "unknown" }] : [out];
+        }
         return null;
       },
       apply: (args, nargout) => {
@@ -49149,6 +49968,33 @@ defineBuiltin({
         if (args.length >= 3 && (isRuntimeString(args[2]) || isRuntimeChar(args[2]))) {
           descend = rstr(args[2]).toLowerCase() === "descend";
         }
+        if (isRuntimeStringArray(v)) {
+          const order = v.data.map((_, i) => i);
+          order.sort((i, j) => {
+            const x = v.data[i];
+            const y = v.data[j];
+            const c = x < y ? -1 : x > y ? 1 : 0;
+            return descend ? -c : c;
+          });
+          const sorted = order.map((i) => v.data[i]);
+          const isRow = v.shape[0] === 1;
+          const shape = isRow ? [1, sorted.length] : [sorted.length, 1];
+          const result = stringArrayValue(sorted, shape);
+          if (nargout > 1) {
+            return [
+              result,
+              RTV.tensor(allocFloat64Array(order.map((i) => i + 1)), [
+                shape[0],
+                shape[1]
+              ])
+            ];
+          }
+          return result;
+        }
+        if (isRuntimeString(v)) {
+          if (nargout > 1) return [v, RTV.num(1)];
+          return v;
+        }
         if (isRuntimeNumber(v)) {
           if (nargout > 1) return [v, RTV.num(1)];
           return v;
@@ -49464,8 +50310,12 @@ var ismemberCases = [
     apply: (args, nargout) => {
       if (args.length < 2)
         throw new RuntimeError("ismember requires 2 arguments");
-      const v = args[0];
-      const b = args[1];
+      const asCellstr = (x) => isRuntimeStringArray(x) ? RTV.cell(
+        x.data.map((s) => RTV.string(s)),
+        [x.shape[0], x.shape[1]]
+      ) : x;
+      const v = asCellstr(args[0]);
+      const b = asCellstr(args[1]);
       const isStringLike = (x) => isRuntimeString(x) || isRuntimeChar(x);
       const isCellOfStrings = (x) => isRuntimeCell(x) && x.data.every(
         (e) => isRuntimeString(e) || isRuntimeChar(e)
@@ -49768,6 +50618,30 @@ defineBuiltin({
         )) {
           return uniqueCellOfStrings(v, nargout, stable);
         }
+        if (isRuntimeStringArray(v)) {
+          const elems = v.data;
+          const seen = /* @__PURE__ */ new Map();
+          for (let i = 0; i < elems.length; i++) {
+            if (!seen.has(elems[i])) seen.set(elems[i], i);
+          }
+          let vals = [...seen.keys()];
+          if (!stable) vals = vals.sort();
+          const isRow = v.shape[0] === 1;
+          const shape = isRow ? [1, vals.length] : [vals.length, 1];
+          const result = stringArrayValue(vals, shape);
+          if (nargout <= 1) return result;
+          const ia = RTV.tensor(
+            allocFloat64Array(vals.map((s) => seen.get(s) + 1)),
+            [vals.length, 1]
+          );
+          if (nargout === 2) return [result, ia];
+          const pos = new Map(vals.map((s, i) => [s, i + 1]));
+          const ic = RTV.tensor(
+            allocFloat64Array(elems.map((s) => pos.get(s))),
+            [elems.length, 1]
+          );
+          return [result, ia, ic];
+        }
         if (!isRuntimeTensor(v))
           throw new RuntimeError("unique: argument must be numeric");
         if (byRows) return uniqueByRows(v, nargout, stable);
@@ -52971,6 +53845,27 @@ function flipAlongDim(v, dimIdx) {
   }
   return RTV.tensor(result, [...shape], resultImag);
 }
+function flipCellAlongDim(v, dimIdx) {
+  const shape = v.shape.length >= 2 ? v.shape : [1, v.shape[0] ?? v.data.length];
+  const totalElems = v.data.length;
+  const dimSize = dimIdx < shape.length ? shape[dimIdx] : 1;
+  let strideDim = 1;
+  for (let d = 0; d < dimIdx; d++) strideDim *= shape[d];
+  const slabSize = strideDim * dimSize;
+  const numOuter = totalElems / slabSize;
+  const result = new Array(totalElems);
+  for (let outer = 0; outer < numOuter; outer++) {
+    const base = outer * slabSize;
+    for (let k = 0; k < dimSize; k++) {
+      const srcOff = base + k * strideDim;
+      const dstOff = base + (dimSize - 1 - k) * strideDim;
+      for (let i = 0; i < strideDim; i++) {
+        result[dstOff + i] = v.data[srcOff + i];
+      }
+    }
+  }
+  return RTV.cell(result, [...shape]);
+}
 function flipSparse(v, dimIdx) {
   const isComplex = v.pi !== void 0;
   const nnz = v.jc[v.n];
@@ -53147,6 +54042,41 @@ defineBuiltin({
               chars[i2 * nc + j2] = linear[j2 * nr + i2];
           return new RuntimeChar(chars.join(""), [nr, nc]);
         }
+        if (isRuntimeStringArray(v)) {
+          const s = parseReshapeDims(args, v.data.length);
+          while (s.length > 2 && s[s.length - 1] === 1) s.pop();
+          if (s.length > 2)
+            throw new RuntimeError("reshape: string arrays must be 2-D");
+          const nr = s[0];
+          const nc = s.length >= 2 ? s[1] : 1;
+          return stringArrayValue(v.data.slice(), [nr, nc]);
+        }
+        if (isRuntimeString(v)) {
+          parseReshapeDims(args, 1);
+          return v;
+        }
+        if (isRuntimeClassInstanceArray(v)) {
+          const total = v.elements.length;
+          const s = parseReshapeDims(args, total);
+          while (s.length > 2 && s[s.length - 1] === 1) s.pop();
+          if (s.length > 2)
+            throw new RuntimeError("reshape: object arrays must be 2-D");
+          const nr = s[0];
+          const nc = s.length >= 2 ? s[1] : 1;
+          if (nr * nc !== total)
+            throw new RuntimeError(
+              "reshape: number of elements must not change"
+            );
+          return RTV.classInstanceArray(v.className, v.elements, [nr, nc]);
+        }
+        if (isRuntimeClassInstance(v)) {
+          const s = parseReshapeDims(args, 1);
+          if (s.reduce((a, b) => a * b, 1) !== 1)
+            throw new RuntimeError(
+              "reshape: number of elements must not change"
+            );
+          return v;
+        }
         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]);
@@ -53458,6 +54388,7 @@ defineBuiltin({
         if (isRuntimeChar(v))
           return RTV.char(v.value.split("").reverse().join(""));
         if (isRuntimeSparseMatrix(v)) return flipSparse(v, 1);
+        if (isRuntimeCell(v)) return flipCellAlongDim(v, 1);
         if (!isRuntimeTensor(v))
           throw new RuntimeError("fliplr: argument must be numeric or char");
         return flipAlongDim(v, 1);
@@ -53478,6 +54409,7 @@ defineBuiltin({
         if (isRuntimeNumber(v)) return v;
         if (isRuntimeChar(v)) return v;
         if (isRuntimeSparseMatrix(v)) return flipSparse(v, 0);
+        if (isRuntimeCell(v)) return flipCellAlongDim(v, 0);
         if (!isRuntimeTensor(v))
           throw new RuntimeError("flipud: argument must be numeric or char");
         return flipAlongDim(v, 0);
@@ -53496,8 +54428,8 @@ defineBuiltin({
       apply: (args) => {
         const v = args[0];
         if (isRuntimeNumber(v)) return v;
-        if (!isRuntimeTensor(v))
-          throw new RuntimeError("flip: argument must be numeric");
+        if (!isRuntimeTensor(v) && !isRuntimeCell(v))
+          throw new RuntimeError("flip: argument must be numeric or cell");
         let dimIdx = 0;
         if (args.length >= 2) {
           dimIdx = Math.round(toNumber(args[1])) - 1;
@@ -53506,7 +54438,7 @@ defineBuiltin({
           dimIdx = shape.findIndex((d) => d > 1);
           if (dimIdx === -1) dimIdx = 0;
         }
-        return flipAlongDim(v, dimIdx);
+        return isRuntimeCell(v) ? flipCellAlongDim(v, dimIdx) : flipAlongDim(v, dimIdx);
       }
     }
   ]
@@ -55176,6 +56108,8 @@ function getValClassName(v) {
       return "double";
     case "dictionary":
       return "dictionary";
+    case "string_array":
+      return "string";
     default:
       return "unknown";
   }
@@ -55205,6 +56139,8 @@ function getShapeOf(v) {
       return [1, 1];
     case "struct_array":
       return [1, obj.elements.length];
+    case "string_array":
+      return [...obj.shape];
     default:
       return [1, 1];
   }
@@ -56872,6 +57808,12 @@ defineBuiltin({
 });
 
 // src/numbl-core/interpreter/builtins/type-constructors.ts
+function parseDoubleText(s) {
+  const t = s.trim();
+  if (t === "") return NaN;
+  if (/^[+-]?inf(inity)?$/i.test(t)) return t[0] === "-" ? -Infinity : Infinity;
+  return Number(t);
+}
 defineBuiltin({
   name: "double",
   cases: [
@@ -56879,7 +57821,7 @@ defineBuiltin({
       match: (argTypes) => {
         if (argTypes.length !== 1) return null;
         const a = argTypes[0];
-        if (a.kind === "number" || a.kind === "boolean" || a.kind === "char" || a.kind === "complex_or_number" || a.kind === "class_instance")
+        if (a.kind === "number" || a.kind === "boolean" || a.kind === "char" || a.kind === "string" || a.kind === "unknown" || a.kind === "complex_or_number" || a.kind === "class_instance")
           return [{ kind: "number" }];
         if (a.kind === "tensor")
           return [
@@ -56901,6 +57843,13 @@ defineBuiltin({
           const codes = Array.from(v.value).map((c) => c.charCodeAt(0));
           return RTV.row(codes);
         }
+        if (isRuntimeString(v)) return RTV.num(parseDoubleText(v));
+        if (isRuntimeStringArray(v)) {
+          return RTV.tensor(allocFloat64Array(v.data.map(parseDoubleText)), [
+            v.shape[0],
+            v.shape[1]
+          ]);
+        }
         if (isRuntimeLogical(v)) return RTV.num(v ? 1 : 0);
         if (isRuntimeNumber(v)) return v;
         if (isRuntimeComplexNumber(v)) return v.re;
@@ -57604,14 +58553,19 @@ registerIBuiltin({
           let delims;
           if (isRuntimeCell(args[1])) {
             delims = args[1].data.map((d) => toString(d));
+          } else if (isRuntimeStringArray(args[1])) {
+            delims = args[1].data.slice();
           } else {
             delims = [toString(args[1])];
           }
           const escaped = delims.map((d) => d.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
           parts = s.split(new RegExp("(?:" + escaped + ")+"));
         }
+        if (isRuntimeString(args[0]) || isRuntimeStringArray(args[0])) {
+          return stringArrayValue(parts, [1, parts.length]);
+        }
         return RTV.cell(
-          parts.map((p2) => RTV.string(p2)),
+          parts.map((p2) => RTV.char(p2)),
           [1, parts.length]
         );
       }
@@ -57625,11 +58579,18 @@ registerIBuiltin({
     return {
       outputTypes: [{ kind: "string" }],
       apply: (args) => {
-        if (!isRuntimeCell(args[0]))
+        let elements;
+        if (isRuntimeCell(args[0])) {
+          elements = args[0].data.map((v) => toString(v));
+        } else if (isRuntimeStringArray(args[0])) {
+          elements = args[0].data.slice();
+        } else if (isRuntimeString(args[0])) {
+          elements = [args[0]];
+        } else {
           throw new RuntimeError(
-            "strjoin: first argument must be a cell array"
+            "strjoin: first argument must be a cell array or string array"
           );
-        const elements = args[0].data.map((v) => toString(v));
+        }
         const delim = args.length >= 2 ? toString(args[1]) : " ";
         return RTV.string(elements.join(delim));
       }
@@ -57706,6 +58667,19 @@ function regexpImpl(caseSensitive, name, args, nargout) {
         [1, tokensList.length]
       );
     }
+    if (mode === "split") {
+      const splits = [];
+      let prev = 0;
+      for (let i = 0; i < starts.length; i++) {
+        splits.push(str.slice(prev, starts[i] - 1));
+        prev = ends[i];
+      }
+      splits.push(str.slice(prev));
+      return RTV.cell(
+        splits.map((s) => RTV.char(s)),
+        [1, splits.length]
+      );
+    }
     if (mode === "names") {
       if (starts.length === 0) return RTV.tensor(allocFloat64Array(0), [0, 0]);
       const namedRe = new RegExp(pat, flags);
@@ -62917,7 +63891,7 @@ function getSourceLine(getSource, file, line) {
 }
 
 // src/numbl-core/version.ts
-var NUMBL_VERSION = "0.4.8";
+var NUMBL_VERSION = "0.4.10";
 
 // src/cli-repl.ts
 import { createInterface } from "readline";
@@ -65186,13 +66160,16 @@ function evalExprNargout(expr, nargout) {
           return ctx.dimIndex < rv.shape.length ? rv.shape[ctx.dimIndex] : 1;
         }
         if (isRuntimeChar(rv)) return rv.value.length;
-        if (isRuntimeString(rv)) return rv.length;
+        if (isRuntimeString(rv)) return 1;
         if (isRuntimeClassInstance(rv)) {
-          return this.rt.dispatch("end", 1, [
-            rv,
-            ctx.dimIndex + 1,
-            ctx.numIndices
-          ]);
+          if (this.rt.resolveClassMethod?.(rv.className, "end")) {
+            return this.rt.dispatch("end", 1, [
+              rv,
+              ctx.dimIndex + 1,
+              ctx.numIndices
+            ]);
+          }
+          return 1;
         }
         if (isRuntimeStructArray(rv)) {
           return rv.elements.length;
@@ -65201,6 +66178,10 @@ function evalExprNargout(expr, nargout) {
           if (ctx.numIndices === 1) return rv.elements.length;
           return ctx.dimIndex < rv.shape.length ? rv.shape[ctx.dimIndex] : 1;
         }
+        if (isRuntimeStringArray(rv)) {
+          if (ctx.numIndices === 1) return rv.data.length;
+          return ctx.dimIndex < 2 ? 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;
@@ -65525,7 +66506,8 @@ function evalMember(expr, nargout) {
       if (lastDot > 0) {
         const prefix = dottedName.slice(0, lastDot);
         const methodName = dottedName.slice(lastDot + 1);
-        if (this.functionIndex.classStaticMethods.get(prefix)?.has(methodName)) {
+        if (this.functionIndex.classStaticMethods.get(prefix)?.has(methodName) || // Implicit static `ClassName.empty` (handled by interpretClassMethod)
+        methodName === "empty" && this.functionIndex.workspaceClasses.has(prefix)) {
           const target = {
             kind: "classMethod",
             className: prefix,
@@ -66777,6 +67759,22 @@ function interpretClassMethod(target, args, nargout) {
         () => this.callUserFunction(extFn, actualArgs2, nargout)
       );
     }
+    if (methodName === "empty") {
+      const dims = [];
+      for (const a of args) {
+        const rv = ensureRuntimeValue(a);
+        if (isRuntimeTensor(rv)) for (const d of rv.data) dims.push(d);
+        else dims.push(toNumber(rv));
+      }
+      if (dims.length === 1) dims.push(dims[0]);
+      if (dims.length === 0) dims.push(0, 0);
+      if (!dims.some((d) => d === 0)) {
+        throw new RuntimeError(
+          `${className}.empty: at least one dimension must be zero`
+        );
+      }
+      return RTV.classInstanceArray(className, [], [dims[0], dims[1]]);
+    }
     throw new RuntimeError(
       `No method '${methodName}' for class '${className}'`
     );
@@ -66902,8 +67900,9 @@ function callUserFunction(fn, args, nargout, narginOverride) {
   const fnEnv = new Environment();
   fnEnv.rt = this.rt;
   fnEnv.persistentFuncId = `${this.currentFile}:${fn.name}`;
-  const hasVarargin = fn.params.length > 0 && fn.params[fn.params.length - 1] === "varargin";
-  const regularParams = hasVarargin ? fn.params.slice(0, -1) : fn.params;
+  const vararginIdx = fn.params.indexOf("varargin");
+  const hasVarargin = vararginIdx !== -1;
+  const regularParams = hasVarargin ? fn.params.slice(0, vararginIdx) : fn.params;
   let numPositional = regularParams.length;
   const inputBlocks = (fn.argumentsBlocks ?? []).filter(
     (b) => b.kind !== "Output"
@@ -66922,7 +67921,14 @@ function callUserFunction(fn, args, nargout, narginOverride) {
     }
   }
   if (hasVarargin) {
-    const extraArgs = sharedArgs.slice(regularParams.length).map((a) => ensureRuntimeValue(a));
+    let extras = sharedArgs.slice(regularParams.length);
+    if (vararginIdx !== fn.params.length - 1) {
+      extras = extras.slice(
+        0,
+        nameValueTailStart(extras, nameValueFieldNames(fn))
+      );
+    }
+    const extraArgs = extras.map((a) => ensureRuntimeValue(a));
     fnEnv.set("varargin", RTV.cell(extraArgs, [1, extraArgs.length]));
   }
   fnEnv.set("$nargin", narginOverride ?? args.length);
@@ -67307,6 +68313,28 @@ function evalInLocalScope(codeArg, fileName) {
   }
   throw new RuntimeError("eval not available in this context");
 }
+function nameValueFieldNames(fn) {
+  const names = /* @__PURE__ */ new Set();
+  for (const block of fn.argumentsBlocks ?? []) {
+    if (block.kind === "Output" || block.kind === "OutputRepeating") continue;
+    for (const e of block.entries) {
+      const dot2 = e.name.indexOf(".");
+      if (dot2 >= 0) names.add(e.name.slice(dot2 + 1));
+    }
+  }
+  return names;
+}
+function nameValueTailStart(extras, fieldNames) {
+  if (fieldNames.size === 0) return extras.length;
+  for (let i = 0; i < extras.length; i++) {
+    if (extras[i] === void 0) continue;
+    const rv = ensureRuntimeValue(extras[i]);
+    if ((isRuntimeChar(rv) || isRuntimeString(rv)) && fieldNames.has(toString(rv))) {
+      return i;
+    }
+  }
+  return extras.length;
+}
 function processArgumentsBlocks(fn, args) {
   const argBlocks = fn.argumentsBlocks;
   if (!argBlocks || argBlocks.length === 0) return;
@@ -67341,9 +68369,18 @@ function processArgumentsBlocks(fn, args) {
         );
       }
     }
+    const vararginIdx = fn.params.indexOf("varargin");
     for (const [paramName, fields] of nvGroups) {
       const pIdx = fn.params.indexOf(paramName);
-      const nvArgs = args.slice(pIdx >= 0 ? pIdx : args.length);
+      let nvArgs;
+      if (pIdx >= 0 && vararginIdx >= 0 && vararginIdx < pIdx) {
+        const extras = args.slice(vararginIdx);
+        nvArgs = extras.slice(
+          nameValueTailStart(extras, nameValueFieldNames(fn))
+        );
+      } else {
+        nvArgs = args.slice(pIdx >= 0 ? pIdx : args.length);
+      }
       const defaults = {};
       for (const { field, defaultExpr } of fields) {
         if (defaultExpr) defaults[field] = this.evalExpr(defaultExpr);
@@ -68629,6 +69666,11 @@ var shimFiles = [
                 else
                     result = val;
                 end
+                % The backing dictionary stores char values as strings;
+                % MATLAB's containers.Map hands back char.
+                if strcmp(obj.ValueType, 'char') && isstring(result)
+                    result = char(result);
+                end
             elseif strcmp(S(1).type, '.')
                 result = builtin('subsref', obj, S);
             elseif strcmp(S(1).type, '{}')
@@ -68662,11 +69704,14 @@ var shimFiles = [
             end
             k = keys(obj.data_);
             if strcmp(obj.KeyType, 'char')
-                % Return cell array of char vectors
-                if iscell(k)
-                    result = k;
-                else
-                    result = {k};
+                % Return a cellstr: the backing dictionary stores keys as
+                % strings, but MATLAB's containers.Map returns char vectors.
+                if ~iscell(k)
+                    k = {k};
+                end
+                result = cell(size(k));
+                for i = 1:numel(k)
+                    result{i} = char(k{i});
                 end
             else
                 % Numeric keys: parse back from string
@@ -68699,6 +69744,14 @@ var shimFiles = [
                         result{i} = v(i);
                     end
                 end
+                if strcmp(obj.ValueType, 'char')
+                    % Stored as strings in the dictionary; MATLAB returns char.
+                    for i = 1:numel(result)
+                        if isstring(result{i})
+                            result{i} = char(result{i});
+                        end
+                    end
+                end
             end
         end
 
@@ -95159,6 +96212,31 @@ function executeCode(source, options = {}, workspaceFiles, mainFileName = "scrip
       implicitCwdPath = null;
     }
   }
+  if (searchPaths && options.fileIO?.scanDirectory) {
+    const haveM = new Set(mWorkspaceFiles.map((f) => f.name));
+    for (const dir of searchPaths) {
+      try {
+        const absDir = options.fileIO.resolvePath?.(dir) ?? dir;
+        for (const f of options.fileIO.scanDirectory(absDir)) {
+          if (f.name.endsWith(".m")) {
+            if (!haveM.has(f.name)) {
+              mWorkspaceFiles.push(f);
+              haveM.add(f.name);
+            }
+          } else if (isNumblJsFile(f.name)) {
+            if (!jsWorkspaceFiles.some((e) => e.name === f.name)) {
+              jsWorkspaceFiles.push(f);
+            }
+          } else if (f.name.endsWith(".wasm")) {
+            if (!wasmWorkspaceFiles.some((e) => e.name === f.name)) {
+              wasmWorkspaceFiles.push(f);
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
   const jsUserFunctions = loadJsUserFunctions(
     jsWorkspaceFiles,
     wasmWorkspaceFiles,
@@ -95791,7 +96869,7 @@ var NodeFileIOAdapter = class {
     if (entry.eof) return 1;
     const buf = Buffer.alloc(1);
     try {
-      const bytesRead = readSync(entry.fd, buf, 0, 1, null);
+      const bytesRead = readSync(entry.fd, buf, 0, 1, entry.pos);
       if (bytesRead === 0) {
         entry.eof = true;
         return 1;
@@ -96294,6 +97372,12 @@ var NodeFileIOAdapter = class {
   }
   /**
    * Read one line from the file's buffer, refilling from the fd as needed.
+   *
+   * All reads are positional so `entry.pos` stays the single source of truth
+   * for the logical file position: the buffer always holds the bytes starting
+   * at `entry.pos`, and consuming a line advances `entry.pos` by its byte
+   * length. This keeps text I/O (fgetl/fgets) coherent with binary I/O and
+   * fscanf (freadBytes/fseek/ftell).
    * @param keepNewline - if true, keep the trailing newline (fgets); if false, strip it (fgetl)
    */
   readLine(entry, keepNewline) {
@@ -96303,7 +97387,13 @@ var NodeFileIOAdapter = class {
       const buf = Buffer.alloc(READ_CHUNK_SIZE);
       let bytesRead;
       try {
-        bytesRead = readSync(entry.fd, buf, 0, READ_CHUNK_SIZE, null);
+        bytesRead = readSync(
+          entry.fd,
+          buf,
+          0,
+          READ_CHUNK_SIZE,
+          entry.pos + Buffer.byteLength(entry.buffer, "utf-8")
+        );
         entry.lastError = "";
       } catch (e) {
         entry.lastError = e instanceof Error ? e.message : String(e);
@@ -96321,12 +97411,15 @@ var NodeFileIOAdapter = class {
     }
     const nlIdx = entry.buffer.indexOf("\n");
     if (nlIdx !== -1) {
-      const line2 = keepNewline ? entry.buffer.slice(0, nlIdx + 1) : entry.buffer.slice(0, nlIdx);
+      const consumed = entry.buffer.slice(0, nlIdx + 1);
+      const line2 = keepNewline ? consumed : entry.buffer.slice(0, nlIdx);
       entry.buffer = entry.buffer.slice(nlIdx + 1);
+      entry.pos += Buffer.byteLength(consumed, "utf-8");
       return line2;
     }
     const line = entry.buffer;
     entry.buffer = "";
+    entry.pos += Buffer.byteLength(line, "utf-8");
     return line;
   }
 };