@ai-ecoverse/slicc-jsh 0.3.6 → 0.3.8

package/dist/node.mjs

@@ -1539,7 +1539,7 @@ ${e3}`;
 // package.json
 var package_default = {
   name: "@ai-ecoverse/slicc-jsh",
-  version: "0.3.6",
+  version: "0.3.8",
   description: "Node.js-compatible runtime for slicc-kernel: the node and jsh commands (abi: js)",
   type: "module",
   license: "Apache-2.0",
@@ -1609,7 +1609,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 +1751,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 +1807,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
@@ -3144,10 +3155,10 @@ function createBuffer() {
         e.code = "ERR_INVALID_ARG_TYPE";
         throw e;
       }
-      if (value instanceof ArrayBuffer) {
+      if (value instanceof ArrayBuffer || typeof SharedArrayBuffer === "function" && value instanceof SharedArrayBuffer) {
         const offset2 = encodingOrOffset ?? 0;
         const len = length ?? value.byteLength - offset2;
-        return Buffer2.fromBytes(new Uint8Array(value, offset2, len));
+        return new Buffer2(value, offset2, len);
       }
       if (value instanceof Uint8Array || Array.isArray(value) || ArrayBuffer.isView(value)) {
         return Buffer2.fromBytes(asUint8(value));
@@ -3291,12 +3302,13 @@ function createBuffer() {
       if (!isBufView(target)) throwBufferArgType("target", target);
       return Buffer2.compare(this, target);
     }
+    // Node: both are views on the same memory (slice is subarray's old name).
     slice(start, end) {
-      return Buffer2.fromBytes(Uint8Array.prototype.slice.call(this, start, end));
+      return this.subarray(start, end);
     }
     subarray(start, end) {
       const view = Uint8Array.prototype.subarray.call(this, start, end);
-      return Buffer2.fromBytes(view);
+      return new Buffer2(view.buffer, view.byteOffset, view.length);
     }
     fill(value, offset2 = 0, end = this.length, encoding = "utf8") {
       if (typeof offset2 === "string") {
@@ -10760,6 +10772,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",
@@ -11249,6 +11282,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,
@@ -11272,10 +11313,404 @@ 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 MAX_LINKS = 40;
+  function realpathSync(p) {
+    let resolved = path.resolve(String(p));
+    const knownHard = /* @__PURE__ */ new Set();
+    let hops = 0;
+    let current2 = "/";
+    let pos = 1;
+    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(() => ops.lstat(base), "lstat", base);
+      if (!st.isSymbolicLink) {
+        knownHard.add(base);
+        continue;
+      }
+      if (++hops > MAX_LINKS) throw fsError("ELOOP", "stat", base);
+      call(() => ops.stat(base), "stat", base);
+      const target = call(() => ops.readlink(base), "readlink", base);
+      resolved = path.resolve(previous, target, resolved.slice(pos));
+      current2 = "/";
+      pos = 1;
+    }
+    return resolved;
+  }
+  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,
@@ -11287,7 +11722,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",
@@ -11300,7 +11737,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";
@@ -11315,7 +11754,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;
@@ -11323,11 +11762,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";
@@ -11348,15 +11782,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;
@@ -11371,13 +11809,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,
@@ -11392,11 +11866,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 {
@@ -11438,12 +11908,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);
@@ -11614,9 +12118,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)) {
@@ -11631,12 +12143,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) => {
@@ -11656,11 +12171,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);
@@ -11669,32 +12187,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;
@@ -11702,6 +12228,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);
@@ -11725,13 +12252,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);
       }
     },
@@ -11749,6 +12276,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) {
@@ -11757,6 +12301,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;
@@ -11804,7 +12353,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;
@@ -11814,27 +12363,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,
@@ -11990,11 +12529,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);
       }
@@ -12025,7 +12564,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) {
@@ -12036,6 +12575,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;
@@ -12052,42 +12602,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++) {
@@ -12095,6 +12613,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) {
@@ -12155,11 +12681,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 = () => {
@@ -12187,13 +12753,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 {
@@ -12246,61 +12823,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);
           }
@@ -12308,7 +12878,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))());
@@ -12323,16 +12893,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))());
@@ -12352,8 +12925,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(
@@ -12675,7 +13248,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),
@@ -12707,7 +13282,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),
@@ -14729,6 +15313,94 @@ function notSupported3(id) {
   err.code = "ERR_NOT_SUPPORTED";
   throw err;
 }
+function describeReceived(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return `type string ('${value}')`;
+  if (typeof value === "function") return `function ${value.name || "<anonymous>"}`;
+  if (typeof value === "object") return `an instance of ${value.constructor?.name || "Object"}`;
+  return `type ${typeof value} (${String(value)})`;
+}
+function invalidArgType(name, expected, value) {
+  const err = new TypeError(
+    `The "${name}" argument must be ${expected}. Received ${describeReceived(value)}`
+  );
+  err.code = "ERR_INVALID_ARG_TYPE";
+  return err;
+}
+var TRANSCODE_ENCODINGS = {
+  ascii: "ascii",
+  latin1: "latin1",
+  binary: "latin1",
+  ucs2: "utf16le",
+  "ucs-2": "utf16le",
+  utf16le: "utf16le",
+  "utf-16le": "utf16le",
+  utf8: "utf8",
+  "utf-8": "utf8"
+};
+function bufferModule(Buffer2) {
+  const MAX_LENGTH = 2 ** 53 - 1;
+  const MAX_STRING_LENGTH = 536870888;
+  const fatal = new TextDecoder("utf-8", { fatal: true });
+  const bytesOf = (input) => {
+    if (input instanceof ArrayBuffer) return new Uint8Array(input);
+    if (typeof SharedArrayBuffer === "function" && input instanceof SharedArrayBuffer) {
+      return new Uint8Array(input);
+    }
+    if (ArrayBuffer.isView(input)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+    throw invalidArgType("input", "an instance of ArrayBuffer, Buffer, or TypedArray", input);
+  };
+  function SlowBuffer(size) {
+    return Buffer2.allocUnsafeSlow(size);
+  }
+  return {
+    Buffer: Buffer2,
+    SlowBuffer,
+    /**
+     * Node's transcode (ICU): text a target cannot hold becomes '?', as ICU's
+     * substitution does; invalid UTF-8 decodes to U+FFFD first.
+     */
+    transcode(source, fromEnc, toEnc) {
+      if (!(source instanceof Uint8Array)) {
+        throw invalidArgType("source", "an instance of Buffer or Uint8Array", source);
+      }
+      const from = TRANSCODE_ENCODINGS[String(fromEnc).toLowerCase()];
+      const to = TRANSCODE_ENCODINGS[String(toEnc).toLowerCase()];
+      if (!from || !to) {
+        const err = new Error("Unable to transcode Buffer [U_ILLEGAL_ARGUMENT_ERROR]");
+        err.code = "U_ILLEGAL_ARGUMENT_ERROR";
+        err.errno = 1;
+        throw err;
+      }
+      let text = Buffer2.from(source).toString(from);
+      if (to === "latin1") text = text.replace(/[^\u0000-\u00ff]/gu, "?");
+      else if (to === "ascii") text = text.replace(/[^\u0000-\u007f]/gu, "?");
+      return Buffer2.from(text, to);
+    },
+    isUtf8(input) {
+      const bytes = bytesOf(input);
+      try {
+        fatal.decode(bytes);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    isAscii(input) {
+      return bytesOf(input).every((b) => b < 128);
+    },
+    kMaxLength: MAX_LENGTH,
+    kStringMaxLength: MAX_STRING_LENGTH,
+    btoa: globalThis.btoa,
+    atob: globalThis.atob,
+    constants: { MAX_LENGTH, MAX_STRING_LENGTH },
+    INSPECT_MAX_BYTES: 50,
+    Blob: globalThis.Blob,
+    File: globalThis.File,
+    resolveObjectURL: () => void 0
+  };
+}
 function createBuiltins({ ctx, process: process2, Buffer: Buffer2, console: console2, path, handles, timers }) {
   const util2 = createUtil();
   const events = createEvents();
@@ -14777,10 +15449,11 @@ function createBuiltins({ ctx, process: process2, Buffer: Buffer2, console: cons
     }
     return childProcess;
   };
+  let bufferExports;
   let ModuleExport = null;
   const implemented = {
     process: () => process2,
-    buffer: () => ({ Buffer: Buffer2, kMaxLength: 2147483647, INSPECT_MAX_BYTES: 50 }),
+    buffer: () => bufferExports ??= bufferModule(Buffer2),
     console: () => console2,
     path: () => path,
     "path/posix": () => path,
@@ -16527,7 +17200,7 @@ function numericExitCode(value) {
   const n = Number(value);
   return Number.isFinite(n) ? n & 255 : 0;
 }
-function describeReceived(value) {
+function describeReceived2(value) {
   if (typeof value === "string") return `type string ('${value}')`;
   if (typeof value === "boolean") return `type boolean (${value})`;
   if (typeof value === "bigint") return `type bigint (${value}n)`;
@@ -16541,7 +17214,7 @@ function assignProcessExitCode(value) {
     const n = Number(value);
     if (value !== "" && Number.isInteger(n)) return n === 0 ? 0 : n;
     const err2 = new TypeError(
-      `The "code" argument must be of type number. Received ${describeReceived(value)}`
+      `The "code" argument must be of type number. Received ${describeReceived2(value)}`
     );
     err2.code = "ERR_INVALID_ARG_TYPE";
     throw err2;
@@ -16555,7 +17228,7 @@ function assignProcessExitCode(value) {
     throw err2;
   }
   const err = new TypeError(
-    `The "code" argument must be of type number. Received ${describeReceived(value)}`
+    `The "code" argument must be of type number. Received ${describeReceived2(value)}`
   );
   err.code = "ERR_INVALID_ARG_TYPE";
   throw err;
@@ -16642,6 +17315,32 @@ function toBytes2(value) {
   if (value == null) return "";
   return String(value);
 }
+function createEnv(initial) {
+  const target = { ...initial };
+  const coerce = (value) => {
+    if (typeof value === "symbol") {
+      throw new TypeError("Cannot convert a Symbol value to a string");
+    }
+    return String(value);
+  };
+  return new Proxy(target, {
+    set(t, key, value) {
+      if (typeof key === "symbol") {
+        t[key] = value;
+        return true;
+      }
+      t[key] = coerce(value);
+      return true;
+    },
+    defineProperty(t, key, desc) {
+      if (typeof key !== "symbol" && "value" in desc) {
+        t[key] = coerce(desc.value);
+        return true;
+      }
+      return Reflect.defineProperty(t, key, desc);
+    }
+  });
+}
 function writableStream(fd, writeSync, isTTY) {
   const ee = new EventEmitter();
   return {
@@ -16922,7 +17621,7 @@ var Process = class extends EventEmitter {
     this._onExit = onExit;
     this.argv = argv.slice();
     this.argv0 = argv[0] ?? "node";
-    this.env = { ...ctx.env };
+    this.env = createEnv(ctx.env);
     this.versions = { node: NODE_SHIM_VERSION };
     this.version = `v${NODE_SHIM_VERSION}`;
     this.platform = "linux";