sandboxedjs 0.1.30 → 0.1.32

package/dist/index.js

@@ -4778,7 +4778,15 @@ var Pipe = class _Pipe {
    * whole line on every keystroke — so the terminal must stop echoing, or
    * every character appears twice.
    */
-  rawMode = false;
+  raw = false;
+  onRawMode;
+  get rawMode() {
+    return this.raw;
+  }
+  set rawMode(enabled) {
+    this.raw = enabled;
+    this.onRawMode?.(enabled);
+  }
   columns;
   rows;
   get closed() {
@@ -5906,13 +5914,19 @@ var Kernel = class {
         stderr: opts.stderr ?? new NullOutput()
       }
     });
+    const cancelWithParent = () => {
+      if (parent?.termSignal) proc.deliver(parent.termSignal);
+    };
+    parent?.signal.addEventListener("abort", cancelWithParent, { once: true });
+    if (parent?.signal.aborted) cancelWithParent();
+    void proc.wait().then(() => parent?.signal.removeEventListener("abort", cancelWithParent));
     let timer;
     if (opts.timeoutMs !== void 0) {
       timer = setTimeout(() => {
         proc.deliver("SIGKILL");
       }, opts.timeoutMs);
     }
-    void this.dispatch(proc).then((code) => {
+    void (proc.signal.aborted ? Promise.resolve(proc.exitCode ?? 137) : this.dispatch(proc)).then((code) => {
       proc.exit(code);
     }).catch((e) => {
       try {
@@ -7904,6 +7918,22 @@ var Shell = class _Shell {
     }
     return this.lastStatus;
   }
+  /** Signal the current terminal pipeline without terminating the interactive shell. */
+  interruptForeground(signal, stdin) {
+    const processes = this.kernel.procs.list().filter((process2) => process2.running);
+    const selected = new Set(processes.filter((process2) => process2.ppid === this.proc.pid && process2.stdin === stdin).map((process2) => process2.pid));
+    for (let changed = true; changed; ) {
+      changed = false;
+      const outputs = processes.filter((process2) => selected.has(process2.pid)).flatMap((process2) => [process2.stdout, process2.stderr]);
+      for (const process2 of processes) {
+        if (!selected.has(process2.pid) && (selected.has(process2.ppid) || outputs.some((output) => output === process2.stdin))) {
+          selected.add(process2.pid);
+          changed = true;
+        }
+      }
+    }
+    for (const process2 of processes) if (selected.has(process2.pid)) process2.deliver(signal);
+  }
   get isExiting() {
     return this.exiting;
   }
@@ -8553,6 +8583,7 @@ sys	${fmt2(Math.floor(ms * 0.2))}
     for (const assignment of assignments) {
       env2[assignment.name] = await expandWordToString(assignment.value, this.expandContext());
     }
+    if (this.proc.signal.aborted) return this.proc.exitCode ?? 137;
     const proc = this.kernel.spawn(words, {
       cwd: this.cwd,
       env: env2,
@@ -8810,7 +8841,7 @@ async function runShell(ctxName, ctx) {
   const args = ctx.args.slice();
   let command;
   let scriptPath;
-  let readStdin2 = false;
+  let readStdin = false;
   let interactive = false;
   let login = ctxName.startsWith("-");
   const options = {};
@@ -8823,7 +8854,7 @@ async function runShell(ctxName, ctx) {
       break;
     }
     if (arg === "-s") {
-      readStdin2 = true;
+      readStdin = true;
       continue;
     }
     if (arg === "-i") {
@@ -8860,7 +8891,7 @@ async function runShell(ctxName, ctx) {
     break;
   }
   const rest = args.slice(i);
-  if (command === void 0 && !readStdin2 && rest.length > 0) {
+  if (command === void 0 && !readStdin && rest.length > 0) {
     scriptPath = rest[0];
   }
   const positional = command !== void 0 ? rest.slice(1) : scriptPath !== void 0 ? rest.slice(1) : rest;
@@ -17755,6 +17786,143 @@ function mountContainerFs(FS, opts) {
   }
 }
 
+// src/runtime/python-syscalls.ts
+var EMPTY = new Uint8Array(0);
+function createStdinHost(ctx) {
+  let pending = EMPTY;
+  let eof = false;
+  const take = (size) => {
+    const n = Math.min(size, pending.length);
+    const out = pending.subarray(0, n);
+    pending = pending.subarray(n);
+    return out;
+  };
+  return {
+    /**
+     * Drain a non-interactive stdin up front.
+     *
+     * A pipe ends, so reading it eagerly costs nothing and leaves every read
+     * answerable without suspending — which is what keeps piped input working
+     * on hosts with no stack-switching. A terminal never ends, so priming one
+     * would hang before the program had printed its prompt.
+     */
+    async prime() {
+      if (ctx.stdin.isTTY || ctx.stdin.interactive) return;
+      try {
+        pending = await ctx.stdin.readAll();
+      } catch {
+        pending = EMPTY;
+      }
+      eof = true;
+    },
+    buffered(size) {
+      if (pending.length > 0) return take(size);
+      return eof ? EMPTY : void 0;
+    },
+    async read(size) {
+      if (pending.length > 0) return take(size);
+      if (eof) return EMPTY;
+      const chunk = await ctx.stdin.read(size);
+      if (chunk === null || chunk.length === 0) {
+        eof = true;
+        return EMPTY;
+      }
+      pending = chunk;
+      return take(size);
+    },
+    isatty() {
+      return Boolean(ctx.stdin.isTTY);
+    }
+  };
+}
+var BRIDGE_PY = `
+import builtins, io, sys
+import _sbx_host as _host
+from pyodide.ffi import can_run_sync, run_sync
+
+
+def _to_bytes(value):
+    if value is None:
+        return b""
+    to_bytes = getattr(value, "to_bytes", None)
+    if to_bytes is not None:
+        return to_bytes()
+    return bytes(value.to_py())
+
+
+class _SbxStdin(io.RawIOBase):
+    """The container's standard input, as a blocking raw stream."""
+
+    def readable(self):
+        return True
+
+    def fileno(self):
+        return 0
+
+    def isatty(self):
+        return bool(_host.isatty())
+
+    def readinto(self, target):
+        want = len(target)
+        if want == 0:
+            return 0
+        ready = _host.buffered(want)
+        if ready is None:
+            if not can_run_sync():
+                raise OSError(
+                    "this host cannot wait for interactive input: WebAssembly "
+                    "stack switching (JSPI) is unavailable. Pipe the input in, "
+                    "or use a browser or Node build that supports it."
+                )
+            ready = run_sync(_host.read(want))
+        data = _to_bytes(ready)
+        target[: len(data)] = data
+        return len(data)
+
+
+def _install():
+    stdin = io.TextIOWrapper(
+        io.BufferedReader(_SbxStdin()), encoding="utf-8", errors="replace", line_buffering=True
+    )
+    sys.stdin = stdin
+    sys.__stdin__ = stdin
+
+    def input(prompt=""):
+        # CPython writes the prompt to stdout and strips exactly one trailing
+        # newline; anything else changes what a program reads back.
+        if prompt != "":
+            sys.stdout.write(str(prompt))
+            sys.stdout.flush()
+        line = sys.stdin.readline()
+        if not line:
+            raise EOFError("EOF when reading a line")
+        if line.endswith("\\n"):
+            line = line[:-1]
+        if line.endswith("\\r"):
+            line = line[:-1]
+        return line
+
+    builtins.input = input
+
+
+_install()
+`;
+function installSyscallBridge(py) {
+  const slot = py.__sbxStdin ??= { active: null };
+  py.registerJsModule("_sbx_host", {
+    /* Not `?.` and `??`: `buffered` returns undefined to mean "you will have
+     * to wait", and a nullish default would quietly turn that into end-of-file —
+     * which is exactly the silent EOF this bridge exists to remove. */
+    buffered: (size) => slot.active ? slot.active.buffered(size) : EMPTY,
+    read: (size) => slot.active ? slot.active.read(size) : Promise.resolve(EMPTY),
+    isatty: () => slot.active?.isatty() ?? false
+  });
+  py.runPython(BRIDGE_PY);
+}
+function bindStdin(py, host2) {
+  py.__sbxStdin.active = host2;
+}
+
 // src/runtime/cpython.ts
 var RESERVED_FOR_INTERPRETER = /* @__PURE__ */ new Set(["lib", "dev", "proc"]);
 var pyodideModule = null;
@@ -17827,6 +17995,7 @@ async function interpreterFor(ctx) {
     });
     mountContainerDirs(py, ctx);
     installRunner(py);
+    installSyscallBridge(py);
     return py;
   })();
   interpreters.set(ctx.vfs, starting);
@@ -17921,7 +18090,7 @@ function reportError(ctx, error) {
 `);
   return 1;
 }
-async function runCPythonProgram(ctx, source, argv, scriptDir, stdinText) {
+async function runCPythonProgram(ctx, source, argv, scriptDir = null) {
   let py;
   try {
     py = await interpreterFor(ctx);
@@ -17942,7 +18111,6 @@ async function runCPythonProgram(ctx, source, argv, scriptDir, stdinText) {
     });
   } catch {
   }
-  const encoder8 = new TextEncoder();
   const decoder8 = new TextDecoder();
   py.setStdout({
     write: (buffer) => {
@@ -17956,20 +18124,17 @@ async function runCPythonProgram(ctx, source, argv, scriptDir, stdinText) {
       return buffer.length;
     }
   });
-  if (stdinText !== null) {
-    const bytes2 = encoder8.encode(stdinText);
-    let offset = 0;
-    py.setStdin({
-      read: (buffer) => {
-        const take = Math.min(buffer.length, bytes2.length - offset);
-        buffer.set(bytes2.subarray(offset, offset + take));
-        offset += take;
-        return take;
-      }
-    });
-  } else {
-    py.setStdin({ read: () => 0 });
-  }
+  const stdinHost = createStdinHost(ctx);
+  await stdinHost.prime();
+  bindStdin(py, stdinHost);
+  py.setStdin({
+    read: (buffer) => {
+      const ready = stdinHost.buffered(buffer.length);
+      if (!ready || ready.length === 0) return 0;
+      buffer.set(ready);
+      return ready.length;
+    }
+  });
   try {
     bootstrap(py, ctx, argv, scriptDir);
   } catch (error) {
@@ -18102,11 +18267,6 @@ function configurePython(options = {}) {
   configureCPython({ indexURL: options.indexURL, moduleURL: options.pyodideURL });
 }
 var isPythonAvailable = isCPythonAvailable;
-async function readStdin(ctx) {
-  if (ctx.stdin.isTTY || ctx.stdin.interactive) return null;
-  const bytes2 = await ctx.stdin.readAll();
-  return bytes2.length ? new TextDecoder().decode(bytes2) : null;
-}
 var python = defineCommand({
   name: "python3",
   path: "/usr/bin/python3",
@@ -18155,7 +18315,7 @@ compatible packages can be installed with pip (micropip).`,
     }
     const rest = argv.slice(i);
     if (command !== void 0) {
-      return (await runCPythonProgram(ctx, command, ["-c", ...rest], null, await readStdin(ctx))).exitCode;
+      return (await runCPythonProgram(ctx, command, ["-c", ...rest], null)).exitCode;
     }
     if (moduleName !== void 0) {
       const program = `
@@ -18167,16 +18327,16 @@ except ImportError:
     print("/usr/bin/python3: No module named " + ${JSON.stringify(moduleName)}, file=sys.stderr)
     raise SystemExit(1)
 `;
-      return (await runCPythonProgram(ctx, program, [moduleName, ...rest], null, await readStdin(ctx))).exitCode;
+      return (await runCPythonProgram(ctx, program, [moduleName, ...rest], null)).exitCode;
     }
     if (script === void 0) {
       if (ctx.stdin.isTTY) return runCPythonRepl(ctx);
       const source2 = new TextDecoder().decode(await ctx.stdin.readAll());
-      return source2.trim() ? (await runCPythonProgram(ctx, source2, ["", ...rest], null, null)).exitCode : 0;
+      return source2.trim() ? (await runCPythonProgram(ctx, source2, ["", ...rest])).exitCode : 0;
     }
     if (script === "-") {
       const source2 = new TextDecoder().decode(await ctx.stdin.readAll());
-      return (await runCPythonProgram(ctx, source2, ["-", ...rest], null, null)).exitCode;
+      return (await runCPythonProgram(ctx, source2, ["-", ...rest])).exitCode;
     }
     const abs = ctx.path(script);
     let source;
@@ -18187,7 +18347,7 @@ except ImportError:
 `);
       return 2;
     }
-    return (await runCPythonProgram(ctx, source, [abs, ...rest], dirname(abs), await readStdin(ctx))).exitCode;
+    return (await runCPythonProgram(ctx, source, [abs, ...rest], dirname(abs))).exitCode;
   }
 });
 function printHelp2(ctx) {
@@ -19699,6 +19859,7 @@ var KernelChildProcess = class {
       this.stdin.isTTY = true;
       this.stdin.interactive = true;
     }
+    this.stdin.onRawMode = (enabled) => this.emit("rawmode", enabled);
     this.kernel = kernel;
     this.cred = cred;
     this.pid = pid;
@@ -19815,7 +19976,7 @@ function installNodeChildProcessBridge(pod, kernel, cred) {
   const originalSpawn = manager.spawn;
   manager.spawn = (config) => {
     const resolved = kernel.resolveExecutable(config.command, config.cwd ?? "/", config.env ?? {}, cred);
-    if (resolved?.kind === "builtin" && resolved.command?.name !== "node" && resolved.command?.name !== "nodejs") {
+    if (resolved?.kind === "builtin") {
       return new KernelChildProcess(kernel, cred, config, nextBridgePid++);
     }
     return originalSpawn.call(manager, config);
@@ -19826,6 +19987,68 @@ function installNodeChildProcessBridge(pod, kernel, cred) {
   };
 }
 
+// src/runtime/host-module-tracker.ts
+var HostModuleTracker = class {
+  active = 0;
+  disposed = false;
+  dispose() {
+    this.disposed = true;
+  }
+  wrapped = /* @__PURE__ */ new WeakMap();
+  originals = /* @__PURE__ */ new WeakMap();
+  pending = () => this.active;
+  unwrap = (value) => value && (typeof value === "object" || typeof value === "function") ? this.originals.get(value) ?? value : value;
+  wrap(value) {
+    if (value === null || typeof value !== "object" && typeof value !== "function") return value;
+    const object = value;
+    if (Array.isArray(value) || ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return value;
+    if (this.wrapped.has(object)) return this.wrapped.get(object);
+    const tracker = this;
+    const proxy = new Proxy(object, {
+      // CommonJS native loaders re-export by assigning exports back onto the
+      // binding object. Never store a process-owned proxy in a shared module.
+      set(target, key, member) {
+        return Reflect.set(target, key, tracker.unwrap(member), target);
+      },
+      defineProperty(target, key, descriptor) {
+        return Reflect.defineProperty(target, key, "value" in descriptor ? { ...descriptor, value: tracker.unwrap(descriptor.value) } : descriptor);
+      },
+      get(target, key) {
+        const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+        const member = Reflect.get(target, key, target);
+        if (descriptor && !descriptor.configurable && "value" in descriptor && !descriptor.writable) return member;
+        return typeof member === "function" ? tracker.wrap(member) : member;
+      },
+      apply(target, receiver, args) {
+        const result = Reflect.apply(target, tracker.unwrap(receiver), args.map(tracker.unwrap));
+        if (result && typeof result.then === "function") {
+          tracker.active++;
+          return Promise.resolve(result).then(
+            (value2) => {
+              tracker.active--;
+              return tracker.disposed ? new Promise(() => {
+              }) : tracker.wrap(value2);
+            },
+            (error) => {
+              tracker.active--;
+              if (tracker.disposed) return new Promise(() => {
+              });
+              throw error;
+            }
+          );
+        }
+        return tracker.wrap(result);
+      },
+      construct(target, args, newTarget) {
+        return tracker.wrap(Reflect.construct(target, args.map(tracker.unwrap), tracker.unwrap(newTarget)));
+      }
+    });
+    this.wrapped.set(object, proxy);
+    this.originals.set(proxy, object);
+    return proxy;
+  }
+};
+
 // src/runtime/commonjs-engine.ts
 init_path();
 var HELPERS = {
@@ -21563,6 +21786,7 @@ var VirtualHttpServer = class extends EventEmitter4 {
   owner;
   listening = false;
   portValue = null;
+  referenced = true;
   listen(...args) {
     const callback = typeof args.at(-1) === "function" ? args.pop() : void 0;
     const first = args[0];
@@ -21591,11 +21815,16 @@ var VirtualHttpServer = class extends EventEmitter4 {
     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;
@@ -21605,13 +21834,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) {
@@ -21620,6 +21852,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();
   }
@@ -22031,6 +22266,108 @@ function hashFor(algorithm) {
 function toBytes2(data, encoding) {
   return typeof data === "string" ? Buffer2.from(data, encoding) : data;
 }
+
+// src/runtime/sync-channel.ts
+var STATE = 0;
+var LENGTH = 1;
+var MORE = 2;
+var CONTROL_WORDS = 4;
+var STATE_REQUEST = 1;
+var STATE_RESPONSE = 2;
+var STATE_CONTINUE = 3;
+var STATE_CLOSED = 4;
+function createSyncChannelBuffers(capacityBytes = 1 << 20) {
+  return {
+    control: new SharedArrayBuffer(CONTROL_WORDS * Int32Array.BYTES_PER_ELEMENT),
+    data: new SharedArrayBuffer(capacityBytes)
+  };
+}
+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;
+}
+function syncChannelSupported() {
+  return syncChannelUnavailableReason() === null;
+}
+var SyncChannelServer = class {
+  constructor(buffers, handle) {
+    this.handle = handle;
+    this.control = new Int32Array(buffers.control);
+    this.data = new Uint8Array(buffers.data);
+    this.capacity = this.data.length;
+  }
+  handle;
+  control;
+  data;
+  capacity;
+  /** Request chunks gathered so far, and the response still to be sent. */
+  incoming = [];
+  outgoing = null;
+  sent = 0;
+  closed = false;
+  /** Call from the wake message the client sends after each chunk. */
+  async pump() {
+    if (this.closed) return;
+    const state = Atomics.load(this.control, STATE);
+    if (state === STATE_REQUEST) {
+      const size = Atomics.load(this.control, LENGTH);
+      this.incoming.push(this.data.slice(0, size));
+      if (Atomics.load(this.control, MORE) === 1) {
+        this.publish(STATE_CONTINUE);
+        return;
+      }
+      const request = concat3(this.incoming);
+      this.incoming = [];
+      let response;
+      try {
+        response = await this.handle(request);
+      } catch {
+        response = new Uint8Array();
+      }
+      if (this.closed) return;
+      this.outgoing = response;
+      this.sent = 0;
+      this.sendChunk();
+      return;
+    }
+    if (state === STATE_CONTINUE) this.sendChunk();
+  }
+  /** Release a blocked client, e.g. when the container is torn down. */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    Atomics.store(this.control, STATE, STATE_CLOSED);
+    Atomics.notify(this.control, STATE);
+  }
+  sendChunk() {
+    const payload = this.outgoing ?? new Uint8Array();
+    const size = Math.min(this.capacity, payload.length - this.sent);
+    this.data.set(payload.subarray(this.sent, this.sent + size), 0);
+    this.sent += size;
+    Atomics.store(this.control, LENGTH, size);
+    Atomics.store(this.control, MORE, this.sent < payload.length ? 1 : 0);
+    this.publish(STATE_RESPONSE);
+  }
+  publish(state) {
+    Atomics.store(this.control, STATE, state);
+    Atomics.notify(this.control, STATE);
+  }
+};
+function concat3(parts) {
+  if (parts.length === 1) return parts[0];
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const joined = new Uint8Array(total);
+  let at = 0;
+  for (const part of parts) {
+    joined.set(part, at);
+    at += part.length;
+  }
+  return joined;
+}
 var ChildProcess = class extends EventEmitter4 {
   stdout = new streamModule4.PassThrough();
   stderr = new streamModule4.PassThrough();
@@ -22235,7 +22572,7 @@ function unavailable(name) {
     const list = Array.isArray(args[1]) ? args[1].map(String) : [];
     const command = file3 ? [file3, ...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;
@@ -22523,6 +22860,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 = "";
@@ -22618,7 +22960,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,
@@ -22627,7 +22969,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 = () => {
@@ -22896,7 +23238,7 @@ function createCoreModules(options) {
     "stream/promises": createStreamPromises(),
     string_decoder: stringDecoderModule,
     timers: { ...timersModule, ...timers.api },
-    "timers/promises": createTimerPromises(),
+    "timers/promises": createTimerPromises(timers.api),
     tty: { isatty: () => false, ReadStream: streamModule4.Readable, WriteStream: streamModule4.Writable },
     url: url_module_default,
     util: util_module_default,
@@ -23641,10 +23983,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() {
@@ -24352,11 +24694,8 @@ function ensureProcessGlobal() {
 // src/runtime/host-rolldown.ts
 var BUNDLER_HINT = "If this is a bundler pre-bundling the worker away, exclude the binding from dependency optimisation \u2014 in Vite:\n\n  optimizeDeps: { exclude: ['@rolldown/binding-wasm32-wasi'] }";
 async function loadHostRolldownBinding() {
-  if (typeof window !== "undefined" && globalThis.crossOriginIsolated !== true) {
-    throw new Error(
-      "Vite 8/Rolldown requires cross-origin isolation. Serve the app with Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp headers."
-    );
-  }
+  const reason = syncChannelUnavailableReason();
+  if (reason) throw new Error(`SandboxedJs threaded WASM unavailable: ${reason}`);
   try {
     const loaded = await import('@rolldown/binding-wasm32-wasi');
     return "__fs" in loaded ? { ...loaded } : loaded.default ?? loaded;
@@ -24364,9 +24703,9 @@ async function loadHostRolldownBinding() {
     if (typeof process !== "undefined" && process.env?.SANDBOXEDJS_DEBUG) {
       console.error("[sandboxedjs] Rolldown WASI binding unavailable:", error);
     }
-    const reason = error instanceof Error ? error.message : String(error);
+    const reason2 = error instanceof Error ? error.message : String(error);
     throw new Error(
-      `The optional Rolldown WASI binding could not be loaded: ${reason}` + (typeof window === "undefined" ? "" : `
+      `The optional Rolldown WASI binding could not be loaded: ${reason2}` + (typeof window === "undefined" ? "" : `
 
 ${BUNDLER_HINT}`),
       { cause: error }
@@ -24477,6 +24816,8 @@ var LocalProcess = class extends EventEmitter4 {
   }
   /** End the process now, for an asynchronous `process.exit`. */
   exitNow(code) {
+    this.killed = true;
+    this.cleanup?.();
     this.finish(code);
     this.resolveKilled();
   }
@@ -24660,6 +25001,7 @@ var LocalRuntimePod = class _LocalRuntimePod {
     )
   };
   disposed = false;
+  running = /* @__PURE__ */ new Set();
   workdir;
   env;
   aliases;
@@ -24701,8 +25043,9 @@ var LocalRuntimePod = class _LocalRuntimePod {
     const cwd = typeof options.cwd === "string" ? options.cwd : this.workdir;
     const env2 = { ...this.env, ...isRecord(options.env) ? options.env : {} };
     const owner = `${this.instanceId}:${Math.random().toString(36).slice(2)}`;
-    return new LocalProcess(async (proc) => {
+    const process2 = new LocalProcess(async (proc) => {
       await this.prepareRolldown(cwd, env2);
+      if (proc.isKilled()) return 137;
       const untrack = trackProcess(proc);
       let requestedExit = 0;
       let engine;
@@ -24730,7 +25073,9 @@ var LocalRuntimePod = class _LocalRuntimePod {
         onRawMode: (enabled) => proc.emit("rawmode", enabled)
       });
       proc.acceptInput((data) => core.writeStdin(data), () => core.endStdin());
+      const hostWork = new HostModuleTracker();
       proc.onKill(() => {
+        hostWork.dispose();
         core.cancelTimers();
         this.router.closeOwner(owner);
       });
@@ -24739,21 +25084,22 @@ var LocalRuntimePod = class _LocalRuntimePod {
         builtins: core.builtins,
         globals: core.globals,
         aliases: this.aliases,
-        overrides: this.modules
+        overrides: Object.fromEntries(Object.entries(this.modules).map(([key, value]) => [key, hostWork.wrap(value)]))
       });
       try {
-        await engine.run(script);
-        await this.settle(owner, core.pendingHandles, core.pendingUnrefed, core.readingStdin, core.pendingRequests, () => proc.isKilled());
-        if (this.router.activePorts(owner).length) {
-          await proc.waitForKill();
-          return 137;
-        }
+        await Promise.race([engine.run(script), proc.waitForKill()]);
+        await this.settle(owner, core.pendingHandles, core.readingStdin, () => core.pendingRequests() + hostWork.pending(), () => proc.isKilled());
         return requestedExit;
       } finally {
+        hostWork.dispose();
+        core.cancelTimers();
         untrack();
         this.router.closeOwner(owner);
       }
     });
+    this.running.add(process2);
+    void process2.completion.then(() => this.running.delete(process2));
+    return process2;
   }
   /**
    * Rolldown's JavaScript API synchronously requires its compiled binding.
@@ -24789,19 +25135,13 @@ var LocalRuntimePod = class _LocalRuntimePod {
    * A plain script that has genuinely finished falls straight through both,
    * costing a handful of empty turns.
    */
-  async settle(owner, pendingHandles, pendingUnrefed, readingStdin, pendingRequests, killed) {
-    for (let turn = 0; turn < DRAIN_TURNS; turn++) {
-      if (this.router.activePorts(owner).length || killed()) return;
-      await new Promise((resolve2) => setTimeout(resolve2, 0));
-    }
-    if (pendingHandles() === 0 && pendingRequests() === 0 && pendingUnrefed() > 0 && !readingStdin()) {
-      const deadline = Date.now() + 1e3;
-      while (!this.router.activePorts(owner).length && !killed() && Date.now() < deadline) {
-        await new Promise((resolve2) => setTimeout(resolve2, 5));
-      }
-    }
-    while (!this.router.activePorts(owner).length && !killed() && (pendingHandles() > 0 || pendingRequests() > 0 || readingStdin())) {
-      await new Promise((resolve2) => setTimeout(resolve2, 5));
+  async settle(owner, pendingHandles, readingStdin, pendingRequests, killed) {
+    let idleTurns = 0;
+    while (!killed()) {
+      const busy = this.router.referencedPorts(owner).length > 0 || pendingHandles() > 0 || pendingRequests() > 0 || readingStdin();
+      idleTurns = busy ? 0 : idleTurns + 1;
+      if (idleTurns >= DRAIN_TURNS) return;
+      await new Promise((resolve2) => setTimeout(resolve2, busy ? 5 : 0));
     }
   }
   async request(_port, _init = {}) {
@@ -24818,6 +25158,8 @@ var LocalRuntimePod = class _LocalRuntimePod {
   }
   teardown() {
     this.disposed = true;
+    for (const process2 of this.running) process2.kill();
+    this.running.clear();
     this.router.closeAll();
     this.esbuild?.stop();
   }
@@ -24887,103 +25229,6 @@ function attachRolldownMirror(binding, volume, root) {
   volume.attach(fs, root);
 }
 
-// src/runtime/sync-channel.ts
-var STATE = 0;
-var LENGTH = 1;
-var MORE = 2;
-var CONTROL_WORDS = 4;
-var STATE_REQUEST = 1;
-var STATE_RESPONSE = 2;
-var STATE_CONTINUE = 3;
-var STATE_CLOSED = 4;
-function createSyncChannelBuffers(capacityBytes = 1 << 20) {
-  return {
-    control: new SharedArrayBuffer(CONTROL_WORDS * Int32Array.BYTES_PER_ELEMENT),
-    data: new SharedArrayBuffer(capacityBytes)
-  };
-}
-function syncChannelSupported() {
-  if (typeof SharedArrayBuffer !== "function") return false;
-  if (typeof Atomics !== "object" || typeof Atomics.wait !== "function") return false;
-  if (typeof window !== "undefined" && globalThis.crossOriginIsolated !== true) return false;
-  return true;
-}
-var SyncChannelServer = class {
-  constructor(buffers, handle) {
-    this.handle = handle;
-    this.control = new Int32Array(buffers.control);
-    this.data = new Uint8Array(buffers.data);
-    this.capacity = this.data.length;
-  }
-  handle;
-  control;
-  data;
-  capacity;
-  /** Request chunks gathered so far, and the response still to be sent. */
-  incoming = [];
-  outgoing = null;
-  sent = 0;
-  closed = false;
-  /** Call from the wake message the client sends after each chunk. */
-  async pump() {
-    if (this.closed) return;
-    const state = Atomics.load(this.control, STATE);
-    if (state === STATE_REQUEST) {
-      const size = Atomics.load(this.control, LENGTH);
-      this.incoming.push(this.data.slice(0, size));
-      if (Atomics.load(this.control, MORE) === 1) {
-        this.publish(STATE_CONTINUE);
-        return;
-      }
-      const request = concat3(this.incoming);
-      this.incoming = [];
-      let response;
-      try {
-        response = await this.handle(request);
-      } catch {
-        response = new Uint8Array();
-      }
-      if (this.closed) return;
-      this.outgoing = response;
-      this.sent = 0;
-      this.sendChunk();
-      return;
-    }
-    if (state === STATE_CONTINUE) this.sendChunk();
-  }
-  /** Release a blocked client, e.g. when the container is torn down. */
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-    Atomics.store(this.control, STATE, STATE_CLOSED);
-    Atomics.notify(this.control, STATE);
-  }
-  sendChunk() {
-    const payload = this.outgoing ?? new Uint8Array();
-    const size = Math.min(this.capacity, payload.length - this.sent);
-    this.data.set(payload.subarray(this.sent, this.sent + size), 0);
-    this.sent += size;
-    Atomics.store(this.control, LENGTH, size);
-    Atomics.store(this.control, MORE, this.sent < payload.length ? 1 : 0);
-    this.publish(STATE_RESPONSE);
-  }
-  publish(state) {
-    Atomics.store(this.control, STATE, state);
-    Atomics.notify(this.control, STATE);
-  }
-};
-function concat3(parts) {
-  if (parts.length === 1) return parts[0];
-  const total = parts.reduce((sum, part) => sum + part.length, 0);
-  const joined = new Uint8Array(total);
-  let at = 0;
-  for (const part of parts) {
-    joined.set(part, at);
-    at += part.length;
-  }
-  return joined;
-}
-
 // src/runtime/remote-volume.ts
 var encoder7 = new TextEncoder();
 var decoder7 = new TextDecoder();
@@ -25078,24 +25323,32 @@ function defaultWorkerUrl() {
   return new URL("./worker-entry.js", import.meta.url);
 }
 function hasDomWorker() {
-  return typeof Worker === "function" && typeof document !== "undefined";
+  return typeof Worker === "function";
 }
 async function startRuntimeWorker(options = {}) {
   const url = options.url ?? defaultWorkerUrl();
   const worker = hasDomWorker() ? await startDomWorker(url) : await startNodeWorker(url, options.workerData ?? {});
-  await new Promise((resolve2, reject) => {
-    const timer = setTimeout(() => reject(new Error("the runtime worker did not start in time")), options.timeoutMs ?? 1e4);
-    worker.onMessage((message) => {
-      if (message?.type === "sandboxedjs:ready") {
+  try {
+    await new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => reject(new Error("the runtime worker did not start in time")), options.timeoutMs ?? 1e4);
+      worker.onMessage((message) => {
+        if (message?.type === "sandboxedjs:ready") {
+          clearTimeout(timer);
+          resolve2();
+        }
+      });
+      worker.onError((error) => {
         clearTimeout(timer);
-        resolve2();
-      }
-    });
-    worker.onError((error) => {
-      clearTimeout(timer);
-      reject(error instanceof Error ? error : new Error(String(error)));
+        reject(error instanceof Error ? error : new Error(String(error)));
+      });
     });
-  });
+  } catch (error) {
+    try {
+      await worker.terminate();
+    } catch {
+    }
+    throw error;
+  }
   return worker;
 }
 async function startDomWorker(url) {
@@ -25156,6 +25409,8 @@ var WorkerProcess = class extends EventEmitter4 {
   started = false;
   pendingInput = [];
   inputEnded = false;
+  inheritedInput;
+  ownRawMode = false;
   on(event, listener) {
     return super.on(event, listener);
   }
@@ -25181,13 +25436,38 @@ var WorkerProcess = class extends EventEmitter4 {
    * program is still loading, and dropping them loses the answer to a prompt.
    */
   write(data) {
+    if (this.inheritedInput) {
+      this.inheritedInput.sendStdin(data);
+      return;
+    }
     if (this.started) this.worker.postMessage({ type: "stdin", data });
     else this.pendingInput.push(data);
   }
   endInput() {
     this.inputEnded = true;
+    if (this.inheritedInput) {
+      this.inheritedInput.endStdin?.();
+      return;
+    }
     if (this.started) this.worker.postMessage({ type: "stdin-end" });
   }
+  rawMode(enabled) {
+    this.ownRawMode = enabled;
+    if (!this.inheritedInput) this.emit("rawmode", enabled);
+  }
+  /** The parent is blocked in Atomics.wait, so inherited input must bypass it. */
+  inheritInput(child) {
+    this.inheritedInput = child;
+    this.emit("rawmode", false);
+    child.on("rawmode", (enabled) => {
+      if (this.inheritedInput === child) this.emit("rawmode", Boolean(enabled));
+    });
+    return () => {
+      if (this.inheritedInput !== child) return;
+      this.inheritedInput = void 0;
+      this.emit("rawmode", this.ownRawMode);
+    };
+  }
   kill(_signal = "SIGTERM") {
     this.worker.postMessage({ type: "kill" });
     this.finish(137);
@@ -25208,25 +25488,30 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
     super(options);
     this.workerUrl = options.workerUrl;
   }
-  /**
-   * Boot a Worker-backed pod, or return null when this host cannot support one.
-   *
-   * Declining is a first-class outcome. `SharedArrayBuffer` needs cross-origin
-   * isolation, a bundler may have made the guest script unreachable, and a host
-   * that supplied its own module objects has handed over things no thread
-   * boundary can carry. In every case the caller falls back to the in-realm pod
-   * and keeps working.
-   */
-  static async tryBoot(options = {}) {
-    if (!syncChannelSupported()) return null;
-    if (options.modules && Object.keys(options.modules).length > 0) return null;
+  /** Boot without silently dropping synchronous child-process support. */
+  static async boot(options = {}) {
+    const reason = syncChannelUnavailableReason();
+    if (reason) throw new Error(`SandboxedJs worker runtime unavailable: ${reason}`);
+    if (options.modules && Object.keys(options.modules).length > 0) {
+      throw new Error("SandboxedJs worker runtime cannot clone host-supplied modules. Use isolation: 'realm' explicitly.");
+    }
     const pod = new _WorkerRuntimePod(options);
     try {
       const probe = await startRuntimeWorker({ ...options.workerUrl ? { url: options.workerUrl } : {}, timeoutMs: 1e4 });
       await probe.terminate();
       return pod;
-    } catch {
+    } catch (cause) {
       pod.teardown();
+      const detail = cause instanceof Error ? cause.message : String(cause);
+      throw new Error(`SandboxedJs guest worker failed to start: ${detail}. Check that worker-entry.js is served as JavaScript; set workerUrl if your bundler moved it.`, { cause });
+    }
+  }
+  /** Compatibility mode, with an observable explanation for every fallback. */
+  static async tryBoot(options = {}, onFallback = (error) => console.warn(`[sandboxedjs] Falling back to the realm runtime; synchronous child processes are unavailable. ${error.message}`)) {
+    try {
+      return await _WorkerRuntimePod.boot(options);
+    } catch (error) {
+      onFallback(error instanceof Error ? error : new Error(String(error)));
       return null;
     }
   }
@@ -25249,11 +25534,14 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
     const streams = { target: null };
     const server = new SyncChannelServer(buffers, serveSyncSyscalls({
       volume: this.volume,
-      spawnChild: (request) => this.runChildToCompletion(request, streams.target)
+      spawnChild: (request) => this.runChildToCompletion(request, streams.target, ownedChildren)
     }));
     const entry = { worker, server };
     this.live.add(entry);
+    const ownedChildren = /* @__PURE__ */ new Set();
     const process2 = new WorkerProcess(worker, () => {
+      for (const child of ownedChildren) child.kill("SIGTERM");
+      ownedChildren.clear();
       this.live.delete(entry);
       server.close();
       this.closeProxies(owner);
@@ -25274,7 +25562,7 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
           process2.error(String(message.text));
           return;
         case "rawmode":
-          process2.emit("rawmode", Boolean(message.enabled));
+          process2.rawMode(Boolean(message.enabled));
           return;
         case "exit":
           process2.finish(Number(message.code));
@@ -25282,11 +25570,20 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
         case "listen":
           this.proxyPort(Number(message.port), owner, worker);
           return;
+        case "close-port": {
+          const port = Number(message.port);
+          const proxy = this.proxies.get(port);
+          if (proxy?.owner === owner) {
+            proxy.close();
+            this.proxies.delete(port);
+          }
+          return;
+        }
         case "http-response":
           this.settleProxied(Number(message.id), message.response);
           return;
         case "child-start":
-          this.startChild(worker, children, message);
+          this.startChild(worker, children, message, ownedChildren);
           return;
         case "child-stdin":
           children.get(message.id)?.sendStdin?.(String(message.data));
@@ -25317,16 +25614,21 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
     return process2;
   }
   /** Start an asynchronous child on the host's behalf and relay its events. */
-  startChild(worker, children, message) {
+  startChild(worker, children, message, owned) {
     const handle = this.processManager.spawn(message.config);
     children.set(message.id, handle);
+    owned.add(handle);
+    handle.on("exit", () => {
+      owned.delete(handle);
+      children.delete(message.id);
+    });
     for (const event of ["stdout", "stderr", "exit"]) {
       handle.on(event, (value) => worker.postMessage({ type: "child-event", id: message.id, event, value }));
     }
     handle.exec();
   }
   /** Run a child to completion and collect it, for the guest's `spawnSync`. */
-  runChildToCompletion(request, streamTo) {
+  runChildToCompletion(request, streamTo, owned) {
     return new Promise((resolve2) => {
       let handle;
       try {
@@ -25342,9 +25644,13 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
         resolve2({ status: null, stdout: "", stderr: "", signal: null, error: { ...failure.code ? { code: failure.code } : {}, message: failure.message } });
         return;
       }
+      owned.add(handle);
+      handle.on("exit", () => owned.delete(handle));
       let stdout = "";
       let stderr = "";
       const live = request.inheritStdio ? streamTo : null;
+      const restoreInput = live?.inheritInput(handle);
+      if (restoreInput) handle.on("exit", restoreInput);
       handle.on("stdout", (text2) => {
         stdout += text2;
         live?.output(text2);
@@ -25498,7 +25804,7 @@ var Container = class _Container {
       ...opts.onServerReady ? { onServerReady: opts.onServerReady } : {}
     };
     const workerOptions = { ...podOptions, ...opts.workerUrl ? { workerUrl: opts.workerUrl } : {} };
-    const pod = opts.pod ?? (opts.isolation === "realm" ? null : await WorkerRuntimePod.tryBoot(workerOptions)) ?? await LocalRuntimePod.boot(podOptions);
+    const pod = opts.pod ?? (opts.isolation === "realm" ? null : opts.isolation === "worker" ? await WorkerRuntimePod.boot(workerOptions) : await WorkerRuntimePod.tryBoot(workerOptions, opts.onRuntimeFallback)) ?? await LocalRuntimePod.boot(podOptions);
     const kernel = new Kernel({
       pod,
       hostname: opts.hostname ?? "sandbox",
@@ -26006,7 +26312,7 @@ var Terminal = class {
     if (this.running) {
       const raw = this.currentStdin?.rawMode === true;
       if (ch === CTRL_C && !raw) {
-        this.session.proc.deliver("SIGINT");
+        if (this.currentStdin) this.session.shell.interruptForeground("SIGINT", this.currentStdin);
         this.write("^C\r\n");
         return;
       }
@@ -26396,7 +26702,7 @@ function serveContainerOn(port, box) {
 }
 async function createPreview(box, options = {}) {
   if (typeof navigator === "undefined" || !("serviceWorker" in navigator)) return null;
-  const scriptUrl = options.scriptUrl ?? new URL("./service-worker.js", import.meta.url);
+  const scriptUrl = options.scriptUrl ?? new URL("./service-worker.js?no-inline", import.meta.url);
   let registration;
   try {
     registration = await navigator.serviceWorker.register(scriptUrl, {