Treat disabled, hidden, and inert element focus fixup like removal when
tracking focus changes during navigation. Clear the automatic change before
blur handlers run so an author focus or blur decision still suppresses reset.
Add a production page-task regression covering automatic fixup and author
focus changes, including a focus-then-blur callback.
A synchronous popup.stop() could precede creation of its protocol target, so
its frozen window.open URL was still loaded later and replaced the initial
Document, aborting requests made after stop. Capture the Window cancellation
generation with the accepted popup action and revalidate it during projection.
Adopt the initial Page while discarding the revoked request and its resources.
Cover three sequential real image loads after stop and a later same-name
navigation, including zero requests for canceled URLs and one accepted request.
Honor form target and submitter formtarget presence, including empty overrides,
then fall back to the owning Document's first base target. Resolve targets after
formdata listeners while preserving the original ancestor-navigation permissions.
Share target sanitization with hyperlinks while retaining browser-compatible
empty-link-target fallback to base[target].
Cover owning Documents, link/form fallback differences, dynamic target changes,
sanitization and sandbox admission. Correct the local form compatibility fixture
so empty formtarget navigates its own source without replacing the harness.
Use the existing renderer-owned auxiliary Page factory for popup form
submissions. Queue the captured GET or POST on that exact Page instead of
loading both a lightweight popup projection and a separate browser target.
Preserve opener and referrer authority and cancel superseded form tasks
across related Pages without mixing source form identities.
Cover sequential form, button and input submissions across seven rel values
with actual protocol-server request and committed-document assertions.
Enumerate registrations by the order in which they entered the registration
map instead of HashMap traversal order. Allocate that position in the shared
resource store, preserve it through updates and persisted worker resources,
and restore it independently of runtime IDs and installation completion order.
Restore all registrations for the caller's storage key when enumerating,
including scopes that do not control the current document. Keep controller
lookups restricted to matching scopes. Read resource-store versions 1 and 2
with stable legacy positions and persist explicit order in version 3.
Cover live object order, updates and unregister/re-register, reversed store
completion and partial lazy restoration, JSON reopen and legacy migration.
Two unchanged regression tests fail at their exact assertions on the old code.
Initialize each service worker registration from an atomic snapshot and
subscription for its exact worker run. Hide the reserved installing version
until Install starts, and apply later snapshots on that worker's task queue.
Reuse service worker wrappers within the realm and deliver trusted statechange
events, including transitions of workers no longer in a registration slot.
Publish installing before update promise completion and updatefound.
Keep worker updates ahead of page updatefound notifications and retain module
bootstrap task ordering. Weak subscriptions cannot retain retired runs.
Cover initial slots, stable identity and lifecycle event order in classic and
module workers, queued snapshots, and stale run subscriptions. The two
classic integration tests fail at the expected assertions on the old code.
Keep skipWaiting promises pending until the owning runtime sets the flag
and tries activation, then settle each request on the worker event loop.
Bind requests and replies to the exact worker run and retain legal module
bootstrap deferral.
Cover early resolution, installed-worker activation order, independent
requests, stale run rejection, and module startup calls.
Terminate the previous waiting worker and deliver its redundant statechange
before publishing a newly installed worker. Keep the previous waiting
worker intact if install or persistence fails.
Cover registration snapshots, host and target cleanup, and failure rollback.
Settle claim promises only after the owning worker run has applied the
controller changes, and reject claims from inactive workers. Keep pending
claim resolvers alive and route replies by request id to that worker run.
Publish the activating worker as active before dispatching activate so
waitUntil(clients.claim()) can complete. Retire the previous active worker
and publish controller changes at this transition instead of deferring
the claim until activation finishes.
Queue functional events until activate finishes, including events received
while the worker is still bootstrapping, without changing their run owner
or counting them twice.
Deliver startup claim replies through the exact starting run, and publish
the worker handle before its parent message pump can process requests.
V8 caches Function-constructor source without the active script identity,
so later functions can inherit another script's import base URL and nonce.
Add an origin discriminator outside the generated FunctionExpression after
the CSP and Trusted Types checks, retaining the original source and
parameter/body offsets. Keep the other V8 compilation caches enabled.
Cover nonce removal, delayed calls from a different script, async and
generator constructors, UTF-16 and toString preservation, parameter
validation, and invalid Trusted Types replacement source.
The V8 archive interposes libc allocation with PartitionAlloc, whose
size limit aborts the process for otherwise valid large ArrayBuffers.
Use anonymous mappings for large backing stores in Window and Worker
isolates while keeping the existing libc path for smaller buffers.
Cover zero initialization, sparse reads and writes, transfer detachment,
and backing stores released on another thread after isolate disposal.
The Window and Worker regressions both SIGTRAP with the old allocator.
A form task can record a renderer-local javascript URL while its owner
handoff or lifecycle turn is still queued. Idle admission considered typed
sources and due timers, letting requestIdleCallback run before the URL's
Trusted Types check. A CSP collector could then finish its connect-src
barrier before the navigation violation was queued.
Count that pending URL as runnable work when admitting unexpired idle
callbacks. Keep ordinary timers and expired idle callbacks eligible.
Cover observable policy, script, and idle ordering in the real owner loop
with standalone and browser-delegated navigation dispatch. The new test
fails on the old implementation with idle, policy, javascript ordering.
A History API request can fall back to browser-owned entries that are absent
from the renderer's history view. Firing beforeunload before the browser
resolves the destination lets an out-of-range history.back() recursively
schedule more traversals and starve an in-flight Location navigation.
An unresolved fallback must also retain a pending Location request until
the browser selects a real traversal destination. Check the outgoing tree
only after selecting that destination.
Keep renderer-checked Location and known cross-document traversal requests
on their existing route. Cover back(), forward(), and go() with an owned
history-task regression that fails on the previous implementation. Also
cover a traversal queued by beforeunload while a Location is pending, and
replace the old test assertion that required discarding that request.
Remove unregistered storage-key/scope entries from lookup and persistence while existing clients and events retain their old registration. Start later jobs with fresh registrations and keep deferred cleanup from deleting replacement resources.
Apply worker-state and registration-slot changes in separate lifecycle tasks, retain watchers for both old and new objects, and stop synthesizing clearing during unregister promise settlement. Clean failed initial registrations before advancing their queued jobs and publish failure slot updates by registration identity, preserving other retired objects at the same scope.
Cover controlled clients, failed replacements, cached failed registrations, identity, persistent removal, queued jobs and callback/microtask slot ordering. Replace legacy resurrection and synchronous-clearing expectations with current Service Worker semantics.
Check ordinary ready timers before admitting an unexpired idle callback. An earlier idle transport deadline must not overtake later ready work in the same heap, including queued popup javascript navigation.
Keep expired idle callbacks runnable. Cover the real owner loop with an HTTP completion witness and six function, source, child-window, expired, cancelled, and future timer scenarios.
Share one deadline ceiling across callbacks in an idle period. Requests
registered after the period starts, including from microtasks and other
Windows, wait for the next opportunity; positive timeouts can expire first.
Recompute IdleDeadline.timeRemaining() from active HTML timers and pending
rendering work on every call. Retain the actual frame wake deadline through
rendering dispatch and use the deadline object's realm when borrowing the
method across windows. Preserve the existing DOM clock precision.
Cover twelve public budget scenarios, six period and timeout-order
scenarios, and future/cancelled/running timer deadline queries.
Recheck the host navigation route before every renderer follow turn. A
javascript: task can start an HTTP navigation, whose fetch and commit belong
to the browser controller on browser-managed Pages. Reusing the standalone
follow loop could replace the source Document before its queued CSP reports
ran and bypass browser navigation state.
Cover assign, replace, and chained javascript: navigations from ordinary
script and DOMContentLoaded, including request uniqueness, history mutation,
and source Document lifetime before browser commit.
Fixes: 4cd690931e ("fix(renderer): execute javascript URL navigations internally")
Queue legacy Document CSP events on the exact-owner task source already used
by inline checks, so later connect or Trusted Types reports cannot overtake
earlier inline violations. Preserve report metadata, retirement and dispatch
time element retargeting; remove the obsolete production parser route.
Cover both orders through the real parser and move CSP fixtures to the
existing exact selected-task executor without changing their assertions.
Suspend the original operation exception while invoking custom element reactions, then rethrow the same value. Callback catch scopes must not consume the original exception or replace it with a callback failure.
Preserve byte streams across FetchEvent dispatch, clone and network fallback.
Keep upload and abort lifetimes independent of synthetic responses, and stream
Service Worker replies to controlled Worker clients.
Validation: fmt, full workspace clippy and nextest pass (25094 tests, 19 skipped).
Ordinary debug and release each improve the selected original WPT cohort from
107/117 to 112/117, with every prior passing case retained.
Read author streams through internal read steps on their script owner and
feed the bounded HTTP/2 transport with snapshotted Uint8Array chunks. Carry
backpressure through owner queues and preserve AbortSignal cancellation
reasons while mapping source failures to network errors.
Wait for upload transmission before processing early responses, preserve
uploads after redirect headers, and reject authentication replays only for
supported challenges within the credentials mode. Keep local URL responses
independent of HTTP upload consumption.
Cover wire delivery before EOF, binary views, backpressure, early redirects,
authentication, source failures, abort identity and local Window/Worker
responses. All required workspace checks pass: 25,087 tests passed and
19 skipped. The 68 original H2 upload subtests pass in ordinary debug and
release builds, up from 40, with no prior PASS lost.
Check non-replayable source identity before POST-to-GET rewriting and route same-origin author streams through the shared redirect policy. Preserve 303, manual/error, missing Location, and byte-backed replay behavior. Cover raw and materialized transfers with a real HTTP matrix.
Protect counts shared by detached easy handles and cached connections with curl platform locks. Decide the last release under the same lock without holding it across allocation, destruction, or callbacks.
Add a single-use request body with bounded backpressure, cancellation and
upload-transmission completion independent of response EOF. Resume paused
reads on curl's owner and support buffered, HTML and raw response transports.
Require HTTPS with HTTP/2, prevent 421 replay, and preserve uploads after
early responses. Honor KEEP_SENDING_ON_ERROR in curl's HTTP/2 END_STREAM
handling so early 4xx responses do not reset an unfinished upload.
Cover channel ownership and backpressure plus real H2 progress, EOF,
cancellation, early responses, warm HTTP/1 rejection and non-replayability.
This provides the native transport for later Window/Worker stream wiring.
Intercept one misdirected response before publishing its headers or body,
then resend the same logical request on a new connection. Preserve the
upload bytes, cancellation, original hop deadline and redirect metadata.
Do not apply the discarded response's cookies or replay author streams.
Carry the request body's source state through Window, Worker and Service
Worker network dispatch, and reset the retry budget on redirects.
Exercise the three native transports with two idle pooled connections,
a truncated 421 body, repeated 421s, byte-exact uploads, non-replayable
sources, cancellation, deadlines and a redirect between retry budgets.
Validation: cargo fmt --all; workspace all-target/all-feature clippy with
-D warnings; full nextest (25,062 passed, 19 skipped), 32 threads, no retries.
Distinguish a fetch abort from an ordinary native network-body failure.
After receiver and unusable-body checks, reject an already-aborted body
immediately without locking or disturbing its stream. Preserve the exact
abort reason and failure kind across response clones in Window and Worker.
Ordinary stream errors retain their existing consumption/task semantics.
Cover all six Body methods, repeated calls, clones before and after abort,
primitive and object reasons, lock precedence, author-created stream
wrappers, and real Service Worker-intercepted responses.
Validation: cargo fmt --all; workspace all-target/all-feature clippy with
-D warnings; full nextest (25,055 passed, 19 skipped), 32 threads, no retries.
Escape non-ASCII Location bytes before URL parsing, matching Chromium's
HTTP redirect handling. Reuse the same encoder for native transports,
manual CORS redirects, and Service Worker synthetic redirects, while
retaining ordinary HTTP fields' isomorphic ByteString representation.
Exercise valid UTF-8, invalid octets and existing percent escapes on the
wire through buffered, HTML and raw transports. Cover browser redirects
and extend the synthetic Service Worker redirect regression.
Validation: cargo fmt --all; workspace all-target/all-feature clippy with
-D warnings; full nextest (25,053 passed, 19 skipped), 32 threads, no retries.
Capture native Window and Worker HTTPS state independently of SecureContext,
author base URLs and request referrers. Preserve the request policy through
Service Worker fallback and intercepted request reconstruction, and validate
initial requests before preflight/cache use and redirects before connecting.
Retain Chromium's loopback exemption and default SharedWorker behavior.
Cover native client ownership, empty referrers, preflight/response cache reuse,
and downgrade redirects with regression tests.
Validation: cargo fmt --all; workspace all-target/all-feature clippy with
-D warnings; full nextest, 32 threads, no retries, default stack.
Capture the native child navigation kind when queueing Location reloads or
history traversals, retain it across document bootstrap, and project it to
Service Worker Request navigation flags. Preserve the same kind when
rebuilding intercepted network requests and navigation preload requests.
Cover native Request copies, clones and RequestInit resets for each kind.
Add a real HTTP regression proving that Service Worker navigation fallback
retains reload cache validation without applying it to history traversals.
Validation: cargo fmt --all; all-target/all-feature workspace clippy with
-D warnings; full nextest (25,046 passed, 19 skipped), 32 threads, no retries.
Use converted dictionary member presence without rereading JS getters.
Preserve native navigation flags for empty initialization, and reset them,
navigate mode and referrer metadata before applying defined overrides.
Retain null BodyInit presence without treating it as a replacement body.
Cover all supported reset-triggering members, absent/undefined members,
null body and signal, single getter evaluation, cache-mode validation order
and source Request isolation through the native constructor binding.
Validation: cargo fmt --all; all-target/all-feature workspace clippy with
-D warnings; full nextest (25,044 passed, 19 skipped), 32 threads, no retries.
Apply force-cache and only-if-cached stale reuse after representation and
Vary selection. Give cors and same-origin requests the same raw response
identity only for untainted same-origin URLs, retaining origin, credential,
partition, cookie and redirect-handling boundaries. Current consumers still
validate every cached redirect and response before exposing it.
Add four I/O regression tests for stale reuse, Vary and authority isolation,
cached same-origin redirects and denial of cached cross-origin redirects.
Validation: workspace fmt, all-target/all-feature clippy, and full nextest
(25,043 passed; 19 skipped).
Joining a parent Worker intentionally does not synchronously join its nested
Workers. Wait for the child to publish its pending detached keepalive before
asserting its exact count, while withholding the server response. Keep the
existing timeout and the zero-after-completion assertion.
Validation: workspace fmt, all-target/all-feature clippy and full nextest.
Use native Window agent-cluster isolation independently of the
permissions-filtered crossOriginIsolated capability. Keep domain
validation and conversion errors, and avoid recording ignored
assignments or refreshing their Window security tokens.
Use V8 per-context constructor policy and conditional installation after binding the native Window or Worker owner. Keep the intrinsic and Wasm shared memory available without exposing the global in nonisolated realms.
Preserve shared BufferSource regression coverage through Wasm-derived constructors and check Window, Worker, iframe, ServiceWorker, SharedWorker, and unbound V8 Context exposure.
Validation: cargo fmt --all; strict workspace/all-target/all-feature clippy; cargo nextest run --no-fail-fast (24,925 passed, 19 skipped; 32 jobs, zero retries).
Use the native Worker Context binding for Trusted Types after removal of the private carrier. Follow the renamed Window bootstrap and initialize runtime-only Document environments explicitly.
Adapt the transaction GC regression to the store-name lifecycle argument and remove the obsolete whole-matrix timeout helper after main split cursor probes into bounded sections. Format the merged native context exports.
Derive ServiceWorker isolation from its own trustworthy enforced COEP response.
A COEP-only worker can clone shared memory; a DIP-only response cannot grant
this capability.
Keep SharedWorker agents in the default non-isolated mode, including the Blob
creator-policy fallback, while retaining independent COEP/DIP network policies.
Cover actual classic/module registration, HTTP and Blob creation, and cloning.
Apply response and container cross-origin-isolated permissions before allowing
structured-clone shared backing stores, preserving denials across descendants.
Resolve COEP-only child capabilities from the top-level COOP+COEP group while
keeping DIP isolation local and compatible with Chromium. Preserve the policy
in navigation snapshots and worker request contexts.