sandboxedjs 0.2.21 → 0.2.23

package/dist/index.js

@@ -1,11 +1,12 @@
 import { Inflate as Inflate$1, Deflate as Deflate$1, inflateRaw, ungzip, gzip as gzip$1, deflate as deflate$1, inflate as inflate$1, deflateRaw } from 'pako';
 import { sha256, sha224 } from '@noble/hashes/sha256';
-import { Parser as Parser$1, parse as parse$1 } from 'acorn';
-import jsx from 'acorn-jsx';
 import { Buffer as Buffer$1 } from 'buffer/index.js';
 import { sha512, sha384 } from '@noble/hashes/sha512';
 import { sha1 } from '@noble/hashes/sha1';
 import { valid, maxSatisfying } from 'semver';
+import { Parser as Parser$1, parse as parse$1 } from 'acorn';
+import jsx from 'acorn-jsx';
+import { transform } from 'sucrase';
 import EventEmitter4 from 'events/events.js';
 import { exports as exports$1, imports } from 'resolve.exports';
 import pathModule from 'path-browserify';
@@ -4129,9 +4130,9 @@ async function randomUuid() {
   const { randomUUID } = await nodeCrypto();
   return randomUUID();
 }
-function toHex(bytes2) {
+function toHex(bytes3) {
   let out = "";
-  for (const byte of bytes2) out += byte.toString(16).padStart(2, "0");
+  for (const byte of bytes3) out += byte.toString(16).padStart(2, "0");
   return out;
 }
 function md5Hex(input) {
@@ -4869,12 +4870,12 @@ var Vfs = class {
   writeFile(abs, data, opts = {}) {
     const cred = opts.privileged ? void 0 : opts.cred;
     const real = this.resolvePath(abs, { cred });
-    const bytes2 = typeof data === "string" ? encoder.encode(data) : data;
+    const bytes3 = typeof data === "string" ? encoder.encode(data) : data;
     const virt = this.lookupVirtual(real);
     if (virt) {
       if (!virt.write) throw new SysError("EACCES", "write", real);
       this.require(this.statFromVirtual(real, virt), W_OK, cred, "open", real);
-      virt.write(bytes2, opts.append ?? false);
+      virt.write(bytes3, opts.append ?? false);
       return;
     }
     if (this.isUnderProvider(real)) throw new SysError("ENOENT", "open", real);
@@ -4889,8 +4890,8 @@ var Vfs = class {
       this.require(pst, W_OK | X_OK, cred, "open", real);
     }
     try {
-      if (opts.append && existing) this.volume.appendFileSync(real, bytes2);
-      else this.volume.writeFileSync(real, bytes2);
+      if (opts.append && existing) this.volume.appendFileSync(real, bytes3);
+      else this.volume.writeFileSync(real, bytes3);
     } catch (e) {
       throw toSysError(e, "open", real);
     }
@@ -5142,7 +5143,7 @@ var Vfs = class {
   usage(abs = "/") {
     let files = 0;
     let dirs = 0;
-    let bytes2 = 0;
+    let bytes3 = 0;
     for (const p of this.walk(abs)) {
       let st = null;
       try {
@@ -5153,10 +5154,10 @@ var Vfs = class {
       if (st.isDirectory()) dirs++;
       else {
         files++;
-        bytes2 += st.size;
+        bytes3 += st.size;
       }
     }
-    return { files, dirs, bytes: bytes2 };
+    return { files, dirs, bytes: bytes3 };
   }
 };
 
@@ -5240,10 +5241,10 @@ var Pipe = class _Pipe {
   write(data) {
     if (this.readerClosed) throw new SysError("EPIPE", "write");
     if (this.writerClosed) return;
-    const bytes2 = this.icrnl && !this.raw ? translateCarriageReturns(toBytes(data)) : toBytes(data);
-    if (bytes2.length === 0) return;
-    this.chunks.push(bytes2);
-    this.buffered += bytes2.length;
+    const bytes3 = this.icrnl && !this.raw ? translateCarriageReturns(toBytes(data)) : toBytes(data);
+    if (bytes3.length === 0) return;
+    this.chunks.push(bytes3);
+    this.buffered += bytes3.length;
     this.wake();
   }
   end() {
@@ -5333,15 +5334,15 @@ var Pipe = class _Pipe {
     return p;
   }
 };
-function translateCarriageReturns(bytes2) {
-  if (!bytes2.includes(CR)) return bytes2;
-  const out = new Uint8Array(bytes2.length);
+function translateCarriageReturns(bytes3) {
+  if (!bytes3.includes(CR)) return bytes3;
+  const out = new Uint8Array(bytes3.length);
   let length = 0;
-  for (let index = 0; index < bytes2.length; index += 1) {
-    const byte = bytes2[index];
+  for (let index = 0; index < bytes3.length; index += 1) {
+    const byte = bytes3[index];
     if (byte === CR) {
       out[length++] = LF;
-      if (bytes2[index + 1] === LF) index += 1;
+      if (bytes3[index + 1] === LF) index += 1;
     } else {
       out[length++] = byte;
     }
@@ -5387,11 +5388,11 @@ var BufferSink = class {
   }
   write(data) {
     if (this._closed) return;
-    const bytes2 = toBytes(data);
-    if (bytes2.length === 0) return;
-    this.chunks.push(bytes2);
-    this.total += bytes2.length;
-    this.onWrite?.(bytes2);
+    const bytes3 = toBytes(data);
+    if (bytes3.length === 0) return;
+    this.chunks.push(bytes3);
+    this.total += bytes3.length;
+    this.onWrite?.(bytes3);
   }
   end() {
     this._closed = true;
@@ -6280,8 +6281,8 @@ var SIZEOF_FDSTAT = 24;
 var SIZEOF_DIRENT = 24;
 var SIZEOF_SUBSCRIPTION = 48;
 var SIZEOF_EVENT = 32;
-function isWasmBinary(bytes2) {
-  return bytes2.length >= 4 && bytes2[0] === 0 && bytes2[1] === 97 && bytes2[2] === 115 && bytes2[3] === 109;
+function isWasmBinary(bytes3) {
+  return bytes3.length >= 4 && bytes3[0] === 0 && bytes3[1] === 97 && bytes3[2] === 115 && bytes3[3] === 109;
 }
 
 // src/wasi/host.ts
@@ -7071,8 +7072,8 @@ function defaultSleep(milliseconds) {
 // src/wasi/run.ts
 var compiled = /* @__PURE__ */ new Map();
 var MAX_CACHED_MODULES = 32;
-async function runWasi(ctx, bytes2, options = {}) {
-  if (!isWasmBinary(bytes2)) {
+async function runWasi(ctx, bytes3, options = {}) {
+  if (!isWasmBinary(bytes3)) {
     ctx.warn("cannot execute binary file: not a WebAssembly module");
     return EXIT_NOT_EXECUTABLE;
   }
@@ -7096,7 +7097,7 @@ async function runWasi(ctx, bytes2, options = {}) {
   });
   let instance;
   try {
-    const module = await compile(bytes2);
+    const module = await compile(bytes3);
     instance = await WebAssembly.instantiate(module, {
       ...options.imports,
       wasi_snapshot_preview1: host2.wasiImport,
@@ -7132,15 +7133,15 @@ async function runWasi(ctx, bytes2, options = {}) {
     }
   }
 }
-async function compile(bytes2) {
-  const key = await digest(bytes2);
+async function compile(bytes3) {
+  const key = await digest(bytes3);
   const hit = compiled.get(key);
   if (hit) {
     compiled.delete(key);
     compiled.set(key, hit);
     return hit;
   }
-  const module = await WebAssembly.compile(sliceForWasm(bytes2));
+  const module = await WebAssembly.compile(sliceForWasm(bytes3));
   compiled.set(key, module);
   if (compiled.size > MAX_CACHED_MODULES) {
     const oldest = compiled.keys().next().value;
@@ -7148,12 +7149,12 @@ async function compile(bytes2) {
   }
   return module;
 }
-async function digest(bytes2) {
-  const hash = await crypto.subtle.digest("SHA-256", sliceForWasm(bytes2));
+async function digest(bytes3) {
+  const hash = await crypto.subtle.digest("SHA-256", sliceForWasm(bytes3));
   return Array.from(new Uint8Array(hash, 0, 16), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-function sliceForWasm(bytes2) {
-  return bytes2.buffer.slice(bytes2.byteOffset, bytes2.byteOffset + bytes2.byteLength);
+function sliceForWasm(bytes3) {
+  return bytes3.buffer.slice(bytes3.byteOffset, bytes3.byteOffset + bytes3.byteLength);
 }
 async function primeStdin(ctx) {
   let pending = new Uint8Array(0);
@@ -7185,19 +7186,19 @@ function describeStartupFailure(error) {
 }
 
 // src/compat/execution.ts
-function binaryDigest(bytes2) {
-  return Array.from(sha256(bytes2), (b) => b.toString(16).padStart(2, "0")).join("");
+function binaryDigest(bytes3) {
+  return Array.from(sha256(bytes3), (b) => b.toString(16).padStart(2, "0")).join("");
 }
-function isElfBinary(bytes2) {
-  return bytes2[0] === 127 && bytes2[1] === 69 && bytes2[2] === 76 && bytes2[3] === 70;
+function isElfBinary(bytes3) {
+  return bytes3[0] === 127 && bytes3[1] === 69 && bytes3[2] === 76 && bytes3[3] === 70;
 }
-function inspectElf(bytes2) {
-  if (!isElfBinary(bytes2) || ![1, 2].includes(bytes2[4]) || ![1, 2].includes(bytes2[5]) || bytes2[6] !== 1 || bytes2.length < (bytes2[4] === 2 ? 64 : 52)) throw new Error("invalid or truncated ELF header");
-  const littleEndian = bytes2[5] === 1;
-  const machine = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength).getUint16(18, littleEndian);
+function inspectElf(bytes3) {
+  if (!isElfBinary(bytes3) || ![1, 2].includes(bytes3[4]) || ![1, 2].includes(bytes3[5]) || bytes3[6] !== 1 || bytes3.length < (bytes3[4] === 2 ? 64 : 52)) throw new Error("invalid or truncated ELF header");
+  const littleEndian = bytes3[5] === 1;
+  const machine = new DataView(bytes3.buffer, bytes3.byteOffset, bytes3.byteLength).getUint16(18, littleEndian);
   return {
     format: "elf",
-    bits: bytes2[4] === 2 ? 64 : 32,
+    bits: bytes3[4] === 2 ? 64 : 32,
     machine,
     littleEndian,
     architecture: { 3: "x86", 62: "x86_64", 40: "arm", 183: "aarch64", 243: "riscv" }[machine] ?? `machine-${machine}`
@@ -7224,14 +7225,14 @@ var BinaryExecutionRegistry = class {
     return this.backends.map(({ id, tier }) => ({ id, tier }));
   }
   async run(ctx, path) {
-    const bytes2 = ctx.vfs.readFile(path, ctx.cred);
+    const bytes3 = ctx.vfs.readFile(path, ctx.cred);
     let info2;
     try {
-      info2 = inspectElf(bytes2);
+      info2 = inspectElf(bytes3);
     } catch (error) {
       return ctx.fail(String(error), 126);
     }
-    const request = { path, bytes: bytes2, info: info2, sha256: binaryDigest(bytes2) };
+    const request = { path, bytes: bytes3, info: info2, sha256: binaryDigest(bytes3) };
     const reasons = [];
     const backends = [...this.backends];
     for (const tier of ["compatibility", "translation", "emulation"]) {
@@ -7254,10 +7255,10 @@ var BinaryExecutionRegistry = class {
   }
 };
 function checkedWasm(artifact) {
-  const bytes2 = artifact.bytes.slice();
-  if (!/^[a-f0-9]{64}$/i.test(artifact.sha256) || binaryDigest(bytes2) !== artifact.sha256.toLowerCase()) throw new Error("Wasm artifact integrity mismatch");
-  if (!WebAssembly.validate(bytes2)) throw new Error("invalid WebAssembly artifact");
-  return bytes2;
+  const bytes3 = artifact.bytes.slice();
+  if (!/^[a-f0-9]{64}$/i.test(artifact.sha256) || binaryDigest(bytes3) !== artifact.sha256.toLowerCase()) throw new Error("Wasm artifact integrity mismatch");
+  if (!WebAssembly.validate(bytes3)) throw new Error("invalid WebAssembly artifact");
+  return bytes3;
 }
 function installWasmCommands(kernel, artifacts) {
   const names = /* @__PURE__ */ new Set();
@@ -7266,7 +7267,7 @@ function installWasmCommands(kernel, artifacts) {
     names.add(artifact.name);
     return { name: artifact.name, bytes: checkedWasm(artifact) };
   });
-  for (const { name, bytes: bytes2 } of checked) kernel.installCommand({ name, run: (ctx) => runWasi(ctx, bytes2) });
+  for (const { name, bytes: bytes3 } of checked) kernel.installCommand({ name, run: (ctx) => runWasi(ctx, bytes3) });
 }
 function createWasmCompatibilityBackend(id, entries) {
   const ports = new Map(entries.map((entry) => {
@@ -7274,8 +7275,8 @@ function createWasmCompatibilityBackend(id, entries) {
     return [entry.elfSha256.toLowerCase(), checkedWasm(entry.wasm)];
   }));
   return { id, tier: "compatibility", prepare(request) {
-    const bytes2 = ports.get(request.sha256);
-    return bytes2 ? { supported: true, program: { run: (ctx) => runWasi(ctx, bytes2, { argv: [request.path, ...ctx.args] }) } } : { supported: false, reason: "no port for this binary digest" };
+    const bytes3 = ports.get(request.sha256);
+    return bytes3 ? { supported: true, program: { run: (ctx) => runWasi(ctx, bytes3, { argv: [request.path, ...ctx.args] }) } } : { supported: false, reason: "no port for this binary digest" };
   } };
 }
 function createTranslationBackend(translator, maxCacheBytes = 32 * 1024 * 1024) {
@@ -7284,32 +7285,32 @@ function createTranslationBackend(translator, maxCacheBytes = 32 * 1024 * 1024)
   let size = 0;
   return { id: translator.id, tier: "translation", async prepare(request, signal) {
     if (!translator.supports(request.info)) return { supported: false, reason: "unsupported ELF architecture" };
-    let bytes2 = cache.get(request.sha256);
-    if (bytes2) {
+    let bytes3 = cache.get(request.sha256);
+    if (bytes3) {
       cache.delete(request.sha256);
-      cache.set(request.sha256, bytes2);
+      cache.set(request.sha256, bytes3);
     } else {
       const output = await translator.translate(request, signal);
       if (signal.aborted) return { supported: false, reason: "cancelled" };
       if (!output) return { supported: false, reason: "translator declined this program" };
-      bytes2 = output.slice();
-      if (!WebAssembly.validate(bytes2.slice())) throw new Error(`${translator.id}: invalid translator output`);
-      if (bytes2.byteLength <= maxCacheBytes) {
+      bytes3 = output.slice();
+      if (!WebAssembly.validate(bytes3.slice())) throw new Error(`${translator.id}: invalid translator output`);
+      if (bytes3.byteLength <= maxCacheBytes) {
         const previous = cache.get(request.sha256);
         if (previous) {
           size -= previous.byteLength;
           cache.delete(request.sha256);
         }
-        while (size + bytes2.byteLength > maxCacheBytes && cache.size) {
+        while (size + bytes3.byteLength > maxCacheBytes && cache.size) {
           const key = cache.keys().next().value;
           size -= cache.get(key).byteLength;
           cache.delete(key);
         }
-        cache.set(request.sha256, bytes2);
-        size += bytes2.byteLength;
+        cache.set(request.sha256, bytes3);
+        size += bytes3.byteLength;
       }
     }
-    const artifact = bytes2;
+    const artifact = bytes3;
     return { supported: true, program: { run: (ctx) => runWasi(ctx, artifact, { argv: [request.path, ...ctx.args] }) } };
   } };
 }
@@ -8358,18 +8359,18 @@ function createSysProvider(kernel) {
 }
 
 // src/net/proxy-fetch.ts
-function toBase64(bytes2) {
+function toBase64(bytes3) {
   let text2 = "";
-  for (let at = 0; at < bytes2.length; at += 32768) {
-    text2 += String.fromCharCode(...bytes2.subarray(at, at + 32768));
+  for (let at = 0; at < bytes3.length; at += 32768) {
+    text2 += String.fromCharCode(...bytes3.subarray(at, at + 32768));
   }
   return btoa(text2);
 }
 function fromBase64(text2) {
   const binary = atob(text2);
-  const bytes2 = new Uint8Array(binary.length);
-  for (let at = 0; at < binary.length; at += 1) bytes2[at] = binary.charCodeAt(at);
-  return bytes2;
+  const bytes3 = new Uint8Array(binary.length);
+  for (let at = 0; at < binary.length; at += 1) bytes3[at] = binary.charCodeAt(at);
+  return bytes3;
 }
 async function proxyExchange(proxy, request, fetchImpl = fetch) {
   let answer;
@@ -8456,6 +8457,93 @@ async function discoverEgress(fetchImpl = fetch) {
   return await found;
 }
 
+// src/net/secrets.ts
+var PLACEHOLDER = /\{\{secret:([A-Za-z_][A-Za-z0-9_]*)\}\}/g;
+var REDACTED = "[sealed]";
+var SecretRefused = class extends Error {
+  code = "EACCES";
+};
+function hostBound(secret, hostname) {
+  return secret.hosts.some((host2) => hostname === host2 || hostname.endsWith(`.${host2}`));
+}
+function mentionsSecret(text2) {
+  PLACEHOLDER.lastIndex = 0;
+  return PLACEHOLDER.test(text2);
+}
+function substituteSecrets(text2, hostname, secrets) {
+  return text2.replace(PLACEHOLDER, (_match, name) => {
+    const secret = Object.prototype.hasOwnProperty.call(secrets, name) ? secrets[name] : void 0;
+    if (!secret) {
+      throw new SecretRefused(`no sealed secret named ${name} is configured for this container`);
+    }
+    if (!hostBound(secret, hostname)) {
+      throw new SecretRefused(
+        `the sealed secret ${name} is not bound to ${hostname}; it may only be sent to ${secret.hosts.join(", ") || "no host"}`
+      );
+    }
+    return secret.value;
+  });
+}
+function sealRequest(request, secrets) {
+  const url = new URL(request.url);
+  if (mentionsSecret(decodeURIComponent(url.href))) {
+    throw new SecretRefused("a sealed secret can only be used in a request header, not in the URL");
+  }
+  const used = [];
+  let headers = null;
+  request.headers.forEach((value, name) => {
+    if (!mentionsSecret(value)) return;
+    headers ??= new Headers(request.headers);
+    headers.set(name, substituteSecrets(value, url.hostname, secrets));
+    PLACEHOLDER.lastIndex = 0;
+    for (const match2 of value.matchAll(PLACEHOLDER)) used.push(match2[1]);
+  });
+  return headers ? { request: new Request(request, { headers }), used } : { request, used };
+}
+function redactResponse(response, secrets) {
+  const values = Object.values(secrets).map((secret) => secret.value).filter((value) => value.length > 0);
+  if (values.length === 0) return response;
+  const headers = new Headers();
+  response.headers.forEach((value, name) => headers.set(name, redactText(value, values)));
+  const init = { status: response.status, statusText: response.statusText, headers };
+  if (!response.body) return new Response(null, init);
+  headers.delete("content-length");
+  return new Response(response.body.pipeThrough(redactingStream(values)), init);
+}
+function redactText(text2, values) {
+  let out = text2;
+  for (const value of values) out = out.split(value).join(REDACTED);
+  return out;
+}
+function redactingStream(values) {
+  const needles = values.map((value) => latin1(new TextEncoder().encode(value)));
+  const hold = Math.max(...needles.map((needle) => needle.length)) - 1;
+  let pending = "";
+  return new TransformStream({
+    transform(chunk, controller) {
+      pending = redactText(pending + latin1(chunk), needles);
+      if (pending.length <= hold) return;
+      controller.enqueue(bytes(pending.slice(0, pending.length - hold)));
+      pending = pending.slice(pending.length - hold);
+    },
+    flush(controller) {
+      if (pending) controller.enqueue(bytes(redactText(pending, needles)));
+    }
+  });
+}
+function latin1(chunk) {
+  let out = "";
+  for (let at = 0; at < chunk.length; at += 32768) {
+    out += String.fromCharCode(...chunk.subarray(at, at + 32768));
+  }
+  return out;
+}
+function bytes(text2) {
+  const out = new Uint8Array(text2.length);
+  for (let index = 0; index < text2.length; index += 1) out[index] = text2.charCodeAt(index);
+  return out;
+}
+
 // src/net/policy.ts
 function isLoopbackHostname(hostname) {
   const host2 = hostname.replace(/^\[|\]$/g, "").toLowerCase();
@@ -8493,6 +8581,24 @@ function requestUrl(input) {
   return input.url;
 }
 function policedFetch(policy, fetchImpl) {
+  const secrets = policy.secrets && Object.keys(policy.secrets).length > 0 ? policy.secrets : null;
+  if (!secrets) return policedPlainFetch(policy, fetchImpl);
+  const plain = policedPlainFetch(policy, fetchImpl);
+  return (async (input, init) => {
+    const url = requestUrl(input);
+    if (!outboundAllowed(policy, url)) {
+      throw Object.assign(new TypeError("fetch failed"), { cause: outboundBlockedError(url) });
+    }
+    let sealed;
+    try {
+      sealed = sealRequest(new Request(input, init), secrets).request;
+    } catch (error) {
+      throw Object.assign(new TypeError("fetch failed"), { cause: error });
+    }
+    return redactResponse(await plain(sealed), secrets);
+  });
+}
+function policedPlainFetch(policy, fetchImpl) {
   return (async (input, init) => {
     const url = requestUrl(input);
     if (!outboundAllowed(policy, url)) {
@@ -8729,22 +8835,22 @@ var NetworkStack = class {
 `;
     return out;
   }
-  countTx(bytes2, iface = "eth0") {
+  countTx(bytes3, iface = "eth0") {
     const i = this.interface(iface);
     if (!i) return;
-    i.txBytes += bytes2;
-    i.txPackets += Math.max(1, Math.ceil(bytes2 / 1400));
+    i.txBytes += bytes3;
+    i.txPackets += Math.max(1, Math.ceil(bytes3 / 1400));
   }
-  countRx(bytes2, iface = "eth0") {
+  countRx(bytes3, iface = "eth0") {
     const i = this.interface(iface);
     if (!i) return;
-    i.rxBytes += bytes2;
-    i.rxPackets += Math.max(1, Math.ceil(bytes2 / 1400));
+    i.rxBytes += bytes3;
+    i.rxPackets += Math.max(1, Math.ceil(bytes3 / 1400));
   }
 };
 function randomMac() {
-  const bytes2 = [2, 66, 172, 17, 0, 2];
-  return bytes2.map((b) => b.toString(16).padStart(2, "0")).join(":");
+  const bytes3 = [2, 66, 172, 17, 0, 2];
+  return bytes3.map((b) => b.toString(16).padStart(2, "0")).join(":");
 }
 function hexIp(ip2) {
   return ip2.split(".").reverse().map((o) => Number(o).toString(16).padStart(2, "0").toUpperCase()).join("");
@@ -9189,15 +9295,15 @@ var Parser = class {
         if (this.isWord("-p")) this.next();
       }
     }
-    const commands12 = [this.parseCommand()];
+    const commands13 = [this.parseCommand()];
     const stderrToo = [];
     while (this.isOp("|") || this.isOp("|&")) {
       stderrToo.push(this.next().value === "|&");
       this.skipNewlines();
-      commands12.push(this.parseCommand());
+      commands13.push(this.parseCommand());
     }
-    if (commands12.length === 1 && !negated && !timed) return commands12[0];
-    return { type: "pipeline", commands: commands12, negated, stderrToo, timed };
+    if (commands13.length === 1 && !negated && !timed) return commands13[0];
+    return { type: "pipeline", commands: commands13, negated, stderrToo, timed };
   }
   // ── commands ─────────────────────────────────────────────────────────────
   parseCommand() {
@@ -10817,8 +10923,8 @@ var decoder4 = new TextDecoder();
 async function readInputs(ctx, operands, opts = {}) {
   const stdinName = opts.stdinName ?? "-";
   if (operands.length === 0) {
-    const bytes2 = await ctx.stdin.readAll();
-    return { sources: [{ name: stdinName, bytes: bytes2 }], ok: true };
+    const bytes3 = await ctx.stdin.readAll();
+    return { sources: [{ name: stdinName, bytes: bytes3 }], ok: true };
   }
   const sources = [];
   let ok2 = true;
@@ -10843,8 +10949,8 @@ async function readInputs(ctx, operands, opts = {}) {
   }
   return { sources, ok: ok2 };
 }
-function splitLines(bytes2) {
-  const text2 = decoder4.decode(bytes2);
+function splitLines(bytes3) {
+  const text2 = decoder4.decode(bytes3);
   if (text2 === "") return { lines: [], trailingNewline: true };
   const trailingNewline = text2.endsWith("\n");
   const body = trailingNewline ? text2.slice(0, -1) : text2;
@@ -10856,11 +10962,11 @@ function joinLines(lines, trailingNewline = true) {
 }
 var SI_UNITS = ["", "k", "M", "G", "T", "P", "E"];
 var IEC_UNITS = ["", "K", "M", "G", "T", "P", "E"];
-function humanSize(bytes2, opts = {}) {
+function humanSize(bytes3, opts = {}) {
   const base2 = opts.si ? 1e3 : 1024;
   const units = opts.si ? SI_UNITS : IEC_UNITS;
-  if (bytes2 < base2) return String(bytes2);
-  let value = bytes2;
+  if (bytes3 < base2) return String(bytes3);
+  let value = bytes3;
   let unit = 0;
   while (value >= base2 && unit < units.length - 1) {
     value /= base2;
@@ -11150,7 +11256,7 @@ var cat = defineCommand({
     let lineNumber = 1;
     let lastWasBlank = false;
     for (const operand of operands) {
-      let bytes2;
+      let bytes3;
       if (operand === "-") {
         if (plain) {
           for (; ; ) {
@@ -11161,7 +11267,7 @@ var cat = defineCommand({
           }
           continue;
         }
-        bytes2 = await ctx.stdin.readAll();
+        bytes3 = await ctx.stdin.readAll();
       } else {
         try {
           const abs = ctx.path(operand);
@@ -11171,17 +11277,17 @@ var cat = defineCommand({
             status = 1;
             continue;
           }
-          bytes2 = ctx.vfs.readFile(abs, ctx.cred);
+          bytes3 = ctx.vfs.readFile(abs, ctx.cred);
         } catch (e) {
           status = ctx.reportError(e, operand);
           continue;
         }
       }
       if (plain) {
-        ctx.write(bytes2);
+        ctx.write(bytes3);
         continue;
       }
-      const text2 = new TextDecoder().decode(bytes2);
+      const text2 = new TextDecoder().decode(bytes3);
       const hadTrailing = text2.endsWith("\n");
       const parts = (hadTrailing ? text2.slice(0, -1) : text2).split("\n");
       for (const raw of parts) {
@@ -12035,15 +12141,15 @@ function describeFile(ctx, abs, st, mime) {
   }
   if (st.isCharacterDevice()) return mime ? "inode/chardevice" : "character special";
   if (st.size === 0) return mime ? "inode/x-empty" : "empty";
-  const bytes2 = ctx.vfs.readFile(abs, ctx.cred).subarray(0, 512);
-  const magic = [...bytes2.subarray(0, 4)];
+  const bytes3 = ctx.vfs.readFile(abs, ctx.cred).subarray(0, 512);
+  const magic = [...bytes3.subarray(0, 4)];
   if (magic[0] === 127 && magic[1] === 69 && magic[2] === 76 && magic[3] === 70) {
     return mime ? "application/x-executable" : "ELF 64-bit LSB executable, x86-64";
   }
   if (magic[0] === 31 && magic[1] === 139) return mime ? "application/gzip" : "gzip compressed data";
   if (magic[0] === 80 && magic[1] === 75) return mime ? "application/zip" : "Zip archive data";
   if (magic[0] === 137 && magic[1] === 80) return mime ? "image/png" : "PNG image data";
-  const text2 = new TextDecoder().decode(bytes2);
+  const text2 = new TextDecoder().decode(bytes3);
   const printable = [...text2].every((c) => c === "\n" || c === "	" || c === "\r" || c >= " " && c <= "~" || c.charCodeAt(0) > 127);
   if (!printable) return mime ? "application/octet-stream" : "data";
   if (text2.startsWith("#!")) {
@@ -12946,6 +13052,523 @@ var commands3 = [
   clear,
   sync
 ];
+var platformBuffer = globalThis.Buffer;
+addUint8ArraySupport(addBase64UrlSupport(Buffer$1));
+var Buffer2 = platformBuffer ?? Buffer$1;
+function addUint8ArraySupport(BufferClass) {
+  const target = BufferClass;
+  if (target.__sandboxedUint8Array) return BufferClass;
+  Object.defineProperty(target, "__sandboxedUint8Array", { value: true });
+  const asBuffer = (value) => value instanceof Uint8Array && !target.isBuffer(value) ? target.from(value.buffer, value.byteOffset, value.byteLength) : value;
+  for (const method of ["indexOf", "lastIndexOf", "includes"]) {
+    const original = target.prototype[method];
+    target.prototype[method] = function(value, ...rest) {
+      return original.call(this, asBuffer(value), ...rest);
+    };
+  }
+  const equals = target.prototype.equals;
+  target.prototype.equals = function(other) {
+    return equals.call(this, asBuffer(other));
+  };
+  return BufferClass;
+}
+function addBase64UrlSupport(BufferClass) {
+  const target = BufferClass;
+  if (target.__sandboxedBase64Url) return BufferClass;
+  Object.defineProperty(target, "__sandboxedBase64Url", { value: true });
+  const from = target.from.bind(target);
+  target.from = (value, encodingOrOffset, length) => from(value, normalizeEncoding(encodingOrOffset), length);
+  const byteLength = target.byteLength.bind(target);
+  target.byteLength = (value, encoding) => byteLength(value, normalizeEncoding(encoding));
+  const isEncoding = target.isEncoding?.bind(target);
+  if (isEncoding) target.isEncoding = (encoding) => encoding.toLowerCase() === "base64url" || isEncoding(encoding);
+  const toString = target.prototype.toString;
+  target.prototype.toString = function(encoding, start2, end) {
+    if (encoding?.toLowerCase() !== "base64url") return toString.call(this, encoding, start2, end);
+    return toString.call(this, "base64", start2, end).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  };
+  const write = target.prototype.write;
+  target.prototype.write = function(...args) {
+    const index = typeof args[1] === "string" ? 1 : typeof args[2] === "string" ? 2 : 3;
+    if (typeof args[index] === "string") args[index] = normalizeEncoding(args[index]);
+    return write.apply(this, args);
+  };
+  return BufferClass;
+}
+function normalizeEncoding(value) {
+  return typeof value === "string" && value.toLowerCase() === "base64url" ? "base64" : value;
+}
+
+// src/pkg/clean-installer.ts
+init_path();
+
+// src/browser/playwright-browsers.ts
+init_path();
+var PLAYWRIGHT_REGISTRY = "/root/.cache/ms-playwright";
+var LAYOUTS = {
+  "chromium": ["chrome-linux64", "chrome"],
+  "chromium-headless-shell": ["chrome-headless-shell-linux64", "chrome-headless-shell"]
+};
+function virtualBrowserFiles(browsersJson) {
+  let manifest;
+  try {
+    manifest = JSON.parse(browsersJson);
+  } catch {
+    return [];
+  }
+  const encoder9 = new TextEncoder();
+  const files = [];
+  for (const browser of manifest.browsers ?? []) {
+    const layout = LAYOUTS[browser.name];
+    if (!layout) continue;
+    const dir3 = join(PLAYWRIGHT_REGISTRY, `${browser.name.replace(/-/g, "_")}-${browser.revision}`);
+    files.push({ path: join(dir3, ...layout), data: encoder9.encode(`#!${BUILTIN_INTERPRETER} chrome
+`), mode: 493 });
+    files.push({ path: join(dir3, "INSTALLATION_COMPLETE"), data: new Uint8Array() });
+  }
+  return files;
+}
+function mkdirp(volume, path) {
+  let current2 = "";
+  for (const part of segments(path)) {
+    current2 += `/${part}`;
+    try {
+      volume.mkdirSync(current2, { mode: 493 });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+  }
+}
+function installVirtualPlaywrightBrowsers(volume, packageDir) {
+  let text2;
+  try {
+    text2 = new TextDecoder().decode(volume.readFileSync(join(packageDir, "browsers.json")));
+  } catch {
+    return [];
+  }
+  const written = [];
+  for (const file3 of virtualBrowserFiles(text2)) {
+    mkdirp(volume, dirname(file3.path));
+    volume.writeFileSync(file3.path, file3.data);
+    if (file3.mode !== void 0) {
+      volume.chmodSync(file3.path, file3.mode);
+      written.push(file3.path);
+    }
+  }
+  return written;
+}
+
+// src/pkg/clean-installer.ts
+var RUNTIME_PACKAGE_FALLBACKS = {
+  esbuild: "esbuild-wasm",
+  rollup: "@rollup/wasm-node"
+};
+var CleanPackageInstaller = class _CleanPackageInstaller {
+  constructor(volume, options = {}) {
+    this.volume = volume;
+    this.options = options;
+    this.registry = (options.registry ?? "https://registry.npmjs.org").replace(/\/$/, "");
+    this.fetcher = options.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  volume;
+  options;
+  registry;
+  fetcher;
+  metadata = /* @__PURE__ */ new Map();
+  tarballs = /* @__PURE__ */ new Map();
+  /** Single-version manifests, for the fields the packument omits. */
+  details = /* @__PURE__ */ new Map();
+  forCwd(cwd) {
+    const installer = new _CleanPackageInstaller(this.volume, { ...this.options, cwd });
+    installer.metadata = this.metadata;
+    installer.tarballs = this.tarballs;
+    installer.details = this.details;
+    return installer;
+  }
+  async install(name, version = "latest", options = {}) {
+    const cwd = this.options.cwd ?? "/";
+    const manifest = await this.installAt(name, version || "latest", join(cwd, "node_modules"), options, /* @__PURE__ */ new Set());
+    if (options.persist !== false) this.persist(cwd, name, version, options.persistDev === true);
+    return manifest;
+  }
+  async installFromManifest(path, options = {}) {
+    const project = this.readJson(path);
+    const cwd = dirname(path);
+    const dependencies = {
+      ...project.dependencies ?? {},
+      ...options.withDevDeps === false ? {} : project.devDependencies ?? {}
+    };
+    await this.prefetch(dependencies);
+    for (const [name, range] of Object.entries(dependencies)) {
+      await this.installAt(name, range, join(cwd, "node_modules"), options, /* @__PURE__ */ new Set());
+    }
+  }
+  async installAt(name, range, modulesRoot, options, ancestry) {
+    const metadata = await this.getMetadata(name);
+    const version = resolveVersion(metadata, range);
+    const manifest = metadata.versions[version];
+    if (!manifest) throw new Error(`No matching version found for ${name}@${range}`);
+    const identity = `${name}@${version}`;
+    if (!supportsPlatform(manifest)) throw new IncompatiblePlatform(identity, "");
+    if (manifest.os?.length || manifest.cpu?.length) {
+      const detail = await this.platformDetail(name, version);
+      if (!platformListAllows(detail.libc, PLATFORM.libc)) {
+        throw new IncompatiblePlatform(identity, ` (needs ${detail.libc?.join(", ")})`);
+      }
+      if (detail.main?.endsWith(".node")) {
+        throw new IncompatiblePlatform(identity, " (native addon; this runtime cannot dlopen)");
+      }
+    }
+    const target = join(modulesRoot, name);
+    const installed3 = this.tryReadJson(join(target, "package.json"));
+    if (ancestry.has(identity)) return manifest;
+    if (installed3?.version !== version) {
+      options.onProgress?.(`Fetching ${identity}`);
+      const archive = await this.getTarball(manifest.dist.tarball);
+      verifyIntegrity(archive, manifest.dist.integrity, manifest.dist.shasum, identity);
+      this.removeIfPresent(target);
+      mkdirp2(this.volume, target);
+      extractNpmTarball(this.volume, archive, target);
+      options.onProgress?.(`Installed ${identity}`);
+    }
+    this.createBinLinks(manifest, target, modulesRoot);
+    if (name === "playwright-core") {
+      for (const executable of installVirtualPlaywrightBrowsers(this.volume, target)) {
+        options.onProgress?.(`Linked ${executable} to the virtual browser`);
+      }
+    }
+    const nextAncestry = new Set(ancestry).add(identity);
+    const fallback = RUNTIME_PACKAGE_FALLBACKS[name];
+    if (fallback && fallback !== name) {
+      await this.installAt(fallback, version, modulesRoot, options, nextAncestry);
+    }
+    const childRoot = join(target, "node_modules");
+    const required = Object.fromEntries(Object.entries(manifest.dependencies ?? {}).filter(([name2]) => !(name2 in (manifest.optionalDependencies ?? {}))));
+    await this.prefetch(required);
+    for (const [dependency, dependencyRange] of Object.entries(required)) {
+      await this.installAt(dependency, dependencyRange, childRoot, options, nextAncestry);
+    }
+    for (const [dependency, dependencyRange] of Object.entries(manifest.optionalDependencies ?? {})) {
+      try {
+        await this.installAt(dependency, dependencyRange, childRoot, options, nextAncestry);
+      } catch (error) {
+        if (error instanceof IncompatiblePlatform) continue;
+        options.onProgress?.(`Skipped optional ${dependency}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    return manifest;
+  }
+  /**
+   * The `libc` and `main` fields, which the abbreviated packument leaves out.
+   *
+   * Fetched per version rather than as a full packument: the single-version
+   * document is a few kilobytes, while the full one for a popular package runs
+   * to megabytes. Only packages that already declare `os` or `cpu` ask for it,
+   * so an ordinary install of pure-JavaScript dependencies makes no extra
+   * requests at all — it is the prebuilt binaries, a handful per project, that
+   * need the answer.
+   *
+   * A failure here is not fatal. Being unable to read `libc` puts the check
+   * back where it was before this existed, which is worth strictly less than
+   * being right and strictly more than refusing to install.
+   */
+  async platformDetail(name, version) {
+    const key = `${name}@${version}`;
+    let request = this.details.get(key);
+    if (!request) {
+      request = (async () => {
+        try {
+          const encoded = name.startsWith("@") ? name.replace("/", "%2F") : encodeURIComponent(name);
+          const response = await this.fetcher(`${this.registry}/${encoded}/${version}`);
+          if (!response.ok) return {};
+          return await response.json();
+        } catch {
+          return {};
+        }
+      })();
+      this.details.set(key, request);
+    }
+    return request;
+  }
+  /** Overlap up to six sibling downloads; filesystem writes remain ordered. */
+  async prefetch(dependencies) {
+    const entries = Object.entries(dependencies);
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(6, entries.length) }, async () => {
+      while (next < entries.length) {
+        const [name, range] = entries[next++];
+        try {
+          const metadata = await this.getMetadata(name);
+          const manifest = metadata.versions[resolveVersion(metadata, range)];
+          if (!manifest.os?.length && !manifest.cpu?.length && supportsPlatform(manifest)) {
+            await this.getTarball(manifest.dist.tarball);
+          }
+        } catch {
+        }
+      }
+    }));
+  }
+  async getMetadata(name) {
+    let request = this.metadata.get(name);
+    if (!request) {
+      request = (async () => {
+        const encoded = name.startsWith("@") ? name.replace("/", "%2F") : encodeURIComponent(name);
+        const response = await this.fetcher(`${this.registry}/${encoded}`, {
+          headers: { Accept: "application/vnd.npm.install-v1+json" }
+        });
+        if (!response.ok) throw new Error(`registry returned ${response.status} for ${name}`);
+        return await response.json();
+      })();
+      this.metadata.set(name, request);
+      void request.catch(() => {
+        this.metadata.delete(name);
+      });
+    }
+    return request;
+  }
+  async getTarball(url) {
+    let request = this.tarballs.get(url);
+    if (!request) {
+      request = (async () => {
+        const response = await this.fetcher(url);
+        if (!response.ok) throw new Error(`tarball returned ${response.status}: ${url}`);
+        return new Uint8Array(await response.arrayBuffer());
+      })();
+      this.tarballs.set(url, request);
+      void request.catch(() => {
+        this.tarballs.delete(url);
+      });
+    }
+    return request;
+  }
+  createBinLinks(manifest, target, modulesRoot) {
+    if (!manifest.bin) return;
+    const bins = typeof manifest.bin === "string" ? { [unscoped(manifest.name)]: manifest.bin } : manifest.bin;
+    const binDir = join(modulesRoot, ".bin");
+    mkdirp2(this.volume, binDir);
+    for (const [name, path] of Object.entries(bins)) {
+      const link = join(binDir, name);
+      this.removeIfPresent(link);
+      this.volume.symlinkSync(relative(binDir, join(target, path)), link);
+    }
+  }
+  persist(cwd, name, range, dev) {
+    const path = join(cwd, "package.json");
+    const manifest = this.tryReadJson(path) ?? {};
+    const key = dev ? "devDependencies" : "dependencies";
+    manifest[key] = { ...manifest[key] ?? {}, [name]: range === "latest" ? "*" : range };
+    this.volume.writeFileSync(path, JSON.stringify(manifest, null, 2) + "\n");
+  }
+  removeIfPresent(path) {
+    let stat2;
+    try {
+      stat2 = this.volume.lstatSync(path);
+    } catch {
+      return;
+    }
+    if (!stat2.isDirectory()) return this.volume.unlinkSync(path);
+    for (const name of this.volume.readdirSync(path)) this.removeIfPresent(join(path, name));
+    this.volume.rmdirSync(path);
+  }
+  readJson(path) {
+    return JSON.parse(new TextDecoder().decode(this.volume.readFileSync(path)));
+  }
+  tryReadJson(path) {
+    try {
+      return this.readJson(path);
+    } catch {
+      return null;
+    }
+  }
+};
+var PLATFORM = { os: "linux", cpu: "x64", libc: "glibc" };
+var IncompatiblePlatform = class extends Error {
+  constructor(identity, detail) {
+    super(`${identity} is not compatible with ${PLATFORM.os}/${PLATFORM.cpu}/${PLATFORM.libc}${detail}`);
+    this.name = "IncompatiblePlatform";
+  }
+};
+function supportsPlatform(manifest) {
+  return platformListAllows(manifest.os, PLATFORM.os) && platformListAllows(manifest.cpu, PLATFORM.cpu) && platformListAllows(manifest.libc, PLATFORM.libc);
+}
+function platformListAllows(values, current2) {
+  if (!values?.length) return true;
+  if (values.includes(`!${current2}`)) return false;
+  const positive = values.filter((value) => !value.startsWith("!"));
+  return positive.length === 0 || positive.includes(current2) || positive.includes("any");
+}
+function resolveVersion(metadata, range) {
+  const tag2 = metadata["dist-tags"]?.[range];
+  if (tag2) return tag2;
+  if (valid(range) && metadata.versions[range]) return range;
+  const found2 = maxSatisfying(Object.keys(metadata.versions), range === "latest" ? "*" : range, { includePrerelease: false });
+  if (!found2) throw new Error(`No matching version found for ${metadata.name}@${range}`);
+  return found2;
+}
+function verifyIntegrity(data, integrity, shasum, identity) {
+  if (integrity) {
+    const choices = integrity.trim().split(/\s+/);
+    for (const choice of choices) {
+      const dash = choice.indexOf("-");
+      const algorithm = choice.slice(0, dash);
+      const expected = choice.slice(dash + 1).replace(/\?.*$/, "");
+      const digest2 = algorithm === "sha512" ? sha512(data) : algorithm === "sha256" ? sha256(data) : null;
+      if (digest2 && Buffer2.from(digest2).toString("base64") === expected) return;
+    }
+    throw new Error(`Integrity check failed for ${identity}`);
+  }
+  if (shasum && Buffer2.from(sha1(data)).toString("hex") === shasum) return;
+  if (shasum) throw new Error(`Legacy checksum check failed for ${identity}`);
+}
+function extractNpmTarball(volume, compressed, destination) {
+  const tar2 = ungzip(compressed);
+  let offset = 0;
+  let longPath = null;
+  let paxPath = null;
+  while (offset + 512 <= tar2.length) {
+    const header = tar2.subarray(offset, offset + 512);
+    if (header.every((byte) => byte === 0)) break;
+    const size = octal(header, 124, 12);
+    const type = String.fromCharCode(header[156] || 48);
+    const prefix = text(header, 345, 155);
+    let name = longPath ?? paxPath ?? [prefix, text(header, 0, 100)].filter(Boolean).join("/");
+    longPath = null;
+    paxPath = null;
+    const data = tar2.subarray(offset + 512, offset + 512 + size);
+    offset += 512 + Math.ceil(size / 512) * 512;
+    if (type === "L") {
+      longPath = new TextDecoder().decode(data).replace(/\0.*$/, "").trim();
+      continue;
+    }
+    if (type === "x" || type === "g") {
+      paxPath = parsePax(data).path ?? null;
+      continue;
+    }
+    name = stripPackageRoot(name);
+    if (!name) continue;
+    const target = safeTarget(destination, name);
+    const mode = octal(header, 100, 8) || 420;
+    if (type === "5") {
+      mkdirp2(volume, target, mode);
+    } else if (type === "2") {
+      mkdirp2(volume, dirname(target));
+      volume.symlinkSync(text(header, 157, 100), target);
+    } else if (type === "1") {
+      mkdirp2(volume, dirname(target));
+      volume.linkSync(safeTarget(destination, stripPackageRoot(text(header, 157, 100))), target);
+    } else if (type === "0" || type === "\0" || type === "7") {
+      mkdirp2(volume, dirname(target));
+      volume.writeFileSync(target, data.slice());
+      volume.chmodSync(target, mode);
+    }
+  }
+}
+function mkdirp2(volume, path, mode = 493) {
+  let current2 = "";
+  for (const part of segments(path)) {
+    current2 += `/${part}`;
+    try {
+      volume.mkdirSync(current2, { mode });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      if (!volume.lstatSync(current2).isDirectory()) throw error;
+    }
+  }
+}
+function safeTarget(destination, name) {
+  const clean2 = clean(`/${name}`).slice(1);
+  if (!clean2 || clean2 === ".." || clean2.startsWith("../") || name.startsWith("/")) throw new Error(`Unsafe path in package: ${name}`);
+  return join(destination, clean2);
+}
+function stripPackageRoot(name) {
+  const clean2 = name.replace(/^\.\//, "").replace(/\/$/, "");
+  const slash = clean2.indexOf("/");
+  return slash === -1 ? "" : clean2.slice(slash + 1);
+}
+function text(bytes3, start2, length) {
+  return new TextDecoder().decode(bytes3.subarray(start2, start2 + length)).replace(/\0.*$/, "").trim();
+}
+function octal(bytes3, start2, length) {
+  return parseInt(text(bytes3, start2, length).replace(/^0+/, "") || "0", 8);
+}
+function parsePax(data) {
+  const value = new TextDecoder().decode(data);
+  const result = {};
+  let offset = 0;
+  while (offset < value.length) {
+    const space = value.indexOf(" ", offset);
+    if (space < 0) break;
+    const length = Number(value.slice(offset, space));
+    if (!Number.isFinite(length) || length <= 0) break;
+    const record2 = value.slice(space + 1, offset + length - 1);
+    const equal2 = record2.indexOf("=");
+    if (equal2 > 0) result[record2.slice(0, equal2)] = record2.slice(equal2 + 1);
+    offset += length;
+  }
+  return result;
+}
+function unscoped(name) {
+  return name.startsWith("@") ? name.slice(name.indexOf("/") + 1) : name;
+}
+
+// src/bin/capabilities.ts
+function report(ctx) {
+  const commands13 = ctx.kernel.commands.names();
+  const has = (name) => commands13.includes(name);
+  return {
+    schemaVersion: 1,
+    runtime: "sandboxedjs",
+    platform: { os: "linux", arch: "x64", libc: "glibc" },
+    filesystem: { writable: true, root: "/", persistence: "container-lifetime", hostAccess: false },
+    shell: { posix: true, pipelines: true, redirection: true, backgroundProcesses: true },
+    languages: { node: has("node"), python: has("python3"), wasmWasi: has("wasi") },
+    packages: {
+      npm: has("npm"),
+      pip: has("pip"),
+      applicationRegistry: has("pm"),
+      nativeAddons: false,
+      fallbacks: RUNTIME_PACKAGE_FALLBACKS
+    },
+    network: {
+      virtualServers: true,
+      loopback: true,
+      outbound: ctx.kernel.net.policy.allowOutbound,
+      allowedHosts: ctx.kernel.net.policy.allowedHosts,
+      proxy: ctx.kernel.net.proxy !== null,
+      listeningPorts: ctx.kernel.net.listening().map(({ port, proto, program }) => ({ port, proto, program }))
+    },
+    interfaces: {
+      desktopGui: false,
+      hostFilesystem: false,
+      systemPackageManager: false,
+      docker: false
+    },
+    commands: commands13
+  };
+}
+var sandboxedjsCapabilities = defineCommand({
+  name: "sandboxedjs-capabilities",
+  aliases: ["sbx-capabilities"],
+  path: "/usr/bin/sandboxedjs-capabilities",
+  summary: "report the runtime capabilities available to tools and agents",
+  usage: "sandboxedjs-capabilities [--json]",
+  run(ctx) {
+    const result = report(ctx);
+    if (ctx.args.includes("--json")) {
+      ctx.line(JSON.stringify(result, null, 2));
+      return 0;
+    }
+    ctx.line("SandboxedJS runtime capabilities");
+    ctx.line(`  commands: ${result.commands.length}`);
+    ctx.line(`  languages: ${Object.entries(result.languages).filter(([, enabled]) => enabled).map(([name]) => name).join(", ")}`);
+    ctx.line(`  outbound network: ${result.network.outbound ? "enabled" : "disabled"}`);
+    ctx.line(`  writable filesystem: ${result.filesystem.root} (${result.filesystem.persistence})`);
+    ctx.line(`  package fallbacks: ${Object.entries(result.packages.fallbacks).map(([from, to]) => `${from} -> ${to}`).join(", ") || "none"}`);
+    ctx.line("Run with --json for the complete machine-readable inventory.");
+    return 0;
+  }
+});
+var commands4 = [sandboxedjsCapabilities];
 
 // src/bin/sed.ts
 var SedParseError = class extends Error {
@@ -15388,8 +16011,8 @@ async function runAwk(ctx) {
           continue;
         }
         try {
-          const bytes2 = ctx.vfs.readFile(ctx.path(operand), ctx.cred);
-          inputs.push({ name: operand, lines: splitLines(bytes2).lines });
+          const bytes3 = ctx.vfs.readFile(ctx.path(operand), ctx.cred);
+          inputs.push({ name: operand, lines: splitLines(bytes3).lines });
         } catch (e) {
           ctx.reportError(e, operand);
           return 2;
@@ -15532,12 +16155,12 @@ async function followFiles(ctx, paths, intervalMs) {
     if (ctx.signal.aborted) break;
     for (const path of paths) {
       try {
-        const bytes2 = ctx.vfs.readFile(ctx.path(path), ctx.cred);
+        const bytes3 = ctx.vfs.readFile(ctx.path(path), ctx.cred);
         const previous = offsets.get(path) ?? 0;
-        if (bytes2.length > previous) {
-          ctx.write(bytes2.subarray(previous));
-          offsets.set(path, bytes2.length);
-        } else if (bytes2.length < previous) {
+        if (bytes3.length > previous) {
+          ctx.write(bytes3.subarray(previous));
+          offsets.set(path, bytes3.length);
+        } else if (bytes3.length < previous) {
           offsets.set(path, 0);
         }
       } catch {
@@ -15920,14 +16543,14 @@ var tee = defineCommand({
       { short: "a", long: "append" },
       { short: "i", long: "ignore-interrupts" }
     ]);
-    const bytes2 = await ctx.stdin.readAll();
-    ctx.write(bytes2);
+    const bytes3 = await ctx.stdin.readAll();
+    ctx.write(bytes3);
     let status = 0;
     for (const target of args.positional) {
       try {
         const abs = ctx.path(target);
-        if (args.has("append")) ctx.vfs.appendFile(abs, bytes2, { cred: ctx.cred });
-        else ctx.vfs.writeFile(abs, bytes2, { cred: ctx.cred });
+        if (args.has("append")) ctx.vfs.appendFile(abs, bytes3, { cred: ctx.cred });
+        else ctx.vfs.writeFile(abs, bytes3, { cred: ctx.cred });
       } catch (e) {
         status = ctx.reportError(e, target);
       }
@@ -16240,16 +16863,16 @@ var split = defineCommand({
     const [input, prefixRaw] = args.positional;
     const prefix = prefixRaw ?? "x";
     const { sources, ok: ok2 } = await readInputs(ctx, input ? [input] : []);
-    const bytes2 = sources[0]?.bytes ?? new Uint8Array(0);
+    const bytes3 = sources[0]?.bytes ?? new Uint8Array(0);
     const suffixLength = args.num("suffix-length", 2);
     const chunks = [];
     const byteSpec = args.str("bytes");
     if (byteSpec !== void 0) {
       const size = parseSize(byteSpec) ?? 1024;
-      for (let i = 0; i < bytes2.length; i += size) chunks.push(bytes2.subarray(i, i + size));
+      for (let i = 0; i < bytes3.length; i += size) chunks.push(bytes3.subarray(i, i + size));
     } else {
       const perChunk = args.num("lines", 1e3);
-      const { lines } = splitLines(bytes2);
+      const { lines } = splitLines(bytes3);
       for (let i = 0; i < lines.length; i += perChunk) {
         chunks.push(new TextEncoder().encode(joinLines(lines.slice(i, i + perChunk), true)));
       }
@@ -16313,7 +16936,7 @@ var awk = defineCommand({
   usage: "awk [-F fs] [-v var=value] 'program' [FILE]...",
   run: runAwk
 });
-var commands4 = [
+var commands5 = [
   head,
   tail,
   wc,
@@ -16459,19 +17082,19 @@ var grep = defineCommand({
     let anyMatch = false;
     let status = 1;
     for (const target of targets) {
-      let bytes2;
+      let bytes3;
       if (target === "-") {
-        bytes2 = await ctx.stdin.readAll();
+        bytes3 = await ctx.stdin.readAll();
       } else {
         try {
-          bytes2 = ctx.vfs.readFile(ctx.path(target), ctx.cred);
+          bytes3 = ctx.vfs.readFile(ctx.path(target), ctx.cred);
         } catch (e) {
           if (!args.has("no-messages")) ctx.reportError(e, target);
           status = 2;
           continue;
         }
       }
-      const { lines } = splitLines(bytes2);
+      const { lines } = splitLines(bytes3);
       const matched = [];
       let count = 0;
       for (let i = 0; i < lines.length && count < maxCount; i++) {
@@ -17044,7 +17667,7 @@ var cmp = defineCommand({
     return 0;
   }
 });
-var commands5 = [grep, find, xargs, diff, cmp];
+var commands6 = [grep, find, xargs, diff, cmp];
 
 // src/bin/archive.ts
 init_mode();
@@ -17054,8 +17677,8 @@ var BLOCK = 512;
 var encoder5 = new TextEncoder();
 var decoder7 = new TextDecoder();
 function writeString(block, offset, value, length) {
-  const bytes2 = encoder5.encode(value);
-  for (let i = 0; i < length; i++) block[offset + i] = i < bytes2.length ? bytes2[i] : 0;
+  const bytes3 = encoder5.encode(value);
+  for (let i = 0; i < length; i++) block[offset + i] = i < bytes3.length ? bytes3[i] : 0;
 }
 function writeOctal(block, offset, value, length) {
   const text2 = value.toString(8).padStart(length - 1, "0");
@@ -17206,23 +17829,23 @@ var tar = defineCommand({
         if (args.has("verbose")) ctx.line(name);
       };
       for (const operand of args.positional) add(resolve(baseDir, operand), operand);
-      let bytes3 = createTar(entries2);
-      if (compressed) bytes3 = await gzip(bytes3);
-      if (archive === void 0 || archive === "-") ctx.write(bytes3);
-      else ctx.vfs.writeFile(ctx.path(archive), bytes3, { cred: ctx.cred, mode: 420 });
+      let bytes4 = createTar(entries2);
+      if (compressed) bytes4 = await gzip(bytes4);
+      if (archive === void 0 || archive === "-") ctx.write(bytes4);
+      else ctx.vfs.writeFile(ctx.path(archive), bytes4, { cred: ctx.cred, mode: 420 });
       return 0;
     }
-    let bytes2;
-    if (archive === void 0 || archive === "-") bytes2 = await ctx.stdin.readAll();
+    let bytes3;
+    if (archive === void 0 || archive === "-") bytes3 = await ctx.stdin.readAll();
     else {
       try {
-        bytes2 = ctx.vfs.readFile(ctx.path(archive), ctx.cred);
+        bytes3 = ctx.vfs.readFile(ctx.path(archive), ctx.cred);
       } catch (e) {
         return ctx.reportError(e, archive);
       }
     }
-    if (bytes2[0] === 31 && bytes2[1] === 139) bytes2 = await gunzip(bytes2);
-    const entries = readTar(bytes2);
+    if (bytes3[0] === 31 && bytes3[1] === 139) bytes3 = await gunzip(bytes3);
+    const entries = readTar(bytes3);
     const strip = args.num("strip-components", 0);
     if (args.has("list")) {
       for (const entry of entries) {
@@ -17359,7 +17982,7 @@ var zlibCompress = defineCommand({
     });
   }
 });
-var commands6 = [tar, gzip2, gunzip2, zcat, zlibCompress];
+var commands7 = [tar, gzip2, gunzip2, zcat, zlibCompress];
 
 // src/bin/hash.ts
 init_binary();
@@ -17401,8 +18024,8 @@ async function checkSums(ctx, algorithm, files, quiet) {
       checked++;
       const [, expected, name] = m;
       try {
-        const bytes2 = ctx.vfs.readFile(ctx.path(name), ctx.cred);
-        const actual = await digestHex(algorithm, bytes2);
+        const bytes3 = ctx.vfs.readFile(ctx.path(name), ctx.cred);
+        const actual = await digestHex(algorithm, bytes3);
         if (actual === expected.toLowerCase()) {
           if (!quiet) ctx.line(`${name}: OK`);
         } else {
@@ -17567,7 +18190,7 @@ var mktemp = defineCommand({
     return 0;
   }
 });
-var commands7 = [
+var commands8 = [
   md5sum,
   sha1sum,
   sha224sum,
@@ -18043,7 +18666,7 @@ var host = defineCommand({
     return 0;
   }
 });
-var commands8 = [curl, wget, ping, ip, ifconfig, ss, netstat, nc, host];
+var commands9 = [curl, wget, ping, ip, ifconfig, ss, netstat, nc, host];
 
 // src/bin/admin.ts
 init_mode();
@@ -18480,7 +19103,7 @@ sys	${fmt2(Math.floor(ms * 0.2))}
     return code;
   }
 });
-var commands9 = [
+var commands10 = [
   suCmd,
   sudo,
   useradd,
@@ -18656,7 +19279,7 @@ var helpCmd = defineCommand({
     return 0;
   }
 });
-var commands10 = [man, whatis, apropos, less, helpCmd];
+var commands11 = [man, whatis, apropos, less, helpCmd];
 
 // src/bin/clipboard.ts
 init_path();
@@ -18671,12 +19294,12 @@ function readSelection(ctx, selection) {
     return new Uint8Array();
   }
 }
-function writeSelection(ctx, selection, bytes2) {
+function writeSelection(ctx, selection, bytes3) {
   try {
     ctx.vfs.mkdir(CLIPBOARD_DIR, { recursive: true, mode: 511 });
   } catch {
   }
-  ctx.vfs.writeFile(selectionPath(selection), bytes2, { privileged: true, mode: 438 });
+  ctx.vfs.writeFile(selectionPath(selection), bytes3, { privileged: true, mode: 438 });
 }
 var xsel = defineCommand({
   name: "xsel",
@@ -18778,8 +19401,8 @@ var wlCopy = defineCommand({
   async run(ctx) {
     const selection = ctx.args.includes("--primary") || ctx.args.includes("-p") ? "primary" : "clipboard";
     const operands = ctx.args.filter((arg) => !arg.startsWith("-"));
-    const bytes2 = operands.length ? new TextEncoder().encode(operands.join(" ")) : await ctx.stdin.readAll();
-    writeSelection(ctx, selection, bytes2);
+    const bytes3 = operands.length ? new TextEncoder().encode(operands.join(" ")) : await ctx.stdin.readAll();
+    writeSelection(ctx, selection, bytes3);
     return 0;
   }
 });
@@ -18789,13 +19412,13 @@ var wlPaste = defineCommand({
   usage: "wl-paste [--primary] [-n]",
   run(ctx) {
     const selection = ctx.args.includes("--primary") || ctx.args.includes("-p") ? "primary" : "clipboard";
-    const bytes2 = readSelection(ctx, selection);
-    ctx.write(bytes2);
+    const bytes3 = readSelection(ctx, selection);
+    ctx.write(bytes3);
     if (!ctx.args.includes("-n") && !ctx.args.includes("--no-newline")) ctx.write("\n");
     return 0;
   }
 });
-var commands11 = [xsel, xclip, pbcopy, pbpaste, wlCopy, wlPaste];
+var commands12 = [xsel, xclip, pbcopy, pbpaste, wlCopy, wlPaste];
 
 // src/node/node.ts
 init_path();
@@ -19243,8 +19866,6 @@ ${lines[index]}`;
   }
   return out;
 }
-
-// src/node/node.ts
 var NODE_VERSION = "v22.12.0";
 new TextEncoder();
 var tempCounter = 0;
@@ -19388,10 +20009,10 @@ async function execute(ctx, invocation) {
 }
 async function captureStdin(ctx) {
   if (ctx.stdin.isTTY || ctx.stdin.interactive) return null;
-  const bytes2 = await ctx.stdin.readAll();
-  if (bytes2.length === 0) return null;
+  const bytes3 = await ctx.stdin.readAll();
+  if (bytes3.length === 0) return null;
   const path = tempPath("stdin", ctx.proc.pid, ".dat");
-  ctx.vfs.writeFile(path, bytes2, { privileged: true, mode: 384 });
+  ctx.vfs.writeFile(path, bytes3, { privileged: true, mode: 384 });
   return path;
 }
 var node = defineCommand({
@@ -19618,7 +20239,7 @@ ${prelude}${preloadRequires(preloads)}${source}
 }
 function resolveScript(ctx, operand) {
   const base2 = ctx.path(operand);
-  const candidates2 = [base2, `${base2}.js`, `${base2}.mjs`, `${base2}.cjs`, `${base2}.json`];
+  const candidates2 = [base2, `${base2}.js`, `${base2}.mjs`, `${base2}.cjs`, `${base2}.ts`, `${base2}.tsx`, `${base2}.json`];
   for (const candidate of candidates2) {
     try {
       const st = ctx.vfs.stat(candidate, { cred: ctx.cred });
@@ -19636,7 +20257,7 @@ function resolveScript(ctx, operand) {
           } catch {
           }
         }
-        for (const index of ["index.js", "index.mjs", "index.cjs"]) {
+        for (const index of ["index.js", "index.mjs", "index.cjs", "index.ts", "index.tsx"]) {
           const path = join(candidate, index);
           if (ctx.vfs.lexists(path)) return ctx.vfs.realpath(path, ctx.cred);
         }
@@ -19753,6 +20374,13 @@ function checkSyntax(ctx, script) {
   let source = ctx.vfs.readText(script, ctx.cred);
   if (source.startsWith("#!")) source = `//${source.slice(2)}`;
   try {
+    if (script.endsWith(".ts") || script.endsWith(".tsx")) {
+      source = transform(source, {
+        transforms: script.endsWith(".tsx") ? ["typescript", "jsx"] : ["typescript"],
+        filePath: script,
+        production: true
+      }).code;
+    }
     const esm = script.endsWith(".mjs") || !script.endsWith(".cjs") && looksLikeEsm(source);
     const transformed = esm ? transformEsm(source, script) : null;
     new AsyncFunction("exports", "require", "module", "__filename", "__dirname", transformed?.code ?? source);
@@ -21086,7 +21714,7 @@ var wheels_default = {
 
 // package.json
 var package_default = {
-  version: "0.2.21"};
+  version: "0.2.23"};
 
 // src/python/extension-abi.ts
 var EXTENSION_ABI = {
@@ -21937,9 +22565,9 @@ var Reader = class {
   at = 0;
   view;
   bytes;
-  constructor(bytes2) {
-    this.bytes = bytes2;
-    this.view = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
+  constructor(bytes3) {
+    this.bytes = bytes3;
+    this.view = new DataView(bytes3.buffer, bytes3.byteOffset, bytes3.byteLength);
   }
   need(count) {
     if (this.at + count > this.bytes.length) throw new ProtocolError("payload underrun");
@@ -22025,9 +22653,9 @@ var ByteQueue = class {
   chunks = [];
   length = 0;
   waiters = /* @__PURE__ */ new Set();
-  push(bytes2) {
-    if (bytes2.length === 0) return;
-    const copy = bytes2.slice();
+  push(bytes3) {
+    if (bytes3.length === 0) return;
+    const copy = bytes3.slice();
     this.chunks.push(copy);
     this.length += copy.length;
     this.wake();
@@ -22087,10 +22715,10 @@ var VirtualTcpConnection = class {
     if (this.eof) return new Uint8Array();
     throw new PosixError(Errno.EAGAIN, "socket read would block");
   }
-  write(bytes2) {
+  write(bytes3) {
     if (!this.writable) throw new PosixError(this.closed || this.writeClosed ? Errno.EPIPE : Errno.ECONNRESET);
-    this.peer.incoming.push(bytes2);
-    return bytes2.length;
+    this.peer.incoming.push(bytes3);
+    return bytes3.length;
   }
   async waitForChange() {
     if (this.readable || this.closed) return;
@@ -22373,9 +23001,9 @@ var SO_ERROR = 4;
 var SO_TYPE = 3;
 var SOCK_STREAM = 1;
 function int32(value) {
-  const bytes2 = new Uint8Array(4);
-  new DataView(bytes2.buffer).setInt32(0, value, true);
-  return bytes2;
+  const bytes3 = new Uint8Array(4);
+  new DataView(bytes3.buffer).setInt32(0, value, true);
+  return bytes3;
 }
 function isLoopback(address) {
   if (address === "" || address === "localhost" || address === "0.0.0.0") return true;
@@ -22766,9 +23394,9 @@ function createHostAbiServer(proc) {
       /* ---------------------------------------------------------- entropy */
       case Op.getrandom: {
         const length = Math.min(r.u32(), 65536);
-        const bytes2 = new Uint8Array(length);
-        crypto.getRandomValues(bytes2);
-        return { status: length, payload: bytes2 };
+        const bytes3 = new Uint8Array(length);
+        crypto.getRandomValues(bytes3);
+        return { status: length, payload: bytes3 };
       }
       /* ----------------------------------------------------------- sockets */
       case Op.socket: {
@@ -23254,9 +23882,9 @@ var FIRST_EGRESS_PORT = 48e3;
 var MAX_HEADER_BYTES = 64 * 1024;
 var MAX_BODY_BYTES = 32 * 1024 * 1024;
 var CRLF = "\r\n";
-function indexOfDoubleCrlf(bytes2) {
-  for (let i = 3; i < bytes2.length; i++) {
-    if (bytes2[i] === 10 && bytes2[i - 1] === 13 && bytes2[i - 2] === 10 && bytes2[i - 3] === 13) return i + 1;
+function indexOfDoubleCrlf(bytes3) {
+  for (let i = 3; i < bytes3.length; i++) {
+    if (bytes3[i] === 10 && bytes3[i - 1] === 13 && bytes3[i - 2] === 10 && bytes3[i - 3] === 13) return i + 1;
   }
   return -1;
 }
@@ -23521,62 +24149,6 @@ function splitOnce(text2, separator) {
   return at < 0 ? [text2] : [text2.slice(0, at), text2.slice(at + 1)];
 }
 
-// src/browser/playwright-browsers.ts
-init_path();
-var PLAYWRIGHT_REGISTRY = "/root/.cache/ms-playwright";
-var LAYOUTS = {
-  "chromium": ["chrome-linux64", "chrome"],
-  "chromium-headless-shell": ["chrome-headless-shell-linux64", "chrome-headless-shell"]
-};
-function virtualBrowserFiles(browsersJson) {
-  let manifest;
-  try {
-    manifest = JSON.parse(browsersJson);
-  } catch {
-    return [];
-  }
-  const encoder9 = new TextEncoder();
-  const files = [];
-  for (const browser of manifest.browsers ?? []) {
-    const layout = LAYOUTS[browser.name];
-    if (!layout) continue;
-    const dir3 = join(PLAYWRIGHT_REGISTRY, `${browser.name.replace(/-/g, "_")}-${browser.revision}`);
-    files.push({ path: join(dir3, ...layout), data: encoder9.encode(`#!${BUILTIN_INTERPRETER} chrome
-`), mode: 493 });
-    files.push({ path: join(dir3, "INSTALLATION_COMPLETE"), data: new Uint8Array() });
-  }
-  return files;
-}
-function mkdirp(volume, path) {
-  let current2 = "";
-  for (const part of segments(path)) {
-    current2 += `/${part}`;
-    try {
-      volume.mkdirSync(current2, { mode: 493 });
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
-    }
-  }
-}
-function installVirtualPlaywrightBrowsers(volume, packageDir) {
-  let text2;
-  try {
-    text2 = new TextDecoder().decode(volume.readFileSync(join(packageDir, "browsers.json")));
-  } catch {
-    return [];
-  }
-  const written = [];
-  for (const file3 of virtualBrowserFiles(text2)) {
-    mkdirp(volume, dirname(file3.path));
-    volume.writeFileSync(file3.path, file3.data);
-    if (file3.mode !== void 0) {
-      volume.chmodSync(file3.path, file3.mode);
-      written.push(file3.path);
-    }
-  }
-  return written;
-}
-
 // src/python/substitutions.ts
 var SUBSTITUTED_WHEELS = {
   playwright: /-py3-none-manylinux1_x86_64\.whl$/
@@ -24143,27 +24715,27 @@ async function installRequirements(options) {
       continue;
     }
     options.progress.downloading(distribution.name, distribution.version);
-    const bytes2 = await download(options.client, distribution);
-    const files = stageWheel(readZip(bytes2));
+    const bytes3 = await download(options.client, distribution);
+    const files = stageWheel(readZip(bytes3));
     staged.push(...distribution.kind === "substituted" ? substituteFiles(distribution.name, files, SITE_PACKAGES) : files);
     installed3.push({ name: distribution.name, version: distribution.version });
   }
   commit(options.vfs, options.cred, staged);
   return { installed: installed3, skipped: solved.skipped };
 }
-function requireArchive(distribution, bytes2) {
-  if (bytes2.length > 1 && bytes2[0] === 80 && bytes2[1] === 75) return;
-  const opening = new TextDecoder().decode(bytes2.subarray(0, 80)).replace(/\s+/g, " ").trim();
+function requireArchive(distribution, bytes3) {
+  if (bytes3.length > 1 && bytes3[0] === 80 && bytes3[1] === 75) return;
+  const opening = new TextDecoder().decode(bytes3.subarray(0, 80)).replace(/\s+/g, " ").trim();
   const looksLikeMarkup = /^<!doctype|^<html/i.test(opening);
   throw new Error(
-    `${distribution.filename} did not arrive as a wheel from ${distribution.url}: ` + (looksLikeMarkup ? "the server answered with an HTML page, which usually means the wheel is not published at that address and the server returned its index page instead" : `expected a zip archive, got ${bytes2.length} bytes beginning ${JSON.stringify(opening)}`)
+    `${distribution.filename} did not arrive as a wheel from ${distribution.url}: ` + (looksLikeMarkup ? "the server answered with an HTML page, which usually means the wheel is not published at that address and the server returned its index page instead" : `expected a zip archive, got ${bytes3.length} bytes beginning ${JSON.stringify(opening)}`)
   );
 }
 async function download(client, distribution) {
-  const bytes2 = await client.bytes(distribution.url, { timeoutMs: 12e4 });
-  requireArchive(distribution, bytes2);
-  const mismatch = digestMismatch(distribution, bytes2);
-  if (!mismatch) return bytes2;
+  const bytes3 = await client.bytes(distribution.url, { timeoutMs: 12e4 });
+  requireArchive(distribution, bytes3);
+  const mismatch = digestMismatch(distribution, bytes3);
+  if (!mismatch) return bytes3;
   const fresh = await refetch(client, distribution);
   if (fresh && !digestMismatch(distribution, fresh)) {
     requireArchive(distribution, fresh);
@@ -24176,22 +24748,22 @@ async function download(client, distribution) {
 async function refetch(client, distribution) {
   const separator = distribution.url.includes("?") ? "&" : "?";
   try {
-    const bytes2 = await client.bytes(
+    const bytes3 = await client.bytes(
       `${distribution.url}${separator}sha256=${distribution.sha256}`,
       { timeoutMs: 6e4 }
     );
-    return bytes2.length > 1 && bytes2[0] === 80 && bytes2[1] === 75 ? bytes2 : null;
+    return bytes3.length > 1 && bytes3[0] === 80 && bytes3[1] === 75 ? bytes3 : null;
   } catch {
     return null;
   }
 }
-function digestMismatch(distribution, bytes2) {
+function digestMismatch(distribution, bytes3) {
   if (!distribution.sha256) {
     throw new Error(
       `${distribution.filename} was published without a sha256 digest, so it cannot be verified`
     );
   }
-  const actual = [...sha256(bytes2)].map((b) => b.toString(16).padStart(2, "0")).join("");
+  const actual = [...sha256(bytes3)].map((b) => b.toString(16).padStart(2, "0")).join("");
   if (actual === distribution.sha256) return null;
   return `${distribution.filename} failed verification: the index published sha256 ${distribution.sha256} but the download hashes to ${actual}.`;
 }
@@ -24321,9 +24893,9 @@ function outputFor(description, fallback) {
   return {
     write(data) {
       if (broken) return;
-      const bytes2 = typeof data === "string" ? new TextEncoder().encode(data) : data;
-      if (bytes2.length === 0) return;
-      queue.push(bytes2.slice());
+      const bytes3 = typeof data === "string" ? new TextEncoder().encode(data) : data;
+      if (bytes3.length === 0) return;
+      queue.push(bytes3.slice());
       if (!active) done = pump();
     },
     end() {
@@ -25688,9 +26260,9 @@ environments. A package with no usable wheel is an error, never a silent skip.`,
       )];
       if (embedded) {
         const binary = atob(embedded);
-        const bytes2 = new Uint8Array(binary.length);
-        for (let i = 0; i < binary.length; i += 1) bytes2[i] = binary.charCodeAt(i);
-        return await read(new Response(bytes2));
+        const bytes3 = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i += 1) bytes3[i] = binary.charCodeAt(i);
+        return await read(new Response(bytes3));
       }
       if (url.startsWith("sbx-wheel:")) {
         const filename = decodeURIComponent(url.slice("sbx-wheel:".length).replace(/^\/+/, ""));
@@ -25759,7 +26331,7 @@ environments. A package with no usable wheel is an error, never a silent skip.`,
     let attemptsLeft = 12;
     for (; ; ) {
       try {
-        const report = await installRequirements({
+        const report2 = await installRequirements({
           index,
           client,
           vfs: ctx.vfs,
@@ -25780,11 +26352,11 @@ environments. A package with no usable wheel is an error, never a silent skip.`,
             }
           }
         });
-        for (const skipped of report.skipped) {
+        for (const skipped of report2.skipped) {
           ctx.line(`  Skipping ${skipped.name} (marker: ${skipped.marker})`);
         }
         ctx.line(
-          `Successfully installed ${report.installed.map((p) => `${p.name}-${p.version}`).join(" ")}`
+          `Successfully installed ${report2.installed.map((p) => `${p.name}-${p.version}`).join(" ")}`
         );
         return 0;
       } catch (error) {
@@ -26170,11 +26742,11 @@ async function loadFactory() {
 function getCompiled() {
   compiled2 ??= (async () => {
     const { factory, wasm } = await loadFactory();
-    const bytes2 = wasm.buffer.slice(
+    const bytes3 = wasm.buffer.slice(
       wasm.byteOffset,
       wasm.byteOffset + wasm.byteLength
     );
-    return { factory, module: await WebAssembly.compile(bytes2) };
+    return { factory, module: await WebAssembly.compile(bytes3) };
   })();
   void compiled2.catch(() => compiled2 = null);
   return compiled2;
@@ -26322,18 +26894,18 @@ than a packet path, and socket calls report ENOTSUP.`,
     }
     if (module === void 0) return ctx.reportError(new UsageError("a module is required"));
     const abs = ctx.path(module);
-    let bytes2;
+    let bytes3;
     try {
-      bytes2 = ctx.vfs.readFile(abs, ctx.cred);
+      bytes3 = ctx.vfs.readFile(abs, ctx.cred);
     } catch (error) {
       ctx.reportError(error, abs);
       return EXIT_NOT_FOUND;
     }
-    if (!isWasmBinary(bytes2)) {
+    if (!isWasmBinary(bytes3)) {
       return ctx.fail(`${abs}: not a WebAssembly module`, 126);
     }
     Object.assign(ctx.env, env2);
-    return await runWasi(ctx, bytes2, {
+    return await runWasi(ctx, bytes3, {
       /* argv[0] is the path as the user wrote it, not the resolved one: a
        * program printing its own usage should echo what was typed. */
       argv: [module, ...rest],
@@ -26344,398 +26916,6 @@ than a packet path, and socket calls report ENOTSUP.`,
 function wasiCommands() {
   return [wasi];
 }
-var platformBuffer = globalThis.Buffer;
-addUint8ArraySupport(addBase64UrlSupport(Buffer$1));
-var Buffer2 = platformBuffer ?? Buffer$1;
-function addUint8ArraySupport(BufferClass) {
-  const target = BufferClass;
-  if (target.__sandboxedUint8Array) return BufferClass;
-  Object.defineProperty(target, "__sandboxedUint8Array", { value: true });
-  const asBuffer = (value) => value instanceof Uint8Array && !target.isBuffer(value) ? target.from(value.buffer, value.byteOffset, value.byteLength) : value;
-  for (const method of ["indexOf", "lastIndexOf", "includes"]) {
-    const original = target.prototype[method];
-    target.prototype[method] = function(value, ...rest) {
-      return original.call(this, asBuffer(value), ...rest);
-    };
-  }
-  const equals = target.prototype.equals;
-  target.prototype.equals = function(other) {
-    return equals.call(this, asBuffer(other));
-  };
-  return BufferClass;
-}
-function addBase64UrlSupport(BufferClass) {
-  const target = BufferClass;
-  if (target.__sandboxedBase64Url) return BufferClass;
-  Object.defineProperty(target, "__sandboxedBase64Url", { value: true });
-  const from = target.from.bind(target);
-  target.from = (value, encodingOrOffset, length) => from(value, normalizeEncoding(encodingOrOffset), length);
-  const byteLength = target.byteLength.bind(target);
-  target.byteLength = (value, encoding) => byteLength(value, normalizeEncoding(encoding));
-  const isEncoding = target.isEncoding?.bind(target);
-  if (isEncoding) target.isEncoding = (encoding) => encoding.toLowerCase() === "base64url" || isEncoding(encoding);
-  const toString = target.prototype.toString;
-  target.prototype.toString = function(encoding, start2, end) {
-    if (encoding?.toLowerCase() !== "base64url") return toString.call(this, encoding, start2, end);
-    return toString.call(this, "base64", start2, end).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-  };
-  const write = target.prototype.write;
-  target.prototype.write = function(...args) {
-    const index = typeof args[1] === "string" ? 1 : typeof args[2] === "string" ? 2 : 3;
-    if (typeof args[index] === "string") args[index] = normalizeEncoding(args[index]);
-    return write.apply(this, args);
-  };
-  return BufferClass;
-}
-function normalizeEncoding(value) {
-  return typeof value === "string" && value.toLowerCase() === "base64url" ? "base64" : value;
-}
-
-// src/pkg/clean-installer.ts
-init_path();
-var CleanPackageInstaller = class _CleanPackageInstaller {
-  constructor(volume, options = {}) {
-    this.volume = volume;
-    this.options = options;
-    this.registry = (options.registry ?? "https://registry.npmjs.org").replace(/\/$/, "");
-    this.fetcher = options.fetch ?? globalThis.fetch.bind(globalThis);
-  }
-  volume;
-  options;
-  registry;
-  fetcher;
-  metadata = /* @__PURE__ */ new Map();
-  tarballs = /* @__PURE__ */ new Map();
-  /** Single-version manifests, for the fields the packument omits. */
-  details = /* @__PURE__ */ new Map();
-  forCwd(cwd) {
-    const installer = new _CleanPackageInstaller(this.volume, { ...this.options, cwd });
-    installer.metadata = this.metadata;
-    installer.tarballs = this.tarballs;
-    installer.details = this.details;
-    return installer;
-  }
-  async install(name, version = "latest", options = {}) {
-    const cwd = this.options.cwd ?? "/";
-    const manifest = await this.installAt(name, version || "latest", join(cwd, "node_modules"), options, /* @__PURE__ */ new Set());
-    if (options.persist !== false) this.persist(cwd, name, version, options.persistDev === true);
-    return manifest;
-  }
-  async installFromManifest(path, options = {}) {
-    const project = this.readJson(path);
-    const cwd = dirname(path);
-    const dependencies = {
-      ...project.dependencies ?? {},
-      ...options.withDevDeps === false ? {} : project.devDependencies ?? {}
-    };
-    await this.prefetch(dependencies);
-    for (const [name, range] of Object.entries(dependencies)) {
-      await this.installAt(name, range, join(cwd, "node_modules"), options, /* @__PURE__ */ new Set());
-    }
-  }
-  async installAt(name, range, modulesRoot, options, ancestry) {
-    const metadata = await this.getMetadata(name);
-    const version = resolveVersion(metadata, range);
-    const manifest = metadata.versions[version];
-    if (!manifest) throw new Error(`No matching version found for ${name}@${range}`);
-    const identity = `${name}@${version}`;
-    if (!supportsPlatform(manifest)) throw new IncompatiblePlatform(identity, "");
-    if (manifest.os?.length || manifest.cpu?.length) {
-      const detail = await this.platformDetail(name, version);
-      if (!platformListAllows(detail.libc, PLATFORM.libc)) {
-        throw new IncompatiblePlatform(identity, ` (needs ${detail.libc?.join(", ")})`);
-      }
-      if (detail.main?.endsWith(".node")) {
-        throw new IncompatiblePlatform(identity, " (native addon; this runtime cannot dlopen)");
-      }
-    }
-    const target = join(modulesRoot, name);
-    const installed3 = this.tryReadJson(join(target, "package.json"));
-    if (ancestry.has(identity)) return manifest;
-    if (installed3?.version !== version) {
-      options.onProgress?.(`Fetching ${identity}`);
-      const archive = await this.getTarball(manifest.dist.tarball);
-      verifyIntegrity(archive, manifest.dist.integrity, manifest.dist.shasum, identity);
-      this.removeIfPresent(target);
-      mkdirp2(this.volume, target);
-      extractNpmTarball(this.volume, archive, target);
-      options.onProgress?.(`Installed ${identity}`);
-    }
-    this.createBinLinks(manifest, target, modulesRoot);
-    if (name === "playwright-core") {
-      for (const executable of installVirtualPlaywrightBrowsers(this.volume, target)) {
-        options.onProgress?.(`Linked ${executable} to the virtual browser`);
-      }
-    }
-    const nextAncestry = new Set(ancestry).add(identity);
-    const childRoot = join(target, "node_modules");
-    const required = Object.fromEntries(Object.entries(manifest.dependencies ?? {}).filter(([name2]) => !(name2 in (manifest.optionalDependencies ?? {}))));
-    await this.prefetch(required);
-    for (const [dependency, dependencyRange] of Object.entries(required)) {
-      await this.installAt(dependency, dependencyRange, childRoot, options, nextAncestry);
-    }
-    for (const [dependency, dependencyRange] of Object.entries(manifest.optionalDependencies ?? {})) {
-      try {
-        await this.installAt(dependency, dependencyRange, childRoot, options, nextAncestry);
-      } catch (error) {
-        if (error instanceof IncompatiblePlatform) continue;
-        options.onProgress?.(`Skipped optional ${dependency}: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-    return manifest;
-  }
-  /**
-   * The `libc` and `main` fields, which the abbreviated packument leaves out.
-   *
-   * Fetched per version rather than as a full packument: the single-version
-   * document is a few kilobytes, while the full one for a popular package runs
-   * to megabytes. Only packages that already declare `os` or `cpu` ask for it,
-   * so an ordinary install of pure-JavaScript dependencies makes no extra
-   * requests at all — it is the prebuilt binaries, a handful per project, that
-   * need the answer.
-   *
-   * A failure here is not fatal. Being unable to read `libc` puts the check
-   * back where it was before this existed, which is worth strictly less than
-   * being right and strictly more than refusing to install.
-   */
-  async platformDetail(name, version) {
-    const key = `${name}@${version}`;
-    let request = this.details.get(key);
-    if (!request) {
-      request = (async () => {
-        try {
-          const encoded = name.startsWith("@") ? name.replace("/", "%2F") : encodeURIComponent(name);
-          const response = await this.fetcher(`${this.registry}/${encoded}/${version}`);
-          if (!response.ok) return {};
-          return await response.json();
-        } catch {
-          return {};
-        }
-      })();
-      this.details.set(key, request);
-    }
-    return request;
-  }
-  /** Overlap up to six sibling downloads; filesystem writes remain ordered. */
-  async prefetch(dependencies) {
-    const entries = Object.entries(dependencies);
-    let next = 0;
-    await Promise.all(Array.from({ length: Math.min(6, entries.length) }, async () => {
-      while (next < entries.length) {
-        const [name, range] = entries[next++];
-        try {
-          const metadata = await this.getMetadata(name);
-          const manifest = metadata.versions[resolveVersion(metadata, range)];
-          if (!manifest.os?.length && !manifest.cpu?.length && supportsPlatform(manifest)) {
-            await this.getTarball(manifest.dist.tarball);
-          }
-        } catch {
-        }
-      }
-    }));
-  }
-  async getMetadata(name) {
-    let request = this.metadata.get(name);
-    if (!request) {
-      request = (async () => {
-        const encoded = name.startsWith("@") ? name.replace("/", "%2F") : encodeURIComponent(name);
-        const response = await this.fetcher(`${this.registry}/${encoded}`, {
-          headers: { Accept: "application/vnd.npm.install-v1+json" }
-        });
-        if (!response.ok) throw new Error(`registry returned ${response.status} for ${name}`);
-        return await response.json();
-      })();
-      this.metadata.set(name, request);
-      void request.catch(() => {
-        this.metadata.delete(name);
-      });
-    }
-    return request;
-  }
-  async getTarball(url) {
-    let request = this.tarballs.get(url);
-    if (!request) {
-      request = (async () => {
-        const response = await this.fetcher(url);
-        if (!response.ok) throw new Error(`tarball returned ${response.status}: ${url}`);
-        return new Uint8Array(await response.arrayBuffer());
-      })();
-      this.tarballs.set(url, request);
-      void request.catch(() => {
-        this.tarballs.delete(url);
-      });
-    }
-    return request;
-  }
-  createBinLinks(manifest, target, modulesRoot) {
-    if (!manifest.bin) return;
-    const bins = typeof manifest.bin === "string" ? { [unscoped(manifest.name)]: manifest.bin } : manifest.bin;
-    const binDir = join(modulesRoot, ".bin");
-    mkdirp2(this.volume, binDir);
-    for (const [name, path] of Object.entries(bins)) {
-      const link = join(binDir, name);
-      this.removeIfPresent(link);
-      this.volume.symlinkSync(relative(binDir, join(target, path)), link);
-    }
-  }
-  persist(cwd, name, range, dev) {
-    const path = join(cwd, "package.json");
-    const manifest = this.tryReadJson(path) ?? {};
-    const key = dev ? "devDependencies" : "dependencies";
-    manifest[key] = { ...manifest[key] ?? {}, [name]: range === "latest" ? "*" : range };
-    this.volume.writeFileSync(path, JSON.stringify(manifest, null, 2) + "\n");
-  }
-  removeIfPresent(path) {
-    let stat2;
-    try {
-      stat2 = this.volume.lstatSync(path);
-    } catch {
-      return;
-    }
-    if (!stat2.isDirectory()) return this.volume.unlinkSync(path);
-    for (const name of this.volume.readdirSync(path)) this.removeIfPresent(join(path, name));
-    this.volume.rmdirSync(path);
-  }
-  readJson(path) {
-    return JSON.parse(new TextDecoder().decode(this.volume.readFileSync(path)));
-  }
-  tryReadJson(path) {
-    try {
-      return this.readJson(path);
-    } catch {
-      return null;
-    }
-  }
-};
-var PLATFORM = { os: "linux", cpu: "x64", libc: "glibc" };
-var IncompatiblePlatform = class extends Error {
-  constructor(identity, detail) {
-    super(`${identity} is not compatible with ${PLATFORM.os}/${PLATFORM.cpu}/${PLATFORM.libc}${detail}`);
-    this.name = "IncompatiblePlatform";
-  }
-};
-function supportsPlatform(manifest) {
-  return platformListAllows(manifest.os, PLATFORM.os) && platformListAllows(manifest.cpu, PLATFORM.cpu) && platformListAllows(manifest.libc, PLATFORM.libc);
-}
-function platformListAllows(values, current2) {
-  if (!values?.length) return true;
-  if (values.includes(`!${current2}`)) return false;
-  const positive = values.filter((value) => !value.startsWith("!"));
-  return positive.length === 0 || positive.includes(current2) || positive.includes("any");
-}
-function resolveVersion(metadata, range) {
-  const tag2 = metadata["dist-tags"]?.[range];
-  if (tag2) return tag2;
-  if (valid(range) && metadata.versions[range]) return range;
-  const found2 = maxSatisfying(Object.keys(metadata.versions), range === "latest" ? "*" : range, { includePrerelease: false });
-  if (!found2) throw new Error(`No matching version found for ${metadata.name}@${range}`);
-  return found2;
-}
-function verifyIntegrity(data, integrity, shasum, identity) {
-  if (integrity) {
-    const choices = integrity.trim().split(/\s+/);
-    for (const choice of choices) {
-      const dash = choice.indexOf("-");
-      const algorithm = choice.slice(0, dash);
-      const expected = choice.slice(dash + 1).replace(/\?.*$/, "");
-      const digest2 = algorithm === "sha512" ? sha512(data) : algorithm === "sha256" ? sha256(data) : null;
-      if (digest2 && Buffer2.from(digest2).toString("base64") === expected) return;
-    }
-    throw new Error(`Integrity check failed for ${identity}`);
-  }
-  if (shasum && Buffer2.from(sha1(data)).toString("hex") === shasum) return;
-  if (shasum) throw new Error(`Legacy checksum check failed for ${identity}`);
-}
-function extractNpmTarball(volume, compressed, destination) {
-  const tar2 = ungzip(compressed);
-  let offset = 0;
-  let longPath = null;
-  let paxPath = null;
-  while (offset + 512 <= tar2.length) {
-    const header = tar2.subarray(offset, offset + 512);
-    if (header.every((byte) => byte === 0)) break;
-    const size = octal(header, 124, 12);
-    const type = String.fromCharCode(header[156] || 48);
-    const prefix = text(header, 345, 155);
-    let name = longPath ?? paxPath ?? [prefix, text(header, 0, 100)].filter(Boolean).join("/");
-    longPath = null;
-    paxPath = null;
-    const data = tar2.subarray(offset + 512, offset + 512 + size);
-    offset += 512 + Math.ceil(size / 512) * 512;
-    if (type === "L") {
-      longPath = new TextDecoder().decode(data).replace(/\0.*$/, "").trim();
-      continue;
-    }
-    if (type === "x" || type === "g") {
-      paxPath = parsePax(data).path ?? null;
-      continue;
-    }
-    name = stripPackageRoot(name);
-    if (!name) continue;
-    const target = safeTarget(destination, name);
-    const mode = octal(header, 100, 8) || 420;
-    if (type === "5") {
-      mkdirp2(volume, target, mode);
-    } else if (type === "2") {
-      mkdirp2(volume, dirname(target));
-      volume.symlinkSync(text(header, 157, 100), target);
-    } else if (type === "1") {
-      mkdirp2(volume, dirname(target));
-      volume.linkSync(safeTarget(destination, stripPackageRoot(text(header, 157, 100))), target);
-    } else if (type === "0" || type === "\0" || type === "7") {
-      mkdirp2(volume, dirname(target));
-      volume.writeFileSync(target, data.slice());
-      volume.chmodSync(target, mode);
-    }
-  }
-}
-function mkdirp2(volume, path, mode = 493) {
-  let current2 = "";
-  for (const part of segments(path)) {
-    current2 += `/${part}`;
-    try {
-      volume.mkdirSync(current2, { mode });
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
-      if (!volume.lstatSync(current2).isDirectory()) throw error;
-    }
-  }
-}
-function safeTarget(destination, name) {
-  const clean2 = clean(`/${name}`).slice(1);
-  if (!clean2 || clean2 === ".." || clean2.startsWith("../") || name.startsWith("/")) throw new Error(`Unsafe path in package: ${name}`);
-  return join(destination, clean2);
-}
-function stripPackageRoot(name) {
-  const clean2 = name.replace(/^\.\//, "").replace(/\/$/, "");
-  const slash = clean2.indexOf("/");
-  return slash === -1 ? "" : clean2.slice(slash + 1);
-}
-function text(bytes2, start2, length) {
-  return new TextDecoder().decode(bytes2.subarray(start2, start2 + length)).replace(/\0.*$/, "").trim();
-}
-function octal(bytes2, start2, length) {
-  return parseInt(text(bytes2, start2, length).replace(/^0+/, "") || "0", 8);
-}
-function parsePax(data) {
-  const value = new TextDecoder().decode(data);
-  const result = {};
-  let offset = 0;
-  while (offset < value.length) {
-    const space = value.indexOf(" ", offset);
-    if (space < 0) break;
-    const length = Number(value.slice(offset, space));
-    if (!Number.isFinite(length) || length <= 0) break;
-    const record2 = value.slice(space + 1, offset + length - 1);
-    const equal2 = record2.indexOf("=");
-    if (equal2 > 0) result[record2.slice(0, equal2)] = record2.slice(equal2 + 1);
-    offset += length;
-  }
-  return result;
-}
-function unscoped(name) {
-  return name.startsWith("@") ? name.slice(name.indexOf("/") + 1) : name;
-}
 var DECLARES_EXPORTS = /(?:^|[\s;{)])(?:var|let|const|function|class)\s+exports\b/;
 var NAME = "exports";
 function renameShadowedExports(source) {
@@ -28448,8 +28628,8 @@ var VireoEngine = class _VireoEngine {
     const app = installedVireo(ctx);
     if (!app?.browserEngine) return null;
     const manifest = app.browserEngine;
-    const bytes2 = ctx.vfs.readFile(`${app.root}/${manifest.wasm}`, ctx.cred);
-    const loaded = await WebAssembly.instantiate(bytes2, {});
+    const bytes3 = ctx.vfs.readFile(`${app.root}/${manifest.wasm}`, ctx.cred);
+    const loaded = await WebAssembly.instantiate(bytes3, {});
     const instance = loaded instanceof WebAssembly.Instance ? loaded : loaded.instance;
     const wasm = instance.exports;
     for (const name of ["memory", "vireo_alloc", "vireo_load_html", "vireo_snapshot_pointer", "vireo_snapshot_length", "vireo_free_document"]) {
@@ -28473,11 +28653,11 @@ var VireoEngine = class _VireoEngine {
       this.wasm.vireo_free_document(handle);
     }
   }
-  copy(bytes2) {
-    if (!bytes2.length) return 0;
-    const pointer = this.wasm.vireo_alloc(bytes2.length);
+  copy(bytes3) {
+    if (!bytes3.length) return 0;
+    const pointer = this.wasm.vireo_alloc(bytes3.length);
     if (!pointer) throw new Error("Vireo ran out of memory");
-    new Uint8Array(this.wasm.memory.buffer, pointer, bytes2.length).set(bytes2);
+    new Uint8Array(this.wasm.memory.buffer, pointer, bytes3.length).set(bytes3);
     return pointer;
   }
 };
@@ -28663,8 +28843,8 @@ var SIGNATURE_PATH = "META/signature.json";
 var TRUSTED_KEYS_PATH = "/etc/pm/trusted-keys.json";
 var PackageError = class extends Error {
 };
-async function openPackage(bytes2, trusted) {
-  const entries = readZip(bytes2);
+async function openPackage(bytes3, trusted) {
+  const entries = readZip(bytes3);
   const byName = new Map(entries.map((entry) => [entry.name, entry]));
   const manifestEntry = byName.get(MANIFEST_PATH);
   if (!manifestEntry) {
@@ -28707,10 +28887,10 @@ async function openPackage(bytes2, trusted) {
   const trustedBy = trusted.find((key) => key.publicKey === signature.publicKey) ?? null;
   return { manifest, signature, entries, trustedBy };
 }
-function parseManifest(bytes2) {
+function parseManifest(bytes3) {
   let parsed;
   try {
-    parsed = JSON.parse(new TextDecoder().decode(bytes2));
+    parsed = JSON.parse(new TextDecoder().decode(bytes3));
   } catch (error) {
     throw new PackageError(`${MANIFEST_PATH} is not JSON: ${error.message}`);
   }
@@ -28726,10 +28906,10 @@ function parseManifest(bytes2) {
   }
   return manifest;
 }
-function parseSignature(bytes2) {
+function parseSignature(bytes3) {
   let parsed;
   try {
-    parsed = JSON.parse(new TextDecoder().decode(bytes2));
+    parsed = JSON.parse(new TextDecoder().decode(bytes3));
   } catch (error) {
     throw new PackageError(`${SIGNATURE_PATH} is not JSON: ${error.message}`);
   }
@@ -28777,16 +28957,16 @@ async function verifySignature(manifestBytes, signature) {
     intoBuffer(manifestBytes)
   );
 }
-function intoBuffer(bytes2) {
-  return bytes2.slice().buffer;
+function intoBuffer(bytes3) {
+  return bytes3.slice().buffer;
 }
 function base64ToBytes(text2) {
   const binary = atob(text2);
-  const bytes2 = new Uint8Array(binary.length);
+  const bytes3 = new Uint8Array(binary.length);
   for (let index = 0; index < binary.length; index += 1) {
-    bytes2[index] = binary.charCodeAt(index);
+    bytes3[index] = binary.charCodeAt(index);
   }
-  return bytes2;
+  return bytes3;
 }
 async function fingerprint(publicKey) {
   const digest2 = await digestHex("sha256", base64ToBytes(publicKey));
@@ -29159,8 +29339,8 @@ function listInstalled2(ctx) {
     return 0;
   }
   for (const app of apps.slice().sort((a, b) => a.name.localeCompare(b.name))) {
-    const commands12 = app.installedBins.length > 0 ? `  (${app.installedBins.join(", ")})` : "";
-    ctx.line(`${app.name} ${app.version}${commands12}`);
+    const commands13 = app.installedBins.length > 0 ? `  (${app.installedBins.join(", ")})` : "";
+    ctx.line(`${app.name} ${app.version}${commands13}`);
   }
   return 0;
 }
@@ -29269,6 +29449,7 @@ function allCommands() {
     ...commands9,
     ...commands10,
     ...commands11,
+    ...commands12,
     ...nodeCommands(),
     ...pythonCommands(),
     ...ffmpegCommands(),
@@ -29313,8 +29494,8 @@ var ContainerFs = class {
     return this.kernel.vfs;
   }
   async readFile(path, encoding) {
-    const bytes2 = this.vfs.readFile(clean(path));
-    return encoding ? new TextDecoder().decode(bytes2) : bytes2;
+    const bytes3 = this.vfs.readFile(clean(path));
+    return encoding ? new TextDecoder().decode(bytes3) : bytes3;
   }
   async writeFile(path, data, opts = {}) {
     const abs = clean(path);
@@ -29640,9 +29821,9 @@ var KernelChildProcess = class {
     this.exitCode = code;
     this.emit("exit", code);
   }
-  append(stream, text2) {
+  append(stream, value, text2 = typeof value === "string" ? value : new TextDecoder().decode(value)) {
     this[stream] += text2;
-    this.emit(stream, text2);
+    this.emit(stream, value);
   }
 };
 var ChildOutput = class {
@@ -29661,7 +29842,7 @@ var ChildOutput = class {
   write(data) {
     if (this.closedState) return;
     const text2 = typeof data === "string" ? data : this.decoder.decode(data, { stream: true });
-    if (text2) this.child.append(this.stream, text2);
+    if (text2 || data instanceof Uint8Array) this.child.append(this.stream, data, text2);
   }
   end() {
     if (this.closedState) return;
@@ -30162,6 +30343,13 @@ var CommonJsEngine = class {
   }
   evaluate(module, source) {
     if (source.startsWith("#!")) source = source.replace(/^#![^\n]*(?:\n|$)/, "");
+    if (isTypeScript(module.filename)) {
+      source = transform(source, {
+        transforms: module.filename.endsWith(".tsx") ? ["typescript", "jsx"] : ["typescript"],
+        filePath: module.filename,
+        production: true
+      }).code;
+    }
     const transformed = transformEsm(source, module.filename);
     const esmBody = transformed?.code ?? source;
     const body = transformAsyncContext(esmBody, module.filename) ?? esmBody;
@@ -30424,6 +30612,9 @@ Require stack:
     return error;
   }
 };
+function isTypeScript(filename) {
+  return filename.endsWith(".ts") || filename.endsWith(".tsx");
+}
 var namespaces = /* @__PURE__ */ new WeakMap();
 function namespaceOf(exports) {
   if (exports === null || typeof exports !== "object" && typeof exports !== "function") {
@@ -31709,13 +31900,13 @@ var Z_NO_FLUSH = 0;
 var Z_SYNC_FLUSH = 2;
 var Z_FULL_FLUSH = 3;
 var Z_FINISH = 4;
-var bytes = (data) => {
+var bytes2 = (data) => {
   if (typeof data === "string") return new Uint8Array(Buffer2.from(data, "utf8"));
   if (data instanceof ArrayBuffer) return new Uint8Array(data);
   return data;
 };
 function codec(run3) {
-  const sync2 = (data, options) => Buffer2.from(run3(bytes(data), options));
+  const sync2 = (data, options) => Buffer2.from(run3(bytes2(data), options));
   const async_ = (data, options, callback) => {
     const done = typeof options === "function" ? options : callback;
     const settings = typeof options === "function" ? void 0 : options;
@@ -32065,6 +32256,8 @@ var VirtualServerResponse = class extends streamModule5.Writable {
   completed;
   constructor(request) {
     super();
+    this.on("error", () => {
+    });
     this.req = request;
     this.completed = new Promise((resolve3) => {
       this.resolve = resolve3;
@@ -32194,9 +32387,9 @@ var VirtualSocket = class extends streamModule5.Duplex {
   _read() {
   }
   _write(chunk, encoding, callback) {
-    const bytes2 = Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk, encoding);
+    const bytes3 = Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk, encoding);
     try {
-      this.peer?.data(new Uint8Array(bytes2));
+      this.peer?.data(new Uint8Array(bytes3));
       callback();
     } catch (error) {
       callback(error);
@@ -32220,9 +32413,9 @@ var VirtualSocket = class extends streamModule5.Duplex {
     this.peer = null;
   }
   /** Bytes arriving from the far end. */
-  deliver(bytes2) {
+  deliver(bytes3) {
     if (this.destroyed || this.hungUp) return;
-    this.push(Buffer2.from(bytes2));
+    this.push(Buffer2.from(bytes3));
   }
   /** The far end went away; let the server's stream end cleanly. */
   peerClosed() {
@@ -32377,7 +32570,7 @@ var VirtualHttpRouter = class {
     request.socket = socket;
     item.server.emit("upgrade", request, socket, Buffer2.alloc(0));
     return {
-      send: (bytes2) => socket.deliver(bytes2),
+      send: (bytes3) => socket.deliver(bytes3),
       close: () => socket.peerClosed()
     };
   }
@@ -32603,9 +32796,9 @@ var VirtualClientRequest = class extends streamModule5.Writable {
     }
     const result = remote ?? await this.router.request(this.target.port, init);
     const body_ = result.body;
-    const bytes2 = typeof body_ === "string" ? new TextEncoder().encode(body_) : body_ instanceof ArrayBuffer ? new Uint8Array(body_) : body_ ?? new Uint8Array();
+    const bytes3 = typeof body_ === "string" ? new TextEncoder().encode(body_) : body_ instanceof ArrayBuffer ? new Uint8Array(body_) : body_ ?? new Uint8Array();
     const status = result.statusCode ?? 200;
-    return new VirtualClientResponse(status, result.statusMessage ?? STATUS_CODES[status] ?? "", lowercaseHeaders(result.headers), bytes2);
+    return new VirtualClientResponse(status, result.statusMessage ?? STATUS_CODES[status] ?? "", lowercaseHeaders(result.headers), bytes3);
   }
   async viaFetch(body) {
     const fetchImpl = this.fetchImpl ?? globalThis.fetch;
@@ -32629,8 +32822,8 @@ var VirtualClientRequest = class extends streamModule5.Writable {
     response.headers.forEach((value, key) => {
       received[key.toLowerCase()] = value;
     });
-    const bytes2 = new Uint8Array(await response.arrayBuffer());
-    return new VirtualClientResponse(response.status, response.statusText, received, bytes2);
+    const bytes3 = new Uint8Array(await response.arrayBuffer());
+    return new VirtualClientResponse(response.status, response.statusText, received, bytes3);
   }
 };
 function lowercaseHeaders(headers) {
@@ -32722,9 +32915,9 @@ function createVirtualFetch(router, options = {}) {
         for (const part of Array.isArray(value) ? value : [value]) responseHeaders.append(name, String(part));
       }
       const raw = result.body;
-      const bytes2 = typeof raw === "string" ? new TextEncoder().encode(raw) : raw instanceof ArrayBuffer ? new Uint8Array(raw) : raw ?? new Uint8Array();
+      const bytes3 = typeof raw === "string" ? new TextEncoder().encode(raw) : raw instanceof ArrayBuffer ? new Uint8Array(raw) : raw ?? new Uint8Array();
       const nullBody = status === 204 || status === 205 || status === 304 || request.method === "HEAD";
-      return new Response(nullBody ? null : new Uint8Array(bytes2), {
+      return new Response(nullBody ? null : new Uint8Array(bytes3), {
         status,
         statusText: result.statusMessage ?? STATUS_CODES[status] ?? "",
         headers: responseHeaders
@@ -32970,7 +33163,7 @@ function createTestModule(host2) {
     });
   };
   const hasOnly = (node2) => Boolean(node2.options.only) || node2.kind === "suite" && node2.children.some(hasOnly);
-  const report = (depth, outcome, name, started, detail) => {
+  const report2 = (depth, outcome, name, started, detail) => {
     if (tap()) {
       tapIndex += 1;
       const ok2 = outcome === "fail" ? "not ok" : "ok";
@@ -33017,13 +33210,13 @@ ${indent(detail, 4)}
     if (runOnly && !options.only) return true;
     if (options.skip) {
       record2("skip", display);
-      report(depth, "skip", name, started);
+      report2(depth, "skip", name, started);
       return true;
     }
     if (!fn) {
       const outcome = options.todo ? "todo" : "skip";
       record2(outcome, display);
-      report(depth, outcome, name, started);
+      report2(depth, outcome, name, started);
       return true;
     }
     const controller = new AbortController();
@@ -33087,21 +33280,21 @@ ${indent(detail, 4)}
     }
     if (skipped) {
       record2("skip", display);
-      report(depth, "skip", name, started);
+      report2(depth, "skip", name, started);
       return true;
     }
     if (error !== void 0) {
       if (todo) {
         record2("todo", display);
-        report(depth, "todo", name, started);
+        report2(depth, "todo", name, started);
         return true;
       }
       record2("fail", display, error);
-      report(depth, "fail", name, started, errorText(error));
+      report2(depth, "fail", name, started, errorText(error));
       return false;
     }
     record2(todo ? "todo" : "pass", display);
-    report(depth, todo ? "todo" : "pass", name, started);
+    report2(depth, todo ? "todo" : "pass", name, started);
     return true;
   };
   const runSuite = async (suite, depth, runOnly) => {
@@ -33116,7 +33309,7 @@ ${indent(detail, 4)}
 `);
       if (suite.options.skip) {
         for (const child of suite.children) if (child.kind === "test") record2("skip", fullName(child));
-        report(depth, "skip", suite.name, started);
+        report2(depth, "skip", suite.name, started);
         return true;
       }
     }
@@ -33128,10 +33321,10 @@ ${indent(detail, 4)}
       for (const child of suite.children) {
         if (child.kind === "test") {
           record2("cancelled", fullName(child), error);
-          report(depth + (isRoot ? 0 : 1), "cancelled", child.name, started, errorText(error));
+          report2(depth + (isRoot ? 0 : 1), "cancelled", child.name, started, errorText(error));
         }
       }
-      if (!isRoot) report(depth, "fail", suite.name, started);
+      if (!isRoot) report2(depth, "fail", suite.name, started);
       return false;
     }
     const only = runOnly || settings().only === true && suite.children.some(hasOnly);
@@ -33511,7 +33704,7 @@ var ChildProcess = class extends EventEmitter4 {
     this.stdin = new streamModule5.Writable({
       write: (chunk, _encoding, done) => {
         try {
-          handle.sendStdin(typeof chunk === "string" ? chunk : Buffer2.from(chunk).toString("utf8"));
+          handle.sendStdin(typeof chunk === "string" ? chunk : new Uint8Array(chunk));
         } catch {
         }
         done();
@@ -33530,8 +33723,8 @@ var ChildProcess = class extends EventEmitter4 {
       const pipe = this.stdio[event.fd];
       pipe?.push(Buffer2.from(event.text));
     });
-    handle.on("stdout", (text2) => this.stdout.write(text2));
-    handle.on("stderr", (text2) => this.stderr.write(text2));
+    handle.on("stdout", (value) => this.stdout.write(typeof value === "string" ? value : Buffer2.from(value)));
+    handle.on("stderr", (value) => this.stderr.write(typeof value === "string" ? value : Buffer2.from(value)));
     handle.on("exit", (code) => this.finish(code));
     referenceChanged(1);
     try {
@@ -34518,7 +34711,7 @@ function createCoreModules(options) {
   });
   processObject.stdin = stdin;
   Reflect.deleteProperty(processObject, "browser");
-  const fs = createFsModule(volume, () => cwd, options.stdinPath, defer);
+  const fs = createFsModule(volume, () => cwd, options.stdinPath, defer, stdin);
   processObject.loadEnvFile = (path2 = ".env") => {
     const parsed = parseEnv(fs.readFileSync(path2, "utf8"));
     for (const [key, value] of Object.entries(parsed)) {
@@ -34890,7 +35083,7 @@ function createPathModule(cwd) {
   path.default = path;
   return path;
 }
-function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
+function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask, stdin) {
   const fds = /* @__PURE__ */ new Map();
   let nextFd = 3;
   if (stdinPath) fds.set(0, { path: stdinPath, position: 0, flags: "r" });
@@ -34901,7 +35094,7 @@ function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
     if (typeof value !== "string") throw new TypeError("path must be a string, Buffer, or URL");
     return value.startsWith("/") ? clean(value) : resolve(cwd(), value);
   };
-  const bytes2 = (data, encoding) => {
+  const bytes3 = (data, encoding) => {
     if (typeof data === "string") return new Uint8Array(Buffer2.from(data, encoding));
     if (Buffer2.isBuffer(data) || data instanceof Uint8Array) return new Uint8Array(data);
     if (data instanceof ArrayBuffer) return new Uint8Array(data);
@@ -34963,12 +35156,12 @@ function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
     readFileSync: (path, options) => read(path, typeof options === "object" && options ? options.encoding : options),
     writeFileSync: (path, data, options) => {
       const encoding = typeof options === "object" && options ? options.encoding : options === "buffer" ? void 0 : options ?? void 0;
-      volume.writeFileSync(abs(path), bytes2(data, encoding ?? void 0));
+      volume.writeFileSync(abs(path), bytes3(data, encoding ?? void 0));
       if (typeof options === "object" && options?.mode !== void 0) volume.chmodSync(abs(path), options.mode);
     },
     appendFileSync: (path, data, options) => {
       const encoding = typeof options === "object" && options ? options.encoding : options === "buffer" ? void 0 : options ?? void 0;
-      volume.appendFileSync(abs(path), bytes2(data, encoding ?? void 0));
+      volume.appendFileSync(abs(path), bytes3(data, encoding ?? void 0));
     },
     existsSync: (path) => {
       try {
@@ -35059,7 +35252,7 @@ function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
         offset = 0;
         length = data.length;
       }
-      const input = bytes2(data);
+      const input = bytes3(data);
       const chunk = input.subarray(offset ?? 0, (offset ?? 0) + (length ?? input.length));
       const size = volume.lstatSync(file3.path).size;
       const append = file3.flags.startsWith("a") || (position ?? file3.position) >= size;
@@ -35184,9 +35377,9 @@ function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
     const self = this;
     const append = () => {
       try {
-        const bytes3 = typeof chunk === "string" ? Buffer2.from(chunk, encoding) : chunk;
-        volume.appendFileSync(self.path, new Uint8Array(bytes3));
-        self.bytesWritten += bytes3.length;
+        const bytes4 = typeof chunk === "string" ? Buffer2.from(chunk, encoding) : chunk;
+        volume.appendFileSync(self.path, new Uint8Array(bytes4));
+        self.bytesWritten += bytes4.length;
         done();
       } catch (error) {
         done(error);
@@ -35387,6 +35580,57 @@ function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
       ({ offset, length, position } = options);
     }
     const start2 = offset ?? 0;
+    if (fd === 0 && stdin) {
+      const requested = length ?? buffer.byteLength - start2;
+      const finish = (chunk) => {
+        const source = Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk);
+        const count = Math.min(requested, source.byteLength);
+        buffer.set(source.subarray(0, count), start2);
+        if (count < source.byteLength && typeof stdin.unshift === "function") {
+          stdin.unshift(source.subarray(count));
+        }
+        cb(null, count, buffer);
+      };
+      const available2 = stdin.read();
+      if (available2 !== null) {
+        defer(() => finish(available2));
+        return;
+      }
+      if (stdin.readableEnded || stdin.destroyed) {
+        defer(() => cb(null, 0, buffer));
+        return;
+      }
+      let settled = false;
+      const cleanup = () => {
+        stdin.removeListener("readable", onReadable);
+        stdin.removeListener("end", onEnd);
+        stdin.removeListener("error", onError);
+      };
+      const onReadable = () => {
+        if (settled) return;
+        const chunk = stdin.read();
+        if (chunk === null) return;
+        settled = true;
+        cleanup();
+        finish(chunk);
+      };
+      const onEnd = () => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        cb(null, 0, buffer);
+      };
+      const onError = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        cb(error);
+      };
+      stdin.on("readable", onReadable);
+      stdin.once("end", onEnd);
+      stdin.once("error", onError);
+      return;
+    }
     runThenCall(() => [fs.readSync(fd, buffer, start2, length ?? buffer.byteLength - start2, position ?? null), buffer], cb);
   };
   fs.write = (fd, data, ...rest) => {
@@ -35478,8 +35722,8 @@ function createBufferBuiltin() {
       }
     },
     isAscii: (input) => {
-      const bytes2 = input instanceof ArrayBuffer ? new Uint8Array(input) : new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
-      for (const byte of bytes2) if (byte > 127) return false;
+      const bytes3 = input instanceof ArrayBuffer ? new Uint8Array(input) : new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+      for (const byte of bytes3) if (byte > 127) return false;
       return true;
     }
   };
@@ -36118,37 +36362,37 @@ var MemoryVolume = class {
   writeFileSync(path, data) {
     const key = this.key(path);
     this.requireParent(key, "open");
-    const bytes2 = typeof data === "string" ? encoder7.encode(data) : data.slice();
+    const bytes3 = typeof data === "string" ? encoder7.encode(data) : data.slice();
     const current2 = this.entries.get(key);
     if (current2?.kind === "directory") throw new VolumeError("EISDIR", "open", key);
     if (current2?.kind === "symlink") throw new VolumeError("EINVAL", "open", key);
     if (current2) {
-      current2.data = bytes2;
+      current2.data = bytes3;
       this.touchChanged(current2, true);
     } else {
-      this.entries.set(key, this.inode("file", 438, bytes2));
+      this.entries.set(key, this.inode("file", 438, bytes3));
     }
   }
   appendFileSync(path, data) {
     const key = this.key(path);
-    const bytes2 = typeof data === "string" ? encoder7.encode(data) : data;
+    const bytes3 = typeof data === "string" ? encoder7.encode(data) : data;
     const current2 = this.entries.get(key);
-    if (!current2) return this.writeFileSync(key, bytes2);
+    if (!current2) return this.writeFileSync(key, bytes3);
     if (current2.kind !== "file") throw new VolumeError(current2.kind === "directory" ? "EISDIR" : "EINVAL", "open", key);
     const length = current2.data.length;
-    const needed = length + bytes2.length;
+    const needed = length + bytes3.length;
     const backing = current2.data.buffer;
     const ownsTail = current2.data.byteOffset === 0 && backing instanceof ArrayBuffer && backing.byteLength >= needed && appendCapacity.get(current2) === backing;
     if (ownsTail) {
       const grown = new Uint8Array(backing, 0, needed);
-      grown.set(bytes2, length);
+      grown.set(bytes3, length);
       current2.data = grown;
     } else {
       const capacity = Math.max(needed, length * 2, 64 * 1024);
       const buffer = new ArrayBuffer(capacity);
       const grown = new Uint8Array(buffer, 0, needed);
       grown.set(current2.data);
-      grown.set(bytes2, length);
+      grown.set(bytes3, length);
       current2.data = grown;
       appendCapacity.set(current2, buffer);
     }
@@ -36721,9 +36965,9 @@ var MirroringVolume = class {
       } catch {
       }
       try {
-        const bytes2 = mirror.readFileSync(source);
+        const bytes3 = mirror.readFileSync(source);
         this.ensureDirectory(dirname(destination));
-        this.inner.writeFileSync(destination, bytes2);
+        this.inner.writeFileSync(destination, bytes3);
       } catch {
       }
     };
@@ -37105,9 +37349,9 @@ var OutboundTcp = class {
     const bridge = new VirtualTcpConnection({ address, port }, { address: local.address, port: local.port });
     guest.pairWith(bridge);
     bridge.pairWith(guest);
-    host2.onData((bytes2) => {
+    host2.onData((bytes3) => {
       try {
-        bridge.write(bytes2);
+        bridge.write(bytes3);
       } catch {
         host2.close();
       }
@@ -37162,9 +37406,9 @@ function createNodeTcpDialer() {
       let onClose = null;
       let closed = false;
       socket.on("data", (chunk) => {
-        const bytes2 = new Uint8Array(chunk);
-        if (onData) onData(bytes2);
-        else pending.push(bytes2);
+        const bytes3 = new Uint8Array(chunk);
+        if (onData) onData(bytes3);
+        else pending.push(bytes3);
       });
       const finish = () => {
         if (closed) return;
@@ -37183,8 +37427,8 @@ function createNodeTcpDialer() {
       socket.on("connect", () => {
         socket.setNoDelay(true);
         resolve3({
-          write(bytes2) {
-            socket.write(bytes2);
+          write(bytes3) {
+            socket.write(bytes3);
           },
           end() {
             socket.end();
@@ -37236,8 +37480,7 @@ function translate(error, host2, port) {
 
 // src/worker/local-runtime-pod.ts
 var WASM_ALIASES = {
-  esbuild: "esbuild-wasm",
-  rollup: "@rollup/wasm-node"
+  ...RUNTIME_PACKAGE_FALLBACKS
 };
 var ProcessExit = class extends Error {
   constructor(code) {
@@ -37397,7 +37640,7 @@ var PodChildProcess = class {
   /* The child is launched asynchronously, but a parent may write and close
    * its input synchronously right after spawning. Holding both until the
    * child exists is what keeps `echo hi | child` from losing the `hi`. */
-  pendingInput = "";
+  pendingInput = [];
   inputEnded = false;
   on(event, listener) {
     let set = this.listeners.get(event);
@@ -37421,15 +37664,13 @@ var PodChildProcess = class {
         (child) => {
           this.child = child;
           if (this.cancelled) child.kill();
-          if (this.pendingInput !== "") {
-            child.write(this.pendingInput);
-            this.pendingInput = "";
-          }
+          for (const chunk of this.pendingInput.splice(0)) child.write(chunk);
           if (this.inputEnded) child.endInput?.();
-          child.on("output", (chunk) => {
+          const outputEvent = child.rawOutput ? "raw-output" : "output";
+          child.on(outputEvent, (chunk) => {
             const text2 = typeof chunk === "string" ? chunk : this.outText.decode(chunk, { stream: true });
             this.stdout += text2;
-            this.emit("stdout", text2);
+            this.emit("stdout", chunk);
           });
           child.on("error", (chunk) => {
             const text2 = typeof chunk === "string" ? chunk : this.errText.decode(chunk, { stream: true });
@@ -37451,7 +37692,7 @@ var PodChildProcess = class {
   }
   sendStdin(data) {
     if (this.child) this.child.write(data);
-    else this.pendingInput += data;
+    else this.pendingInput.push(data);
   }
   /** Signal EOF, so a child reading stdin to the end can finish. */
   endStdin() {
@@ -37811,14 +38052,14 @@ ${headers.join("\r\n")}\r
 `);
     connection.write(request);
     if (body.length) connection.write(body);
-    const bytes2 = [];
+    const bytes3 = [];
     let combined = new Uint8Array();
     for (; ; ) {
       try {
         const chunk = connection.read(64 * 1024);
         if (chunk.length === 0) break;
-        bytes2.push(chunk);
-        combined = joinBytes(bytes2);
+        bytes3.push(chunk);
+        combined = joinBytes(bytes3);
         const headerEnd = findBytes(combined, new Uint8Array([13, 10, 13, 10]));
         if (headerEnd < 0) continue;
         const headerText = new TextDecoder().decode(combined.subarray(0, headerEnd));
@@ -37884,11 +38125,11 @@ function findBytes(haystack, needle) {
   }
   return -1;
 }
-function parseHttpResponse(bytes2) {
+function parseHttpResponse(bytes3) {
   const marker = new Uint8Array([13, 10, 13, 10]);
-  const headerEnd = findBytes(bytes2, marker);
+  const headerEnd = findBytes(bytes3, marker);
   if (headerEnd < 0) throw new Error("Python server returned an incomplete HTTP response");
-  const text2 = new TextDecoder().decode(bytes2.subarray(0, headerEnd));
+  const text2 = new TextDecoder().decode(bytes3.subarray(0, headerEnd));
   const lines = text2.split("\r\n");
   const status = /HTTP\/\d\.\d\s+(\d+)(?:\s+(.*))?/.exec(lines.shift() ?? "");
   if (!status) throw new Error("Python server returned an invalid HTTP status line");
@@ -37897,7 +38138,7 @@ function parseHttpResponse(bytes2) {
     const separator = line.indexOf(":");
     if (separator > 0) headers[line.slice(0, separator).toLowerCase()] = line.slice(separator + 1).trim();
   }
-  let body = bytes2.slice(headerEnd + marker.length);
+  let body = bytes3.slice(headerEnd + marker.length);
   if (CHUNKED.test(headers["transfer-encoding"] ?? "")) {
     body = decodeChunked(body).body;
     delete headers["transfer-encoding"];
@@ -37911,19 +38152,19 @@ function parseHttpResponse(bytes2) {
   };
 }
 var CHUNKED = /^(?:transfer-encoding:.*)?\bchunked\b/im;
-function decodeChunked(bytes2) {
+function decodeChunked(bytes3) {
   const parts = [];
   const crlf = new Uint8Array([13, 10]);
   for (let at = 0; ; ) {
-    const lineEnd = findBytes(bytes2.subarray(at), crlf);
+    const lineEnd = findBytes(bytes3.subarray(at), crlf);
     if (lineEnd < 0) return { body: joinBytes(parts), complete: false };
-    const header = new TextDecoder().decode(bytes2.subarray(at, at + lineEnd)).split(";")[0].trim();
+    const header = new TextDecoder().decode(bytes3.subarray(at, at + lineEnd)).split(";")[0].trim();
     const size = /^[0-9a-f]+$/i.test(header) ? Number.parseInt(header, 16) : Number.NaN;
     if (!Number.isInteger(size)) throw new Error("Python server returned an invalid chunked response");
     at += lineEnd + crlf.length;
     if (size === 0) return { body: joinBytes(parts), complete: true };
-    if (at + size + crlf.length > bytes2.length) return { body: joinBytes(parts), complete: false };
-    parts.push(bytes2.subarray(at, at + size));
+    if (at + size + crlf.length > bytes3.length) return { body: joinBytes(parts), complete: false };
+    parts.push(bytes3.subarray(at, at + size));
     at += size + crlf.length;
   }
 }
@@ -38106,7 +38347,7 @@ var WorkerProcess = class extends EventEmitter4 {
    */
   write(data) {
     if (this.inheritedInput) {
-      this.inheritedInput.sendStdin(typeof data === "string" ? data : new TextDecoder().decode(data));
+      this.inheritedInput.sendStdin(data);
       return;
     }
     if (this.started) this.worker.postMessage({ type: "stdin", data });
@@ -38270,7 +38511,9 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
           this.startChild(worker, children, message, ownedChildren);
           return;
         case "child-stdin":
-          children.get(message.id)?.sendStdin?.(String(message.data));
+          children.get(message.id)?.sendStdin?.(
+            message.data instanceof Uint8Array ? message.data : String(message.data)
+          );
           return;
         case "child-stdin-end":
           children.get(message.id)?.endStdin?.();
@@ -38312,20 +38555,22 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
           return;
       }
     });
-    worker.postMessage({
-      type: "start",
-      buffers,
-      script,
-      cwd,
-      env: env2,
-      argv: Array.isArray(options.argv) ? options.argv : ["/usr/bin/node", script, ...args.slice(1)],
-      aliases: this.aliases,
-      ...typeof options.stdinPath === "string" ? { stdinPath: options.stdinPath } : {},
-      ...options.interactiveStdin ? { interactiveStdin: true } : {},
-      ...options.tty ? { tty: true } : {},
-      ...this.networkPolicy ? { network: this.networkPolicy } : {}
-    });
-    process2.begin();
+    setTimeout(() => {
+      worker.postMessage({
+        type: "start",
+        buffers,
+        script,
+        cwd,
+        env: env2,
+        argv: Array.isArray(options.argv) ? options.argv : ["/usr/bin/node", script, ...args.slice(1)],
+        aliases: this.aliases,
+        ...typeof options.stdinPath === "string" ? { stdinPath: options.stdinPath } : {},
+        ...options.interactiveStdin ? { interactiveStdin: true } : {},
+        ...options.tty ? { tty: true } : {},
+        ...this.networkPolicy ? { network: this.networkPolicy } : {}
+      });
+      process2.begin();
+    }, 0);
     return process2;
   }
   /** Start an asynchronous child on the host's behalf and relay its events. */
@@ -38363,16 +38608,20 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
       handle.on("exit", () => owned.delete(handle));
       let stdout = "";
       let stderr = "";
+      const stdoutDecoder = new TextDecoder();
+      const stderrDecoder = new TextDecoder();
       const live = request.inheritStdio ? streamTo : null;
       const restoreInput = live?.inheritInput(handle);
       if (restoreInput) handle.on("exit", restoreInput);
-      handle.on("stdout", (text2) => {
+      handle.on("stdout", (value) => {
+        const text2 = typeof value === "string" ? value : stdoutDecoder.decode(value, { stream: true });
         stdout += text2;
-        live?.output(text2);
+        live?.output(value);
       });
-      handle.on("stderr", (text2) => {
+      handle.on("stderr", (value) => {
+        const text2 = typeof value === "string" ? value : stderrDecoder.decode(value, { stream: true });
         stderr += text2;
-        live?.error(text2);
+        live?.error(value);
       });
       handle.on("exit", (code) => resolve3({ status: code, stdout, stderr, signal: null }));
       handle.exec();
@@ -38443,8 +38692,8 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
     const id = this.nextRequestId++;
     this.upgraded.set(id, socket);
     socket.on("data", (chunk) => {
-      const bytes2 = new Uint8Array(chunk);
-      worker.postMessage({ type: "ws-data", id, data: bytes2 });
+      const bytes3 = new Uint8Array(chunk);
+      worker.postMessage({ type: "ws-data", id, data: bytes3 });
     });
     const drop = () => {
       if (!this.upgraded.delete(id)) return;
@@ -38584,7 +38833,8 @@ var Container = class _Container {
     const network = {
       allowOutbound: opts.network?.allowOutbound ?? false,
       allowedHosts: opts.network?.allowedHosts ?? null,
-      ...opts.network?.proxy ? { proxy: opts.network.proxy } : {}
+      ...opts.network?.proxy ? { proxy: opts.network.proxy } : {},
+      ...opts.network?.secrets ? { secrets: opts.network.secrets } : {}
     };
     const podOptions = {
       workdir: opts.cwd ?? "/",
@@ -38900,17 +39150,17 @@ var Container = class _Container {
       body: init.body ?? null
     });
     const bodyRaw = res.body;
-    const bytes2 = bodyRaw instanceof Uint8Array ? bodyRaw : (
+    const bytes3 = bodyRaw instanceof Uint8Array ? bodyRaw : (
       // The binary dispatcher answers with an ArrayBuffer.
       bodyRaw instanceof ArrayBuffer ? new Uint8Array(bodyRaw) : typeof bodyRaw === "string" ? new TextEncoder().encode(bodyRaw) : new Uint8Array(0)
     );
-    const body = typeof bodyRaw === "string" ? bodyRaw : new TextDecoder().decode(bytes2);
+    const body = typeof bodyRaw === "string" ? bodyRaw : new TextDecoder().decode(bytes3);
     return {
       status: res.statusCode ?? 200,
       statusText: res.statusMessage ?? "",
       headers: res.headers ?? {},
       body,
-      bytes: bytes2,
+      bytes: bytes3,
       json() {
         return JSON.parse(body);
       }
@@ -39543,7 +39793,7 @@ function serveContainerOn(port, box) {
         headers: request.headers,
         ...request.body ? { body: new Uint8Array(request.body) } : {}
       });
-      const bytes2 = response.bytes.slice();
+      const bytes3 = response.bytes.slice();
       port.postMessage(
         {
           id: request.id,
@@ -39551,10 +39801,10 @@ function serveContainerOn(port, box) {
             status: response.status,
             statusText: response.statusText,
             headers: response.headers,
-            body: bytes2.buffer
+            body: bytes3.buffer
           }
         },
-        [bytes2.buffer]
+        [bytes3.buffer]
       );
     } catch (error) {
       const message = new TextEncoder().encode(error instanceof Error ? error.message : String(error));
@@ -39640,8 +39890,8 @@ async function createPreview(box, options = {}) {
           Number(data.port),
           { method: "GET", path: data.path ?? "/", headers: data.headers ?? {} },
           {
-            data: (bytes2) => {
-              const carrier = bytes2.slice().buffer;
+            data: (bytes3) => {
+              const carrier = bytes3.slice().buffer;
               reply({ type: WS_DATA, id, data: carrier }, [carrier]);
             },
             close: () => {
@@ -39723,8 +39973,8 @@ function gitFilesystem(ctx) {
   const encoding = (opts) => typeof opts === "string" ? opts : opts?.encoding;
   return { promises: {
     async readFile(path, opts) {
-      const bytes2 = Buffer2.from(ctx.vfs.readFile(ctx.path(path), ctx.cred));
-      return encoding(opts) ? bytes2.toString(encoding(opts)) : bytes2;
+      const bytes3 = Buffer2.from(ctx.vfs.readFile(ctx.path(path), ctx.cred));
+      return encoding(opts) ? bytes3.toString(encoding(opts)) : bytes3;
     },
     async writeFile(path, data, opts) {
       ctx.vfs.writeFile(ctx.path(path), data, { cred: ctx.cred, mode: opts?.mode });
@@ -39916,8 +40166,8 @@ var signed = (value) => {
   }
 };
 var str = (s) => {
-  const bytes2 = [...new TextEncoder().encode(s)];
-  return [...leb(bytes2.length), ...bytes2];
+  const bytes3 = [...new TextEncoder().encode(s)];
+  return [...leb(bytes3.length), ...bytes3];
 };
 var section = (id, data) => [id, ...leb(data.length), ...data];
 function compileInstruction({ op, next }) {