Use the existing shadow-including containment and tree-order helpers to find
frame owners directly, rather than scanning every retained shadow host.
Keep disconnected queries structural because compaction may drop candidates.
Restore shadow-frame candidates during the existing reconnection walk.
Cover ordering, reinsertion, clone/import/adoption, inert template contents
and foreign elements.
Carry newly created null and document-default registry associations through
parser handoffs instead of cloning every retained ShadowRoot after each parse.
Keep fragment, streaming, windowless and popup consumers on the same path.
Preserve the registry when attachShadow reuses a declarative root. Cover
stream notification ownership and cross-document default/null associations
with a fixture also exercised against native Chromium.
Retain local font completion queues and explicitly dispatch resource bodies and font tasks. Use the Page owner executor for Promise rejection notifications, preserving intermediate loading states and the original assertions.
Create requests after key conversion and reject transactions invalidated by author code. Preserve transaction-owned wrapper identities across borrowed methods and keep the stronger key-range regression coverage.
Share AssignedNodesOptions through WebIdlDictionary/WebIdlArgs for
assignedNodes and assignedElements. Reject primitive dictionaries, propagate
member getter exceptions and ignore unknown flattened spelling.
Resolve the node runtime after option conversion so getter mutations and
reentrant assignment queries see current state without retaining a Rust
runtime reference across user JavaScript. Keep the generated receiver check.
Cover default/member conversions, getter/proxy/receiver ordering, callee
TypeError realms and reentrant mutations in live and windowless documents.
Validation: full Rust gates, 23,787 passed/18 skipped. Normal debug/release
CLIs each match Chromium152 on all192 native controls and all3 fixtures;
the pinned old binary differs in112 controls. All178 original observations
were retained per profile; the176 fully observed non-getHTML pages retain
all2398 prior passing IDs. Native getHTML timeout/cleanup failures remain
open and also reproduce with old debug/release binaries under load; no
whole-profile compatibility or performance non-regression claim.
Use the unified origin-scoped transport authentication helper in the imported
proxy credential regression. Include the existing default Accept-Encoding in
the new complete cookie-header assertion.
Remove obsolete renderer JSON parser aliases after XHR switched to intrinsic
parsing, and initialize response cache/preload metadata in the imported
streaming JSON BOM regression.
Validation: cargo fmt --all; workspace/all-target/all-feature clippy with
-D warnings; full nextest, 23,787 passed and 18 skipped, with zero retries.
Clear native relatedTarget together with a shadow-scoped target even when
the related target has no DOM node handle, such as an XHR or Window. Keep
the initial dispatch path across listener mutations and bypass author
getters through the existing private Event state.
Cover four event interfaces, four non-Node target kinds, both shadow modes,
path mutation, composed dispatch, ordinary Event shape, and poisoned getters.
Validation: cargo fmt --all; cargo clippy --workspace --all-targets
--all-features -- -D warnings; cargo nextest run --no-fail-fast.
23,727 passed, 18 skipped; 32 build jobs/test threads, zero retries.
Use acknowledged upload reports in Window and Worker, and preserve Chromium's empty-versus-absent body event behavior. Select queued browser network notifications before delayed timers even with old V8 foreground work; retain the source FIFO, eight-turn fairness bound and ordinary foreground order.
Measure Worker XHR's first timeout deadline from send, preserve ordinary timer admission, and retire pending/ready cancellations after microtasks. Add scheduler regressions and the same 16-case Window/Worker HTML through the native CLI.
Validation: root fmt and strict workspace/all-target/all-feature Clippy; full nextest 23,723 passed / 18 existing skips, 32 threads, zero retries. Fresh normal CGU=1 release: 58/58 terminal and upload sequences match Chromium; exact CLI/CDP fixtures pass 16/16 per Window/Worker; separated 80ms/180ms controls match 12/12. Retained redirect, completed-response, selected-response and held-network regressions passed. Original XHR WPT: 139/140, four improvements and no regressions; remaining supplemental HTTPS fixture also fails in Chromium. Existing response-header and Worker keepalive differences remain documented.
Separate transport byte accounting from browser upload notifications. Poll on the existing curl owner with a 100ms cadence, coalesce reports until owner acknowledgement, and flush at final response headers/completion. Queued reports retain only weak observer identity; native immediate observers keep their existing behavior.
Cover held responses, acknowledgement backpressure, final-header flush, empty/absent bodies, early responses and cancellation with real TCP regressions.
Validation of the combined final tree: cargo fmt --all; cargo clippy --workspace --all-targets --all-features -- -D warnings; cargo nextest run --no-fail-fast (23,723 passed, 18 existing skips, 32 threads, zero retries). Fresh normal CGU=1 release and independent CLI/CDP regressions passed.
Wait asynchronously for Window/Worker XHR and Fetch owners before following each redirect, keeping unrelated resource I/O runnable and cancellation wakeable. Preserve Window keepalive and synchronous XHR paths, and cover buffered, streamed, headers-first and resumed requests. Reuse the existing Worker XHR timeout flow when a queued redirect observes an elapsed current timeout; leave ordinary Worker timers unchanged.
Add an HTTP CLI regression covering Window and a persistent Worker, independent I/O, keepalive, request modes, timeout changes, abort and synchronous XHR.
Validation: cargo fmt --all; strict workspace/all-targets/all-features Clippy; cargo nextest run --no-fail-fast (23716 passed,18 existing skips,32 threads,zero retries). Normal CGU1 release compared with Chromium152; original WPT, completed-response arbitration and held-network controls retained.
Original XHR WPT:112 observations/140 IDs,135 pass/5 fail;one historical status flip retained and reproduced with the unchanged b104 release (HTTP/HTTPS),while Chromium152 passes both. Existing Worker keepalive-after-retirement differences remain documented.
A Window or reused Worker's timeout task can run before its queued networking delivery after a long JavaScript task. Arbitrate timeout cancellation against the selected transport response through the existing resource lease, preserving completed outcomes while continuing to cancel pending requests. Keep authentication and response-interception holds timeout-able, and leave explicit abort/open cancellation unchanged.
Add a production CLI regression covering Window/Worker responses, timeout changes, incomplete bodies, author abort and request reuse.
Validation: cargo fmt --all; strict workspace/all-targets/all-features Clippy; cargo nextest run --no-fail-fast (23715 passed,18 existing skips,32 threads,zero retries). Normal CGU1 release:20 core cases and10/12 additional cases match Chromium152;2 pre-existing redirect differences retained;6 held-network cases match;112 original WPT observations/140 IDs with no new regressions.
Long synchronous XHR can exhaust the script watchdog while no author JavaScript is running. Pause the active owner-thread registrations only around the response/timeout/cancellation channel wait, then restore the remaining budgets before processing results or entering callbacks.
Use new deadline keys after resuming so stale queued expiries cannot terminate a resumed registration. Handle nested waits, disarmed registrations and already exhausted budgets without adding service threads. Keep the default eight-second JS budget and the XHR-specific timeout/cancellation paths.
Cover real HTTP waiting, post-wait runaway JavaScript, nested waits, stale expiries, disarm and recovery.
Validation on the combined source tree: cargo fmt --all; strict workspace/all-targets/all-features Clippy; cargo nextest run --no-fail-fast (23714 passed, 18 existing skips, 32 threads, zero automatic retries).
The fixture combines loading, bitmap snapshots and two native seeks under one 2.5-second case timer. Give each ready, seek and bitmap operation its own 2.5-second bound and include the operation and elapsed time in failure diagnostics. Preserve all 192 distinct pixel, frame, realm and ownership checks and the scenario driver's overall bound.
Validation on the combined source tree: cargo fmt --all; strict workspace/all-targets/all-features Clippy; cargo nextest run --no-fail-fast (23714 passed, 18 existing skips, 32 threads, zero automatic retries).
The inherited regression inspects a child navigation immediately after form.submit(), while this branch schedules form navigation on the Page task executor. Use the existing executor fixture and consume the FormNavigation task before inspecting the request. Preserve both charset cases and every byte-level assertion.
Validation on the combined source tree: cargo fmt --all; strict workspace/all-targets/all-features Clippy; cargo nextest run --no-fail-fast (23714 passed, 18 existing skips, 32 threads, zero automatic retries).
Own native resource coordination at the browser-context resource owner root,
shared across Fetch backend generations. Page and Worker authorities borrow
that executor; shutdown cancels its tasks and joins it without giving request
futures ownership of the runtime. Route Worker XHR through its captured runner.
Admit pre-scanned scripts with request policies only after their Document owner
installs those policies. Preserve runners when UA/config changes replace and
retire an old Fetch backend. Cover background progress, shutdown, backend
replacement, and production Window/Worker callback ordering.
Validation: cargo fmt --all; strict workspace/all-targets/all-features clippy;
cargo nextest run --no-fail-fast (23,709 passed, 18 existing skips; 32 jobs/test
threads, zero retries); normal release CGU=1; 286 original WPT page observations.
Window HTTP/HTTPS long-task timeout tests now pass; all 884 WebTransport test
statuses are unchanged. Existing 5ms upload-order and synchronous long-request
failures, including raw status regressions, remain recorded in docs/inner.
Accept successful CONNECT statuses and legacy-profile optional protocol metadata. Distinguish clean CONNECT FIN from malformed or interrupted capsules, retain immutable diagnostics and SDK unwind safety, and cover the behavior with real QUIC regression tests.
Notify idle Window and worker streams through weak endpoint identities, preserving realm-correct error identity. Connect the existing controller AbortSignal algorithms to native cancellation.
Deliver pending bytes before FIN and acknowledge BYOB EOF through the shared Streams source completion helper.
Observe peer termination without application demand and interrupt blocked writes or FIN acknowledgement through a bounded native driver.
Backport Quinn terminal-reader waker cleanup and preserve unmappable reset failures. Add real QUIC regressions for cancellation, FIN, invalid codes, and passive observer lifetime.
Add QUIC byte streams, datagrams, protocol negotiation and graceful close with browser DNS/TLS/address policy. Bind the connector to the Fetch semantic owner and retain independent per-session cancellation.
Include real peer lifetime tests and a Fetch connector probe validated against upstream WPT HTTP/3 handlers. JavaScript frontend integration remains separate.
Forward original Worker console arguments to the captured V8 console so CDP
preserves UTF-16 code units, native object handles and Inspector replay.
Share Window's stack-hook protection and retain CLI/classic log capture.
Remove synthetic Worker Runtime console replay and its obsolete cursor.
Reuse per-session native Console ownership to avoid duplicate notifications,
and route ServiceWorker Console commands through the existing native adapter.
Cover all Worker global kinds, replay/disable/discard, author hook isolation,
raw protocol ownership and real page/Worker replay isolation.
Reuse the native InspectorJson transport and schema-specific handle ownership. Preserve independent frontend IDs/session routing, bounded raw wire output, pause balance and automation sidecars with complete additional regressions.
Decode binding error text strictly for the scalar consumer while preserving its original error code and avoiding success state updates. Keep opaque Inspector payloads unchanged.
Canceling transports and queued tasks left XHR send flags and cached response
state live. A parent microtask could still abort a removed iframe's XHR and
receive terminal events, or inspect old response data after context retirement.
Register weak per-realm lifecycle observers and dispose live instances at the
captured LocalWindow retirement boundary, before caller microtasks. Preserve
readyState, clear response/send state, and suppress automatic XHR/upload events.
Keep deferred realm teardown idempotent and preserve same-Window document.open.
Cover immediate state snapshots across removal/navigation/document.open, weak
GC ownership, and real partial HTTP response cancellation before VM cleanup.
Validation: cargo fmt --all; cargo clippy --workspace --all-targets
--all-features -- -D warnings; cargo nextest run --no-fail-fast.
1440 focused and 23623 full tests passed; 18 skipped, 32 threads, 0 retries.
Terminate the previous Window fetch only after open() validates its arguments.
Share transport retirement with abort() while retaining each method's own state
and event transitions, and resolve the network host from the XHR receiver realm.
Cover actual TCP cancellation before headers and during a partial response,
replacement completion, invalid-open preservation, and interception retirement.
Validation: cargo fmt --all; cargo clippy --workspace --all-targets
--all-features -- -D warnings; cargo nextest run --no-fail-fast.
An immediately aborted fetch can close an accepted socket before sending an
HTTP request. The request reader returns an empty string for that EOF; avoid
parsing it as a request line and panicking the fixture server.
Keep the resource timing assertions and actual-request abort checks intact.
Validation: cargo fmt --all; cargo clippy --workspace --all-targets
--all-features -- -D warnings; cargo nextest run --no-fail-fast.
Queue local responses and failures after the initiating task's microtasks.
Use the XHR's creation context so borrowed methods retain the receiver's
Window lifetime and completion realm. Preserve generation/abort checks and
synchronous delivery.
Cover microtask cancellation, late completion, borrowed methods and iframe
retirement. Migrate existing local-response fixtures to actual task/event
completion, including the CDP failure and preserved document.open wrapper
checks. Align CSP/loadend and batch marker ordering with pinned Chromium
observations while preserving response and state assertions.
Validation: fmt; strict workspace/all-target/all-feature clippy;1348 focused
checks; full nextest23618 passed,18 skipped,zero retries.
Reuse native request policy snapshots and queue CSP listeners after the
initiating task and its microtasks. Capture the caller location and check
all policies, preserving XHR's report-only-before-enforce order separately
from Fetch and WebTransport.
Queue local asynchronous failures on the same owner FIFO as preceding CSP
tasks; keep synchronous NetworkError and existing abort/reopen/timeout
checks. Admit keepalive reports before the worker can close.
Cover synchronous/asynchronous Dedicated/Shared classic/module workers,
listener reentrancy, native identities, caller locations and top-level
await. Make the existing report-only fixture await the actual event.
Validation: cargo fmt --all; strict workspace/all-target/all-feature
clippy; 63 focused tests; full nextest 23616 passed, 18 skipped, no retries.
Share native request CSP admission with WebTransport. Capture all policy
violations and caller locations at the initiating call, then deliver events
through the existing worker task channel in enforce/report order. Admit
keepalive network reports before rejection handlers can close the Worker;
the existing per-worker report history suppresses duplicate submissions.
Allow queued CSP tasks during pending module evaluation, including those
buffered while the module graph was loading, so top-level await can wait
for a violation without blocking initialization. Keep other startup message
admission and order intact.
Cover classic/module Dedicated and Shared Workers, listener reentrancy,
Promise microtasks, error identity, captured locations and pre-wire blocking.
Wait for real CSP events in existing service-worker reporting tests.
Validation: cargo fmt --all; strict workspace/all-targets/all-features
clippy; cargo nextest run --no-fail-fast (23,615 passed, 18 skipped,
32 threads, no retries).
Keep the early-abort endpoint from sending a response head before the
Worker calls AbortController.abort. Wait for EOF or reset instead, so the
test selects a pre-header cancellation even when the native transport
executor runs before the next JavaScript statement. Keep the existing 86
JavaScript checks and the post-header abort endpoint unchanged.
Validation: cargo fmt --all; strict workspace/all-targets/all-features
clippy; cargo nextest run --no-fail-fast (23,615 passed, 18 skipped,
32 threads, no retries).
Inherit the creator resource executor in dedicated/shared workers and pass it
through nested worker construction. Run native fetch IO and controlled-fetch
fallback on the load lease executor so Worker LocalRuntime shutdown cannot
drop detached keepalive transport. Ordinary loads still cancel at retirement.
Cover immediate GET/POST close, nested worker teardown, response bodies held
after worker join, ordinary cancellation and explicit AbortSignal cancellation.
Validation: cargo fmt --all; strict workspace/all-targets/all-features clippy;
cargo nextest run --no-fail-fast (23612 passed, 18 skipped, 32 threads, no retries).
Default debug CLI: original keepalive WPT 28/28 PASS (+2); 12 production
worker/fallback transport controls complete.
Reuse the admitted connect policy snapshot for initial Fetch checks and the shared native snapshot for other Window connect clients. Preserve the inherited policy URL for self matching and relative report-uri resolution while reporting the actual Document URI.
Keep source-location capture and violation task ordering in one queue helper, remove obsolete per-context connect paths, and calculate srcdoc referrers against the actual navigation URL. Cover same/cross-origin Fetch admission, report-only independence, report endpoints and default/same-origin referrer policies.
Retain native policy context through the runtime root loader and capture it for child module roots and static dependencies. Check initial and redirect URLs without duplicate reports, retain Document referrer policy and source/SRI handling, and keep pre-transport CSP rejection separate from a network failure. Add held-response, redirect and no-network regressions for main and child Documents, including JSON/text dependencies.
Reuse the intrinsic native simple-event builder for child readiness and script/modulepreload terminals. Remove the duplicate untrusted Event constructor and verify terminal event realm, trust, target and flags.
Check enforced and report-only script URLs against the policy's retained self URL while preserving the protected Document URL in violation reports. This lets initial about:blank popup script elements load same-origin modules without widening cross-origin policy.
Strengthen the real auxiliary-target regression with inherited script-src/connect-src self and an unchanged about:blank URL. Cover positive and negative script policies plus reporting for blank, srcdoc and data Documents.
Validation: cargo fmt --all; cargo clippy --workspace --all-targets --all-features -- -D warnings; cargo nextest run --no-fail-fast (23552 passed, 18 existing skips; 32 threads, no retries).
Use the exact Document request policy and networking tasks for ordinary module graph loads, including redirects, all CSP policies, source locations, native timing and Service Worker destinations. Keep JSON/text on connect-src and preserve parser-inserted script metadata.
Cover main and child Document reports before response headers, per-report microtasks before blocked-import rejection, and blocking before any network request.
Validation: cargo fmt --all; cargo clippy --workspace --all-targets --all-features -- -D warnings; cargo nextest run --no-fail-fast (23551 passed, 18 existing skips; 32 threads, no retries).
The upstream Window prototype regression shares the existing fixture, which
already covers 186 checks on this branch. Keep that full coverage and align
the new harness count. Format the combined IndexedDB imports.
Validation: cargo fmt --all; strict workspace all-targets all-features
Clippy; cargo nextest run --no-fail-fast (23508 passed, 18 existing skips,
32 threads, no retries).
Keep JSON preloads on the initiating Document connect policy instead of converting them into script requests. Cover main and child Documents with script-src disabled and multiple connect-src report-only policies while the response headers are held.
Queue each policy violation independently of the pending response, use native fetch settings for connected links, and retain the initiating callsite and exact child realm. Dispatch existing networking CSP events in their current task with normal task-end microtask checkpoints. Keep heavy Fetch and WebSocket continuations boxed so the added report identity does not inflate every pending resource.
Parse absolute HTTPS URLs without a Document or worker base, then apply the constructor realm native connect policy after WebIDL validation. Reject ready and closed with the same session error at the first checkpoint on CSP denial, and queue trusted violation events with their initiating source location for Window and worker owners. Cover multiple policies, borrowed constructors, custom NewTarget, validation failures, and immediate close.
Use the existing native miscellaneous-platform task source for Fetch admission violations in Window, child, and popup realms. Initiate reports and preserve call-site deduplication before event delivery; queue enforcement violations before report-only violations. Cover Promise rejection order, native event identity, and discarded browsing contexts.
Assert frame availability in the canplaythrough/seeked Promise reaction instead of waiting for an unrelated zero-delay timer. Preserve all 192 checks, case deadlines, and parallelism.