wpr-http 0.2.0__tar.gz → 0.2.2__tar.gz

{wpr_http-0.2.0 → wpr_http-0.2.2}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: wpr-http
-Version: 0.2.0
+Version: 0.2.2
 Summary: Standalone HTTP client using version-selected Firefox Necko/NSS Workers
 License: MPL-2.0-compatible client; see runtime bundle notices
 Project-URL: Repository, https://github.com/childclm/wpr-http
 Project-URL: Documentation, https://github.com/childclm/wpr-http/blob/main/README.md
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: wpr-runtime-core<0.3,>=0.2.0
+Requires-Dist: wpr-runtime-core<0.3,>=0.2.8
 
 # WPR HTTP
 
@@ -50,3 +50,44 @@ The native network runtime is a separate download from the private
 `childclm/gecko-web-runtime` Release. Installation needs access to that repository. Set
 `WPR_GITHUB_TOKEN` or `GH_TOKEN`, or use Git Credential Manager, then run
 `python -m wpr_http install-runtime --version 155`.
+# Per-request Fetch Metadata policy
+
+`header_policy="native"` is the backward-compatible default. Gecko generates
+Fetch Metadata from the native Channel context and may overwrite explicit
+`Sec-Fetch-*` headers. To preserve explicit metadata in the standalone HTTP
+transport, use:
+
+```python
+response = await client.get(
+    "https://example.com/api",
+    headers={"Sec-Fetch-Mode": "cors", "Sec-Fetch-Site": "cross-site"},
+    header_policy="passthrough",
+)
+```
+
+The policy can also be a client default and overridden per request. It is
+stored on prepared `Request` objects. Passthrough requires the native
+`network_header_passthrough` capability; older Workers raise
+`RuntimeCompatibilityError` before the request is sent.
+
+Passthrough suppresses automatic Fetch Metadata generation for that network
+Channel. Explicit `Sec-Fetch-*` fields survive redirects. Omitted metadata is
+not invented. This is semantic header preservation, not byte-for-byte HTTP
+replay: Host, Content-Length, HTTP/2 normalization and Gecko's credential,
+Cookie and redirect rules remain in effect. In particular this option does
+not restore Authorization or arbitrary sensitive headers on redirects. It
+does not turn the request into page `fetch()` or enable CORS preflight.
+Browser/page Workers retain Firefox's native behavior; no global preference
+or upstream SecFetch implementation is changed.
+
+This requires Network Runtime 155.0.9 or later; the Python change alone does
+not update an installed binary. Upgrade both components:
+
+```powershell
+uv pip install --upgrade wpr-http
+python -m wpr_http install-runtime --version 155
+```
+
+`wpr-runtime-core` 0.2.3 selects network and browser defaults independently:
+network 155.0.9, browser 155.0.8. An explicitly pinned older runtime stays
+pinned and raises a compatibility error for passthrough requests.

wpr_http-0.2.2/README.md

@@ -0,0 +1,82 @@
+# WPR HTTP
+
+Standalone HTTP requests using real, version-selected Firefox Necko/NSS network
+Workers. Installing this package does not install the WPR browser client.
+The native runtime is downloaded separately and remains centrally built.
+
+```python
+import asyncio
+from wpr_http import AsyncClient
+
+async def main():
+    async with AsyncClient(firefox_version="155") as client:
+        response = await client.get("https://www.baidu.com/")
+        async with response:
+            response.raise_for_status()
+            print(response.status_code, await response.atext())
+
+asyncio.run(main())
+```
+
+`firefox_version` selects a genuine installed Gecko network engine, not a
+User-Agent string or a simulated browser. Only Firefox 155 is currently built
+and supported. Selecting another version raises an explicit compatibility error;
+it never silently uses 155. Different installed engine versions use separate
+runtime/profile locations and separate Worker processes.
+
+Runtime installation and supported versions:
+
+```powershell
+python -m wpr_http runtimes
+python -m wpr_http install-runtime --version 155
+```
+
+An explicit `runtime_home` can select another verified runtime installation.
+Existing `AsyncWprHttpClient`, Request/Response/Timeout and exception names remain
+available. `WprHttpClient` remains the historical asynchronous alias.
+
+The native network runtime is a separate download from the private
+`childclm/gecko-web-runtime` Release. Installation needs access to that repository. Set
+`WPR_GITHUB_TOKEN` or `GH_TOKEN`, or use Git Credential Manager, then run
+`python -m wpr_http install-runtime --version 155`.
+# Per-request Fetch Metadata policy
+
+`header_policy="native"` is the backward-compatible default. Gecko generates
+Fetch Metadata from the native Channel context and may overwrite explicit
+`Sec-Fetch-*` headers. To preserve explicit metadata in the standalone HTTP
+transport, use:
+
+```python
+response = await client.get(
+    "https://example.com/api",
+    headers={"Sec-Fetch-Mode": "cors", "Sec-Fetch-Site": "cross-site"},
+    header_policy="passthrough",
+)
+```
+
+The policy can also be a client default and overridden per request. It is
+stored on prepared `Request` objects. Passthrough requires the native
+`network_header_passthrough` capability; older Workers raise
+`RuntimeCompatibilityError` before the request is sent.
+
+Passthrough suppresses automatic Fetch Metadata generation for that network
+Channel. Explicit `Sec-Fetch-*` fields survive redirects. Omitted metadata is
+not invented. This is semantic header preservation, not byte-for-byte HTTP
+replay: Host, Content-Length, HTTP/2 normalization and Gecko's credential,
+Cookie and redirect rules remain in effect. In particular this option does
+not restore Authorization or arbitrary sensitive headers on redirects. It
+does not turn the request into page `fetch()` or enable CORS preflight.
+Browser/page Workers retain Firefox's native behavior; no global preference
+or upstream SecFetch implementation is changed.
+
+This requires Network Runtime 155.0.9 or later; the Python change alone does
+not update an installed binary. Upgrade both components:
+
+```powershell
+uv pip install --upgrade wpr-http
+python -m wpr_http install-runtime --version 155
+```
+
+`wpr-runtime-core` 0.2.3 selects network and browser defaults independently:
+network 155.0.9, browser 155.0.8. An explicitly pinned older runtime stays
+pinned and raises a compatibility error for passthrough requests.

{wpr_http-0.2.0 → wpr_http-0.2.2}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wpr-http"
-version = "0.2.0"
+version = "0.2.2"
 description = "Standalone HTTP client using version-selected Firefox Necko/NSS Workers"
 readme = "README.md"
 requires-python = ">=3.10"
 license = {text = "MPL-2.0-compatible client; see runtime bundle notices"}
-dependencies = ["wpr-runtime-core>=0.2.0,<0.3"]
+dependencies = ["wpr-runtime-core>=0.2.8,<0.3"]
 
 [project.urls]
 Repository = "https://github.com/childclm/wpr-http"

{wpr_http-0.2.0 → wpr_http-0.2.2}/tests/test_contracts.py

@@ -119,12 +119,16 @@ def test_unpublished_version_never_silently_falls_back(monkeypatch):
 
 
 def test_registration_preserves_other_engines_and_exact_builds(tmp_path, monkeypatch):
+    from wpr_runtime_core import installer
     from wpr_runtime_core.installer import _write_config, config_path
 
     monkeypatch.setenv("LOCALAPPDATA", str(tmp_path / "appdata"))
     monkeypatch.delenv("WPR_RUNTIME_HOME", raising=False)
     a, _ = make_runtime(tmp_path, "155")
     b, _ = make_runtime(tmp_path, "156")
+    monkeypatch.setattr(installer, "NETWORK_RELEASES", {
+        "155": {"version": "155.0.6"}, "156": {"version": "156.0.6"},
+    })
     _write_config(a, product="network")
     _write_config(b, product="network")
     settings = json.loads(config_path().read_text(encoding="utf-8"))
@@ -157,11 +161,13 @@ def test_catalog_selects_default_and_exact_build_without_fallback(monkeypatch):
     older = deepcopy(releases["builds"]["155.0.6"])
     older["version"] = "155.0.5"
     releases["builds"]["155.0.5"] = older
+    missing_build = "155.999.999"
+    releases["builds"].pop(missing_build, None)
     monkeypatch.setattr(installer, "RUNTIME_CATALOG", catalog)
-    assert installer.select_release("155")["version"] == "155.0.6"
+    assert installer.select_release("155", product="network")["version"] == releases.get("default_network_build", releases["default_build"])
     assert installer.select_release("155.0.5")["version"] == "155.0.5"
     with pytest.raises(RuntimeCompatibilityError, match="no published runtime"):
-        installer.select_release("155.0.4")
+        installer.select_release(missing_build)
 
 
 @pytest.mark.parametrize("kind", ["protocol", "abi", "hash", "escape"])

wpr_http-0.2.2/tests/test_header_policy.py

@@ -0,0 +1,67 @@
+import asyncio
+
+import pytest
+
+from wpr_http import AsyncClient, Request, RuntimeCompatibilityError
+from wpr_http.transport import GeckoNetworkTransport
+from wpr_runtime_core.session import RuntimeConfig
+
+
+def test_request_policy_defaults_and_client_override(tmp_path):
+    config = RuntimeConfig(package_root=tmp_path, runtime_dir=tmp_path,
+                           worker_exe=tmp_path / "unused-worker.exe")
+    client = AsyncClient(config=config, header_policy="passthrough")
+    assert Request("GET", "http://fixture").header_policy == "native"
+    assert client.build_request("GET", "http://fixture").header_policy == "passthrough"
+    assert client.build_request("GET", "http://fixture", header_policy="native").header_policy == "native"
+
+
+@pytest.mark.parametrize("value", ["cors", "", False, None])
+def test_invalid_policy(value):
+    with pytest.raises(ValueError, match="header_policy"):
+        Request("GET", "http://fixture", header_policy=value)
+    with pytest.raises(ValueError, match="header_policy"):
+        AsyncClient(header_policy=value)
+
+
+class Session:
+    def __init__(self, supported=True):
+        self.supported = supported
+        self.probes = 0
+        self.sent = []
+
+    async def request(self, payload):
+        assert payload == {"method": "runtime.capabilities"}
+        self.probes += 1
+        await asyncio.sleep(0)
+        return {"ok": True, "value": {"network_header_passthrough": self.supported}}
+
+    async def request_with_timing(self, payload):
+        self.sent.append(payload)
+        return {"ok": True}, {"test": 1}
+
+
+@pytest.mark.asyncio
+async def test_capability_is_cached_per_worker_under_concurrency():
+    transport = GeckoNetworkTransport()
+    session = Session()
+    request = Request("POST", "http://fixture", headers={"Sec-Fetch-Mode": "cors"},
+                      content="body", header_policy="passthrough")
+    await asyncio.gather(*(transport._send_passthrough(session, request) for _ in range(20)))
+    assert session.probes == 1
+    assert len(session.sent) == 20
+    assert session.sent[0]["header_policy"] == "passthrough"
+    assert session.sent[0]["body"] == "body"
+    assert session.sent[0]["headers"]["Sec-Fetch-Mode"] == "cors"
+    another = Session()
+    await transport._send_passthrough(another, request)
+    assert another.probes == 1
+
+
+@pytest.mark.asyncio
+async def test_old_worker_is_rejected_before_network_request():
+    session = Session(supported=False)
+    with pytest.raises(RuntimeCompatibilityError, match="update the native runtime"):
+        await GeckoNetworkTransport()._send_passthrough(
+            session, Request("GET", "http://fixture", header_policy="passthrough"))
+    assert session.sent == []

wpr_http-0.2.2/tests/test_native_header_policy.py

@@ -0,0 +1,136 @@
+"""Receiver-side contracts; opt in with WPR_TEST_WORKER_EXE."""
+import asyncio
+import json
+import os
+import threading
+from dataclasses import replace
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+import pytest
+
+from wpr_http import AsyncClient
+
+pytestmark = pytest.mark.skipif(not os.environ.get("WPR_TEST_WORKER_EXE"),
+                                reason="requires a freshly built native Worker")
+
+
+class Echo(BaseHTTPRequestHandler):
+    def log_message(self, *_):
+        pass
+
+    def do_GET(self):
+        if self.path.startswith("/redirect"):
+            target = self.server.other if self.path == "/redirect-cross" else self.server.server_port
+            self.send_response(302)
+            self.send_header("Location", f"http://127.0.0.1:{target}/echo")
+            self.send_header("Content-Length", "0")
+            self.end_headers()
+            return
+        size = int(self.headers.get("Content-Length", "0"))
+        body = json.dumps({"headers": {k.lower(): v for k, v in self.headers.items()},
+                           "body": self.rfile.read(size).decode() if size else ""}).encode()
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Set-Cookie", "policy=kept; Path=/")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    do_POST = do_GET
+
+
+@pytest.fixture
+def fixture():
+    servers = [ThreadingHTTPServer(("127.0.0.1", 0), Echo) for _ in range(2)]
+    for server in servers:
+        server.other = servers[1].server_port
+    threads = [threading.Thread(target=s.serve_forever, daemon=True) for s in servers]
+    for thread in threads:
+        thread.start()
+    worker = Path(os.environ["WPR_TEST_WORKER_EXE"])
+    base = AsyncClient(firefox_version="155", runtime_home=os.environ.get("WPR_TEST_RUNTIME_HOME")).config
+    config = replace(base, worker_exe=worker, network_worker_exe=worker,
+                     runtime_dir=worker.parent, proxy="")
+    try:
+        yield config, f"http://127.0.0.1:{servers[0].server_port}"
+    finally:
+        for server in servers:
+            server.shutdown()
+            server.server_close()
+        for thread in threads:
+            thread.join()
+
+
+EXPLICIT = {"Sec-Fetch-Mode": "cors", "Sec-Fetch-Site": "cross-site",
+            "Sec-Fetch-Dest": "empty", "Sec-Fetch-User": "?1", "X-Probe": "kept",
+            "Origin": "https://source.example.net", "Referer": "https://source.example.net/"}
+
+
+@pytest.mark.asyncio
+async def test_default_passthrough_and_cookie_body(fixture):
+    config, root = fixture
+    async with AsyncClient(config=config, proxy="") as client:
+        native = await (await client.get(root, headers=EXPLICIT)).ajson()
+        assert native["headers"]["sec-fetch-mode"] == "no-cors"
+        assert native["headers"]["sec-fetch-site"] == "none"
+        response = await client.post(root, headers=EXPLICIT, content="payload",
+                                     header_policy="passthrough")
+        actual = await response.ajson()
+        assert actual["body"] == "payload"
+        assert "policy=kept" in actual["headers"]["cookie"]
+        for name, value in EXPLICIT.items():
+            assert actual["headers"][name.lower()] == value
+        raw = await (await client.get(root, header_policy="passthrough")).ajson()
+        assert not any(k.startswith("sec-fetch-") for k in raw["headers"])
+        after = await (await client.get(root)).ajson()
+        assert after["headers"]["sec-fetch-mode"] == "no-cors"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("path", ["/redirect", "/redirect-cross"])
+async def test_redirect_preserves_metadata_not_credentials(fixture, path):
+    config, root = fixture
+    async with AsyncClient(config=config, proxy="") as client:
+        headers = {**EXPLICIT, "Authorization": "Bearer fixture-only"}
+        actual = await (await client.get(root + path, headers=headers,
+                                         header_policy="passthrough")).ajson()
+        for key in ("sec-fetch-mode", "sec-fetch-site", "sec-fetch-dest", "sec-fetch-user"):
+            assert actual["headers"][key] == {k.lower(): v for k, v in EXPLICIT.items()}[key]
+        if path == "/redirect-cross":
+            assert "authorization" not in actual["headers"]
+
+
+@pytest.mark.asyncio
+async def test_mixed_policies_share_one_worker_without_leakage(fixture):
+    config, root = fixture
+    async with AsyncClient(config=config, proxy="", max_workers=1, max_channels_per_worker=20) as client:
+        async def one(i):
+            policy = "passthrough" if i % 2 else "native"
+            headers = {k.lower(): v for k, v in EXPLICIT.items()} if i % 3 else EXPLICIT
+            actual = await (await client.get(root, headers=headers, header_policy=policy)).ajson()
+            expected = ("cors", "cross-site") if i % 2 else ("no-cors", "none")
+            assert (actual["headers"]["sec-fetch-mode"], actual["headers"]["sec-fetch-site"]) == expected
+        await asyncio.gather(*(one(i) for i in range(40)))
+        assert client.transport_stats["worker_count"] == 1
+
+
+@pytest.mark.asyncio
+async def test_nonmultiplex_pipe_and_client_default(fixture):
+    config, root = fixture
+    async with AsyncClient(config=config, proxy="", header_policy="passthrough",
+        ipc_backend="threaded", release_mode="immediate", max_channels_per_worker=1) as client:
+        actual = await (await client.get(root, headers=EXPLICIT)).ajson()
+        assert actual["headers"]["sec-fetch-mode"] == "cors"
+        native = await (await client.get(root, headers=EXPLICIT, header_policy="native")).ajson()
+        assert native["headers"]["sec-fetch-mode"] == "no-cors"
+
+
+@pytest.mark.asyncio
+async def test_invalid_policy_rpc_is_rejected(fixture):
+    config, root = fixture
+    async with AsyncClient(config=config, proxy="") as client:
+        raw = await client._slots[0].session.request({"method": "network.fetch",
+            "url": root, "header_policy": "invalid-policy"})
+        assert raw["ok"] is False
+        assert raw["error"]["code"] == "INVALID_HEADER_POLICY"

{wpr_http-0.2.0 → wpr_http-0.2.2}/wpr_http/__init__.py

@@ -14,7 +14,7 @@ from .exceptions import (
 )
 from .models import Headers, HttpRequest, HttpResponse, NetworkTiming, Request, Timeout
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 
 
 class AsyncClient(AsyncWprHttpClient):

{wpr_http-0.2.0 → wpr_http-0.2.2}/wpr_http/client.py

@@ -83,7 +83,11 @@ class AsyncWprHttpClient:
         release_mode: str = "piggyback",
         ipc_backend: str = "iocp",
         max_channels_per_worker: int = 20,
+        header_policy: str = "native",
     ) -> None:
+        if header_policy not in {"native", "passthrough"}:
+            raise ValueError("header_policy must be 'native' or 'passthrough'")
+        self.header_policy = header_policy
         try:
             worker_limit = integer_index(max_workers)
         except TypeError:
@@ -340,6 +344,7 @@ class AsyncWprHttpClient:
         params: Mapping[str, Any] | Sequence[tuple[str, Any]] | None = None,
         timeout: float | Timeout | None | object = _UNSET,
         follow_redirects: bool | None = None,
+        header_policy: str | None = None,
     ) -> Request:
         """Merge client defaults and return a prepared, inspectable request."""
         if sum(value is not None for value in (content, data, json)) > 1:
@@ -382,6 +387,7 @@ class AsyncWprHttpClient:
             headers=request_headers,
             content=request_body,
             timeout=selected_timeout,
+            header_policy=self.header_policy if header_policy is None else header_policy,
             follow_redirects=(
                 self.follow_redirects
                 if follow_redirects is None

{wpr_http-0.2.0 → wpr_http-0.2.2}/wpr_http/models.py

@@ -101,8 +101,11 @@ class Request:
     content: str | None = None
     timeout: Timeout | float | None = field(default_factory=Timeout)
     follow_redirects: bool = True
+    header_policy: str = "native"
 
     def __post_init__(self) -> None:
+        if self.header_policy not in {"native", "passthrough"}:
+            raise ValueError("header_policy must be 'native' or 'passthrough'")
         object.__setattr__(self, "method", self.method.upper())
         object.__setattr__(self, "headers", Headers(self.headers))
         if not isinstance(self.timeout, Timeout):

{wpr_http-0.2.0 → wpr_http-0.2.2}/wpr_http/transport.py

@@ -4,8 +4,10 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import weakref
 
 from wpr_runtime_core.data_plane import SharedBlob, SharedBlobDescriptor
+from wpr_runtime_core.registry import RuntimeCompatibilityError
 from wpr_runtime_core.session import AsyncWorkerSession as AsyncGeckoWorkerSession
 
 from ._urls import safe_url
@@ -18,6 +20,28 @@ _logger = logging.getLogger("wpr_http")
 class GeckoNetworkTransport:
     """One-request adapter; all Gecko protocol details stay below the client."""
 
+    def __init__(self) -> None:
+        self._header_capabilities = weakref.WeakKeyDictionary()
+
+    async def _send_passthrough(self, session, request):
+        capability_task = self._header_capabilities.get(session)
+        if capability_task is None:
+            capability_task = asyncio.create_task(session.request({"method": "runtime.capabilities"}))
+            self._header_capabilities[session] = capability_task
+        response = await asyncio.shield(capability_task)
+        if not response.get("ok") or not response.get("value", {}).get("network_header_passthrough"):
+            raise RuntimeCompatibilityError(
+                "header_policy='passthrough' requires a Network Worker with "
+                "network_header_passthrough support; update the native runtime"
+            )
+        payload = {"method": "network.fetch", "url": request.url,
+                   "http_method": request.method, "headers": dict(request.headers),
+                   "follow_redirects": request.follow_redirects,
+                   "header_policy": "passthrough"}
+        if request.content is not None:
+            payload["body"] = request.content
+        return await session.request_with_timing(payload)
+
     async def send(
         self,
         session: AsyncGeckoWorkerSession,
@@ -34,7 +58,9 @@ class GeckoNetworkTransport:
             "follow_redirects": request.follow_redirects,
         }
         timed_fetch = getattr(session, "network_fetch_with_timing", None)
-        if timed_fetch is None:
+        if request.header_policy == "passthrough":
+            operation = self._send_passthrough(session, request)
+        elif timed_fetch is None:
 
             async def legacy_fetch():
                 return await session.network_fetch(request.url, **fetch_kwargs), {}

{wpr_http-0.2.0 → wpr_http-0.2.2}/wpr_http.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: wpr-http
-Version: 0.2.0
+Version: 0.2.2
 Summary: Standalone HTTP client using version-selected Firefox Necko/NSS Workers
 License: MPL-2.0-compatible client; see runtime bundle notices
 Project-URL: Repository, https://github.com/childclm/wpr-http
 Project-URL: Documentation, https://github.com/childclm/wpr-http/blob/main/README.md
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: wpr-runtime-core<0.3,>=0.2.0
+Requires-Dist: wpr-runtime-core<0.3,>=0.2.8
 
 # WPR HTTP
 
@@ -50,3 +50,44 @@ The native network runtime is a separate download from the private
 `childclm/gecko-web-runtime` Release. Installation needs access to that repository. Set
 `WPR_GITHUB_TOKEN` or `GH_TOKEN`, or use Git Credential Manager, then run
 `python -m wpr_http install-runtime --version 155`.
+# Per-request Fetch Metadata policy
+
+`header_policy="native"` is the backward-compatible default. Gecko generates
+Fetch Metadata from the native Channel context and may overwrite explicit
+`Sec-Fetch-*` headers. To preserve explicit metadata in the standalone HTTP
+transport, use:
+
+```python
+response = await client.get(
+    "https://example.com/api",
+    headers={"Sec-Fetch-Mode": "cors", "Sec-Fetch-Site": "cross-site"},
+    header_policy="passthrough",
+)
+```
+
+The policy can also be a client default and overridden per request. It is
+stored on prepared `Request` objects. Passthrough requires the native
+`network_header_passthrough` capability; older Workers raise
+`RuntimeCompatibilityError` before the request is sent.
+
+Passthrough suppresses automatic Fetch Metadata generation for that network
+Channel. Explicit `Sec-Fetch-*` fields survive redirects. Omitted metadata is
+not invented. This is semantic header preservation, not byte-for-byte HTTP
+replay: Host, Content-Length, HTTP/2 normalization and Gecko's credential,
+Cookie and redirect rules remain in effect. In particular this option does
+not restore Authorization or arbitrary sensitive headers on redirects. It
+does not turn the request into page `fetch()` or enable CORS preflight.
+Browser/page Workers retain Firefox's native behavior; no global preference
+or upstream SecFetch implementation is changed.
+
+This requires Network Runtime 155.0.9 or later; the Python change alone does
+not update an installed binary. Upgrade both components:
+
+```powershell
+uv pip install --upgrade wpr-http
+python -m wpr_http install-runtime --version 155
+```
+
+`wpr-runtime-core` 0.2.3 selects network and browser defaults independently:
+network 155.0.9, browser 155.0.8. An explicitly pinned older runtime stays
+pinned and raises a compatibility error for passthrough requests.

{wpr_http-0.2.0 → wpr_http-0.2.2}/wpr_http.egg-info/SOURCES.txt

@@ -1,6 +1,8 @@
 README.md
 pyproject.toml
 tests/test_contracts.py
+tests/test_header_policy.py
+tests/test_native_header_policy.py
 tests/test_native_http.py
 wpr_http/__init__.py
 wpr_http/__main__.py

wpr_http-0.2.2/wpr_http.egg-info/requires.txt

@@ -0,0 +1 @@
+wpr-runtime-core<0.3,>=0.2.8

wpr_http-0.2.0/README.md

@@ -1,41 +0,0 @@
-# WPR HTTP
-
-Standalone HTTP requests using real, version-selected Firefox Necko/NSS network
-Workers. Installing this package does not install the WPR browser client.
-The native runtime is downloaded separately and remains centrally built.
-
-```python
-import asyncio
-from wpr_http import AsyncClient
-
-async def main():
-    async with AsyncClient(firefox_version="155") as client:
-        response = await client.get("https://www.baidu.com/")
-        async with response:
-            response.raise_for_status()
-            print(response.status_code, await response.atext())
-
-asyncio.run(main())
-```
-
-`firefox_version` selects a genuine installed Gecko network engine, not a
-User-Agent string or a simulated browser. Only Firefox 155 is currently built
-and supported. Selecting another version raises an explicit compatibility error;
-it never silently uses 155. Different installed engine versions use separate
-runtime/profile locations and separate Worker processes.
-
-Runtime installation and supported versions:
-
-```powershell
-python -m wpr_http runtimes
-python -m wpr_http install-runtime --version 155
-```
-
-An explicit `runtime_home` can select another verified runtime installation.
-Existing `AsyncWprHttpClient`, Request/Response/Timeout and exception names remain
-available. `WprHttpClient` remains the historical asynchronous alias.
-
-The native network runtime is a separate download from the private
-`childclm/gecko-web-runtime` Release. Installation needs access to that repository. Set
-`WPR_GITHUB_TOKEN` or `GH_TOKEN`, or use Git Credential Manager, then run
-`python -m wpr_http install-runtime --version 155`.

wpr_http-0.2.0/wpr_http.egg-info/requires.txt

@@ -1 +0,0 @@
-wpr-runtime-core<0.3,>=0.2.0