@ai-ecoverse/slicc-jsh 0.3.5 → 0.3.7

package/dist/node.mjs

@@ -1539,7 +1539,7 @@ ${e3}`;
 // package.json
 var package_default = {
   name: "@ai-ecoverse/slicc-jsh",
-  version: "0.3.5",
+  version: "0.3.7",
   description: "Node.js-compatible runtime for slicc-kernel: the node and jsh commands (abi: js)",
   type: "module",
   license: "Apache-2.0",
@@ -3144,10 +3144,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 +3291,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") {
@@ -11284,8 +11285,10 @@ var ERRNO = {
   EACCES: -13,
   EINVAL: -22,
   EIO: -5,
-  ENOTEMPTY: -66,
-  EBADF: -9
+  ENOTEMPTY: -39,
+  // Linux (the shim's process.platform)
+  EBADF: -9,
+  ENOTSUP: -45
 };
 var DESCRIPTIONS = {
   ENOENT: "no such file or directory",
@@ -11297,7 +11300,8 @@ var DESCRIPTIONS = {
   EINVAL: "invalid argument",
   EIO: "i/o error",
   ENOTEMPTY: "directory not empty",
-  EBADF: "bad file descriptor"
+  EBADF: "bad file descriptor",
+  ENOTSUP: "operation not supported"
 };
 function nodeFsError(code, syscall, pathArg, err, dest) {
   const c = typeof code === "string" ? code : err?.code || "EIO";
@@ -11318,37 +11322,90 @@ function nodeFsError(code, syscall, pathArg, err, dest) {
   if (dest !== void 0) e.dest = dest;
   return e;
 }
+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";
+  e.code = "ERR_FS_EISDIR";
+  e.errno = 21;
+  e.syscall = "rm";
+  e.path = String(pathArg);
+  e.info = { code: "EISDIR", message: "is a directory", path: String(pathArg), syscall: "rm", errno: 21 };
+  return e;
+}
 function toBytes(data2) {
   if (typeof data2 === "string") return encoder3.encode(data2);
   if (data2 instanceof Uint8Array) return data2;
   if (ArrayBuffer.isView(data2)) return new Uint8Array(data2.buffer, data2.byteOffset, data2.byteLength);
   return encoder3.encode(String(data2));
 }
+var S_IFMT = 61440;
+var S_IFREG = 32768;
+var S_IFDIR = 16384;
+var S_IFLNK = 40960;
+var Stats = class {
+  isFile() {
+    return (this.mode & S_IFMT) === S_IFREG;
+  }
+  isDirectory() {
+    return (this.mode & S_IFMT) === S_IFDIR;
+  }
+  isSymbolicLink() {
+    return (this.mode & S_IFMT) === S_IFLNK;
+  }
+  isBlockDevice() {
+    return false;
+  }
+  isCharacterDevice() {
+    return false;
+  }
+  isFIFO() {
+    return false;
+  }
+  isSocket() {
+    return false;
+  }
+};
 function statView(st) {
   const mtimeMs = st.mtimeMs ?? (st.mtime ? Number(st.mtime) : 0);
   const atimeMs = st.atimeMs ?? mtimeMs;
   const ctimeMs = st.ctimeMs ?? mtimeMs;
-  return {
-    isFile: () => !!st.isFile,
-    isDirectory: () => !!st.isDirectory,
-    isSymbolicLink: () => !!st.isSymbolicLink,
-    size: st.size ?? 0,
-    mode: st.mode,
-    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;
+  return Object.assign(new Stats(), {
+    dev: st.dev ?? 0,
+    mode: type | perm,
+    nlink: st.nlink ?? 1,
+    uid: st.uid ?? 0,
+    gid: st.gid ?? 0,
+    rdev: 0,
+    blksize: 4096,
+    ino: st.ino ?? 0,
+    size,
+    blocks: Math.ceil(size / 512),
     atimeMs,
+    mtimeMs,
     ctimeMs,
-    mtime: new Date(mtimeMs),
+    birthtimeMs: ctimeMs,
     atime: new Date(atimeMs),
+    mtime: new Date(mtimeMs),
     ctime: new Date(ctimeMs),
-    birthtime: new Date(ctimeMs),
-    ino: st.ino,
-    dev: st.dev
-  };
+    birthtime: new Date(ctimeMs)
+  });
 }
 var Dirent = class {
-  constructor(name, type) {
+  constructor(name, type, parentPath) {
     this.name = name;
-    this._type = type;
+    this.parentPath = parentPath;
+    this.path = parentPath;
+    Object.defineProperty(this, "_type", { value: type, enumerable: false });
   }
   isFile() {
     return this._type === "file";
@@ -11380,6 +11437,20 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
   const syncFs = ctx.sync.fs;
   const asyncFs = ctx.fs;
   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 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);
+  };
+  const encodeAs = (data2, 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);
+    }
+    return toBytes(data2);
+  };
   const track = (p) => handles ? trackPromise(handles, p) : p;
   const fdTable = /* @__PURE__ */ new Map();
   let nextFd = 3;
@@ -11505,12 +11576,10 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
   function readStdinSync(encoding) {
     try {
       if (typeof process2?._readStdinSync === "function") {
-        const out = process2._readStdinSync();
-        return encoding ? decoder3.decode(out) : wrapBuffer(out);
+        return decodeAs(process2._readStdinSync(), encoding);
       }
       if (typeof process2?.stdin?._readAllSync === "function") {
-        const out = process2.stdin._readAllSync();
-        return encoding ? decoder3.decode(out) : wrapBuffer(out);
+        return decodeAs(process2.stdin._readAllSync(), encoding);
       }
       if (typeof ctx.sync?.read === "function") {
         const chunks = [];
@@ -11527,11 +11596,11 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
           out.set(c, at2);
           at2 += c.length;
         }
-        return encoding ? decoder3.decode(out) : wrapBuffer(out);
+        return decodeAs(out, encoding);
       }
     } catch {
     }
-    return encoding ? "" : wrapBuffer(new Uint8Array(0));
+    return decodeAs(new Uint8Array(0), encoding);
   }
   function mkdirSync(p, options = {}) {
     const pathArg = p;
@@ -11548,42 +11617,105 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     }
     const parts = String(target).split("/").filter(Boolean);
     let cur = "";
+    let first;
     for (const part of parts) {
       cur += `/${part}`;
-      if (syncFs.exists(cur)) continue;
+      if (syncFs.exists(cur)) {
+        let st;
+        try {
+          st = syncFs.stat(cur);
+        } catch {
+          st = null;
+        }
+        if (st && !st.isDirectory) throw nodeFsError("ENOTDIR", "mkdir", pathArg);
+        continue;
+      }
       try {
         syncFs.mkdir(cur);
+        first ??= path.isAbsolute(String(p)) ? cur : path.relative(process2.cwd(), cur);
       } catch (err) {
         if (err?.code === "EEXIST") continue;
         throw nodeFsError(err?.code || "EIO", "mkdir", pathArg, err);
       }
     }
+    return first;
+  }
+  const typeAt = (full) => {
+    try {
+      const st = syncFs.lstat(full);
+      return st.isDirectory ? "dir" : st.isSymbolicLink ? "link" : st.isFile ? "file" : "unknown";
+    } catch {
+      return "unknown";
+    }
+  };
+  function mustExist(p, syscall) {
+    let ok = false;
+    try {
+      ok = syncFs.exists(abs(p));
+    } catch {
+      ok = false;
+    }
+    if (!ok) throw nodeFsError("ENOENT", syscall, p);
   }
   function readdirSync(p, options) {
     const pathArg = p;
     const target = abs(p);
+    const encoding = optEncoding(options);
+    const asName = (name) => encoding === "buffer" ? wrapBuffer(encoder3.encode(name)) : name;
+    let names;
     try {
-      const names = syncFs.readdir(target);
+      names = syncFs.readdir(target);
+    } catch (err) {
+      throw nodeFsError(err?.code || "ENOENT", "scandir", pathArg, err);
+    }
+    if (!options?.recursive) {
       if (options?.withFileTypes) {
-        return names.map((name) => {
-          let type = "unknown";
+        return names.map((name) => new Dirent(name, typeAt(path.join(target, name)), String(pathArg)));
+      }
+      return names.map(asName);
+    }
+    const out = [];
+    const queue = [{ dir: target, rel: "", parent: String(pathArg), names }];
+    while (queue.length) {
+      const { dir, rel, parent, names: entries } = 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;
           try {
-            const st = syncFs.lstat(path.join(target, name));
-            type = st.isDirectory ? "dir" : st.isSymbolicLink ? "link" : st.isFile ? "file" : "unknown";
+            children = syncFs.readdir(full);
           } catch {
+            children = [];
           }
-          return new Dirent(name, type);
-        });
+          queue.push({
+            dir: full,
+            rel: rel ? `${rel}/${name}` : name,
+            parent: path.join(parent, name),
+            names: children
+          });
+        }
       }
-      return names;
-    } catch (err) {
-      throw nodeFsError(err?.code || "ENOENT", "scandir", pathArg, err);
     }
+    return out;
   }
   const syncApi = {
     readFileSync(p, options) {
-      const encoding = typeof options === "string" ? options : options?.encoding;
+      const encoding = optEncoding(options);
       if (p === 0 || p === "0") return readStdinSync(encoding);
+      if (typeof p === "number") {
+        const ent = fdTable.get(p);
+        if (!ent || !ent.readable) throw nodeFsError("EBADF", "read", void 0);
+        try {
+          const bytes = syncFs.readFile(ent.path);
+          const rest = bytes.subarray(Math.min(ent.pos, bytes.length));
+          ent.pos += rest.length;
+          return decodeAs(rest, encoding);
+        } catch (err) {
+          throw nodeFsError(err?.code || "EIO", "read", void 0, err);
+        }
+      }
       const pathArg = p;
       if (pathArg === "/dev/stdin" || pathArg === "/dev/fd/0") {
         return readStdinSync(encoding);
@@ -11598,32 +11730,52 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
           e.syscall = "read";
           throw e;
         }
-        const bytes = syncFs.readFile(target);
-        if (encoding) return decoder3.decode(bytes);
-        return wrapBuffer(bytes);
+        return decodeAs(syncFs.readFile(target), encoding);
       } catch (err) {
         if (err?.code && err.syscall) throw err;
         throw nodeFsError(err?.code || "ENOENT", "open", pathArg, err);
       }
     },
     writeFileSync(p, data2, options) {
+      const bytes = encodeAs(data2, optEncoding(options));
+      const flag = optFlag(options, "w");
+      if (typeof p === "number") {
+        syncApi.writeSync(p, bytes);
+        return;
+      }
+      if (flag.includes("a")) {
+        syncApi.appendFileSync(p, bytes);
+        return;
+      }
       const pathArg = p;
       const target = abs(p);
-      void options;
+      if (flag.includes("x") && syncFs.exists(target)) throw nodeFsError("EEXIST", "open", pathArg);
       try {
-        syncFs.writeFile(target, toBytes(data2));
+        syncFs.writeFile(target, bytes);
       } catch (err) {
         throw nodeFsError(err?.code || "EIO", "open", pathArg, err);
       }
     },
     appendFileSync(p, data2, options) {
+      const next = encodeAs(data2, optEncoding(options));
+      if (typeof p === "number") {
+        const ent = fdTable.get(p);
+        let end = null;
+        if (ent) {
+          try {
+            end = syncFs.stat(ent.path).size ?? 0;
+          } catch {
+            end = 0;
+          }
+        }
+        syncApi.writeSync(p, next, 0, next.length, end);
+        return;
+      }
       const pathArg = p;
       const target = abs(p);
-      void options;
       try {
         let prev = new Uint8Array(0);
         if (syncFs.exists(target)) prev = syncFs.readFile(target);
-        const next = toBytes(data2);
         const merged = new Uint8Array(prev.length + next.length);
         merged.set(prev);
         merged.set(next, prev.length);
@@ -11650,20 +11802,24 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
         throw nodeFsError(err?.code || "ENOENT", "access", pathArg, err);
       }
     },
-    statSync(p) {
+    statSync(p, options) {
       const pathArg = p;
       try {
         return statView(syncFs.stat(abs(p)));
       } catch (err) {
-        throw nodeFsError(err?.code || "ENOENT", "stat", pathArg, err);
+        const code = err?.code || "ENOENT";
+        if (options?.throwIfNoEntry === false && (code === "ENOENT" || code === "ENOTDIR")) return void 0;
+        throw nodeFsError(code, "stat", pathArg, err);
       }
     },
-    lstatSync(p) {
+    lstatSync(p, options) {
       const pathArg = p;
       try {
         return statView(syncFs.lstat(abs(p)));
       } catch (err) {
-        throw nodeFsError(err?.code || "ENOENT", "lstat", pathArg, err);
+        const code = err?.code || "ENOENT";
+        if (options?.throwIfNoEntry === false && (code === "ENOENT" || code === "ENOTDIR")) return void 0;
+        throw nodeFsError(code, "lstat", pathArg, err);
       }
     },
     /**
@@ -11683,37 +11839,57 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     },
     readdirSync,
     mkdirSync,
+    // The kernel's rm is recursive: only ever hand it an empty directory.
     rmdirSync(p, options = {}) {
       const pathArg = p;
       const target = abs(p);
+      let st;
       try {
-        if (options.recursive) {
-          syncApi.rmSync(p, { recursive: true, force: options.force });
-          return;
-        }
-        syncFs.rm(target);
+        st = syncFs.lstat(target);
       } catch (err) {
         throw nodeFsError(err?.code || "ENOENT", "rmdir", pathArg, err);
       }
+      if (!st.isDirectory) throw nodeFsError("ENOTDIR", "rmdir", pathArg);
+      if (options?.recursive) {
+        syncApi.rmSync(p, { recursive: true, force: options.force });
+        return;
+      }
+      let entries;
+      try {
+        entries = syncFs.readdir(target);
+      } catch (err) {
+        throw nodeFsError(err?.code || "EIO", "rmdir", pathArg, err);
+      }
+      if (entries.length > 0) throw nodeFsError("ENOTEMPTY", "rmdir", pathArg);
+      try {
+        syncFs.rm(target);
+      } catch (err) {
+        throw nodeFsError(err?.code || "EIO", "rmdir", pathArg, err);
+      }
     },
     rmSync(p, options = {}) {
       const pathArg = p;
       const target = abs(p);
+      let st;
+      try {
+        st = syncFs.lstat(target);
+      } catch (err) {
+        if (options?.force && (err?.code === "ENOENT" || err?.code === "ENOTDIR")) return;
+        throw nodeFsError(err?.code || "ENOENT", "lstat", pathArg, err);
+      }
+      if (st.isDirectory && !options?.recursive) throw rmIsDirectoryError(pathArg);
       try {
-        const st = syncFs.lstat(target);
         if (st.isDirectory) {
-          if (options.recursive) {
-            for (const name of syncFs.readdir(target)) {
-              syncApi.rmSync(path.join(target, name), { recursive: true, force: options.force });
-            }
+          for (const name of syncFs.readdir(target)) {
+            syncApi.rmSync(path.join(target, name), { recursive: true, force: options.force });
           }
           syncFs.rm(target);
         } else {
           syncFs.unlink(target);
         }
       } catch (err) {
-        if (options.force && (err?.code === "ENOENT" || !syncFs.exists(target))) return;
-        throw nodeFsError(err?.code || "ENOENT", "rm", pathArg, err);
+        if (err?.syscall) throw err;
+        throw nodeFsError(err?.code || "EIO", "rm", pathArg, err);
       }
     },
     unlinkSync(p) {
@@ -11788,7 +11964,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
         return n;
       }
       const ent = fdTable.get(fd);
-      if (!ent) throw nodeFsError("EBADF", "read", void 0);
+      if (!ent || !ent.readable) throw nodeFsError("EBADF", "read", void 0);
       try {
         const bytes = syncFs.readFile(ent.path);
         const pos = filePosition == null ? ent.pos : filePosition;
@@ -11807,7 +11983,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
         return bytes2.byteLength;
       }
       const ent = fdTable.get(fd);
-      if (!ent) throw nodeFsError("EBADF", "write", void 0);
+      if (!ent || !ent.writable) throw nodeFsError("EBADF", "write", void 0);
       const { bytes, filePosition } = parseWriteSyncArgs(data2, offset2, length, position);
       try {
         return writeBytesAtPath(ent, bytes, filePosition);
@@ -11859,8 +12035,176 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
       } catch (err) {
         throw nodeFsError(err?.code || "ENOENT", "readlink", p, err);
       }
+    },
+    copyFileSync(src, dest, mode = 0) {
+      const from = abs(src);
+      const to = abs(dest);
+      let st;
+      try {
+        st = syncFs.stat(from);
+      } catch (err) {
+        throw nodeFsError(err?.code || "ENOENT", "copyfile", src, err, dest);
+      }
+      if (st.isDirectory) throw nodeFsError("EISDIR", "copyfile", src, void 0, dest);
+      if (mode & 1 && syncFs.exists(to)) throw nodeFsError("EEXIST", "copyfile", src, void 0, dest);
+      try {
+        syncFs.writeFile(to, syncFs.readFile(from));
+      } catch (err) {
+        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));
+    },
+    mkdtempSync(prefix, options) {
+      const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+      const bytes = new Uint8Array(6);
+      for (let attempt = 0; attempt < 100; attempt++) {
+        crypto.getRandomValues(bytes);
+        const name = `${prefix}${[...bytes].map((b) => chars[b % chars.length]).join("")}`;
+        const target = abs(name);
+        if (syncFs.exists(target)) continue;
+        try {
+          syncFs.mkdir(target);
+        } catch (err) {
+          throw nodeFsError(err?.code || "ENOENT", "mkdtemp", `${prefix}XXXXXX`, err);
+        }
+        return optEncoding(options) === "buffer" ? wrapBuffer(encoder3.encode(name)) : name;
+      }
+      throw nodeFsError("EEXIST", "mkdtemp", `${prefix}XXXXXX`);
+    },
+    truncateSync(p, len = 0) {
+      if (typeof p === "number") {
+        syncApi.ftruncateSync(p, len);
+        return;
+      }
+      const target = abs(p);
+      let cur;
+      try {
+        cur = syncFs.readFile(target);
+      } catch (err) {
+        throw nodeFsError(err?.code || "ENOENT", "open", p, err);
+      }
+      const out = new Uint8Array(Math.max(0, len));
+      out.set(cur.subarray(0, Math.min(cur.length, out.length)), 0);
+      syncFs.writeFile(target, out);
+    },
+    // The kernel's JS fs has no mode bits, owners or times to set: these
+    // check that the path exists, as Node's do, and change nothing.
+    chmodSync(p) {
+      mustExist(p, "chmod");
+    },
+    lchmodSync(p) {
+      mustExist(p, "lchmod");
+    },
+    fchmodSync(fd) {
+      syncApi.fstatSync(fd);
+    },
+    chownSync(p) {
+      mustExist(p, "chown");
+    },
+    lchownSync(p) {
+      mustExist(p, "lchown");
+    },
+    fchownSync(fd) {
+      syncApi.fstatSync(fd);
+    },
+    utimesSync(p) {
+      mustExist(p, "utime");
+    },
+    lutimesSync(p) {
+      mustExist(p, "lutime");
+    },
+    futimesSync(fd) {
+      syncApi.fstatSync(fd);
+    },
+    fsyncSync(fd) {
+      if (fd !== 0 && fd !== 1 && fd !== 2 && !fdTable.has(fd)) throw nodeFsError("EBADF", "fsync", void 0);
+    },
+    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 });
+      return createDir(String(p), entries);
     }
   };
+  function createDir(dirPath, entries) {
+    let closed = false;
+    const next = () => {
+      if (closed) {
+        const e = new Error("Directory handle was closed");
+        e.code = "ERR_DIR_CLOSED";
+        throw e;
+      }
+      return entries.length ? entries.shift() : null;
+    };
+    return {
+      path: dirPath,
+      readSync: next,
+      read(cb) {
+        if (typeof cb === "function") {
+          queueMicrotask(() => {
+            try {
+              cb(null, next());
+            } catch (err) {
+              cb(err);
+            }
+          });
+          return void 0;
+        }
+        return Promise.resolve().then(next);
+      },
+      closeSync() {
+        closed = true;
+      },
+      close(cb) {
+        closed = true;
+        if (typeof cb === "function") queueMicrotask(() => cb(null));
+        else return Promise.resolve();
+        return void 0;
+      },
+      async *[Symbol.asyncIterator]() {
+        try {
+          for (let d = next(); d; d = next()) yield d;
+        } finally {
+          closed = true;
+        }
+      }
+    };
+  }
   function requireCallback(cb) {
     if (typeof cb === "function") return cb;
     let received;
@@ -11902,11 +12246,9 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     readFile(p, options) {
       return track(
         (async () => {
-          const encoding = typeof options === "string" ? options : options?.encoding;
+          const encoding = optEncoding(options);
           try {
-            const bytes = await asyncFs.readFile(abs(p));
-            if (encoding) return decoder3.decode(bytes);
-            return wrapBuffer(bytes);
+            return decodeAs(await asyncFs.readFile(abs(p)), encoding);
           } catch (err) {
             throw nodeFsError(err?.code || "ENOENT", "open", p, err);
           }
@@ -11916,23 +12258,27 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     writeFile(p, data2, options) {
       return track(
         (async () => {
-          void options;
+          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(abs(p), toBytes(data2));
+            await asyncFs.writeFile(target, bytes);
           } catch (err) {
             throw nodeFsError(err?.code || "EIO", "open", p, err);
           }
+          return void 0;
         })()
       );
     },
     appendFile(p, data2, options) {
       return track(
         (async () => {
-          void options;
           const target = abs(p);
           let prev = new Uint8Array(0);
           if (await asyncFs.exists(target)) prev = await asyncFs.readFile(target);
-          const next = toBytes(data2);
+          const next = encodeAs(data2, optEncoding(options));
           const merged = new Uint8Array(prev.length + next.length);
           merged.set(prev);
           merged.set(next, prev.length);
@@ -11963,75 +12309,52 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
       );
     },
     readdir(p, options) {
-      return track(
-        (async () => {
-          try {
-            const names = await asyncFs.readdir(abs(p));
-            if (options?.withFileTypes) {
-              const out = [];
-              for (const name of names) {
-                let type = "unknown";
-                try {
-                  const st = await asyncFs.lstat(path.join(abs(p), name));
-                  type = st.isDirectory ? "dir" : st.isSymbolicLink ? "link" : st.isFile ? "file" : "unknown";
-                } catch {
-                }
-                out.push(new Dirent(name, type));
-              }
-              return out;
-            }
-            return names;
-          } catch (err) {
-            throw nodeFsError(err?.code || "ENOENT", "scandir", p, err);
-          }
-        })()
-      );
+      return track((async () => readdirSync(p, options))());
     },
     mkdir(p, options = {}) {
-      return track(
-        (async () => {
-          const target = abs(p);
-          if (options?.recursive) {
-            const parts = String(target).split("/").filter(Boolean);
-            let cur = "";
-            for (const part of parts) {
-              cur += `/${part}`;
-              if (await asyncFs.exists(cur)) continue;
-              try {
-                await asyncFs.mkdir(cur);
-              } catch (err) {
-                if (err?.code !== "EEXIST") throw nodeFsError(err?.code || "EIO", "mkdir", p, err);
-              }
-            }
-            return;
-          }
-          if (await asyncFs.exists(target)) throw nodeFsError("EEXIST", "mkdir", p);
-          await asyncFs.mkdir(target);
-        })()
-      );
+      return track((async () => mkdirSync(p, options))());
     },
     rm(p, options = {}) {
-      return track(
-        (async () => {
-          const target = abs(p);
-          try {
-            const st = await asyncFs.lstat(target);
-            if (st.isDirectory) {
-              if (options.recursive) {
-                for (const name of await asyncFs.readdir(target)) {
-                  await promises.rm(path.join(target, name), { recursive: true, force: options.force });
-                }
-              }
-              await asyncFs.rm(target);
-            } else {
-              await asyncFs.unlink(target);
-            }
-          } catch (err) {
-            if (options.force && err?.code === "ENOENT") return;
-            throw nodeFsError(err?.code || "ENOENT", "rm", p, err);
-          }
-        })()
-      );
+      return track((async () => syncApi.rmSync(p, options))());
+    },
+    rmdir(p, options = {}) {
+      return track((async () => syncApi.rmdirSync(p, options))());
+    },
+    copyFile(src, dest, mode) {
+      return track((async () => syncApi.copyFileSync(src, dest, mode))());
+    },
+    cp(src, dest, options) {
+      return track((async () => syncApi.cpSync(src, dest, options))());
+    },
+    mkdtemp(prefix, options) {
+      return track((async () => syncApi.mkdtempSync(prefix, options))());
+    },
+    truncate(p, len) {
+      return track((async () => syncApi.truncateSync(p, len))());
+    },
+    realpath(p) {
+      return track((async () => syncApi.realpathSync(p))());
+    },
+    chmod(p) {
+      return track((async () => syncApi.chmodSync(p))());
+    },
+    lchmod(p) {
+      return track((async () => syncApi.lchmodSync(p))());
+    },
+    chown(p) {
+      return track((async () => syncApi.chownSync(p))());
+    },
+    lchown(p) {
+      return track((async () => syncApi.lchownSync(p))());
+    },
+    utimes(p) {
+      return track((async () => syncApi.utimesSync(p))());
+    },
+    lutimes(p) {
+      return track((async () => syncApi.lutimesSync(p))());
+    },
+    opendir(p) {
+      return track((async () => syncApi.opendirSync(p))());
     },
     unlink(p) {
       return track(
@@ -12120,10 +12443,32 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
         ensureOpen("truncate");
         syncApi.ftruncateSync(fd, len);
       },
+      async readFile(options) {
+        ensureOpen("readFile");
+        return syncApi.readFileSync(fd, options);
+      },
+      async sync() {
+        ensureOpen("fsync");
+      },
+      async datasync() {
+        ensureOpen("fdatasync");
+      },
+      async chmod() {
+        ensureOpen("fchmod");
+      },
+      async chown() {
+        ensureOpen("fchown");
+      },
+      async utimes() {
+        ensureOpen("futimes");
+      },
       async close() {
         ensureOpen("close");
         closed = true;
         syncApi.closeSync(fd);
+      },
+      async [Symbol.asyncDispose ?? /* @__PURE__ */ Symbol.for("nodejs.asyncDispose")]() {
+        if (!closed) await handle.close();
       }
     };
     return handle;
@@ -12185,6 +12530,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     });
     r.path = p;
     r.bytesRead = 0;
+    Object.defineProperty(r, FS_READ_STREAM, { value: true });
     if (!openEmitted) {
       queueMicrotask(() => {
         if (openEmitted || r.destroyed) return;
@@ -12248,6 +12594,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     });
     w.path = p;
     w.bytesWritten = 0;
+    Object.defineProperty(w, FS_WRITE_STREAM, { value: true });
     if (!openEmitted) {
       queueMicrotask(() => {
         if (openEmitted || w.destroyed) return;
@@ -12270,10 +12617,20 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     }
     return w;
   }
+  function ReadStream(p, options) {
+    return createReadStream(p, options);
+  }
+  Object.defineProperty(ReadStream, Symbol.hasInstance, { value: (x) => !!x?.[FS_READ_STREAM] });
+  function WriteStream(p, options) {
+    return createWriteStream(p, options);
+  }
+  Object.defineProperty(WriteStream, Symbol.hasInstance, { value: (x) => !!x?.[FS_WRITE_STREAM] });
   return {
     ...syncApi,
     promises,
     Dirent,
+    ReadStream,
+    WriteStream,
     createReadStream,
     createWriteStream,
     readFile: callbackify(syncApi.readFileSync),
@@ -12321,10 +12678,55 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     lstat: callbackify(syncApi.lstatSync),
     realpath: callbackify(syncApi.realpathSync),
     readdir: callbackify(syncApi.readdirSync),
-    mkdir: callbackify(syncApi.mkdirSync),
+    mkdir: callbackify(syncApi.mkdirSync, { minArgsBeforeCb: 2 }),
     rmdir: callbackify(syncApi.rmdirSync),
     unlink: callbackify(syncApi.unlinkSync),
     rename: callbackify(syncApi.renameSync, { minArgsBeforeCb: 2 }),
+    // Node 22's rm does not check its callback up front: without one it does
+    // the work, then calls the missing callback and throws from there.
+    rm(p, options, callback) {
+      const cb = typeof options === "function" ? options : callback;
+      const opts = typeof options === "function" ? void 0 : options;
+      if (typeof cb === "function") return callbackify(syncApi.rmSync)(p, opts ?? {}, cb);
+      let err = null;
+      try {
+        syncApi.rmSync(p, opts ?? {});
+      } catch (e) {
+        err = e;
+      }
+      void err;
+      setTimeout(() => {
+        const e = new TypeError("callback is not a function");
+        e._fsPretty = `node:fs:1225
+      return callback(err);
+             ^
+
+${e.stack}
+`;
+        throw e;
+      }, 0);
+      return void 0;
+    },
+    copyFile: callbackify(syncApi.copyFileSync, { minArgsBeforeCb: 2 }),
+    cp: callbackify(syncApi.cpSync, { minArgsBeforeCb: 2 }),
+    mkdtemp: callbackify(syncApi.mkdtempSync),
+    truncate: callbackify(syncApi.truncateSync),
+    ftruncate: callbackify(syncApi.ftruncateSync),
+    chmod: callbackify(syncApi.chmodSync, { minArgsBeforeCb: 2 }),
+    lchmod: callbackify(syncApi.lchmodSync, { minArgsBeforeCb: 2 }),
+    fchmod: callbackify(syncApi.fchmodSync, { minArgsBeforeCb: 2 }),
+    chown: callbackify(syncApi.chownSync, { minArgsBeforeCb: 3 }),
+    lchown: callbackify(syncApi.lchownSync, { minArgsBeforeCb: 3 }),
+    fchown: callbackify(syncApi.fchownSync, { minArgsBeforeCb: 3 }),
+    utimes: callbackify(syncApi.utimesSync, { minArgsBeforeCb: 3 }),
+    lutimes: callbackify(syncApi.lutimesSync, { minArgsBeforeCb: 3 }),
+    futimes: callbackify(syncApi.futimesSync, { minArgsBeforeCb: 3 }),
+    fsync: callbackify(syncApi.fsyncSync),
+    fdatasync: callbackify(syncApi.fdatasyncSync),
+    opendir: callbackify(syncApi.opendirSync),
+    symlink: callbackify(syncApi.symlinkSync, { minArgsBeforeCb: 2 }),
+    readlink: callbackify(syncApi.readlinkSync),
+    Stats,
     constants: {
       F_OK: 0,
       R_OK: 4,
@@ -12335,7 +12737,15 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
       O_RDWR: 2,
       O_CREAT: 64,
       O_TRUNC: 512,
-      O_APPEND: 1024
+      O_APPEND: 1024,
+      O_EXCL: 128,
+      S_IFMT,
+      S_IFREG,
+      S_IFDIR,
+      S_IFLNK,
+      COPYFILE_EXCL: 1,
+      COPYFILE_FICLONE: 2,
+      COPYFILE_FICLONE_FORCE: 4
     }
   };
 }
@@ -14320,6 +14730,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();
@@ -14368,10 +14866,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,
@@ -16118,7 +16617,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)`;
@@ -16132,7 +16631,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;
@@ -16146,7 +16645,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;
@@ -16233,6 +16732,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 {
@@ -16513,7 +17038,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";