sandboxedjs 0.1.91 → 0.1.93

package/dist/index.cjs

@@ -20031,6 +20031,67 @@ var wheels_default = {
         ]
       }
     },
+    {
+      name: "argon2-cffi-bindings",
+      version: "21.2.0",
+      filename: "argon2_cffi_bindings-21.2.0-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "16a0bb095ad8c966509752c2f0498bea965839deead4d84ad4badf6465b5948b",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [
+        "cffi>=1.0.1",
+        'pytest; extra == "tests"',
+        'pytest; extra == "dev"',
+        'cogapp; extra == "dev"',
+        'pre-commit; extra == "dev"',
+        'wheel; extra == "dev"'
+      ],
+      provenance: {
+        sourceTreeDigest: "8093e19a848187cbd5a92c541c1dab627f0bacb7ac8d09216d0226a313d6f9ab",
+        recipeSha256: "3744603cabcf8107c497d8e6d106614135ef0dfeec5d32ac24039b7e8e4d9009",
+        buildTools: [
+          "setuptools==84.0.0",
+          "cffi==2.1.1",
+          "setuptools-scm==10.2.3"
+        ],
+        nativeDependencies: [],
+        patches: []
+      }
+    },
+    {
+      name: "bcrypt",
+      version: "5.0.0",
+      filename: "bcrypt-5.0.0-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "a8fdcaccccf931b2fb3e327f94e8dc9a8e7c53bf17bc9fb85aae25211cbac61f",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [],
+      provenance: {
+        sourceTreeDigest: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        recipeSha256: "3a1af92dc00b0d1896cf1483399c002df4b36289de7dea2324035407e78e9f9b",
+        buildTools: [
+          "setuptools==84.0.0"
+        ],
+        nativeDependencies: [],
+        patches: []
+      }
+    },
+    {
+      name: "brotli",
+      version: "1.2.0",
+      filename: "brotli-1.2.0-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "b67d1b9169ba3e0790d04b8020adb1a58f0b89f8961aca360dca5f020de07a21",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [],
+      provenance: {
+        sourceTreeDigest: "7b563fa2e7f20edac204cc80004cae35c844b36a83758e5957184383332d1209",
+        recipeSha256: "09bf4f6072d637866a6b3c3deaec419dc3ff8a32a6f3b0813f57e06316bfcf39",
+        buildTools: [
+          "setuptools==84.0.0",
+          "pkgconfig==1.6.0"
+        ],
+        nativeDependencies: [],
+        patches: []
+      }
+    },
     {
       name: "cffi",
       version: "2.1.1",
@@ -20052,6 +20113,26 @@ var wheels_default = {
         patches: []
       }
     },
+    {
+      name: "cryptography",
+      version: "50.0.1",
+      filename: "cryptography-50.0.1-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "10bb6568bf4368a593ea3a990ea870e57d4eeb1d3278af89bf24a8713473238e",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [
+        'cffi>=2.0.0; platform_python_implementation != "PyPy"'
+      ],
+      provenance: {
+        sourceTreeDigest: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        recipeSha256: "082169d1d317ba001e37ccfb7a40a0dafd8d3d34e42034da8590f0207ae73ea5",
+        buildTools: [
+          "setuptools==84.0.0",
+          "cffi==2.1.1"
+        ],
+        nativeDependencies: [],
+        patches: []
+      }
+    },
     {
       name: "fastar",
       version: "0.12.0",
@@ -20105,6 +20186,32 @@ var wheels_default = {
         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",
@@ -20144,20 +20251,86 @@ var wheels_default = {
         patches: []
       }
     },
+    {
+      name: "orjson",
+      version: "3.12.0",
+      filename: "orjson-3.12.0-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "1a8b9b3ab496f6d8b1ef73d0ae282262d8399f55243bf01f2dbfac46aff99a35",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [],
+      provenance: {
+        sourceTreeDigest: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        recipeSha256: "cda75f871a972e759361a12baeaa3531dc9c68c958556674fd30f3d639fb6b45",
+        buildTools: [
+          "setuptools==84.0.0"
+        ],
+        nativeDependencies: [],
+        patches: []
+      }
+    },
     {
       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: "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: []
       }
     },
@@ -20218,6 +20391,23 @@ var wheels_default = {
         patches: []
       }
     },
+    {
+      name: "regex",
+      version: "2026.9.10",
+      filename: "regex-2026.9.10-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "44995aafa6294c4c817ff658755b931d936b0c00db6e4b086b6469a76938f7c8",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [],
+      provenance: {
+        sourceTreeDigest: "db71e2c60e74953662c35d3ce3f75893ac7a9df8190afecc916f1a73981c50f5",
+        recipeSha256: "5fb970f2bdc3dfe0be8f98b04caa083c6a9088351d1415d4f9f49d154c7df90d",
+        buildTools: [
+          "setuptools==84.0.0"
+        ],
+        nativeDependencies: [],
+        patches: []
+      }
+    },
     {
       name: "rignore",
       version: "0.8.1",
@@ -20406,6 +20596,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",
@@ -20429,6 +20636,44 @@ var wheels_default = {
         ]
       }
     },
+    {
+      name: "tiktoken",
+      version: "0.14.0",
+      filename: "tiktoken-0.14.0-cp313-cp313-emscripten_5_0_6_wasm32.whl",
+      sha256: "a006e3c7d5281b05af21d11692d9be00bb2d4ca554589889fe93c5616e94d02f",
+      abiId: "sbxabi1-c2637d04695ad927",
+      requires: [
+        "regex>=2022.1.18",
+        "requests>=2.26.0"
+      ],
+      provenance: {
+        sourceTreeDigest: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        recipeSha256: "99b8a588584b366576b343a3eeeff8cae87f9ba917b26460b050b2fc462239ed",
+        buildTools: [
+          "setuptools==84.0.0"
+        ],
+        nativeDependencies: [],
+        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",
@@ -20511,7 +20756,7 @@ var wheels_default = {
 
 // package.json
 var package_default = {
-  version: "0.1.91"};
+  version: "0.1.93"};
 
 // src/python/extension-abi.ts
 var EXTENSION_ABI = {
@@ -22616,7 +22861,13 @@ async function serve(ctx, connection) {
       headers: forwarded,
       ...request.body.length > 0 ? { body: request.body } : {}
     });
-    writeResponse(connection, result.status, result.statusText, result.headers, result.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 {
@@ -22915,16 +23166,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`]: ""
@@ -22932,6 +23200,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,
@@ -22956,7 +23231,7 @@ function builtinCandidates(name) {
     filename: `${name}-${builtin.version}-py3-none-any.whl`,
     sha256: "",
     metadataUrl: null,
-    indexedRequires: []
+    indexedRequires: builtin.requires
   }];
 }
 function isBuiltinOnly(name) {
@@ -23852,6 +24127,36 @@ 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'"."""
+
+        _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())
+
 
 _egress = os.environ.get("SBX_HTTP_EGRESS")
 if _egress:
@@ -23933,6 +24238,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
@@ -23961,6 +24515,47 @@ 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())
 `;
 function ensureProcessShims(ctx) {
   const hook = `${SITE_PACKAGES}/sitecustomize.py`;