numbl 0.4.7 → 0.4.9

package/dist-lib/lib.js

@@ -110,6 +110,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";
@@ -128,6 +129,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 {
@@ -159,6 +161,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;
@@ -613,6 +633,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/runtime/convert.ts
 function toNumber(v) {
@@ -689,6 +732,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`);
   }
@@ -748,6 +796,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;
   }
@@ -800,7 +857,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;
@@ -1115,6 +1199,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);
   },
@@ -22719,6 +22807,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);
@@ -23225,12 +23335,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))
@@ -23243,6 +23365,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))
@@ -23255,7 +23379,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]));
@@ -24638,6 +24793,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];
@@ -24768,6 +24985,9 @@ function indexIntoRTValue(base, indices) {
       return base;
     }
   }
+  if (isRuntimeStringArray(base)) {
+    return indexIntoStringArray(base, indices);
+  }
   if (isRuntimeLogical(base)) {
     return indexIntoLogical(base, indices);
   }
@@ -25589,26 +25809,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);
   }
@@ -25623,6 +25835,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);
   }
@@ -25631,6 +25846,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;
@@ -29860,9 +30155,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");
@@ -29891,9 +30186,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");
@@ -30740,13 +31035,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) {
@@ -30758,6 +31048,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'");
@@ -32170,6 +32476,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() {
@@ -34601,6 +34917,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) {
@@ -34873,6 +35196,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({
@@ -34928,7 +35252,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",
@@ -35111,6 +35439,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;
     })
   ]
@@ -35165,6 +35494,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;
       }
     }
@@ -35195,6 +35525,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;
       }
     }
@@ -35322,6 +35654,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");
@@ -35372,7 +35705,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]
     );
   }
@@ -35380,7 +35713,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]
   );
 }
@@ -36457,6 +36790,87 @@ defineBuiltin({
   ]
 });
 
+// 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/strings.ts
 function isTextType(t) {
   return t.kind === "char" || t.kind === "string";
@@ -36481,6 +36895,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) {
@@ -36493,6 +36910,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 {
@@ -36582,17 +37009,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(""));
       }
     };
   }
@@ -36600,18 +37024,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));
       }
     };
   };
@@ -36779,9 +37200,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) {
@@ -37027,24 +37455,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)));
       }
     };
   }
@@ -37054,7 +37501,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) => {
@@ -37064,20 +37511,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));
+          });
         }
       };
     }
@@ -37089,13 +37528,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");
       }
     };
@@ -37151,6 +37596,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;
   }
 });
@@ -37336,29 +37795,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) => {
@@ -37569,7 +38006,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" }],
@@ -37591,6 +38028,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");
       }
     };
@@ -37601,14 +38041,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);
       }
     };
   }
@@ -37645,7 +38331,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);
       }
     };
@@ -37666,80 +38355,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)];
@@ -38018,6 +38638,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) => {
@@ -38036,6 +38660,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;
@@ -38351,8 +39002,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)
@@ -38655,6 +39310,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);
@@ -41858,6 +42537,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];
@@ -42034,6 +42734,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]);
@@ -42345,6 +43080,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);
@@ -42365,6 +43101,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);
@@ -42383,8 +43120,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;
@@ -42393,7 +43130,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);
       }
     }
   ]
@@ -44063,6 +44800,8 @@ function getValClassName(v) {
       return "double";
     case "dictionary":
       return "dictionary";
+    case "string_array":
+      return "string";
     default:
       return "unknown";
   }
@@ -44092,6 +44831,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];
   }
@@ -45759,6 +46500,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: [
@@ -45766,7 +46513,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 [
@@ -45788,6 +46535,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;
@@ -46491,14 +47245,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]
         );
       }
@@ -46512,11 +47271,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));
       }
@@ -46593,6 +47359,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);
@@ -55036,6 +55815,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "fclose",
   "fgetl",
   "fgets",
+  "fscanf",
   "fileread",
   "feof",
   "ferror",
@@ -55132,6 +55912,8 @@ var SPECIAL_BUILTIN_NAMES = [
   "delete",
   "rmdir",
   "movefile",
+  "copyfile",
+  "fileattrib",
   "unzip",
   "dir",
   "warning",
@@ -55141,6 +55923,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "userpath",
   "getenv",
   "setenv",
+  "maxNumCompThreads",
   "pwd",
   "cd",
   "ode45",
@@ -55300,7 +56083,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 {
@@ -55454,6 +56240,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));
@@ -56082,6 +56915,65 @@ function registerSpecialBuiltins(rt) {
       RTV.char("")
     ];
   });
+  registerSpecial("copyfile", (nargout, args) => {
+    const io = requireFileIO();
+    if (!io.copyfile)
+      throw new RuntimeError("copyfile is not available in this environment");
+    const margs = args.map((a) => ensureRuntimeValue(a));
+    if (margs.length < 1)
+      throw new RuntimeError("copyfile requires at least 1 argument");
+    const source = toString(margs[0]);
+    const destination = margs.length >= 2 ? toString(margs[1]) : rt.system?.cwd() ?? ".";
+    let force = false;
+    if (margs.length >= 3) {
+      const third = toString(margs[2]);
+      if (third.toLowerCase() === "f") force = true;
+    }
+    const ok = io.copyfile(source, destination, force);
+    if (nargout === 0) {
+      if (!ok)
+        throw new RuntimeError(
+          `copyfile: cannot copy '${source}' to '${destination}'`
+        );
+      return void 0;
+    }
+    return nargout <= 1 ? RTV.num(ok ? 1 : 0) : [
+      RTV.num(ok ? 1 : 0),
+      RTV.char(ok ? "" : `Cannot copy '${source}' to '${destination}'`),
+      RTV.char("")
+    ];
+  });
+  registerSpecial("fileattrib", (nargout, args) => {
+    const io = requireFileIO();
+    if (!io.fileattrib)
+      throw new RuntimeError("fileattrib is not available in this environment");
+    const margs = args.map((a) => ensureRuntimeValue(a));
+    if (margs.length < 1)
+      throw new RuntimeError("fileattrib requires at least 1 argument");
+    const p2 = toString(margs[0]);
+    const info = io.fileattrib(p2);
+    if (nargout === 0) {
+      if (!info)
+        throw new RuntimeError(
+          `fileattrib: cannot find '${p2}': No such file or directory`
+        );
+      return void 0;
+    }
+    const values = info ? RTV.struct(
+      /* @__PURE__ */ new Map([
+        ["Name", RTV.char(info.Name)],
+        ["archive", RTV.num(0)],
+        ["system", RTV.num(0)],
+        ["hidden", RTV.num(0)],
+        ["directory", RTV.num(info.directory ? 1 : 0)],
+        ["UserRead", RTV.num(info.UserRead ? 1 : 0)],
+        ["UserWrite", RTV.num(info.UserWrite ? 1 : 0)],
+        ["UserExecute", RTV.num(info.UserExecute ? 1 : 0)]
+      ])
+    ) : RTV.char(`No such file or directory: ${p2}`);
+    if (nargout <= 1) return RTV.num(info ? 1 : 0);
+    return [RTV.num(info ? 1 : 0), values, RTV.char("")];
+  });
   registerSpecial("unzip", (nargout, args) => {
     const io = requireFileIO();
     if (!io.unzip)
@@ -56407,6 +57299,7 @@ function registerSpecialBuiltins(rt) {
     }
     return RTV.char(sys?.getEnv(toString(args[0])) ?? "");
   });
+  registerSpecial("maxNumCompThreads", () => RTV.num(1));
   registerSpecialVoid("setenv", (args) => {
     const sys = rt.system;
     if (args.length === 2) {
@@ -57821,6 +58714,9 @@ function isa(rt, value, classNameArg) {
       case "class_instance_array":
         valueClass = mv.className;
         break;
+      case "string_array":
+        valueClass = "string";
+        break;
       default:
         valueClass = "unknown";
         break;
@@ -58394,6 +59290,8 @@ function numblClass(v) {
       return "double";
     case "class_instance":
       return v.className;
+    case "string_array":
+      return "string";
     default:
       return "unknown";
   }
@@ -58563,6 +59461,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;
@@ -58849,6 +59751,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) {
@@ -59042,6 +59966,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)) {
@@ -59085,6 +60018,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);
@@ -61298,6 +62334,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];
   }
@@ -62056,6 +63093,13 @@ function defaultClassInstanceVertcat(rows) {
 }
 
 // src/numbl-core/jsUserFunctions.ts
+function callHandle(handle, args, nargout = 1) {
+  const rt = getCurrentRuntime();
+  if (!rt) {
+    throw new RuntimeError("callHandle: no active runtime to invoke handle");
+  }
+  return rt.index(handle, args, nargout);
+}
 function funcNameFromFile(fileName) {
   const base = fileName.split("/").pop();
   return base.replace(/\.numbl\.js$/, "");
@@ -62101,6 +63145,8 @@ function instantiateWasm(wasmData) {
   const moduleImports = WebAssembly.Module.imports(wasmModule);
   const importObject = {};
   const neededModules = new Set(moduleImports.map((i) => i.module));
+  const callbacks = /* @__PURE__ */ new Map();
+  let nextCbId = 1;
   if (neededModules.has("wasi_snapshot_preview1")) {
     importObject.wasi_snapshot_preview1 = {
       fd_write: () => 0,
@@ -62120,10 +63166,36 @@ function instantiateWasm(wasmData) {
   if (neededModules.has("env")) {
     importObject.env = {
       emscripten_notify_memory_growth: () => {
+      },
+      // Scalar callback: WASM calls back into a registered handle with one
+      // f64 and receives an f64. Exceptions thrown here (incl. a missing id)
+      // propagate out through the WASM call into the apply.
+      numbl_cb_d: (id, x) => {
+        const fn = callbacks.get(id);
+        if (!fn) {
+          throw new RuntimeError(
+            `numbl_cb_d: no callback registered for id ${id}`
+          );
+        }
+        return fn(x);
       }
     };
   }
-  return new WebAssembly.Instance(wasmModule, importObject);
+  const instance = new WebAssembly.Instance(
+    wasmModule,
+    importObject
+  );
+  instance.callbacks = {
+    add(fn) {
+      const id = nextCbId++;
+      callbacks.set(id, fn);
+      return id;
+    },
+    remove(id) {
+      callbacks.delete(id);
+    }
+  };
+  return instance;
 }
 function resolveBindings(file, directives, getWasmInstance, nativeBridge) {
   const wasmInstance = directives.wasm ? getWasmInstance(directives.wasm) : void 0;
@@ -62198,6 +63270,8 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge) {
       "wasm",
       "native",
       "importJS",
+      "callHandle",
+      "toNumber",
       libFile.source
     );
     const exports = factory(
@@ -62207,7 +63281,9 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge) {
       dummyRegister,
       wasmInstance,
       nativeLib,
-      importJS
+      importJS,
+      callHandle,
+      toNumber
     );
     libCache.set(name, exports);
     return exports;
@@ -62245,6 +63321,8 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge) {
         "wasm",
         "native",
         "importJS",
+        "callHandle",
+        "toNumber",
         file.source
       );
       factory(
@@ -62254,7 +63332,9 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge) {
         registerFn,
         wasmInstance,
         nativeLib,
-        importJS
+        importJS,
+        callHandle,
+        toNumber
       );
       if (!builtin) {
         throw new Error(
@@ -63874,6 +64954,15 @@ __export(interpreterExec_exports, {
   writeLValueBase: () => writeLValueBase
 });
 
+// src/numbl-core/jitDeclineDiagnostics.ts
+var lastDecline = null;
+function recordJitDecline(d) {
+  lastDecline = d;
+}
+function getLastJitDecline() {
+  return lastDecline;
+}
+
 // src/numbl-core/runtime/cow.ts
 function cowCopy(v) {
   if (isRuntimeTensor(v)) {
@@ -64176,14 +65265,16 @@ function execStmtInner(stmt) {
     case "Directive": {
       if (stmt.directive === "assert_jit") {
         const wantC = stmt.args.includes("c");
+        const decline = getLastJitDecline();
+        const why = decline ? ` Most recent JIT decline (${decline.where}, ${decline.kind}): ${decline.message}` : ` (no JIT decline reason was recorded \u2014 the unit may have been declined before lowering, e.g. an unsupported input type.)`;
         if (this.optimization === "1") {
           throw new RuntimeError(
-            `%!numbl:assert_jit: expected the enclosing loop/function/script to be JS-JIT-compiled at --opt 1, but it ran in the interpreter. (Run with --opt 0 to silence.)`
+            `%!numbl:assert_jit: expected the enclosing loop/function/script to be JS-JIT-compiled at --opt 1, but it ran in the interpreter.${why} (Run with --opt 0 to silence.)`
           );
         }
         if (this.optimization === "2" && wantC) {
           throw new RuntimeError(
-            `%!numbl:assert_jit c: expected the enclosing loop/function/script to be C-JIT-compiled at --opt 2, but it ran in the interpreter. (Run with --opt 0 to silence.)`
+            `%!numbl:assert_jit c: expected the enclosing loop/function/script to be C-JIT-compiled at --opt 2, but it ran in the interpreter.${why} (Run with --opt 0 to silence.)`
           );
         }
       }
@@ -64255,13 +65346,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;
@@ -64270,6 +65364,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;
@@ -64594,7 +65692,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,
@@ -65846,6 +66945,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}'`
     );
@@ -65971,8 +67086,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"
@@ -65991,7 +67107,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);
@@ -66376,6 +67499,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;
@@ -66410,9 +67555,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);
@@ -67698,6 +68852,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, '{}')
@@ -67731,11 +68890,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
@@ -67768,6 +68930,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
 
@@ -77094,6 +78264,30 @@ var sin = defineUnaryRealMath({
   complex: { cFnComplex: "mtoc2_csin", jsFnComplex: cSin }
 });
 
+// src/numbl-core/jit/builtins/defs/math/rand.ts
+var rand = {
+  name: "rand",
+  transfer(argTypes, nargout) {
+    if (nargout > 1) {
+      throw new UnsupportedConstruct(
+        `'rand' does not support multi-output (nargout=${nargout})`
+      );
+    }
+    if (argTypes.length !== 0) {
+      throw new UnsupportedConstruct(
+        `JS-JIT 'rand' supports only the scalar form rand() so far (got ${argTypes.length} arg(s)); matrix/seed forms run in the interpreter`
+      );
+    }
+    return [scalarDouble("nonneg")];
+  },
+  emitJs() {
+    return "$rand()";
+  },
+  call() {
+    return [rngRandom()];
+  }
+};
+
 // src/numbl-core/jit/builtins/defs/math/tan.ts
 var tan = defineUnaryRealMath({
   name: "tan",
@@ -82477,6 +83671,7 @@ for (const b of [
   stdBuiltin,
   min,
   max,
+  rand,
   any,
   all,
   zeros,
@@ -88262,12 +89457,13 @@ function emitJsProgram(prog, opts = {}) {
   const wrapperLines = [];
   if (opts.exposeSpec !== void 0) {
     wrapperLines.push(
-      `return function ($h) { globalThis.$write = $h.write; globalThis.$plotDispatch = $h.plotDispatch; return ${opts.exposeSpec}; };`
+      `return function ($h) { globalThis.$write = $h.write; globalThis.$plotDispatch = $h.plotDispatch; globalThis.$rand = $h.rand; return ${opts.exposeSpec}; };`
     );
   } else {
     wrapperLines.push("function run($h) {");
     wrapperLines.push("  globalThis.$write = $h.write;");
     wrapperLines.push("  globalThis.$plotDispatch = $h.plotDispatch;");
+    wrapperLines.push("  globalThis.$rand = $h.rand;");
     const locals = collectAssignedLocals(prog.topLevelStmts);
     if (locals.length > 0) {
       wrapperLines.push(`  let ${locals.join(", ")};`);
@@ -90304,6 +91500,7 @@ function getOrCreateSession(interp) {
 function buildHostHelpers(rt) {
   return {
     write: (s) => rt.output(s),
+    rand: () => rngRandom(),
     plotDispatch: (name, args) => {
       const runtimeArgs = args.map((a) => jitToNumbl(a));
       const handled = dispatchPlotBuiltin(
@@ -90396,6 +91593,11 @@ var jitCallExecutor = {
       return { specFn };
     } catch (e) {
       if (e instanceof UnsupportedConstruct || e instanceof TypeError2) {
+        recordJitDecline({
+          message: e.message,
+          kind: e.constructor.name,
+          where: "jit-call"
+        });
         return null;
       }
       throw e;
@@ -90522,6 +91724,11 @@ var jitLoopExecutor = {
       return { specFn };
     } catch (e) {
       if (e instanceof UnsupportedConstruct || e instanceof TypeError2) {
+        recordJitDecline({
+          message: e.message,
+          kind: e.constructor.name,
+          where: "jit-loop"
+        });
         return null;
       }
       throw e;
@@ -90662,6 +91869,11 @@ var jitTopLevelExecutor = {
       return { specFn, nargout };
     } catch (e) {
       if (e instanceof UnsupportedConstruct || e instanceof TypeError2) {
+        recordJitDecline({
+          message: e.message,
+          kind: e.constructor.name,
+          where: "jit-top-level"
+        });
         return null;
       }
       throw e;
@@ -90866,6 +92078,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,
@@ -91325,9 +92562,790 @@ async function load() {
   setDelaunayBackend((points, dim) => qhull.delaunay(points, dim).facets);
   setConvexHullBackend((points, dim) => qhull.convexHull(points, dim).facets);
 }
+
+// src/vfs/VirtualFileSystem.ts
+var VirtualFileSystem = class {
+  files = /* @__PURE__ */ new Map();
+  directories = /* @__PURE__ */ new Set();
+  cwd = "/project";
+  // Change tracking
+  createdFiles = /* @__PURE__ */ new Set();
+  modifiedFiles = /* @__PURE__ */ new Set();
+  deletedFiles = /* @__PURE__ */ new Set();
+  /** Clear change tracking. Call after populating the VFS with initial files. */
+  clearChangeTracking() {
+    this.createdFiles.clear();
+    this.modifiedFiles.clear();
+    this.deletedFiles.clear();
+  }
+  /** Normalize a path to absolute form. */
+  normalizePath(p2) {
+    if (!p2.startsWith("/")) {
+      p2 = this.cwd + "/" + p2;
+    }
+    const parts = p2.split("/");
+    const resolved = [];
+    for (const part of parts) {
+      if (part === "" || part === ".") continue;
+      if (part === "..") {
+        if (resolved.length > 0) resolved.pop();
+      } else {
+        resolved.push(part);
+      }
+    }
+    return "/" + resolved.join("/");
+  }
+  getCwd() {
+    return this.cwd;
+  }
+  setCwd(dir) {
+    this.cwd = this.normalizePath(dir);
+  }
+  readFile(path) {
+    const norm2 = this.normalizePath(path);
+    const file = this.files.get(norm2);
+    if (!file) throw new Error(`File not found: ${path}`);
+    return file.content;
+  }
+  writeFile(path, content) {
+    const norm2 = this.normalizePath(path);
+    const existed = this.files.has(norm2);
+    this.files.set(norm2, { content, mtimeMs: Date.now() });
+    this.ensureParentDirs(norm2);
+    if (this.deletedFiles.has(norm2)) {
+      this.deletedFiles.delete(norm2);
+      this.modifiedFiles.add(norm2);
+    } else if (!existed) {
+      this.createdFiles.add(norm2);
+    } else if (!this.createdFiles.has(norm2)) {
+      this.modifiedFiles.add(norm2);
+    }
+  }
+  deleteFile(path) {
+    const norm2 = this.normalizePath(path);
+    if (!this.files.has(norm2)) return false;
+    this.files.delete(norm2);
+    if (this.createdFiles.has(norm2)) {
+      this.createdFiles.delete(norm2);
+      this.modifiedFiles.delete(norm2);
+    } else {
+      this.modifiedFiles.delete(norm2);
+      this.deletedFiles.add(norm2);
+    }
+    return true;
+  }
+  exists(path) {
+    const norm2 = this.normalizePath(path);
+    if (this.files.has(norm2)) return "file";
+    if (this.directories.has(norm2)) return "dir";
+    const prefix = norm2 + "/";
+    for (const key of this.files.keys()) {
+      if (key.startsWith(prefix)) return "dir";
+    }
+    return null;
+  }
+  fileSize(path) {
+    const norm2 = this.normalizePath(path);
+    const file = this.files.get(norm2);
+    return file ? file.content.length : 0;
+  }
+  mkdir(dirPath) {
+    const norm2 = this.normalizePath(dirPath);
+    this.directories.add(norm2);
+    this.ensureParentDirs(norm2 + "/placeholder");
+    return true;
+  }
+  /** Move/rename a file or directory tree. Returns true on success. */
+  movefile(source, destination) {
+    const srcNorm = this.normalizePath(source);
+    const srcType = this.exists(srcNorm);
+    if (srcType === null) return false;
+    let dstNorm = this.normalizePath(destination);
+    const dstType = this.exists(dstNorm);
+    if (dstType === "dir") {
+      const lastSlash = srcNorm.lastIndexOf("/");
+      const baseName = lastSlash >= 0 ? srcNorm.slice(lastSlash + 1) : srcNorm;
+      dstNorm = (dstNorm === "/" ? "" : dstNorm) + "/" + baseName;
+    }
+    if (srcType === "dir" && this.exists(dstNorm) === "file") return false;
+    if (srcType === "file") {
+      const content = this.files.get(srcNorm).content;
+      if (this.exists(dstNorm) === "file") this.deleteFile(dstNorm);
+      this.writeFile(dstNorm, content);
+      this.deleteFile(srcNorm);
+      return true;
+    }
+    const srcPrefix = srcNorm + "/";
+    const filesToMove = [];
+    for (const [path, file] of this.files) {
+      if (path === srcNorm || path.startsWith(srcPrefix)) {
+        const rest = path === srcNorm ? "" : path.slice(srcNorm.length);
+        filesToMove.push({
+          from: path,
+          to: dstNorm + rest,
+          content: file.content
+        });
+      }
+    }
+    const dirsToMove = [];
+    for (const dir of this.directories) {
+      if (dir === srcNorm || dir.startsWith(srcPrefix)) {
+        const rest = dir === srcNorm ? "" : dir.slice(srcNorm.length);
+        dirsToMove.push({ from: dir, to: dstNorm + rest });
+      }
+    }
+    for (const { from } of filesToMove) this.deleteFile(from);
+    for (const { from } of dirsToMove) this.directories.delete(from);
+    this.directories.add(dstNorm);
+    for (const { to } of dirsToMove) this.directories.add(to);
+    for (const { to, content } of filesToMove) this.writeFile(to, content);
+    return true;
+  }
+  /** Copy a file or directory tree (source is left in place). True on success. */
+  copyfile(source, destination) {
+    const srcNorm = this.normalizePath(source);
+    const srcType = this.exists(srcNorm);
+    if (srcType === null) return false;
+    let dstNorm = this.normalizePath(destination);
+    if (this.exists(dstNorm) === "dir") {
+      const lastSlash = srcNorm.lastIndexOf("/");
+      const baseName = lastSlash >= 0 ? srcNorm.slice(lastSlash + 1) : srcNorm;
+      dstNorm = (dstNorm === "/" ? "" : dstNorm) + "/" + baseName;
+    }
+    if (srcType === "dir" && this.exists(dstNorm) === "file") return false;
+    if (srcType === "file") {
+      const content = this.files.get(srcNorm).content;
+      if (this.exists(dstNorm) === "file") this.deleteFile(dstNorm);
+      this.writeFile(dstNorm, content);
+      return true;
+    }
+    const srcPrefix = srcNorm + "/";
+    for (const [path, file] of [...this.files]) {
+      if (path === srcNorm || path.startsWith(srcPrefix)) {
+        const rest = path === srcNorm ? "" : path.slice(srcNorm.length);
+        this.writeFile(dstNorm + rest, file.content);
+      }
+    }
+    for (const dir of [...this.directories]) {
+      if (dir === srcNorm || dir.startsWith(srcPrefix)) {
+        const rest = dir === srcNorm ? "" : dir.slice(srcNorm.length);
+        this.directories.add(dstNorm + rest);
+      }
+    }
+    this.directories.add(dstNorm);
+    return true;
+  }
+  /** Resolve a path to its (normalized) absolute path + attributes, or null. */
+  fileattrib(path) {
+    const norm2 = this.normalizePath(path);
+    const t = this.exists(norm2);
+    if (t === null) return null;
+    return {
+      Name: norm2,
+      directory: t === "dir",
+      UserRead: true,
+      UserWrite: true,
+      UserExecute: t === "dir"
+    };
+  }
+  rmdir(dirPath, recursive) {
+    const norm2 = this.normalizePath(dirPath);
+    if (this.exists(norm2) !== "dir") return false;
+    if (recursive) {
+      const prefix = norm2 + "/";
+      for (const key of [...this.files.keys()]) {
+        if (key.startsWith(prefix)) {
+          this.deleteFile(key);
+        }
+      }
+      for (const dir of [...this.directories]) {
+        if (dir === norm2 || dir.startsWith(prefix)) {
+          this.directories.delete(dir);
+        }
+      }
+    } else {
+      const prefix = norm2 + "/";
+      for (const key of this.files.keys()) {
+        if (key.startsWith(prefix)) return false;
+      }
+      this.directories.delete(norm2);
+    }
+    return true;
+  }
+  /** List entries in a directory. */
+  listDir(dirPath) {
+    const norm2 = this.normalizePath(dirPath);
+    const prefix = norm2 === "/" ? "/" : norm2 + "/";
+    const results = [];
+    const now = Date.now();
+    results.push({
+      name: ".",
+      folder: norm2,
+      bytes: 0,
+      isdir: true,
+      mtimeMs: now
+    });
+    results.push({
+      name: "..",
+      folder: norm2,
+      bytes: 0,
+      isdir: true,
+      mtimeMs: now
+    });
+    const seen = /* @__PURE__ */ new Set();
+    for (const [path, file] of this.files) {
+      if (!path.startsWith(prefix)) continue;
+      const rest = path.slice(prefix.length);
+      const slashIdx = rest.indexOf("/");
+      if (slashIdx === -1) {
+        results.push({
+          name: rest,
+          folder: norm2,
+          bytes: file.content.length,
+          isdir: false,
+          mtimeMs: file.mtimeMs
+        });
+      } else {
+        const dirName = rest.slice(0, slashIdx);
+        if (!seen.has(dirName)) {
+          seen.add(dirName);
+          results.push({
+            name: dirName,
+            folder: norm2,
+            bytes: 0,
+            isdir: true,
+            mtimeMs: now
+          });
+        }
+      }
+    }
+    for (const dir of this.directories) {
+      if (!dir.startsWith(prefix)) continue;
+      const rest = dir.slice(prefix.length);
+      if (!rest.includes("/") && rest.length > 0 && !seen.has(rest)) {
+        seen.add(rest);
+        results.push({
+          name: rest,
+          folder: norm2,
+          bytes: 0,
+          isdir: true,
+          mtimeMs: now
+        });
+      }
+    }
+    return results;
+  }
+  /** List all file paths in the VFS. */
+  allFiles() {
+    return [...this.files.keys()];
+  }
+  /** Get the changes since the VFS was created. */
+  getChanges() {
+    const created = [];
+    const modified = [];
+    for (const path of this.createdFiles) {
+      const file = this.files.get(path);
+      if (file) created.push({ path, content: file.content });
+    }
+    for (const path of this.modifiedFiles) {
+      const file = this.files.get(path);
+      if (file) modified.push({ path, content: file.content });
+    }
+    return {
+      created,
+      modified,
+      deleted: [...this.deletedFiles]
+    };
+  }
+  ensureParentDirs(path) {
+    const parts = path.split("/").filter(Boolean);
+    for (let i = 1; i < parts.length; i++) {
+      const dir = "/" + parts.slice(0, i).join("/");
+      this.directories.add(dir);
+    }
+  }
+};
+
+// src/vfs/BrowserFileIOAdapter.ts
+import { unzipSync } from "fflate";
+var TEXT_DECODER = new TextDecoder("utf-8");
+var TEXT_ENCODER = new TextEncoder();
+var READ_CHUNK_SIZE = 8192;
+var BrowserFileIOAdapter = class {
+  constructor(vfs) {
+    this.vfs = vfs;
+  }
+  nextFid = 3;
+  // 0=stdin, 1=stdout, 2=stderr reserved
+  openFiles = /* @__PURE__ */ new Map();
+  fopen(filename, permission) {
+    const perm = permission.replace(/b/g, "");
+    const path = this.vfs.normalizePath(filename);
+    try {
+      let data;
+      let pos = 0;
+      if (perm === "r" || perm === "r+") {
+        if (this.vfs.exists(filename) !== "file") return -1;
+        data = new Uint8Array(this.vfs.readFile(filename));
+      } else if (perm === "w" || perm === "w+") {
+        data = new Uint8Array(0);
+      } else if (perm === "a" || perm === "a+") {
+        if (this.vfs.exists(filename) === "file") {
+          data = new Uint8Array(this.vfs.readFile(filename));
+          pos = data.length;
+        } else {
+          data = new Uint8Array(0);
+        }
+      } else {
+        return -1;
+      }
+      const fid = this.nextFid++;
+      this.openFiles.set(fid, {
+        path,
+        permission: perm,
+        lastError: "",
+        buffer: "",
+        eof: false,
+        pos,
+        data,
+        dataLen: data.length,
+        dirty: perm === "w" || perm === "a"
+        // w starts dirty (truncated or new)
+      });
+      return fid;
+    } catch {
+      return -1;
+    }
+  }
+  fclose(fidOrAll) {
+    if (fidOrAll === "all") {
+      for (const [, entry2] of this.openFiles) {
+        this.flushEntry(entry2);
+      }
+      this.openFiles.clear();
+      return 0;
+    }
+    const entry = this.openFiles.get(fidOrAll);
+    if (!entry) return -1;
+    this.flushEntry(entry);
+    this.openFiles.delete(fidOrAll);
+    return 0;
+  }
+  fgetl(fid) {
+    const entry = this.getEntry(fid);
+    if (!entry) return -1;
+    return this.readLine(entry, false);
+  }
+  fgets(fid) {
+    const entry = this.getEntry(fid);
+    if (!entry) return -1;
+    return this.readLine(entry, true);
+  }
+  fileread(filename) {
+    const data = this.vfs.readFile(filename);
+    return TEXT_DECODER.decode(data);
+  }
+  feof(fid) {
+    const entry = this.getEntry(fid);
+    if (!entry) return 1;
+    if (entry.buffer.length > 0) return 0;
+    if (entry.eof) return 1;
+    if (entry.pos >= entry.dataLen) {
+      entry.eof = true;
+      return 1;
+    }
+    return 0;
+  }
+  ferror(fid) {
+    const entry = this.getEntry(fid);
+    if (!entry) return "Invalid file identifier";
+    return entry.lastError;
+  }
+  fwrite(fid, text) {
+    const entry = this.getEntry(fid);
+    if (!entry) throw new Error(`Invalid file identifier: ${fid}`);
+    const bytes = TEXT_ENCODER.encode(text);
+    this.writeBytes(entry, bytes);
+    entry.lastError = "";
+  }
+  freadBytes(fid, count) {
+    const entry = this.getEntry(fid);
+    if (!entry) throw new Error(`Invalid file identifier: ${fid}`);
+    if (entry.buffer.length > 0) {
+      entry.buffer = "";
+    }
+    const available = entry.dataLen - entry.pos;
+    const toRead = Math.min(count, available);
+    if (toRead <= 0) {
+      entry.eof = true;
+      return new Uint8Array(0);
+    }
+    const result = new Uint8Array(toRead);
+    result.set(entry.data.subarray(entry.pos, entry.pos + toRead));
+    entry.pos += toRead;
+    if (entry.pos >= entry.dataLen) entry.eof = true;
+    entry.lastError = "";
+    return result;
+  }
+  fwriteBytes(fid, data) {
+    const entry = this.getEntry(fid);
+    if (!entry) throw new Error(`Invalid file identifier: ${fid}`);
+    this.writeBytes(entry, data);
+    entry.lastError = "";
+    return data.length;
+  }
+  fseek(fid, offset, origin) {
+    const entry = this.getEntry(fid);
+    if (!entry) return -1;
+    entry.buffer = "";
+    entry.eof = false;
+    if (origin === -1) {
+      entry.pos = offset;
+    } else if (origin === 0) {
+      entry.pos += offset;
+    } else {
+      entry.pos = entry.dataLen + offset;
+    }
+    return 0;
+  }
+  ftell(fid) {
+    const entry = this.getEntry(fid);
+    if (!entry) return -1;
+    return entry.pos;
+  }
+  scanDirectory(dirPath) {
+    const norm2 = this.vfs.normalizePath(dirPath);
+    const prefix = norm2 === "/" ? "/" : norm2 + "/";
+    const results = [];
+    for (const filePath of this.vfs.allFiles()) {
+      if (!filePath.startsWith(prefix)) continue;
+      const relativePath = filePath.slice(prefix.length);
+      if (!relativePath) continue;
+      const segments = relativePath.split("/");
+      const dirs = segments.slice(0, -1);
+      const allSpecial = dirs.every(
+        (d) => d.startsWith("@") || d.startsWith("+") || d === "private"
+      );
+      if (!allSpecial) continue;
+      if (!relativePath.endsWith(".m") && !relativePath.endsWith(".numbl.js") && !relativePath.endsWith(".wasm")) {
+        continue;
+      }
+      try {
+        const content = this.vfs.readFile(filePath);
+        if (relativePath.endsWith(".wasm")) {
+          results.push({
+            name: filePath,
+            source: "",
+            data: new Uint8Array(content)
+          });
+        } else {
+          results.push({
+            name: filePath,
+            source: TEXT_DECODER.decode(content)
+          });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  resolvePath(dirPath) {
+    return this.vfs.normalizePath(dirPath);
+  }
+  existsPath(path) {
+    return this.vfs.exists(path);
+  }
+  mkdir(dirPath) {
+    return this.vfs.mkdir(dirPath);
+  }
+  tempdir() {
+    return "/tmp";
+  }
+  userpath() {
+    return "/system";
+  }
+  deleteFile(pattern) {
+    const norm2 = this.vfs.normalizePath(pattern);
+    if (norm2.includes("*") || norm2.includes("?")) {
+      const lastSlash = norm2.lastIndexOf("/");
+      const dir = norm2.slice(0, lastSlash);
+      const globPat = norm2.slice(lastSlash + 1);
+      const re = new RegExp(
+        "^" + globPat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
+      );
+      const entries = this.vfs.listDir(dir);
+      for (const entry of entries) {
+        if (!entry.isdir && re.test(entry.name)) {
+          this.vfs.deleteFile(dir + "/" + entry.name);
+        }
+      }
+    } else {
+      this.vfs.deleteFile(norm2);
+    }
+  }
+  rmdir(dirPath, recursive) {
+    return this.vfs.rmdir(dirPath, recursive);
+  }
+  movefile(source, destination) {
+    return this.vfs.movefile(source, destination);
+  }
+  copyfile(source, destination) {
+    return this.vfs.copyfile(source, destination);
+  }
+  fileattrib(path) {
+    return this.vfs.fileattrib(path);
+  }
+  listDir(dirPath) {
+    const norm2 = this.vfs.normalizePath(dirPath);
+    if (dirPath.includes("**")) {
+      return this.listDirRecursive(dirPath);
+    }
+    if (dirPath.includes("*") || dirPath.includes("?")) {
+      return this.listDirGlob(dirPath);
+    }
+    const type = this.vfs.exists(dirPath);
+    if (type === "file") {
+      const lastSlash = norm2.lastIndexOf("/");
+      const name = lastSlash >= 0 ? norm2.slice(lastSlash + 1) : norm2;
+      const folder = lastSlash >= 0 ? norm2.slice(0, lastSlash) : "/";
+      return [
+        {
+          name,
+          folder,
+          bytes: this.vfs.fileSize(dirPath),
+          isdir: false,
+          mtimeMs: Date.now()
+        }
+      ];
+    }
+    return this.vfs.listDir(dirPath);
+  }
+  websave(url, filename, options) {
+    url = filterUrl(url);
+    const method = options?.requestMethod?.toUpperCase() || "GET";
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, url, false);
+    if (options?.timeout) xhr.timeout = Math.round(options.timeout * 1e3);
+    if (options?.username && options?.password) {
+      xhr.setRequestHeader(
+        "Authorization",
+        "Basic " + btoa(`${options.username}:${options.password}`)
+      );
+    }
+    if (options?.keyName && options?.keyValue) {
+      xhr.setRequestHeader(options.keyName, options.keyValue);
+    }
+    xhr.responseType = "arraybuffer";
+    xhr.send();
+    if (xhr.status < 200 || xhr.status >= 300) {
+      throw new Error(`websave: HTTP ${xhr.status} for ${url}`);
+    }
+    const data = new Uint8Array(xhr.response);
+    this.vfs.writeFile(filename, data);
+  }
+  webread(url, options) {
+    url = filterUrl(url);
+    const method = options?.requestMethod?.toUpperCase() || "GET";
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, url, false);
+    if (options?.timeout) xhr.timeout = Math.round(options.timeout * 1e3);
+    if (options?.username && options?.password) {
+      xhr.setRequestHeader(
+        "Authorization",
+        "Basic " + btoa(`${options.username}:${options.password}`)
+      );
+    }
+    if (options?.keyName && options?.keyValue) {
+      xhr.setRequestHeader(options.keyName, options.keyValue);
+    }
+    xhr.send();
+    if (xhr.status < 200 || xhr.status >= 300) {
+      throw new Error(`webread: HTTP ${xhr.status} for ${url}`);
+    }
+    return xhr.responseText;
+  }
+  unzip(zipfilename, outputfolder) {
+    zipfilename = filterUrl(zipfilename);
+    const zipData = this.vfs.readFile(zipfilename);
+    this.vfs.mkdir(outputfolder);
+    const files = unzipSync(zipData);
+    const extracted = [];
+    for (const [entryName, fileData] of Object.entries(files)) {
+      if (entryName.endsWith("/")) {
+        this.vfs.mkdir(outputfolder + "/" + entryName);
+        continue;
+      }
+      const outPath = outputfolder + "/" + entryName;
+      const lastSlash = outPath.lastIndexOf("/");
+      if (lastSlash > 0) {
+        this.vfs.mkdir(outPath.slice(0, lastSlash));
+      }
+      this.vfs.writeFile(outPath, fileData);
+      extracted.push(this.vfs.normalizePath(outPath));
+    }
+    return extracted;
+  }
+  /** Get the VFS changes for syncing back to the main thread. */
+  getChanges() {
+    for (const [, entry] of this.openFiles) {
+      this.flushEntry(entry);
+    }
+    return this.vfs.getChanges();
+  }
+  getEntry(fid) {
+    return this.openFiles.get(fid);
+  }
+  flushEntry(entry) {
+    if (entry.dirty) {
+      const finalData = entry.dataLen === entry.data.length ? entry.data : entry.data.subarray(0, entry.dataLen);
+      this.vfs.writeFile(entry.path, finalData);
+      entry.dirty = false;
+    }
+  }
+  writeBytes(entry, bytes) {
+    const needed = entry.pos + bytes.length;
+    if (needed > entry.data.length) {
+      const newSize = Math.max(needed, entry.data.length * 2, 256);
+      const newData = new Uint8Array(newSize);
+      newData.set(entry.data.subarray(0, entry.dataLen));
+      entry.data = newData;
+    }
+    entry.data.set(bytes, entry.pos);
+    entry.pos += bytes.length;
+    if (entry.pos > entry.dataLen) {
+      entry.dataLen = entry.pos;
+    }
+    entry.dirty = true;
+  }
+  /**
+   * `entry.pos` stays the logical (consumed) byte position: the text buffer
+   * holds the bytes starting at `entry.pos`, and consuming a line advances
+   * `entry.pos` by its byte length. This keeps fgetl/fgets coherent with
+   * freadBytes/fseek/ftell (and fscanf, which mixes the two).
+   */
+  readLine(entry, keepNewline) {
+    while (!entry.eof) {
+      const nlIdx2 = entry.buffer.indexOf("\n");
+      if (nlIdx2 !== -1) break;
+      const bufStart = entry.pos + TEXT_ENCODER.encode(entry.buffer).length;
+      const available = entry.dataLen - bufStart;
+      if (available <= 0) {
+        entry.eof = true;
+        break;
+      }
+      const toRead = Math.min(READ_CHUNK_SIZE, available);
+      const chunk = entry.data.subarray(bufStart, bufStart + toRead);
+      entry.buffer += TEXT_DECODER.decode(chunk, { stream: true });
+    }
+    if (entry.buffer.length === 0) {
+      return -1;
+    }
+    const nlIdx = entry.buffer.indexOf("\n");
+    if (nlIdx !== -1) {
+      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 += TEXT_ENCODER.encode(consumed).length;
+      return line2;
+    }
+    const line = entry.buffer;
+    entry.buffer = "";
+    entry.pos += TEXT_ENCODER.encode(line).length;
+    return line;
+  }
+  listDirGlob(pattern) {
+    const norm2 = this.vfs.normalizePath(pattern);
+    const lastSlash = norm2.lastIndexOf("/");
+    const dir = lastSlash >= 0 ? norm2.slice(0, lastSlash) : "/";
+    const globPat = lastSlash >= 0 ? norm2.slice(lastSlash + 1) : norm2;
+    const re = new RegExp(
+      "^" + globPat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
+    );
+    const entries = this.vfs.listDir(dir);
+    return entries.filter(
+      (e) => e.name !== "." && e.name !== ".." && re.test(e.name)
+    );
+  }
+  listDirRecursive(pattern) {
+    const idx = pattern.indexOf("**");
+    let baseDir = pattern.slice(0, idx);
+    if (baseDir.endsWith("/")) baseDir = baseDir.slice(0, -1);
+    if (!baseDir) baseDir = ".";
+    const results = [];
+    const walkDir = (dir) => {
+      const entries = this.vfs.listDir(dir);
+      results.push(...entries);
+      for (const entry of entries) {
+        if (entry.isdir && entry.name !== "." && entry.name !== "..") {
+          walkDir(entry.folder + "/" + entry.name);
+        }
+      }
+    };
+    walkDir(this.vfs.normalizePath(baseDir));
+    return results;
+  }
+};
+function filterUrl(url) {
+  if (/^https:\/\/github\.com\/.+\/releases\/download\/.+/.test(url)) {
+    url = url.replace(
+      "https://github.com/",
+      "https://mip-cors-proxy.figurl.workers.dev/gh/"
+    );
+    url += url.includes("?") ? "&" : "?";
+    url += "t=" + Date.now();
+  }
+  return url;
+}
+
+// src/vfs/BrowserSystemAdapter.ts
+var BrowserSystemAdapter = class {
+  vars = /* @__PURE__ */ new Map();
+  vfs = null;
+  // Used only when no VFS is attached (e.g. tests that don't need files).
+  fallbackCwd = "/";
+  constructor(vfs) {
+    if (vfs) this.vfs = vfs;
+  }
+  /** Attach (or replace) the VFS used as the cwd source of truth. */
+  setVfs(vfs) {
+    this.vfs = vfs;
+  }
+  getEnv(name) {
+    return this.vars.get(name);
+  }
+  getAllEnv() {
+    const result = {};
+    for (const [k, v] of this.vars) {
+      result[k] = v;
+    }
+    return result;
+  }
+  setEnv(name, value) {
+    this.vars.set(name, value);
+  }
+  cwd() {
+    return this.vfs ? this.vfs.getCwd() : this.fallbackCwd;
+  }
+  chdir(dir) {
+    if (this.vfs) {
+      this.vfs.setCwd(dir);
+    } else {
+      this.fallbackCwd = dir.startsWith("/") ? dir : this.fallbackCwd.replace(/\/$/, "") + "/" + dir;
+    }
+  }
+  platform() {
+    return "linux";
+  }
+  arch() {
+    return "x64";
+  }
+};
 export {
+  BrowserFileIOAdapter,
+  BrowserSystemAdapter,
   RTV,
   RuntimeError,
+  VirtualFileSystem,
   displayValue,
   executeCode,
   loadQhullNodeBackend as loadDelaunayBackend,