sandboxedjs 0.1.30 → 0.1.32

package/dist/worker-entry.js

@@ -27251,6 +27251,7 @@ var VirtualHttpServer = class extends import_events.default {
   owner;
   listening = false;
   portValue = null;
+  referenced = true;
   listen(...args) {
     const callback = typeof args.at(-1) === "function" ? args.pop() : void 0;
     const first = args[0];
@@ -27279,11 +27280,16 @@ var VirtualHttpServer = class extends import_events.default {
     return this.portValue === null ? null : { address: "0.0.0.0", family: "IPv4", port: this.portValue };
   }
   ref() {
+    this.referenced = true;
     return this;
   }
   unref() {
+    this.referenced = false;
     return this;
   }
+  hasRef() {
+    return this.referenced;
+  }
   setTimeout(_milliseconds, callback) {
     if (callback) this.on("timeout", callback);
     return this;
@@ -27293,13 +27299,16 @@ var VirtualHttpRouter = class {
   servers = /* @__PURE__ */ new Map();
   /** Notified when a server begins listening, for `onServerReady`. */
   onListen;
+  onClose;
   register(port, server, owner) {
     if (this.servers.has(port)) throw Object.assign(new Error(`listen EADDRINUSE: address already in use 0.0.0.0:${port}`), { code: "EADDRINUSE", port });
     this.servers.set(port, { server, owner });
     this.onListen?.(port);
   }
   unregister(port, server) {
-    if (this.servers.get(port)?.server === server) this.servers.delete(port);
+    if (this.servers.get(port)?.server !== server) return;
+    this.servers.delete(port);
+    this.onClose?.(port);
   }
   /** Whether anything in this container is listening on `port`. */
   activePortsIncludes(port) {
@@ -27308,6 +27317,9 @@ var VirtualHttpRouter = class {
   activePorts(owner) {
     return [...this.servers].filter(([, item]) => owner === void 0 || item.owner === owner).map(([port]) => port).sort((a, b) => a - b);
   }
+  referencedPorts(owner) {
+    return [...this.servers].filter(([, item]) => item.owner === owner && item.server.hasRef()).map(([port]) => port);
+  }
   closeOwner(owner) {
     for (const { server, owner: value } of [...this.servers.values()]) if (value === owner) server.close();
   }
@@ -28582,6 +28594,102 @@ function toBytes2(data2, encoding) {
   return typeof data2 === "string" ? Buffer2.from(data2, encoding) : data2;
 }
 
+// src/runtime/sync-channel.ts
+var STATE = 0;
+var LENGTH2 = 1;
+var MORE = 2;
+var STATE_IDLE = 0;
+var STATE_REQUEST = 1;
+var STATE_RESPONSE = 2;
+var STATE_CONTINUE = 3;
+var WAIT_SLICE_MS = 250;
+function syncChannelUnavailableReason() {
+  if (typeof globalThis.crossOriginIsolated === "boolean" && !globalThis.crossOriginIsolated) {
+    return "The browser host is not cross-origin isolated. Serve the host app over HTTPS or localhost with Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp. For a built app use sandboxedjs-serve <directory>. Embedded browsers or iframe policies may also prevent isolation.";
+  }
+  if (typeof SharedArrayBuffer !== "function") return "SharedArrayBuffer is unavailable in this host.";
+  if (typeof Atomics !== "object" || typeof Atomics.wait !== "function") return "Atomics.wait is unavailable in this host.";
+  return null;
+}
+var SyncChannelClosedError = class extends Error {
+  code = "ERR_SYNC_CHANNEL_CLOSED";
+  constructor() {
+    super("the sandbox runtime host went away while a synchronous call was waiting");
+  }
+};
+var SyncChannelClient = class {
+  constructor(buffers, wake) {
+    this.wake = wake;
+    this.control = new Int32Array(buffers.control);
+    this.data = new Uint8Array(buffers.data);
+    this.capacity = this.data.length;
+  }
+  wake;
+  control;
+  data;
+  capacity;
+  /** Send a request and block until the whole response has come back. */
+  call(request) {
+    this.send(request);
+    return this.receive();
+  }
+  /** Write the request across, a window at a time. */
+  send(request) {
+    let offset2 = 0;
+    for (; ; ) {
+      const size = Math.min(this.capacity, request.length - offset2);
+      this.data.set(request.subarray(offset2, offset2 + size), 0);
+      offset2 += size;
+      Atomics.store(this.control, LENGTH2, size);
+      Atomics.store(this.control, MORE, offset2 < request.length ? 1 : 0);
+      this.publish(STATE_REQUEST);
+      const next = this.waitWhile(STATE_REQUEST);
+      if (next === STATE_RESPONSE) return;
+      if (next !== STATE_CONTINUE) throw new SyncChannelClosedError();
+    }
+  }
+  /** Read the response back, a window at a time. */
+  receive() {
+    const parts = [];
+    let total = 0;
+    for (; ; ) {
+      const size = Atomics.load(this.control, LENGTH2);
+      parts.push(this.data.slice(0, size));
+      total += size;
+      if (Atomics.load(this.control, MORE) === 0) break;
+      this.publish(STATE_CONTINUE);
+      if (this.waitWhile(STATE_CONTINUE) !== STATE_RESPONSE) throw new SyncChannelClosedError();
+    }
+    Atomics.store(this.control, STATE, STATE_IDLE);
+    if (parts.length === 1) return parts[0];
+    const joined = new Uint8Array(total);
+    let at2 = 0;
+    for (const part of parts) {
+      joined.set(part, at2);
+      at2 += part.length;
+    }
+    return joined;
+  }
+  publish(state) {
+    Atomics.store(this.control, STATE, state);
+    Atomics.notify(this.control, STATE);
+    this.wake();
+  }
+  /**
+   * Block until the state moves off `state`.
+   *
+   * Waking periodically rather than waiting forever is what lets a torn-down
+   * host release a worker instead of stranding it.
+   */
+  waitWhile(state) {
+    for (; ; ) {
+      Atomics.wait(this.control, STATE, state, WAIT_SLICE_MS);
+      const current2 = Atomics.load(this.control, STATE);
+      if (current2 !== state) return current2;
+    }
+  }
+};
+
 // src/runtime/child-process-module.ts
 var import_events2 = __toESM(require_events());
 var import_stream_browserify3 = __toESM(require_stream_browserify());
@@ -28789,7 +28897,7 @@ function unavailable(name) {
     const list = Array.isArray(args[1]) ? args[1].map(String) : [];
     const command = file ? [file, ...list].join(" ") : void 0;
     const error = new Error(
-      `child_process.${name} is not supported in the sandboxed runtime` + (command ? ` (tried to run: ${command})` : "") + `: the caller, the child and the event loop share one thread, so blocking the caller would also stop the child. Run it with the asynchronous form (spawn/exec/execFile), or run the command from the container shell.`
+      `child_process.${name} is not supported in the sandboxed runtime` + (command ? ` (tried to run: ${command})` : "") + `: the caller, the child and the event loop share one thread, so blocking the caller would also stop the child. Enable the SandboxedJs worker runtime with createContainer({ isolation: "worker" }) and fix any boot prerequisite it reports. ` + (syncChannelUnavailableReason() ?? "This process is using the realm runtime, which cannot provide synchronous child processes.")
     );
     error.code = "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM";
     throw error;
@@ -29115,6 +29223,11 @@ function createReadlineModule(defaultInput, defaultOutput = () => void 0) {
     edit(sequence, key) {
       if (this.closed) return;
       const name = key.name;
+      if (key.ctrl && name === "c") {
+        if (this.listenerCount("SIGINT") > 0) this.emit("SIGINT");
+        else this.close();
+        return;
+      }
       if (name === "return" || name === "enter") {
         const value = this.line;
         this.line = "";
@@ -29210,7 +29323,7 @@ function createReadlineModule(defaultInput, defaultOutput = () => void 0) {
   };
   const createInterface = (options, output) => {
     if (options && typeof options === "object" && !options.on) {
-      const resolvedOutput2 = options.output ?? defaultOutput();
+      const resolvedOutput2 = options.output;
       const instance = new Interface(
         options.input ?? defaultInput(),
         resolvedOutput2,
@@ -29219,7 +29332,7 @@ function createReadlineModule(defaultInput, defaultOutput = () => void 0) {
       if (typeof options.prompt === "string") instance.setPrompt(options.prompt);
       return instance;
     }
-    const resolvedOutput = output ?? defaultOutput();
+    const resolvedOutput = output;
     return new Interface(options ?? defaultInput(), resolvedOutput, isTerminal(void 0, resolvedOutput));
   };
   const noop = () => {
@@ -29492,7 +29605,7 @@ function createCoreModules(options) {
     "stream/promises": createStreamPromises(),
     string_decoder: import_string_decoder.default,
     timers: { ...import_timers_browserify.default, ...timers.api },
-    "timers/promises": createTimerPromises(),
+    "timers/promises": createTimerPromises(timers.api),
     tty: { isatty: () => false, ReadStream: import_stream_browserify4.default.Readable, WriteStream: import_stream_browserify4.default.Writable },
     url: url_module_default,
     util: util_module_default,
@@ -30237,10 +30350,10 @@ function createTrackedTimers() {
     cancelAll
   };
 }
-function createTimerPromises() {
+function createTimerPromises(timers) {
   return {
-    setTimeout: (delay, value) => new Promise((resolve2) => setTimeout(resolve2, delay, value)),
-    setImmediate: (value) => new Promise((resolve2) => setTimeout(resolve2, 0, value))
+    setTimeout: (delay, value) => new Promise((resolve2) => timers.setTimeout(resolve2, delay, value)),
+    setImmediate: (value) => new Promise((resolve2) => timers.setImmediate(resolve2, value))
   };
 }
 function createAsyncHooksModule() {
@@ -30491,94 +30604,6 @@ var RemoteVolume = class {
   }
 };
 
-// src/runtime/sync-channel.ts
-var STATE = 0;
-var LENGTH2 = 1;
-var MORE = 2;
-var STATE_IDLE = 0;
-var STATE_REQUEST = 1;
-var STATE_RESPONSE = 2;
-var STATE_CONTINUE = 3;
-var WAIT_SLICE_MS = 250;
-var SyncChannelClosedError = class extends Error {
-  code = "ERR_SYNC_CHANNEL_CLOSED";
-  constructor() {
-    super("the sandbox runtime host went away while a synchronous call was waiting");
-  }
-};
-var SyncChannelClient = class {
-  constructor(buffers, wake) {
-    this.wake = wake;
-    this.control = new Int32Array(buffers.control);
-    this.data = new Uint8Array(buffers.data);
-    this.capacity = this.data.length;
-  }
-  wake;
-  control;
-  data;
-  capacity;
-  /** Send a request and block until the whole response has come back. */
-  call(request) {
-    this.send(request);
-    return this.receive();
-  }
-  /** Write the request across, a window at a time. */
-  send(request) {
-    let offset2 = 0;
-    for (; ; ) {
-      const size = Math.min(this.capacity, request.length - offset2);
-      this.data.set(request.subarray(offset2, offset2 + size), 0);
-      offset2 += size;
-      Atomics.store(this.control, LENGTH2, size);
-      Atomics.store(this.control, MORE, offset2 < request.length ? 1 : 0);
-      this.publish(STATE_REQUEST);
-      const next = this.waitWhile(STATE_REQUEST);
-      if (next === STATE_RESPONSE) return;
-      if (next !== STATE_CONTINUE) throw new SyncChannelClosedError();
-    }
-  }
-  /** Read the response back, a window at a time. */
-  receive() {
-    const parts = [];
-    let total = 0;
-    for (; ; ) {
-      const size = Atomics.load(this.control, LENGTH2);
-      parts.push(this.data.slice(0, size));
-      total += size;
-      if (Atomics.load(this.control, MORE) === 0) break;
-      this.publish(STATE_CONTINUE);
-      if (this.waitWhile(STATE_CONTINUE) !== STATE_RESPONSE) throw new SyncChannelClosedError();
-    }
-    Atomics.store(this.control, STATE, STATE_IDLE);
-    if (parts.length === 1) return parts[0];
-    const joined = new Uint8Array(total);
-    let at2 = 0;
-    for (const part of parts) {
-      joined.set(part, at2);
-      at2 += part.length;
-    }
-    return joined;
-  }
-  publish(state) {
-    Atomics.store(this.control, STATE, state);
-    Atomics.notify(this.control, STATE);
-    this.wake();
-  }
-  /**
-   * Block until the state moves off `state`.
-   *
-   * Waking periodically rather than waiting forever is what lets a torn-down
-   * host release a worker instead of stranding it.
-   */
-  waitWhile(state) {
-    for (; ; ) {
-      Atomics.wait(this.control, STATE, state, WAIT_SLICE_MS);
-      const current2 = Atomics.load(this.control, STATE);
-      if (current2 !== state) return current2;
-    }
-  }
-};
-
 // src/runtime/sync-syscalls.ts
 var SPAWN_OP = "spawnSync";
 function spawnSyncOverChannel(channel, request) {
@@ -30655,6 +30680,7 @@ async function run(port, start) {
   const router = new VirtualHttpRouter();
   const owner = "worker";
   router.onListen = (listening) => port.postMessage({ type: "listen", port: listening });
+  router.onClose = (closed) => port.postMessage({ type: "close-port", port: closed });
   let requestedExit = 0;
   let engine;
   let finished = false;
@@ -30683,6 +30709,8 @@ async function run(port, start) {
   const finish = (code) => {
     if (finished) return;
     finished = true;
+    core.cancelTimers();
+    router.closeOwner(owner);
     port.postMessage({ type: "exit", code });
   };
   port.onMessage((message) => {
@@ -30704,7 +30732,6 @@ async function run(port, start) {
   try {
     await engine.run(start.script);
     await settle(router, owner, core, () => finished);
-    if (router.activePorts(owner).length) return;
     finish(requestedExit);
   } catch (error) {
     if (error instanceof ProcessExit) {
@@ -30716,18 +30743,12 @@ async function run(port, start) {
   }
 }
 async function settle(router, owner, core, killed) {
-  for (let turn = 0; turn < DRAIN_TURNS; turn++) {
-    if (router.activePorts(owner).length || killed()) return;
-    await new Promise((resolve2) => setTimeout(resolve2, 0));
-  }
-  if (core.pendingHandles() === 0 && core.pendingRequests() === 0 && core.pendingUnrefed() > 0 && !core.readingStdin()) {
-    const deadline = Date.now() + 1e3;
-    while (!router.activePorts(owner).length && !killed() && Date.now() < deadline) {
-      await new Promise((resolve2) => setTimeout(resolve2, 5));
-    }
-  }
-  while (!router.activePorts(owner).length && !killed() && (core.pendingHandles() > 0 || core.pendingRequests() > 0 || core.readingStdin())) {
-    await new Promise((resolve2) => setTimeout(resolve2, 5));
+  let idleTurns = 0;
+  while (!killed()) {
+    const busy = router.referencedPorts(owner).length > 0 || core.pendingHandles() > 0 || core.pendingRequests() > 0 || core.readingStdin();
+    idleTurns = busy ? 0 : idleTurns + 1;
+    if (idleTurns >= DRAIN_TURNS) return;
+    await new Promise((resolve2) => setTimeout(resolve2, busy ? 5 : 0));
   }
 }
 async function answer(port, router, message) {