numbl 0.4.11 → 0.4.13

package/dist-lib/node.js

@@ -0,0 +1,829 @@
+// src/cli-fileio.ts
+import {
+  openSync,
+  closeSync,
+  readSync,
+  writeSync,
+  readFileSync as readFileSync2,
+  writeFileSync,
+  statSync as statSync2,
+  fstatSync,
+  mkdirSync,
+  unlinkSync,
+  readdirSync as readdirSync2,
+  rmSync,
+  rmdirSync,
+  renameSync,
+  chmodSync,
+  realpathSync
+} from "fs";
+import { unzipSync, zipSync } from "fflate";
+import { execFileSync } from "child_process";
+import { homedir, tmpdir } from "os";
+import { join as join2, resolve, relative, dirname, basename } from "path";
+
+// src/cli-scan.ts
+import { readFileSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+function scanMFiles(dirPath, excludeFile) {
+  const files = [];
+  let entries;
+  try {
+    entries = readdirSync(dirPath);
+  } catch {
+    return files;
+  }
+  for (const entry of entries) {
+    const fullPath = join(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(".numbl.js"))) {
+        const source = readFileSync(fullPath, "utf-8");
+        files.push({
+          name: fullPath,
+          source
+        });
+      } else if (stat.isFile() && entry.endsWith(".wasm")) {
+        const data = readFileSync(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 files;
+}
+
+// src/cli-fileio.ts
+function expandTilde(filepath) {
+  if (filepath.startsWith("~/")) {
+    return join2(homedir(), filepath.slice(2));
+  }
+  return filepath;
+}
+function copyDirRecursive(src, dst) {
+  mkdirSync(dst, { recursive: true });
+  for (const entry of readdirSync2(src, { withFileTypes: true })) {
+    const s = join2(src, entry.name);
+    const d = join2(dst, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(s, d);
+    } else {
+      writeFileSync(d, readFileSync2(s));
+    }
+  }
+}
+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;
+function buildFetchOptions(options) {
+  const init = {};
+  if (options?.requestMethod) {
+    init.method = options.requestMethod.toUpperCase();
+  }
+  const headers = {};
+  if (options?.username && options?.password) {
+    headers["Authorization"] = "Basic " + Buffer.from(`${options.username}:${options.password}`).toString("base64");
+  }
+  if (options?.keyName && options?.keyValue) {
+    headers[options.keyName] = options.keyValue;
+  }
+  if (Object.keys(headers).length > 0) init.headers = headers;
+  return init;
+}
+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 readFileSync2(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 = readSync(entry.fd, buf, 0, 1, entry.pos);
+      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 = 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);
+    }
+  }
+  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;
+    }
+  }
+  ftell(fid) {
+    const entry = this.getEntry(fid);
+    if (!entry) return -1;
+    return entry.pos;
+  }
+  scanDirectory(dirPath) {
+    return scanMFiles(expandTilde(dirPath));
+  }
+  resolvePath(dirPath) {
+    return resolve(process.cwd(), expandTilde(dirPath));
+  }
+  existsPath(path) {
+    try {
+      const s = statSync2(expandTilde(path));
+      return s.isDirectory() ? "dir" : "file";
+    } catch {
+      return null;
+    }
+  }
+  mkdir(dirPath) {
+    try {
+      mkdirSync(expandTilde(dirPath), { recursive: true });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  tempdir() {
+    return tmpdir();
+  }
+  userpath() {
+    return join2(homedir(), ".numbl");
+  }
+  websave(url, filename, options) {
+    const dest = expandTilde(filename);
+    const timeoutMs = options?.timeout ? Math.round(options.timeout * 1e3) : 3e4;
+    const fetchOpts = buildFetchOptions(options);
+    const script = `
+      const ac = new AbortController();
+      const t = setTimeout(() => ac.abort(), ${timeoutMs});
+      fetch(${JSON.stringify(url)}, { ...${JSON.stringify(fetchOpts)}, signal: ac.signal })
+        .then(r => { clearTimeout(t); if (!r.ok) throw new Error('HTTP ' + r.status); return r.arrayBuffer(); })
+        .then(buf => require('fs').writeFileSync(${JSON.stringify(dest)}, Buffer.from(buf)))
+        .catch(e => { process.stderr.write(e.message + '\\n'); process.exit(1); });
+    `;
+    try {
+      execFileSync(process.execPath, ["-e", script], {
+        stdio: ["ignore", "ignore", "pipe"],
+        timeout: timeoutMs + 5e3
+      });
+    } catch (e) {
+      const msg = e instanceof Error && "stderr" in e ? e.stderr.toString().trim() : String(e);
+      throw new Error(`websave: failed to download ${url}: ${msg}`);
+    }
+  }
+  webread(url, options) {
+    const timeoutMs = options?.timeout ? Math.round(options.timeout * 1e3) : 3e4;
+    const fetchOpts = buildFetchOptions(options);
+    const script = `
+      const ac = new AbortController();
+      const t = setTimeout(() => ac.abort(), ${timeoutMs});
+      fetch(${JSON.stringify(url)}, { ...${JSON.stringify(fetchOpts)}, signal: ac.signal })
+        .then(r => { clearTimeout(t); if (!r.ok) throw new Error('HTTP ' + r.status); return r.text(); })
+        .then(t => process.stdout.write(t))
+        .catch(e => { process.stderr.write(e.message + '\\n'); process.exit(1); });
+    `;
+    try {
+      const result = execFileSync(process.execPath, ["-e", script], {
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: timeoutMs + 5e3,
+        maxBuffer: 50 * 1024 * 1024
+      });
+      return result.toString();
+    } catch (e) {
+      const msg = e instanceof Error && "stderr" in e ? e.stderr.toString().trim() : String(e);
+      throw new Error(`webread: failed to fetch ${url}: ${msg}`);
+    }
+  }
+  rmdir(dirPath, recursive) {
+    try {
+      const p = expandTilde(dirPath);
+      if (recursive) {
+        rmSync(p, { recursive: true });
+      } else {
+        rmdirSync(p);
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  movefile(source, destination, force) {
+    try {
+      const src = expandTilde(source);
+      const srcStat = statSync2(src);
+      let dst = expandTilde(destination);
+      let dstType = null;
+      try {
+        const s = statSync2(dst);
+        dstType = s.isDirectory() ? "dir" : "file";
+      } catch {
+        dstType = null;
+      }
+      if (dstType === "dir") {
+        dst = join2(dst, basename(src));
+        try {
+          dstType = statSync2(dst).isDirectory() ? "dir" : "file";
+        } catch {
+          dstType = null;
+        }
+      }
+      if (dstType === "file" && force) {
+        try {
+          chmodSync(dst, 438);
+        } catch {
+        }
+      }
+      if (srcStat.isDirectory() && dstType === "file") {
+        return false;
+      }
+      const parent = dirname(dst);
+      if (parent && parent !== "." && parent !== "/") {
+        try {
+          mkdirSync(parent, { recursive: true });
+        } catch {
+        }
+      }
+      try {
+        renameSync(src, dst);
+        return true;
+      } catch {
+        if (srcStat.isDirectory()) {
+          copyDirRecursive(src, dst);
+          rmSync(src, { recursive: true });
+        } else {
+          writeFileSync(dst, readFileSync2(src));
+          unlinkSync(src);
+        }
+        return true;
+      }
+    } catch {
+      return false;
+    }
+  }
+  copyfile(source, destination, force) {
+    try {
+      const src = expandTilde(source);
+      const srcStat = statSync2(src);
+      let dst = expandTilde(destination);
+      try {
+        if (statSync2(dst).isDirectory()) dst = join2(dst, basename(src));
+      } catch {
+      }
+      if (srcStat.isDirectory()) {
+        copyDirRecursive(src, dst);
+        return true;
+      }
+      const parent = dirname(dst);
+      if (parent && parent !== "." && parent !== "/") {
+        mkdirSync(parent, { recursive: true });
+      }
+      if (force) {
+        try {
+          chmodSync(dst, 438);
+        } catch {
+        }
+      }
+      writeFileSync(dst, readFileSync2(src));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  fileattrib(path) {
+    try {
+      const p = expandTilde(path);
+      const st = statSync2(p);
+      const mode = st.mode;
+      return {
+        Name: realpathSync(p),
+        directory: st.isDirectory(),
+        UserRead: (mode & 256) !== 0,
+        UserWrite: (mode & 128) !== 0,
+        UserExecute: (mode & 64) !== 0
+      };
+    } catch {
+      return null;
+    }
+  }
+  deleteFile(pattern) {
+    const p = expandTilde(pattern);
+    if (p.includes("*") || p.includes("?")) {
+      const lastSep = Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\"));
+      const dir = lastSep >= 0 ? p.slice(0, lastSep) : ".";
+      const globPat = lastSep >= 0 ? p.slice(lastSep + 1) : p;
+      const re = new RegExp(
+        "^" + globPat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
+      );
+      let entries;
+      try {
+        entries = readdirSync2(dir);
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (re.test(entry)) {
+          try {
+            unlinkSync(join2(dir, entry));
+          } catch {
+          }
+        }
+      }
+    } else {
+      try {
+        unlinkSync(p);
+      } catch {
+      }
+    }
+  }
+  unzip(zipfilename, outputfolder) {
+    const src = expandTilde(zipfilename);
+    const dest = resolve(expandTilde(outputfolder));
+    mkdirSync(dest, { recursive: true });
+    const buf = readFileSync2(src);
+    const files = unzipSync(
+      new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength)
+    );
+    const extracted = [];
+    for (const [entryName, data] of Object.entries(files)) {
+      if (entryName.endsWith("/")) {
+        mkdirSync(join2(dest, entryName), { recursive: true });
+        continue;
+      }
+      const outPath = join2(dest, entryName);
+      mkdirSync(dirname(outPath), { recursive: true });
+      writeFileSync(outPath, data);
+      extracted.push(outPath);
+    }
+    return extracted;
+  }
+  zip(zipfilename, filenames, rootDir) {
+    const root = resolve(expandTilde(rootDir));
+    const dest = resolve(expandTilde(zipfilename));
+    const entries = {};
+    const names = [];
+    const toEntryName = (abs) => {
+      const rel = relative(root, abs);
+      if (rel.startsWith("..")) return basename(abs);
+      return rel.split("\\").join("/");
+    };
+    const addFile = (abs) => {
+      const name = toEntryName(abs);
+      const buf = readFileSync2(abs);
+      entries[name] = new Uint8Array(
+        buf.buffer,
+        buf.byteOffset,
+        buf.byteLength
+      );
+      names.push(name);
+    };
+    const addDir = (absDir) => {
+      for (const entry of readdirSync2(absDir)) {
+        const abs = join2(absDir, entry);
+        let st;
+        try {
+          st = statSync2(abs);
+        } catch {
+          continue;
+        }
+        if (st.isDirectory()) addDir(abs);
+        else addFile(abs);
+      }
+    };
+    const addPath = (abs) => {
+      const st = statSync2(abs);
+      if (st.isDirectory()) addDir(abs);
+      else addFile(abs);
+    };
+    for (const f of filenames) {
+      const p = expandTilde(f);
+      const abs = resolve(root, p);
+      const last = basename(p);
+      if (last.includes("*") || last.includes("?")) {
+        const dir = dirname(abs);
+        const re = new RegExp(
+          "^" + last.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
+        );
+        let dirEntries;
+        try {
+          dirEntries = readdirSync2(dir);
+        } catch {
+          continue;
+        }
+        for (const entry of dirEntries) {
+          if (re.test(entry)) addPath(join2(dir, entry));
+        }
+      } else {
+        addPath(abs);
+      }
+    }
+    writeFileSync(dest, zipSync(entries));
+    return names;
+  }
+  listDir(dirPath) {
+    const p = expandTilde(dirPath);
+    if (p.includes("**")) {
+      return this.listDirRecursive(p);
+    }
+    if (p.includes("*") || p.includes("?")) {
+      return this.listDirGlob(p);
+    }
+    try {
+      const s = statSync2(p);
+      if (s.isDirectory()) {
+        const absDir = resolve(p);
+        const results = [];
+        results.push({
+          name: ".",
+          folder: absDir,
+          bytes: 0,
+          isdir: true,
+          mtimeMs: s.mtimeMs
+        });
+        try {
+          const parentStat = statSync2(resolve(absDir, ".."));
+          results.push({
+            name: "..",
+            folder: absDir,
+            bytes: 0,
+            isdir: true,
+            mtimeMs: parentStat.mtimeMs
+          });
+        } catch {
+          results.push({
+            name: "..",
+            folder: absDir,
+            bytes: 0,
+            isdir: true,
+            mtimeMs: 0
+          });
+        }
+        const entries = readdirSync2(absDir);
+        for (const entry of entries) {
+          try {
+            const es = statSync2(join2(absDir, entry));
+            results.push({
+              name: entry,
+              folder: absDir,
+              bytes: es.isDirectory() ? 0 : es.size,
+              isdir: es.isDirectory(),
+              mtimeMs: es.mtimeMs
+            });
+          } catch {
+          }
+        }
+        return results;
+      } else {
+        const absPath = resolve(p);
+        return [
+          {
+            name: basename(absPath),
+            folder: dirname(absPath),
+            bytes: s.size,
+            isdir: false,
+            mtimeMs: s.mtimeMs
+          }
+        ];
+      }
+    } catch {
+      return [];
+    }
+  }
+  listDirGlob(pattern) {
+    const lastSep = Math.max(
+      pattern.lastIndexOf("/"),
+      pattern.lastIndexOf("\\")
+    );
+    const dir = lastSep >= 0 ? pattern.slice(0, lastSep) : ".";
+    const globPat = lastSep >= 0 ? pattern.slice(lastSep + 1) : pattern;
+    const re = new RegExp(
+      "^" + globPat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
+    );
+    const absDir = resolve(dir);
+    const results = [];
+    let entries;
+    try {
+      entries = readdirSync2(absDir);
+    } catch {
+      return [];
+    }
+    for (const entry of entries) {
+      if (re.test(entry)) {
+        try {
+          const es = statSync2(join2(absDir, entry));
+          results.push({
+            name: entry,
+            folder: absDir,
+            bytes: es.isDirectory() ? 0 : es.size,
+            isdir: es.isDirectory(),
+            mtimeMs: es.mtimeMs
+          });
+        } catch {
+        }
+      }
+    }
+    return results;
+  }
+  listDirRecursive(pattern) {
+    const norm = pattern.replace(/\\/g, "/");
+    const idx = norm.indexOf("**");
+    let baseDir = norm.slice(0, idx);
+    if (baseDir.endsWith("/")) {
+      baseDir = baseDir.slice(0, -1);
+    }
+    if (!baseDir) baseDir = ".";
+    const absBase = resolve(baseDir);
+    try {
+      if (!statSync2(absBase).isDirectory()) return [];
+    } catch {
+      return [];
+    }
+    const suffix = norm.slice(idx);
+    const DIRS = "\0";
+    const ANY = "
";
+    const re = new RegExp(
+      "^" + suffix.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, DIRS).replace(/\*\*/g, ANY).replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(new RegExp(DIRS, "g"), "(?:.*/)?").replace(new RegExp(ANY, "g"), ".*") + "$"
+    );
+    const results = [];
+    const pushIfMatch = (rel, name, folder, bytes, isdir, mtimeMs) => {
+      if (re.test(rel)) results.push({ name, folder, bytes, isdir, mtimeMs });
+    };
+    const walkDir = (dir, rel) => {
+      const relPrefix = rel ? rel + "/" : "";
+      let dirMtime = 0;
+      try {
+        dirMtime = statSync2(dir).mtimeMs;
+      } catch {
+      }
+      pushIfMatch(relPrefix + ".", ".", dir, 0, true, dirMtime);
+      let parentMtime = 0;
+      try {
+        parentMtime = statSync2(resolve(dir, "..")).mtimeMs;
+      } catch {
+      }
+      pushIfMatch(relPrefix + "..", "..", dir, 0, true, parentMtime);
+      let entries;
+      try {
+        entries = readdirSync2(dir);
+      } catch {
+        return;
+      }
+      const subdirs = [];
+      for (const entry of entries) {
+        try {
+          const es = statSync2(join2(dir, entry));
+          pushIfMatch(
+            relPrefix + entry,
+            entry,
+            dir,
+            es.isDirectory() ? 0 : es.size,
+            es.isDirectory(),
+            es.mtimeMs
+          );
+          if (es.isDirectory()) subdirs.push(entry);
+        } catch {
+        }
+      }
+      for (const sub of subdirs) {
+        walkDir(join2(dir, sub), relPrefix + sub);
+      }
+    };
+    walkDir(absBase, "");
+    return results;
+  }
+  getEntry(fid) {
+    return this.openFiles.get(fid);
+  }
+  /**
+   * Read one line from the file's buffer, refilling from the fd as needed.
+   *
+   * All reads are positional so `entry.pos` stays the single source of truth
+   * for the logical file position: the buffer always holds the bytes starting
+   * at `entry.pos`, and consuming a line advances `entry.pos` by its byte
+   * length. This keeps text I/O (fgetl/fgets) coherent with binary I/O and
+   * fscanf (freadBytes/fseek/ftell).
+   * @param keepNewline - if true, keep the trailing newline (fgets); if false, strip it (fgetl)
+   */
+  readLine(entry, keepNewline) {
+    while (!entry.eof) {
+      const nlIdx2 = entry.buffer.indexOf("\n");
+      if (nlIdx2 !== -1) break;
+      const buf = Buffer.alloc(READ_CHUNK_SIZE);
+      let bytesRead;
+      try {
+        bytesRead = readSync(
+          entry.fd,
+          buf,
+          0,
+          READ_CHUNK_SIZE,
+          entry.pos + Buffer.byteLength(entry.buffer, "utf-8")
+        );
+        entry.lastError = "";
+      } catch (e) {
+        entry.lastError = e instanceof Error ? e.message : String(e);
+        entry.eof = true;
+        break;
+      }
+      if (bytesRead === 0) {
+        entry.eof = true;
+        break;
+      }
+      entry.buffer += buf.toString("utf-8", 0, bytesRead);
+    }
+    if (entry.buffer.length === 0) {
+      return -1;
+    }
+    const nlIdx = entry.buffer.indexOf("\n");
+    if (nlIdx !== -1) {
+      const consumed = entry.buffer.slice(0, nlIdx + 1);
+      const line2 = keepNewline ? consumed : entry.buffer.slice(0, nlIdx);
+      entry.buffer = entry.buffer.slice(nlIdx + 1);
+      entry.pos += Buffer.byteLength(consumed, "utf-8");
+      return line2;
+    }
+    const line = entry.buffer;
+    entry.buffer = "";
+    entry.pos += Buffer.byteLength(line, "utf-8");
+    return line;
+  }
+};
+
+// 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;
+  }
+};
+export {
+  NodeFileIOAdapter,
+  NodeSystemAdapter,
+  scanMFiles
+};