sandboxedjs 0.1.29 → 0.1.31

package/dist/index.cjs

@@ -4795,7 +4795,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() {
@@ -5923,13 +5931,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 {
@@ -7921,6 +7935,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;
   }
@@ -8570,6 +8600,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,
@@ -19712,6 +19743,11 @@ var KernelChildProcess = class {
   started = false;
   cancelled = false;
   constructor(kernel, cred, config, pid) {
+    if (config.inheritStdio) {
+      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;
@@ -19828,7 +19864,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);
@@ -19839,6 +19875,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 = {
@@ -21576,6 +21674,7 @@ var VirtualHttpServer = class extends EventEmitter4__default.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];
@@ -21604,11 +21703,16 @@ var VirtualHttpServer = class extends EventEmitter4__default.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;
@@ -21618,13 +21722,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) {
@@ -21633,6 +21740,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();
   }
@@ -22044,6 +22154,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__default.default {
   stdout = new streamModule4__default.default.PassThrough();
   stderr = new streamModule4__default.default.PassThrough();
@@ -22116,7 +22328,8 @@ var ChildProcess = class extends EventEmitter4__default.default {
     queueMicrotask(() => this.emit("close", code, null));
   }
 };
-function createChildProcessModule(spawnChild, defaultCwd, syncSpawn) {
+function createChildProcessModule(spawnChild, defaultCwd, syncSpawn, defaultEnv = () => ({})) {
+  const environmentFor = (options) => options.env ? { ...options.env } : defaultEnv();
   const throughShell = (command, options) => {
     const shell = typeof options.shell === "string" ? options.shell : "/bin/sh";
     return { file: shell, args: ["-c", command] };
@@ -22127,7 +22340,7 @@ function createChildProcessModule(spawnChild, defaultCwd, syncSpawn) {
       command: resolved.file,
       args: resolved.args,
       cwd: options.cwd ?? defaultCwd(),
-      ...options.env ? { env: options.env } : {}
+      env: environmentFor(options)
     });
     return new ChildProcess(handle, resolved.file, resolved.args);
   };
@@ -22173,11 +22386,11 @@ ${err.join("")}`),
     exec,
     execFile,
     fork: (modulePath, args = [], options = {}) => spawn("node", [modulePath, ...args], options),
-    ...buildSyncFamily(syncSpawn, throughShell, defaultCwd),
+    ...buildSyncFamily(syncSpawn, throughShell, defaultCwd, environmentFor),
     ChildProcess
   };
 }
-function buildSyncFamily(syncSpawn, throughShell, defaultCwd) {
+function buildSyncFamily(syncSpawn, throughShell, defaultCwd, environmentFor) {
   if (!syncSpawn) {
     return {
       execSync: unavailable("execSync"),
@@ -22188,12 +22401,14 @@ function buildSyncFamily(syncSpawn, throughShell, defaultCwd) {
   const run = (file3, args, options) => {
     const resolved = options.shell ? throughShell([file3, ...args].join(" "), options) : { file: file3, args };
     const input = options.input === void 0 ? void 0 : typeof options.input === "string" ? options.input : new TextDecoder().decode(options.input);
+    const inherit = options.stdio === "inherit" || Array.isArray(options.stdio) && options.stdio[0] === "inherit";
     return syncSpawn({
       command: resolved.file,
       args: resolved.args,
       cwd: options.cwd ?? defaultCwd(),
-      ...options.env ? { env: options.env } : {},
-      ...input === void 0 ? {} : { input }
+      env: environmentFor(options),
+      ...input === void 0 ? {} : { input },
+      ...inherit ? { inheritStdio: true } : {}
     });
   };
   const asOutput = (text2, options) => options.encoding === "buffer" || options.encoding === void 0 ? Buffer2.from(text2) : text2;
@@ -22245,7 +22460,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;
@@ -22533,6 +22748,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 = "";
@@ -22628,7 +22848,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,
@@ -22637,7 +22857,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 = () => {
@@ -22873,7 +23093,7 @@ 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) : createUnsupportedModule("child_process");
+  const childProcess = options.spawnChild ? createChildProcessModule(options.spawnChild, () => cwd, options.syncSpawn, () => ({ ...processObject.env })) : createUnsupportedModule("child_process");
   const readline = createReadlineModule(() => processObject.stdin, () => processObject.stdout);
   const dns = createDnsModule();
   const builtins = {
@@ -22906,7 +23126,7 @@ function createCoreModules(options) {
     "stream/promises": createStreamPromises(),
     string_decoder: stringDecoderModule__default.default,
     timers: { ...timersModule__default.default, ...timers.api },
-    "timers/promises": createTimerPromises(),
+    "timers/promises": createTimerPromises(timers.api),
     tty: { isatty: () => false, ReadStream: streamModule4__default.default.Readable, WriteStream: streamModule4__default.default.Writable },
     url: url_module_default,
     util: util_module_default,
@@ -23651,10 +23871,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() {
@@ -24118,8 +24338,10 @@ var MirroringVolume = class {
    * container pays nothing for this.
    */
   attach(mirror, root) {
+    const cleanRoot = clean(root);
+    if (this.mirror === mirror && this.root === cleanRoot) return;
     this.mirror = mirror;
-    this.root = clean(root);
+    this.root = cleanRoot;
     this.seed();
   }
   detach() {
@@ -24360,11 +24582,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;
@@ -24372,9 +24591,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 }
@@ -24485,6 +24704,8 @@ var LocalProcess = class extends EventEmitter4__default.default {
   }
   /** End the process now, for an asynchronous `process.exit`. */
   exitNow(code) {
+    this.killed = true;
+    this.cleanup?.();
     this.finish(code);
     this.resolveKilled();
   }
@@ -24668,6 +24889,7 @@ var LocalRuntimePod = class _LocalRuntimePod {
     )
   };
   disposed = false;
+  running = /* @__PURE__ */ new Set();
   workdir;
   env;
   aliases;
@@ -24709,8 +24931,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;
@@ -24738,7 +24961,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);
       });
@@ -24747,21 +24972,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.
@@ -24797,19 +25023,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 = {}) {
@@ -24826,6 +25046,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();
   }
@@ -24895,103 +25117,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();
@@ -25086,24 +25211,32 @@ function defaultWorkerUrl() {
   return new URL("./worker-entry.js", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 }
 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) {
@@ -25164,6 +25297,8 @@ var WorkerProcess = class extends EventEmitter4__default.default {
   started = false;
   pendingInput = [];
   inputEnded = false;
+  inheritedInput;
+  ownRawMode = false;
   on(event, listener) {
     return super.on(event, listener);
   }
@@ -25189,13 +25324,38 @@ var WorkerProcess = class extends EventEmitter4__default.default {
    * 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);
@@ -25216,25 +25376,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;
     }
   }
@@ -25254,18 +25419,23 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
       ...this.workerUrl ? { url: this.workerUrl } : {},
       timeoutMs: 15e3
     });
+    const streams = { target: null };
     const server = new SyncChannelServer(buffers, serveSyncSyscalls({
       volume: this.volume,
-      spawnChild: (request) => this.runChildToCompletion(request)
+      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);
       void worker.terminate();
     });
+    streams.target = process2;
     const children = /* @__PURE__ */ new Map();
     worker.onMessage((raw) => {
       const message = raw;
@@ -25280,7 +25450,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));
@@ -25288,11 +25458,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));
@@ -25323,16 +25502,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) {
+  runChildToCompletion(request, streamTo, owned) {
     return new Promise((resolve2) => {
       let handle;
       try {
@@ -25340,27 +25524,35 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
           command: request.command,
           args: request.args,
           cwd: request.cwd,
-          ...request.env ? { env: request.env } : {}
+          ...request.env ? { env: request.env } : {},
+          ...request.inheritStdio ? { inheritStdio: true } : {}
         });
       } catch (error) {
         const failure = error;
         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);
       });
       handle.on("stderr", (text2) => {
         stderr += text2;
+        live?.error(text2);
       });
       handle.on("exit", (code) => resolve2({ status: code, stdout, stderr, signal: null }));
       handle.exec();
       if (request.input !== void 0) {
         handle.sendStdin?.(request.input);
       }
-      handle.endStdin?.();
+      if (!request.inheritStdio) handle.endStdin?.();
     });
   }
   // ── HTTP servers living on another thread ─────────────────────────────────
@@ -25500,7 +25692,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",
@@ -26008,7 +26200,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;
       }
@@ -26361,6 +26553,97 @@ init_variables();
 init_arith();
 init_expand();
 init_builtins();
+
+// src/preview/register.ts
+function serveContainerOn(port, box) {
+  port.onmessage = async (event) => {
+    const request = event.data;
+    try {
+      const response = await box.request(request.port, {
+        method: request.method,
+        path: request.path,
+        headers: request.headers,
+        ...request.body ? { body: new Uint8Array(request.body) } : {}
+      });
+      const bytes2 = response.bytes.slice();
+      port.postMessage(
+        {
+          id: request.id,
+          response: {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            body: bytes2.buffer
+          }
+        },
+        [bytes2.buffer]
+      );
+    } catch (error) {
+      const message = new TextEncoder().encode(error instanceof Error ? error.message : String(error));
+      port.postMessage({
+        id: request.id,
+        response: { status: 502, statusText: "Bad Gateway", headers: {}, body: message.buffer }
+      });
+    }
+  };
+  port.start?.();
+}
+async function createPreview(box, options = {}) {
+  if (typeof navigator === "undefined" || !("serviceWorker" in navigator)) return null;
+  const scriptUrl = options.scriptUrl ?? new URL("./service-worker.js?no-inline", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+  let registration;
+  try {
+    registration = await navigator.serviceWorker.register(scriptUrl, {
+      type: "module",
+      ...options.scope ? { scope: options.scope } : {}
+    });
+  } catch {
+    return null;
+  }
+  const worker = registration.active ?? registration.waiting ?? registration.installing;
+  if (!worker) return null;
+  if (worker.state !== "activated") {
+    const activated = await new Promise((resolve2) => {
+      const check = () => {
+        if (worker.state === "activated") {
+          worker.removeEventListener("statechange", check);
+          resolve2(true);
+        } else if (worker.state === "redundant") {
+          worker.removeEventListener("statechange", check);
+          resolve2(false);
+        }
+      };
+      worker.addEventListener("statechange", check);
+      setTimeout(() => resolve2(worker.state === "activated"), 1e4);
+      check();
+    });
+    if (!activated) return null;
+  }
+  const channel = new MessageChannel();
+  serveContainerOn(channel.port1, box);
+  worker.postMessage({ type: "sandboxedjs:connect" }, [channel.port2]);
+  const base2 = registration.scope.replace(/\/$/, "");
+  return {
+    urlFor: (port) => `${base2}/__sbx__/${port}/`,
+    dispose: async () => {
+      channel.port1.close();
+      await registration.unregister();
+    }
+  };
+}
+async function renderInto(box, element, options = { port: 80 }) {
+  const response = await box.request(options.port, { path: options.path ?? "/" });
+  const frame = document.createElement("iframe");
+  frame.setAttribute("sandbox", "allow-scripts");
+  frame.style.width = "100%";
+  frame.style.height = "100%";
+  frame.style.border = "0";
+  frame.srcdoc = response.body;
+  element.replaceChildren(frame);
+  return frame;
+}
+
+// src/index.ts
 var src_default = createContainer;
 
 exports.BufferSink = BufferSink;
@@ -26404,6 +26687,7 @@ exports.VirtualHttpServer = VirtualHttpServer;
 exports.VirtualIncomingMessage = VirtualIncomingMessage;
 exports.VirtualServerResponse = VirtualServerResponse;
 exports.WASM_ALIASES = WASM_ALIASES;
+exports.WorkerRuntimePod = WorkerRuntimePod;
 exports.allCommands = allCommands;
 exports.applyChmod = applyChmod;
 exports.braceExpand = braceExpand;
@@ -26416,6 +26700,7 @@ exports.createChildProcessModule = createChildProcessModule;
 exports.createContainer = createContainer;
 exports.createContext = createContext;
 exports.createCoreModules = createCoreModules;
+exports.createPreview = createPreview;
 exports.default = src_default;
 exports.defineCommand = defineCommand;
 exports.evalArith = evalArith;
@@ -26442,6 +26727,7 @@ exports.octalMode = octalMode;
 exports.parseShell = parse;
 exports.parseUmask = parseUmask;
 exports.posixPath = path_exports;
+exports.renderInto = renderInto;
 exports.resetPidCounter = resetPidCounter;
 exports.shellQuote = shellQuote;
 exports.startRuntimeWorker = startRuntimeWorker;