@lifo-sh/node-runner 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -20,7 +20,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  NodeRunner: () => NodeRunner
+  NodeRunner: () => NodeRunner,
+  ProcessExitError: () => ProcessExitError,
+  resolveModule: () => resolveModule,
+  shouldTreatAsEsm: () => shouldTreatAsEsm,
+  transformEsmToCjs: () => transformEsmToCjs,
+  transformToCjs: () => transformToCjs
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -78,19 +83,30 @@ var minimalPath = {
   posix: null
 };
 minimalPath.posix = minimalPath;
-function createScriptConsole(stdout, stderr) {
-  const format = (...args) => args.map(
+function formatArgs(...args) {
+  return args.map(
     (a) => typeof a === "string" ? a : JSON.stringify(a, null, 2) ?? String(a)
   ).join(" ");
+}
+function createCaptureConsole(stdout, stderr) {
+  return {
+    log: (...args) => stdout.push(formatArgs(...args)),
+    error: (...args) => stderr.push(formatArgs(...args)),
+    warn: (...args) => stderr.push(formatArgs(...args)),
+    info: (...args) => stdout.push(formatArgs(...args)),
+    debug: (...args) => stdout.push(formatArgs(...args))
+  };
+}
+function createStreamConsole(stdout, stderr) {
   return {
-    log: (...args) => stdout.push(format(...args)),
-    error: (...args) => stderr.push(format(...args)),
-    warn: (...args) => stderr.push(format(...args)),
-    info: (...args) => stdout.push(format(...args)),
-    debug: (...args) => stdout.push(format(...args))
+    log: (...args) => stdout.write(formatArgs(...args) + "\n"),
+    error: (...args) => stderr.write(formatArgs(...args) + "\n"),
+    warn: (...args) => stderr.write(formatArgs(...args) + "\n"),
+    info: (...args) => stdout.write(formatArgs(...args) + "\n"),
+    debug: (...args) => stdout.write(formatArgs(...args) + "\n")
   };
 }
-function createMinimalProcess(env, cwd, argv) {
+function createMinimalProcess(env, cwd, argv, stdout, stderr) {
   return {
     env,
     cwd: () => cwd,
@@ -105,12 +121,14 @@ function createMinimalProcess(env, cwd, argv) {
     pid: 1,
     ppid: 0,
     stdout: {
-      write: (_s) => {
+      write: (s) => {
+        if (stdout) stdout.write(String(s));
         return true;
       }
     },
     stderr: {
-      write: (_s) => {
+      write: (s) => {
+        if (stderr) stderr.write(String(s));
         return true;
       }
     },
@@ -128,13 +146,12 @@ var ProcessExitError = class extends Error {
     this.code = code;
   }
 };
-function createBuiltinModules(_vfs, env, cwd, argv, scriptConsole, nodeCompat) {
+function createBuiltinModules(_vfs, env, cwd, argv, scriptConsole, nodeCompat, stdout, stderr) {
   const builtins = /* @__PURE__ */ new Map();
   builtins.set("path", nodeCompat?.path ?? minimalPath);
-  const process = nodeCompat?.process ?? createMinimalProcess(env, cwd, argv);
+  const process = nodeCompat?.process ?? createMinimalProcess(env, cwd, argv, stdout, stderr);
   builtins.set("process", process);
-  const console_ = scriptConsole;
-  builtins.set("console", console_);
+  builtins.set("console", scriptConsole);
   if (nodeCompat?.fs) builtins.set("fs", nodeCompat.fs);
   if (nodeCompat?.fsPromises) builtins.set("fs/promises", nodeCompat.fsPromises);
   if (nodeCompat?.events) builtins.set("events", nodeCompat.events);
@@ -152,20 +169,40 @@ function createBuiltinModules(_vfs, env, cwd, argv, scriptConsole, nodeCompat) {
 // src/resolver.ts
 var textDecoder = new TextDecoder();
 function resolveModule(vfs, id, fromDir) {
-  const candidates = buildCandidates(id, fromDir);
-  for (const candidate of candidates) {
+  if (id.startsWith("#")) {
+    return resolvePackageImport(vfs, id, fromDir);
+  }
+  if (id.startsWith("./") || id.startsWith("../") || id.startsWith("/")) {
+    return resolveRelative(vfs, id, fromDir);
+  }
+  return resolveNodeModule(vfs, id, fromDir);
+}
+function resolveRelative(vfs, id, fromDir) {
+  const absPath = id.startsWith("/") ? id : normalizePath(fromDir + "/" + id);
+  return resolveFile(vfs, absPath);
+}
+function resolveFile(vfs, absPath) {
+  if (vfs.exists(absPath)) {
     try {
-      if (!vfs.existsSync(candidate)) continue;
-      const stat = vfs.statSync(candidate);
-      if (stat.isDirectory()) {
-        const fromPkg = tryPackageMain(vfs, candidate);
+      const stat = vfs.stat(absPath);
+      if (stat.type === "file") {
+        const source = textDecoder.decode(vfs.readFile(absPath));
+        return { path: absPath, source };
+      }
+      if (stat.type === "directory") {
+        const fromPkg = tryPackageMain(vfs, absPath);
         if (fromPkg) return fromPkg;
-        const fromIndex = tryIndexFile(vfs, candidate);
+        const fromIndex = tryIndexFile(vfs, absPath);
         if (fromIndex) return fromIndex;
-        continue;
       }
-      if (stat.isFile()) {
-        const source = textDecoder.decode(vfs.readFileSync(candidate));
+    } catch {
+    }
+  }
+  for (const ext of [".js", ".ts", ".mjs", ".json"]) {
+    const candidate = absPath + ext;
+    try {
+      if (vfs.exists(candidate) && vfs.stat(candidate).type === "file") {
+        const source = textDecoder.decode(vfs.readFile(candidate));
         return { path: candidate, source };
       }
     } catch {
@@ -173,33 +210,149 @@ function resolveModule(vfs, id, fromDir) {
   }
   return null;
 }
-function buildCandidates(id, fromDir) {
-  const candidates = [];
-  if (id.startsWith("./") || id.startsWith("../") || id.startsWith("/")) {
-    const resolved = id.startsWith("/") ? id : normalizePath(fromDir + "/" + id);
-    candidates.push(resolved);
-    candidates.push(resolved + ".js");
-    candidates.push(resolved + ".ts");
-    candidates.push(resolved + ".mjs");
-    candidates.push(resolved + ".json");
+function resolveNodeModule(vfs, name, fromDir) {
+  let packageName;
+  let subpath = null;
+  if (name.startsWith("@")) {
+    const parts = name.split("/");
+    if (parts.length < 2) return null;
+    packageName = parts[0] + "/" + parts[1];
+    if (parts.length > 2) subpath = parts.slice(2).join("/");
   } else {
-    let dir = fromDir;
-    while (true) {
-      candidates.push(normalizePath(dir + "/node_modules/" + id));
-      candidates.push(normalizePath(dir + "/node_modules/" + id + ".js"));
-      candidates.push(normalizePath(dir + "/node_modules/" + id + ".json"));
-      const parent = dir.slice(0, dir.lastIndexOf("/"));
-      if (parent === dir || parent === "") break;
-      dir = parent;
+    const slashIdx = name.indexOf("/");
+    if (slashIdx !== -1) {
+      packageName = name.slice(0, slashIdx);
+      subpath = name.slice(slashIdx + 1);
+    } else {
+      packageName = name;
+    }
+  }
+  let current = fromDir;
+  for (; ; ) {
+    const candidate = normalizePath(current + "/node_modules/" + packageName);
+    if (vfs.exists(candidate)) {
+      const resolved = resolvePackageEntry(vfs, candidate, subpath);
+      if (resolved) return resolved;
+    }
+    const parent = current.slice(0, current.lastIndexOf("/"));
+    if (parent === current || parent === "") break;
+    current = parent;
+  }
+  for (const globalDir of ["/usr/lib/node_modules", "/usr/share/pkg/node_modules"]) {
+    const candidate = normalizePath(globalDir + "/" + packageName);
+    if (vfs.exists(candidate)) {
+      const resolved = resolvePackageEntry(vfs, candidate, subpath);
+      if (resolved) return resolved;
     }
   }
-  return candidates;
+  return null;
+}
+function resolveExportsCondition(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const cond = value;
+    if (typeof cond.require === "string") return cond.require;
+    if (typeof cond.default === "string") return cond.default;
+    if (typeof cond.import === "string") return cond.import;
+    for (const key of Object.keys(cond)) {
+      if (key === "types") continue;
+      const nested = resolveExportsCondition(cond[key]);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+function resolvePackageEntry(vfs, pkgDir, subpath) {
+  const pkgJsonPath = pkgDir + "/package.json";
+  let pkgJson = null;
+  if (vfs.exists(pkgJsonPath)) {
+    try {
+      pkgJson = JSON.parse(textDecoder.decode(vfs.readFile(pkgJsonPath)));
+    } catch {
+    }
+  }
+  if (subpath) {
+    if (pkgJson?.exports && typeof pkgJson.exports === "object") {
+      const exportsMap = pkgJson.exports;
+      const key = "./" + subpath;
+      if (key in exportsMap) {
+        const target = resolveExportsCondition(exportsMap[key]);
+        if (target) {
+          const resolved = resolveFile(vfs, normalizePath(pkgDir + "/" + target));
+          if (resolved) return resolved;
+        }
+      }
+      for (const pattern of Object.keys(exportsMap)) {
+        if (pattern.endsWith("/*") && key.startsWith(pattern.slice(0, -1))) {
+          const targetPattern = resolveExportsCondition(exportsMap[pattern]);
+          if (targetPattern && targetPattern.endsWith("/*")) {
+            const suffix = key.slice(pattern.length - 1);
+            const target = targetPattern.slice(0, -1) + suffix;
+            const resolved = resolveFile(vfs, normalizePath(pkgDir + "/" + target));
+            if (resolved) return resolved;
+          }
+        }
+      }
+    }
+    return resolveFile(vfs, normalizePath(pkgDir + "/" + subpath));
+  }
+  if (pkgJson?.exports) {
+    const exportsVal = pkgJson.exports;
+    let rootExport = null;
+    if (typeof exportsVal === "string") {
+      rootExport = exportsVal;
+    } else if (typeof exportsVal === "object" && !Array.isArray(exportsVal)) {
+      const exportsMap = exportsVal;
+      rootExport = exportsMap["."] ?? null;
+      if (!rootExport && ("require" in exportsMap || "import" in exportsMap || "default" in exportsMap)) {
+        rootExport = exportsMap;
+      }
+    }
+    if (rootExport) {
+      const target = resolveExportsCondition(rootExport);
+      if (target) {
+        const resolved = resolveFile(vfs, normalizePath(pkgDir + "/" + target));
+        if (resolved) return resolved;
+      }
+    }
+  }
+  if (pkgJson?.main && typeof pkgJson.main === "string") {
+    const resolved = resolveFile(vfs, normalizePath(pkgDir + "/" + pkgJson.main));
+    if (resolved) return resolved;
+  }
+  return tryIndexFile(vfs, pkgDir);
+}
+function resolvePackageImport(vfs, name, fromDir) {
+  let current = fromDir;
+  for (; ; ) {
+    const pkgPath = current + "/package.json";
+    if (vfs.exists(pkgPath)) {
+      try {
+        const pkg = JSON.parse(textDecoder.decode(vfs.readFile(pkgPath)));
+        if (pkg.imports && typeof pkg.imports === "object") {
+          const importsMap = pkg.imports;
+          if (name in importsMap) {
+            const target = resolveExportsCondition(importsMap[name]);
+            if (target) {
+              return resolveFile(vfs, normalizePath(current + "/" + target));
+            }
+          }
+        }
+      } catch {
+      }
+      break;
+    }
+    const parent = current.slice(0, current.lastIndexOf("/"));
+    if (parent === current || parent === "") break;
+    current = parent;
+  }
+  return null;
 }
 function tryPackageMain(vfs, dirPath) {
   const pkgPath = dirPath + "/package.json";
   try {
-    if (!vfs.existsSync(pkgPath)) return null;
-    const raw = textDecoder.decode(vfs.readFileSync(pkgPath));
+    if (!vfs.exists(pkgPath)) return null;
+    const raw = textDecoder.decode(vfs.readFile(pkgPath));
     const pkg = JSON.parse(raw);
     const main = pkg.main || pkg.module || "index.js";
     return resolveModule(vfs, "./" + main, dirPath);
@@ -211,8 +364,8 @@ function tryIndexFile(vfs, dirPath) {
   for (const name of ["index.js", "index.ts", "index.mjs", "index.json"]) {
     const fullPath = dirPath + "/" + name;
     try {
-      if (!vfs.existsSync(fullPath)) continue;
-      const source = textDecoder.decode(vfs.readFileSync(fullPath));
+      if (!vfs.exists(fullPath)) continue;
+      const source = textDecoder.decode(vfs.readFile(fullPath));
       return { path: fullPath, source };
     } catch {
       continue;
@@ -230,20 +383,458 @@ function normalizePath(p) {
   return (p.startsWith("/") ? "/" : "") + result.join("/");
 }
 
+// src/transformer.ts
+var CJS_WRAPPER_PARAMS = /* @__PURE__ */ new Set([
+  "exports",
+  "require",
+  "module",
+  "__filename",
+  "__dirname",
+  "console",
+  "process",
+  "Buffer",
+  "setTimeout",
+  "setInterval",
+  "clearTimeout",
+  "clearInterval",
+  "global",
+  "__importMetaUrl",
+  "__importMeta",
+  "__importMetaResolve"
+]);
+function cjsDecl(name) {
+  return CJS_WRAPPER_PARAMS.has(name) ? "var" : "const";
+}
+function dirname(p) {
+  const idx = p.lastIndexOf("/");
+  if (idx === -1) return ".";
+  if (idx === 0) return "/";
+  return p.slice(0, idx);
+}
+function join(...parts) {
+  const joined = parts.join("/").replace(/\/+/g, "/");
+  return normalize(joined);
+}
+function extname(p) {
+  const base = p.slice(p.lastIndexOf("/") + 1);
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0) return "";
+  return base.slice(dot);
+}
+function normalize(p) {
+  const parts = p.split("/");
+  const result = [];
+  for (const part of parts) {
+    if (part === "..") result.pop();
+    else if (part !== "." && part !== "") result.push(part);
+  }
+  return (p.startsWith("/") ? "/" : "") + result.join("/");
+}
+function maskStringLiterals(src) {
+  const literals = [];
+  let masked = "";
+  let i = 0;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === "/" && i + 1 < src.length && src[i + 1] === "/") {
+      const nl = src.indexOf("\n", i);
+      const end = nl === -1 ? src.length : nl;
+      masked += src.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (ch === "/" && i + 1 < src.length && src[i + 1] === "*") {
+      const end = src.indexOf("*/", i + 2);
+      const close = end === -1 ? src.length : end + 2;
+      masked += src.slice(i, close);
+      i = close;
+      continue;
+    }
+    if (ch === "/" && i + 1 < src.length && src[i + 1] !== "/" && src[i + 1] !== "*") {
+      let k = i - 1;
+      while (k >= 0 && (src[k] === " " || src[k] === "	" || src[k] === "\n" || src[k] === "\r")) k--;
+      const prev = k >= 0 ? src[k] : "\0";
+      if ("\0=([{,;!&|^~?:+-*%<>/)]}".includes(prev) || k >= 1 && /\b(?:return|typeof|void|delete|throw|new|case|of|in|yield|await)\s*$/.test(src.slice(Math.max(0, k - 11), k + 1))) {
+        const regStart = i;
+        i++;
+        while (i < src.length && src[i] !== "\n") {
+          if (src[i] === "\\") {
+            i += 2;
+            continue;
+          }
+          if (src[i] === "/") {
+            i++;
+            break;
+          }
+          if (src[i] === "[") {
+            i++;
+            while (i < src.length && src[i] !== "]" && src[i] !== "\n") {
+              if (src[i] === "\\") i++;
+              i++;
+            }
+            if (i < src.length && src[i] === "]") i++;
+            continue;
+          }
+          i++;
+        }
+        while (i < src.length && /[gimsuyv]/.test(src[i])) i++;
+        masked += src.slice(regStart, i);
+        continue;
+      }
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const start = i;
+      const quote = ch;
+      i++;
+      while (i < src.length) {
+        if (src[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (src[i] === quote) {
+          i++;
+          break;
+        }
+        if (quote === "`" && src[i] === "$" && i + 1 < src.length && src[i + 1] === "{") {
+          let depth = 1;
+          i += 2;
+          while (i < src.length && depth > 0) {
+            if (src[i] === "{") depth++;
+            else if (src[i] === "}") depth--;
+            else if (src[i] === "\\") i++;
+            else if (src[i] === "'" || src[i] === '"') {
+              const q = src[i];
+              i++;
+              while (i < src.length && src[i] !== q) {
+                if (src[i] === "\\") i++;
+                i++;
+              }
+              if (i < src.length) i++;
+              continue;
+            } else if (src[i] === "`") {
+              i++;
+              while (i < src.length && src[i] !== "`") {
+                if (src[i] === "\\") i++;
+                i++;
+              }
+              if (i < src.length) i++;
+              continue;
+            }
+            i++;
+          }
+          continue;
+        }
+        i++;
+      }
+      const literal = src.slice(start, i);
+      const idx = literals.length;
+      literals.push(literal);
+      masked += quote + "__LIFO_S" + idx + "__" + quote;
+      continue;
+    }
+    masked += ch;
+    i++;
+  }
+  return { masked, literals };
+}
+function unmaskStringLiterals(src, literals) {
+  return src.replace(
+    /(['"`])__LIFO_S(\d+)__\1/g,
+    (_match, _quote, idxStr) => literals[parseInt(idxStr, 10)]
+  );
+}
+function isEsmSource(source) {
+  return /(?:^|\n|;)\s*(?:import\s*[\w{*('".]|export\s+|export\s*\{)/.test(source);
+}
+function shouldTreatAsEsm(source, filename, vfs) {
+  const ext = extname(filename);
+  if (ext === ".mjs") return true;
+  if (ext === ".cjs") return false;
+  if (vfs && ext === ".js") {
+    let dir = dirname(filename);
+    for (; ; ) {
+      const pkgPath = join(dir, "package.json");
+      if (vfs.exists(pkgPath)) {
+        try {
+          const pkg = JSON.parse(vfs.readFileString(pkgPath));
+          if (pkg.type === "module") return true;
+          if (pkg.type === "commonjs") return false;
+        } catch {
+        }
+        break;
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return isEsmSource(source);
+}
+function transformEsmToCjs(source) {
+  let result = source.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  result = result.split("import.meta.url").join("__importMetaUrl");
+  result = result.split("import.meta.dirname").join("__dirname");
+  result = result.split("import.meta.filename").join("__filename");
+  result = result.split("import.meta.require").join("require");
+  result = result.split("import.meta.resolve").join("__importMetaResolve");
+  result = result.split("import.meta").join("__importMeta");
+  const { masked, literals } = maskStringLiterals(result);
+  result = masked;
+  result = result.replace(
+    /;([ \t]*(?:import\s*[\w${*('".]|export[\s{*]))/g,
+    ";\n$1"
+  );
+  const trailingExports = [];
+  let hasDefaultExport = false;
+  let hasNamedExport = false;
+  const importSources = /* @__PURE__ */ new Map();
+  hasDefaultExport = /(?:^|\n)\s*export\s+default\s+/.test(result);
+  hasNamedExport = /(?:^|\n)\s*export\s+(?:const|let|var|function|class|\{|\*\s+from)/.test(result);
+  result = result.replace(/^[ \t]*import\s+type\s+.*?from\s+(['"`]).*?\1[ \t]*;?$/gm, "");
+  result = result.replace(/^[ \t]*export\s+type\s+\{[^}]*\}(?:\s+from\s+(['"`]).*?\1)?[ \t]*;?$/gm, "");
+  result = result.replace(/^[ \t]*export\s+type\s+\*\s+from\s+(['"`]).*?\1[ \t]*;?$/gm, "");
+  result = result.replace(
+    /(?:^|\n)([ \t]*)import\s+([\w$]+)\s*,\s*\{([^}]+)\}\s*from\s*(['"][^'"]+['"])[ \t]*;?/g,
+    (match, indent, defaultName, imports, mod) => {
+      if (imports.includes("${")) return match;
+      const tmp = "__mod_" + defaultName;
+      const mapped = imports.split(",").map((s) => {
+        const parts = s.trim().split(/\s+as\s+/);
+        const sourceProp = parts[0].trim();
+        const localName = parts.length === 2 ? parts[1].trim() : sourceProp;
+        if (localName) importSources.set(localName, { modRef: tmp, prop: sourceProp });
+        if (parts.length === 2) return `${sourceProp}: ${localName}`;
+        return sourceProp;
+      }).filter((s) => s).join(", ");
+      return `
+${indent}${cjsDecl(tmp)} ${tmp} = require(${mod});
+${indent}${cjsDecl(defaultName)} ${defaultName} = ${tmp}.default || ${tmp};
+${indent}const { ${mapped} } = ${tmp};`;
+    }
+  );
+  result = result.replace(
+    /(?:^|\n)([ \t]*)import\s+([\w$]+)\s*,\s*\*\s*as\s+([\w$]+)\s+from\s*(['"][^'"]+['"])[ \t]*;?/g,
+    (_match, indent, defaultName, nsName, mod) => {
+      return `
+${indent}${cjsDecl(nsName)} ${nsName} = require(${mod});
+${indent}${cjsDecl(defaultName)} ${defaultName} = ${nsName}.default || ${nsName};`;
+    }
+  );
+  result = result.replace(
+    /(?:^|\n)([ \t]*)import\s*\{([^}]+)\}\s*from\s*(['"][^'"]+['"])[ \t]*;?/g,
+    (match, indent, imports, mod) => {
+      if (imports.includes("${")) return match;
+      const modRef = "__imp_" + Math.random().toString(36).slice(2, 8);
+      const mapped = imports.split(",").map((s) => {
+        const parts = s.trim().split(/\s+as\s+/);
+        const sourceProp = parts[0].trim();
+        const localName = parts.length === 2 ? parts[1].trim() : sourceProp;
+        if (localName) importSources.set(localName, { modRef, prop: sourceProp });
+        if (parts.length === 2) return `${sourceProp}: ${localName}`;
+        return sourceProp;
+      }).filter((s) => s).join(", ");
+      return `
+${indent}const ${modRef} = require(${mod});
+${indent}const { ${mapped} } = ${modRef};`;
+    }
+  );
+  result = result.replace(
+    /(?:^|\n)([ \t]*)import\s*\*\s*as\s+([\w$]+)\s+from\s*(['"][^'"]+['"])[ \t]*;?/g,
+    (_match, indent, name, mod) => `
+${indent}${cjsDecl(name)} ${name} = require(${mod});`
+  );
+  result = result.replace(
+    /(?:^|\n)([ \t]*)import\s+([\w$]+)\s+from\s*(['"][^'"]+['"])[ \t]*;?/g,
+    (_match, indent, name, mod) => `
+${indent}${cjsDecl(name)} ${name} = require(${mod});`
+  );
+  result = result.replace(
+    /(?:^|\n)([ \t]*)import\s*(['"][^'"]+['"])[ \t]*;?/g,
+    (_match, indent, mod) => `
+${indent}require(${mod});`
+  );
+  result = result.replace(/(?:^|\n)[ \t]*export\s*\{\s*\}[ \t]*;?/g, "");
+  result = result.replace(
+    /(?:^|\n)([ \t]*)export\s*\*\s*from\s*(['"][^'"]+['"])[ \t]*;?/g,
+    (_match, indent, mod) => {
+      const tmpVar = "__star_" + Math.random().toString(36).slice(2, 8);
+      return `
+${indent}const ${tmpVar} = require(${mod});
+${indent}Object.keys(${tmpVar}).forEach(function(k) { if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, { get: function() { return ${tmpVar}[k]; }, enumerable: true, configurable: true }); });`;
+    }
+  );
+  result = result.replace(
+    /(?:^|\n)([ \t]*)export\s*\{([^}]+)\}\s*from\s*(['"][^'"]+['"])[ \t]*;?/g,
+    (match, indent, names, mod) => {
+      if (names.includes("${")) return match;
+      const tmpVar = "__re_" + Math.random().toString(36).slice(2, 8);
+      const assignments = names.split(",").map((s) => {
+        const parts = s.trim().split(/\s+as\s+/);
+        const local = parts[0].trim();
+        const exported = parts.length === 2 ? parts[1].trim() : local;
+        return `${indent}Object.defineProperty(exports, '${exported}', { get() { return ${tmpVar}.${local}; }, enumerable: true, configurable: true });`;
+      }).join("\n");
+      return `
+${indent}const ${tmpVar} = require(${mod});
+${assignments}`;
+    }
+  );
+  if (hasDefaultExport && hasNamedExport) {
+    result = result.replace(
+      /(?:^|\n)([ \t]*)export\s+default\s+/g,
+      (_match, indent) => `
+${indent}exports.default = `
+    );
+  } else {
+    result = result.replace(
+      /(?:^|\n)([ \t]*)export\s+default\s+/g,
+      (_match, indent) => `
+${indent}module.exports = `
+    );
+  }
+  result = result.replace(
+    /(?:^|\n)([ \t]*)export\s+(const|let|var)\s+([\w$]+)\s*=/g,
+    (match, indent, keyword, name) => {
+      if (match.includes("${")) return match;
+      return `
+${indent}${keyword} ${name} = exports.${name} =`;
+    }
+  );
+  result = result.replace(
+    /(?:^|\n)([ \t]*)export\s+(async\s+function\s+([\w$]+)|function\s+([\w$]+)|class\s+([\w$]+))/g,
+    (match, indent, decl, asyncFnName, fnName, className, offset) => {
+      const nextChar = result.charAt(offset + match.length);
+      if (nextChar === "{") return match;
+      const name = asyncFnName || fnName || className;
+      trailingExports.push(`exports.${name} = ${name};`);
+      return `
+${indent}${decl}`;
+    }
+  );
+  result = result.replace(
+    /(?:^|\n)([ \t]*)export\s*\{([^}]+)\}[ \t]*;?/g,
+    (match, _indent, names) => {
+      if (names.includes("${")) return match;
+      names.split(",").forEach((s) => {
+        const parts = s.trim().split(/\s+as\s+/);
+        const local = parts[0].trim();
+        const exported = parts.length === 2 ? parts[1].trim() : local;
+        if (!local) return;
+        const src = importSources.get(local);
+        if (src) {
+          trailingExports.push(`Object.defineProperty(exports, '${exported}', { get: function() { return ${src.modRef}.${src.prop}; }, enumerable: true, configurable: true });`);
+        } else {
+          trailingExports.push(`exports.${exported} = ${local};`);
+        }
+      });
+      return "";
+    }
+  );
+  result = result.replace(
+    /(?<!\.)(?<!\w)\bimport\s*\(\s*(['"][^'"]+['"])\s*\)/g,
+    (_match, mod) => `Promise.resolve(require(${mod}))`
+  );
+  {
+    let i = 0;
+    let out = "";
+    while (i < result.length) {
+      const importIdx = result.indexOf("import(", i);
+      if (importIdx === -1) {
+        out += result.slice(i);
+        break;
+      }
+      if (importIdx > 0 && /[\w$.]/.test(result[importIdx - 1])) {
+        out += result.slice(i, importIdx + 7);
+        i = importIdx + 7;
+        continue;
+      }
+      {
+        let depth2 = 1;
+        let k = importIdx + 7;
+        while (k < result.length && depth2 > 0) {
+          if (result[k] === "(") depth2++;
+          else if (result[k] === ")") depth2--;
+          k++;
+        }
+        if (depth2 === 0) {
+          let afterClose = k;
+          while (afterClose < result.length && /[ \t]/.test(result[afterClose])) afterClose++;
+          if (result[afterClose] === "{") {
+            out += result.slice(i, importIdx + 7);
+            i = importIdx + 7;
+            continue;
+          }
+        }
+      }
+      out += result.slice(i, importIdx);
+      let depth = 1;
+      let j = importIdx + 7;
+      while (j < result.length && depth > 0) {
+        if (result[j] === "(") depth++;
+        else if (result[j] === ")") depth--;
+        j++;
+      }
+      if (depth === 0) {
+        const arg = result.slice(importIdx + 7, j - 1);
+        out += `Promise.resolve().then(function() { return require(${arg}); })`;
+      } else {
+        out += result.slice(importIdx, j);
+      }
+      i = j;
+    }
+    result = out;
+  }
+  result = result.replace(
+    /\b(const|let)\s+(__dirname|__filename|exports|require|module|console|process|Buffer|global)\b/g,
+    (_match, _kw, name) => `var ${name}`
+  );
+  if (trailingExports.length > 0) {
+    result += "\n" + trailingExports.join("\n");
+  }
+  result = unmaskStringLiterals(result, literals);
+  return result;
+}
+function transformToCjs(source, filename, vfs) {
+  if (shouldTreatAsEsm(source, filename, vfs)) {
+    return { code: transformEsmToCjs(source), wasEsm: true };
+  }
+  return { code: source, wasEsm: false };
+}
+
 // src/runner.ts
 var textEncoder = new TextEncoder();
+function stripShebang(src) {
+  if (src.charCodeAt(0) === 35 && src.charCodeAt(1) === 33) {
+    const nl = src.indexOf("\n");
+    if (nl === -1) return "";
+    return "\n" + src.slice(nl + 1);
+  }
+  return src;
+}
 var NodeRunner = class {
   vfs;
+  moduleMapFactory;
   nodeCompat;
   env;
   cwd;
   argv;
+  stdout;
+  stderr;
+  signal;
+  globalShims;
+  /** Module cache from the last execution. Can be inspected by the caller. */
+  moduleCache = /* @__PURE__ */ new Map();
   constructor(options) {
-    this.vfs = options.vfs ?? (0, import_vfs.createVFS)();
+    this.vfs = options.vfs ?? new import_vfs.VFS();
+    this.moduleMapFactory = options.moduleMap;
     this.nodeCompat = options.nodeCompat;
     this.env = options.env ?? {};
     this.cwd = options.cwd ?? "/";
     this.argv = options.argv ?? [];
+    this.stdout = options.stdout;
+    this.stderr = options.stderr;
+    this.signal = options.signal;
+    this.globalShims = options.globalShims;
     if (options.files) {
       this.writeFilesSync(options.files);
     }
@@ -255,26 +846,16 @@ var NodeRunner = class {
       for (let i = 1; i < parts.length; i++) {
         const dir = "/" + parts.slice(0, i).join("/");
         try {
-          this.vfs.mkdirSync(dir);
+          this.vfs.mkdir(dir);
         } catch {
         }
       }
-      this.vfs.writeFileSync(filePath, textEncoder.encode(content));
+      this.vfs.writeFile(filePath, textEncoder.encode(content));
     }
   }
-  /** Write files to the VFS asynchronously (persists to IndexedDB backend) */
+  /** Write files to the VFS asynchronously (for IndexedDB-backed VFS) */
   async writeFiles(files) {
-    for (const [filePath, content] of Object.entries(files)) {
-      const parts = filePath.split("/").filter(Boolean);
-      for (let i = 1; i < parts.length; i++) {
-        const dir = "/" + parts.slice(0, i).join("/");
-        try {
-          await this.vfs.mkdir(dir);
-        } catch {
-        }
-      }
-      await this.vfs.writeFile(filePath, textEncoder.encode(content));
-    }
+    this.writeFilesSync(files);
   }
   /** Run a script file from the VFS, resolving extensions and index files */
   async runFile(filePath) {
@@ -283,10 +864,14 @@ var NodeRunner = class {
     const id = absPath.startsWith("/") ? absPath : "./" + absPath;
     const resolved = resolveModule(this.vfs, id, scriptDir);
     if (!resolved) {
+      const msg = `Error: ENOENT: no such file or directory, open '${absPath}'`;
+      if (this.stderr) {
+        this.stderr.write(msg + "\n");
+      }
       return {
         exitCode: 1,
         stdout: "",
-        stderr: `Error: ENOENT: no such file or directory, open '${absPath}'`
+        stderr: this.stderr ? "" : msg
       };
     }
     return this.execute(resolved.source, resolved.path);
@@ -301,117 +886,349 @@ var NodeRunner = class {
     this.writeFilesSync({ [filePath]: source });
     return this.runFile(filePath);
   }
-  execute(source, absPath) {
+  async execute(source, absPath) {
+    this.moduleCache.clear();
     const stdoutLines = [];
     const stderrLines = [];
-    const scriptConsole = createScriptConsole(stdoutLines, stderrLines);
-    const builtins = createBuiltinModules(
-      this.vfs,
+    const scriptConsole = this.stdout && this.stderr ? createStreamConsole(this.stdout, this.stderr) : this.stdout ? createStreamConsole(this.stdout, { write: (s) => stderrLines.push(s) }) : this.stderr ? createStreamConsole({ write: (s) => stdoutLines.push(s) }, this.stderr) : createCaptureConsole(stdoutLines, stderrLines);
+    const isStreaming = !!(this.stdout || this.stderr);
+    let getBuiltin;
+    if (this.moduleMapFactory) {
+      const moduleMap = this.moduleMapFactory;
+      getBuiltin = (id) => {
+        const name = id.startsWith("node:") ? id.slice(5) : id;
+        if (name in moduleMap) {
+          if (this.moduleCache.has(name)) return this.moduleCache.get(name);
+          const mod = moduleMap[name]();
+          this.moduleCache.set(name, mod);
+          return mod;
+        }
+        return void 0;
+      };
+    } else {
+      const builtins = createBuiltinModules(
+        this.vfs,
+        this.env,
+        this.cwd,
+        [absPath, ...this.argv],
+        scriptConsole,
+        this.nodeCompat,
+        this.stdout,
+        this.stderr
+      );
+      getBuiltin = (id) => {
+        const name = id.startsWith("node:") ? id.slice(5) : id;
+        return builtins.has(name) ? builtins.get(name) : void 0;
+      };
+    }
+    const processObj = getBuiltin("process") ?? createMinimalProcess(
       this.env,
       this.cwd,
       [absPath, ...this.argv],
-      scriptConsole,
-      this.nodeCompat
+      this.stdout,
+      this.stderr
     );
-    const moduleCache = /* @__PURE__ */ new Map();
+    const bufferObj = getBuiltin("buffer");
+    const BufferClass = bufferObj && typeof bufferObj === "object" && "Buffer" in bufferObj ? bufferObj.Buffer : void 0;
+    const pObj = processObj;
+    if (pObj.stdout && typeof pObj.stdout === "object") {
+      const pStdout = pObj.stdout;
+      if (this.stdout) {
+        pStdout.write = (s) => {
+          this.stdout.write(String(s));
+          return true;
+        };
+      } else {
+        pStdout.write = (s) => {
+          stdoutLines.push(String(s));
+          return true;
+        };
+      }
+    }
+    if (pObj.stderr && typeof pObj.stderr === "object") {
+      const pStderr = pObj.stderr;
+      if (this.stderr) {
+        pStderr.write = (s) => {
+          this.stderr.write(String(s));
+          return true;
+        };
+      } else {
+        pStderr.write = (s) => {
+          stderrLines.push(String(s));
+          return true;
+        };
+      }
+    }
+    const self = this;
     const createRequire = (fromDir) => {
-      const require2 = (id) => {
-        if (builtins.has(id)) return builtins.get(id);
-        const resolved = resolveModule(this.vfs, id, fromDir);
+      const require3 = (id) => {
+        const name = id.startsWith("node:") ? id.slice(5) : id;
+        const builtin = getBuiltin(name);
+        if (builtin !== void 0) return builtin;
+        const resolved = resolveModule(self.vfs, id, fromDir);
         if (!resolved) {
           throw new Error(`Cannot find module '${id}'`);
         }
-        if (moduleCache.has(resolved.path)) {
-          return moduleCache.get(resolved.path);
+        if (self.moduleCache.has(resolved.path)) {
+          return self.moduleCache.get(resolved.path);
         }
         if (resolved.path.endsWith(".json")) {
           const json = JSON.parse(resolved.source);
-          moduleCache.set(resolved.path, json);
+          self.moduleCache.set(resolved.path, json);
           return json;
         }
-        const moduleExports = {};
-        const moduleObj = { exports: moduleExports };
-        moduleCache.set(resolved.path, moduleExports);
-        const moduleDir = resolved.path.slice(
-          0,
-          resolved.path.lastIndexOf("/")
-        );
+        const moduleExports2 = {};
+        const moduleObj2 = { exports: moduleExports2 };
+        self.moduleCache.set(resolved.path, moduleExports2);
+        const moduleDir = resolved.path.slice(0, resolved.path.lastIndexOf("/"));
         const childRequire = createRequire(moduleDir);
-        const factory = compileModule(resolved.source, resolved.path);
-        factory(
-          moduleObj.exports,
-          childRequire,
-          moduleObj,
-          resolved.path,
-          moduleDir,
-          scriptConsole,
-          builtins.get("process")
-        );
-        moduleCache.set(resolved.path, moduleObj.exports);
-        return moduleObj.exports;
+        let cleanSource = stripShebang(resolved.source);
+        const { code: cjsSource } = transformToCjs(cleanSource, resolved.path, self.vfs);
+        cleanSource = cjsSource;
+        const factory = compileModule(cleanSource, resolved.path, self.stderr);
+        const importMetaUrl = "file://" + resolved.path;
+        const importMeta = { url: importMetaUrl, dirname: moduleDir, filename: resolved.path };
+        const importMetaResolve = (specifier) => {
+          throw new Error(`import.meta.resolve('${specifier}') is not supported`);
+        };
+        const global2 = { process: processObj, Buffer: BufferClass, console: scriptConsole };
+        const ga2 = globalThis;
+        const isRealNode2 = typeof ga2.process?.pid === "number";
+        const saved2 = {};
+        if (!isRealNode2) {
+          saved2.process = ga2.process;
+          ga2.process = processObj;
+          saved2.Buffer = ga2.Buffer;
+          if (BufferClass) ga2.Buffer = BufferClass;
+          saved2.console = ga2.console;
+          ga2.console = scriptConsole;
+        }
+        const savedShims2 = {};
+        if (self.globalShims) {
+          for (const k of Object.keys(self.globalShims)) {
+            savedShims2[k] = ga2[k];
+            ga2[k] = self.globalShims[k];
+          }
+        }
+        try {
+          factory(
+            moduleObj2.exports,
+            childRequire,
+            moduleObj2,
+            resolved.path,
+            moduleDir,
+            scriptConsole,
+            processObj,
+            BufferClass,
+            globalThis.setTimeout,
+            globalThis.setInterval,
+            globalThis.clearTimeout,
+            globalThis.clearInterval,
+            global2,
+            importMetaUrl,
+            importMeta,
+            importMetaResolve
+          );
+        } catch (e) {
+          if (e instanceof ProcessExitError) throw e;
+          const err = e instanceof Error ? e : new Error(String(e));
+          if (!err.message.includes("[/")) {
+            err.message = `[${resolved.path}] ${err.message}`;
+          }
+          throw err;
+        } finally {
+          if (self.globalShims) {
+            for (const k of Object.keys(savedShims2)) ga2[k] = savedShims2[k];
+          }
+          if (!isRealNode2) {
+            ga2.process = saved2.process;
+            ga2.Buffer = saved2.Buffer;
+            ga2.console = saved2.console;
+          }
+        }
+        if (moduleObj2.exports !== moduleExports2) {
+          self.moduleCache.set(resolved.path, moduleObj2.exports);
+        }
+        return moduleObj2.exports;
       };
-      require2.resolve = (id) => {
-        if (builtins.has(id)) return id;
-        const resolved = resolveModule(this.vfs, id, fromDir);
+      require3.resolve = (id) => {
+        const name = id.startsWith("node:") ? id.slice(5) : id;
+        if (getBuiltin(name) !== void 0) return id;
+        const resolved = resolveModule(self.vfs, id, fromDir);
         if (!resolved) throw new Error(`Cannot find module '${id}'`);
         return resolved.path;
       };
-      return require2;
+      return require3;
     };
+    if (this.moduleMapFactory) {
+      const moduleMap = this.moduleMapFactory;
+      moduleMap.module = () => {
+        const makeCreateRequire = (_filename) => {
+          const dir = typeof _filename === "string" ? _filename.slice(0, _filename.lastIndexOf("/")) || "/" : "/";
+          return createRequire(dir);
+        };
+        const builtinNames = Object.keys(moduleMap);
+        const isBuiltin = (s) => {
+          const n = s.startsWith("node:") ? s.slice(5) : s;
+          return builtinNames.includes(n);
+        };
+        return { createRequire: makeCreateRequire, builtinModules: builtinNames, isBuiltin, default: { createRequire: makeCreateRequire } };
+      };
+    }
     let exitCode = 0;
+    let cleanMainSource = stripShebang(source);
+    const { code: cjsMainSource, wasEsm: isEsm } = transformToCjs(cleanMainSource, absPath, this.vfs);
+    cleanMainSource = cjsMainSource;
+    const wrapped = isEsm ? `(async function(exports, require, module, __filename, __dirname, console, process, Buffer, setTimeout, setInterval, clearTimeout, clearInterval, global, __importMetaUrl, __importMeta, __importMetaResolve) {
+${cleanMainSource}
+})` : `(function(exports, require, module, __filename, __dirname, console, process, Buffer, setTimeout, setInterval, clearTimeout, clearInterval, global, __importMetaUrl, __importMeta, __importMetaResolve) {
+${cleanMainSource}
+})`;
+    const scriptDir = absPath.slice(0, absPath.lastIndexOf("/")) || "/";
+    const require2 = createRequire(scriptDir);
+    const moduleExports = {};
+    const moduleObj = { exports: moduleExports };
+    const global = { process: processObj, Buffer: BufferClass, console: scriptConsole };
+    const mainImportMetaUrl = "file://" + absPath;
+    const mainImportMeta = { url: mainImportMetaUrl, dirname: scriptDir, filename: absPath };
+    const mainImportMetaResolve = (specifier) => {
+      throw new Error(`import.meta.resolve('${specifier}') is not supported`);
+    };
+    const ga = globalThis;
+    const isRealNode = typeof ga.process?.pid === "number";
+    const saved = {};
+    if (!isRealNode) {
+      saved.process = ga.process;
+      ga.process = processObj;
+      saved.Buffer = ga.Buffer;
+      if (BufferClass) ga.Buffer = BufferClass;
+      saved.console = ga.console;
+      ga.console = scriptConsole;
+    }
+    const savedShims = {};
+    if (this.globalShims) {
+      for (const k of Object.keys(this.globalShims)) {
+        savedShims[k] = ga[k];
+        ga[k] = this.globalShims[k];
+      }
+    }
+    let pendingRejection = null;
+    const rejectionHandler = (event) => {
+      pendingRejection = event.reason;
+      event.preventDefault();
+      const msg = event.reason instanceof Error ? event.reason.stack || event.reason.message : String(event.reason);
+      const errMsg = `[unhandledRejection] ${msg}
+`;
+      if (this.stderr) this.stderr.write(errMsg);
+      else stderrLines.push(errMsg);
+    };
+    if (typeof globalThis.addEventListener === "function") {
+      globalThis.addEventListener("unhandledrejection", rejectionHandler);
+    }
     try {
-      const scriptDir = absPath.slice(0, absPath.lastIndexOf("/")) || "/";
-      const require2 = createRequire(scriptDir);
-      const factory = compileModule(source, absPath);
-      const moduleExports = {};
-      const moduleObj = { exports: moduleExports };
-      const processObj = builtins.get("process");
-      if (processObj) {
-        const stdout = processObj.stdout;
-        const stderr = processObj.stderr;
-        if (stdout)
-          stdout.write = (s) => {
-            stdoutLines.push(String(s));
-            return true;
-          };
-        if (stderr)
-          stderr.write = (s) => {
-            stderrLines.push(String(s));
-            return true;
-          };
-      }
-      factory(moduleObj.exports, require2, moduleObj, absPath, scriptDir, scriptConsole, builtins.get("process"));
-    } catch (err) {
-      if (err instanceof ProcessExitError) {
-        exitCode = err.code;
+      const fn = new Function("return " + wrapped)();
+      const result = fn(
+        moduleExports,
+        require2,
+        moduleObj,
+        absPath,
+        scriptDir,
+        scriptConsole,
+        processObj,
+        BufferClass,
+        globalThis.setTimeout,
+        globalThis.setInterval,
+        globalThis.clearTimeout,
+        globalThis.clearInterval,
+        global,
+        mainImportMetaUrl,
+        mainImportMeta,
+        mainImportMetaResolve
+      );
+      if (isEsm && result && typeof result.then === "function") {
+        await result;
+      }
+      if (pendingRejection) {
+        if (pendingRejection instanceof ProcessExitError) {
+          exitCode = pendingRejection.code;
+        } else {
+          exitCode = 1;
+        }
+      }
+    } catch (e) {
+      if (e instanceof ProcessExitError) {
+        exitCode = e.code;
       } else {
         exitCode = 1;
-        const message = err instanceof Error ? err.message : String(err);
-        const stack = err instanceof Error && err.stack ? err.stack : "";
-        stderrLines.push(stack || message);
+        const msg = e instanceof Error ? e.stack || e.message : String(e);
+        if (this.stderr) {
+          this.stderr.write(msg + "\n");
+        } else {
+          stderrLines.push(msg);
+        }
+      }
+    } finally {
+      if (this.globalShims) {
+        for (const k of Object.keys(savedShims)) ga[k] = savedShims[k];
+      }
+      if (!isRealNode) {
+        ga.process = saved.process;
+        ga.Buffer = saved.Buffer;
+        ga.console = saved.console;
+      }
+      if (typeof globalThis.removeEventListener === "function") {
+        globalThis.removeEventListener("unhandledrejection", rejectionHandler);
       }
     }
     return {
       exitCode,
-      stdout: stdoutLines.join("\n"),
-      stderr: stderrLines.join("\n")
+      stdout: isStreaming ? "" : stdoutLines.join("\n"),
+      stderr: isStreaming ? "" : stderrLines.join("\n")
     };
   }
 };
-function compileModule(source, filename) {
-  const wrapped = `(function(exports, require, module, __filename, __dirname, console, process) {
+function compileModule(source, filename, stderr) {
+  const wrapped = `(function(exports, require, module, __filename, __dirname, console, process, Buffer, setTimeout, setInterval, clearTimeout, clearInterval, global, __importMetaUrl, __importMeta, __importMetaResolve) {
 ${source}
 })`;
   try {
     return (0, eval)(wrapped);
   } catch (err) {
-    throw new SyntaxError(
-      `Failed to compile '${filename}': ${err instanceof Error ? err.message : String(err)}`
-    );
+    const errMsg = err instanceof Error ? err.message : String(err);
+    const msg = `Failed to compile '${filename}': ${errMsg}`;
+    if (stderr) {
+      stderr.write(`[CJS-FAIL] file=${filename} srcLen=${source.length} err=${errMsg}
+`);
+      const lines = source.split("\n");
+      let lo = 0, hi = lines.length;
+      while (hi - lo > 3) {
+        const mid = lo + hi >>> 1;
+        const partial = lines.slice(0, mid).join("\n");
+        try {
+          new Function(partial);
+          lo = mid;
+        } catch (e2) {
+          if (e2 instanceof Error && e2.message === errMsg) hi = mid;
+          else lo = mid;
+        }
+      }
+      stderr.write(`[CJS-FAIL] error at L${lo}-${hi}, showing L${Math.max(1, lo - 25)} to L${hi + 3}:
+`);
+      for (let li = Math.max(0, lo - 25); li < Math.min(lines.length, hi + 3); li++) {
+        stderr.write(`[CJS-FAIL] ${li + 1 === lo || li + 1 === hi ? ">>>" : "   "} L${li + 1}: ${lines[li]?.slice(0, 200)}
+`);
+      }
+    }
+    throw new SyntaxError(msg);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  NodeRunner
+  NodeRunner,
+  ProcessExitError,
+  resolveModule,
+  shouldTreatAsEsm,
+  transformEsmToCjs,
+  transformToCjs
 });
 //# sourceMappingURL=index.cjs.map