numbl 0.1.0 → 0.1.1

package/dist-cli/cli.js

@@ -7,15 +7,17 @@ var __export = (target, all) => {
 
 // src/cli.ts
 import {
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   readSync as readSync3,
-  readdirSync as readdirSync2,
-  statSync as statSync2,
+  readdirSync as readdirSync3,
+  statSync as statSync3,
   existsSync as existsSync2,
   writeFileSync as writeFileSync3,
-  appendFileSync as appendFileSync2
+  appendFileSync as appendFileSync2,
+  mkdirSync as mkdirSync2
 } from "fs";
-import { delimiter, dirname as dirname2, join as join4, relative, resolve as resolve2 } from "path";
+import { delimiter, dirname as dirname2, join as join5, relative, resolve as resolve2 } from "path";
+import { homedir as homedir3 } from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createRequire } from "module";
 import { execSync } from "child_process";
@@ -28720,6 +28722,20 @@ registerIBuiltin({
     apply: () => RTV.char("")
   })
 });
+registerIBuiltin({
+  name: "isnumbl",
+  resolve: (argTypes) => {
+    if (argTypes.length !== 0) return null;
+    return {
+      outputTypes: [{ kind: "boolean" }],
+      apply: () => true
+    };
+  },
+  jitEmit: (_args, types) => {
+    if (types.length !== 0) return null;
+    return "1";
+  }
+});
 registerIBuiltin({
   name: "ishold",
   resolve: () => ({
@@ -29031,6 +29047,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "mfilename",
   "addpath",
   "rmpath",
+  "savepath",
   "path",
   "mkdir",
   "websave",
@@ -30041,6 +30058,10 @@ function registerSpecialBuiltins(rt) {
     if (nargout >= 1) return RTV.char(rt.searchPaths.join(";"));
     return 0;
   });
+  registerSpecial("savepath", () => {
+    rt.output("Warning: savepath is a no-op in numbl\n");
+    return 0;
+  });
   registerSpecial("input", (_nargout, args) => {
     const margs = args.map((a) => ensureRuntimeValue(a));
     const prompt = margs.length >= 1 ? toString(margs[0]) : "";
@@ -35455,18 +35476,57 @@ registerIBuiltin({
     };
   }
 });
+function str2doubleScalar(s) {
+  s = s.trim();
+  if (s === "") return NaN;
+  s = s.replace(/,/g, "");
+  const complexFull = /^([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)\s*([+-]\s*(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)\s*[ij]$/i;
+  const mFull = complexFull.exec(s);
+  if (mFull) {
+    const real = Number(mFull[1]);
+    const imag = Number(mFull[2].replace(/\s/g, ""));
+    if (!isNaN(real) && !isNaN(imag)) return real;
+  }
+  const pureImag = /^([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)\s*[ij]$/i;
+  const mImag = pureImag.exec(s);
+  if (mImag) {
+  }
+  const n = Number(s);
+  return isNaN(n) ? NaN : n;
+}
 registerIBuiltin({
   name: "str2double",
   resolve: (argTypes) => {
     if (argTypes.length !== 1) return null;
-    if (!isTextType(argTypes[0])) return null;
-    return {
-      outputTypes: [{ kind: "number" }],
-      apply: (args) => {
-        const s = toString(args[0]).trim();
-        return RTV.num(s === "" ? NaN : Number(s));
-      }
-    };
+    const t = argTypes[0];
+    if (isTextType(t)) {
+      return {
+        outputTypes: [{ kind: "number" }],
+        apply: (args) => RTV.num(str2doubleScalar(toString(args[0])))
+      };
+    }
+    if (t.kind === "cell") {
+      return {
+        outputTypes: [{ kind: "tensor", isComplex: false }],
+        apply: (args) => {
+          const cell = args[0];
+          if (typeof cell !== "object" || cell === null || cell.kind !== "cell")
+            throw new RuntimeError("str2double: expected cell array");
+          const c = cell;
+          const data = new FloatXArray(c.data.length);
+          for (let i = 0; i < c.data.length; i++) {
+            const el = c.data[i];
+            if (isRuntimeString(el) || isRuntimeChar(el)) {
+              data[i] = str2doubleScalar(toString(el));
+            } else {
+              data[i] = NaN;
+            }
+          }
+          return RTV.tensor(data, c.shape.slice());
+        }
+      };
+    }
+    return null;
   }
 });
 registerIBuiltin({
@@ -44569,13 +44629,20 @@ function getSourceLine(getSource, file, line) {
 }
 
 // src/numbl-core/version.ts
-var NUMBL_VERSION = "0.1.0";
+var NUMBL_VERSION = "0.1.1";
 
 // src/cli-repl.ts
 import { createInterface } from "readline";
-import { readFileSync as readFileSync2, readSync, writeFileSync, appendFileSync } from "fs";
-import { join as join2 } from "path";
-import { homedir } from "os";
+import {
+  openSync as openSync2,
+  closeSync as closeSync2,
+  readFileSync as readFileSync4,
+  readSync as readSync2,
+  writeFileSync as writeFileSync2,
+  appendFileSync
+} from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir2 } from "os";
 
 // src/numbl-core/jsUserFunctions.ts
 function funcNameFromFile(fileName) {
@@ -50309,681 +50376,239 @@ ${jitSections.join("\n\n")}` : "// interpreted mode \u2014 no JS generated";
   }
 }
 
-// src/cli-system.ts
-var NodeSystemAdapter = class {
-  getEnv(name) {
-    return process.env[name];
+// src/cli-fileio.ts
+import {
+  openSync,
+  closeSync,
+  readSync,
+  writeSync,
+  readFileSync as readFileSync3,
+  writeFileSync,
+  statSync as statSync2,
+  fstatSync,
+  mkdirSync,
+  unlinkSync,
+  readdirSync as readdirSync2,
+  rmSync,
+  rmdirSync
+} from "fs";
+import { inflateRawSync } from "zlib";
+import { execFileSync } from "child_process";
+import { homedir, tmpdir } from "os";
+import { join as join3, resolve, dirname, basename } from "path";
+
+// src/cli-scan.ts
+import { readFileSync as readFileSync2, readdirSync, statSync } from "fs";
+import { join as join2 } from "path";
+function scanMFiles(dirPath, excludeFile) {
+  const files = [];
+  let entries;
+  try {
+    entries = readdirSync(dirPath);
+  } catch {
+    return files;
   }
-  getAllEnv() {
-    const result = {};
-    for (const [k, v] of Object.entries(process.env)) {
-      if (v !== void 0) result[k] = v;
+  for (const entry of entries) {
+    const fullPath = join2(dirPath, entry);
+    if (excludeFile && fullPath === excludeFile) {
+      continue;
+    }
+    try {
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        if (entry.startsWith("@") || entry.startsWith("+") || entry === "private") {
+          files.push(...scanMFiles(fullPath, excludeFile));
+        }
+      } else if (stat.isFile() && (entry.endsWith(".m") || entry.endsWith(".js"))) {
+        const source = readFileSync2(fullPath, "utf-8");
+        files.push({
+          name: fullPath,
+          source
+        });
+      } else if (stat.isFile() && entry.endsWith(".wasm")) {
+        const data = readFileSync2(fullPath);
+        files.push({
+          name: fullPath,
+          source: "",
+          data: new Uint8Array(data)
+        });
+      }
+    } catch (err) {
+      console.warn(
+        `Warning: could not read ${fullPath}: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
-    return result;
-  }
-  setEnv(name, value) {
-    process.env[name] = value;
-  }
-  cwd() {
-    return process.cwd();
-  }
-  chdir(dir) {
-    process.chdir(dir);
-  }
-  platform() {
-    return process.platform;
-  }
-  arch() {
-    return process.arch;
   }
-};
+  return files;
+}
 
-// src/cli-repl.ts
-var HISTORY_FILE = join2(homedir(), ".numbl_history");
-var HISTORY_MAX = 1e3;
-function loadHistory() {
-  try {
-    const content = readFileSync2(HISTORY_FILE, "utf8");
-    return content.split("\n").filter((line) => line.length > 0).map((line) => line.replace(/\\n/g, "\n").replace(/\\\\/g, "\\"));
-  } catch {
-    return [];
+// src/cli-fileio.ts
+function expandTilde(filepath) {
+  if (filepath.startsWith("~/")) {
+    return join3(homedir(), filepath.slice(2));
   }
+  return filepath;
 }
-function saveHistoryEntry(entry, hist) {
-  try {
-    if (hist.length <= HISTORY_MAX) {
-      const encoded = entry.replace(/\\/g, "\\\\").replace(/\n/g, "\\n");
-      appendFileSync(HISTORY_FILE, encoded + "\n", "utf8");
-    } else {
-      const trimmed = hist.slice(-HISTORY_MAX);
-      const content = trimmed.map((e) => e.replace(/\\/g, "\\\\").replace(/\n/g, "\\n")).join("\n") + "\n";
-      writeFileSync(HISTORY_FILE, content, "utf8");
-    }
-  } catch {
+function permissionToFlags(permission) {
+  switch (permission) {
+    case "r":
+      return "r";
+    case "w":
+      return "w";
+    case "a":
+      return "a";
+    case "r+":
+      return "r+";
+    case "w+":
+      return "w+";
+    case "a+":
+      return "a+";
+    default:
+      return permission;
   }
 }
-async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths, nativeBridge2, optimization) {
-  let variableValues = {};
-  let holdState = false;
-  const workspaceFiles = [...initialWorkspaceFiles];
-  const searchPaths = [...initialSearchPaths ?? []];
-  const system = new NodeSystemAdapter();
-  const onInput = (prompt) => {
-    process.stdout.write(prompt);
-    const buf2 = Buffer.alloc(1);
-    let line = "";
-    while (true) {
-      const bytesRead = readSync(0, buf2, 0, 1, null);
-      if (bytesRead === 0) break;
-      const ch = buf2.toString("utf8");
-      if (ch === "\n") break;
-      if (ch === "\r") continue;
-      line += ch;
+var READ_CHUNK_SIZE = 8192;
+var NodeFileIOAdapter = class {
+  nextFid = 3;
+  // 0=stdin, 1=stdout, 2=stderr reserved
+  openFiles = /* @__PURE__ */ new Map();
+  fopen(filename, permission) {
+    try {
+      const flags = permissionToFlags(permission);
+      const fd = openSync(expandTilde(filename), flags);
+      const fid = this.nextFid++;
+      this.openFiles.set(fid, {
+        fd,
+        permission,
+        lastError: "",
+        buffer: "",
+        eof: false,
+        pos: 0
+      });
+      return fid;
+    } catch (e) {
+      return -1;
     }
-    return line;
-  };
-  console.log(
-    "numbl REPL \u2014 type 'exit' or press Ctrl+D to quit, Alt+Enter for new line"
-  );
-  if (!process.stdin.isTTY) {
-    const rl = createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      prompt: ">> "
-    });
-    rl.prompt();
-    for await (const line of rl) {
-      const trimmed = line.trim();
-      if (trimmed === "exit" || trimmed === "quit") break;
-      if (trimmed === "") {
-        rl.prompt();
-        continue;
-      }
-      try {
-        const result = executeCode(
-          trimmed,
-          {
-            displayResults: true,
-            onOutput: (text) => process.stdout.write(text),
-            onDrawnow,
-            onInput,
-            initialVariableValues: variableValues,
-            initialHoldState: holdState,
-            optimization,
-            system
-          },
-          workspaceFiles,
-          "repl",
-          searchPaths,
-          nativeBridge2
-        );
-        variableValues = result.variableValues;
-        holdState = result.holdState;
-        if (result.searchPaths) {
-          searchPaths.length = 0;
-          searchPaths.push(...result.searchPaths);
-          workspaceFiles.length = 0;
-          workspaceFiles.push(...result.workspaceFiles ?? []);
-        }
-        if (result.plotInstructions.length > 0 && onDrawnow) {
-          onDrawnow(result.plotInstructions);
+  }
+  fclose(fidOrAll) {
+    if (fidOrAll === "all") {
+      for (const [, entry2] of this.openFiles) {
+        try {
+          closeSync(entry2.fd);
+        } catch {
         }
-      } catch (error) {
-        const diags = diagnoseErrors(error, trimmed, "repl", workspaceFiles);
-        console.error(formatDiagnostics(diags));
       }
-      rl.prompt();
+      this.openFiles.clear();
+      return 0;
     }
-    console.log("");
-    process.exit(0);
-  }
-  const stdin = process.stdin;
-  const stdout = process.stdout;
-  stdin.setRawMode(true);
-  stdin.resume();
-  stdout.write("\x1B[?2004h");
-  const PS1 = ">> ";
-  const PS2 = "   ";
-  let buf = [""];
-  let row = 0;
-  let col = 0;
-  let sRow = 0;
-  const hist = loadHistory();
-  let hIdx = -1;
-  let hStash = "";
-  let hPrefix = "";
-  let pasting = false;
-  let pasteBuf = [];
-  let busy = false;
-  function display() {
-    if (sRow > 0) stdout.write(`\x1B[${sRow}A`);
-    stdout.write("\r\x1B[J");
-    for (let i = 0; i < buf.length; i++) {
-      stdout.write((i === 0 ? PS1 : PS2) + buf[i]);
-      if (i < buf.length - 1) stdout.write("\r\n");
+    const entry = this.openFiles.get(fidOrAll);
+    if (!entry) return -1;
+    try {
+      closeSync(entry.fd);
+    } catch {
+      return -1;
     }
-    const fromEnd = buf.length - 1 - row;
-    if (fromEnd > 0) stdout.write(`\x1B[${fromEnd}A`);
-    const pLen = row === 0 ? PS1.length : PS2.length;
-    stdout.write(`\x1B[${pLen + col + 1}G`);
-    sRow = row;
+    this.openFiles.delete(fidOrAll);
+    return 0;
   }
-  function resetInput() {
-    buf = [""];
-    row = col = sRow = 0;
-    hIdx = -1;
-    hStash = "";
-    hPrefix = "";
-    stdout.write(PS1);
+  fgetl(fid) {
+    const entry = this.getEntry(fid);
+    if (!entry) return -1;
+    return this.readLine(entry, false);
   }
-  function cleanup() {
-    stdout.write("\x1B[?2004l");
-    stdin.setRawMode(false);
-    stdin.pause();
+  fgets(fid) {
+    const entry = this.getEntry(fid);
+    if (!entry) return -1;
+    return this.readLine(entry, true);
   }
-  function insertNewline() {
-    const after = buf[row].slice(col);
-    buf[row] = buf[row].slice(0, col);
-    buf.splice(row + 1, 0, after);
-    row++;
-    col = 0;
-    display();
+  fileread(filename) {
+    return readFileSync3(expandTilde(filename), "utf-8");
   }
-  function exec2() {
-    const code = buf.join("\n").trim();
-    const below = buf.length - 1 - sRow;
-    if (below > 0) stdout.write(`\x1B[${below}B`);
-    stdout.write("\r\n");
-    sRow = 0;
-    if (!code) {
-      resetInput();
-      return;
+  feof(fid) {
+    const entry = this.getEntry(fid);
+    if (!entry) return 1;
+    if (entry.buffer.length > 0) return 0;
+    if (entry.eof) return 1;
+    const buf = Buffer.alloc(1);
+    try {
+      const bytesRead = readSync(entry.fd, buf, 0, 1, null);
+      if (bytesRead === 0) {
+        entry.eof = true;
+        return 1;
+      }
+      entry.buffer = buf.toString("utf-8", 0, bytesRead);
+      return 0;
+    } catch {
+      entry.eof = true;
+      return 1;
     }
-    if (code === "exit" || code === "quit") {
-      cleanup();
-      console.log("");
-      process.exit(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}`);
+    try {
+      writeSync(entry.fd, text);
+      entry.lastError = "";
+    } catch (e) {
+      entry.lastError = e instanceof Error ? e.message : String(e);
+      throw e;
     }
-    const entry = buf.join("\n");
-    hist.push(entry);
-    saveHistoryEntry(entry, hist);
-    hIdx = -1;
-    busy = true;
-    stdin.setRawMode(false);
+  }
+  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 buf = Buffer.alloc(count);
     try {
-      const result = executeCode(
-        code,
-        {
-          displayResults: true,
-          onOutput: (text) => stdout.write(text),
-          onDrawnow,
-          onInput,
-          initialVariableValues: variableValues,
-          initialHoldState: holdState,
-          optimization
-        },
-        workspaceFiles,
-        "repl",
-        searchPaths,
-        nativeBridge2
-      );
-      variableValues = result.variableValues;
-      holdState = result.holdState;
-      if (result.searchPaths) {
-        searchPaths.length = 0;
-        searchPaths.push(...result.searchPaths);
-        workspaceFiles.length = 0;
-        workspaceFiles.push(...result.workspaceFiles ?? []);
-      }
-      if (result.plotInstructions.length > 0 && onDrawnow) {
-        onDrawnow(result.plotInstructions);
-      }
-    } catch (error) {
-      const diags = diagnoseErrors(error, code, "repl", workspaceFiles);
-      console.error(formatDiagnostics(diags));
+      const bytesRead = readSync(entry.fd, buf, 0, count, entry.pos);
+      entry.pos += bytesRead;
+      if (bytesRead === 0) entry.eof = true;
+      else if (bytesRead < count) entry.eof = true;
+      entry.lastError = "";
+      return new Uint8Array(buf.buffer, buf.byteOffset, bytesRead);
+    } catch (e) {
+      entry.lastError = e instanceof Error ? e.message : String(e);
+      entry.eof = true;
+      return new Uint8Array(0);
     }
-    stdin.setRawMode(true);
-    busy = false;
-    resetInput();
   }
-  function handlePaste(text) {
-    text = text.replace(/(\r\n|\r|\n)$/, "");
-    const lines = text.split(/\r\n|\r|\n/);
-    if (lines.length === 1) {
-      buf[row] = buf[row].slice(0, col) + lines[0] + buf[row].slice(col);
-      col += lines[0].length;
-    } else {
-      const after = buf[row].slice(col);
-      buf[row] = buf[row].slice(0, col) + lines[0];
-      for (let j = 1; j < lines.length; j++) {
-        buf.splice(row + j, 0, lines[j]);
-      }
-      row += lines.length - 1;
-      col = buf[row].length;
-      buf[row] += after;
+  fwriteBytes(fid, data) {
+    const entry = this.getEntry(fid);
+    if (!entry) throw new Error(`Invalid file identifier: ${fid}`);
+    try {
+      const written = writeSync(entry.fd, data, 0, data.length, entry.pos);
+      entry.pos += written;
+      entry.lastError = "";
+      return written;
+    } catch (e) {
+      entry.lastError = e instanceof Error ? e.message : String(e);
+      throw e;
     }
-    display();
   }
-  function navHistory(dir) {
-    if (hist.length === 0) return;
-    if (hIdx === -1 && dir > 0) return;
-    if (hIdx === -1) {
-      hStash = buf.join("\n");
-      hPrefix = hStash;
-      if (hPrefix.length > 0) {
-        for (let k = hist.length - 1; k >= 0; k--) {
-          if (hist[k].startsWith(hPrefix)) {
-            hIdx = k;
-            break;
-          }
-        }
-        if (hIdx === -1) return;
-      } else {
-        hIdx = hist.length - 1;
-      }
-    } else {
-      let found = false;
-      if (dir < 0) {
-        for (let k = hIdx - 1; k >= 0; k--) {
-          if (hPrefix.length === 0 || hist[k].startsWith(hPrefix)) {
-            hIdx = k;
-            found = true;
-            break;
-          }
-        }
-        if (!found) return;
+  fseek(fid, offset, origin) {
+    const entry = this.getEntry(fid);
+    if (!entry) return -1;
+    entry.buffer = "";
+    entry.eof = false;
+    try {
+      if (origin === -1) {
+        entry.pos = offset;
+      } else if (origin === 0) {
+        entry.pos += offset;
       } else {
-        for (let k = hIdx + 1; k < hist.length; k++) {
-          if (hPrefix.length === 0 || hist[k].startsWith(hPrefix)) {
-            hIdx = k;
-            found = true;
-            break;
-          }
-        }
-        if (!found) {
-          buf = hStash.split("\n");
-          hIdx = -1;
-          row = buf.length - 1;
-          col = buf[row].length;
-          display();
-          return;
-        }
+        const size = fstatSync(entry.fd).size;
+        entry.pos = size + offset;
       }
-    }
-    buf = hist[hIdx].split("\n");
-    row = buf.length - 1;
-    col = buf[row].length;
-    display();
-  }
-  function handleCSI(seq) {
-    switch (seq) {
-      case "A":
-        if (buf.length > 1 && row > 0) {
-          row--;
-          col = Math.min(col, buf[row].length);
-          display();
-        } else {
-          navHistory(-1);
-        }
-        break;
-      case "B":
-        if (buf.length > 1 && row < buf.length - 1) {
-          row++;
-          col = Math.min(col, buf[row].length);
-          display();
-        } else {
-          navHistory(1);
-        }
-        break;
-      case "C":
-        if (col < buf[row].length) {
-          col++;
-          display();
-        } else if (row < buf.length - 1) {
-          row++;
-          col = 0;
-          display();
-        }
-        break;
-      case "D":
-        if (col > 0) {
-          col--;
-          display();
-        } else if (row > 0) {
-          row--;
-          col = buf[row].length;
-          display();
-        }
-        break;
-      case "H":
-      // Home
-      case "1~":
-        col = 0;
-        display();
-        break;
-      case "F":
-      // End
-      case "4~":
-        col = buf[row].length;
-        display();
-        break;
-      case "3~":
-        if (col < buf[row].length) {
-          buf[row] = buf[row].slice(0, col) + buf[row].slice(col + 1);
-          display();
-        } else if (row < buf.length - 1) {
-          buf[row] += buf[row + 1];
-          buf.splice(row + 1, 1);
-          display();
-        }
-        break;
-      case "13;2u":
-        insertNewline();
-        break;
-    }
-  }
-  resetInput();
-  return new Promise((resolve3) => {
-    stdin.on("data", (chunk) => {
-      if (busy) return;
-      const data = chunk.toString("utf8");
-      let i = 0;
-      while (i < data.length) {
-        if (busy) return;
-        if (data.startsWith("\x1B[200~", i)) {
-          pasting = true;
-          pasteBuf = [];
-          i += 6;
-          continue;
-        }
-        if (data.startsWith("\x1B[201~", i)) {
-          pasting = false;
-          handlePaste(pasteBuf.join(""));
-          i += 6;
-          continue;
-        }
-        if (pasting) {
-          const end = data.indexOf("\x1B[201~", i);
-          if (end >= 0) {
-            pasteBuf.push(data.slice(i, end));
-            pasting = false;
-            handlePaste(pasteBuf.join(""));
-            i = end + 6;
-          } else {
-            pasteBuf.push(data.slice(i));
-            i = data.length;
-          }
-          continue;
-        }
-        if (data[i] === "\x1B" && i + 1 < data.length && (data[i + 1] === "\r" || data[i + 1] === "\n")) {
-          insertNewline();
-          i += 2;
-          continue;
-        }
-        if (data.startsWith("\x1B[", i)) {
-          let j = i + 2;
-          while (j < data.length && (data.charCodeAt(j) < 64 || data.charCodeAt(j) > 126))
-            j++;
-          if (j >= data.length) {
-            i = data.length;
-            continue;
-          }
-          handleCSI(data.slice(i + 2, j + 1));
-          i = j + 1;
-          continue;
-        }
-        if (data[i] === "\x1B") {
-          i++;
-          continue;
-        }
-        const code = data.charCodeAt(i);
-        i++;
-        if (code === 13 || code === 10) {
-          try {
-            exec2();
-          } catch (err) {
-            console.error("Unexpected REPL error:", err);
-            busy = false;
-            resetInput();
-          }
-        } else if (code === 127 || code === 8) {
-          if (col > 0) {
-            buf[row] = buf[row].slice(0, col - 1) + buf[row].slice(col);
-            col--;
-            display();
-          } else if (row > 0) {
-            col = buf[row - 1].length;
-            buf[row - 1] += buf[row];
-            buf.splice(row, 1);
-            row--;
-            display();
-          }
-        } else if (code === 1) {
-          col = 0;
-          display();
-        } else if (code === 5) {
-          col = buf[row].length;
-          display();
-        } else if (code === 11) {
-          buf[row] = buf[row].slice(0, col);
-          display();
-        } else if (code === 21) {
-          buf[row] = buf[row].slice(col);
-          col = 0;
-          display();
-        } else if (code === 3) {
-          const below = buf.length - 1 - sRow;
-          if (below > 0) stdout.write(`\x1B[${below}B`);
-          stdout.write("\r\n^C\r\n");
-          sRow = 0;
-          resetInput();
-        } else if (code === 4) {
-          if (buf.length === 1 && buf[0] === "") {
-            stdout.write("\r\n");
-            cleanup();
-            resolve3();
-            return;
-          }
-        } else if (code === 12) {
-          stdout.write("\x1B[2J\x1B[H");
-          sRow = 0;
-          display();
-        } else if (code >= 32) {
-          buf[row] = buf[row].slice(0, col) + data[i - 1] + buf[row].slice(col);
-          col++;
-          display();
-        }
-      }
-    });
-  });
-}
-
-// src/cli-fileio.ts
-import {
-  openSync,
-  closeSync,
-  readSync as readSync2,
-  writeSync,
-  readFileSync as readFileSync3,
-  writeFileSync as writeFileSync2,
-  statSync,
-  fstatSync,
-  mkdirSync,
-  unlinkSync,
-  readdirSync,
-  rmSync,
-  rmdirSync
-} from "fs";
-import { inflateRawSync } from "zlib";
-import { execFileSync } from "child_process";
-import { homedir as homedir2, tmpdir } from "os";
-import { join as join3, resolve, dirname, basename } from "path";
-function expandTilde(filepath) {
-  if (filepath.startsWith("~/")) {
-    return join3(homedir2(), filepath.slice(2));
-  }
-  return filepath;
-}
-function permissionToFlags(permission) {
-  switch (permission) {
-    case "r":
-      return "r";
-    case "w":
-      return "w";
-    case "a":
-      return "a";
-    case "r+":
-      return "r+";
-    case "w+":
-      return "w+";
-    case "a+":
-      return "a+";
-    default:
-      return permission;
-  }
-}
-var READ_CHUNK_SIZE = 8192;
-var NodeFileIOAdapter = class {
-  nextFid = 3;
-  // 0=stdin, 1=stdout, 2=stderr reserved
-  openFiles = /* @__PURE__ */ new Map();
-  fopen(filename, permission) {
-    try {
-      const flags = permissionToFlags(permission);
-      const fd = openSync(expandTilde(filename), flags);
-      const fid = this.nextFid++;
-      this.openFiles.set(fid, {
-        fd,
-        permission,
-        lastError: "",
-        buffer: "",
-        eof: false,
-        pos: 0
-      });
-      return fid;
-    } catch (e) {
-      return -1;
-    }
-  }
-  fclose(fidOrAll) {
-    if (fidOrAll === "all") {
-      for (const [, entry2] of this.openFiles) {
-        try {
-          closeSync(entry2.fd);
-        } catch {
-        }
-      }
-      this.openFiles.clear();
-      return 0;
-    }
-    const entry = this.openFiles.get(fidOrAll);
-    if (!entry) return -1;
-    try {
-      closeSync(entry.fd);
-    } catch {
-      return -1;
-    }
-    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) {
-    return readFileSync3(expandTilde(filename), "utf-8");
-  }
-  feof(fid) {
-    const entry = this.getEntry(fid);
-    if (!entry) return 1;
-    if (entry.buffer.length > 0) return 0;
-    if (entry.eof) return 1;
-    const buf = Buffer.alloc(1);
-    try {
-      const bytesRead = readSync2(entry.fd, buf, 0, 1, null);
-      if (bytesRead === 0) {
-        entry.eof = true;
-        return 1;
-      }
-      entry.buffer = buf.toString("utf-8", 0, bytesRead);
-      return 0;
-    } catch {
-      entry.eof = true;
-      return 1;
-    }
-  }
-  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}`);
-    try {
-      writeSync(entry.fd, text);
-      entry.lastError = "";
-    } catch (e) {
-      entry.lastError = e instanceof Error ? e.message : String(e);
-      throw e;
-    }
-  }
-  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 buf = Buffer.alloc(count);
-    try {
-      const bytesRead = readSync2(entry.fd, buf, 0, count, entry.pos);
-      entry.pos += bytesRead;
-      if (bytesRead === 0) entry.eof = true;
-      else if (bytesRead < count) entry.eof = true;
-      entry.lastError = "";
-      return new Uint8Array(buf.buffer, buf.byteOffset, bytesRead);
-    } catch (e) {
-      entry.lastError = e instanceof Error ? e.message : String(e);
-      entry.eof = true;
-      return new Uint8Array(0);
-    }
-  }
-  fwriteBytes(fid, data) {
-    const entry = this.getEntry(fid);
-    if (!entry) throw new Error(`Invalid file identifier: ${fid}`);
-    try {
-      const written = writeSync(entry.fd, data, 0, data.length, entry.pos);
-      entry.pos += written;
-      entry.lastError = "";
-      return written;
-    } catch (e) {
-      entry.lastError = e instanceof Error ? e.message : String(e);
-      throw e;
-    }
-  }
-  fseek(fid, offset, origin) {
-    const entry = this.getEntry(fid);
-    if (!entry) return -1;
-    entry.buffer = "";
-    entry.eof = false;
-    try {
-      if (origin === -1) {
-        entry.pos = offset;
-      } else if (origin === 0) {
-        entry.pos += offset;
-      } else {
-        const size = fstatSync(entry.fd).size;
-        entry.pos = size + offset;
-      }
-      return 0;
-    } catch {
-      return -1;
+      return 0;
+    } catch {
+      return -1;
     }
   }
   ftell(fid) {
@@ -50999,7 +50624,7 @@ var NodeFileIOAdapter = class {
   }
   existsPath(path) {
     try {
-      const s = statSync(expandTilde(path));
+      const s = statSync2(expandTilde(path));
       return s.isDirectory() ? "dir" : "file";
     } catch {
       return null;
@@ -51077,7 +50702,7 @@ var NodeFileIOAdapter = class {
       );
       let entries;
       try {
-        entries = readdirSync(dir);
+        entries = readdirSync2(dir);
       } catch {
         return;
       }
@@ -51150,7 +50775,7 @@ var NodeFileIOAdapter = class {
       }
       const outPath = join3(dest, entryName);
       mkdirSync(dirname(outPath), { recursive: true });
-      writeFileSync2(outPath, fileData);
+      writeFileSync(outPath, fileData);
       extracted.push(outPath);
     }
     return extracted;
@@ -51164,7 +50789,7 @@ var NodeFileIOAdapter = class {
       return this.listDirGlob(p2);
     }
     try {
-      const s = statSync(p2);
+      const s = statSync2(p2);
       if (s.isDirectory()) {
         const absDir = resolve(p2);
         const results = [];
@@ -51176,7 +50801,7 @@ var NodeFileIOAdapter = class {
           mtimeMs: s.mtimeMs
         });
         try {
-          const parentStat = statSync(resolve(absDir, ".."));
+          const parentStat = statSync2(resolve(absDir, ".."));
           results.push({
             name: "..",
             folder: absDir,
@@ -51193,10 +50818,10 @@ var NodeFileIOAdapter = class {
             mtimeMs: 0
           });
         }
-        const entries = readdirSync(absDir);
+        const entries = readdirSync2(absDir);
         for (const entry of entries) {
           try {
-            const es = statSync(join3(absDir, entry));
+            const es = statSync2(join3(absDir, entry));
             results.push({
               name: entry,
               folder: absDir,
@@ -51238,14 +50863,14 @@ var NodeFileIOAdapter = class {
     const results = [];
     let entries;
     try {
-      entries = readdirSync(absDir);
+      entries = readdirSync2(absDir);
     } catch {
       return [];
     }
     for (const entry of entries) {
       if (re2.test(entry)) {
         try {
-          const es = statSync(join3(absDir, entry));
+          const es = statSync2(join3(absDir, entry));
           results.push({
             name: entry,
             folder: absDir,
@@ -51270,7 +50895,7 @@ var NodeFileIOAdapter = class {
     const results = [];
     const walkDir = (dir) => {
       try {
-        const ds = statSync(dir);
+        const ds = statSync2(dir);
         results.push({
           name: ".",
           folder: dir,
@@ -51288,7 +50913,7 @@ var NodeFileIOAdapter = class {
         });
       }
       try {
-        const ps = statSync(resolve(dir, ".."));
+        const ps = statSync2(resolve(dir, ".."));
         results.push({
           name: "..",
           folder: dir,
@@ -51307,14 +50932,14 @@ var NodeFileIOAdapter = class {
       }
       let entries;
       try {
-        entries = readdirSync(dir);
+        entries = readdirSync2(dir);
       } catch {
         return;
       }
       const subdirs = [];
       for (const entry of entries) {
         try {
-          const es = statSync(join3(dir, entry));
+          const es = statSync2(join3(dir, entry));
           results.push({
             name: entry,
             folder: dir,
@@ -51347,7 +50972,7 @@ var NodeFileIOAdapter = class {
       const buf = Buffer.alloc(READ_CHUNK_SIZE);
       let bytesRead;
       try {
-        bytesRead = readSync2(entry.fd, buf, 0, READ_CHUNK_SIZE, null);
+        bytesRead = readSync(entry.fd, buf, 0, READ_CHUNK_SIZE, null);
         entry.lastError = "";
       } catch (e) {
         entry.lastError = e instanceof Error ? e.message : String(e);
@@ -51375,11 +51000,573 @@ var NodeFileIOAdapter = class {
   }
 };
 
+// src/cli-system.ts
+var NodeSystemAdapter = class {
+  getEnv(name) {
+    return process.env[name];
+  }
+  getAllEnv() {
+    const result = {};
+    for (const [k, v] of Object.entries(process.env)) {
+      if (v !== void 0) result[k] = v;
+    }
+    return result;
+  }
+  setEnv(name, value) {
+    process.env[name] = value;
+  }
+  cwd() {
+    return process.cwd();
+  }
+  chdir(dir) {
+    process.chdir(dir);
+  }
+  platform() {
+    return process.platform;
+  }
+  arch() {
+    return process.arch;
+  }
+};
+
+// src/cli-repl.ts
+var HISTORY_FILE = join4(homedir2(), ".numbl_history");
+var HISTORY_MAX = 1e3;
+function loadHistory() {
+  try {
+    const content = readFileSync4(HISTORY_FILE, "utf8");
+    return content.split("\n").filter((line) => line.length > 0).map((line) => line.replace(/\\n/g, "\n").replace(/\\\\/g, "\\"));
+  } catch {
+    return [];
+  }
+}
+function saveHistoryEntry(entry, hist) {
+  try {
+    if (hist.length <= HISTORY_MAX) {
+      const encoded = entry.replace(/\\/g, "\\\\").replace(/\n/g, "\\n");
+      appendFileSync(HISTORY_FILE, encoded + "\n", "utf8");
+    } else {
+      const trimmed = hist.slice(-HISTORY_MAX);
+      const content = trimmed.map((e) => e.replace(/\\/g, "\\\\").replace(/\n/g, "\\n")).join("\n") + "\n";
+      writeFileSync2(HISTORY_FILE, content, "utf8");
+    }
+  } catch {
+  }
+}
+async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths, nativeBridge2, optimization) {
+  let variableValues = {};
+  let holdState = false;
+  const workspaceFiles = [...initialWorkspaceFiles];
+  const searchPaths = [...initialSearchPaths ?? []];
+  const fileIO = new NodeFileIOAdapter();
+  const system = new NodeSystemAdapter();
+  const onInput = (prompt) => {
+    process.stdout.write(prompt);
+    const ttyFd = openSync2("/dev/tty", "r");
+    try {
+      const buf2 = Buffer.alloc(1);
+      let line = "";
+      while (true) {
+        const bytesRead = readSync2(ttyFd, buf2, 0, 1, null);
+        if (bytesRead === 0) break;
+        const ch = buf2.toString("utf8");
+        if (ch === "\n") break;
+        if (ch === "\r") continue;
+        line += ch;
+      }
+      return line;
+    } finally {
+      closeSync2(ttyFd);
+    }
+  };
+  console.log(
+    "numbl REPL \u2014 type 'exit' or press Ctrl+D to quit, Alt+Enter for new line"
+  );
+  if (!process.stdin.isTTY) {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: ">> "
+    });
+    rl.prompt();
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      if (trimmed === "exit" || trimmed === "quit") break;
+      if (trimmed === "") {
+        rl.prompt();
+        continue;
+      }
+      try {
+        const result = executeCode(
+          trimmed,
+          {
+            displayResults: true,
+            onOutput: (text) => process.stdout.write(text),
+            onDrawnow,
+            onInput,
+            initialVariableValues: variableValues,
+            initialHoldState: holdState,
+            optimization,
+            fileIO,
+            system
+          },
+          workspaceFiles,
+          "repl",
+          searchPaths,
+          nativeBridge2
+        );
+        variableValues = result.variableValues;
+        holdState = result.holdState;
+        if (result.searchPaths) {
+          searchPaths.length = 0;
+          searchPaths.push(...result.searchPaths);
+          workspaceFiles.length = 0;
+          workspaceFiles.push(...result.workspaceFiles ?? []);
+        }
+        if (result.plotInstructions.length > 0 && onDrawnow) {
+          onDrawnow(result.plotInstructions);
+        }
+      } catch (error) {
+        const diags = diagnoseErrors(error, trimmed, "repl", workspaceFiles);
+        console.error(formatDiagnostics(diags));
+      }
+      rl.prompt();
+    }
+    console.log("");
+    process.exit(0);
+  }
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdout.write("\x1B[?2004h");
+  const PS1 = ">> ";
+  const PS2 = "   ";
+  let buf = [""];
+  let row = 0;
+  let col = 0;
+  let sRow = 0;
+  const hist = loadHistory();
+  let hIdx = -1;
+  let hStash = "";
+  let hPrefix = "";
+  let pasting = false;
+  let pasteBuf = [];
+  let busy = false;
+  function display() {
+    if (sRow > 0) stdout.write(`\x1B[${sRow}A`);
+    stdout.write("\r\x1B[J");
+    for (let i = 0; i < buf.length; i++) {
+      stdout.write((i === 0 ? PS1 : PS2) + buf[i]);
+      if (i < buf.length - 1) stdout.write("\r\n");
+    }
+    const fromEnd = buf.length - 1 - row;
+    if (fromEnd > 0) stdout.write(`\x1B[${fromEnd}A`);
+    const pLen = row === 0 ? PS1.length : PS2.length;
+    stdout.write(`\x1B[${pLen + col + 1}G`);
+    sRow = row;
+  }
+  function resetInput() {
+    buf = [""];
+    row = col = sRow = 0;
+    hIdx = -1;
+    hStash = "";
+    hPrefix = "";
+    stdout.write(PS1);
+  }
+  function cleanup() {
+    stdout.write("\x1B[?2004l");
+    stdin.setRawMode(false);
+    stdin.pause();
+  }
+  function insertNewline() {
+    const after = buf[row].slice(col);
+    buf[row] = buf[row].slice(0, col);
+    buf.splice(row + 1, 0, after);
+    row++;
+    col = 0;
+    display();
+  }
+  function exec2() {
+    const code = buf.join("\n").trim();
+    const below = buf.length - 1 - sRow;
+    if (below > 0) stdout.write(`\x1B[${below}B`);
+    stdout.write("\r\n");
+    sRow = 0;
+    if (!code) {
+      resetInput();
+      return;
+    }
+    if (code === "exit" || code === "quit") {
+      cleanup();
+      console.log("");
+      process.exit(0);
+    }
+    const entry = buf.join("\n");
+    hist.push(entry);
+    saveHistoryEntry(entry, hist);
+    hIdx = -1;
+    busy = true;
+    stdin.setRawMode(false);
+    stdin.pause();
+    try {
+      const result = executeCode(
+        code,
+        {
+          displayResults: true,
+          onOutput: (text) => stdout.write(text),
+          onDrawnow,
+          onInput,
+          initialVariableValues: variableValues,
+          initialHoldState: holdState,
+          optimization,
+          fileIO,
+          system
+        },
+        workspaceFiles,
+        "repl",
+        searchPaths,
+        nativeBridge2
+      );
+      variableValues = result.variableValues;
+      holdState = result.holdState;
+      if (result.searchPaths) {
+        searchPaths.length = 0;
+        searchPaths.push(...result.searchPaths);
+        workspaceFiles.length = 0;
+        workspaceFiles.push(...result.workspaceFiles ?? []);
+      }
+      if (result.plotInstructions.length > 0 && onDrawnow) {
+        onDrawnow(result.plotInstructions);
+      }
+    } catch (error) {
+      const diags = diagnoseErrors(error, code, "repl", workspaceFiles);
+      console.error(formatDiagnostics(diags));
+    }
+    stdin.resume();
+    stdin.setRawMode(true);
+    busy = false;
+    resetInput();
+  }
+  function handlePaste(text) {
+    text = text.replace(/(\r\n|\r|\n)$/, "");
+    const lines = text.split(/\r\n|\r|\n/);
+    if (lines.length === 1) {
+      buf[row] = buf[row].slice(0, col) + lines[0] + buf[row].slice(col);
+      col += lines[0].length;
+    } else {
+      const after = buf[row].slice(col);
+      buf[row] = buf[row].slice(0, col) + lines[0];
+      for (let j = 1; j < lines.length; j++) {
+        buf.splice(row + j, 0, lines[j]);
+      }
+      row += lines.length - 1;
+      col = buf[row].length;
+      buf[row] += after;
+    }
+    display();
+  }
+  function navHistory(dir) {
+    if (hist.length === 0) return;
+    if (hIdx === -1 && dir > 0) return;
+    if (hIdx === -1) {
+      hStash = buf.join("\n");
+      hPrefix = hStash;
+      if (hPrefix.length > 0) {
+        for (let k = hist.length - 1; k >= 0; k--) {
+          if (hist[k].startsWith(hPrefix)) {
+            hIdx = k;
+            break;
+          }
+        }
+        if (hIdx === -1) return;
+      } else {
+        hIdx = hist.length - 1;
+      }
+    } else {
+      let found = false;
+      if (dir < 0) {
+        for (let k = hIdx - 1; k >= 0; k--) {
+          if (hPrefix.length === 0 || hist[k].startsWith(hPrefix)) {
+            hIdx = k;
+            found = true;
+            break;
+          }
+        }
+        if (!found) return;
+      } else {
+        for (let k = hIdx + 1; k < hist.length; k++) {
+          if (hPrefix.length === 0 || hist[k].startsWith(hPrefix)) {
+            hIdx = k;
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          buf = hStash.split("\n");
+          hIdx = -1;
+          row = buf.length - 1;
+          col = buf[row].length;
+          display();
+          return;
+        }
+      }
+    }
+    buf = hist[hIdx].split("\n");
+    row = buf.length - 1;
+    col = buf[row].length;
+    display();
+  }
+  function handleCSI(seq) {
+    switch (seq) {
+      case "A":
+        if (buf.length > 1 && row > 0) {
+          row--;
+          col = Math.min(col, buf[row].length);
+          display();
+        } else {
+          navHistory(-1);
+        }
+        break;
+      case "B":
+        if (buf.length > 1 && row < buf.length - 1) {
+          row++;
+          col = Math.min(col, buf[row].length);
+          display();
+        } else {
+          navHistory(1);
+        }
+        break;
+      case "C":
+        if (col < buf[row].length) {
+          col++;
+          display();
+        } else if (row < buf.length - 1) {
+          row++;
+          col = 0;
+          display();
+        }
+        break;
+      case "D":
+        if (col > 0) {
+          col--;
+          display();
+        } else if (row > 0) {
+          row--;
+          col = buf[row].length;
+          display();
+        }
+        break;
+      case "H":
+      // Home
+      case "1~":
+        col = 0;
+        display();
+        break;
+      case "F":
+      // End
+      case "4~":
+        col = buf[row].length;
+        display();
+        break;
+      case "3~":
+        if (col < buf[row].length) {
+          buf[row] = buf[row].slice(0, col) + buf[row].slice(col + 1);
+          display();
+        } else if (row < buf.length - 1) {
+          buf[row] += buf[row + 1];
+          buf.splice(row + 1, 1);
+          display();
+        }
+        break;
+      case "13;2u":
+        insertNewline();
+        break;
+    }
+  }
+  resetInput();
+  return new Promise((resolve3) => {
+    stdin.on("data", (chunk) => {
+      if (busy) return;
+      const data = chunk.toString("utf8");
+      let i = 0;
+      while (i < data.length) {
+        if (busy) return;
+        if (data.startsWith("\x1B[200~", i)) {
+          pasting = true;
+          pasteBuf = [];
+          i += 6;
+          continue;
+        }
+        if (data.startsWith("\x1B[201~", i)) {
+          pasting = false;
+          handlePaste(pasteBuf.join(""));
+          i += 6;
+          continue;
+        }
+        if (pasting) {
+          const end = data.indexOf("\x1B[201~", i);
+          if (end >= 0) {
+            pasteBuf.push(data.slice(i, end));
+            pasting = false;
+            handlePaste(pasteBuf.join(""));
+            i = end + 6;
+          } else {
+            pasteBuf.push(data.slice(i));
+            i = data.length;
+          }
+          continue;
+        }
+        if (data[i] === "\x1B" && i + 1 < data.length && (data[i + 1] === "\r" || data[i + 1] === "\n")) {
+          insertNewline();
+          i += 2;
+          continue;
+        }
+        if (data.startsWith("\x1B[", i)) {
+          let j = i + 2;
+          while (j < data.length && (data.charCodeAt(j) < 64 || data.charCodeAt(j) > 126))
+            j++;
+          if (j >= data.length) {
+            i = data.length;
+            continue;
+          }
+          handleCSI(data.slice(i + 2, j + 1));
+          i = j + 1;
+          continue;
+        }
+        if (data[i] === "\x1B") {
+          i++;
+          continue;
+        }
+        const code = data.charCodeAt(i);
+        i++;
+        if (code === 13 || code === 10) {
+          try {
+            exec2();
+          } catch (err) {
+            console.error("Unexpected REPL error:", err);
+            busy = false;
+            resetInput();
+          }
+        } else if (code === 127 || code === 8) {
+          if (col > 0) {
+            buf[row] = buf[row].slice(0, col - 1) + buf[row].slice(col);
+            col--;
+            display();
+          } else if (row > 0) {
+            col = buf[row - 1].length;
+            buf[row - 1] += buf[row];
+            buf.splice(row, 1);
+            row--;
+            display();
+          }
+        } else if (code === 1) {
+          col = 0;
+          display();
+        } else if (code === 5) {
+          col = buf[row].length;
+          display();
+        } else if (code === 11) {
+          buf[row] = buf[row].slice(0, col);
+          display();
+        } else if (code === 21) {
+          buf[row] = buf[row].slice(col);
+          col = 0;
+          display();
+        } else if (code === 3) {
+          const below = buf.length - 1 - sRow;
+          if (below > 0) stdout.write(`\x1B[${below}B`);
+          stdout.write("\r\n^C\r\n");
+          sRow = 0;
+          resetInput();
+        } else if (code === 4) {
+          if (buf.length === 1 && buf[0] === "") {
+            stdout.write("\r\n");
+            cleanup();
+            resolve3();
+            return;
+          }
+        } else if (code === 12) {
+          stdout.write("\x1B[2J\x1B[H");
+          sRow = 0;
+          display();
+        } else if (code >= 32) {
+          buf[row] = buf[row].slice(0, col) + data[i - 1] + buf[row].slice(col);
+          col++;
+          display();
+        }
+      }
+    });
+  });
+}
+
+// src/vfs/unzipToFiles.ts
+import { inflateSync } from "fflate";
+var TEXT_DECODER = new TextDecoder("utf-8");
+function unzipToFiles(zipData) {
+  let eocdOffset = -1;
+  for (let i = zipData.length - 22; i >= 0; i--) {
+    if (zipData[i] === 80 && zipData[i + 1] === 75 && zipData[i + 2] === 5 && zipData[i + 3] === 6) {
+      eocdOffset = i;
+      break;
+    }
+  }
+  if (eocdOffset === -1) throw new Error("Invalid ZIP file");
+  const view = new DataView(
+    zipData.buffer,
+    zipData.byteOffset,
+    zipData.byteLength
+  );
+  const cdOffset = view.getUint32(eocdOffset + 16, true);
+  const cdEntries = view.getUint16(eocdOffset + 10, true);
+  const files = [];
+  let pos = cdOffset;
+  for (let i = 0; i < cdEntries; i++) {
+    if (view.getUint32(pos, true) !== 33639248) {
+      throw new Error("Corrupt ZIP central directory");
+    }
+    const method = view.getUint16(pos + 10, true);
+    const nameLen = view.getUint16(pos + 28, true);
+    const extraLen = view.getUint16(pos + 30, true);
+    const commentLen = view.getUint16(pos + 32, true);
+    const localHeaderOffset = view.getUint32(pos + 42, true);
+    const entryName = TEXT_DECODER.decode(
+      zipData.subarray(pos + 46, pos + 46 + nameLen)
+    );
+    pos += 46 + nameLen + extraLen + commentLen;
+    if (entryName.endsWith("/")) continue;
+    const localPos = localHeaderOffset;
+    if (view.getUint32(localPos, true) !== 67324752) {
+      throw new Error("Corrupt ZIP local header");
+    }
+    const localNameLen = view.getUint16(localPos + 26, true);
+    const localExtraLen = view.getUint16(localPos + 28, true);
+    const compressedSize = view.getUint32(localPos + 18, true);
+    const dataStart = localPos + 30 + localNameLen + localExtraLen;
+    const compressedData = zipData.subarray(
+      dataStart,
+      dataStart + compressedSize
+    );
+    let content;
+    if (method === 0) {
+      content = new Uint8Array(compressedData);
+    } else if (method === 8) {
+      content = inflateSync(compressedData);
+    } else {
+      throw new Error(
+        `Unsupported ZIP compression method ${method} for ${entryName}`
+      );
+    }
+    files.push({ path: entryName, content });
+  }
+  return files;
+}
+
 // src/cli.ts
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname = dirname2(__filename);
-var packageDir = join4(__dirname, "..");
-var addonPath = join4(packageDir, "build", "Release", "numbl_addon.node");
+var packageDir = join5(__dirname, "..");
+var addonPath = join5(packageDir, "build", "Release", "numbl_addon.node");
 var nativeAddonLoaded = false;
 if (!process.env.NUMBL_NO_NATIVE) {
   try {
@@ -51408,62 +51595,51 @@ try {
   nativeBridge = { load: (path) => koffi.load(path) };
 } catch {
 }
-function scanMFiles(dirPath, excludeFile) {
-  const files = [];
-  let entries;
-  try {
-    entries = readdirSync2(dirPath);
-  } catch {
-    return files;
+var MHL_URL = "https://github.com/mip-org/mip-core/releases/download/mip-main/mip-main-any.mhl";
+var mipCoreDir = join5(
+  homedir3(),
+  ".numbl",
+  "mip",
+  "packages",
+  "mip-org",
+  "core",
+  "mip"
+);
+var mipCoreSearchPath = join5(mipCoreDir, "mip");
+async function ensureMipCorePackage() {
+  if (existsSync2(join5(mipCoreSearchPath, "mip.m"))) return;
+  console.error("Installing mip core package...");
+  const resp = await fetch(MHL_URL);
+  if (!resp.ok) {
+    console.error(
+      `Warning: failed to download mip core package (HTTP ${resp.status})`
+    );
+    return;
   }
-  for (const entry of entries) {
-    const fullPath = join4(dirPath, entry);
-    if (excludeFile && fullPath === excludeFile) {
-      continue;
-    }
-    try {
-      const stat = statSync2(fullPath);
-      if (stat.isDirectory()) {
-        if (entry.startsWith("@") || entry.startsWith("+") || entry === "private") {
-          files.push(...scanMFiles(fullPath, excludeFile));
-        }
-      } else if (stat.isFile() && (entry.endsWith(".m") || entry.endsWith(".js"))) {
-        const source = readFileSync4(fullPath, "utf-8");
-        files.push({
-          name: fullPath,
-          source
-        });
-      } else if (stat.isFile() && entry.endsWith(".wasm")) {
-        const data = readFileSync4(fullPath);
-        files.push({
-          name: fullPath,
-          source: "",
-          data: new Uint8Array(data)
-        });
-      }
-    } catch (err) {
-      console.warn(
-        `Warning: could not read ${fullPath}: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
+  const buf = new Uint8Array(await resp.arrayBuffer());
+  const files = unzipToFiles(buf);
+  for (const f of files) {
+    const dest = join5(mipCoreDir, f.path);
+    mkdirSync2(dirname2(dest), { recursive: true });
+    writeFileSync3(dest, f.content);
   }
-  return files;
+  console.error("mip core package installed.");
 }
 function findTestFiles(dir) {
   const results = [];
   function walk(current) {
     let entries;
     try {
-      entries = readdirSync2(current);
+      entries = readdirSync3(current);
     } catch {
       return;
     }
     entries.sort();
     for (const entry of entries) {
-      const fullPath = join4(current, entry);
+      const fullPath = join5(current, entry);
       let stat;
       try {
-        stat = statSync2(fullPath);
+        stat = statSync3(fullPath);
       } catch {
         continue;
       }
@@ -51472,7 +51648,7 @@ function findTestFiles(dir) {
           walk(fullPath);
         }
       } else if (stat.isFile() && entry.endsWith(".m")) {
-        const content = readFileSync4(fullPath, "utf-8");
+        const content = readFileSync5(fullPath, "utf-8");
         if (content.includes("SUCCESS")) {
           results.push(fullPath);
         }
@@ -51514,7 +51690,7 @@ async function runTests(dir, optimization) {
   const failedScripts = [];
   for (const filepath of testFiles) {
     const rel = relative(process.cwd(), filepath);
-    const source = readFileSync4(filepath, "utf-8");
+    const source = readFileSync5(filepath, "utf-8");
     const mainFileName = filepath;
     const scriptDir = dirname2(filepath);
     const searchPaths = [scriptDir];
@@ -51729,8 +51905,9 @@ async function cmdRun(args) {
     console.error("Error: numbl run accepts only one file argument");
     process.exit(1);
   }
+  await ensureMipCorePackage();
   const filepath = resolve2(process.cwd(), opts.positional[0]);
-  const code = readFileSync4(filepath, "utf-8");
+  const code = readFileSync5(filepath, "utf-8");
   const mainFileName = filepath;
   const searchPaths = [];
   let workspaceFiles = [];
@@ -51743,6 +51920,10 @@ async function cmdRun(args) {
     searchPaths.push(p2);
     workspaceFiles.push(...scanMFiles(p2));
   }
+  if (existsSync2(mipCoreSearchPath)) {
+    searchPaths.push(mipCoreSearchPath);
+    workspaceFiles.push(...scanMFiles(mipCoreSearchPath));
+  }
   await executeWithOptions(
     code,
     mainFileName,
@@ -51761,12 +51942,17 @@ async function cmdEval(args) {
     console.error("Error: numbl eval accepts only one code argument");
     process.exit(1);
   }
+  await ensureMipCorePackage();
   const searchPaths = [];
   const workspaceFiles = [];
   for (const p2 of opts.extraPaths) {
     searchPaths.push(p2);
     workspaceFiles.push(...scanMFiles(p2));
   }
+  if (existsSync2(mipCoreSearchPath)) {
+    searchPaths.push(mipCoreSearchPath);
+    workspaceFiles.push(...scanMFiles(mipCoreSearchPath));
+  }
   await executeWithOptions(
     opts.positional[0],
     "eval.m",
@@ -51978,13 +52164,13 @@ function finalizeDumpFile(dumpFile, mainFileName, jsCode) {
   }
   let jitContent = "";
   try {
-    jitContent = readFileSync4(dumpFile, "utf-8");
+    jitContent = readFileSync5(dumpFile, "utf-8");
   } catch {
   }
   writeFileSync3(dumpFile, header + jsCode + "\n" + jitContent);
 }
 async function cmdBuildAddon() {
-  const bindingGyp = join4(packageDir, "binding.gyp");
+  const bindingGyp = join5(packageDir, "binding.gyp");
   if (!existsSync2(bindingGyp)) {
     console.error(
       "Error: binding.gyp not found in package directory: " + packageDir
@@ -52030,8 +52216,13 @@ function cmdListBuiltins() {
 }
 async function cmdRepl(args) {
   const opts = parseOptions(args);
+  await ensureMipCorePackage();
   const replSearchPaths = [...opts.extraPaths];
   const replFiles = opts.extraPaths.flatMap((d) => scanMFiles(d));
+  if (existsSync2(mipCoreSearchPath)) {
+    replSearchPaths.push(mipCoreSearchPath);
+    replFiles.push(...scanMFiles(mipCoreSearchPath));
+  }
   const replPlotOpts = opts.plotPort !== void 0 ? { port: opts.plotPort, host: "0.0.0.0" } : void 0;
   const { onDrawnow: replDrawnow } = createPlotHandler(
     !opts.plot,
@@ -52097,7 +52288,7 @@ function cmdShowProfile(args) {
     console.error(`Error: profile file not found: ${filepath}`);
     process.exit(1);
   }
-  const data = JSON.parse(readFileSync4(filepath, "utf-8"));
+  const data = JSON.parse(readFileSync5(filepath, "utf-8"));
   const fmt = (n, decimals = 1) => n.toFixed(decimals);
   const pad = (s, w) => s.padStart(w);
   const execTime = data.executionTimeMs || 1;
@@ -52179,7 +52370,7 @@ async function main() {
       break;
     case "run-tests": {
       const testOpts = parseOptions(rest);
-      const dir = testOpts.positional.length > 0 ? testOpts.positional[0] : join4(packageDir, "numbl_test_scripts");
+      const dir = testOpts.positional.length > 0 ? testOpts.positional[0] : join5(packageDir, "numbl_test_scripts");
       await runTests(dir, testOpts.optimization);
       break;
     }