sandboxedjs 0.1.92 → 0.1.94

package/dist/index.js

@@ -19804,6 +19804,7 @@ var Op = {
   setsockopt: 1802,
   getsockopt: 1803,
   socket_close: 1804,
+  resolve: 1805,
   spawn: 2048,
   waitpid: 2049,
   kill: 2050
@@ -20040,6 +20041,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",
@@ -20057,6 +20080,26 @@ var wheels_default = {
         patches: []
       }
     },
+    {
+      name: "brotli",
+      version: "1.2.0",
+      filename: "brotli-1.2.0-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "d8b06cc04770a048b41956c9cc767e7332c49f0229e69744f4b1c2892b888b27",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [],
+      provenance: {
+        sourceTreeDigest: "7b563fa2e7f20edac204cc80004cae35c844b36a83758e5957184383332d1209",
+        recipeSha256: "1326c898e999feba536ff15f080fed9ac4b9cd14e0dbfee39a950decf19607ef",
+        buildTools: [
+          "setuptools==84.0.0",
+          "pkgconfig==1.6.0"
+        ],
+        nativeDependencies: [],
+        patches: [
+          "0001-meth-noargs-signatures.patch"
+        ]
+      }
+    },
     {
       name: "cffi",
       version: "2.1.1",
@@ -20082,14 +20125,14 @@ var wheels_default = {
       name: "cryptography",
       version: "50.0.1",
       filename: "cryptography-50.0.1-cp313-cp313-emscripten_5_0_6_wasm32.whl",
-      sha256: "5c1498a64d987b68623a0e3ce5da36499cd69ad6a7e1309ec62c584ec7cc5f52",
+      sha256: "10bb6568bf4368a593ea3a990ea870e57d4eeb1d3278af89bf24a8713473238e",
       abiId: "sbxabi1-c2637d04695ad927",
       requires: [
         'cffi>=2.0.0; platform_python_implementation != "PyPy"'
       ],
       provenance: {
         sourceTreeDigest: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-        recipeSha256: "c7521d2b03c8bf941fe7d464ba54c8ec9356d823c715d65baab53e3223412dc6",
+        recipeSha256: "082169d1d317ba001e37ccfb7a40a0dafd8d3d34e42034da8590f0207ae73ea5",
         buildTools: [
           "setuptools==84.0.0",
           "cffi==2.1.1"
@@ -20115,6 +20158,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",
@@ -20151,6 +20213,58 @@ 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",
+      filename: "lz4-4.4.5-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "f94c0ef7d84c9bf700cc86f69a28382699262e442e29d9763736afdb61141ffe",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [
+        'pytest!=3.3.0; extra == "tests"',
+        'psutil; extra == "tests"',
+        'pytest-cov; extra == "tests"',
+        'sphinx>=1.6.0; extra == "docs"',
+        'sphinx_bootstrap_theme; extra == "docs"',
+        'flake8; extra == "flake8"'
+      ],
+      provenance: {
+        sourceTreeDigest: "5f7bda9bfb026d0a30bb5e3383a4b25ae6b7f44fd6dc74950653d57f84c9d88e",
+        recipeSha256: "80250de0ae159cd9f977bdfad059de0d192f28555225b084b42b5a180f684e0c",
+        buildTools: [
+          "setuptools==84.0.0",
+          "pkgconfig==1.6.0",
+          "setuptools-scm==10.2.3"
+        ],
+        nativeDependencies: [],
+        patches: []
+      }
+    },
     {
       name: "msgpack",
       version: "1.1.0",
@@ -20211,16 +20325,172 @@ var wheels_default = {
       name: "ormsgpack",
       version: "1.12.2",
       filename: "ormsgpack-1.12.2-cp313-cp313-emscripten_5_0_6_wasm32.whl",
-      sha256: "42ca38d1948a36d43294c7843fd9398f1ae88bddd9e56b26ad80a644f9bdec52",
+      sha256: "7fa4463a69aad2fe057c111642cce71c8f72af8465c22769d839415dbc15ac79",
       abiId: "sbxabi1-c2637d04695ad927",
       requires: [],
       provenance: {
-        sourceTreeDigest: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-        recipeSha256: "6ab618fe6bc9dee1fa76f57f298c55732fe2241e122240f44007a2ce0025e1b2",
+        sourceTreeDigest: "eff3a7be3bc6de2a15e479c0e3e94905c35203fd83369124073f2df5cce46409",
+        recipeSha256: "bd398762801fce51d35b33439f5e57037e1d4d274f25bd795683e2ad17d34b62",
         buildTools: [
           "setuptools==84.0.0"
         ],
         nativeDependencies: [],
+        patches: [
+          "0001-pylong-asbytearray-313-signature.patch"
+        ]
+      }
+    },
+    {
+      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",
+      filename: "pillow-12.3.0-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "7e585c71bf943029d8201283308a1b43f2be5f166d9beb36697d1f6bfba865e9",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [
+        'furo; extra == "docs"',
+        'olefile; extra == "docs"',
+        'sphinx>=8.2; extra == "docs"',
+        'sphinx-autobuild; extra == "docs"',
+        'sphinx-copybutton; extra == "docs"',
+        'sphinx-inline-tabs; extra == "docs"',
+        'sphinxext-opengraph; extra == "docs"',
+        'olefile; extra == "fpx"',
+        'olefile; extra == "mic"',
+        'arro3-compute; extra == "test-arrow"',
+        'arro3-core; extra == "test-arrow"',
+        'nanoarrow; extra == "test-arrow"',
+        'pyarrow; extra == "test-arrow"',
+        'coverage>=7.4.2; extra == "tests"',
+        'defusedxml; extra == "tests"',
+        'markdown2; extra == "tests"',
+        'olefile; extra == "tests"',
+        'packaging; extra == "tests"',
+        'pytest; extra == "tests"',
+        'pytest-cov; extra == "tests"',
+        'pytest-timeout; extra == "tests"',
+        'pytest-xdist; extra == "tests"',
+        'setuptools; extra == "tests"',
+        'trove-classifiers>=2024.10.12; extra == "tests"',
+        'defusedxml; extra == "xmp"'
+      ],
+      provenance: {
+        sourceTreeDigest: "5427eff55a6a0e5f667d70527c2c3749f2c0786598903d7bbe7aaf16c4e95e31",
+        recipeSha256: "77418b7e139e4779f2a422a06abbea27c941174b1f86597a2f3c4483bb236b7f",
+        buildTools: [
+          "setuptools==84.0.0",
+          "pybind11==3.1.0"
+        ],
+        nativeDependencies: [
+          "z==1.3.1",
+          "jpeg==9f"
+        ],
         patches: []
       }
     },
@@ -20281,6 +20551,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",
@@ -20486,6 +20781,23 @@ var wheels_default = {
         patches: []
       }
     },
+    {
+      name: "simplejson",
+      version: "4.1.2",
+      filename: "simplejson-4.1.2-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "80671c2b02beb0d429108df8cefb6f27857b34e032bb5a5f1e0f957e7bf3cab6",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [],
+      provenance: {
+        sourceTreeDigest: "055af71755ff30d71076fdebc6f605e66f5876e6f01350a7d6075e8679006111",
+        recipeSha256: "e163a1f2e78f32265c3ffdbf743dab27bc9e0829f21c553cabf0bafafd7d69fd",
+        buildTools: [
+          "setuptools==84.0.0"
+        ],
+        nativeDependencies: [],
+        patches: []
+      }
+    },
     {
       name: "siphash24",
       version: "1.9",
@@ -20529,6 +20841,24 @@ var wheels_default = {
         patches: []
       }
     },
+    {
+      name: "ujson",
+      version: "6.0.0",
+      filename: "ujson-6.0.0-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "3d4fd009acb9fad7a2070b0e2e498f6257e9c0cc28f806950d8c04cbb6849c24",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [],
+      provenance: {
+        sourceTreeDigest: "2a0c67ecb71628cb89b46090372d11dc4cf6e91c2406260a4e544c17331a31da",
+        recipeSha256: "e9f3fe48e14241bd38d1d20dc691413d8c646984d67ae3898f4b27d10af4bf80",
+        buildTools: [
+          "setuptools==84.0.0",
+          "setuptools-scm==10.2.3"
+        ],
+        nativeDependencies: [],
+        patches: []
+      }
+    },
     {
       name: "uuid-utils",
       version: "0.17.1",
@@ -20611,7 +20941,7 @@ var wheels_default = {
 
 // package.json
 var package_default = {
-  version: "0.1.92"};
+  version: "0.1.94"};
 
 // src/python/extension-abi.ts
 var EXTENSION_ABI = {
@@ -21649,6 +21979,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) {
@@ -21666,13 +21998,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;
@@ -21723,6 +22077,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;
   }
@@ -21787,7 +22143,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);
@@ -21799,7 +22155,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;
@@ -21810,6 +22170,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;
@@ -21821,6 +22190,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);
@@ -21834,7 +22215,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 }
@@ -21848,6 +22233,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);
   }
@@ -21865,7 +22270,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);
@@ -22156,7 +22561,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))) };
@@ -22180,9 +22585,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()) };
@@ -22716,6 +23127,38 @@ async function serve(ctx, connection) {
       headers: forwarded,
       ...request.body.length > 0 ? { body: request.body } : {}
     });
+    const {
+      "content-encoding": _encoding,
+      "content-length": _length,
+      "transfer-encoding": _chunked,
+      ...responseHeaders
+    } = result.headers;
+    writeResponse(connection, result.status, result.statusText, responseHeaders, 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();
+  }
+}
+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);
@@ -23015,16 +23458,33 @@ def run(main, *, loop_factory=new_event_loop, debug=None, **run_kwargs):
     with __asyncio.Runner(loop_factory=loop_factory, debug=debug) as runner:
         return runner.run(main)
 `;
-function builtinDistribution(name, version, summary, files) {
+var HTTPX2_JSFETCH_VERSION = "1.0";
+var HTTPX2_JSFETCH_SOURCE = `"""SandboxedJs stand-in for httpx2-jsfetch.
+
+The real package drives the browser fetch API through Pyodide's \`js\` module.
+This runtime has no \`js\` module but does have sockets, so httpx2's regular
+httpcore2 transports are used under the names httpx2 imports on Emscripten.
+"""
+
+from httpx2._transports.default import (
+    AsyncHTTPTransport as AsyncJavascriptFetchTransport,
+    HTTPTransport as JavascriptFetchTransport,
+)
+
+__all__ = ["AsyncJavascriptFetchTransport", "JavascriptFetchTransport"]
+`;
+function builtinDistribution(name, version, summary, files, requires = []) {
   return {
     version,
+    requires,
     files: {
       ...files,
       [`${name}-${version}.dist-info/METADATA`]: `Metadata-Version: 2.1
 Name: ${name}
 Version: ${version}
 Summary: ${summary}
-`,
+` + requires.map((r) => `Requires-Dist: ${r}
+`).join(""),
       [`${name}-${version}.dist-info/WHEEL`]: "Wheel-Version: 1.0\nGenerator: sandboxedjs\nRoot-Is-Purelib: true\nTag: py3-none-any\n",
       [`${name}-${version}.dist-info/INSTALLER`]: "sandboxedjs\n",
       [`${name}-${version}.dist-info/RECORD`]: ""
@@ -23032,6 +23492,13 @@ Summary: ${summary}
   };
 }
 var BUILTINS3 = {
+  "httpx2-jsfetch": builtinDistribution(
+    "httpx2_jsfetch",
+    HTTPX2_JSFETCH_VERSION,
+    "SandboxedJs stand-in: httpx2's socket transports under the jsfetch names",
+    { "httpx2_jsfetch/__init__.py": HTTPX2_JSFETCH_SOURCE },
+    ["httpcore2[asyncio]", "anyio>=4.10", "truststore>=0.10"]
+  ),
   greenlet: builtinDistribution(
     "greenlet",
     GREENLET_VERSION,
@@ -23056,7 +23523,7 @@ function builtinCandidates(name) {
     filename: `${name}-${builtin.version}-py3-none-any.whl`,
     sha256: "",
     metadataUrl: null,
-    indexedRequires: []
+    indexedRequires: builtin.requires
   }];
 }
 function isBuiltinOnly(name) {
@@ -23240,7 +23707,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 ? {
@@ -23252,8 +23719,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();
@@ -23265,9 +23732,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;
       }
@@ -23291,15 +23758,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) {
@@ -23805,8 +24270,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({
@@ -23847,6 +24322,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
@@ -23952,8 +24621,82 @@ if sys.platform in ("emscripten", "wasi"):
 
     sys.meta_path.insert(0, _SbxAsyncioWatcherHook())
 
+    class _SbxPyodideFetchHook:
+        """Libraries read \`sys.platform == "emscripten"\` as "running in Pyodide"
+        and switch to a browser-fetch backend that imports Pyodide's \`js\`
+        module. This runtime has no \`js\` but does have sockets, so those
+        backends are replaced by modules that leave the socket path in place.
+        urllib3 (and so requests) imports its backend at package import, which
+        made anything using requests fail with "No module named 'js'"."""
 
-_egress = os.environ.get("SBX_HTTP_EGRESS")
+        _STANDINS = {
+            # urllib3/__init__.py calls inject_into_urllib3() on emscripten.
+            "urllib3.contrib.emscripten": "def inject_into_urllib3():\\n    pass\\n",
+        }
+
+        def find_spec(self, name, path=None, target=None):
+            source = self._STANDINS.get(name)
+            if source is None:
+                return None
+            import importlib.util
+
+            class _Loader:
+                def create_module(self, spec):
+                    return None
+
+                def exec_module(self, module):
+                    exec(compile(source, f"<sandboxedjs {name}>", "exec"), module.__dict__)
+
+            return importlib.util.spec_from_loader(name, _Loader(), is_package=False)
+
+    sys.meta_path.insert(0, _SbxPyodideFetchHook())
+
+
+# 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
@@ -24033,6 +24776,255 @@ if _egress:
     http.client.HTTPConnection = _SbxEgressConnection
     http.client.HTTPSConnection = _SbxEgressTlsConnection
 
+    # Everything above routes code that reaches for the standard library. The
+    # popular HTTP clients do not: urllib3 (so requests), httpcore (so httpx)
+    # and httpcore2 (so httpx2) open sockets themselves, and raw sockets do not
+    # leave this container -- connect() to anything but loopback is
+    # ENETUNREACH, and CPython's ssl cannot wrap these sockets anyway. So each
+    # client's connection layer is replaced by one that speaks plain HTTP to
+    # the egress endpoint with the absolute URL in the request line, which is
+    # what the standard-library shims above already do.
+
+    def _sbx_egress_request(method, url, headers, body, timeout=None):
+        """One request through the egress. Returns (status, reason, headers, body)."""
+        connection = _RealHTTPConnection(_egress_host, _egress_port, timeout=timeout)
+        try:
+            connection.request(method, url, body, {k: v for k, v in headers if k.lower() != "host"})
+            response = connection.getresponse()
+            payload = response.read()
+            if response.getheader("x-sbx-error"):
+                raise OSError(payload.decode("utf-8", "replace").strip())
+            return response.status, response.reason, response.getheaders(), payload
+        finally:
+            connection.close()
+
+    async def _sbx_egress_request_async(method, url, headers, body):
+        """The same hop as _sbx_egress_request, over asyncio streams."""
+        import asyncio
+        reader, writer = await asyncio.open_connection(_egress_host, _egress_port)
+        try:
+            payload = body or b""
+            if isinstance(payload, str):
+                payload = payload.encode()
+            lines = [f"{method} {url} HTTP/1.1", f"Host: {_egress_host}:{_egress_port}"]
+            for key, value in headers:
+                if key.lower() in ("host", "connection", "content-length", "transfer-encoding"):
+                    continue
+                lines.append(f"{key}: {value}")
+            lines.append(f"Content-Length: {len(payload)}")
+            # Read to EOF rather than tracking keep-alive framing: one request
+            # per connection, which is what this hop is for.
+            lines.append("Connection: close")
+            writer.write(("\\r\\n".join(lines) + "\\r\\n\\r\\n").encode("latin-1") + payload)
+            await writer.drain()
+
+            head = await reader.readuntil(b"\\r\\n\\r\\n")
+            start, _, rest = head.decode("latin-1").partition("\\r\\n")
+            _, _, status_text = start.partition(" ")
+            code, _, reason = status_text.partition(" ")
+            received = []
+            for line in rest.split("\\r\\n"):
+                key, sep, value = line.partition(":")
+                if sep:
+                    received.append((key.strip(), value.strip()))
+            content = dict((k.lower(), v) for k, v in received)
+            if "content-length" in content:
+                data = await reader.readexactly(int(content["content-length"]))
+            else:
+                data = await reader.read()
+            if content.get("x-sbx-error"):
+                raise OSError(data.decode("utf-8", "replace").strip())
+            return int(code), reason, received, data
+        finally:
+            writer.close()
+
+    class _SbxUrllib3Hook:
+        """urllib3's emscripten backend is Pyodide's \`js\` fetch, which this
+        runtime has no module for; its socket backend cannot leave the
+        container. Both connection classes become egress ones."""
+
+        def find_spec(self, name, path=None, target=None):
+            if name != "urllib3.contrib.emscripten":
+                return None
+            import importlib.util
+
+            def inject_into_urllib3():
+                import urllib3.connection
+                from urllib3.connectionpool import HTTPConnectionPool, HTTPSConnectionPool
+
+                class _Plain(urllib3.connection.HTTPConnection):
+                    """urllib3's own connection, dialled at the egress.
+
+                    urllib3.connection.HTTPConnection still derives from
+                    http.client.HTTPConnection, so request building is
+                    inherited; only where it connects and what goes in the
+                    request line change.
+                    """
+
+                    _sbx_scheme = "http"
+                    default_port = 80
+                    is_verified = True
+                    proxy_is_verified = None
+
+                    def __init__(self, host, port=None, **kwargs):
+                        # A distinct name from the http.client shim's
+                        # _sbx_origin: that class is further up this MRO and
+                        # its __init__ runs after this one, so sharing the name
+                        # overwrote the real destination with the egress and
+                        # every request went out addressed to the egress itself.
+                        self._sbx_target = (host, port or self.default_port)
+                        for unsupported in ("ssl_context", "ssl_version", "ssl_minimum_version",
+                                            "ssl_maximum_version", "assert_hostname",
+                                            "assert_fingerprint", "server_hostname", "ca_certs",
+                                            "ca_cert_dir", "ca_cert_data", "cert_file", "key_file",
+                                            "key_password", "cert_reqs"):
+                            kwargs.pop(unsupported, None)
+                        super().__init__(_egress_host, port=_egress_port, **kwargs)
+
+                    def _sbx_absolute(self, url):
+                        host, port = self._sbx_target
+                        if url.startswith("http://") or url.startswith("https://"):
+                            return url
+                        netloc = host if port == self.default_port else f"{host}:{port}"
+                        return f"{self._sbx_scheme}://{netloc}{url}"
+
+                    # urllib3 v2 writes the request line in its own request()
+                    # rather than through http.client's putrequest, so both
+                    # are absolutised; the egress refuses an origin-form target.
+                    def request(self, method, url, *args, **kwargs):
+                        return super().request(method, self._sbx_absolute(url), *args, **kwargs)
+
+                    def putrequest(self, method, url, *args, **kwargs):
+                        return super().putrequest(method, self._sbx_absolute(url), *args, **kwargs)
+
+                    def set_tunnel(self, *args, **kwargs):
+                        raise OSError("this container reaches the network through its egress, not CONNECT")
+
+                class _Tls(_Plain):
+                    _sbx_scheme = "https"
+                    default_port = 443
+
+                HTTPConnectionPool.ConnectionCls = _Plain
+                HTTPSConnectionPool.ConnectionCls = _Tls
+                urllib3.connection.HTTPConnection = _Plain
+                urllib3.connection.HTTPSConnection = _Tls
+
+            class _Loader:
+                def create_module(self, spec):
+                    return None
+
+                def exec_module(self, module):
+                    module.inject_into_urllib3 = inject_into_urllib3
+
+            return importlib.util.spec_from_loader(name, _Loader(), is_package=True)
+
+    sys.meta_path.insert(0, _SbxUrllib3Hook())
+
+    def _sbx_httpx_transports(httpx_module):
+        """Sync and async httpx transports that send through the egress."""
+
+        class _Transport(httpx_module.BaseTransport):
+            def __init__(self, *args, **kwargs):
+                pass
+
+            def handle_request(self, request):
+                body = request.read()
+                sent = [(k.decode("latin-1"), v.decode("latin-1")) for k, v in request.headers.raw]
+                status, reason, headers, payload = _sbx_egress_request(
+                    request.method, str(request.url), sent, body,
+                )
+                # Content-Length/Transfer-Encoding describe the egress hop's
+                # framing, and httpx re-derives them from the body it is given.
+                keep = [(k, v) for k, v in headers
+                        if k.lower() not in ("content-length", "transfer-encoding", "content-encoding")]
+                return httpx_module.Response(
+                    status, headers=keep, content=payload, request=request,
+                    extensions={"reason_phrase": (reason or "").encode()},
+                )
+
+            def close(self):
+                pass
+
+            def __enter__(self):
+                return self
+
+            def __exit__(self, *args):
+                pass
+
+        class _AsyncTransport(httpx_module.AsyncBaseTransport):
+            def __init__(self, *args, **kwargs):
+                pass
+
+            async def handle_async_request(self, request):
+                # Not the blocking client on the loop thread: this image
+                # proxies every syscall to one thread, so a blocking recv
+                # inside a coroutine stops the loop that must service it. The
+                # egress is loopback, which asyncio streams reach.
+                import asyncio
+                body = await request.aread()
+                sent = [(k.decode("latin-1"), v.decode("latin-1")) for k, v in request.headers.raw]
+                status, reason, headers, payload = await _sbx_egress_request_async(
+                    request.method, str(request.url), sent, body,
+                )
+                keep = [(k, v) for k, v in headers
+                        if k.lower() not in ("content-length", "transfer-encoding", "content-encoding")]
+                return httpx_module.Response(
+                    status, headers=keep, content=payload, request=request,
+                    extensions={"reason_phrase": (reason or "").encode()},
+                )
+
+            async def aclose(self):
+                pass
+
+            async def __aenter__(self):
+                return self
+
+            async def __aexit__(self, *args):
+                pass
+
+        return _Transport, _AsyncTransport
+
+    class _SbxHttpxHook:
+        """httpx and httpx2 build their default transports on httpcore, which
+        opens sockets. Their default transport classes are replaced as the
+        module loads, so \`httpx.get(...)\` and every client built from the
+        defaults leave through the egress."""
+
+        _PACKAGES = {"httpx": "httpx", "httpx2": "httpx2"}
+
+        def find_spec(self, name, path=None, target=None):
+            package = self._PACKAGES.get(name)
+            if package is None or getattr(self, "_loading", None) == name:
+                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):
+                self._loading = name
+                try:
+                    load(module)
+                finally:
+                    self._loading = None
+                transport, async_transport = _sbx_httpx_transports(module)
+                module.HTTPTransport = transport
+                module.AsyncHTTPTransport = async_transport
+                defaults = sys.modules.get(f"{package}._transports.default")
+                if defaults is not None:
+                    defaults.HTTPTransport = transport
+                    defaults.AsyncHTTPTransport = async_transport
+                client = sys.modules.get(f"{package}._client")
+                if client is not None:
+                    client.HTTPTransport = transport
+                    client.AsyncHTTPTransport = async_transport
+
+            spec.loader.exec_module = exec_module
+            return spec
+
+    sys.meta_path.insert(0, _SbxHttpxHook())
+
 
 if os.environ.get("SBX_SERIAL_HOST_CALLS") == "1":
     import asyncio
@@ -24061,10 +25053,127 @@ if os.environ.get("SBX_SERIAL_HOST_CALLS") == "1":
         )
 
     asyncio.to_thread = _to_thread
+
+    class _SbxAnyioThreadHook:
+        """anyio's thread offload, run inline.
+
+        anyio has its own worker threads, so it never reaches asyncio.to_thread
+        and the refusal above -- it deadlocks instead, for the reason described
+        there. Starlette sends every *synchronous* endpoint through
+        anyio.to_thread.run_sync, so a plain def FastAPI route hung forever
+        while an async def one answered.
+
+        Running the function on the loop thread keeps such an endpoint working.
+        The cost is real and worth stating: a synchronous handler blocks the
+        loop for its duration, so it does not overlap with other requests.
+        """
+
+        def find_spec(self, name, path=None, target=None):
+            if name != "anyio.to_thread":
+                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)
+
+                async def run_sync(func, *args, abandon_on_cancel=False,
+                                   cancellable=None, limiter=None):
+                    return func(*args)
+
+                async def run_sync_in_worker_thread(func, *args, **kwargs):
+                    return func(*args)
+
+                module.run_sync = run_sync
+                module.run_sync_in_worker_thread = run_sync_in_worker_thread
+
+            spec.loader.exec_module = exec_module
+            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;
@@ -24111,6 +25220,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 {
@@ -24313,6 +25423,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}`),
@@ -24465,7 +25583,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"));
   };
@@ -24514,7 +25632,7 @@ function mountContainerFs(FS, opts) {
           blocks: Math.ceil(st.size / 512)
         };
       } catch (e) {
-        return translate(e);
+        return translate2(e);
       }
     },
     setattr(node2, attr) {
@@ -24530,7 +25648,7 @@ function mountContainerFs(FS, opts) {
           opts.onWrite?.(path);
         }
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
     },
     lookup(parent, name) {
@@ -24555,7 +25673,7 @@ function mountContainerFs(FS, opts) {
         }
         opts.onWrite?.(path);
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
       return backend.createNode(parent, name, mode, dev);
     },
@@ -24566,7 +25684,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;
@@ -24577,7 +25695,7 @@ function mountContainerFs(FS, opts) {
         vfs.unlink(path, cred);
         opts.onWrite?.(path);
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
     },
     rmdir(parent, name) {
@@ -24586,7 +25704,7 @@ function mountContainerFs(FS, opts) {
         vfs.rmdir(path, cred);
         opts.onWrite?.(path);
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
     },
     readdir(node2) {
@@ -24594,7 +25712,7 @@ function mountContainerFs(FS, opts) {
       try {
         return [".", "..", ...vfs.readdir(path, cred)];
       } catch (e) {
-        return translate(e);
+        return translate2(e);
       }
     },
     symlink(parent, newName, oldPath) {
@@ -24603,7 +25721,7 @@ function mountContainerFs(FS, opts) {
         vfs.symlink(oldPath, path, cred);
         opts.onWrite?.(path);
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
     },
     readlink(node2) {
@@ -24611,7 +25729,7 @@ function mountContainerFs(FS, opts) {
       try {
         return vfs.readlink(path, cred);
       } catch (e) {
-        return translate(e);
+        return translate2(e);
       }
     }
   };
@@ -24623,7 +25741,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) {
@@ -24633,7 +25751,7 @@ function mountContainerFs(FS, opts) {
         vfs.writeFile(path, stream.sbxBuffer, { cred });
         opts.onWrite?.(path);
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
       stream.sbxDirty = false;
     },
@@ -24659,7 +25777,7 @@ function mountContainerFs(FS, opts) {
         opts.onWrite?.(path);
         stream.sbxDirty = false;
       } catch (e) {
-        translate(e);
+        translate2(e);
       }
       return length;
     },
@@ -34340,6 +35458,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"
@@ -34695,6 +36019,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 };