Let an associated worker query its registration during evaluation, installation, and pending unregistration. Deliver same-run query replies to its published Starting host while keeping default MatchAll restricted to the exact active controller version.
Cover lifecycle transitions, waiting-worker isolation, mismatched registrations, and real worker startup promises with stale-run replies.
Pass the client snapshot frame type to the base Client binding so dedicated,
shared and blob worker clients expose the readonly frameType attribute.
Correct the previous expectation that worker Client objects lack frameType.
Cover matchAll/get results, readonly assignments and the worker Client shape
without adding WindowClient-only attributes or methods.
Enumerate Clients.matchAll candidates by storage key, which already carries
origin and partition identity, rather than requiring a matching scope URL.
Preserve inherited-origin about:blank and blob clients, and skip insecure,
unready and discarded clients before applying controller and type filters.
Cover clients controlled by another registration, out-of-scope window and
worker clients, inherited origins, storage isolation and query eligibility.
Match serialized scope URL prefixes, including partial path segments and query
strings, rather than requiring directory boundaries.
Select the longest matching registration before considering whether it has an
active worker. Installing and waiting registrations must prevent a shorter
scope from claiming or controlling their clients.
Cover literal prefixes, query scopes, origin boundaries, inactive longer
registrations, and claims after a longer registration is removed.
Apply the sandbox flags stored on an auxiliary browsing context to each new document environment before parsing and realm bootstrap. Network responses must retain inherited origin, storage and script restrictions while keeping their own CSP constraints.
Cover direct window.open, hyperlink activation and an initial blank popup followed by network navigation. Check successive documents, opaque origins, cookie, localStorage and sessionStorage access, request Origin headers, script blocking, noscript parsing and explicit sandbox escape.
Reject opaque HTTP document cookie reads and writes with SecurityError before accessing the shared cookie store. Retain inherited blank-document URL resolution and return empty values or ignore writes for detached and non-HTTP documents.
Cover normal and opaque HTTP documents, exception identity, Web IDL value conversion order, and inherited cookie access before and after removing the browsing context.
A same-origin source WindowProxy can be detached while its new LocalWindow remains lazy after navigation. Attach the current realm before exposing the accepted proxy as MessageEvent.source so reading its properties does not depend on an earlier iframe.contentWindow read.
Validate that the captured proxy still belongs to the live browsing context. Preserve source identity across navigation, captured event origin and cross-origin access checks, and avoid rebinding proxies from removed or reinserted frames.
Keep nullable DOMString return conversion within the callback relevant and incumbent contexts, before callback cleanup can run microtasks. Preserve window.event throughout conversion and report conversion exceptions after cleanup.
Cover bound native postMessage calls from child callbacks, conversion/microtask order, and error identity and reporting order.
Select the synthetic click default-action target before invoking listeners so removing or reparenting a clicked descendant cannot suppress or redirect activation. Recheck the chosen control state after dispatch.
Retain label identity while resolving its associated control after listeners, including newly established associations. Cover removal, reparenting, cancellation, disabled controls, form reassociation and label retargeting for click() and dispatched mouse events.
Route ServiceWorkerContainer registration and queries through worker settings, storage keys and the shared registration job coordinator. Preserve Trusted Types argument conversion, default policies and violation reporting in each worker realm.
Deliver registration snapshots and lifecycle events on the worker task queue, retain realm-local wrapper identity, and run real unregister jobs instead of returning a constant. Keep lifecycle subscriptions weak and partition scoped.
Validate Dedicated, Shared and Service Worker callers against real script loading, lifecycle transitions, Trusted Types and partition isolation.
Reserve navigation clients after the actual request partition and credentialless nonce are known, then preserve that key when the Window client commits. Popup descendants inherit the popup storage partition instead of the opener top-level site.
Keep same-partition ServiceWorker control and localStorage sharing while isolating identical frame origins embedded under a different top-level site. Validate both outcomes over trusted TLS and retain reserved-client visibility checks.
Determine secure Window settings from every frame ancestor and captured native execution-context identity. Use the same state for gated APIs and worker creation, independent of author-visible isSecureContext properties.
Honor an explicitly insecure creator when spawning HTTPS workers, keep inherited blob/data policy, and retain secure ServiceWorker settings.
Validate real TLS iframe, DedicatedWorker, SharedWorker and nested-worker settings plus the workspace fmt, clippy and nextest gates.
Keep independent HTTP and HTTPS ports, preserve HTTPS/WSS template origins and authored transport flags, and trust the ephemeral fixture authority explicitly. Use HTTP/1.1 for WebSocket upgrades and preserve the test origin for relative reftest resources.
Validate the WPT runner with 526 Python tests, including verified TLS/WSS, rejected untrusted certificates and hostnames, and independent listener substitution. No Rust source or Rust build metadata changes.
Route FontFaceSet events and CSS font requests through an exact Window/Document task source instead of the author timer heap. Prefer ready posted messages over font work while retaining bounded source fairness, and resume the current document lifecycle when its completion recheck becomes ready.
Cover source FIFO and retirement, message fairness, and the font event task-end checkpoint.
Keep the initial Document FontFaceSet.ready promise pending until its
Document finishes load delivery, including an otherwise empty font set.
Preserve the pending promise when the first font starts loading and wake
it from exact-owner main, child and popup load completion.
Cover initial readiness and the complete-to-load boundary, including a
font cycle started while the initial promise is pending. Complete native
font domain fixtures before exercising their later loading cycles.
Return Ahem.ttf and the upstream CORS, TAO, cache and ETag headers instead
of exposing cors-ahem.py as static Python source. Keep the conditional
304 response free of permission headers so the client must reuse cached
metadata, and send headers before delayed font response bodies.
Cover HTTP methods, exact conditional matching, sparse 304 metadata,
response pipe overrides and the header/body boundary with HTTP tests.
Retain the stylesheet source through nested imports and CSS font requests,
and publish each completed font timing in its requesting Document. Reuse
response filtering and Service Worker source hiding, and avoid duplicate
timings when consuming preloads.
Cover inline, base URL, linked, imported and cross-origin stylesheets in
main and child documents, plus synthetic, forwarded and fallback worker
responses with real font bytes and physical request counts.
Fetch child parser stylesheet imports through the shared import graph,
including nested requests, response policies and cycle deduplication.
Install descendant CSSOM sheets into their original owner before releasing
parser and frame load blockers. Preserve retired-owner network facts.
Cover linked and inline roots, duplicate and cyclic imports, failed child
responses, controlled pending requests and stale graph completions.
Keep initiating sources on connected-link requests and report their real
network terminal clocks. Attribute image and other link preloads to link,
and preserve the actual caller for stylesheet preloads. Attribute response
header preloads to their requesting Document.
Cover pending and completed consumption, cache policies, Document realms,
and HTTP Link preloads. Hide initiating sources for Service Worker
responses while retaining them on actual network fallback.
Observe each retiring Document's own unload event and transfer that record
only when its replacement commits. Expose modern and legacy timestamps
through the same native origin and redirect checks, including inherited
opaque origins. Keep pagehide and descendant unload handlers outside the
recorded interval.
Retain the accepted navigation clock for local child Documents so their
previous unload remains on the new timeline. Cover iframe and popup
replacement, cross-origin redirects, sandbox isolation and local srcdoc.
Keep each Realm matrix within the existing runtime command budget rather
than aggregating four independent matrices in one awaitPromise command.
Retain every transaction assertion and interleaving, all Realm combinations
and all 1,701 checks. Keep the default fixture entry running all matrices.
Add per-matrix failure context and retain the original 30-second budget.
Retain each accepted child navigation attempt's monotonic and wall clocks
through deferred attribute and Location commits. Keep fetch timing tied to
the actual loader and transport rather than the navigation time origin.
When a retiring subtree has beforeunload handlers, establish its new time
origin after the existing beforeunload check completes. Preserve navigation
cancellation and ownership checks.
Cover queued network and service worker requests, replaced attempts, and
beforeunload listeners, properties, HTML attributes and descendants. Keep
safe diagnostic context for existing controlled-preload timeout failures.
Use the allowed response fetch start for DNS and connection timing when
there is no client connection, including Service Worker respondWith.
Keep TLS unset and retain TAO masking and actual network observations.
Cover synthetic, forwarded, network fallback and cross-origin responses
in both the top Window and an iframe.
Carry request-owned attribution through parser and dynamic module graphs and
modulepreload producers. Preserve the source captured before asynchronous
scheduling, independently of URL resolution and HTTP referrer policy.
Publish the native timing entry for runtime module roots and retain child
root/dependency timing data through owner-checked completions. Keep actual
Service Worker response provenance so synthetic responses stay unattributed.
Cover parser/import sources, dynamic modules in main and child Documents,
modulepreload reuse, base URLs, and real Service Worker module responses.
Use Worker-owned fetch transport for EventSource in dedicated and shared
workers, including CORS/CSP, service-worker responses, interception, streaming
SSE parsing, reconnection and UTF-8 Last-Event-ID headers.
Deliver state and messages as individual networking tasks. Keep connection
callbacks separate from fetch Promise consumers, and use private delayed
networking tasks that author timers cannot cancel. Close and Worker teardown
cancel their transport and delayed work. Keep CONNECTING when a closing
Worker discards connection tasks.
Remove the unsupported constructor and cover both Worker kinds with fourteen
API tests, retaining Window EventSource and existing Worker test identities.
Keep dedicated worker main-script timing in the outside settings timeline.
Publish a networking task targeted to the captured creator Window, independent
of the worker wrapper, and retain native request, body and completion timing.
Report nested worker root fetches in the parent WorkerGlobalScope, including
HTTP and MIME failures. Reuse response filtering and keep local blob/data
scripts outside HTTP timing.
Cover classic, module, iframe and nested creation, rejected responses and
local-script controls with eight API tests.
Keep successful parser-async network results through parse-time tasks, EOF
fallback and late source completion. Publish ready scanner preloads through
the same owner task so each async fetch is recorded once.
Capture native response timestamps and body sizes at the source fetch, and
retain them independently of when script execution becomes eligible. Keep
attribution outside fetch reuse keys and apply existing CORS/TAO filtering.
Cover streaming parse-time execution, EOF completion, single-chunk parsing
and multiple async task turns with four API regressions.
Capture image, stylesheet, classic-script and iframe initiators when the
request is admitted, and retain them through deferred completion and src
reloads. Keep attribution separate from fetch option reuse keys and expose
it only for readable network responses.
Cover caller provenance, CORS/TAO boundaries, repeated element requests and
stylesheet fetch reuse with eight native regressions. Box owner task state
before constructing the async wrapper to avoid nested stack growth.
Load image inputs using their own request lifecycle and input initiator.
Record resource timing before user-interaction load/error delivery, retain
no-CORS credentials, and release document delays on completion or adoption.
Cover source transitions, failures, cancellation, cross-origin requests,
parsed inputs, document load gating and adoption in native regressions.
Available-image reuse shared the Local completion source, so its load event
synthesized a timing entry without a new fetch. Distinguish reused completion.
Keep decoded scanner preloads on the original response-consumption path until
their fetch has been reported; the synchronous available-image shortcut must
not skip that first timing entry. Preserve load/decode task delivery.
Cover consecutive image reuse, decoded scanner preloads before element
creation, and separate HTTP-cached fetches of the same URL.
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.