numbl 0.4.7 → 0.4.8

package/dist-lib/lib.js

@@ -55132,6 +55132,8 @@ var SPECIAL_BUILTIN_NAMES = [
   "delete",
   "rmdir",
   "movefile",
+  "copyfile",
+  "fileattrib",
   "unzip",
   "dir",
   "warning",
@@ -55141,6 +55143,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "userpath",
   "getenv",
   "setenv",
+  "maxNumCompThreads",
   "pwd",
   "cd",
   "ode45",
@@ -56082,6 +56085,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 +56469,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) {
@@ -62056,6 +62119,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 +62171,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 +62192,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 +62296,8 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge) {
       "wasm",
       "native",
       "importJS",
+      "callHandle",
+      "toNumber",
       libFile.source
     );
     const exports = factory(
@@ -62207,7 +62307,9 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge) {
       dummyRegister,
       wasmInstance,
       nativeLib,
-      importJS
+      importJS,
+      callHandle,
+      toNumber
     );
     libCache.set(name, exports);
     return exports;
@@ -62245,6 +62347,8 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge) {
         "wasm",
         "native",
         "importJS",
+        "callHandle",
+        "toNumber",
         file.source
       );
       factory(
@@ -62254,7 +62358,9 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge) {
         registerFn,
         wasmInstance,
         nativeLib,
-        importJS
+        importJS,
+        callHandle,
+        toNumber
       );
       if (!builtin) {
         throw new Error(
@@ -63874,6 +63980,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 +64291,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.)`
           );
         }
       }
@@ -77094,6 +77211,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 +82618,7 @@ for (const b of [
   stdBuiltin,
   min,
   max,
+  rand,
   any,
   all,
   zeros,
@@ -88262,12 +88404,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 +90447,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 +90540,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 +90671,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 +90816,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;
@@ -91325,9 +91484,781 @@ 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;
+  }
+  readLine(entry, keepNewline) {
+    while (!entry.eof) {
+      const nlIdx2 = entry.buffer.indexOf("\n");
+      if (nlIdx2 !== -1) break;
+      const available = entry.dataLen - entry.pos;
+      if (available <= 0) {
+        entry.eof = true;
+        break;
+      }
+      const toRead = Math.min(READ_CHUNK_SIZE, available);
+      const chunk = entry.data.subarray(entry.pos, entry.pos + toRead);
+      entry.pos += 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 line2 = keepNewline ? entry.buffer.slice(0, nlIdx + 1) : entry.buffer.slice(0, nlIdx);
+      entry.buffer = entry.buffer.slice(nlIdx + 1);
+      return line2;
+    }
+    const line = entry.buffer;
+    entry.buffer = "";
+    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,