Use the upstream fixture server limit of 512 header lines so requests
with all 253 valid header values can reach the handler instead of
receiving HTTP 431. Cover complete GET/POST header round trips and
retain count and line-length bounds.
Validation: all 596 benchmark Python tests pass; Moli passes all 537
Headers WPT subtests. Both engines pass all 105 header value and
normalization subtests, with Chromium's 24 unrelated failures unchanged.
Route POST, OPTIONS, and extension methods through the existing header
inspection fixture, preserving response metadata and CORS behavior.
Close connections with unread uploads so header-only inspection can
respond immediately.
Validate with 45 HTTP fixture tests and the upstream header normalization
cases in Moli and Chromium (93/93 each, up from 63/93).
Use the CSS token stream to recognize empty rootMargin and scrollMargin
values, including comments, and reject unitless numbers even when zero.
Cover CSS whitespace, invalid tokens, and valid shorthand through both
the parser and IntersectionObserver constructor.
Convert option members in WebIDL order, including root brand validation and
the threshold double-or-sequence union. Propagate conversion failures before
constructor margin/range validation and retain duplicate thresholds when sorting.
Cover iterable discrimination, getter order, exception precedence, and later
getter mutations; update the existing duplicate-threshold expectations.
Return SyntaxError DOMExceptions when rootMargin or scrollMargin parsing fails.
Use the renderer intrinsic exception factory so replacing globalThis.DOMException
cannot change the result, and preserve WebIDL getter and conversion exceptions.
Add regression coverage for both margin fields and update the existing option
surface and ported fixture expectations.
Convert complete nested sequences before Headers and URLSearchParams validate pair lengths or header syntax. Use the shared sequence converter for Headers inner iterables so later conversion exceptions take precedence and indexed length access is unnecessary.
Cover conversion order, exception identity, inner iterable behavior, and extra pair elements for Headers, URLSearchParams, Request, and Response.
Stop reading or calling iterator.return when WebIDL element conversion
fails. Propagate the original exception directly, including failures in
nested sequences and interface-valued sequences.
Cover string, numeric, interface and iterator-protocol failures. Correct
old URLSearchParams closure expectations and make invalid-pair fixtures
finite so their behavior can also be checked in Chromium.
Use sequence/record discrimination for native Headers, URLSearchParams,
FormData, and URL initializers. Read the author iterator once, preserve
its result or exception, and use own record properties when it is absent.
Cover Request and Response headers, enumerable iterator symbols, and
FormData File conversion. Remove unused imports and the URL
stringification helper.
Collect all own keys, then inspect each current property descriptor before
converting its key and value. Record conversion now observes Proxy traps,
getter-driven property changes and abrupt completion in WebIDL order.
Preserve normalized duplicate-key replacement and cover Headers,
URLSearchParams and ClipboardItem, including thenable conversion order.
Correct the local URLSearchParams smoke expectation: non-enumerable symbol
keys are ignored, while enumerable symbol keys throw before value access.
Validation:
- cargo fmt --all
- cargo clippy --workspace --all-targets --all-features -- -D warnings
- cargo nextest run --no-fail-fast: 18,208 passed, 13 skipped
- Headers upstream WPT: 490/537 -> 504/537 (+14), no new failures
- URLSearchParams and ClipboardItem constructor regressions: 82/82
- Record behavior probes: 5/5 in Moli and Chromium
- Local URLSearchParams smoke: 26/26 in Moli; changed symbol checks: 2/2
in both engines. The full legacy smoke page times out in Chromium before
and after this change, so only its changed assertions claim parity.
Give Cache.put its own response admission rules: accept Response.error(),
and reject public status 206 or Vary: * before consuming the body. Keep
filtered internal response metadata available for storage and respondWith.
Reconstruct error responses without invoking the global Response
constructor and make headers on all cached responses immutable. Cover
failed replacement, streaming bodies, cloned errors and global tampering.
Carry the original response filter and validation state through Window
streams and Worker completions, including paused responses. Synthesized
responses remain basic, and already fetched bodies are not filtered by ORB
again. Keep client CORP/COEP checks against actual network response URLs.
Retain internal headers separately from the CORS public header view through
clone, deferred Cache.put, persistent Cache storage and respondWith. Match
Vary using the public header view and keep filtered cached headers immutable.
Keep internal response status, status text and headers through Window and
Worker fetch, Response.clone(), Cache storage and FetchEvent.respondWith().
This preserves CORP checks when a require-corp client receives an opaque
response from a service worker.
Keep public opaque headers empty and immutable, and use the public header
view when matching Vary in Cache. Cover streamed and materialized responses,
opaque redirects, filtered HTTP 206 responses and Vary:* cache roundtrips.
Reject invalid filtered respondWith responses before following their
restored internal Location headers.
Apply the data-scheme exception when selecting response filtering and the
observable response type. Data URL origins remain opaque, while no-cors
fetches retain their status, immutable headers and response body.
Cover Window and opaque-origin Worker fetches across request modes,
redirect modes, GET/HEAD/POST, Request clones, URL fragments, MIME types,
binary body reads, response clones and bodyUsed behavior.
Reject cross-origin HTTP(S) no-cors requests with manual or error redirect
mode before transport, CDP interception, or Service Worker dispatch in
Window and Worker fetch. Check the logical URL at the fetch entry point
so a CDP transport URL rewrite retains the original policy decision.
Cover non-redirecting responses, Request clones and init overrides,
local URL fetches, argument and abort precedence, interception ordering,
and Service Worker dispatch counts.
Route Window and Worker Fetch/XHR through per-hop authorization even for
safelisted requests. Reject unauthorized or credentialed cross-origin
redirects before contacting the next URL, strip cross-origin Authorization,
and preserve redirect origin, cookie, network-event and referrer state.
Discard unused preflight and redirect bodies without delaying the final
stream. Give each transfer private cancellation while sharing parent aborts
and only the accepted final response's completion facts. Select manual and
error modes from the redirect status before parsing Location.
Cover 930 Window/Worker Fetch and synchronous/asynchronous XHR scenarios,
including forbidden destination contact and request headers, plus transport
cancellation and referrer-policy regressions.
Validation:
- cargo fmt --all
- cargo clippy --workspace --all-targets --all-features -- -D warnings
- cargo nextest run --no-fail-fast: 18,188 passed, 13 skipped
- 252 CORS/Redirect/XHR WPT cases: 1,603 -> 1,841 passing subtests out of
2,007, with no newly failing cases or subtests
Serve Fetch redirect.py with upstream Origin and credentials responses,
preflight handling, query inheritance, counters, delays and form status codes.
Recognize its relative, absolute and RESOURCES_DIR references during discovery.
Cover the HTTP behavior and discovery with regressions. Verify the fixture
against upstream wptserve, including byte parsing and unread request bodies.
Combine all matching Access-Control-Allow-Origin and credentialed
Access-Control-Allow-Credentials fields before validating the response.
Empty duplicates and repeated matching values must also fail the CORS check.
Cover ordinary responses, preflight rejection, and responses after preflight
in Window and Worker Fetch plus asynchronous and synchronous XHR.
Share Fetch body filtering with local responses and XHR, complete null-body streams at headers, and preserve replacement request progress when old completions arrive.
Cover Window and Worker response types, synthetic null-body statuses, empty response event order, and request reuse.
Ignore unsupported responseType values without resetting the selected type,
including historical moz-* tokens. Convert the value to a string before XHR
state checks and preserve conversion exceptions and reentrant state changes.
A missing setter argument is converted like undefined and ignored.
Validate native getter/setter receivers before conversion. Ignore document in
Workers before checking LOADING or DONE, while retaining InvalidStateError and
InvalidAccessError for valid values where the XHR setter algorithm requires it.
Cover Window and Worker conversion, borrowed accessors, forged receivers,
response identity, and open/send reentrancy over real HTTP. Correct the legacy
test expectations for invalid enum assignments and historical moz-* tokens.
https://webidl.spec.whatwg.org/#dfn-attribute-setterhttps://xhr.spec.whatwg.org/#the-responsetype-attribute
Validation: cargo fmt --all; workspace Clippy with all targets/features and
-D warnings; cargo nextest run --no-fail-fast (18161 passed, 13 skipped).
192 upstream WPT cases: 175 -> 178 pass, 726 -> 748 passing subtests,
no new regressions. Window and Worker responseType matrices both pass 50/50.
Reject invalid HTTP method tokens with SyntaxError and forbidden methods with
SecurityError. Share validation with Fetch while preserving its TypeError
behavior. Validate native receivers before argument conversion and document
activity before method and URL processing.
Create exceptions in the invoked method realm, including when DOMException is
first materialized after WindowProxy detachment. Resolve its prototype from
the realm-owned intrinsic registry. Preserve pending requests, headers,
responses, and events when open fails.
Cover Window and Worker conversion order, native receiver identity, cross-realm
inactive documents, retired cold realms, and request preservation on the wire.
Validation: cargo fmt --all; workspace Clippy with all targets/features and
-D warnings; cargo nextest run --no-fail-fast (18157 passed, 13 skipped).
189 upstream WPT cases: 171 -> 174 pass, 624 -> 642 passing subtests. Four
cases improve. open-url-multi-window-6.htm now fails its caller-realm
constructor assertion; two popup probes using the method-realm expectation
improve from fail to pass. The original WPT and raw comparison are unchanged.
WebIDL specifies the method realm for DOMExceptions:
https://webidl.spec.whatwg.org/#js-creating-throwing-exceptions
Complete active page XHRs with the request-error steps when a response
stream fails after delivering partial data. Reset the response and dispatch
error/loadend instead of leaving the request in LOADING.
Check the request identity for stream and body-materialization failures so
queued errors cannot overwrite an aborted or reopened XHR. Exercise real
truncated Content-Length and malformed chunked responses, including abort,
open, and resend before a queued failure is delivered.
Validation: cargo fmt --all; full workspace clippy with warnings denied;
cargo nextest run --no-fail-fast (18,153 passed, 13 skipped).
Focused upstream WPT: 83/88 cases and 133/143 subtests pass, up from 82/88
and 132/143, with no regressions. Page malformed-body error now passes.
Serve the upstream malformed chunk sequence and infinite redirect loop
instead of returning Python source. Preserve redirect parameters and origin,
explicit raw body writes, and supported endpoint filtering.
Validation: all 550 benchmark tests pass, including raw wire and partial
HTTP body decoding regressions. With the same Moli binary, 88 focused WPT
cases improve from 77 to 82 passes (127 to 132 of 143 subtests).
The corrected fixture also exposes a page XHR bug: malformed-body handling
now times out instead of failing on unexpected load. Its streaming failure
branch records the network error without dispatching XHR error/loadend;
that engine fix follows separately. The worker variant now passes.
Route URL and network policy rejections through the pending worker XHR
completion queue so send() returns before error delivery. Immediate abort()
and open() can cancel the queued failure. Validate request identity before
applying a completion so old failures cannot overwrite a new send.
Cover six rejection causes, listeners installed after send, microtask abort,
reopen and resend, synchronous NetworkError, and duplicate failure records.
Validation: cargo fmt --all; full workspace clippy with warnings denied;
cargo nextest run --no-fail-fast (18,152 passed, 13 skipped).
Focused upstream WPT: 77/86 cases and 127/141 subtests pass, up from 76/86
and 126/141, with no regressions. Worker abort-with-error now passes.
Observe transmitted request bytes in the native transport and queue upload
progress and completion in the owning page or worker realm. Cover empty
bodies, resumed requests, redirects, and partial uploads without fabricating
completion during send().
Mark uploads complete before final callbacks and reject stale events after
abort or reopen. Preserve upload error events and update local smoke tests
to collect the full final upload task.
Validation: cargo fmt --all; full workspace clippy with warnings denied;
cargo nextest run --no-fail-fast (18,148 passed, 13 skipped).
Focused upstream WPT: 67/73 passing versus 65/73, 114/125 subtests versus
112/125, with no regressions.
Snapshot upload listeners before send callbacks and carry the preflight
requirement through page and worker requests, redirects, interception,
authentication continuations, and service worker network fallback. Route
synchronous worker XHR through the shared CORS transport and validate
preflight responses using the actual request credentials mode.
Add real HTTP regressions for listener timing, sync and async requests,
redirects, interception, credentials, and denied preflights. Update existing
PageVm response fixtures to authorize preflights before testing the actual
CORS response and to respect the shared redirect limit.
Validation: cargo fmt --all; full workspace clippy with warnings denied;
cargo nextest run --no-fail-fast (18,142 passed, 13 skipped). The 73 selected
upstream WPT cases retain 65 passing cases and 112/125 passing subtests,
with no regressions.
Dispatch XHR loadstart before upload loadstart and report zero initially transmitted bytes. Snapshot registered upload listeners before callbacks and preserve requests reopened or aborted during startup in both page and worker realms.
Use non-computable zero-total upload events and update local compatibility expectations. Real transport-driven upload progress and completion remain a separate follow-up.
Validation: cargo fmt --all; cargo clippy --workspace --all-targets --all-features -- -D warnings; cargo nextest run --no-fail-fast (18139 passed, 13 skipped). Selected upstream WPT: 51 to 59 passing cases out of 66; 68 to 80 passing subtests out of 89, with no regressions.
Match the upstream corsenabled.py response headers, request metadata reflection, query-controlled delay and additional Content-Type allowance. Recognize exact relative and absolute fixture references during XHR case selection.
Validation: all 545 Python tests pass, including six new fixture tests. With an unchanged engine binary, nine CORS WPT cases improve from 1 to 6 passing and subtests from 14 to 36 of 44, with no regressions.
Use internal ready state and the send flag to select abort error steps in both page and worker contexts. Keep OPENED requests before send unchanged, reset completed responses without new error events, and fire readystatechange before active-request abort events. Preserve requests reopened by event callbacks.
Validation: cargo fmt --all, full workspace Clippy with warnings denied, and cargo nextest run --no-fail-fast pass (18,135 passed, 13 skipped). The final binary improves 50 abort-related WPT cases from 21 to 42 passing and subtests from 31 to 54 of 62, with no regressions.
Serve the requested Content-Type and unchanged file bytes, and recognize exact absolute and relative handler references during case selection.
Validation: all 539 Python tests pass, including six new fixture tests. Eight complete charset WPT cases improve from 3 to 8 passing (32/32 subtests). Results match the upstream handler on all ten selected cases; two upstream cases omit a required ct parameter and are excluded from complete-case gains.
Keep one copy of the identical Fetch stash and status, trickle, and abort handlers, along with their regression tests. The merged status helper remains shared by Fetch and XHR.
Validation: 256 WPT fixture and harness Python tests passed.
Store the response Last-Modified timestamp on each XML or HTML response
Document using the existing HTTP date parser. Preserve current-time fallback
for unknown dates and keep metadata independent of the requester and XHR reuse.
Cover buffered and streamed responses, child-realm access, invalid and missing
headers, epoch timestamps, old response Documents, and timezone changes.
Honor response and override charsets, BOMs, and XML or HTML encoding
declarations across buffered, queued, and streaming delivery. Reuse the
HTML document decoder with UTF-8 fallback and expose its selected charset.
Keep JSON decoding fixed to UTF-8 and binary responses byte-exact.
Select the decoder after HEADERS_RECEIVED handlers can change the MIME
override. Keep queued response bytes intact and handle split BOMs and
multibyte characters in streaming text.
Carry the wire reason phrase through buffered and streaming transport,
response conversion, cache, and Window/Worker Fetch and XHR delivery.
Preserve explicitly empty messages, including HTTP/2 and HTTP/3, and
Latin-1 reason bytes while retaining existing synthetic defaults.
Bump cache metadata to version 4 and keep the original status message
when revalidating an entity with a 304 response. Cover transport modes,
cache reloads, response conversions, and streaming XHR state changes.
Return null for failed XML parsing while preserving DOMParser error Documents.
Apply the text/xml response MIME fallback and recognize arbitrary +xml
subtypes. Restrict HTML parsing to the document response type. Parse MIME
overrides at the setter so invalid values select application/octet-stream.
Cover buffered, queued and streaming responses, valid author parsererror
elements, document identity and XHR reuse.
Expose the upstream status.py response bytes, status text, Content-Type
and request method using the existing Fetch status parameter parser.
Serve well-formed.xml and its file modification date for last-modified.py.
Recognize both resource paths during case enumeration and cover real HTTP
responses, custom methods, HEAD, unused uploads, byte payloads and mtime.
Use the native live collection queries for XML and detached HTML Documents,
with stable receiver-realm objects instead of detached snapshots.
Match HTML elements and unnamespaced href/name attributes, include area in
links, alias plugins to embeds, and keep applets permanently empty.
Cover mutation, adoption, namespace filtering, borrowed getters and receiver
validation; remove the obsolete detached collection scanners.
Parse response documents with the final response URL in the XHR creation
realm. Inherit the requester origin separately for CORS responses, and keep
relative URL resolution consistent through base insertion/removal/adoption.
Validated with cargo fmt, workspace clippy, and nextest (17991 passed,
13 skipped). All 935 contract checks pass; the 75-case WPT suite gains five
passing subtests with no regressions. Chromium passes all 61 new checks.
Record the URL creator's storage key and browser partition independently of
its backing Blob, and check authorization atomically with URL removal.
Use the Worker's environment key and share opaque-origin nonce allocation
between Windows and Workers so unrelated opaque origins cannot collide.
Validated with cargo fmt, workspace clippy, and nextest (17990 passed,
13 skipped). Cross-global revoke WPT passes 3/3; all 874 contract checks pass,
with no regressions across the 68-case WPT suite.
Read headers and signal through exception-preserving helpers. Capture
conversion exceptions around Window and Worker fetch argument parsing so
rejected promises retain the original thrown value, including primitives,
instead of replacing it with a TypeError or starting a request.
Cover constructor and fetch exception identity, unused input bodies, no
network dispatch, and cross-realm Promise ownership.
Validation: cargo fmt, workspace Clippy with warnings denied, and nextest
(17987 passed, 13 skipped). 68 upstream WPT cases show no regressions.
All 832 additional checks pass, including the eight pre-existing getter
exception failures identified during the preceding blob URL fix.
ldm0