sandboxedjs 0.1.93 → 0.1.94

package/dist/index.cjs

@@ -19821,6 +19821,7 @@ var Op = {
   setsockopt: 1802,
   getsockopt: 1803,
   socket_close: 1804,
+  resolve: 1805,
   spawn: 2048,
   waitpid: 2049,
   kill: 2050
@@ -20057,6 +20058,28 @@ var wheels_default = {
         patches: []
       }
     },
+    {
+      name: "asyncpg",
+      version: "0.31.0",
+      filename: "asyncpg-0.31.0-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "3eaf965cbd78d2314e8f12b9384e5642725323063aaff2708a8a4b3c01ef10ba",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [
+        'async_timeout>=4.0.3; python_version < "3.11.0"',
+        'gssapi; platform_system != "Windows" and extra == "gssauth"',
+        'sspilib; platform_system == "Windows" and extra == "gssauth"'
+      ],
+      provenance: {
+        sourceTreeDigest: "a9ab0177da5c0c2d0ba635d1f5568687efbf8aefc08cd51cd086277184eba76f",
+        recipeSha256: "fb9cf1a9fd35d8d63ac69dcf6a1671ceeebcb23f381a100b412058d75ff2eedc",
+        buildTools: [
+          "setuptools==84.0.0",
+          "Cython==3.1.4"
+        ],
+        nativeDependencies: [],
+        patches: []
+      }
+    },
     {
       name: "bcrypt",
       version: "5.0.0",
@@ -20078,18 +20101,20 @@ var wheels_default = {
       name: "brotli",
       version: "1.2.0",
       filename: "brotli-1.2.0-cp313-cp313-emscripten_5_0_6_wasm32.whl",
-      sha256: "b67d1b9169ba3e0790d04b8020adb1a58f0b89f8961aca360dca5f020de07a21",
+      sha256: "d8b06cc04770a048b41956c9cc767e7332c49f0229e69744f4b1c2892b888b27",
       abiId: "sbxabi1-c2637d04695ad927",
       requires: [],
       provenance: {
         sourceTreeDigest: "7b563fa2e7f20edac204cc80004cae35c844b36a83758e5957184383332d1209",
-        recipeSha256: "09bf4f6072d637866a6b3c3deaec419dc3ff8a32a6f3b0813f57e06316bfcf39",
+        recipeSha256: "1326c898e999feba536ff15f080fed9ac4b9cd14e0dbfee39a950decf19607ef",
         buildTools: [
           "setuptools==84.0.0",
           "pkgconfig==1.6.0"
         ],
         nativeDependencies: [],
-        patches: []
+        patches: [
+          "0001-meth-noargs-signatures.patch"
+        ]
       }
     },
     {
@@ -20150,6 +20175,25 @@ var wheels_default = {
         patches: []
       }
     },
+    {
+      name: "google-crc32c",
+      version: "1.8.0",
+      filename: "google_crc32c-1.8.0-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "e64c21841598ea21121d7b7bb203e124d58c035db49ffce03631c55216c942cd",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [],
+      provenance: {
+        sourceTreeDigest: "fa277032a78adfccf6adcda32cadc4f6958a324979040c231e01f0963821cb75",
+        recipeSha256: "843dea57727061bdfc7bcd27ac380d16a767effa538cbab6257e106939689f43",
+        buildTools: [
+          "setuptools==84.0.0"
+        ],
+        nativeDependencies: [
+          "crc32c==1.1.2"
+        ],
+        patches: []
+      }
+    },
     {
       name: "httptools",
       version: "0.8.0",
@@ -20186,6 +20230,32 @@ var wheels_default = {
         patches: []
       }
     },
+    {
+      name: "lxml",
+      version: "6.1.3",
+      filename: "lxml-6.1.3-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "dc76d45314b806934bdaf35f9e4ae61e86e741e07bac53fae7e94f9d3dab9d4e",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [
+        'cssselect>=0.7; extra == "cssselect"',
+        'html5lib; extra == "html5"',
+        'BeautifulSoup4; extra == "htmlsoup"',
+        'lxml_html_clean; extra == "html-clean"'
+      ],
+      provenance: {
+        sourceTreeDigest: "aedea680c1fe58ae9a124d81ea28f2316765e444e3809691854ddbf173c22bf5",
+        recipeSha256: "aa62da97bb13eb5fa0a047f7c61ed93554f60142be9fcae64e3053e2a5673e9f",
+        buildTools: [
+          "setuptools==84.0.0",
+          "Cython==3.1.4"
+        ],
+        nativeDependencies: [
+          "xml2==2.13.8",
+          "xslt==1.1.43"
+        ],
+        patches: []
+      }
+    },
     {
       name: "lz4",
       version: "4.4.5",
@@ -20287,6 +20357,113 @@ var wheels_default = {
         ]
       }
     },
+    {
+      name: "pandas",
+      version: "3.0.5",
+      filename: "pandas-3.0.5-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "ae36ad9b403b6fc28cb2bb79f54a38e1897ab43635c596fff2bce87f8148ac48",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [
+        'numpy>=1.26.0; python_version < "3.14"',
+        'numpy>=2.3.3; python_version >= "3.14"',
+        "python-dateutil>=2.8.2",
+        'tzdata; sys_platform == "win32"',
+        'tzdata; sys_platform == "emscripten"',
+        'hypothesis>=6.116.0; extra == "test"',
+        'pytest<9.1,>=8.3.4; extra == "test"',
+        'pytest-xdist>=3.6.1; extra == "test"',
+        'pyarrow>=13.0.0; extra == "pyarrow"',
+        'bottleneck>=1.4.2; extra == "performance"',
+        'numba>=0.60.0; extra == "performance"',
+        'numexpr>=2.10.2; extra == "performance"',
+        'scipy>=1.14.1; extra == "computation"',
+        'xarray>=2024.10.0; extra == "computation"',
+        'fsspec>=2024.10.0; extra == "fss"',
+        's3fs>=2024.10.0; extra == "aws"',
+        'gcsfs>=2024.10.0; extra == "gcp"',
+        'odfpy>=1.4.1; extra == "excel"',
+        'openpyxl>=3.1.5; extra == "excel"',
+        'python-calamine>=0.3.0; extra == "excel"',
+        'pyxlsb>=1.0.10; extra == "excel"',
+        'xlrd>=2.0.1; extra == "excel"',
+        'xlsxwriter>=3.2.0; extra == "excel"',
+        'pyarrow>=13.0.0; extra == "parquet"',
+        'pyarrow>=13.0.0; extra == "feather"',
+        'pyiceberg>=0.8.1; extra == "iceberg"',
+        'tables>=3.10.1; extra == "hdf5"',
+        'pyreadstat>=1.2.8; extra == "spss"',
+        'SQLAlchemy>=2.0.36; extra == "postgresql"',
+        'psycopg2>=2.9.10; extra == "postgresql"',
+        'adbc-driver-postgresql>=1.2.0; extra == "postgresql"',
+        'SQLAlchemy>=2.0.36; extra == "mysql"',
+        'pymysql>=1.1.1; extra == "mysql"',
+        'SQLAlchemy>=2.0.36; extra == "sql-other"',
+        'adbc-driver-postgresql>=1.2.0; extra == "sql-other"',
+        'adbc-driver-sqlite>=1.2.0; extra == "sql-other"',
+        'beautifulsoup4>=4.12.3; extra == "html"',
+        'html5lib>=1.1; extra == "html"',
+        'lxml>=5.3.0; extra == "html"',
+        'lxml>=5.3.0; extra == "xml"',
+        'matplotlib>=3.9.3; extra == "plot"',
+        'jinja2>=3.1.5; extra == "output-formatting"',
+        'tabulate>=0.9.0; extra == "output-formatting"',
+        'PyQt5>=5.15.9; extra == "clipboard"',
+        'qtpy>=2.4.2; extra == "clipboard"',
+        'zstandard>=0.23.0; extra == "compression"',
+        'pytz>=2020.1; extra == "timezone"',
+        'adbc-driver-postgresql>=1.2.0; extra == "all"',
+        'adbc-driver-sqlite>=1.2.0; extra == "all"',
+        'beautifulsoup4>=4.12.3; extra == "all"',
+        'bottleneck>=1.4.2; extra == "all"',
+        'fastparquet>=2024.11.0; extra == "all"',
+        'fsspec>=2024.10.0; extra == "all"',
+        'gcsfs>=2024.10.0; extra == "all"',
+        'html5lib>=1.1; extra == "all"',
+        'hypothesis>=6.116.0; extra == "all"',
+        'jinja2>=3.1.5; extra == "all"',
+        'lxml>=5.3.0; extra == "all"',
+        'matplotlib>=3.9.3; extra == "all"',
+        'numba>=0.60.0; extra == "all"',
+        'numexpr>=2.10.2; extra == "all"',
+        'odfpy>=1.4.1; extra == "all"',
+        'openpyxl>=3.1.5; extra == "all"',
+        'psycopg2>=2.9.10; extra == "all"',
+        'pyarrow>=13.0.0; extra == "all"',
+        'pyiceberg>=0.8.1; extra == "all"',
+        'pymysql>=1.1.1; extra == "all"',
+        'PyQt5>=5.15.9; extra == "all"',
+        'pyreadstat>=1.2.8; extra == "all"',
+        'pytest>=8.3.4; extra == "all"',
+        'pytest-xdist>=3.6.1; extra == "all"',
+        'python-calamine>=0.3.0; extra == "all"',
+        'pytz>=2020.1; extra == "all"',
+        'pyxlsb>=1.0.10; extra == "all"',
+        'qtpy>=2.4.2; extra == "all"',
+        'scipy>=1.14.1; extra == "all"',
+        's3fs>=2024.10.0; extra == "all"',
+        'SQLAlchemy>=2.0.36; extra == "all"',
+        'tables>=3.10.1; extra == "all"',
+        'tabulate>=0.9.0; extra == "all"',
+        'xarray>=2024.10.0; extra == "all"',
+        'xlrd>=2.0.1; extra == "all"',
+        'xlsxwriter>=3.2.0; extra == "all"',
+        'zstandard>=0.23.0; extra == "all"'
+      ],
+      provenance: {
+        sourceTreeDigest: "373f08151b5a209a84dd35b086316ef11a0d4030150457c2bfdab38305903d54",
+        recipeSha256: "56976ed58b17053971334a62b503d5397b8ff739911fb596a116df23aeccabb0",
+        buildTools: [
+          "setuptools==84.0.0",
+          "Cython==3.1.4",
+          "meson-python==0.21.0",
+          "meson==1.12.0",
+          "ninja==1.13.2",
+          "versioneer==0.29"
+        ],
+        nativeDependencies: [],
+        patches: []
+      }
+    },
     {
       name: "pillow",
       version: "12.3.0",
@@ -20391,6 +20568,31 @@ var wheels_default = {
         patches: []
       }
     },
+    {
+      name: "rapidfuzz",
+      version: "3.14.6",
+      filename: "rapidfuzz-3.14.6-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "b9ed2ea058350925beda765364c0f382bf9a7c08b3bec33840795178de021d32",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [
+        'numpy; extra == "all"'
+      ],
+      provenance: {
+        sourceTreeDigest: "ae2b2bb95f7aba2babbbe668b68d48b5347ca923e6508b76d24228cd13ac7cd3",
+        recipeSha256: "46954814226fff070aa6771d2f09d32a96b718ce8ef7a9f9404375850f7d1f77",
+        buildTools: [
+          "setuptools==84.0.0",
+          "scikit-build-core==1.0.3",
+          "cmake==4.4.3",
+          "ninja==1.13.2",
+          "Cython==3.1.4",
+          "pathspec==1.1.1",
+          "packaging==26.3"
+        ],
+        nativeDependencies: [],
+        patches: []
+      }
+    },
     {
       name: "regex",
       version: "2026.9.10",
@@ -20756,7 +20958,7 @@ var wheels_default = {
 
 // package.json
 var package_default = {
-  version: "0.1.93"};
+  version: "0.1.94"};
 
 // src/python/extension-abi.ts
 var EXTENSION_ABI = {
@@ -21794,6 +21996,8 @@ var VirtualTcpSocket = class _VirtualTcpSocket {
   network;
   listenerValue = null;
   connectionValue = null;
+  /** Held so closing the guest's socket closes the host's, not just the queues. */
+  hostConnection = null;
   boundPort = 0;
   boundAddress = "0.0.0.0";
   bind(address, port) {
@@ -21811,13 +22015,35 @@ var VirtualTcpSocket = class _VirtualTcpSocket {
     }
     this.listenerValue = this.network.listen(this.boundPort, this.boundAddress, backlog);
   }
-  connect(port, address = "127.0.0.1") {
+  /**
+   * Connect, in the container or out of it.
+   *
+   * The destination used to be discarded, which quietly turned every connect
+   * into a loopback connect: a guest dialling example.com:443 would reach a
+   * container server listening on 443 and believe it had reached the internet.
+   * Loopback is still routed inside the container; anything else goes to the
+   * host's outbound stack, which owns the names and the real sockets, and
+   * which refuses with a reason when the host has no way out.
+   */
+  async connect(port, address = "127.0.0.1") {
     if (this.listenerValue || this.connectionValue) throw new PosixError(Errno.EISCONN);
     if (!isLoopback(address)) {
-      throw new PosixError(
-        Errno.ENETUNREACH,
-        `cannot reach ${address}:${port}: outbound network access is not available through raw sockets in this container; only loopback is routed`
-      );
+      const outbound = this.network.outbound;
+      if (!outbound) {
+        throw new PosixError(
+          Errno.ENETUNREACH,
+          `cannot reach ${address}:${port}: outbound network access is not available through raw sockets in this container; only loopback is routed`
+        );
+      }
+      const dialled = await outbound.connect(address, port, {
+        address: this.boundAddress,
+        port: this.boundPort
+      });
+      this.connectionValue = dialled.connection;
+      this.hostConnection = dialled.host;
+      this.boundPort = dialled.connection.local.port;
+      this.boundAddress = dialled.connection.local.address;
+      return;
     }
     this.connectionValue = this.network.connect(port, this.boundPort, this.boundAddress);
     this.boundPort = this.connectionValue.local.port;
@@ -21868,6 +22094,8 @@ var VirtualTcpSocket = class _VirtualTcpSocket {
   close() {
     if (this.listenerValue) this.network.close(this.listenerValue);
     this.connectionValue?.close();
+    this.hostConnection?.close();
+    this.hostConnection = null;
     this.listenerValue = null;
     this.connectionValue = null;
   }
@@ -21932,7 +22160,7 @@ var SocketDescription = class _SocketDescription {
     this.resource.listen(backlog);
   }
   connect(address, port) {
-    this.resource.connect(port, address);
+    return this.resource.connect(port, address);
   }
   accept() {
     return new _SocketDescription(this.resource.accept(), this.flags);
@@ -21944,7 +22172,11 @@ var SocketDescription = class _SocketDescription {
     this.options.set(`${level}:${option}`, value.slice());
   }
   getOption(level, option) {
-    return this.options.get(`${level}:${option}`)?.slice() ?? new Uint8Array(4);
+    const stored = this.options.get(`${level}:${option}`);
+    if (stored) return stored.slice();
+    if (level === SOL_SOCKET && option === SO_TYPE) return int32(SOCK_STREAM);
+    if (level === SOL_SOCKET && option === SO_ERROR) return int32(0);
+    return new Uint8Array(4);
   }
   localAddress() {
     return this.resource.local;
@@ -21955,6 +22187,15 @@ var SocketDescription = class _SocketDescription {
     return peer;
   }
 };
+var SOL_SOCKET = 1;
+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;
+}
 function isLoopback(address) {
   if (address === "" || address === "localhost" || address === "0.0.0.0") return true;
   if (address === "::1" || address === "::" || address === "[::1]") return true;
@@ -21966,6 +22207,18 @@ var VirtualTcpNetwork = class {
   }
   occupied;
   listeners = /* @__PURE__ */ new Map();
+  /** The host's outbound stack, when this host can open sockets at all. */
+  outbound = null;
+  /**
+   * Ports held by in-container servers that are not sockets.
+   *
+   * A JavaScript HTTP server in the container is registered with the request
+   * router and never binds one of these sockets, so a guest connecting to its
+   * port found nothing listening. Before sockets could leave the container
+   * this did not arise -- every guest client went out through the egress --
+   * and afterwards `urllib` dialling a container server got ECONNREFUSED.
+   */
+  loopbackHttp = null;
   listen(port, address = "0.0.0.0", backlog = 128) {
     if (this.listeners.has(port) || this.occupied?.(port)) throw new PosixError(Errno.EADDRINUSE, `port ${port} is already in use`);
     const listener = new VirtualTcpListener(port, address, backlog);
@@ -21979,7 +22232,11 @@ var VirtualTcpNetwork = class {
   }
   connect(port, localPort = 0, localAddress = "127.0.0.1") {
     const listener = this.listeners.get(port);
-    if (!listener || listener.isClosed) throw new PosixError(Errno.ECONNREFUSED, `port ${port} is not listening`);
+    if (!listener || listener.isClosed) {
+      const bridged = this.connectToNonSocketServer(port, localPort, localAddress);
+      if (bridged) return bridged;
+      throw new PosixError(Errno.ECONNREFUSED, `port ${port} is not listening`);
+    }
     const client = new VirtualTcpConnection(
       { address: localAddress, port: localPort },
       { address: listener.address, port }
@@ -21993,6 +22250,26 @@ var VirtualTcpNetwork = class {
     listener.enqueue(server);
     return client;
   }
+  /** A connection to a port an in-container server holds without a socket. */
+  connectToNonSocketServer(port, localPort, localAddress) {
+    if (!this.loopbackHttp) return null;
+    const client = new VirtualTcpConnection(
+      { address: localAddress, port: localPort },
+      { address: "127.0.0.1", port }
+    );
+    const server = new VirtualTcpConnection(
+      { address: "127.0.0.1", port },
+      { address: localAddress, port: localPort }
+    );
+    client.pairWith(server);
+    server.pairWith(client);
+    if (!this.loopbackHttp(port, server)) {
+      client.close();
+      server.close();
+      return null;
+    }
+    return client;
+  }
   hasListener(port) {
     return this.listeners.has(port);
   }
@@ -22010,7 +22287,7 @@ var POLLIN = 1;
 var POLLOUT = 4;
 var POLLHUP = 16;
 var AF_INET = 2;
-var SOCK_STREAM = 1;
+var SOCK_STREAM2 = 1;
 var IPPROTO_TCP = 6;
 function createHostAbiServer(proc) {
   const files = new FileService(proc.vfs, proc.cred);
@@ -22301,7 +22578,7 @@ function createHostAbiServer(proc) {
         const family = r.u32();
         const type = r.u32();
         const protocol = r.i32();
-        if (family !== AF_INET || (type & 15) !== SOCK_STREAM) throw new PosixError(Errno.EAFNOSUPPORT);
+        if (family !== AF_INET || (type & 15) !== SOCK_STREAM2) throw new PosixError(Errno.EAFNOSUPPORT);
         if (protocol !== 0 && protocol !== IPPROTO_TCP) throw new PosixError(Errno.EPROTONOSUPPORT);
         if (!proc.sockets) throw new PosixError(Errno.ENOSYS);
         return { status: proc.table.add(new SocketDescription(new VirtualTcpSocket(proc.sockets))) };
@@ -22325,9 +22602,15 @@ function createHostAbiServer(proc) {
       }
       case Op.connect: {
         const description = socketDescription(proc.table.get(r.i32()));
-        description.connect(r.string(), r.u32());
+        await description.connect(r.string(), r.u32());
         return { status: 0 };
       }
+      case Op.resolve: {
+        const sockets = proc.sockets;
+        if (!sockets?.outbound) throw new PosixError(Errno.ENOSYS);
+        const address = sockets.outbound.resolve(r.string());
+        return { status: 0, payload: new Writer().string(address).finish() };
+      }
       case Op.send: {
         const description = socketDescription(proc.table.get(r.i32()));
         return { status: await writeBlocking(description, r.bytes32()) };
@@ -22885,6 +23168,32 @@ async function serve(ctx, connection) {
     connection.close();
   }
 }
+async function serveHttpOverConnection(connection, handle) {
+  try {
+    const request = await readRequest(connection);
+    if (!request) {
+      writeResponse(connection, 400, "Bad Request", {}, new TextEncoder().encode("malformed request\n"));
+      return;
+    }
+    const result = await handle(request);
+    writeResponse(connection, result.status, result.statusText, result.headers, result.body);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    try {
+      writeResponse(
+        connection,
+        502,
+        "Bad Gateway",
+        { "x-sbx-error": "1" },
+        new TextEncoder().encode(`${message}
+`)
+      );
+    } catch {
+    }
+  } finally {
+    connection.close();
+  }
+}
 var listeners = /* @__PURE__ */ new WeakMap();
 function ensureHttpEgress(ctx) {
   const sockets = ctx.kernel.pod.sockets;
@@ -23415,7 +23724,7 @@ async function resolve2(options) {
     if (viable.length === 0) {
       const wanted = [...unusable.get(name)?.versions ?? []].filter((version) => clauses.every((s) => compareVersions(version, s.version, s.op)));
       const nothingUsable = all.length === 0 || wanted.length > 0;
-      const error2 = new ResolutionError(
+      const error = new ResolutionError(
         nothingUsable ? `no distribution of ${name}${all.length > 0 ? ` ${newest(wanted)}` : ""} is usable by this runtime (it needs a pure-Python wheel or one tagged ${WHEEL_TAG})` : `no version of ${name} satisfies every requirement`,
         explain(name, next.constraints, null, all),
         nothingUsable ? {
@@ -23427,8 +23736,8 @@ async function resolve2(options) {
           sourceAvailable: unusable.get(name)?.sourceAvailable ?? false
         } : { reason: "conflicting-requirements", package: name }
       );
-      nogoods.set(signature, error2);
-      throw error2;
+      nogoods.set(signature, error);
+      throw error;
     }
     let failure2 = null;
     const seenVersions = /* @__PURE__ */ new Set();
@@ -23440,9 +23749,9 @@ async function resolve2(options) {
       let requires;
       try {
         requires = await requiresFor(candidate);
-      } catch (error2) {
+      } catch (error) {
         failure2 = new ResolutionError(
-          `could not read the dependencies of ${name} ${candidate.version}: ${error2.message}`
+          `could not read the dependencies of ${name} ${candidate.version}: ${error.message}`
         );
         continue;
       }
@@ -23466,15 +23775,13 @@ async function resolve2(options) {
       chosen.set(name, { ...candidate, requires });
       try {
         return await search([...edges, ...rest], { chosen, constraints: next.constraints });
-      } catch (error2) {
-        if (!(error2 instanceof ResolutionError)) throw error2;
-        if (/cancelled|budget/.test(error2.message)) throw error2;
-        failure2 = error2;
+      } catch (error) {
+        if (!(error instanceof ResolutionError)) throw error;
+        if (/cancelled|budget/.test(error.message)) throw error;
+        failure2 = error;
       }
     }
-    const error = failure2 ?? new ResolutionError(`could not resolve ${name}`);
-    nogoods.set(signature, error);
-    throw error;
+    throw failure2 ?? new ResolutionError(`could not resolve ${name}`);
   };
   const seeded = /* @__PURE__ */ new Map();
   for (const root of roots) {
@@ -23980,8 +24287,18 @@ async function runOwnedPython(ctx, argv) {
   if (!manifest) throw new Error("no Python runtime manifest is configured");
   const mounts = containerMounts(ctx);
   const env2 = withSitePackages(ctx.env);
+  await ensureTrustStore(ctx);
   const egressPort = ensureHttpEgress(ctx);
   if (egressPort > 0) env2[EGRESS_ENV] = `127.0.0.1:${egressPort}`;
+  try {
+    if (ctx.vfs.stat(CA_BUNDLE_PATH, { cred: ctx.cred }).size > 0) {
+      env2.SSL_CERT_FILE = CA_BUNDLE_PATH;
+      env2.SSL_CERT_DIR = "/etc/ssl/certs";
+      env2.REQUESTS_CA_BUNDLE = CA_BUNDLE_PATH;
+    }
+  } catch {
+  }
+  if (ctx.kernel.pod.sockets?.outbound) env2.SBX_OUTBOUND_SOCKETS = "1";
   env2.SBX_SERIAL_HOST_CALLS = "1";
   const inherit = claimInheritance(env2);
   const process2 = await startPythonProcess({
@@ -24022,6 +24339,200 @@ function isTerminal(ctx) {
   const stdin = ctx.stdin;
   return Boolean(stdin.isTTY || stdin.interactive);
 }
+var TLS_MODULE_SOURCE = `"""TLS over a SandboxedJs socket, using this interpreter's own OpenSSL.
+
+CPython's \`ssl\` cannot wrap one of these sockets directly: \`_ssl\` wants a real
+\`_socket.socket\` whose descriptor OpenSSL can read and write, and a socket here
+is a host resource reached through the SandboxedJs ABI. But OpenSSL does not
+need a descriptor -- \`SSLContext.wrap_bio\` drives the same protocol over a pair
+of memory buffers, which is how asyncio has always done TLS. So the handshake
+and every record are performed here, in the container, and only the ciphertext
+crosses to the host. Certificates are verified by this interpreter against the
+trust store the host writes into the image, and \`getpeercert\` answers.
+"""
+
+import io
+import socket as _socket_module
+import ssl as _ssl
+
+
+def wrappable(sock):
+    """Whether this socket is one of the container's own."""
+    target = getattr(sock, "_sock", sock)
+    return hasattr(target, "_fd")
+
+
+class SbxTlsSocket:
+    """What \`SSLContext.wrap_socket\` returns for a container socket."""
+
+    def __init__(self, context, sock, server_hostname, suppress_ragged_eofs=True):
+        self._sock = sock
+        self.context = context
+        self.server_hostname = server_hostname
+        self.suppress_ragged_eofs = suppress_ragged_eofs
+        self._incoming = _ssl.MemoryBIO()
+        self._outgoing = _ssl.MemoryBIO()
+        self._closed = False
+        self._tls = context.wrap_bio(
+            self._incoming, self._outgoing,
+            server_side=False,
+            server_hostname=server_hostname,
+        )
+
+    # -- moving bytes between OpenSSL and the socket ------------------------
+    def _flush(self):
+        data = self._outgoing.read()
+        if data:
+            self._sock.sendall(data)
+
+    def _feed(self):
+        chunk = self._sock.recv(32768)
+        if not chunk:
+            self._incoming.write_eof()
+            return False
+        self._incoming.write(chunk)
+        return True
+
+    def _run(self, operation):
+        """Drive one OpenSSL operation, pumping the socket as it asks."""
+        while True:
+            try:
+                result = operation()
+            except _ssl.SSLWantReadError:
+                self._flush()
+                if not self._feed():
+                    raise
+                continue
+            except _ssl.SSLWantWriteError:
+                self._flush()
+                continue
+            self._flush()
+            return result
+
+    # -- the handshake ------------------------------------------------------
+    def do_handshake(self, block=False):
+        self._run(self._tls.do_handshake)
+
+    # -- the socket ---------------------------------------------------------
+    def recv(self, length=1024, flags=0):
+        if flags:
+            raise OSError("socket flags are not supported")
+        try:
+            return self._run(lambda: self._tls.read(length))
+        except _ssl.SSLZeroReturnError:
+            return b""
+        except _ssl.SSLWantReadError:
+            # The peer closed without close_notify. Ragged, and normal enough
+            # on the public internet that clients ask to tolerate it.
+            if self.suppress_ragged_eofs:
+                return b""
+            raise
+
+    def recv_into(self, buffer, nbytes=0, flags=0):
+        data = self.recv(nbytes or len(buffer), flags)
+        buffer[:len(data)] = data
+        return len(data)
+
+    def read(self, length=1024, buffer=None):
+        if buffer is not None:
+            return self.recv_into(buffer, length)
+        return self.recv(length)
+
+    def send(self, data, flags=0):
+        if flags:
+            raise OSError("socket flags are not supported")
+        return self._run(lambda: self._tls.write(data))
+
+    def sendall(self, data, flags=0):
+        view = memoryview(data)
+        while view:
+            view = view[self.send(view, flags):]
+
+    def write(self, data):
+        return self.send(data)
+
+    _io_refs = 0
+
+    def _decref_socketios(self):
+        # socket.SocketIO calls this when a file object built on this socket is
+        # closed; without it http.client failed with "no attribute
+        # _decref_socketios" the moment it read a response.
+        if self._io_refs > 0:
+            self._io_refs -= 1
+
+    def makefile(self, mode="r", buffering=None, *, encoding=None, errors=None, newline=None):
+        # http.client and everything built on it read the response through a
+        # file object, so this has to work like socket.makefile does.
+        raw = _socket_module.SocketIO(self, "rw" if "w" in mode else "r")
+        self._io_refs += 1
+        buffer = io.BufferedRWPair(raw, raw) if "w" in mode and "r" in mode else (
+            io.BufferedWriter(raw) if "w" in mode else io.BufferedReader(raw)
+        )
+        if "b" in mode:
+            return buffer
+        text = io.TextIOWrapper(buffer, encoding, errors, newline)
+        text.mode = mode
+        return text
+
+    def settimeout(self, value): return self._sock.settimeout(value)
+    def gettimeout(self): return self._sock.gettimeout()
+    def setblocking(self, flag): return self._sock.setblocking(flag)
+    def getblocking(self): return self._sock.getblocking()
+    def setsockopt(self, *args): return self._sock.setsockopt(*args)
+    def getsockopt(self, *args): return self._sock.getsockopt(*args)
+    def fileno(self): return self._sock.fileno()
+    def getpeername(self): return self._sock.getpeername()
+    def getsockname(self): return self._sock.getsockname()
+    def detach(self): return self._sock.detach()
+
+    def shutdown(self, how):
+        return self._sock.shutdown(how)
+
+    def unwrap(self):
+        self._run(self._tls.unwrap)
+        return self._sock
+
+    def close(self):
+        if not self._closed:
+            self._closed = True
+            self._sock.close()
+
+    def __enter__(self): return self
+    def __exit__(self, *args): self.close()
+
+    @property
+    def family(self): return getattr(self._sock, "family", _socket_module.AF_INET)
+    @property
+    def type(self): return getattr(self._sock, "type", _socket_module.SOCK_STREAM)
+    @property
+    def proto(self): return getattr(self._sock, "proto", 0)
+    @property
+    def session(self): return self._tls.session
+    @session.setter
+    def session(self, value): self._tls.session = value
+    @property
+    def session_reused(self): return self._tls.session_reused
+
+    # -- what OpenSSL knows about this connection ---------------------------
+    def getpeercert(self, binary_form=False): return self._tls.getpeercert(binary_form)
+    def get_unverified_chain(self): return self._tls.get_unverified_chain()
+    def get_verified_chain(self): return self._tls.get_verified_chain()
+    def cipher(self): return self._tls.cipher()
+    def shared_ciphers(self): return self._tls.shared_ciphers()
+    def compression(self): return self._tls.compression()
+    def selected_alpn_protocol(self): return self._tls.selected_alpn_protocol()
+    def selected_npn_protocol(self): return None
+    def version(self): return self._tls.version()
+    def pending(self): return self._tls.pending()
+    def get_channel_binding(self, cb_type="tls-unique"):
+        return self._tls.get_channel_binding(cb_type)
+
+
+def wrap(context, sock, server_hostname, suppress_ragged_eofs=True):
+    wrapped = SbxTlsSocket(context, sock, server_hostname, suppress_ragged_eofs)
+    wrapped.do_handshake()
+    return wrapped
+`;
 var SHIM_HEADER = "# generated by sandboxedjs - safe to delete or replace\n";
 var SHIM_SOURCE = `"""Rebuild os.system and os.popen on the container's process table."""
 import io, os, subprocess, sys
@@ -24158,7 +24669,51 @@ if sys.platform in ("emscripten", "wasi"):
     sys.meta_path.insert(0, _SbxPyodideFetchHook())
 
 
-_egress = os.environ.get("SBX_HTTP_EGRESS")
+# The egress shims exist for a host that cannot open sockets. Where the host
+# can, the guest's own clients are used instead: real streaming, real TLS, and
+# whatever protocol the library speaks rather than the subset HTTP-over-egress
+# allows. Both worlds are supported, and which one this is comes from the host
+# rather than from probing.
+if os.environ.get("SBX_OUTBOUND_SOCKETS") == "1":
+
+    class _SbxTruststoreHook:
+        """truststore verifies the peer's chain itself, against the operating
+        system's trust store. In this container the handshake happens on the
+        host, which verified the chain against exactly that store, and the
+        chain is not carried back -- so truststore's own check cannot run and
+        httpx2 failed with "no attribute get_unverified_chain". Its context is
+        therefore the standard one: same verification, done once, where the
+        connection is."""
+
+        def find_spec(self, name, path=None, target=None):
+            if name != "truststore":
+                return None
+            import importlib.util
+
+            class _Loader:
+                def create_module(self, spec):
+                    return None
+
+                def exec_module(self, module):
+                    import ssl as _ssl
+                    module.SSLContext = _ssl.SSLContext
+
+                    def inject_into_ssl():
+                        pass
+
+                    def extract_from_ssl():
+                        pass
+
+                    module.inject_into_ssl = inject_into_ssl
+                    module.extract_from_ssl = extract_from_ssl
+                    module.__version__ = "sandboxedjs"
+
+            return importlib.util.spec_from_loader(name, _Loader(), is_package=True)
+
+    sys.meta_path.insert(0, _SbxTruststoreHook())
+
+
+_egress = None if os.environ.get("SBX_OUTBOUND_SOCKETS") == "1" else os.environ.get("SBX_HTTP_EGRESS")
 if _egress:
     import http.client
     import urllib.request
@@ -24556,10 +25111,86 @@ if os.environ.get("SBX_SERIAL_HOST_CALLS") == "1":
             return spec
 
     sys.meta_path.insert(0, _SbxAnyioThreadHook())
+
+    class _SbxLoopResolverHook:
+        """asyncio resolves names on a worker thread, which cannot run here.
+
+        loop.getaddrinfo hands the call to a ThreadPoolExecutor and awaits
+        it -- the deadlock described above -- so every asyncio client that
+        connects by name hung: aiohttp never got past its first request. In
+        this container resolution is a host call that answers immediately, so
+        it is done on the loop thread instead of being handed away."""
+
+        def find_spec(self, name, path=None, target=None):
+            if name != "asyncio.base_events":
+                return None
+            import importlib.machinery
+            spec = importlib.machinery.PathFinder.find_spec(name, path)
+            if spec is None or spec.loader is None:
+                return spec
+            load = spec.loader.exec_module
+
+            def exec_module(module):
+                load(module)
+                import socket as _socket
+
+                async def getaddrinfo(self, host, port, *, family=0, type=0, proto=0, flags=0):
+                    return _socket.getaddrinfo(host, port, family, type, proto, flags)
+
+                async def getnameinfo(self, sockaddr, flags=0):
+                    return _socket.getnameinfo(sockaddr, flags)
+
+                module.BaseEventLoop.getaddrinfo = getaddrinfo
+                module.BaseEventLoop.getnameinfo = getnameinfo
+
+            spec.loader.exec_module = exec_module
+            return spec
+
+    sys.meta_path.insert(0, _SbxLoopResolverHook())
+
+    def _sbx_patch_loop_resolver(module):
+        """Also patch the module if it is already imported.
+
+        This file imports asyncio itself, a few lines above, so by the time the
+        hook is installed asyncio.base_events is usually already in
+        sys.modules and the hook would never see it -- which is why aiohttp
+        still hung after the hook existed."""
+        import socket as _socket
+
+        async def getaddrinfo(self, host, port, *, family=0, type=0, proto=0, flags=0):
+            return _socket.getaddrinfo(host, port, family, type, proto, flags)
+
+        async def getnameinfo(self, sockaddr, flags=0):
+            return _socket.getnameinfo(sockaddr, flags)
+
+        module.BaseEventLoop.getaddrinfo = getaddrinfo
+        module.BaseEventLoop.getnameinfo = getnameinfo
+
+    _loaded_base_events = sys.modules.get("asyncio.base_events")
+    if _loaded_base_events is not None:
+        _sbx_patch_loop_resolver(_loaded_base_events)
 `;
+var CA_BUNDLE_PATH = "/etc/ssl/certs/ca-certificates.crt";
+async function ensureTrustStore(ctx) {
+  try {
+    if (ctx.vfs.stat(CA_BUNDLE_PATH, { cred: ctx.cred }).size > 0) return;
+  } catch {
+  }
+  try {
+    const tls = await nodeBuiltin("tls");
+    const bundle = tls.rootCertificates.join("\n");
+    if (!bundle) return;
+    ctx.vfs.mkdir("/etc/ssl/certs", { cred: ctx.cred, recursive: true });
+    ctx.vfs.writeFile(CA_BUNDLE_PATH, bundle, { privileged: true, mode: 420 });
+  } catch {
+  }
+}
 function ensureProcessShims(ctx) {
-  const hook = `${SITE_PACKAGES}/sitecustomize.py`;
-  const source = `${SHIM_HEADER}${SHIM_SOURCE}`;
+  writeShim(ctx, `${SITE_PACKAGES}/sitecustomize.py`, SHIM_SOURCE);
+  writeShim(ctx, `${SITE_PACKAGES}/_sbx_tls.py`, TLS_MODULE_SOURCE);
+}
+function writeShim(ctx, hook, body) {
+  const source = `${SHIM_HEADER}${body}`;
   try {
     const existing = ctx.vfs.readText(hook, ctx.cred);
     if (existing === source || !existing.startsWith(SHIM_HEADER)) return;
@@ -24606,6 +25237,7 @@ function containerMounts(ctx) {
 
 // src/python/pip-command.ts
 init_binary();
+var RESOLVE_DEADLINE_MS = 15 * 6e4;
 async function requestRemoteBuild(service, requirement, line) {
   line(`Asking ${new URL(service).host} to build ${requirement}`);
   try {
@@ -24808,6 +25440,14 @@ environments. A package with no usable wheel is an error, never a silent skip.`,
           vfs: ctx.vfs,
           cred: ctx.cred,
           requirements,
+          /* The resolver's own default is three minutes, which is a fine bound
+           * for a library but far too tight for a real requirements file: a
+           * `langchain` plus `deepagents` graph is hundreds of distributions,
+           * each needing a metadata fetch, and the install died mid-resolution
+           * with "exceeded its 180s budget" while still making progress. `pip`
+           * already has a 20-minute ceiling on the whole command; this leaves
+           * room for the download phase inside it. */
+          deadlineMs: RESOLVE_DEADLINE_MS,
           pythonVersion: pythonBackend().manifest?.pythonVersion ?? "3.13.5",
           progress: {
             collecting: (name) => ctx.line(`Collecting ${name}`),
@@ -24960,7 +25600,7 @@ function mountContainerFs(FS, opts) {
   const throwErrno = (code) => {
     throw new FS.ErrnoError(emErrno(code));
   };
-  const translate = (e) => {
+  const translate2 = (e) => {
     if (isSysError(e)) return throwErrno(e.code);
     throw new FS.ErrnoError(emErrno("EIO"));
   };
@@ -25009,7 +25649,7 @@ function mountContainerFs(FS, opts) {
           blocks: Math.ceil(st.size / 512)
         };
       } catch (e) {
-        return translate(e);
+        return translate2(e);
       }
     },
     setattr(node2, attr) {
@@ -25025,7 +25665,7 @@ function mountContainerFs(FS, opts) {
           opts.onWrite?.(path);
         }
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
     },
     lookup(parent, name) {
@@ -25050,7 +25690,7 @@ function mountContainerFs(FS, opts) {
         }
         opts.onWrite?.(path);
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
       return backend.createNode(parent, name, mode, dev);
     },
@@ -25061,7 +25701,7 @@ function mountContainerFs(FS, opts) {
         vfs.rename(from, to, cred);
         opts.onWrite?.(to);
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
       oldNode.name = newName;
       oldNode.parent = newDir;
@@ -25072,7 +25712,7 @@ function mountContainerFs(FS, opts) {
         vfs.unlink(path, cred);
         opts.onWrite?.(path);
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
     },
     rmdir(parent, name) {
@@ -25081,7 +25721,7 @@ function mountContainerFs(FS, opts) {
         vfs.rmdir(path, cred);
         opts.onWrite?.(path);
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
     },
     readdir(node2) {
@@ -25089,7 +25729,7 @@ function mountContainerFs(FS, opts) {
       try {
         return [".", "..", ...vfs.readdir(path, cred)];
       } catch (e) {
-        return translate(e);
+        return translate2(e);
       }
     },
     symlink(parent, newName, oldPath) {
@@ -25098,7 +25738,7 @@ function mountContainerFs(FS, opts) {
         vfs.symlink(oldPath, path, cred);
         opts.onWrite?.(path);
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
     },
     readlink(node2) {
@@ -25106,7 +25746,7 @@ function mountContainerFs(FS, opts) {
       try {
         return vfs.readlink(path, cred);
       } catch (e) {
-        return translate(e);
+        return translate2(e);
       }
     }
   };
@@ -25118,7 +25758,7 @@ function mountContainerFs(FS, opts) {
         stream.sbxBuffer = vfs.lexists(path) ? vfs.readFile(path, cred) : new Uint8Array(0);
         stream.sbxDirty = false;
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
     },
     close(stream) {
@@ -25128,7 +25768,7 @@ function mountContainerFs(FS, opts) {
         vfs.writeFile(path, stream.sbxBuffer, { cred });
         opts.onWrite?.(path);
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
       stream.sbxDirty = false;
     },
@@ -25154,7 +25794,7 @@ function mountContainerFs(FS, opts) {
         opts.onWrite?.(path);
         stream.sbxDirty = false;
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
       return length;
     },
@@ -34835,6 +35475,212 @@ ${BUNDLER_HINT}`),
 
 // src/worker/local-runtime-pod.ts
 init_path();
+
+// src/net/outbound-tcp.ts
+var FIRST_SYNTHETIC = 2887581696;
+var SYNTHETIC_COUNT = 65534;
+function toDotted(value) {
+  return [value >>> 24, value >>> 16 & 255, value >>> 8 & 255, value & 255].join(".");
+}
+var OutboundTcp = class {
+  constructor(policy, dialer) {
+    this.policy = policy;
+    this.dialer = dialer;
+  }
+  policy;
+  dialer;
+  byName = /* @__PURE__ */ new Map();
+  byAddress = /* @__PURE__ */ new Map();
+  next = 0;
+  /** Whether this address was handed out by `resolve`. */
+  knows(address) {
+    return this.byAddress.has(address);
+  }
+  hostnameFor(address) {
+    return this.byAddress.get(address);
+  }
+  /**
+   * The address for `hostname`, allocating one on first use.
+   *
+   * Refusal happens here as well as at connect, because a name that cannot be
+   * reached should fail as a resolution failure -- which is what every client
+   * reports as "unknown host" rather than as a mid-connection error.
+   */
+  resolve(hostname) {
+    const name = hostname.trim().toLowerCase();
+    if (!name) throw new PosixError(Errno.EINVAL, "empty hostname");
+    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(name)) return name;
+    if (isLoopbackHostname(name)) return "127.0.0.1";
+    const known = this.byName.get(name);
+    if (known) return known;
+    if (!this.allowed(name)) {
+      throw new PosixError(
+        Errno.ENETUNREACH,
+        `cannot resolve ${hostname}: outbound network access is not allowed for this container`
+      );
+    }
+    if (this.next >= SYNTHETIC_COUNT) {
+      throw new PosixError(Errno.ENOSPC, "no addresses left for resolved names");
+    }
+    const address = toDotted(FIRST_SYNTHETIC + this.next + 1);
+    this.next += 1;
+    this.byName.set(name, address);
+    this.byAddress.set(address, name);
+    return address;
+  }
+  /** Open a connection to a resolved address, or to a literal one. */
+  async connect(address, port, local) {
+    const hostname = this.byAddress.get(address) ?? address;
+    if (!this.allowed(hostname)) {
+      throw new PosixError(
+        Errno.ENETUNREACH,
+        `cannot reach ${hostname}:${port}: outbound network access is not allowed for this container`
+      );
+    }
+    if (!this.dialer) {
+      throw new PosixError(
+        Errno.ENETUNREACH,
+        `cannot reach ${hostname}:${port}: this host cannot open sockets (a browser cannot), so outbound traffic has to leave over HTTP through the container's egress`
+      );
+    }
+    const host2 = await this.dialer(hostname, port);
+    const guest = new VirtualTcpConnection(
+      { address: local.address, port: host2.localPort || local.port },
+      { address, port }
+    );
+    const bridge = new VirtualTcpConnection({ address, port }, { address: local.address, port: local.port });
+    guest.pairWith(bridge);
+    bridge.pairWith(guest);
+    host2.onData((bytes2) => {
+      try {
+        bridge.write(bytes2);
+      } catch {
+        host2.close();
+      }
+    });
+    host2.onClose(() => {
+      bridge.shutdown(false, true);
+      bridge.close();
+    });
+    void (async () => {
+      for (; ; ) {
+        if (bridge.readable) {
+          let chunk;
+          try {
+            chunk = bridge.read(64 * 1024);
+          } catch {
+            break;
+          }
+          if (chunk.length === 0) {
+            host2.end();
+            break;
+          }
+          host2.write(chunk);
+          continue;
+        }
+        await bridge.waitForChange();
+      }
+    })();
+    return { connection: guest, host: host2 };
+  }
+  allowed(hostname) {
+    const policy = this.policy();
+    if (isLoopbackHostname(hostname)) return true;
+    if (!policy.allowOutbound) return false;
+    const hosts = policy.allowedHosts;
+    if (!hosts) return true;
+    return hosts.some((allowed) => hostname === allowed || hostname.endsWith(`.${allowed}`));
+  }
+};
+
+// src/net/node-tcp-dialer.ts
+init_binary();
+function canDialTcp() {
+  return typeof process !== "undefined" && Boolean(process.versions?.node);
+}
+function createNodeTcpDialer() {
+  return async (host2, port) => {
+    const net = await nodeBuiltin("net");
+    return await new Promise((resolve3, reject) => {
+      const socket = net.connect({ host: host2, port });
+      const pending = [];
+      let onData = null;
+      let onClose = null;
+      let closed = false;
+      socket.on("data", (chunk) => {
+        const bytes2 = new Uint8Array(chunk);
+        if (onData) onData(bytes2);
+        else pending.push(bytes2);
+      });
+      const finish = () => {
+        if (closed) return;
+        closed = true;
+        onClose?.();
+      };
+      socket.on("close", finish);
+      socket.on("end", finish);
+      socket.on("error", (error) => {
+        if (!closed) {
+          closed = true;
+          onClose?.();
+        }
+        reject(translate(error, host2, port));
+      });
+      socket.on("connect", () => {
+        socket.setNoDelay(true);
+        resolve3({
+          write(bytes2) {
+            socket.write(bytes2);
+          },
+          end() {
+            socket.end();
+          },
+          close() {
+            socket.destroy();
+          },
+          onData(handler) {
+            onData = handler;
+            for (const chunk of pending.splice(0)) handler(chunk);
+          },
+          onClose(handler) {
+            onClose = handler;
+            if (closed) handler();
+          },
+          get remoteAddress() {
+            return socket.remoteAddress ?? host2;
+          },
+          get remotePort() {
+            return socket.remotePort ?? port;
+          },
+          get localPort() {
+            return socket.localPort ?? 0;
+          }
+        });
+      });
+    });
+  };
+}
+function translate(error, host2, port) {
+  const where = `${host2}:${port}`;
+  switch (error.code) {
+    case "ECONNREFUSED":
+      return new PosixError(Errno.ECONNREFUSED, `connection refused by ${where}`);
+    case "ENOTFOUND":
+    case "EAI_AGAIN":
+      return new PosixError(Errno.ENETUNREACH, `cannot resolve ${host2}`);
+    case "ETIMEDOUT":
+      return new PosixError(Errno.ETIMEDOUT, `connection to ${where} timed out`);
+    case "ECONNRESET":
+      return new PosixError(Errno.ECONNRESET, `connection to ${where} was reset`);
+    case "EHOSTUNREACH":
+    case "ENETUNREACH":
+      return new PosixError(Errno.ENETUNREACH, `cannot reach ${where}`);
+    default:
+      return new PosixError(Errno.ECONNREFUSED, `connection to ${where} failed: ${error.message}`);
+  }
+}
+
+// src/worker/local-runtime-pod.ts
 var WASM_ALIASES = {
   esbuild: "esbuild-wasm",
   rollup: "@rollup/wasm-node"
@@ -35190,6 +36036,32 @@ var LocalRuntimePod = class _LocalRuntimePod {
   constructor(options) {
     ensureProcessGlobal();
     this.sockets = new VirtualTcpNetwork((port) => this.router.activePortsIncludes(port));
+    this.sockets.loopbackHttp = (port, connection) => {
+      if (!this.router.activePortsIncludes(port)) return false;
+      void serveHttpOverConnection(connection, async (request) => {
+        const url = new URL(request.target, `http://127.0.0.1:${port}`);
+        const answer = await this.router.request(port, {
+          method: request.method,
+          path: `${url.pathname}${url.search}`,
+          headers: request.headers,
+          ...request.body.length > 0 ? { body: request.body } : {}
+        });
+        const payload = answer.body ?? new Uint8Array();
+        return {
+          status: Number(answer.statusCode ?? 200),
+          statusText: String(answer.statusMessage ?? ""),
+          headers: answer.headers ?? {},
+          body: typeof payload === "string" ? new TextEncoder().encode(payload) : payload instanceof Uint8Array ? payload : new Uint8Array(payload)
+        };
+      });
+      return true;
+    };
+    if (canDialTcp()) {
+      this.sockets.outbound = new OutboundTcp(
+        () => this.networkPolicy ?? { allowOutbound: false, allowedHosts: null },
+        createNodeTcpDialer()
+      );
+    }
     this.router = new VirtualHttpRouter(this.sockets);
     this.workdir = options.workdir ?? "/";
     this.env = { ...options.env };