@ai-ecoverse/slicc-jsh 0.3.7 → 0.3.9

package/dist/jsh.mjs

@@ -1536,10 +1536,191 @@ ${e3}`;
   }
 });
 
+// src/runtime/path.mjs
+function normalizeArray(parts, allowAboveRoot) {
+  const res = [];
+  for (const part of parts) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      if (res.length > 0 && res[res.length - 1] !== "..") res.pop();
+      else if (allowAboveRoot) res.push("..");
+    } else {
+      res.push(part);
+    }
+  }
+  return res;
+}
+function normalize(path) {
+  if (path.length === 0) return ".";
+  const isAbsolute = path.charCodeAt(0) === 47;
+  const trailingSep = path.charCodeAt(path.length - 1) === 47;
+  let out = normalizeArray(path.split("/"), !isAbsolute).join("/");
+  if (out.length === 0 && !isAbsolute) out = ".";
+  if (out.length > 0 && trailingSep) out += "/";
+  return (isAbsolute ? "/" : "") + out;
+}
+function join(...parts) {
+  const joined = parts.filter((p) => typeof p === "string" && p.length > 0).join("/");
+  if (joined.length === 0) return ".";
+  return normalize(joined);
+}
+function dirname(path) {
+  if (path.length === 0) return ".";
+  const hasRoot = path.charCodeAt(0) === 47;
+  let end = -1;
+  let matchedSlash = true;
+  for (let i2 = path.length - 1; i2 >= 1; i2--) {
+    if (path.charCodeAt(i2) === 47) {
+      if (!matchedSlash) {
+        end = i2;
+        break;
+      }
+    } else {
+      matchedSlash = false;
+    }
+  }
+  if (end === -1) return hasRoot ? "/" : ".";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  let start = 0;
+  let end = -1;
+  let matchedSlash = true;
+  for (let i2 = path.length - 1; i2 >= 0; i2--) {
+    if (path.charCodeAt(i2) === 47) {
+      if (!matchedSlash) {
+        start = i2 + 1;
+        break;
+      }
+    } else if (end === -1) {
+      matchedSlash = false;
+      end = i2 + 1;
+    }
+  }
+  const base = end === -1 ? "" : path.slice(start, end);
+  if (ext && base.endsWith(ext) && base !== ext) return base.slice(0, base.length - ext.length);
+  return base;
+}
+function extname(path) {
+  const base = basename(path);
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0) return "";
+  return base.slice(dot);
+}
+function resolve(getCwd, parts) {
+  let resolved = "";
+  let isAbsolute = false;
+  for (let i2 = parts.length - 1; i2 >= -1 && !isAbsolute; i2--) {
+    const part = i2 >= 0 ? parts[i2] : getCwd();
+    if (typeof part !== "string" || part.length === 0) continue;
+    resolved = resolved.length > 0 ? `${part}/${resolved}` : part;
+    isAbsolute = part.charCodeAt(0) === 47;
+  }
+  const normalized = normalizeArray(resolved.split("/"), !isAbsolute).join("/");
+  if (isAbsolute) return normalized.length > 0 ? `/${normalized}` : "/";
+  return normalized.length > 0 ? normalized : ".";
+}
+function parse(path) {
+  const ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0) return ret;
+  const isAbsolute = path.charCodeAt(0) === 47;
+  if (isAbsolute) ret.root = "/";
+  ret.dir = dirname(path);
+  ret.base = basename(path);
+  ret.ext = extname(path);
+  ret.name = ret.ext ? ret.base.slice(0, ret.base.length - ret.ext.length) : ret.base;
+  if (ret.dir === "." && !isAbsolute) ret.dir = "";
+  return ret;
+}
+function format(pathObject) {
+  if (typeof pathObject === "string") return pathObject;
+  const dir = pathObject.dir || pathObject.root || "";
+  const base = pathObject.base || `${pathObject.name || ""}${pathObject.ext || ""}`;
+  if (!dir) return base;
+  if (dir === "/") return `/${base}`;
+  return `${dir}/${base}`;
+}
+function createPath(getCwd = () => "/") {
+  const api = {
+    sep: "/",
+    delimiter: ":",
+    basename,
+    dirname,
+    extname,
+    parse,
+    format,
+    isAbsolute: (path) => path.length > 0 && path.charCodeAt(0) === 47,
+    join,
+    normalize,
+    resolve: (...parts) => resolve(getCwd, parts),
+    relative(from, to) {
+      const fromAbs = resolve(getCwd, [from]);
+      const toAbs = resolve(getCwd, [to]);
+      if (fromAbs === toAbs) return "";
+      const fromParts = fromAbs.split("/").filter(Boolean);
+      const toParts = toAbs.split("/").filter(Boolean);
+      let i2 = 0;
+      while (i2 < fromParts.length && i2 < toParts.length && fromParts[i2] === toParts[i2]) i2++;
+      return [...fromParts.slice(i2).map(() => ".."), ...toParts.slice(i2)].join("/");
+    }
+  };
+  api.posix = api;
+  return api;
+}
+
+// src/runtime/realpath.mjs
+var MAX_LINKS = 40;
+function realpathWith(fs, path, p, fail) {
+  let resolved = path.resolve(String(p));
+  const knownHard = /* @__PURE__ */ new Set();
+  let hops = 0;
+  let current2 = "/";
+  let pos = 1;
+  const call = (fn, syscall, at2) => {
+    try {
+      return fn();
+    } catch (err) {
+      throw fail(err?.code || "ENOENT", syscall, at2, err);
+    }
+  };
+  while (pos < resolved.length) {
+    const next = resolved.indexOf("/", pos);
+    const part = next === -1 ? resolved.slice(pos) : resolved.slice(pos, next);
+    pos = next === -1 ? resolved.length : next + 1;
+    if (!part) continue;
+    const previous = current2;
+    const base = current2 === "/" ? `/${part}` : `${current2}/${part}`;
+    current2 = base;
+    if (knownHard.has(base)) continue;
+    const st = call(() => fs.lstat(base), "lstat", base);
+    if (!st.isSymbolicLink) {
+      knownHard.add(base);
+      continue;
+    }
+    if (++hops > MAX_LINKS) throw fail("ELOOP", "stat", base);
+    call(() => fs.stat(base), "stat", base);
+    const target = call(() => fs.readlink(base), "readlink", base);
+    resolved = path.resolve(previous, target, resolved.slice(pos));
+    current2 = "/";
+    pos = 1;
+  }
+  return resolved;
+}
+function realMainPath(ctx, filePath, execArgv = []) {
+  if (execArgv.includes("--preserve-symlinks-main")) return filePath;
+  const fs = ctx?.sync?.fs;
+  if (typeof fs?.lstat !== "function" || typeof fs?.readlink !== "function") return filePath;
+  try {
+    return realpathWith(fs, createPath(() => ctx.cwd), filePath, (code) => Object.assign(new Error(code), { code }));
+  } catch {
+    return filePath;
+  }
+}
+
 // package.json
 var package_default = {
   name: "@ai-ecoverse/slicc-jsh",
-  version: "0.3.7",
+  version: "0.3.9",
   description: "Node.js-compatible runtime for slicc-kernel: the node and jsh commands (abi: js)",
   type: "module",
   license: "Apache-2.0",
@@ -1609,7 +1790,7 @@ var package_default = {
     "trust:dry": "npx fledgling sync --dry-run -y --skip-publish"
   },
   devDependencies: {
-    "@ai-ecoverse/slicc-kernel": "1.63.0",
+    "@ai-ecoverse/slicc-kernel": "1.64.0",
     "@ai-ecoverse/wasi-pnpm": "12.9.1-8",
     "abort-controller": "3.0.0",
     acorn: "8.19.0",
@@ -1751,10 +1932,21 @@ function joinChild(dir, name) {
   if (dir === "/") return `/${name}`;
   return `${dir}/${name}`;
 }
+function skillRootOf(dir) {
+  if (!dir) return dir;
+  const absolute = dir.startsWith("/");
+  const parts = dir.split("/").filter(Boolean);
+  const at2 = parts.lastIndexOf("scripts");
+  if (at2 < 0) return dir;
+  const rootParts = parts.slice(0, at2);
+  if (rootParts.length === 0) return absolute ? "/" : "";
+  return (absolute ? "/" : "") + rootParts.join("/");
+}
 function createSkill({ argv, fs, exec }) {
   const dir = dirnameOf(argv[1] ?? "");
-  const refs = joinChild(dir, "references");
-  const assets = joinChild(dir, "assets");
+  const root = skillRootOf(dir);
+  const refs = joinChild(root, "references");
+  const assets = joinChild(root, "assets");
   const configPath = joinChild(dir, ".config");
   async function readConfig() {
     let text;
@@ -1796,7 +1988,7 @@ function createSkill({ argv, fs, exec }) {
     }
     return stdout.replace(/\r?\n+$/, "");
   }
-  return Object.freeze({ dir, refs, assets, config, token });
+  return Object.freeze({ dir, root, refs, assets, config, token });
 }
 
 // src/jsh/sliccy/http.mjs
@@ -2366,8 +2558,9 @@ function compiler(rt) {
     return (...args) => fn(...args.slice(0, JSH_PARAMS.length), importFrom);
   };
 }
-async function runKernelJsh(ctx, rt, filename) {
+async function runKernelJsh(ctx, rt, givenFilename) {
   const { process: process2, console: console2 } = rt;
+  const filename = realMainPath(ctx, givenFilename);
   let stdoutIsTTY = false;
   try {
     stdoutIsTTY = !!await rt.track(Promise.resolve(ctx.isatty?.(1)));
@@ -3532,7 +3725,7 @@ var {
   // identicalSequenceRange,
   inspect,
   // inspectDefaultOptions,
-  format,
+  format: format2,
   formatWithOptions,
   // getStringWidth,
   stripVTControlCharacters,
@@ -3623,7 +3816,7 @@ function createUtil() {
   inspect3.defaultOptions = inspect.defaultOptions ?? { depth: 2, colors: false };
   return {
     inspect: inspect3,
-    format,
+    format: format2,
     formatWithOptions,
     promisify,
     types,
@@ -4146,7 +4339,7 @@ var Parser = function Parser2(options, input, startPos) {
   this.privateNameStack = [];
 };
 var prototypeAccessors = { inFunction: { configurable: true }, inGenerator: { configurable: true }, inAsync: { configurable: true }, canAwait: { configurable: true }, allowReturn: { configurable: true }, allowSuper: { configurable: true }, allowDirectSuper: { configurable: true }, treatFunctionsAsVar: { configurable: true }, allowNewDotTarget: { configurable: true }, allowUsing: { configurable: true }, inClassStaticBlock: { configurable: true } };
-Parser.prototype.parse = function parse() {
+Parser.prototype.parse = function parse2() {
   var this$1$1 = this;
   var node = this.options.program || this.startNode();
   this.nextToken();
@@ -4229,7 +4422,7 @@ Parser.extend = function extend() {
   }
   return cls;
 };
-Parser.parse = function parse2(input, options) {
+Parser.parse = function parse3(input, options) {
   return new this(options, input).parse();
 };
 Parser.parseExpressionAt = function parseExpressionAt(input, pos, options) {
@@ -9370,7 +9563,7 @@ Parser.acorn = {
   lineBreakG,
   nonASCIIwhitespace
 };
-function parse3(input, options) {
+function parse4(input, options) {
   return Parser.parse(input, options);
 }
 
@@ -9412,7 +9605,7 @@ function transformEsm(source, filename) {
   const body = stripHashbang(source);
   let ast;
   try {
-    ast = parse3(body, {
+    ast = parse4(body, {
       ecmaVersion: "latest",
       sourceType: "module",
       allowAwaitOutsideFunction: true
@@ -9873,7 +10066,7 @@ function rewriteDynamicImports(source) {
   const body = stripHashbang(source);
   let ast;
   try {
-    ast = parse3(body, {
+    ast = parse4(body, {
       ecmaVersion: "latest",
       sourceType: "script",
       allowAwaitOutsideFunction: false
@@ -9903,7 +10096,7 @@ function rewriteDynamicImports(source) {
 function shouldRunAsEsm(source) {
   const body = stripHashbang(source);
   try {
-    parse3(body, {
+    parse4(body, {
       ecmaVersion: "latest",
       sourceType: "script",
       allowAwaitOutsideFunction: false
@@ -9912,7 +10105,7 @@ function shouldRunAsEsm(source) {
   } catch {
   }
   try {
-    parse3(body, {
+    parse4(body, {
       ecmaVersion: "latest",
       sourceType: "module",
       allowAwaitOutsideFunction: true
@@ -9923,138 +10116,6 @@ function shouldRunAsEsm(source) {
   }
 }
 
-// src/runtime/path.mjs
-function normalizeArray(parts, allowAboveRoot) {
-  const res = [];
-  for (const part of parts) {
-    if (part === "" || part === ".") continue;
-    if (part === "..") {
-      if (res.length > 0 && res[res.length - 1] !== "..") res.pop();
-      else if (allowAboveRoot) res.push("..");
-    } else {
-      res.push(part);
-    }
-  }
-  return res;
-}
-function normalize(path) {
-  if (path.length === 0) return ".";
-  const isAbsolute = path.charCodeAt(0) === 47;
-  const trailingSep = path.charCodeAt(path.length - 1) === 47;
-  let out = normalizeArray(path.split("/"), !isAbsolute).join("/");
-  if (out.length === 0 && !isAbsolute) out = ".";
-  if (out.length > 0 && trailingSep) out += "/";
-  return (isAbsolute ? "/" : "") + out;
-}
-function join(...parts) {
-  const joined = parts.filter((p) => typeof p === "string" && p.length > 0).join("/");
-  if (joined.length === 0) return ".";
-  return normalize(joined);
-}
-function dirname(path) {
-  if (path.length === 0) return ".";
-  const hasRoot = path.charCodeAt(0) === 47;
-  let end = -1;
-  let matchedSlash = true;
-  for (let i2 = path.length - 1; i2 >= 1; i2--) {
-    if (path.charCodeAt(i2) === 47) {
-      if (!matchedSlash) {
-        end = i2;
-        break;
-      }
-    } else {
-      matchedSlash = false;
-    }
-  }
-  if (end === -1) return hasRoot ? "/" : ".";
-  return path.slice(0, end);
-}
-function basename(path, ext) {
-  let start = 0;
-  let end = -1;
-  let matchedSlash = true;
-  for (let i2 = path.length - 1; i2 >= 0; i2--) {
-    if (path.charCodeAt(i2) === 47) {
-      if (!matchedSlash) {
-        start = i2 + 1;
-        break;
-      }
-    } else if (end === -1) {
-      matchedSlash = false;
-      end = i2 + 1;
-    }
-  }
-  const base = end === -1 ? "" : path.slice(start, end);
-  if (ext && base.endsWith(ext) && base !== ext) return base.slice(0, base.length - ext.length);
-  return base;
-}
-function extname(path) {
-  const base = basename(path);
-  const dot = base.lastIndexOf(".");
-  if (dot <= 0) return "";
-  return base.slice(dot);
-}
-function resolve(getCwd, parts) {
-  let resolved = "";
-  let isAbsolute = false;
-  for (let i2 = parts.length - 1; i2 >= -1 && !isAbsolute; i2--) {
-    const part = i2 >= 0 ? parts[i2] : getCwd();
-    if (typeof part !== "string" || part.length === 0) continue;
-    resolved = resolved.length > 0 ? `${part}/${resolved}` : part;
-    isAbsolute = part.charCodeAt(0) === 47;
-  }
-  const normalized = normalizeArray(resolved.split("/"), !isAbsolute).join("/");
-  if (isAbsolute) return normalized.length > 0 ? `/${normalized}` : "/";
-  return normalized.length > 0 ? normalized : ".";
-}
-function parse4(path) {
-  const ret = { root: "", dir: "", base: "", ext: "", name: "" };
-  if (path.length === 0) return ret;
-  const isAbsolute = path.charCodeAt(0) === 47;
-  if (isAbsolute) ret.root = "/";
-  ret.dir = dirname(path);
-  ret.base = basename(path);
-  ret.ext = extname(path);
-  ret.name = ret.ext ? ret.base.slice(0, ret.base.length - ret.ext.length) : ret.base;
-  if (ret.dir === "." && !isAbsolute) ret.dir = "";
-  return ret;
-}
-function format2(pathObject) {
-  if (typeof pathObject === "string") return pathObject;
-  const dir = pathObject.dir || pathObject.root || "";
-  const base = pathObject.base || `${pathObject.name || ""}${pathObject.ext || ""}`;
-  if (!dir) return base;
-  if (dir === "/") return `/${base}`;
-  return `${dir}/${base}`;
-}
-function createPath(getCwd = () => "/") {
-  const api = {
-    sep: "/",
-    delimiter: ":",
-    basename,
-    dirname,
-    extname,
-    parse: parse4,
-    format: format2,
-    isAbsolute: (path) => path.length > 0 && path.charCodeAt(0) === 47,
-    join,
-    normalize,
-    resolve: (...parts) => resolve(getCwd, parts),
-    relative(from, to) {
-      const fromAbs = resolve(getCwd, [from]);
-      const toAbs = resolve(getCwd, [to]);
-      if (fromAbs === toAbs) return "";
-      const fromParts = fromAbs.split("/").filter(Boolean);
-      const toParts = toAbs.split("/").filter(Boolean);
-      let i2 = 0;
-      while (i2 < fromParts.length && i2 < toParts.length && fromParts[i2] === toParts[i2]) i2++;
-      return [...fromParts.slice(i2).map(() => ".."), ...toParts.slice(i2)].join("/");
-    }
-  };
-  api.posix = api;
-  return api;
-}
-
 // src/runtime/builtins/assert.mjs
 var inspect2 = (v) => inspect(v, { compact: false, breakLength: 80, sorted: true });
 var AssertionError = class extends Error {
@@ -10761,6 +10822,27 @@ function createEvents() {
 }
 
 // src/runtime/builtins/child-process.mjs
+var PROMISIFY_CUSTOM2 = /* @__PURE__ */ Symbol.for("nodejs.util.promisify.custom");
+function customPromiseExecFunction(orig) {
+  return function(...args) {
+    let resolve2;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve2 = res;
+      reject = rej;
+    });
+    promise.child = orig(...args, (err, stdout, stderr) => {
+      if (err != null) {
+        err.stdout = stdout;
+        err.stderr = stderr;
+        reject(err);
+      } else {
+        resolve2({ stdout, stderr });
+      }
+    });
+    return promise;
+  };
+}
 var SIGNAL_NAMES = {
   1: "SIGHUP",
   2: "SIGINT",
@@ -11250,6 +11332,14 @@ function createChildProcess({ ctx, process: process2, Buffer: Buffer2, handles,
     const cmd = String(command);
     return execFile(shell, ["-c", cmd], { ...opts, shell: false, _execCmd: cmd }, cb);
   }
+  Object.defineProperty(exec, PROMISIFY_CUSTOM2, {
+    enumerable: false,
+    value: customPromiseExecFunction(exec)
+  });
+  Object.defineProperty(execFile, PROMISIFY_CUSTOM2, {
+    enumerable: false,
+    value: customPromiseExecFunction(execFile)
+  });
   return {
     spawn,
     execFile,
@@ -11273,10 +11363,375 @@ function createChildProcess({ ctx, process: process2, Buffer: Buffer2, handles,
   };
 }
 
+// src/runtime/builtins/fs-cp.mjs
+var ERRNO = { EEXIST: 17, ENOTDIR: 20, EISDIR: 21, EINVAL: 22 };
+var SYSTEM_ERROR_PREFIX = {
+  ERR_FS_CP_DIR_TO_NON_DIR: "Cannot overwrite non-directory with directory",
+  ERR_FS_CP_EEXIST: "Target already exists",
+  ERR_FS_CP_EINVAL: "Invalid src or dest",
+  ERR_FS_CP_NON_DIR_TO_DIR: "Cannot overwrite directory with non-directory",
+  ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY: "Cannot overwrite symlink in subdirectory of self",
+  ERR_FS_EISDIR: "Path is a directory"
+};
+function systemError(key, { message, path, code }) {
+  const err = new Error(
+    `${SYSTEM_ERROR_PREFIX[key]}: cp returned ${code} (${message})${path === void 0 ? "" : ` ${path}`}`
+  );
+  err.name = "SystemError";
+  err.code = key;
+  err.errno = ERRNO[code];
+  err.syscall = "cp";
+  if (path !== void 0) err.path = path;
+  err.info = { code, message, path, syscall: "cp", errno: ERRNO[code] };
+  return err;
+}
+function nativeError(code, message) {
+  const err = new Error(message);
+  err.code = code;
+  return err;
+}
+function invalidFilterReturn() {
+  const err = new TypeError(
+    'Expected boolean to be returned from the "filter" function but got an instance of Promise.'
+  );
+  err.code = "ERR_INVALID_RETURN_VALUE";
+  return err;
+}
+var isPromise = (v) => v != null && typeof v.then === "function";
+function createCp({ path, ops, abs, fsError, copyFileSync, mkdirpSync }) {
+  const tryCall = (fn) => {
+    try {
+      return fn();
+    } catch {
+      return null;
+    }
+  };
+  const call = (fn, syscall, pathArg, dest) => {
+    try {
+      return fn();
+    } catch (err) {
+      if (err?.syscall) throw err;
+      throw fsError(err?.code || "EIO", syscall, pathArg, err, dest);
+    }
+  };
+  const lstat = (p) => call(() => ops.lstat(abs(p)), "lstat", p);
+  const stat = (p) => call(() => ops.stat(abs(p)), "stat", p);
+  const readlink = (p) => call(() => ops.readlink(abs(p)), "readlink", p);
+  const symlink = (target, p) => call(() => ops.symlink(target, abs(p)), "symlink", target, p);
+  const unlink = (p) => call(() => ops.unlink(abs(p)), "unlink", p);
+  const readdir = (p) => call(() => ops.readdir(abs(p)), "scandir", p);
+  const exists = (p) => !!tryCall(() => ops.stat(abs(p)));
+  const realpathSync = (p) => realpathWith(ops, path, p, (code, syscall, at2, err) => fsError(code, syscall, at2, err));
+  function weaklyCanonical(p) {
+    const parts = path.resolve(p).split("/").filter(Boolean);
+    for (let i2 = parts.length; i2 > 0; i2--) {
+      const prefix = `/${parts.slice(0, i2).join("/")}`;
+      if (!exists(prefix)) continue;
+      const real = tryCall(() => realpathSync(prefix)) ?? prefix;
+      return path.join(real, ...parts.slice(i2));
+    }
+    return path.resolve(p);
+  }
+  const equivalent = (a, b) => {
+    if (!exists(a) || !exists(b)) return false;
+    return tryCall(() => realpathSync(a)) === tryCall(() => realpathSync(b));
+  };
+  const normalizeArray2 = (p) => path.resolve(p).split("/").filter(Boolean);
+  const isSrcSubdir = (src, dest) => {
+    const s = normalizeArray2(src);
+    const d = normalizeArray2(dest);
+    return s.every((cur, i2) => d[i2] === cur);
+  };
+  const withDefaults = (options = {}) => ({
+    dereference: false,
+    errorOnExist: false,
+    force: true,
+    preserveTimestamps: false,
+    recursive: false,
+    verbatimSymlinks: false,
+    mode: 0,
+    ...options
+  });
+  function checkPathsSync(src, dest, dereference, recursive) {
+    const srcSt = call(() => dereference ? ops.lstat(abs(src)) : ops.stat(abs(src)), dereference ? "stat" : "lstat", src);
+    const destSt = tryCall(() => dereference ? ops.stat(abs(dest)) : ops.lstat(abs(dest)));
+    const srcIsDir = !!srcSt.isDirectory || dereference && !!srcSt.isSymbolicLink;
+    if (destSt) {
+      if (equivalent(src, dest)) throw nativeError("ERR_FS_CP_EINVAL", `src and dest cannot be the same ${dest}`);
+      const destIsDir = !!destSt.isDirectory;
+      if (srcIsDir && !destIsDir) {
+        throw nativeError("ERR_FS_CP_DIR_TO_NON_DIR", `Cannot overwrite non-directory ${dest} with directory ${src}`);
+      }
+      if (!srcIsDir && destIsDir) {
+        throw nativeError("ERR_FS_CP_NON_DIR_TO_DIR", `Cannot overwrite directory ${dest} with non-directory ${src}`);
+      }
+    }
+    const srcSlash = src.endsWith("/") ? src : `${src}/`;
+    const subdir = () => nativeError("ERR_FS_CP_EINVAL", `Cannot copy ${srcSlash} to a subdirectory of self ${dest}`);
+    if (srcIsDir && dest.startsWith(srcSlash)) throw subdir();
+    if (path.dirname(src) !== path.dirname(dest) && equivalent(src, path.dirname(dest))) throw subdir();
+    if (srcIsDir && !recursive) {
+      throw nativeError("ERR_FS_EISDIR", `Recursive option not enabled, cannot copy a directory: ${srcSlash}`);
+    }
+    if (!destSt || !exists(path.dirname(dest))) tryCall(() => mkdirpSync(path.dirname(dest)));
+  }
+  function getStatsSync(src, dest, opts) {
+    const srcSt = opts.dereference ? stat(src) : lstat(src);
+    const destSt = tryCall(() => opts.dereference ? ops.stat(abs(dest)) : ops.lstat(abs(dest)));
+    if (srcSt.isDirectory && opts.recursive) return copyDirSync(src, dest, opts, !destSt);
+    if (srcSt.isSymbolicLink) return onLinkSync(destSt, src, dest, opts.verbatimSymlinks);
+    if (!destSt) return copyFileSync(src, dest, opts.mode);
+    if (opts.force) {
+      unlink(dest);
+      return copyFileSync(src, dest, opts.mode);
+    }
+    if (opts.errorOnExist) {
+      throw systemError("ERR_FS_CP_EEXIST", { message: `${dest} already exists`, path: dest, code: "EEXIST" });
+    }
+    return void 0;
+  }
+  function copyDirSync(src, dest, opts, mkDir) {
+    if (!opts.filter) return nativeCopyDir(src, dest, opts);
+    if (mkDir) call(() => ops.mkdir(abs(dest)), "mkdir", dest);
+    for (const name of readdir(src)) {
+      const srcItem = path.join(src, name);
+      const destItem = path.join(dest, name);
+      const shouldCopy = opts.filter(srcItem, destItem);
+      if (isPromise(shouldCopy)) throw invalidFilterReturn();
+      if (shouldCopy) getStatsSync(srcItem, destItem, opts);
+    }
+    return void 0;
+  }
+  function nativeCopyDir(src, dest, opts) {
+    call(() => mkdirpSync(dest), "cp", dest);
+    const walk2 = (srcDir, destDir) => {
+      for (const name of readdir(srcDir)) {
+        const srcItem = path.join(srcDir, name);
+        const destItem = path.join(destDir, name);
+        const st = lstat(srcItem);
+        if (st.isSymbolicLink) {
+          const target = readlink(srcItem);
+          if (opts.verbatimSymlinks) {
+            if (tryCall(() => ops.lstat(abs(destItem)))) throw fsError("EEXIST", "cp", destDir);
+            symlink(target, destItem);
+            continue;
+          }
+          if (exists(destItem)) {
+            const destLink = tryCall(() => ops.lstat(abs(destItem)));
+            if (destLink?.isSymbolicLink) {
+              unlink(destItem);
+            } else if (!stat(destItem).isDirectory) {
+              if (!opts.dereference || !opts.force && opts.errorOnExist) {
+                throw fsError("EEXIST", "cp", destItem);
+              }
+            }
+          } else if (tryCall(() => ops.lstat(abs(destItem)))?.isSymbolicLink) {
+            unlink(destItem);
+          }
+          symlink(weaklyCanonical(path.resolve(srcDir, target)), destItem);
+        } else if (st.isDirectory) {
+          if (!tryCall(() => ops.lstat(abs(destItem)))) call(() => ops.mkdir(abs(destItem)), "cp", destDir);
+          walk2(srcItem, destItem);
+        } else {
+          const there = tryCall(() => ops.lstat(abs(destItem)));
+          if (there) {
+            if (opts.force) {
+              unlink(destItem);
+            } else if (opts.errorOnExist) {
+              throw nativeError(
+                "ERR_FS_CP_EEXIST",
+                `[ERR_FS_CP_EEXIST]: Target already exists: cp returned EEXIST (${destItem} already exists)`
+              );
+            } else {
+              continue;
+            }
+          }
+          copyFileSync(srcItem, destItem);
+        }
+      }
+    };
+    walk2(src, dest);
+  }
+  function onLinkSync(destSt, src, dest, verbatimSymlinks) {
+    let resolvedSrc = readlink(src);
+    if (!verbatimSymlinks && !path.isAbsolute(resolvedSrc)) resolvedSrc = path.resolve(path.dirname(src), resolvedSrc);
+    if (!destSt) return symlink(resolvedSrc, dest);
+    let resolvedDest;
+    try {
+      resolvedDest = readlink(dest);
+    } catch (err) {
+      if (err.code === "EINVAL" || err.code === "UNKNOWN") return symlink(resolvedSrc, dest);
+      throw err;
+    }
+    if (!path.isAbsolute(resolvedDest)) resolvedDest = path.resolve(path.dirname(dest), resolvedDest);
+    if (isSrcSubdir(resolvedSrc, resolvedDest)) {
+      throw systemError("ERR_FS_CP_EINVAL", {
+        message: `cannot copy ${resolvedSrc} to a subdirectory of self ${resolvedDest}`,
+        path: dest,
+        code: "EINVAL"
+      });
+    }
+    if (tryCall(() => ops.stat(abs(dest)))?.isDirectory && isSrcSubdir(resolvedDest, resolvedSrc)) {
+      throw systemError("ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY", {
+        message: `cannot overwrite ${resolvedDest} with ${resolvedSrc}`,
+        path: dest,
+        code: "EINVAL"
+      });
+    }
+    unlink(dest);
+    return symlink(resolvedSrc, dest);
+  }
+  function cpSync(src, dest, options) {
+    const opts = withDefaults(options);
+    src = String(src);
+    dest = String(dest);
+    if (opts.filter) {
+      const shouldCopy = opts.filter(src, dest);
+      if (isPromise(shouldCopy)) throw invalidFilterReturn();
+      if (!shouldCopy) return;
+    }
+    checkPathsSync(src, dest, opts.dereference, opts.recursive);
+    getStatsSync(src, dest, opts);
+  }
+  const sameFile = (a, aPath, b, bPath) => {
+    if (a?.ino && a?.dev && b?.ino && b?.dev) return a.ino === b.ino && a.dev === b.dev;
+    return equivalent(aPath, bPath);
+  };
+  async function cp(src, dest, options) {
+    const opts = withDefaults(options);
+    src = String(src);
+    dest = String(dest);
+    const checked = await checkPaths(src, dest, opts);
+    if (checked.skipped) return;
+    checkParentPaths(src, checked.srcStat, dest);
+    if (!exists(path.dirname(dest))) mkdirpSync(path.dirname(dest));
+    await copyEntry(checked.destStat, src, dest, opts);
+  }
+  async function checkPaths(src, dest, opts) {
+    if (opts.filter && !await opts.filter(src, dest)) return { skipped: true };
+    const statFn = opts.dereference ? stat : lstat;
+    const srcStat = statFn(src);
+    let destStat = null;
+    try {
+      destStat = statFn(dest);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    if (destStat) {
+      if (sameFile(srcStat, src, destStat, dest)) {
+        throw systemError("ERR_FS_CP_EINVAL", { message: "src and dest cannot be the same", path: dest, code: "EINVAL" });
+      }
+      if (srcStat.isDirectory && !destStat.isDirectory) {
+        throw systemError("ERR_FS_CP_DIR_TO_NON_DIR", {
+          message: `cannot overwrite non-directory ${dest} with directory ${src}`,
+          path: dest,
+          code: "EISDIR"
+        });
+      }
+      if (!srcStat.isDirectory && destStat.isDirectory) {
+        throw systemError("ERR_FS_CP_NON_DIR_TO_DIR", {
+          message: `cannot overwrite directory ${dest} with non-directory ${src}`,
+          path: dest,
+          code: "ENOTDIR"
+        });
+      }
+    }
+    if (srcStat.isDirectory && isSrcSubdir(src, dest)) {
+      throw systemError("ERR_FS_CP_EINVAL", {
+        message: `cannot copy ${src} to a subdirectory of self ${dest}`,
+        path: dest,
+        code: "EINVAL"
+      });
+    }
+    return { srcStat, destStat, skipped: false };
+  }
+  function checkParentPaths(src, srcStat, dest) {
+    const srcParent = path.resolve(path.dirname(src));
+    const destParent = path.resolve(path.dirname(dest));
+    if (destParent === srcParent || destParent === "/") return;
+    const destStat = tryCall(() => ops.stat(destParent));
+    if (!destStat) return;
+    const same = sameFile(srcStat, src, destStat, destParent);
+    if (same) {
+      throw systemError("ERR_FS_CP_EINVAL", {
+        message: `cannot copy ${src} to a subdirectory of self ${dest}`,
+        path: dest,
+        code: "EINVAL"
+      });
+    }
+    checkParentPaths(src, srcStat, destParent);
+  }
+  async function copyEntry(destStat, src, dest, opts) {
+    const srcStat = opts.dereference ? stat(src) : lstat(src);
+    if (srcStat.isDirectory && opts.recursive) {
+      if (!destStat) call(() => ops.mkdir(abs(dest)), "mkdir", dest);
+      for (const name of readdir(src)) {
+        const srcItem = path.join(src, name);
+        const destItem = path.join(dest, name);
+        const checked = await checkPaths(srcItem, destItem, opts);
+        if (!checked.skipped) await copyEntry(checked.destStat, srcItem, destItem, opts);
+      }
+      return;
+    }
+    if (srcStat.isDirectory) {
+      throw systemError("ERR_FS_EISDIR", { message: `${src} is a directory (not copied)`, path: src, code: "EISDIR" });
+    }
+    if (srcStat.isSymbolicLink) {
+      let resolvedSrc = readlink(src);
+      if (!opts.verbatimSymlinks && !path.isAbsolute(resolvedSrc)) {
+        resolvedSrc = path.resolve(path.dirname(src), resolvedSrc);
+      }
+      if (!destStat) {
+        symlink(resolvedSrc, dest);
+        return;
+      }
+      let resolvedDest;
+      try {
+        resolvedDest = readlink(dest);
+      } catch (err) {
+        if (err.code === "EINVAL" || err.code === "UNKNOWN") {
+          symlink(resolvedSrc, dest);
+          return;
+        }
+        throw err;
+      }
+      if (!path.isAbsolute(resolvedDest)) resolvedDest = path.resolve(path.dirname(dest), resolvedDest);
+      if (isSrcSubdir(resolvedSrc, resolvedDest)) {
+        throw systemError("ERR_FS_CP_EINVAL", {
+          message: `cannot copy ${resolvedSrc} to a subdirectory of self ${resolvedDest}`,
+          path: dest,
+          code: "EINVAL"
+        });
+      }
+      if (tryCall(() => ops.stat(abs(src)))?.isDirectory && isSrcSubdir(resolvedDest, resolvedSrc)) {
+        throw systemError("ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY", {
+          message: `cannot overwrite ${resolvedDest} with ${resolvedSrc}`,
+          path: dest,
+          code: "EINVAL"
+        });
+      }
+      unlink(dest);
+      symlink(resolvedSrc, dest);
+      return;
+    }
+    if (!destStat) {
+      copyFileSync(src, dest, opts.mode);
+      return;
+    }
+    if (opts.force) {
+      unlink(dest);
+      copyFileSync(src, dest, opts.mode);
+    } else if (opts.errorOnExist) {
+      throw systemError("ERR_FS_CP_EEXIST", { message: `${dest} already exists`, path: dest, code: "EEXIST" });
+    }
+  }
+  return { cpSync, cp, realpathSync, weaklyCanonical };
+}
+
 // src/runtime/builtins/fs.mjs
 var encoder3 = new TextEncoder();
 var decoder3 = new TextDecoder();
-var ERRNO = {
+var ERRNO2 = {
   ENOENT: -2,
   EEXIST: -17,
   EISDIR: -21,
@@ -11288,7 +11743,9 @@ var ERRNO = {
   ENOTEMPTY: -39,
   // Linux (the shim's process.platform)
   EBADF: -9,
-  ENOTSUP: -45
+  ENOTSUP: -45,
+  EXDEV: -18,
+  ELOOP: -40
 };
 var DESCRIPTIONS = {
   ENOENT: "no such file or directory",
@@ -11301,7 +11758,9 @@ var DESCRIPTIONS = {
   EIO: "i/o error",
   ENOTEMPTY: "directory not empty",
   EBADF: "bad file descriptor",
-  ENOTSUP: "operation not supported"
+  ENOTSUP: "operation not supported",
+  EXDEV: "cross-device link not permitted",
+  ELOOP: "too many symbolic links encountered"
 };
 function nodeFsError(code, syscall, pathArg, err, dest) {
   const c = typeof code === "string" ? code : err?.code || "EIO";
@@ -11316,7 +11775,7 @@ function nodeFsError(code, syscall, pathArg, err, dest) {
   }
   const e = new Error(msg);
   e.code = c;
-  e.errno = ERRNO[c] ?? -1;
+  e.errno = ERRNO2[c] ?? -1;
   e.syscall = syscall;
   if (pathArg !== void 0 && pathArg !== null) e.path = pathArg;
   if (dest !== void 0) e.dest = dest;
@@ -11324,11 +11783,6 @@ function nodeFsError(code, syscall, pathArg, err, dest) {
 }
 var FS_READ_STREAM = /* @__PURE__ */ Symbol("fs.ReadStream");
 var FS_WRITE_STREAM = /* @__PURE__ */ Symbol("fs.WriteStream");
-function cpInvalid(message) {
-  const e = new Error(message);
-  e.code = "ERR_FS_CP_EINVAL";
-  return e;
-}
 function rmIsDirectoryError(pathArg) {
   const e = new Error(`Path is a directory: rm returned EISDIR (is a directory) ${pathArg}`);
   e.name = "SystemError";
@@ -11349,15 +11803,19 @@ var S_IFMT = 61440;
 var S_IFREG = 32768;
 var S_IFDIR = 16384;
 var S_IFLNK = 40960;
+var modeType = (mode) => {
+  if (typeof mode === "bigint") return Number(BigInt.asUintN(32, mode) & BigInt(S_IFMT));
+  return typeof mode === "number" ? mode & S_IFMT : -1;
+};
 var Stats = class {
   isFile() {
-    return (this.mode & S_IFMT) === S_IFREG;
+    return modeType(this.mode) === S_IFREG;
   }
   isDirectory() {
-    return (this.mode & S_IFMT) === S_IFDIR;
+    return modeType(this.mode) === S_IFDIR;
   }
   isSymbolicLink() {
-    return (this.mode & S_IFMT) === S_IFLNK;
+    return modeType(this.mode) === S_IFLNK;
   }
   isBlockDevice() {
     return false;
@@ -11372,13 +11830,49 @@ var Stats = class {
     return false;
   }
 };
-function statView(st) {
+for (const name of ["atime", "mtime", "ctime", "birthtime"]) {
+  Object.defineProperty(Stats.prototype, name, {
+    configurable: true,
+    enumerable: false,
+    get() {
+      return new Date(Number(this[`${name}Ms`]));
+    },
+    set(value) {
+      Object.defineProperty(this, name, { value, writable: true, configurable: true, enumerable: true });
+    }
+  });
+}
+function statView(st, bigint = false) {
   const mtimeMs = st.mtimeMs ?? (st.mtime ? Number(st.mtime) : 0);
   const atimeMs = st.atimeMs ?? mtimeMs;
   const ctimeMs = st.ctimeMs ?? mtimeMs;
   const type = st.isDirectory ? S_IFDIR : st.isSymbolicLink ? S_IFLNK : S_IFREG;
   const perm = typeof st.mode === "number" ? st.mode & ~S_IFMT : st.isDirectory ? 493 : 420;
   const size = st.size ?? 0;
+  if (bigint) {
+    const B = (v) => BigInt(Math.trunc(Number(v) || 0));
+    const ns = (ms) => BigInt(Math.trunc(ms * 1e6));
+    return Object.assign(new Stats(), {
+      dev: B(st.dev),
+      mode: B(type | perm),
+      nlink: B(st.nlink ?? 1),
+      uid: B(st.uid),
+      gid: B(st.gid),
+      rdev: 0n,
+      blksize: 4096n,
+      ino: B(st.ino),
+      size: B(size),
+      blocks: B(Math.ceil(size / 512)),
+      atimeMs: B(atimeMs),
+      mtimeMs: B(mtimeMs),
+      ctimeMs: B(ctimeMs),
+      birthtimeMs: B(ctimeMs),
+      atimeNs: ns(atimeMs),
+      mtimeNs: ns(mtimeMs),
+      ctimeNs: ns(ctimeMs),
+      birthtimeNs: ns(ctimeMs)
+    });
+  }
   return Object.assign(new Stats(), {
     dev: st.dev ?? 0,
     mode: type | perm,
@@ -11393,11 +11887,7 @@ function statView(st) {
     atimeMs,
     mtimeMs,
     ctimeMs,
-    birthtimeMs: ctimeMs,
-    atime: new Date(atimeMs),
-    mtime: new Date(mtimeMs),
-    ctime: new Date(ctimeMs),
-    birthtime: new Date(ctimeMs)
+    birthtimeMs: ctimeMs
   });
 }
 var Dirent = class {
@@ -11439,12 +11929,46 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
   const wrapBuffer = (bytes) => Buffer2 ? Buffer2.from(bytes) : bytes;
   const optEncoding = (options) => typeof options === "string" ? options : options?.encoding ?? null;
   const optFlag = (options, fallback) => options && typeof options === "object" && options.flag || fallback;
+  const ENCODINGS = /* @__PURE__ */ new Set([
+    "utf8",
+    "utf-8",
+    "ucs2",
+    "ucs-2",
+    "utf16le",
+    "utf-16le",
+    "latin1",
+    "binary",
+    "base64",
+    "base64url",
+    "hex",
+    "ascii",
+    "buffer"
+  ]);
+  const checkEncoding = (encoding) => {
+    if (encoding == null || ENCODINGS.has(String(encoding).toLowerCase())) return;
+    const err = new TypeError(`The argument 'encoding' is invalid encoding. Received '${encoding}'`);
+    err.code = "ERR_INVALID_ARG_VALUE";
+    throw err;
+  };
   const decodeAs = (bytes, encoding) => {
-    if (!encoding || encoding === "buffer") return wrapBuffer(bytes);
-    if (encoding === "utf8" || encoding === "utf-8") return decoder3.decode(bytes);
-    return Buffer2 ? Buffer2.from(bytes).toString(encoding) : decoder3.decode(bytes);
+    checkEncoding(encoding);
+    if (!encoding) return wrapBuffer(bytes);
+    const enc = String(encoding).toLowerCase();
+    if (enc === "buffer") {
+      const err = new TypeError("Unknown encoding: buffer");
+      err.code = "ERR_UNKNOWN_ENCODING";
+      throw err;
+    }
+    if (enc === "utf8" || enc === "utf-8") return decoder3.decode(bytes);
+    if (enc === "ascii") {
+      let out = "";
+      for (let i2 = 0; i2 < bytes.length; i2++) out += String.fromCharCode(bytes[i2] & 127);
+      return out;
+    }
+    return Buffer2 ? Buffer2.from(bytes).toString(enc) : decoder3.decode(bytes);
   };
   const encodeAs = (data2, encoding) => {
+    checkEncoding(encoding);
     if (typeof data2 === "string" && encoding && encoding !== "utf8" && encoding !== "utf-8" && Buffer2) {
       const b = Buffer2.from(data2, encoding);
       return new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
@@ -11615,9 +12139,17 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
       }
       return;
     }
+    const given = [];
+    for (let cur2 = String(p); ; ) {
+      given.unshift(cur2);
+      const up = path.dirname(cur2);
+      if (up === cur2) break;
+      cur2 = up;
+    }
     const parts = String(target).split("/").filter(Boolean);
     let cur = "";
     let first;
+    let firstAbs;
     for (const part of parts) {
       cur += `/${part}`;
       if (syncFs.exists(cur)) {
@@ -11632,12 +12164,15 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
       }
       try {
         syncFs.mkdir(cur);
-        first ??= path.isAbsolute(String(p)) ? cur : path.relative(process2.cwd(), cur);
+        firstAbs ??= cur;
       } catch (err) {
         if (err?.code === "EEXIST") continue;
         throw nodeFsError(err?.code || "EIO", "mkdir", pathArg, err);
       }
     }
+    if (firstAbs !== void 0) {
+      first = given.find((g) => abs(g) === firstAbs) ?? firstAbs;
+    }
     return first;
   }
   const typeAt = (full) => {
@@ -11657,11 +12192,14 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     }
     if (!ok) throw nodeFsError("ENOENT", syscall, p);
   }
-  function readdirSync(p, options) {
+  const MAX_LINK_DEPTH = 40;
+  function readdirSync(p, options, { followLinks = true } = {}) {
     const pathArg = p;
     const target = abs(p);
     const encoding = optEncoding(options);
+    checkEncoding(encoding);
     const asName = (name) => encoding === "buffer" ? wrapBuffer(encoder3.encode(name)) : name;
+    const dirent = (name, type, parent) => new Dirent(asName(name), type, parent);
     let names;
     try {
       names = syncFs.readdir(target);
@@ -11670,32 +12208,40 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     }
     if (!options?.recursive) {
       if (options?.withFileTypes) {
-        return names.map((name) => new Dirent(name, typeAt(path.join(target, name)), String(pathArg)));
+        return names.map((name) => dirent(name, typeAt(path.join(target, name)), String(pathArg)));
       }
       return names.map(asName);
     }
     const out = [];
-    const queue = [{ dir: target, rel: "", parent: String(pathArg), names }];
+    const queue = [{ dir: target, rel: "", parent: String(pathArg), names, links: 0 }];
     while (queue.length) {
-      const { dir, rel, parent, names: entries } = queue.shift();
+      const { dir, rel, parent, names: entries, links } = queue.shift();
       for (const name of entries) {
         const full = path.join(dir, name);
         const type = typeAt(full);
-        out.push(options.withFileTypes ? new Dirent(name, type, parent) : asName(rel ? `${rel}/${name}` : name));
-        if (type === "dir") {
-          let children;
+        out.push(options.withFileTypes ? dirent(name, type, parent) : asName(rel ? `${rel}/${name}` : name));
+        let descend = type === "dir";
+        if (followLinks && type === "link" && links < MAX_LINK_DEPTH) {
           try {
-            children = syncFs.readdir(full);
+            descend = !!syncFs.stat(full).isDirectory;
           } catch {
-            children = [];
+            descend = false;
           }
-          queue.push({
-            dir: full,
-            rel: rel ? `${rel}/${name}` : name,
-            parent: path.join(parent, name),
-            names: children
-          });
         }
+        if (!descend) continue;
+        let children;
+        try {
+          children = syncFs.readdir(full);
+        } catch {
+          continue;
+        }
+        queue.push({
+          dir: full,
+          rel: rel ? `${rel}/${name}` : name,
+          parent: path.join(parent, name),
+          names: children,
+          links: links + (type === "link" ? 1 : 0)
+        });
       }
     }
     return out;
@@ -11703,6 +12249,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
   const syncApi = {
     readFileSync(p, options) {
       const encoding = optEncoding(options);
+      checkEncoding(encoding);
       if (p === 0 || p === "0") return readStdinSync(encoding);
       if (typeof p === "number") {
         const ent = fdTable.get(p);
@@ -11726,13 +12273,13 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
         if (st.isDirectory) {
           const e = new Error("EISDIR: illegal operation on a directory, read");
           e.code = "EISDIR";
-          e.errno = ERRNO.EISDIR;
+          e.errno = ERRNO2.EISDIR;
           e.syscall = "read";
           throw e;
         }
         return decodeAs(syncFs.readFile(target), encoding);
       } catch (err) {
-        if (err?.code && err.syscall) throw err;
+        if (err?.code && err.syscall || String(err?.code).startsWith("ERR_")) throw err;
         throw nodeFsError(err?.code || "ENOENT", "open", pathArg, err);
       }
     },
@@ -11750,6 +12297,23 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
       const pathArg = p;
       const target = abs(p);
       if (flag.includes("x") && syncFs.exists(target)) throw nodeFsError("EEXIST", "open", pathArg);
+      if (flag.startsWith("r")) {
+        let cur;
+        try {
+          cur = syncFs.readFile(target);
+        } catch (err) {
+          throw nodeFsError(err?.code || "ENOENT", "open", pathArg, err);
+        }
+        const out = new Uint8Array(Math.max(cur.length, bytes.length));
+        out.set(cur, 0);
+        out.set(bytes, 0);
+        try {
+          syncFs.writeFile(target, out);
+        } catch (err) {
+          throw nodeFsError(err?.code || "EIO", "write", pathArg, err);
+        }
+        return;
+      }
       try {
         syncFs.writeFile(target, bytes);
       } catch (err) {
@@ -11758,6 +12322,11 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     },
     appendFileSync(p, data2, options) {
       const next = encodeAs(data2, optEncoding(options));
+      const flag = optFlag(options, "a");
+      if (!flag.includes("a")) {
+        syncApi.writeFileSync(p, next, { flag });
+        return;
+      }
       if (typeof p === "number") {
         const ent = fdTable.get(p);
         let end = null;
@@ -11805,7 +12374,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     statSync(p, options) {
       const pathArg = p;
       try {
-        return statView(syncFs.stat(abs(p)));
+        return statView(syncFs.stat(abs(p)), options?.bigint === true);
       } catch (err) {
         const code = err?.code || "ENOENT";
         if (options?.throwIfNoEntry === false && (code === "ENOENT" || code === "ENOTDIR")) return void 0;
@@ -11815,27 +12384,17 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     lstatSync(p, options) {
       const pathArg = p;
       try {
-        return statView(syncFs.lstat(abs(p)));
+        return statView(syncFs.lstat(abs(p)), options?.bigint === true);
       } catch (err) {
         const code = err?.code || "ENOENT";
         if (options?.throwIfNoEntry === false && (code === "ENOENT" || code === "ENOTDIR")) return void 0;
         throw nodeFsError(code, "lstat", pathArg, err);
       }
     },
-    /**
-     * Resolve to a canonical absolute path. Symlink walk is not implemented;
-     * when the path exists we return the normalized absolute form (enough for
-     * pnpm's cmd shims, which only need dirname(realpathSync(argv[1]))).
-     */
-    realpathSync(p) {
-      const pathArg = p;
-      const target = abs(p);
-      try {
-        syncFs.stat(target);
-        return target;
-      } catch (err) {
-        throw nodeFsError(err?.code || "ENOENT", "realpath", pathArg, err);
-      }
+    /** Node's JS realpath: every symlink along the path resolved. */
+    realpathSync(p, options) {
+      const real = getCp().realpathSync(abs(p));
+      return optEncoding(options) === "buffer" ? wrapBuffer(encoder3.encode(real)) : real;
     },
     readdirSync,
     mkdirSync,
@@ -11991,11 +12550,11 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
         throw nodeFsError(err?.code || "EIO", "write", ent.path, err);
       }
     },
-    fstatSync(fd) {
+    fstatSync(fd, options) {
       const ent = fdTable.get(fd);
       if (!ent) throw nodeFsError("EBADF", "fstat", void 0);
       try {
-        return statView(syncFs.stat(ent.path));
+        return statView(syncFs.stat(ent.path), options?.bigint === true);
       } catch (err) {
         throw nodeFsError(err?.code || "EIO", "fstat", ent.path, err);
       }
@@ -12026,7 +12585,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
       try {
         syncFs.symlink(target, abs(p));
       } catch (err) {
-        throw nodeFsError(err?.code || "EIO", "symlink", p, err);
+        throw nodeFsError(err?.code || "EIO", "symlink", target, err, p);
       }
     },
     readlinkSync(p) {
@@ -12037,6 +12596,17 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
       }
     },
     copyFileSync(src, dest, mode = 0) {
+      if (mode == null) mode = 0;
+      if (typeof mode !== "number" || !Number.isInteger(mode)) {
+        const err = new TypeError("mode must be int32 or null/undefined");
+        err.code = "ERR_INVALID_ARG_TYPE";
+        throw err;
+      }
+      if (mode < 0 || mode > 7) {
+        const err = new RangeError("mode is out of range: >= 0 && <= 7");
+        err.code = "ERR_OUT_OF_RANGE";
+        throw err;
+      }
       const from = abs(src);
       const to = abs(dest);
       let st;
@@ -12053,42 +12623,10 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
         throw nodeFsError(err?.code || "EIO", "copyfile", src, err, dest);
       }
     },
-    cpSync(src, dest, options = {}) {
-      const from = abs(src);
-      const to = abs(dest);
-      if (from === to) throw cpInvalid(`src and dest cannot be the same ${src}`);
-      if (to.startsWith(`${from}/`)) {
-        throw cpInvalid(`Cannot copy ${src}/ to a subdirectory of self ${dest}`);
-      }
-      let st;
-      try {
-        st = syncFs.stat(from);
-      } catch (err) {
-        throw nodeFsError(err?.code || "ENOENT", "cp", src, err);
-      }
-      if (st.isDirectory) {
-        if (!options?.recursive) {
-          const e = new Error(`Recursive option not enabled, cannot copy a directory: ${src}/`);
-          e.code = "ERR_FS_EISDIR";
-          throw e;
-        }
-        mkdirSync(to, { recursive: true });
-        for (const name of syncFs.readdir(from)) {
-          syncApi.cpSync(path.join(from, name), path.join(to, name), options);
-        }
-        return;
-      }
-      const exists = syncFs.exists(to);
-      if (exists && options?.errorOnExist && options?.force === false) {
-        const e = new Error(`Target already exists: cp returned EEXIST (${to} already exists)`);
-        e.name = "SystemError";
-        e.code = "ERR_FS_CP_EEXIST";
-        throw e;
-      }
-      if (exists && options?.force === false) return;
-      syncFs.writeFile(to, syncFs.readFile(from));
+    cpSync(src, dest, options) {
+      getCp().cpSync(src, dest, options);
     },
-    mkdtempSync(prefix, options) {
+    mkdtempSync(prefix, options, { namedError = false } = {}) {
       const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
       const bytes = new Uint8Array(6);
       for (let attempt = 0; attempt < 100; attempt++) {
@@ -12096,6 +12634,14 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
         const name = `${prefix}${[...bytes].map((b) => chars[b % chars.length]).join("")}`;
         const target = abs(name);
         if (syncFs.exists(target)) continue;
+        const parent = path.dirname(target);
+        let parentOk = false;
+        try {
+          parentOk = !!syncFs.stat(parent).isDirectory;
+        } catch {
+          parentOk = false;
+        }
+        if (!parentOk) throw nodeFsError("ENOENT", "mkdtemp", namedError ? name : `${prefix}XXXXXX`);
         try {
           syncFs.mkdir(target);
         } catch (err) {
@@ -12156,11 +12702,51 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     fdatasyncSync(fd) {
       if (fd !== 0 && fd !== 1 && fd !== 2 && !fdTable.has(fd)) throw nodeFsError("EBADF", "fdatasync", void 0);
     },
-    opendirSync(p) {
-      const entries = readdirSync(p, { withFileTypes: true });
+    opendirSync(p, options) {
+      let entries;
+      try {
+        entries = readdirSync(p, { withFileTypes: true, recursive: options?.recursive === true }, { followLinks: false });
+      } catch (err) {
+        throw nodeFsError(err?.code || "ENOENT", "opendir", void 0, err);
+      }
       return createDir(String(p), entries);
+    },
+    linkSync(existingPath, newPath) {
+      try {
+        syncFs.link(abs(existingPath), abs(newPath));
+      } catch (err) {
+        throw nodeFsError(err?.code || "EIO", "link", existingPath, err, newPath);
+      }
     }
   };
+  let cpImpl;
+  function getCp() {
+    cpImpl ??= createCp({
+      path,
+      abs,
+      fsError: nodeFsError,
+      copyFileSync: (src, dest, mode) => syncApi.copyFileSync(src, dest, mode),
+      mkdirpSync: (p) => mkdirSync(p, { recursive: true }),
+      ops: {
+        lstat: (p) => syncFs.lstat(p),
+        stat: (p) => syncFs.stat(p),
+        readlink: (p) => syncFs.readlink(p),
+        symlink: (target, p) => syncFs.symlink(target, p),
+        readdir: (p) => syncFs.readdir(p),
+        mkdir: (p) => syncFs.mkdir(p),
+        unlink: (p) => syncFs.unlink(p)
+      }
+    });
+    return cpImpl;
+  }
+  function realpathNative(p, options) {
+    try {
+      return syncApi.realpathSync(p, options);
+    } catch (err) {
+      throw nodeFsError(err?.code || "ENOENT", "realpath", p, err);
+    }
+  }
+  syncApi.realpathSync.native = realpathNative;
   function createDir(dirPath, entries) {
     let closed = false;
     const next = () => {
@@ -12188,13 +12774,24 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
         return Promise.resolve().then(next);
       },
       closeSync() {
+        if (closed) next();
         closed = true;
       },
       close(cb) {
+        let err = null;
+        if (closed) {
+          try {
+            next();
+          } catch (e) {
+            err = e;
+          }
+        }
         closed = true;
-        if (typeof cb === "function") queueMicrotask(() => cb(null));
-        else return Promise.resolve();
-        return void 0;
+        if (typeof cb === "function") {
+          queueMicrotask(() => cb(err));
+          return void 0;
+        }
+        return err ? Promise.reject(err) : Promise.resolve();
       },
       async *[Symbol.asyncIterator]() {
         try {
@@ -12247,61 +12844,54 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
       return track(
         (async () => {
           const encoding = optEncoding(options);
+          checkEncoding(encoding);
           try {
             return decodeAs(await asyncFs.readFile(abs(p)), encoding);
           } catch (err) {
+            if (String(err?.code).startsWith("ERR_")) throw err;
             throw nodeFsError(err?.code || "ENOENT", "open", p, err);
           }
         })()
       );
     },
+    // The write happens when the call is made, as Node's open does in call
+    // order: a later `flag: 'wx'` sees the file an earlier writeFile made.
     writeFile(p, data2, options) {
-      return track(
-        (async () => {
-          const bytes = encodeAs(data2, optEncoding(options));
-          const flag = optFlag(options, "w");
-          if (flag.includes("a")) return promises.appendFile(p, bytes);
-          const target = abs(p);
-          if (flag.includes("x") && await asyncFs.exists(target)) throw nodeFsError("EEXIST", "open", p);
-          try {
-            await asyncFs.writeFile(target, bytes);
-          } catch (err) {
-            throw nodeFsError(err?.code || "EIO", "open", p, err);
-          }
-          return void 0;
-        })()
-      );
+      let result;
+      try {
+        syncApi.writeFileSync(p, data2, options);
+        result = Promise.resolve();
+      } catch (err) {
+        result = Promise.reject(err);
+      }
+      return track(result);
     },
     appendFile(p, data2, options) {
-      return track(
-        (async () => {
-          const target = abs(p);
-          let prev = new Uint8Array(0);
-          if (await asyncFs.exists(target)) prev = await asyncFs.readFile(target);
-          const next = encodeAs(data2, optEncoding(options));
-          const merged = new Uint8Array(prev.length + next.length);
-          merged.set(prev);
-          merged.set(next, prev.length);
-          await asyncFs.writeFile(target, merged);
-        })()
-      );
+      let result;
+      try {
+        syncApi.appendFileSync(p, data2, options);
+        result = Promise.resolve();
+      } catch (err) {
+        result = Promise.reject(err);
+      }
+      return track(result);
     },
-    stat(p) {
+    stat(p, options) {
       return track(
         (async () => {
           try {
-            return statView(await asyncFs.stat(abs(p)));
+            return statView(await asyncFs.stat(abs(p)), options?.bigint === true);
           } catch (err) {
             throw nodeFsError(err?.code || "ENOENT", "stat", p, err);
           }
         })()
       );
     },
-    lstat(p) {
+    lstat(p, options) {
       return track(
         (async () => {
           try {
-            return statView(await asyncFs.lstat(abs(p)));
+            return statView(await asyncFs.lstat(abs(p)), options?.bigint === true);
           } catch (err) {
             throw nodeFsError(err?.code || "ENOENT", "lstat", p, err);
           }
@@ -12309,7 +12899,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
       );
     },
     readdir(p, options) {
-      return track((async () => readdirSync(p, options))());
+      return track((async () => readdirSync(p, options, { followLinks: !options?.withFileTypes }))());
     },
     mkdir(p, options = {}) {
       return track((async () => mkdirSync(p, options))());
@@ -12324,16 +12914,19 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
       return track((async () => syncApi.copyFileSync(src, dest, mode))());
     },
     cp(src, dest, options) {
-      return track((async () => syncApi.cpSync(src, dest, options))());
+      return track(getCp().cp(src, dest, options));
+    },
+    link(existingPath, newPath) {
+      return track((async () => syncApi.linkSync(existingPath, newPath))());
     },
     mkdtemp(prefix, options) {
-      return track((async () => syncApi.mkdtempSync(prefix, options))());
+      return track((async () => syncApi.mkdtempSync(prefix, options, { namedError: true }))());
     },
     truncate(p, len) {
       return track((async () => syncApi.truncateSync(p, len))());
     },
-    realpath(p) {
-      return track((async () => syncApi.realpathSync(p))());
+    realpath(p, options) {
+      return track((async () => realpathNative(p, options))());
     },
     chmod(p) {
       return track((async () => syncApi.chmodSync(p))());
@@ -12353,8 +12946,8 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     lutimes(p) {
       return track((async () => syncApi.lutimesSync(p))());
     },
-    opendir(p) {
-      return track((async () => syncApi.opendirSync(p))());
+    opendir(p, options) {
+      return track((async () => syncApi.opendirSync(p, options))());
     },
     unlink(p) {
       return track(
@@ -12676,7 +13269,9 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     access: callbackify(syncApi.accessSync),
     stat: callbackify(syncApi.statSync),
     lstat: callbackify(syncApi.lstatSync),
-    realpath: callbackify(syncApi.realpathSync),
+    realpath: Object.assign(callbackify(syncApi.realpathSync), {
+      native: callbackify(realpathNative)
+    }),
     readdir: callbackify(syncApi.readdirSync),
     mkdir: callbackify(syncApi.mkdirSync, { minArgsBeforeCb: 2 }),
     rmdir: callbackify(syncApi.rmdirSync),
@@ -12708,7 +13303,16 @@ ${e.stack}
       return void 0;
     },
     copyFile: callbackify(syncApi.copyFileSync, { minArgsBeforeCb: 2 }),
-    cp: callbackify(syncApi.cpSync, { minArgsBeforeCb: 2 }),
+    cp(src, dest, options, callback) {
+      const cb = typeof options === "function" ? options : callback;
+      const opts = typeof options === "function" ? void 0 : options;
+      requireCallback(cb);
+      track(getCp().cp(src, dest, opts)).then(
+        () => cb(null),
+        (err) => cb(err)
+      );
+    },
+    link: callbackify(syncApi.linkSync, { minArgsBeforeCb: 2 }),
     mkdtemp: callbackify(syncApi.mkdtempSync),
     truncate: callbackify(syncApi.truncateSync),
     ftruncate: callbackify(syncApi.ftruncateSync),
@@ -14628,9 +15232,17 @@ function fileURLToPath(url) {
   }
   return decodeURIComponent(parsed.pathname);
 }
+var FILE_URL_SAFE = /[A-Za-z0-9\-._/!$&'()*+,;=:@]/;
+function encodeFilePath(path) {
+  let out = "";
+  for (const ch of path) {
+    if (FILE_URL_SAFE.test(ch)) out += ch;
+    else for (const b of new TextEncoder().encode(ch)) out += `%${b.toString(16).toUpperCase().padStart(2, "0")}`;
+  }
+  return out;
+}
 function pathToFileURL(path) {
-  const encoded = path.split("/").map((seg) => encodeURIComponent(seg)).join("/");
-  return new URL(`file://${encoded}`);
+  return new URL(`file://${encodeFilePath(path)}`);
 }
 function parse5(urlStr, parseQueryString = false, slashesDenoteHost = false) {
   void slashesDenoteHost;
@@ -14948,8 +15560,19 @@ function createResolver({
   path,
   readPackageJson,
   conditions = REQUIRE_CONDITIONS,
-  extensions = DEFAULT_EXTENSIONS
+  extensions = DEFAULT_EXTENSIONS,
+  preserveSymlinks: preserveSymlinks2 = false
 } = {}) {
+  const real = (filename) => {
+    if (preserveSymlinks2 || typeof fs.lstat !== "function" || typeof fs.readlink !== "function") {
+      return filename;
+    }
+    try {
+      return realpathWith(fs, path, filename, (code) => Object.assign(new Error(code), { code }));
+    } catch {
+      return filename;
+    }
+  };
   const tryStat = (p) => {
     try {
       if (!fs.exists(p)) return null;
@@ -15155,17 +15778,17 @@ function createResolver({
     const fromDir = parentFilename.endsWith("/") || tryStat(parentFilename)?.isDirectory ? parentFilename : path.dirname(parentFilename);
     if (request.startsWith("#")) {
       const hit = packageImportsResolve(request, parentFilename);
-      if (hit) return { type: "file", filename: hit };
+      if (hit) return { type: "file", filename: real(hit) };
       throw moduleNotFound(request, stack);
     }
     if (request.startsWith("/") || request.startsWith("./") || request.startsWith("../")) {
       const abs = path.resolve(fromDir, request);
       const hit = loadAsFileOrDir(abs);
-      if (hit) return { type: "file", filename: hit };
+      if (hit) return { type: "file", filename: real(hit) };
       throw moduleNotFound(request, stack);
     }
     const nm = loadNodeModules(request, fromDir);
-    if (nm) return { type: "file", filename: nm };
+    if (nm) return { type: "file", filename: real(nm) };
     throw moduleNotFound(request, stack);
   }
   return { resolve: resolve2, tryFile, loadAsDirectory };
@@ -15215,6 +15838,18 @@ function isBuiltinName(name) {
 
 // src/runtime/cjs/loader.mjs
 var decoder5 = new TextDecoder();
+function nodeModulePaths(dir) {
+  const parts = dir.split("/").filter(Boolean);
+  const out = [];
+  for (let i2 = parts.length; i2 >= 0; i2--) {
+    if (parts[i2 - 1] === "node_modules") continue;
+    out.push(`/${[...parts.slice(0, i2), "node_modules"].join("/")}`);
+  }
+  return out;
+}
+function preserveSymlinks(process2) {
+  return (process2?.execArgv ?? []).includes("--preserve-symlinks") || process2?.env?.NODE_PRESERVE_SYMLINKS === "1";
+}
 function createCjs({
   ctx,
   process: process2,
@@ -15240,7 +15875,7 @@ function createCjs({
       return null;
     }
   };
-  const resolver = createResolver({ fs, path, readPackageJson });
+  const resolver = createResolver({ fs, path, readPackageJson, preserveSymlinks: preserveSymlinks(process2) });
   const builtins = createBuiltins({ ctx, process: process2, Buffer: Buffer2, console: console2, path, handles, timers });
   const cache2 = /* @__PURE__ */ Object.create(null);
   function Module(id, parent) {
@@ -15251,9 +15886,10 @@ function createCjs({
     this.parent = parent ?? null;
     this.loaded = false;
     this.children = [];
-    this.paths = [];
+    this.paths = id.startsWith("/") ? nodeModulePaths(path.dirname(id)) : [];
   }
   Module._cache = cache2;
+  Module._nodeModulePaths = (from) => nodeModulePaths(path.resolve(process2.cwd(), String(from)));
   Module.builtinModules = [
     "assert",
     "assert/strict",
@@ -15556,6 +16192,7 @@ ${err.name}: ${err.message}`;
     mod.filename = filename;
     mod.id = filename === "[stdin]" || filename === "[eval]" ? filename : ".";
     mod.path = filename.startsWith("[") ? "." : path.dirname(filename);
+    mod.paths = nodeModulePaths(filename.startsWith("[") ? process2.cwd() : path.dirname(filename));
     cache2[filename] = mod;
     mainModule = setMain ? mod : void 0;
     if (filename.startsWith("[")) {
@@ -15586,6 +16223,7 @@ function parseNodeArgv(argv) {
   let print = false;
   let script;
   const userArgs = [];
+  const flags = [];
   let i2 = 0;
   while (i2 < args.length) {
     const arg = args[i2];
@@ -15633,6 +16271,11 @@ function parseNodeArgv(argv) {
       userArgs.push(...args.slice(i2));
       break;
     }
+    if (arg === "--preserve-symlinks" || arg === "--preserve-symlinks-main") {
+      flags.push(arg);
+      i2 += 1;
+      continue;
+    }
     if (arg.startsWith("-")) {
       if (arg === "-c" || arg === "--check") {
         i2 += 1;
@@ -15651,7 +16294,7 @@ function parseNodeArgv(argv) {
       code: evalCode,
       print,
       processArgv: [argv0, ...userArgs],
-      execArgv: [flag, evalCode]
+      execArgv: [...flags, flag, evalCode]
     };
   }
   if (script !== void 0) {
@@ -15659,13 +16302,13 @@ function parseNodeArgv(argv) {
       mode: "file",
       script,
       processArgv: [argv0, script, ...userArgs],
-      execArgv: []
+      execArgv: [...flags]
     };
   }
   return {
     mode: "empty",
     processArgv: [argv0],
-    execArgv: []
+    execArgv: [...flags]
   };
 }
 
@@ -15814,8 +16457,7 @@ var IMPORT_CONDITIONS = ["slicc", "import", "node", "default"];
 function pathToFileURL2(filename) {
   if (filename.startsWith("file:")) return filename;
   const p = filename.startsWith("/") ? filename : `/${filename}`;
-  const encoded = p.split("/").map((seg) => encodeURIComponent(seg)).join("/");
-  return `file://${encoded}`;
+  return `file://${encodeFilePath(p)}`;
 }
 function cjsToNamespace(exports) {
   if (exports && typeof exports === "object" && exports.__esModule && "default" in exports) {
@@ -15866,7 +16508,8 @@ function createEsm({ ctx, process: process2, handles, builtins, cjs, trackPromis
     path,
     readPackageJson,
     conditions: IMPORT_CONDITIONS,
-    extensions: [".js", ".mjs", ".cjs", ".json"]
+    extensions: [".js", ".mjs", ".cjs", ".json"],
+    preserveSymlinks: preserveSymlinks(process2)
   });
   const cache2 = /* @__PURE__ */ new Map();
   const evaluatingStack = /* @__PURE__ */ new Set();
@@ -15892,12 +16535,20 @@ function createEsm({ ctx, process: process2, handles, builtins, cjs, trackPromis
     if (source != null && shouldRunAsEsm(source)) return true;
     return false;
   }
+  function esmResolve(specifier, parentFilename) {
+    try {
+      return resolver.resolve(String(specifier), parentFilename, [parentFilename]);
+    } catch (err) {
+      if (err && err.code === "MODULE_NOT_FOUND") err.code = "ERR_MODULE_NOT_FOUND";
+      throw err;
+    }
+  }
   function makeImportMeta(filename) {
     const url = filename.startsWith("[") ? filename : pathToFileURL2(filename);
     const meta = {
       url,
       resolve(specifier) {
-        const resolved = resolver.resolve(String(specifier), filename, [filename]);
+        const resolved = esmResolve(specifier, filename);
         if (resolved.type === "builtin") return `node:${resolved.id}`;
         return pathToFileURL2(resolved.filename);
       }
@@ -15909,7 +16560,7 @@ function createEsm({ ctx, process: process2, handles, builtins, cjs, trackPromis
     return meta;
   }
   function resolveAndLoadSync(specifier, parentFilename) {
-    const resolved = resolver.resolve(specifier, parentFilename, [parentFilename]);
+    const resolved = esmResolve(specifier, parentFilename);
     if (resolved.type === "builtin") {
       return cjsToNamespace(builtins.load(resolved.id));
     }
@@ -15980,7 +16631,7 @@ ${code}`
       };
       const __preload = async () => {
         for (const spec of staticSpecs) {
-          const resolved = resolver.resolve(spec, filename, [filename]);
+          const resolved = esmResolve(spec, filename);
           if (resolved.type === "builtin") continue;
           const dep = cache2.get(resolved.filename);
           if (dep?.namespace) continue;
@@ -18202,13 +18853,14 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
         return 1;
       }
       process2.argv[1] = filePath;
+      const mainPath = realMainPath(ctx, filePath, process2.execArgv);
       try {
-        const useEsm = esm.isEsmFilename(filePath, source);
+        const useEsm = esm.isEsmFilename(mainPath, source);
         if (useEsm) {
-          const result = esm.runMain(filePath, source);
+          const result = esm.runMain(mainPath, source);
           if (result != null && typeof result.then === "function") setEntry(result, "esm");
         } else {
-          cjs.runMain(filePath, source);
+          cjs.runMain(mainPath, source);
         }
         nextTick.flushSync();
       } catch (err) {