Timers queued from microtasks inherited the surrounding timer task's nesting
level and were clamped to 4ms after six callbacks. Suspend that metadata for
the microtask checkpoint and restore it for the outer task and interval rearm.
Cover the existing worker import, module and error checkpoint entry points.
Correct the old native expectation that required microtask inheritance and
add queueMicrotask/Promise, interval and worker-owner restoration regressions.
The tests inspect scheduled delays without relying on elapsed wall time.
Derive pending upload state from the prepared body before loadstart
callbacks. Upload listeners still select CORS preflight and event delivery,
but no longer create an unfinished upload for a null or ignored body.
Cover Window and worker aborts, policy failures, and an abort callback
that replaces a POST with a GET. Retain upload error events for empty
strings and nonempty request bodies.
Align the existing CLI timeout fixture with null bodies being upload-
complete, retaining its response, event-order and timeout assertions.
Discover parser-blocking imports with Stylo instead of splitting CSS text.
Use native supports conditions and decoded URLs, and coalesce duplicate
network identities so parser gates and CSSOM installation bind one graph.
Cover duplicate imports and escaped, conditional, layered, and fragmented
imports at the live parser handoff. Both regressions fail on the previous
implementation because the CSSOM owner starts an independent graph.
Capture the classic worker entry script and retain its origin-bound source in
callbacks and timers. Save fetch, XHR, and importScripts initiators at request
admission, while keeping opaque, cached, and synthetic responses redacted.
Match the native worker run and origin without rooting its callback graph.
Keep callbacks registered by unknown debugger evaluations redacted even when
their functions were defined by a known script.
Capture attribution per callback registration and restore it in the callback
realm before calling its body or looking up handleEvent. Keep synchronous
callers, unknown sources, origin checks, and callback currentness intact.
Cover timers, handler reassignment, synchronous dispatch, and callback-interface
getters using real page tasks and network responses.
The streaming input channel publishes its payload before requesting the
Networking parser continuation. Restoring a Page between those operations
can observe buffered input without a runnable task, which previously aborted
the renderer with an invalid invariant assertion.
Use the production scheduler snapshot for restoration admission and wait for
the producer's subsequent continuation publication and owner wake. Remove the
redundant payload readiness probes; keep producer task publication and wake
ordering unchanged.
Add a deterministic regression using the real channel receiver wake to enter
admission before the sender publishes its continuation. Verify that the owner
waits, receives the Networking wake, and can consume the exact parser task and
payload. Replace the obsolete unit that expected this legal interval to panic.
Capture the outer classic script source independently of its resolution base
and preserve it across Promise continuations. Snapshot the source and Window
origin when admitting a fetch or XHR, then retain it through response completion
and lazy resource timing publication.
Expose initiatorUrl through native resource timing slots and toJSON. Keep
unknown, redacted, opaque, cached and synthetic response attribution empty.
Other resource producers and callback task sources remain unattributed.
Add regression coverage for caller versus callee provenance, delayed response
publication, Promise and microtask propagation, and readable network response
requirements for both buffered and streaming completions.
Window.close marks a browsing context closed before its queued document
cleanup. Do not admit ServiceWorker requests during that gap, where
cleanup can retire their resolvers before a surviving caller sees them.
Cover lightweight popups and renderer-owned auxiliary Pages, including
reentrant URL conversion. Preserve requests made during beforeunload,
document owner retirement, and stale completion authorization.
An adopted native replacement can be superseded before protocol installation.
Stale completion used to leave its response-gated parser held on the live Page,
so the next beforeunload never ran. Release that continuation only for the
original Page residence and adopted Document agent.
Add deterministic beforeunload and newer-Document retention tests.
A newer navigation can cancel a replacement response while its Document is
already installed and still completing its requested lifecycle stage.
Detach that observer and continue on the existing Page, preserving its
navigation reply policy and original close owner.
Cover cancellation after the native Document is installed but before
protocol adoption, followed by beforeunload for the successor navigation.
Reserve command-owned scheduler publications before waiting for renderer
output. Keep their original response as a separate execution predecessor so
later state publications cannot overtake an unadmitted earlier sequence.
Retain accepted owner work when a response is dropped, preserve navigation
continuation progress, and allow independent targets to keep running.
Cover publication order, response cancellation, and target isolation.
Keep javascript URLs out of iframe history while their scripts execute.
Replace the latest committed entry only after accepting a string result,
preserving its URL and key and assigning a new document and entry ID.
Cover seven navigation entry points, non-string results, and history changes
made by scripts before string, void, or abrupt completion.
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.
Use the existing WebIDL dictionary converter for IdleRequestOptions.
Preserve getter and numeric-conversion exceptions, reject primitive
options, and wrap timeout values as unsigned long instead of clamping.
Only positive converted values establish a timeout deadline.
Cover 22 public-API option cases with the same JavaScript fixture used
for browser comparison. Keep the existing expiration assertions by
using a positive timeout that has elapsed before callback dispatch.
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.
Enter the child Window's Realm before materializing its wrapper and read Location state from native slots. Browser-owned synchronization must not leave an author-facing SecurityError pending.
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.
Retain the first accepted header spelling in the internal list and combine
request values for native dispatch without using the lowercase public
Headers projection. Preserve case through append/set, Request copies and
clones; reset it after delete. Keep lookup and Set-Cookie case-insensitive,
and retain lowercase public iteration and explicit HeadersInit conversion.
Use a one-pass name index when rebuilding the stored list. Canonicalize
CORS exposed-name metadata separately when materializing a response.
Exercise Window and Worker through twelve real HTTP requests each,
covering duplicate values, public views, mutations, internal copies,
author-overridden iterators and generic iterable initializers.
Validation: cargo fmt --all; workspace all-target/all-feature clippy with
-D warnings; full nextest (25,064 passed, 19 skipped), 32 threads, no retries.
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).