sandboxedjs 0.1.80 → 0.1.83

package/dist/worker-entry.js

@@ -8795,7 +8795,7 @@ var require_path_browserify = __commonJS({
         if (hasRoot && end === 1) return "//";
         return path.slice(0, end);
       },
-      basename: function basename(path, ext) {
+      basename: function basename2(path, ext) {
         if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
         assertPath(path);
         var start = 0;
@@ -8849,7 +8849,7 @@ var require_path_browserify = __commonJS({
           return path.slice(start, end);
         }
       },
-      extname: function extname(path) {
+      extname: function extname2(path) {
         assertPath(path);
         var startDot = -1;
         var startPart = 0;
@@ -15513,6 +15513,18 @@ function dirname(p) {
   if (idx === 0) return "/";
   return norm.slice(0, idx);
 }
+function basename(p, ext) {
+  const norm = stripTrailing(normalize(p));
+  if (norm === "/") return "/";
+  const idx = norm.lastIndexOf("/");
+  let base2 = idx < 0 ? norm : norm.slice(idx + 1);
+  return base2;
+}
+function extname(p) {
+  const base2 = basename(p);
+  const idx = base2.lastIndexOf(".");
+  return idx <= 0 ? "" : base2.slice(idx);
+}
 function clean(p) {
   return stripTrailing(normalize(p));
 }
@@ -21686,6 +21698,49 @@ var CommonJsEngine = class {
     this.globals = { ...options.globals };
     this.aliases = { ...options.aliases };
     this.overrides = { ...options.overrides };
+    const engine = this;
+    this.moduleApi = function Module(id = "", parent = null) {
+      Object.assign(this, { id, filename: id, exports: {}, loaded: false, parent, children: [] });
+    };
+    Object.assign(this.moduleApi, this.builtins.module);
+    this.moduleApi.Module = this.moduleApi;
+    this.moduleApi._extensions = {
+      ".js": (module, filename) => this.evaluate(module, this.readText(filename)),
+      ".json": (module, filename) => {
+        module.exports = JSON.parse(this.readText(filename));
+      },
+      ".node": (_module, filename) => {
+        throw dlopenFailed(filename);
+      }
+    };
+    this.moduleApi._cache = new Proxy(/* @__PURE__ */ Object.create(null), {
+      get: (_target, key) => typeof key === "string" ? this.cache.get(key) : void 0,
+      set: (_target, key, value) => {
+        this.cache.set(String(key), value);
+        return true;
+      },
+      deleteProperty: (_target, key) => this.cache.delete(String(key)),
+      ownKeys: () => [...this.cache.keys()],
+      getOwnPropertyDescriptor: (_target, key) => this.cache.has(String(key)) ? { enumerable: true, configurable: true, writable: true, value: this.cache.get(String(key)) } : void 0
+    });
+    this.moduleApi._resolveFilename = (request, parent) => this.resolve(request, parent?.filename || join(this.cwd, "__entry__.js"));
+    this.moduleApi.prototype.require = function(request) {
+      const filename = engine.moduleApi._resolveFilename(request, this);
+      const builtin = engine.builtin(filename, this);
+      if (builtin.found) return builtin.value;
+      const target = engine.load(filename, this, false);
+      if (target.pending) throw requireOfAsyncModule(request);
+      return target.exports;
+    };
+    this.moduleApi.prototype._compile = function(source, filename) {
+      this.filename = filename;
+      engine.evaluate(this, source);
+    };
+    this.moduleApi.createRequire = (filename) => {
+      const path = String(filename).startsWith("file:") ? pathFromFileUrl(String(filename)) : String(filename);
+      if (!path.startsWith("/")) throw new TypeError("createRequire requires an absolute path or file URL");
+      return this.makeRequire(Object.assign(new this.moduleApi(path), { filename: path }));
+    };
   }
   volume;
   cache = /* @__PURE__ */ new Map();
@@ -21698,6 +21753,7 @@ var CommonJsEngine = class {
   /** `package.json` per directory; resolution reads them constantly. */
   manifests = /* @__PURE__ */ new Map();
   evaluationDepth = 0;
+  moduleApi;
   /**
    * Is a module body running synchronously right now?
    *
@@ -21734,7 +21790,7 @@ var CommonJsEngine = class {
       specifier = pathFromFileUrl(specifier);
     }
     const builtin = this.builtin(specifier);
-    if (builtin.found) return specifier.replace(/^node:/, "");
+    if (builtin.found) return specifier;
     if (specifier.startsWith("#")) {
       const found = this.resolveImports(specifier, importer, kind);
       if (found) return found;
@@ -21767,17 +21823,14 @@ var CommonJsEngine = class {
       parent,
       children: []
     };
+    Object.setPrototypeOf(module, this.moduleApi.prototype);
     this.cache.set(filename, module);
     parent?.children.push(module);
     if (isMain) this.main = module;
     try {
-      if (filename.endsWith(".node")) {
-        throw dlopenFailed(filename);
-      } else if (filename.endsWith(".json")) {
-        module.exports = JSON.parse(this.readText(filename));
-      } else {
-        this.evaluate(module, this.readText(filename));
-      }
+      const extension = extname(filename);
+      const loader = this.moduleApi._extensions[extension] ?? this.moduleApi._extensions[".js"];
+      loader(module, filename);
       module.loaded = true;
       return module;
     } catch (error) {
@@ -21830,15 +21883,12 @@ ${code}
   /** The `require` a module sees, complete with `resolve`, `cache` and `main`. */
   makeRequire(module) {
     const localRequire = ((specifier) => {
-      const builtin = this.builtin(specifier, module);
-      if (builtin.found) return builtin.value;
-      const target = this.load(this.resolve(specifier, module.filename, "require"), module, false);
-      if (target.pending) throw requireOfAsyncModule(specifier);
-      return target.exports;
+      return this.moduleApi.prototype.require.call(module, specifier);
     });
-    localRequire.resolve = (specifier) => this.resolve(specifier, module.filename, "require");
+    localRequire.resolve = (specifier) => this.moduleApi._resolveFilename(specifier, module);
     Object.defineProperty(localRequire, "main", { get: () => this.main });
-    localRequire.cache = Object.fromEntries(this.cache);
+    localRequire.cache = this.moduleApi._cache;
+    localRequire.extensions = this.moduleApi._extensions;
     return localRequire;
   }
   /**
@@ -22013,12 +22063,7 @@ ${code}
     if (prefixOnly || !Object.prototype.hasOwnProperty.call(this.builtins, name)) {
       return Object.prototype.hasOwnProperty.call(this.overrides, specifier) ? { found: true, value: this.overrides[specifier] } : { found: false, value: void 0 };
     }
-    if (name === "module" && importer) {
-      return {
-        found: true,
-        value: { ...this.builtins.module, createRequire: () => this.makeRequire(importer) }
-      };
-    }
+    if (name === "module") return { found: true, value: this.moduleApi };
     return { found: true, value: this.builtins[name] };
   }
   exists(path) {
@@ -22126,6 +22171,62 @@ function splitSpecifier(specifier) {
   return { name: parts.slice(0, size).join("/"), subpath: parts.slice(size).join("/") };
 }
 
+// src/node/diagnostics-channel.ts
+function createDiagnosticsChannel() {
+  const channels = /* @__PURE__ */ new Map();
+  class Channel {
+    constructor(name) {
+      this.name = name;
+    }
+    name;
+    listeners = /* @__PURE__ */ new Set();
+    get hasSubscribers() {
+      return this.listeners.size > 0;
+    }
+    subscribe(fn) {
+      if (typeof fn !== "function") throw new TypeError("subscriber must be a function");
+      this.listeners.add(fn);
+    }
+    unsubscribe(fn) {
+      return this.listeners.delete(fn);
+    }
+    publish(message) {
+      for (const fn of [...this.listeners]) {
+        try {
+          fn(message, this.name);
+        } catch (error) {
+          queueMicrotask(() => {
+            throw error;
+          });
+        }
+      }
+    }
+  }
+  const channel = (name) => {
+    if (typeof name !== "string" && typeof name !== "symbol") throw new TypeError("channel name must be a string or symbol");
+    let result = channels.get(name);
+    if (!result) {
+      result = new Channel(name);
+      channels.set(name, result);
+    }
+    return result;
+  };
+  return {
+    Channel,
+    channel,
+    hasSubscribers: (name) => channels.get(name)?.hasSubscribers ?? false,
+    subscribe: (name, fn) => channel(name).subscribe(fn),
+    unsubscribe: (name, fn) => channels.get(name)?.unsubscribe(fn) ?? false
+  };
+}
+
+// src/node/ipc-channel.ts
+var IPC_CHANNEL_ENV = "SANDBOXEDJS_IPC_CHANNEL";
+function newIpcChannelId() {
+  const random = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : Math.random().toString(36).slice(2);
+  return `ipc-${random}`;
+}
+
 // src/node/buffer-module.ts
 var import_buffer = __toESM(require_buffer());
 var platformBuffer = globalThis.Buffer;
@@ -22254,6 +22355,132 @@ ${lines[index]}`;
   return out;
 }
 
+// src/node/parse-args.ts
+function argError(code, message) {
+  return Object.assign(new TypeError(message), { code });
+}
+function parseArgs(config = {}) {
+  const args = config.args ?? globalThis.process?.argv?.slice(2) ?? [];
+  const options = config.options ?? {};
+  const strict = config.strict ?? true;
+  const allowPositionals = config.allowPositionals ?? !strict;
+  const allowNegative = config.allowNegative ?? false;
+  const byShort = /* @__PURE__ */ new Map();
+  for (const [name, option] of Object.entries(options)) {
+    if (option.type !== "string" && option.type !== "boolean") {
+      throw argError("ERR_INVALID_ARG_VALUE", `The property 'options.${name}.type' must be one of: 'string', 'boolean'`);
+    }
+    if (option.short !== void 0) {
+      if (option.short.length !== 1) {
+        throw argError("ERR_INVALID_ARG_VALUE", `The property 'options.${name}.short' must be a single character`);
+      }
+      byShort.set(option.short, name);
+    }
+  }
+  const tokens = [];
+  const takesValue = (name) => options[name]?.type === "string";
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--") {
+      tokens.push({ kind: "option-terminator", index });
+      for (let rest = index + 1; rest < args.length; rest++) tokens.push({ kind: "positional", index: rest, value: args[rest] });
+      break;
+    }
+    if (arg.startsWith("--") && arg.length > 2) {
+      const equals = arg.indexOf("=");
+      if (equals !== -1) {
+        tokens.push({ kind: "option", name: arg.slice(2, equals), rawName: arg.slice(0, equals), index, value: arg.slice(equals + 1), inlineValue: true });
+        continue;
+      }
+      const name = arg.slice(2);
+      if (takesValue(name) && index + 1 < args.length) {
+        tokens.push({ kind: "option", name, rawName: arg, index, value: args[index + 1], inlineValue: false });
+        index++;
+      } else {
+        tokens.push({ kind: "option", name, rawName: arg, index, value: void 0, inlineValue: void 0 });
+      }
+      continue;
+    }
+    if (arg.startsWith("-") && arg.length > 1) {
+      for (let at2 = 1; at2 < arg.length; at2++) {
+        const short = arg[at2];
+        const name = byShort.get(short) ?? short;
+        if (takesValue(name)) {
+          if (at2 + 1 < arg.length) {
+            tokens.push({ kind: "option", name, rawName: `-${short}`, index, value: arg.slice(at2 + 1), inlineValue: true });
+          } else if (index + 1 < args.length) {
+            tokens.push({ kind: "option", name, rawName: `-${short}`, index, value: args[index + 1], inlineValue: false });
+            index++;
+          } else {
+            tokens.push({ kind: "option", name, rawName: `-${short}`, index, value: void 0, inlineValue: void 0 });
+          }
+          break;
+        }
+        tokens.push({ kind: "option", name, rawName: `-${short}`, index, value: void 0, inlineValue: void 0 });
+      }
+      continue;
+    }
+    tokens.push({ kind: "positional", index, value: arg });
+  }
+  const values = /* @__PURE__ */ Object.create(null);
+  const positionals = [];
+  const store = (name, value) => {
+    if (options[name]?.multiple) {
+      const list = values[name] ?? [];
+      list.push(value);
+      values[name] = list;
+    } else {
+      values[name] = value;
+    }
+  };
+  for (const token of tokens) {
+    if (token.kind === "option-terminator") continue;
+    if (token.kind === "positional") {
+      if (!allowPositionals) {
+        throw argError("ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL", `Unexpected argument '${token.value}'. This command does not take positional arguments`);
+      }
+      positionals.push(token.value);
+      continue;
+    }
+    let name = token.name;
+    let negated = false;
+    if (allowNegative && name.startsWith("no-") && token.rawName.startsWith("--") && options[name.slice(3)]?.type === "boolean") {
+      name = name.slice(3);
+      negated = true;
+    }
+    const option = options[name];
+    if (!option) {
+      if (strict) {
+        throw argError(
+          "ERR_PARSE_ARGS_UNKNOWN_OPTION",
+          `Unknown option '${token.rawName}'${allowPositionals ? `. To specify a positional argument starting with a '-', place it at the end of the command after '--', as in '-- ${JSON.stringify(token.rawName)}'` : ""}`
+        );
+      }
+      store(name, token.value ?? true);
+      continue;
+    }
+    if (option.type === "string") {
+      if (token.value === void 0) {
+        if (strict) throw argError("ERR_PARSE_ARGS_INVALID_OPTION_VALUE", `Option '${token.rawName} <value>' argument missing`);
+        store(name, true);
+        continue;
+      }
+      store(name, token.value);
+    } else {
+      if (token.inlineValue && strict) {
+        throw argError("ERR_PARSE_ARGS_INVALID_OPTION_VALUE", `Option '${token.rawName}' does not take an argument`);
+      }
+      store(name, !negated);
+    }
+  }
+  for (const [name, option] of Object.entries(options)) {
+    if (option.default !== void 0 && values[name] === void 0) {
+      values[name] = Array.isArray(option.default) ? option.default.slice() : option.default;
+    }
+  }
+  return config.tokens ? { values, positionals, tokens } : { values, positionals };
+}
+
 // src/node/util-module.ts
 var customInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var promisifyCustom = /* @__PURE__ */ Symbol.for("nodejs.util.promisify.custom");
@@ -22282,8 +22509,9 @@ function render(value, depth, seen, options) {
   if (value === null) return "null";
   const object = value;
   const custom = object[customInspect];
-  if (typeof custom === "function") {
-    return String(custom.call(object, depth, options));
+  if (options.customInspect !== false && typeof custom === "function") {
+    const result = custom.call(object, depth, options, inspect);
+    if (result !== object) return typeof result === "string" ? result : render(result, depth, seen, options);
   }
   if (seen.has(object)) return "[Circular *1]";
   if (depth < 0) return Array.isArray(object) ? "[Array]" : "[Object]";
@@ -22618,6 +22846,7 @@ var legacy = {
 inspect.custom = customInspect;
 var utilModule = {
   parseEnv,
+  parseArgs,
   format,
   formatWithOptions,
   inspect,
@@ -28502,6 +28731,18 @@ function toBytes(data2) {
   abytes(data2);
   return data2;
 }
+function kdfInputToBytes(data2) {
+  if (typeof data2 === "string")
+    data2 = utf8ToBytes(data2);
+  abytes(data2);
+  return data2;
+}
+function checkOpts(defaults, opts) {
+  if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]")
+    throw new Error("options should be object or undefined");
+  const merged = Object.assign(defaults, opts);
+  return merged;
+}
 var Hash = class {
 };
 function createHasher(hashCons) {
@@ -29304,6 +29545,51 @@ var HMAC = class extends Hash {
 var hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
 hmac.create = (hash, key) => new HMAC(hash, key);
 
+// node_modules/@noble/hashes/esm/pbkdf2.js
+function pbkdf2Init(hash, _password, _salt, _opts) {
+  ahash(hash);
+  const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
+  const { c, dkLen, asyncTick } = opts;
+  anumber(c);
+  anumber(dkLen);
+  anumber(asyncTick);
+  if (c < 1)
+    throw new Error("iterations (c) should be >= 1");
+  const password = kdfInputToBytes(_password);
+  const salt = kdfInputToBytes(_salt);
+  const DK = new Uint8Array(dkLen);
+  const PRF = hmac.create(hash, password);
+  const PRFSalt = PRF._cloneInto().update(salt);
+  return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
+}
+function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
+  PRF.destroy();
+  PRFSalt.destroy();
+  if (prfW)
+    prfW.destroy();
+  clean2(u);
+  return DK;
+}
+function pbkdf2(hash, password, salt, opts) {
+  const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
+  let prfW;
+  const arr = new Uint8Array(4);
+  const view = createView(arr);
+  const u = new Uint8Array(PRF.outputLen);
+  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+    const Ti = DK.subarray(pos, pos + PRF.outputLen);
+    view.setInt32(0, ti, false);
+    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+    Ti.set(u.subarray(0, Ti.length));
+    for (let ui = 1; ui < c; ui++) {
+      PRF._cloneInto(prfW).update(u).digestInto(u);
+      for (let i = 0; i < Ti.length; i++)
+        Ti[i] ^= u[i];
+    }
+  }
+  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+}
+
 // src/node/crypto-module.ts
 var hashes = { md5, sha1, "sha-1": sha1, sha224: sha2242, "sha-224": sha2242, sha256: sha2562, "sha-256": sha2562, sha384: sha3842, "sha-384": sha3842, sha512: sha5122, "sha-512": sha5122 };
 function createCryptoModule() {
@@ -29341,6 +29627,28 @@ function createCryptoModule() {
       };
       return api;
     },
+    pbkdf2Sync(password, salt, iterations, keylen, digest) {
+      return pbkdf2Key(password, salt, iterations, keylen, digest);
+    },
+    /* Node derives the key on the libuv thread pool and calls back from the poll
+     * phase. Here it is derived on the calling thread — the ordering a program
+     * observes is the same (the call returns first, the callback comes on a later
+     * turn), but the main thread is busy while it computes. Invalid arguments throw
+     * synchronously, as in Node. */
+    pbkdf2(password, salt, iterations, keylen, digest, callback) {
+      if (typeof callback !== "function") {
+        throw Object.assign(new TypeError('The "callback" argument must be of type function'), { code: "ERR_INVALID_ARG_TYPE" });
+      }
+      hashFor(digest);
+      let key;
+      let failure = null;
+      try {
+        key = pbkdf2Key(password, salt, iterations, keylen, digest);
+      } catch (error) {
+        failure = error instanceof Error ? error : new Error(String(error));
+      }
+      setTimeout(() => failure ? callback(failure) : callback(null, key), 0);
+    },
     randomBytes(size, callback) {
       const value = Buffer2.alloc(size);
       cryptoObject.getRandomValues(value);
@@ -29390,6 +29698,15 @@ function createCryptoModule() {
     constants: {}
   };
 }
+function pbkdf2Key(password, salt, iterations, keylen, digest) {
+  if (!Number.isInteger(iterations) || iterations < 1) {
+    throw Object.assign(new RangeError(`The value of "iterations" is out of range. It must be >= 1. Received ${iterations}`), { code: "ERR_OUT_OF_RANGE" });
+  }
+  if (!Number.isInteger(keylen) || keylen < 0) {
+    throw Object.assign(new RangeError(`The value of "keylen" is out of range. It must be >= 0. Received ${keylen}`), { code: "ERR_OUT_OF_RANGE" });
+  }
+  return Buffer2.from(pbkdf2(hashFor(digest), toBytes2(password), toBytes2(salt), { c: iterations, dkLen: keylen }));
+}
 function hashFor(algorithm) {
   const hash = hashes[algorithm.toLowerCase()];
   if (!hash) throw Object.assign(new Error(`Digest method not supported: ${algorithm}`), { code: "ERR_OSSL_EVP_UNSUPPORTED" });
@@ -29499,20 +29816,10 @@ var SyncChannelClient = class {
 var import_events2 = __toESM(require_events());
 var import_stream_browserify3 = __toESM(require_stream_browserify());
 var ChildProcess = class extends import_events2.default {
-  stdout = new import_stream_browserify3.default.PassThrough();
-  stderr = new import_stream_browserify3.default.PassThrough();
-  stdin;
-  stdio;
-  pid;
-  exitCode = null;
-  signalCode = null;
-  killed = false;
-  spawnfile;
-  spawnargs;
-  handle;
-  settled = false;
-  constructor(handle, file, args) {
+  constructor(handle, file, args, referenceChanged = () => {
+  }) {
     super();
+    this.referenceChanged = referenceChanged;
     this.handle = handle;
     this.pid = handle.pid;
     this.spawnfile = file;
@@ -29537,31 +29844,90 @@ var ChildProcess = class extends import_events2.default {
     handle.on("stdout", (text) => this.stdout.write(text));
     handle.on("stderr", (text) => this.stderr.write(text));
     handle.on("exit", (code) => this.finish(code));
-    handle.exec();
+    referenceChanged(1);
+    try {
+      handle.exec();
+    } catch (error) {
+      this.unref();
+      throw error;
+    }
   }
+  referenceChanged;
+  stdout = new import_stream_browserify3.default.PassThrough();
+  stderr = new import_stream_browserify3.default.PassThrough();
+  stdin;
+  stdio;
+  pid;
+  exitCode = null;
+  signalCode = null;
+  killed = false;
+  spawnfile;
+  spawnargs;
+  handle;
+  settled = false;
+  referenced = true;
   kill(signal = "SIGTERM") {
     this.killed = true;
     this.handle.kill(typeof signal === "number" ? "SIGTERM" : signal);
     return true;
   }
   ref() {
+    if (!this.settled && !this.referenced) {
+      this.referenced = true;
+      this.referenceChanged(1);
+    }
     return this;
   }
   unref() {
+    if (this.referenced) {
+      this.referenced = false;
+      this.referenceChanged(-1);
+    }
     return this;
   }
-  disconnect() {
-    this.emit("disconnect");
-  }
-  /** No IPC channel exists, and reporting that honestly beats a silent drop. */
-  send() {
-    return false;
+  channel;
+  channelOpen = false;
+  /** Open the parent's end of a `fork` channel. */
+  attachChannel(transport, id) {
+    this.channelOpen = true;
+    this.channel = transport.attach(
+      id,
+      "parent",
+      (message) => this.emit("message", message, void 0),
+      () => this.channelClosed()
+    );
   }
   get connected() {
-    return false;
+    return this.channelOpen;
+  }
+  /** `send(message[, sendHandle][, options][, callback])`, as Node spells it. */
+  send(message, ...rest) {
+    const callback = rest.find((value) => typeof value === "function");
+    if (!this.channel || !this.channelOpen) {
+      const error = Object.assign(new Error("Channel closed"), { code: "ERR_IPC_CHANNEL_CLOSED" });
+      if (callback) queueMicrotask(() => callback(error));
+      else queueMicrotask(() => this.emit("error", error));
+      return false;
+    }
+    this.channel.send(message);
+    if (callback) queueMicrotask(() => callback(null));
+    return true;
+  }
+  disconnect() {
+    if (!this.channelOpen) return;
+    this.channel?.disconnect();
+    this.channelClosed();
+  }
+  channelClosed() {
+    if (!this.channelOpen) return;
+    this.channelOpen = false;
+    this.emit("disconnect");
   }
   finish(code) {
     if (this.settled) return;
+    this.channel?.disconnect();
+    this.channelClosed();
+    this.unref();
     this.settled = true;
     this.exitCode = code;
     this.stdout.end();
@@ -29570,7 +29936,7 @@ var ChildProcess = class extends import_events2.default {
     queueMicrotask(() => this.emit("close", code, null));
   }
 };
-function createChildProcessModule(spawnChild, defaultCwd, syncSpawn, defaultEnv = () => ({})) {
+function createChildProcessModule(spawnChild, defaultCwd, syncSpawn, defaultEnv = () => ({}), lifecycle = {}) {
   const environmentFor = (options) => options.env ? { ...options.env } : defaultEnv();
   const throughShell = (command, options) => {
     const shell = typeof options.shell === "string" ? options.shell : "/bin/sh";
@@ -29581,16 +29947,24 @@ function createChildProcessModule(spawnChild, defaultCwd, syncSpawn, defaultEnv
     if (stdio === "ignore") return true;
     return Array.isArray(stdio) && stdio[0] === "ignore";
   };
+  const wantsChannel = (options) => Array.isArray(options.stdio) && options.stdio.includes("ipc");
   const start = (file, args, options) => {
     const resolved = options.shell ? throughShell([file, ...args].join(" "), options) : { file, args };
+    const channelId = wantsChannel(options) && lifecycle.ipc ? newIpcChannelId() : void 0;
     const handle = spawnChild({
       command: resolved.file,
       args: resolved.args,
       cwd: options.cwd ?? defaultCwd(),
-      env: environmentFor(options),
+      env: channelId ? { ...environmentFor(options), [IPC_CHANNEL_ENV]: channelId } : environmentFor(options),
+      ...options.stdio === "inherit" || Array.isArray(options.stdio) && options.stdio[0] === "inherit" ? { inheritStdio: true } : {},
       ...stdinIgnored(options) ? { stdinIgnored: true } : {}
     });
-    return new ChildProcess(handle, resolved.file, resolved.args);
+    const child = new ChildProcess(handle, resolved.file, resolved.args, lifecycle.referenceChanged);
+    if (channelId && lifecycle.ipc) child.attachChannel(lifecycle.ipc, channelId);
+    const inherited = (index) => options.stdio === "inherit" || Array.isArray(options.stdio) && options.stdio[index] === "inherit";
+    if (inherited(1)) child.stdout.on("data", (chunk) => lifecycle.stdout?.(chunk.toString()));
+    if (inherited(2)) child.stderr.on("data", (chunk) => lifecycle.stderr?.(chunk.toString()));
+    return child;
   };
   const spawn = (file, args = [], options = {}) => {
     if (!Array.isArray(args)) return start(file, [], args);
@@ -29633,7 +30007,13 @@ ${err2.join("")}`),
     spawn,
     exec,
     execFile,
-    fork: (modulePath, args = [], options = {}) => spawn("node", [modulePath, ...args], options),
+    fork: (modulePath, args = [], options = {}) => {
+      const [list, opts] = Array.isArray(args) ? [args, options] : [[], args ?? {}];
+      const stdio = Array.isArray(opts.stdio) ? opts.stdio : typeof opts.stdio === "string" ? [opts.stdio, opts.stdio, opts.stdio] : opts.silent ? ["pipe", "pipe", "pipe"] : ["inherit", "inherit", "inherit"];
+      const withChannel = stdio.includes("ipc") ? stdio : [...stdio, "ipc"];
+      const execArgv = (opts.execArgv ?? []).filter((flag) => !/^--(inspect|debug)/.test(flag));
+      return start("node", [...execArgv, modulePath, ...list], { ...opts, shell: false, stdio: withChannel });
+    },
     ...buildSyncFamily(syncSpawn, throughShell, defaultCwd, environmentFor),
     ChildProcess
   };
@@ -30301,11 +30681,14 @@ function createCoreModules(options) {
   });
   const stderrWrite = options.stderr ?? (() => {
   });
-  const timers = createTrackedTimers((error) => reportUncaught(error));
+  const timers = createTrackedTimers((error) => reportUncaught(error), () => runTicks());
   const processObject = Object.assign(new import_events4.default(), import_browser.default, {
     argv: options.argv?.slice() ?? ["/usr/bin/node"],
     argv0: "node",
     execPath: "/usr/bin/node",
+    /* `process/browser.js` has no `execArgv`; Node always has an array, and
+     * CLIs that fork copy it (`[...process.execArgv]`). */
+    execArgv: [],
     env,
     platform: "linux",
     arch: "x64",
@@ -30344,13 +30727,14 @@ function createCoreModules(options) {
       options.onExit?.(status);
     },
     nextTick: (fn, ...args) => {
-      queueMicrotask(() => {
-        try {
-          fn(...args);
-        } catch (error) {
-          reportUncaught(error);
-        }
-      });
+      if (typeof fn !== "function") {
+        throw Object.assign(new TypeError('The "callback" argument must be of type function'), { code: "ERR_INVALID_ARG_TYPE" });
+      }
+      tickQueue.push([fn, args]);
+      if (!tickDrainScheduled) {
+        tickDrainScheduled = true;
+        afterMicrotasks(runTicks);
+      }
     },
     kill: () => true
   });
@@ -30358,10 +30742,42 @@ function createCoreModules(options) {
     const implementation = import_events4.default.prototype[method];
     if (typeof implementation === "function") processObject[method] = implementation;
   }
+  const hrtime = (previous) => {
+    const now = performance.timeOrigin + performance.now();
+    let seconds = Math.floor(now / 1e3);
+    let nanoseconds = Math.floor(now % 1e3 * 1e6);
+    if (previous) {
+      seconds -= previous[0];
+      nanoseconds -= previous[1];
+      if (nanoseconds < 0) {
+        seconds -= 1;
+        nanoseconds += 1e9;
+      }
+    }
+    return [seconds, nanoseconds];
+  };
+  hrtime.bigint = () => {
+    const [seconds, nanoseconds] = hrtime();
+    return BigInt(seconds) * 1000000000n + BigInt(nanoseconds);
+  };
+  processObject.hrtime = hrtime;
   const tty = options.tty === true;
   processObject.stdout = makeOutputStream(stdoutWrite, 1, tty);
   processObject.stderr = makeOutputStream(stderrWrite, 2, tty);
   let exiting = false;
+  const tickQueue = [];
+  let tickDrainScheduled = false;
+  const runTicks = () => {
+    tickDrainScheduled = false;
+    while (tickQueue.length && !exiting) {
+      const [fn, args] = tickQueue.shift();
+      try {
+        fn(...args);
+      } catch (error) {
+        reportUncaught(error);
+      }
+    }
+  };
   const emitExit = (status) => {
     if (exiting) return;
     exiting = true;
@@ -30429,13 +30845,16 @@ function createCoreModules(options) {
   const moduleBuiltin = {
     builtinModules: builtinNames.flatMap((name) => [name, `node:${name}`]),
     isBuiltin: (name) => builtinNames.includes(name.replace(/^node:/, "")),
+    findSourceMap: () => void 0,
     createRequire: () => {
       throw new Error("createRequire is only available inside a loaded module");
     }
   };
   let inFlightRequests = 0;
+  let requestsStarted = 0;
   const trackRequest = () => {
     inFlightRequests++;
+    requestsStarted += 1;
     return () => {
       inFlightRequests--;
     };
@@ -30449,7 +30868,86 @@ function createCoreModules(options) {
   };
   const http = options.http ? createHttpModule(options.http.router, options.http.owner, httpOptions, "http:") : createUnsupportedModule("http");
   const https = options.http ? createHttpModule(options.http.router, options.http.owner, httpOptions, "https:") : createUnsupportedModule("https");
-  const childProcess = options.spawnChild ? createChildProcessModule(options.spawnChild, () => cwd, options.syncSpawn, () => ({ ...processObject.env })) : createUnsupportedModule("child_process");
+  let referencedChildren = 0;
+  const childProcess = options.spawnChild ? createChildProcessModule(options.spawnChild, () => cwd, options.syncSpawn, () => ({ ...processObject.env }), {
+    referenceChanged: (delta) => {
+      referencedChildren += delta;
+    },
+    stdout: options.stdout,
+    stderr: options.stderr,
+    ...options.ipc ? { ipc: options.ipc } : {}
+  }) : createUnsupportedModule("child_process");
+  let channelReferenced = 0;
+  const channelId = env[IPC_CHANNEL_ENV];
+  if (channelId && options.ipc) {
+    delete env[IPC_CHANNEL_ENV];
+    let open = true;
+    let referenced = true;
+    channelReferenced = 1;
+    const close = () => {
+      if (!open) return;
+      open = false;
+      if (referenced) channelReferenced = 0;
+      processObject.connected = false;
+      delete processObject.send;
+      try {
+        processObject.emit("disconnect");
+      } catch (error) {
+        reportUncaught(error);
+      }
+      runTicks();
+    };
+    const endpoint = options.ipc.attach(
+      channelId,
+      "child",
+      (message) => {
+        try {
+          processObject.emit("message", message, void 0);
+        } catch (error) {
+          reportUncaught(error);
+        }
+        runTicks();
+      },
+      close
+    );
+    processObject.connected = true;
+    processObject.send = (message, ...rest) => {
+      const callback = rest.find((value) => typeof value === "function");
+      if (!open) {
+        const error = Object.assign(new Error("Channel closed"), { code: "ERR_IPC_CHANNEL_CLOSED" });
+        if (callback) defer(() => callback(error));
+        else defer(() => {
+          processObject.emit("error", error);
+        });
+        return false;
+      }
+      endpoint.send(message);
+      if (callback) defer(() => callback(null));
+      return true;
+    };
+    processObject.disconnect = () => {
+      if (open) {
+        endpoint.disconnect();
+        close();
+      }
+    };
+    processObject.channel = {
+      ref() {
+        if (open && !referenced) {
+          referenced = true;
+          channelReferenced = 1;
+        }
+        return this;
+      },
+      unref() {
+        if (referenced) {
+          referenced = false;
+          channelReferenced = 0;
+        }
+        return this;
+      }
+    };
+  }
   const readline = createReadlineModule(() => processObject.stdin, () => processObject.stdout);
   const dns = createDnsModule(defer);
   const builtins = {
@@ -30461,6 +30959,7 @@ function createCoreModules(options) {
     console: consoleObject,
     constants: fs.constants,
     crypto: createCryptoModule(),
+    diagnostics_channel: createDiagnosticsChannel(),
     dns,
     "dns/promises": dns.promises,
     events: import_events4.default,
@@ -30479,6 +30978,25 @@ function createCoreModules(options) {
     readline,
     "readline/promises": readline.promises,
     stream: import_stream_browserify4.default,
+    "stream/web": Object.fromEntries([
+      "ReadableStream",
+      "ReadableStreamDefaultReader",
+      "ReadableStreamBYOBReader",
+      "ReadableStreamDefaultController",
+      "ReadableByteStreamController",
+      "ReadableStreamBYOBRequest",
+      "WritableStream",
+      "WritableStreamDefaultWriter",
+      "WritableStreamDefaultController",
+      "TransformStream",
+      "TransformStreamDefaultController",
+      "ByteLengthQueuingStrategy",
+      "CountQueuingStrategy",
+      "TextEncoderStream",
+      "TextDecoderStream",
+      "CompressionStream",
+      "DecompressionStream"
+    ].filter((name) => name in globalThis).map((name) => [name, globalThis[name]])),
     "stream/promises": createStreamPromises(),
     string_decoder: import_string_decoder.default,
     timers: { ...import_timers_browserify.default, ...timers.api },
@@ -30510,7 +31028,57 @@ function createCoreModules(options) {
     })
   };
   for (const name of stubNames) builtins[name] = createUnsupportedModule(name);
+  builtins.worker_threads = {
+    MessagePort: globalThis.MessagePort ?? class MessagePort {
+    },
+    markAsUncloneable: () => {
+    },
+    isMarkedAsUncloneable: () => false,
+    markAsUntransferable: () => {
+    },
+    isMarkedAsUntransferable: () => false
+  };
   builtins.net = createNetModule();
+  builtins.inspector = createUnsupportedModule("inspector", {
+    url: () => void 0,
+    close: () => {
+    },
+    waitForDebugger: () => {
+      throw Object.assign(new Error("Inspector is not active"), { code: "ERR_INSPECTOR_NOT_ACTIVE" });
+    },
+    console: consoleObject
+  });
+  builtins.v8 = createUnsupportedModule("v8", {
+    getHeapStatistics: () => {
+      const memory = performance.memory;
+      const limit = memory?.jsHeapSizeLimit ?? 4 * 1024 ** 3;
+      return {
+        total_heap_size: memory?.totalJSHeapSize ?? 0,
+        total_heap_size_executable: 0,
+        total_physical_size: memory?.totalJSHeapSize ?? 0,
+        total_available_size: limit - (memory?.usedJSHeapSize ?? 0),
+        used_heap_size: memory?.usedJSHeapSize ?? 0,
+        heap_size_limit: limit,
+        malloced_memory: 0,
+        peak_malloced_memory: 0,
+        does_zap_garbage: 0,
+        number_of_native_contexts: 1,
+        number_of_detached_contexts: 0,
+        total_global_handles_size: 0,
+        used_global_handles_size: 0,
+        external_memory: 0
+      };
+    },
+    getHeapSpaceStatistics: () => [],
+    getHeapCodeStatistics: () => ({ code_and_metadata_size: 0, bytecode_and_metadata_size: 0, external_script_source_size: 0, cpu_profiler_metadata_size: 0 }),
+    cachedDataVersionTag: () => 0,
+    setFlagsFromString: () => {
+    },
+    setHeapSnapshotNearHeapLimit: () => {
+    },
+    serialize: (value) => Buffer2.from(JSON.stringify(value) ?? "null"),
+    deserialize: (buffer) => JSON.parse(Buffer2.from(buffer).toString("utf8"))
+  });
   const globals = {
     Buffer: Buffer2,
     console: consoleObject,
@@ -30545,7 +31113,7 @@ function createCoreModules(options) {
     builtins,
     globals,
     process: processObject,
-    pendingHandles: timers.pending,
+    pendingHandles: () => timers.pending() + referencedChildren + channelReferenced,
     pendingUnrefed: timers.pendingUnrefed,
     /** Client requests sent but not yet read to completion. */
     pendingRequests: () => inFlightRequests,
@@ -30554,6 +31122,18 @@ function createCoreModules(options) {
     reportUnhandledRejection: (reason) => reportUncaught(reason, "unhandledRejection"),
     exitStatus: () => normalizeExitCode(processObject.exitCode),
     emitExit,
+    runTicks,
+    emitBeforeExit: (status) => {
+      if (exiting || processObject.listenerCount("beforeExit") === 0) return false;
+      try {
+        processObject.emit("beforeExit", status);
+      } catch (error) {
+        reportUncaught(error);
+      }
+      runTicks();
+      return true;
+    },
+    loopActivity: () => timers.scheduled() + requestsStarted,
     writeStdin: (data2) => {
       if (options.interactiveStdin) stdin.write(data2);
     },
@@ -30599,7 +31179,9 @@ var ASYNC_FS_METHODS = [
   "close",
   "read",
   "write",
-  "exists"
+  "exists",
+  "fsync",
+  "fdatasync"
 ];
 function createPathModule(cwd) {
   const resolve2 = (...segments2) => import_path_browserify.default.resolve(cwd(), ...segments2);
@@ -30822,6 +31404,12 @@ function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
     unwatchFile: () => {
     }
   };
+  fs.fsyncSync = (fd) => {
+    requiredFd(fds, fd);
+  };
+  fs.fdatasyncSync = (fd) => {
+    requiredFd(fds, fd);
+  };
   fs.ftruncateSync = (fd, length) => fs.truncateSync(requiredFd(fds, fd).path, length);
   fs.fchmodSync = (fd, mode) => fs.chmodSync(requiredFd(fds, fd).path, mode);
   fs.fchownSync = (fd, uid, gid) => fs.chownSync(requiredFd(fds, fd).path, uid, gid);
@@ -30882,6 +31470,8 @@ function makeFileHandle(fs, fd) {
   return {
     fd,
     close: async () => fs.closeSync(fd),
+    sync: async () => fs.fsyncSync(fd),
+    datasync: async () => fs.fdatasyncSync(fd),
     stat: async () => fs.fstatSync(fd),
     truncate: async (length) => fs.ftruncateSync(fd, length),
     chmod: async (mode) => fs.fchmodSync(fd, mode),
@@ -31164,8 +31754,28 @@ var ERRNO_CONSTANTS = {
   EWOULDBLOCK: 11,
   EXDEV: 18
 };
+var afterMicrotasks = (() => {
+  const host = globalThis.process;
+  if (typeof host?.nextTick === "function" && host.versions?.node) return (fn) => host.nextTick(fn);
+  if (typeof MessageChannel === "function") {
+    const queue = [];
+    let channel = null;
+    return (fn) => {
+      if (!channel) {
+        channel = new MessageChannel();
+        channel.port1.onmessage = () => queue.shift()?.();
+      }
+      queue.push(fn);
+      channel.port2.postMessage(null);
+    };
+  }
+  return (fn) => {
+    setTimeout(fn, 0);
+  };
+})();
 function createTrackedTimers(onError = (error) => {
   throw error;
+}, afterCallback = () => {
 }) {
   const run2 = (fn, args) => {
     try {
@@ -31173,11 +31783,14 @@ function createTrackedTimers(onError = (error) => {
     } catch (error) {
       onError(error);
     }
+    afterCallback();
   };
+  let scheduled = 0;
   const live = /* @__PURE__ */ new Set();
   const unrefed = /* @__PURE__ */ new Set();
   const states = /* @__PURE__ */ new WeakMap();
   const track = (native) => {
+    scheduled += 1;
     const state = { native, active: true, referenced: true };
     const handle = {
       ref() {
@@ -31282,6 +31895,7 @@ function createTrackedTimers(onError = (error) => {
     },
     pending: () => live.size,
     pendingUnrefed: () => unrefed.size,
+    scheduled: () => scheduled,
     cancelAll
   };
 }
@@ -31451,7 +32065,7 @@ function formatUncaught(error) {
 Node.js v22.12.0
 `;
 }
-var stubNames = ["cluster", "dgram", "diagnostics_channel", "domain", "http2", "inspector", "net", "tls", "v8", "vm", "worker_threads"];
+var stubNames = ["cluster", "dgram", "domain", "http2", "inspector", "net", "tls", "v8", "vm", "worker_threads"];
 var builtinNames = [
   "assert",
   "assert/strict",
@@ -31464,6 +32078,7 @@ var builtinNames = [
   "events",
   "fs",
   "fs/promises",
+  "diagnostics_channel",
   "dns",
   "dns/promises",
   "http",
@@ -31479,6 +32094,7 @@ var builtinNames = [
   "readline",
   "readline/promises",
   "stream",
+  "stream/web",
   "stream/promises",
   "string_decoder",
   "timers",
@@ -31706,6 +32322,7 @@ async function run(port, start) {
     /* Asynchronous children are the host's business: it owns the process table
      * and the PATH. Both forms end up in the same place, one blocking. */
     spawnChild: (config) => hostChildProcess(port, config),
+    ipc: hostIpcOverPort(port),
     syncSpawn: (request) => spawnSyncOverChannel(channel, request),
     ...start.stdinPath ? { stdinPath: start.stdinPath } : {},
     ...start.interactiveStdin ? { interactiveStdin: true } : {},
@@ -31767,8 +32384,16 @@ async function run(port, start) {
     aliases: start.aliases
   });
   try {
-    await engine.run(start.script);
+    const main2 = engine.run(start.script);
+    core.runTicks();
+    await main2;
     await settle(router, owner, core, () => finished);
+    while (!finished) {
+      const activity = core.loopActivity();
+      if (!core.emitBeforeExit(core.exitStatus())) break;
+      await settle(router, owner, core, () => finished);
+      if (core.loopActivity() === activity) break;
+    }
     const status = core.exitStatus();
     core.emitExit(status);
     finish(status);
@@ -31864,6 +32489,32 @@ function hostChildProcess(port, config) {
   });
   return handle;
 }
+function hostIpcOverPort(port) {
+  const ends = /* @__PURE__ */ new Map();
+  port.onMessage((message) => {
+    if (message?.type !== "ipc-message" && message?.type !== "ipc-disconnect") return;
+    const end = ends.get(`${message.side}:${message.id}`);
+    if (!end) return;
+    if (message.type === "ipc-message") end.message(message.value);
+    else {
+      ends.delete(`${message.side}:${message.id}`);
+      end.disconnect();
+    }
+  });
+  return {
+    attach(id, side, onMessage, onDisconnect) {
+      ends.set(`${side}:${id}`, { message: onMessage, disconnect: onDisconnect });
+      port.postMessage({ type: "ipc-attach", id, side });
+      return {
+        send: (value) => port.postMessage({ type: "ipc-send", id, side, value: value === void 0 ? void 0 : JSON.parse(JSON.stringify(value)) }),
+        disconnect: () => {
+          ends.delete(`${side}:${id}`);
+          port.postMessage({ type: "ipc-close", id, side });
+        }
+      };
+    }
+  };
+}
 function formatError(error) {
   if (error instanceof Error) return `${error.stack ?? `${error.name}: ${error.message}`}
 `;