@ai-ecoverse/slicc-jsh 0.3.4 → 0.3.6

package/dist/node.mjs

@@ -1536,56 +1536,10 @@ ${e3}`;
   }
 });
 
-// src/runtime/exit.mjs
-var NodeExitError = class extends Error {
-  constructor(code) {
-    super(`Process exited with code ${code}`);
-    this.name = "NodeExitError";
-    this.code = code;
-  }
-};
-function numericExitCode(value) {
-  const n = Number(value);
-  return Number.isFinite(n) ? n & 255 : 0;
-}
-function describeReceived(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)`;
-  if (Array.isArray(value)) return "an instance of Array";
-  if (typeof value === "object" && value !== null) return "an instance of Object";
-  return `type ${typeof value}`;
-}
-function assignProcessExitCode(value) {
-  if (value === null || value === void 0) return void 0;
-  if (typeof value === "string") {
-    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)}`
-    );
-    err2.code = "ERR_INVALID_ARG_TYPE";
-    throw err2;
-  }
-  if (typeof value === "number") {
-    if (Number.isInteger(value)) return value === 0 ? 0 : value;
-    const err2 = new RangeError(
-      `The value of "code" is out of range. It must be an integer. Received ${String(value)}`
-    );
-    err2.code = "ERR_OUT_OF_RANGE";
-    throw err2;
-  }
-  const err = new TypeError(
-    `The "code" argument must be of type number. Received ${describeReceived(value)}`
-  );
-  err.code = "ERR_INVALID_ARG_TYPE";
-  throw err;
-}
-
 // package.json
 var package_default = {
   name: "@ai-ecoverse/slicc-jsh",
-  version: "0.3.4",
+  version: "0.3.6",
   description: "Node.js-compatible runtime for slicc-kernel: the node and jsh commands (abi: js)",
   type: "module",
   license: "Apache-2.0",
@@ -1655,7 +1609,7 @@ var package_default = {
     "trust:dry": "npx fledgling sync --dry-run -y --skip-publish"
   },
   devDependencies: {
-    "@ai-ecoverse/slicc-kernel": "1.61.0",
+    "@ai-ecoverse/slicc-kernel": "1.63.0",
     "@ai-ecoverse/wasi-pnpm": "12.9.1-8",
     "abort-controller": "3.0.0",
     acorn: "8.19.0",
@@ -2318,16 +2272,12 @@ async function runJsh({ filename, engine, process: process2, console: console2 }
   const baseRequire = engine.createRequire(filename);
   const requireSliccy = createSliccyResolver({ engine, process: process2, require: baseRequire });
   const require2 = wrapRequire(baseRequire, requireSliccy, module);
-  try {
+  const body = (async () => {
     const fn = engine.compile(prepareSource(source), filename);
     await fn(process2, console2, require2, module, module.exports, engine.fetch, dirname2, filename);
     module.loaded = true;
-  } catch (err) {
-    if (engine.isExit(err)) return engine.exit(err.code);
-    engine.writeStderr(`${err?.stack ?? err}
-`);
-    return engine.exit(1);
-  }
+  })();
+  engine.started?.(body);
   return void 0;
 }
 
@@ -2365,7 +2315,7 @@ async function writeAll(stream, data2) {
   } catch {
   }
 }
-function kernelSpawn(ctx, process2) {
+function kernelSpawn(ctx, process2, track) {
   return (argv, { stdin } = {}) => {
     let child = null;
     const done = (async () => {
@@ -2396,7 +2346,7 @@ function kernelSpawn(ctx, process2) {
     })();
     return {
       kill: async (sig = "SIGTERM") => child ? child.kill(sig) : false,
-      done
+      done: track(done)
     };
   };
 }
@@ -2420,7 +2370,7 @@ async function runKernelJsh(ctx, rt, filename) {
   const { process: process2, console: console2 } = rt;
   let stdoutIsTTY = false;
   try {
-    stdoutIsTTY = !!await ctx.isatty?.(1);
+    stdoutIsTTY = !!await rt.track(Promise.resolve(ctx.isatty?.(1)));
   } catch {
     stdoutIsTTY = false;
   }
@@ -2432,11 +2382,11 @@ async function runKernelJsh(ctx, rt, filename) {
     writeStdout: (s) => process2.stdout.write(String(s)),
     writeStderr: (s) => process2.stderr.write(String(s)),
     stdoutIsTTY,
-    spawn: kernelSpawn(ctx, process2),
+    spawn: kernelSpawn(ctx, process2, rt.track),
     shell: ["sh", "-c"],
     fetch: rt.fetch,
-    isExit: (err) => err instanceof NodeExitError,
-    exit: (code) => process2.exit(code)
+    exit: (code) => process2.exit(code),
+    started: (body) => rt.setEntry(body, "jsh")
   };
   await runJsh({ filename, engine, process: process2, console: console2 });
 }
@@ -2517,7 +2467,14 @@ async function checkpoint(nextTick) {
     if (idle >= 6) break;
   }
 }
-async function drainLoop(handles, nextTick, { onBeforeExit, shouldStop } = {}) {
+var nativeSetTimeout = globalThis.setTimeout.bind(globalThis);
+var ENTRY_GRACE_TURNS = 8;
+function macrotask() {
+  return new Promise((resolve2) => {
+    nativeSetTimeout(resolve2, 0);
+  });
+}
+async function drainLoop(handles, nextTick, { onBeforeExit, shouldStop, weakPending } = {}) {
   for (; ; ) {
     await checkpoint(nextTick);
     if (shouldStop?.()) return;
@@ -2527,6 +2484,15 @@ async function drainLoop(handles, nextTick, { onBeforeExit, shouldStop } = {}) {
       await checkpoint(nextTick);
       continue;
     }
+    if (weakPending?.()) {
+      for (let i2 = 0; i2 < ENTRY_GRACE_TURNS; i2++) {
+        await macrotask();
+        await checkpoint(nextTick);
+        if (shouldStop?.() || handles.refCount > 0 || !weakPending()) break;
+      }
+      if (shouldStop?.()) return;
+      if (handles.refCount > 0 || !weakPending()) continue;
+    }
     if (onBeforeExit) {
       onBeforeExit();
       await checkpoint(nextTick);
@@ -11318,8 +11284,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",
@@ -11331,7 +11299,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";
@@ -11352,37 +11321,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";
@@ -11414,6 +11436,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;
@@ -11539,12 +11575,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 = [];
@@ -11561,11 +11595,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;
@@ -11582,42 +11616,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);
@@ -11632,32 +11729,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);
@@ -11684,20 +11801,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);
       }
     },
     /**
@@ -11717,37 +11838,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) {
@@ -11822,7 +11963,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;
@@ -11841,7 +11982,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);
@@ -11893,8 +12034,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;
@@ -11936,11 +12245,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);
           }
@@ -11950,23 +12257,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);
@@ -11997,75 +12308,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(
@@ -12154,10 +12442,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;
@@ -12219,6 +12529,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;
@@ -12282,6 +12593,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;
@@ -12304,10 +12616,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),
@@ -12355,10 +12677,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,
@@ -12369,7 +12736,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
     }
   };
 }
@@ -15618,20 +15993,12 @@ ${parts.join("\n")}`
       return cjs.runMain(filename, src);
     }
     const { hasTopLevelAwait } = transformEsm(src, filename);
-    if (hasTopLevelAwait) {
-      const p = evaluateEsmAsync(filename, src);
-      if (trackPromise2 && handles) trackPromise2(handles, p);
-      return p;
-    }
+    if (hasTopLevelAwait) return evaluateEsmAsync(filename, src);
     return evaluateEsm(filename, src);
   }
   function runEsmEval(code, filename = "[eval]") {
     const { hasTopLevelAwait } = transformEsm(code, filename);
-    if (hasTopLevelAwait) {
-      const p = evaluateEsmAsync(filename, code);
-      if (trackPromise2 && handles) trackPromise2(handles, p);
-      return p;
-    }
+    if (hasTopLevelAwait) return evaluateEsmAsync(filename, code);
     return evaluateEsm(filename, code);
   }
   function requireEsm(filename) {
@@ -15848,7 +16215,7 @@ function frameLocation(stack) {
   const file = m[1] === void 0 || m[0].includes("[eval]") ? "[eval]" : m[1];
   return { file, line: Number(m[2]), column: Number(m[3]) };
 }
-function snippetFor(ctx, loc, evalCode) {
+function snippetFor(ctx, loc, evalCode, fromPromise = false) {
   if (!loc) return null;
   let source;
   if (loc.file === "[eval]") source = evalCode;
@@ -15868,7 +16235,9 @@ function snippetFor(ctx, loc, evalCode) {
   let col2 = loc.column;
   const throwAt = text.search(/\bthrow\b/);
   const isAsyncLine = /\basync\b/.test(text);
-  if (loc.file === "[eval]" && throwAt === 0) {
+  if (fromPromise && loc.column >= 1) {
+    col2 = loc.column;
+  } else if (loc.file === "[eval]" && throwAt === 0) {
     col2 = 1;
   } else if (throwAt >= 0 && isAsyncLine && /\bthrow\s+new\b/.test(text)) {
     col2 = text.indexOf("new", throwAt) + 1;
@@ -15931,7 +16300,7 @@ function glueStackAndProps(stack, props) {
   if (!props) return frames;
   return `${frames} ${finalizeProps(props)}`;
 }
-function formatUncaughtError(err, { ctx, util: util2, version: version2, evalCode } = {}) {
+function formatUncaughtError(err, { ctx, util: util2, version: version2, evalCode, fromPromise } = {}) {
   const trailer = `
 Node.js v${version2}
 `;
@@ -16005,7 +16374,7 @@ ${trailer}` };
     }
   }
   const loc = frameLocation(rawStack);
-  const snip = snippetFor(ctx, loc, evalCode);
+  const snip = snippetFor(ctx, loc, evalCode, fromPromise);
   if (snip) head = `${snip.file}:${snip.lineNo}
 ${snip.text}
 ${snip.caret}
@@ -16102,7 +16471,7 @@ function collapseMatchingCauseFrames(body, err) {
 }
 function formatUnhandledRejection(reason, { ctx, util: util2, version: version2, evalCode } = {}) {
   if (reason instanceof Error) {
-    return formatUncaughtError(reason, { ctx, util: util2, version: version2, evalCode });
+    return formatUncaughtError(reason, { ctx, util: util2, version: version2, evalCode, fromPromise: true });
   }
   const trailer = `
 Node.js v${version2}
@@ -16114,13 +16483,84 @@ Node.js v${version2}
       new UnhandledPromiseRejection(reason);
       ^
 
-UnhandledPromiseRejection: ${msg} {
+UnhandledPromiseRejection: ${msg}
+    at throwUnhandledRejectionsMode (node:internal/process/promises:392:7)
+    at processPromiseRejections (node:internal/process/promises:475:17)
+    at process.processTicksAndRejections (node:internal/process/task_queues:106:32) {
   code: 'ERR_UNHANDLED_REJECTION'
 }
 `;
   return { body: body + trailer };
 }
 
+// src/runtime/exit.mjs
+var NodeExitError = class extends Error {
+  constructor(code) {
+    super(`Process exited with code ${code}`);
+    this.name = "NodeExitError";
+    this.code = code;
+    this.status = code;
+  }
+};
+function isExitError2(err) {
+  return err instanceof NodeExitError || err?.name === "NodeExitError" || err?.name === "JsExit";
+}
+function hardExitError(ctx, code) {
+  if (typeof ctx?.exit === "function") {
+    try {
+      ctx.exit(code);
+    } catch (err) {
+      if (err && typeof err === "object" && err.name === "JsExit") {
+        try {
+          Object.defineProperty(err, "name", { value: "NodeExitError", configurable: true, writable: true });
+          err.message = `Process exited with code ${code}`;
+          err.code = code;
+        } catch {
+        }
+        return err;
+      }
+    }
+  }
+  return new NodeExitError(code);
+}
+function numericExitCode(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n & 255 : 0;
+}
+function describeReceived(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)`;
+  if (Array.isArray(value)) return "an instance of Array";
+  if (typeof value === "object" && value !== null) return "an instance of Object";
+  return `type ${typeof value}`;
+}
+function assignProcessExitCode(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "string") {
+    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)}`
+    );
+    err2.code = "ERR_INVALID_ARG_TYPE";
+    throw err2;
+  }
+  if (typeof value === "number") {
+    if (Number.isInteger(value)) return value === 0 ? 0 : value;
+    const err2 = new RangeError(
+      `The value of "code" is out of range. It must be an integer. Received ${String(value)}`
+    );
+    err2.code = "ERR_OUT_OF_RANGE";
+    throw err2;
+  }
+  const err = new TypeError(
+    `The "code" argument must be of type number. Received ${describeReceived(value)}`
+  );
+  err.code = "ERR_INVALID_ARG_TYPE";
+  throw err;
+}
+
 // src/runtime/handles.mjs
 function createHandleTable() {
   const refed = /* @__PURE__ */ new Set();
@@ -16156,6 +16596,7 @@ function createHandleTable() {
 // src/runtime/next-tick.mjs
 function createNextTick() {
   const queue = [];
+  let stopped = false;
   return {
     nextTick(fn, ...args) {
       if (typeof fn !== "function") {
@@ -16171,7 +16612,12 @@ function createNextTick() {
         err.code = "ERR_INVALID_ARG_TYPE";
         throw err;
       }
-      queue.push(() => fn(...args));
+      if (!stopped) queue.push(() => fn(...args));
+    },
+    /** process.exit(): drop what is queued and ignore new ticks. */
+    stop() {
+      stopped = true;
+      queue.length = 0;
     },
     /** Run queued ticks synchronously. */
     flushSync() {
@@ -16513,8 +16959,12 @@ var Process = class extends EventEmitter {
       tls: false,
       cached_builtins: true
     };
-    const writeStdout = (value) => ctx.sync.write(1, toBytes2(value));
-    const writeStderr = (value) => ctx.sync.write(2, toBytes2(value));
+    const writeStdout = (value) => {
+      if (!this._silenced) ctx.sync.write(1, toBytes2(value));
+    };
+    const writeStderr = (value) => {
+      if (!this._silenced) ctx.sync.write(2, toBytes2(value));
+    };
     this._writeStdout = writeStdout;
     this._writeStderr = writeStderr;
     this.stdout = writableStream(1, writeStdout, false);
@@ -16640,24 +17090,29 @@ var Process = class extends EventEmitter {
     }
     this._cwd = this._ctx.resolve(path);
   }
+  /**
+   * Node's process.exit: 'exit' listeners run, then the program ends. The
+   * kernel is told the status at once (see hardExitError); what still runs
+   * while the throw unwinds — a user `catch` or `finally` — is silenced:
+   * its output is dropped, a second exit() keeps the first status, and
+   * timers and ticks are stopped.
+   */
   exit(...args) {
-    if (args.length === 0) {
-      const code2 = numericExitCode(this._assignedExitCode);
-      this._recordExit(code2);
-      try {
-        this.emit("exit", code2);
-      } catch {
-      }
-      throw new NodeExitError(code2);
-    }
-    this._assignedExitCode = assignProcessExitCode(args[0]);
+    if (this._exitError) throw this._exitError;
+    if (args.length > 0) this._assignedExitCode = assignProcessExitCode(args[0]);
     const code = numericExitCode(this._assignedExitCode);
     this._recordExit(code);
     try {
       this.emit("exit", code);
     } catch {
     }
-    throw new NodeExitError(code);
+    this._silenced = true;
+    try {
+      this._onHardExit?.(code);
+    } catch {
+    }
+    this._exitError = hardExitError(this._ctx, code);
+    throw this._exitError;
   }
   _recordExit(code) {
     this._didExit = true;
@@ -16666,8 +17121,9 @@ var Process = class extends EventEmitter {
     this._onExit?.(code);
   }
 };
-function createProcess({ ctx, argv, nextTick, onExit, handles, Buffer: Buffer2 }) {
+function createProcess({ ctx, argv, nextTick, onExit, onHardExit, handles, Buffer: Buffer2 }) {
   const process2 = new Process({ ctx, argv, nextTick, onExit, handles, Buffer: Buffer2 });
+  process2._onHardExit = onHardExit;
   return {
     process: process2,
     writeStdout: process2._writeStdout,
@@ -16690,11 +17146,12 @@ function Timeout() {
 function Immediate() {
 }
 function createTimers(handles, { onCallbackError } = {}) {
-  const nativeSetTimeout = globalThis.setTimeout.bind(globalThis);
+  const nativeSetTimeout2 = globalThis.setTimeout.bind(globalThis);
   const nativeClearTimeout = globalThis.clearTimeout.bind(globalThis);
   const nativeSetInterval = globalThis.setInterval.bind(globalThis);
   const nativeClearInterval = globalThis.clearInterval.bind(globalThis);
   const byId = /* @__PURE__ */ new Map();
+  let stopped = false;
   const runMethod = (handle, method, args) => {
     try {
       handle[method](...args);
@@ -16728,6 +17185,9 @@ function createTimers(handles, { onCallbackError } = {}) {
     };
   };
   const makeTimeout = (fn, delay, args, repeating) => {
+    if (stopped) {
+      return repeating ? nativeSetInterval(fn, delay, ...args) : nativeSetTimeout2(fn, delay, ...args);
+    }
     const state = {
       refed: true,
       id: null,
@@ -16737,18 +17197,20 @@ function createTimers(handles, { onCallbackError } = {}) {
     handle._onTimeout = fn;
     attachRefApi(handle, state);
     const fire = () => {
+      if (stopped) return;
       if (!state.repeating) {
         byId.delete(state.id);
         handles.delete(state);
       }
       runMethod(handle, "_onTimeout", args);
     };
-    state.id = repeating ? nativeSetInterval(fire, delay ?? 0) : nativeSetTimeout(fire, delay ?? 0);
+    state.id = repeating ? nativeSetInterval(fire, delay ?? 0) : nativeSetTimeout2(fire, delay ?? 0);
     byId.set(state.id, state);
     handles.add(state);
     return handle;
   };
   const makeImmediate = (fn, args) => {
+    if (stopped) return nativeSetTimeout2(fn, 0, ...args);
     const state = {
       refed: true,
       id: null,
@@ -16758,11 +17220,12 @@ function createTimers(handles, { onCallbackError } = {}) {
     handle._onImmediate = fn;
     attachRefApi(handle, state);
     const fire = () => {
+      if (stopped) return;
       byId.delete(state.id);
       handles.delete(state);
       runMethod(handle, "_onImmediate", args);
     };
-    state.id = nativeSetTimeout(fire, 0);
+    state.id = nativeSetTimeout2(fire, 0);
     byId.set(state.id, state);
     handles.add(state);
     return handle;
@@ -16778,7 +17241,7 @@ function createTimers(handles, { onCallbackError } = {}) {
   };
   return {
     setTimeout: (fn, delay, ...args) => {
-      if (typeof fn !== "function") return nativeSetTimeout(fn, delay, ...args);
+      if (typeof fn !== "function") return nativeSetTimeout2(fn, delay, ...args);
       return makeTimeout(fn, delay, args, false);
     },
     clearTimeout: (handle) => clear(handle, nativeClearTimeout),
@@ -16788,7 +17251,7 @@ function createTimers(handles, { onCallbackError } = {}) {
     },
     clearInterval: (handle) => clear(handle, nativeClearInterval),
     setImmediate: (fn, ...args) => {
-      if (typeof fn !== "function") return nativeSetTimeout(fn, 0, ...args);
+      if (typeof fn !== "function") return nativeSetTimeout2(fn, 0, ...args);
       return makeImmediate(fn, args);
     },
     clearImmediate: (handle) => clear(handle, nativeClearTimeout),
@@ -16800,12 +17263,60 @@ function createTimers(handles, { onCallbackError } = {}) {
       }
       byId.clear();
       handles.notify();
+    },
+    /** The program is ending: clear its timers; later ones bypass the table. */
+    stop() {
+      stopped = true;
+      this.clearPending();
     }
   };
 }
 
 // src/runtime/web/fetch.mjs
-function createFetch(ctx) {
+var BODY_METHODS = ["arrayBuffer", "blob", "bytes", "formData", "json", "text"];
+function trackBody(response, track) {
+  for (const name of BODY_METHODS) {
+    const method = response[name];
+    if (typeof method !== "function") continue;
+    Object.defineProperty(response, name, {
+      value: function tracked(...args) {
+        return track(method.apply(response, args));
+      },
+      configurable: true,
+      writable: true
+    });
+  }
+  const bodyDesc = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(response), "body");
+  if (!bodyDesc?.get) return response;
+  let wrapped;
+  Object.defineProperty(response, "body", {
+    configurable: true,
+    get() {
+      if (wrapped !== void 0) return wrapped;
+      const original = bodyDesc.get.call(response);
+      if (original == null || typeof ReadableStream !== "function") {
+        wrapped = original;
+        return wrapped;
+      }
+      let reader;
+      wrapped = new ReadableStream({
+        async pull(controller) {
+          reader ??= original.getReader();
+          const { value, done } = await track(reader.read());
+          if (done) controller.close();
+          else controller.enqueue(value);
+        },
+        cancel(reason) {
+          return (reader ?? original).cancel(reason);
+        }
+      });
+      return wrapped;
+    }
+  });
+  return response;
+}
+function createFetch(ctx, { handles } = {}) {
+  const track = (p) => handles ? trackPromise(handles, p) : p;
   async function fetch(input, init) {
     if (typeof ctx.fetch !== "function") {
       const err = new TypeError("fetch failed");
@@ -16814,7 +17325,13 @@ function createFetch(ctx) {
       });
       throw err;
     }
-    return ctx.fetch(input, init);
+    const response = await track(ctx.fetch(input, init));
+    if (!handles || response == null || typeof response !== "object") return response;
+    try {
+      return trackBody(response, track);
+    } catch {
+      return response;
+    }
   }
   return fetch;
 }
@@ -17129,6 +17646,43 @@ function installJshGlobals(bindings) {
     }
   };
 }
+function trackPlatformAsync(handles) {
+  const undo = [];
+  const wrap = (target, names) => {
+    if (!target) return;
+    for (const name of names) {
+      const original = target[name];
+      if (typeof original !== "function") continue;
+      try {
+        target[name] = function tracked(...args) {
+          return trackPromise(handles, original.apply(this, args));
+        };
+        undo.push(() => {
+          target[name] = original;
+        });
+      } catch {
+      }
+    }
+  };
+  wrap(globalThis.SubtleCrypto?.prototype, [
+    "decrypt",
+    "deriveBits",
+    "deriveKey",
+    "digest",
+    "encrypt",
+    "exportKey",
+    "generateKey",
+    "importKey",
+    "sign",
+    "unwrapKey",
+    "verify",
+    "wrapKey"
+  ]);
+  wrap(globalThis.WebAssembly, ["compile", "compileStreaming", "instantiate", "instantiateStreaming"]);
+  return () => {
+    for (const fn of undo.reverse()) fn();
+  };
+}
 async function runNode(ctx, options = {}) {
   installStackPrepare();
   const handles = createHandleTable();
@@ -17188,6 +17742,12 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
     Buffer: Buffer2,
     onExit: (code) => {
       exitStatus = code;
+    },
+    // process.exit(): nothing the unwinding code schedules may run.
+    onHardExit: () => {
+      timers.stop();
+      nextTick.stop();
+      handles.notify();
     }
   });
   process2.execArgv = parsed.execArgv ? [...parsed.execArgv] : [];
@@ -17196,12 +17756,13 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
     lastEvalCode = parsed.code;
   }
   const console2 = createConsole(writeStdout, writeStderr, util2);
-  const fetch = createFetch(ctx);
+  const fetch = createFetch(ctx, { handles });
+  const restorePlatform = trackPlatformAsync(handles);
   const WebSocket = createWebSocket(ctx, { handles, trackPromise });
   const timers = createTimers(handles, {
     onCallbackError: (err) => {
-      if (err instanceof NodeExitError) {
-        exitStatus = err.code;
+      if (isExitError2(err) || getDidExit()) {
+        exitStatus = getDidExit() ? getExitCode() : err.code;
         timers.clearPending();
         try {
           handles.notify();
@@ -17249,16 +17810,16 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
     } catch {
     }
     exitStatus = 1;
-    timers.clearPending();
+    timers.stop();
     try {
       ctx.exit?.(1);
     } catch {
     }
   };
-  const isExit = (err) => err instanceof NodeExitError || err?.name === "NodeExitError" || getDidExit();
+  const isExit = (err) => isExitError2(err) || getDidExit();
   const rejectionHandler = (reason, promise) => {
     if (isExit(reason)) {
-      exitStatus = reason instanceof NodeExitError || reason?.name === "NodeExitError" ? Number(reason.code) & 255 : getExitCode();
+      exitStatus = getDidExit() ? getExitCode() : Number(reason.code) & 255;
       timers.clearPending();
       try {
         handles.notify();
@@ -17277,16 +17838,16 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
       evalCode: lastEvalCode
     });
     writeStderr(body);
+    exitStatus = 1;
+    timers.stop();
     try {
       ctx.exit?.(1);
     } catch {
     }
-    exitStatus = 1;
-    timers.clearPending();
   };
   const exceptionHandler = (err) => {
     if (isExit(err)) {
-      exitStatus = err instanceof NodeExitError || err?.name === "NodeExitError" ? Number(err.code) & 255 : getExitCode();
+      exitStatus = getDidExit() ? getExitCode() : Number(err.code) & 255;
       timers.clearPending();
       try {
         handles.notify();
@@ -17357,8 +17918,27 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
   });
   cjs.setRequireEsmHook((filename) => esm.requireEsm(filename));
   cjs.setImportModuleHook((specifier, parent) => esm.importModule(specifier, parent));
+  let entry = null;
+  const setEntry = (promise, kind) => {
+    const current2 = { kind, pending: true, promise };
+    entry = current2;
+    Promise.resolve(promise).then(
+      () => {
+        current2.pending = false;
+        handles.notify();
+      },
+      (err) => {
+        current2.pending = false;
+        if (kind === "jsh") rejectionHandler(err, promise);
+        else exceptionHandler(err);
+        handles.notify();
+      }
+    );
+  };
   try {
     const rt = {
+      setEntry,
+      track: (promise) => trackPromise(handles, promise),
       process: process2,
       console: console2,
       Buffer: Buffer2,
@@ -17378,7 +17958,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
         }
         nextTick.flushSync();
       } catch (err) {
-        if (err instanceof NodeExitError) throw err;
+        if (isExitError2(err)) throw err;
         if (process2.listenerCount("uncaughtException") > 0) {
           process2.emit(
             "uncaughtException",
@@ -17426,7 +18006,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
         cjs.runMain("[stdin]", source, { setMain: false });
         nextTick.flushSync();
       } catch (err) {
-        if (err instanceof NodeExitError) throw err;
+        if (isExitError2(err)) throw err;
         if (process2.listenerCount("uncaughtException") > 0) {
           process2.emit(
             "uncaughtException",
@@ -17448,10 +18028,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
 )` : parsed.code,
             "[eval]"
           );
-          if (result != null && typeof result.then === "function") {
-            trackPromise(handles, result);
-            await result;
-          }
+          if (result != null && typeof result.then === "function") setEntry(result, "esm");
           nextTick.flushSync();
         } else {
           const evalParent = `${process2.cwd()}/[eval]`;
@@ -17485,7 +18062,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
           }
         }
       } catch (err) {
-        if (err instanceof NodeExitError) throw err;
+        if (isExitError2(err)) throw err;
         if (process2.listenerCount("uncaughtException") > 0) {
           process2.emit(
             "uncaughtException",
@@ -17513,16 +18090,13 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
         const useEsm = esm.isEsmFilename(filePath, source);
         if (useEsm) {
           const result = esm.runMain(filePath, source);
-          if (result != null && typeof result.then === "function") {
-            trackPromise(handles, result);
-            await result;
-          }
+          if (result != null && typeof result.then === "function") setEntry(result, "esm");
         } else {
           cjs.runMain(filePath, source);
         }
         nextTick.flushSync();
       } catch (err) {
-        if (err instanceof NodeExitError) throw err;
+        if (isExitError2(err)) throw err;
         if (process2.listenerCount("uncaughtException") > 0) {
           process2.emit(
             "uncaughtException",
@@ -17543,8 +18117,17 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
       onBeforeExit: () => {
         emitBeforeExit();
       },
-      shouldStop: () => getDidExit() || exitStatus !== void 0
+      shouldStop: () => getDidExit() || exitStatus !== void 0,
+      weakPending: () => entry?.pending === true
     });
+    if (entry?.pending && entry.kind === "esm" && exitStatus === void 0 && !getDidExit()) {
+      const where = parsed.mode === "file" ? `file://${process2.argv[1]}` : "[eval1]";
+      writeStderr(`Warning: Detected unsettled top-level await at ${where}
+
+
+`);
+      exitStatus = 13;
+    }
     for (let i2 = 0; i2 < 3; i2++) {
       if (exitStatus !== void 0 || getDidExit()) break;
       await new Promise((resolve2) => {
@@ -17569,9 +18152,9 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
     }
     return code;
   } catch (err) {
-    if (err instanceof NodeExitError) {
+    if (isExitError2(err)) {
       timers.clearPending();
-      return err.code;
+      return getDidExit() ? getExitCode() : err.code;
     }
     try {
       printUncaught(err);
@@ -17582,7 +18165,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
     return 1;
   } finally {
     timers.clearPending();
-    for (const remove of removeCtxHooks) {
+    for (const remove of getDidExit() ? [] : removeCtxHooks) {
       try {
         remove?.();
       } catch {
@@ -17590,6 +18173,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
     }
     try {
       restoreGlobals();
+      restorePlatform();
       removeJshHandoff();
     } catch {
     }