Classify a bounded response prefix before replacing the active Document. Replay original chunks exactly once through the shared raw-document pipeline, retaining raw headers separately from computed MIME. Apply the same decision to streaming, captured and complete child responses.
Keep the old owner running while MIME is undecided. Cancel provisional navigation on stopLoading, propagate transport errors and route unsupported content to downloads before reporting navigation success. Allocate streaming-response navigation state lazily.
Add 13 native regressions for split signatures, replay and observer ownership, cancellation, old-document liveness, inert text, computed metadata and binary text downloads. Make the existing NUL literal-text fixture explicitly nosniff, preserving its assertions, and separately cover browser-confirmed binary download behavior.
Validation: fmt; all-target/all-feature workspace clippy; 22634 nextest passes with 32 threads and zero retries; original WPT 245/251 retained plus 3/3 added coverage. Pinned Chromium controls verify 12 MIME cases and 38 commit phases, 32 navigation cases, 36 frame metadata cases and 5 binary text/nosniff cases. No new original-WPT passes are claimed. Response-stage MIME overrides, image document.open DOM and Blob child-origin gaps remain follow-up work.
Queue unconstrained replies behind earlier frozen output from the same
renderer stream. Keep exact load barriers when draining Runtime fences
and allow independent streams to advance without overtaking their own
output. Regress timer console ordering for root and child evaluate and
callFunctionOn through real flattened WebSockets.
Preserve shared document.domain state and retired-realm token invalidation
when initial document environments cross Page hosts. Restore the bootstrap
fallback state and cover retained auxiliary functions after navigation.
Remove duplicate interface registrations introduced by the overlapping main
changes and retain both existing and new interface regression modules.
Use the upstream owner-settlement API and publish nested command output at
the shared completion boundary. Inspector callbacks can already publish the
pending prefix while an owner remains paused; fence the concrete published
tail even when settlement has no new batch. This keeps beforeunload output
ahead of navigation fetch without closing the suspended command recorder.
Include before-fetch messages and completion details in the existing
paused-navigation regression assertions, and format replayed imports.
Validation: cargo fmt --all; workspace/all-target/all-feature Clippy with
warnings denied; nextest 20,797 passed, 16 skipped, 32 threads, zero retries.
Both paused beforeunload regressions also passed 10 consecutive rounds.
Run tree beforeunload from the existing Inspector scope so navigation can
start its request while the old script remains paused. Bind the active
Page per owner-task poll and preserve the beforeunload output prefix and
navigation fence without completing a suspended Runtime command.
Keep document-replacement termination pauses internal while preserving
real output and balancing pauses already reported to frontend sessions.
Keep intentional pagehide/unload callbacks debuggable during replacement.
Cover root/child lifecycle ordering, 204 recovery, resumable unload,
multiple sessions and cancellation between pause notification and loop entry.
Run browser-initiated main-document checks through the existing asynchronous
lifecycle scheduler before Fetch interception or network loading. Project the
source turn first, reject superseded navigation tokens, and share navigation
finalization so failed checks retain the committed document and release state.
Foreground DevTools callers remain pending through the check and load, preserving
typed navigation results and the captured target owner.
Keep beforeunload and commit unload commands out of nested non-V8 Page-agent
dispatch while the owner is debugger-paused. Cover real navigate/reload/history
responses, retained documents, pause/resume, supersession, and Fetch ordering.
Join child candidates to their active top-level Document's queue in connection
order. Revalidate ownership and ancestor fragments when flushing, and preserve
blocked candidates until their own Document's stylesheet readiness settles.
Construct focus transitions in the target Document's realm using the intrinsic
FocusEvent with its view, without consulting author constructors or inherited
initialization getters. Cover queue ownership, retirement, policies, stylesheet
wakes, and cross-realm focus event behavior.
Keep submit and formdata events synchronous while navigation runs as a
DOM-manipulation task. Capture the request, submitter, target and history
handling; coalesce replaced submissions without extra task turns.
Preserve popup POST requests, cross-origin and sandbox boundaries, and
javascript URL replacement ordering. Follow form navigation that starts
during document creation and cover reentrant, adopted and same-URL forms.
Validation: cargo fmt --all; workspace all-target/all-feature clippy with
warnings denied; cargo nextest run --no-fail-fast (20,002 passed, 16 skipped).
Two additional official WPT cases pass with no passing-case regressions
across the form and Navigation API suites.
Allow top-level navigation owner actions from the current Document through
the in-flight navigation gate so they can cancel the previous request.
Keep exact scheduler predecessors and Page residence validation in place.
Cover an unresponsive first request replaced by page JavaScript without
further client commands, and ensure only the replacement enters history.
Carry committed renderer history through browser navigation requests and
restore structured state, entry identities, and activation before new
Document scripts execute. Read the latest committed source entries when
creating the destination so state updates made during a pending response
are retained.
Keep browser traversals aligned with native Document identities, rebuild
private history ordinals for restored top-level entries, and use native
entry indices for fragment mutations after a cross-origin history prefix.
Cover structured-state restoration, pending-navigation source updates,
fragment indices, browser-owned back/forward traversal, and same-Document
realm and element preservation after WebDriver history restoration.
execCommand("copy") previously returned the user-activation flag without
firing an event or updating the clipboard. Dispatch trusted beforecopy and
copy events, honor cancellation, and copy the receiver document's selection.
Keep text-control selections per document across focus changes and reject
nested editing commands per native document. Share Window activation state
with navigator.userActivation so copying remains available after the
activating call and expires without clearing sticky activation. Read fresh
layout for DOM selection text, preserve preformatted whitespace, and use
the browser profile's clipboard line endings.
Add nine regression tests and correct the BiDi activation regression test.
Validate 38 copy-command cases, 38 existing native shortcut cases, and nine
activation-state cases against Chromium. The copy-event WPT and all 32
selection line-break subtests now pass, with no regressions in 65 WPT cases.
Start the held Fetch from interactive readystatechange so the fixture establishes its intended defer-wait boundary. A speculative script request is not an EOF signal. Retain both normal/crashed modes and every history, adoption and result assertion without changing timeouts or retry policy.
Validation (32 build jobs / test threads, zero retries):
- `cargo fmt --all`
- `cargo clippy --workspace --all-targets --all-features -- -D warnings`
- `cargo nextest run --no-fail-fast`: Summary [ 140.487s] 22001 tests run: 22001 passed (9 slow), 19 skipped
Page.enable must acknowledge a native Document that is already running while protocol Page adoption waits for resources. Reuse the prepared-document lifecycle state instead of starting another lazy initial navigation, which can revoke the existing work and deadlock behind Fetch interception. The regression holds a script response, enables Page before adoption, verifies the original paused Fetch remains valid, and checks the final URL for both normal and crashed targets.
Use Page residence and the stable Document token to deduplicate native
history registration and Page adoption. Keep lifecycle epochs in native
execution and cancellation identities. Adopt a restarted epoch's reply
title instead of retaining a title published by its predecessor epoch.
Cover asynchronous document.open/write/close before DCL on reused and
crash-recovery Pages, checking history length/index and replacement
content/title without requiring unchanged entry ids.
Dispatch late Fetch configuration and blocked URLs to the exact running native
Document before Page adoption. Apply admitted title facts to the published
history entry before later pushState operations can create another entry. The adoption path
retains the reply's exact Document identity even before native commit projection,
so journal and reply arrival order cannot register the same history entry twice.
Retire failed debugger-paused Worker targets and sessions when their prepared
owner is superseded, even after native destruction has already been deferred.
A new native commit also ends that deferral; stale Page destruction cannot
start it again. Reuse the existing retirement and session disposal paths.
Cover reused and crash-recovery Pages with four WebSocket regressions. Hold
response headers to enforce policy/title phases and require Worker retirement
before the replacement Document can commit.
Carry matching completion data in each Fetch operation instead of storing a
parallel dispatch kind. Restrict navigation termination to document work and
require native completion results directly, removing impossible fallbacks.
Move one owned workflow payload through execution, cancellation and recovery.
Derive renderer commit observation from its captured native Document.
Wait for the recovered session/frame/loader load in the cancellation integration
test before querying the new realm; a navigation ACK can precede Page adoption.
Capture weak command capabilities for the exact native Document behind early
Fetch pauses. Use them for request, response, authentication and cleanup work,
and restore pause records when dispatch is rejected.
Carry publication Page sources through owner-action projection. Register and
attach workers during handoff, revoke abandoned Page workers, and preserve
source identity for dialogs, choosers, popups and script navigation.
Record native navigation history once, retain observed URLs and titles at
adoption, and publish error-Document failure before its frozen frame commit.
Add controlled WebSocket regressions for handoff, cancellation and recovery.
Run CDP, BiDi, Classic and test workflows through finite synchronous state
access and revocable weak handles. Remove the mailbox, Inline driver,
exclusive completion branches and unused Fetch/Runtime connection APIs.
Keep original document, attachment and call identities through owned waits.
Preserve terminal responses for retired documents, settle empty renderer
boundaries and retain Fetch request announcements until terminal delivery.
Keep body/resource I/O outside shared state and preserve typed error causes.
Validation: cargo fmt --all; full workspace/all-targets/all-features Clippy;
21,456 Nextest tests (19 existing skips); five ownership doctests; same-source
CLI with Playwright, Puppeteer and CDP/BiDi/Classic workflow checks;
1,024 complete navigations; 128 cancelled waits and 4,096 peer commands.
Admit finite commands synchronously and route every asynchronous automation
command through the existing controller. Remove the server's duplicated
owned-command selector and exclusive-connection fallback. Restrict the old
automation and Runtime/Page inline entry points to the test harness.
Prepare desired preload registries before waiting and retain each original
host and Document for ordered Native updates. Reuse target preload/channel
execution and completion-owned recovery without adding task registries.
Pass actual ingress receivers into BiDi realm, layout and frame inventories.
Keep their accepted output prefixes in the original command's event sources;
perform context and target descriptor inventories synchronously.
Preserve original pending navigation replies from admission queries and realm
replay before projecting subscription events. Give the header-only network
baseline fixture its own URL so late baseline events cannot select the
collector request. Keep the original body and success assertions.
Validation: cargo fmt --all; default CLI Clippy; workspace all-targets
all-features Clippy with -D warnings; cargo nextest run --no-fail-fast
(21,413 passed, 19 existing skips); five protocol doctests.
Route navigation, reload and history traversal through the shared automation
owner and Page workflows. Retain the original typed result, navigation
identity and source response across auth handoff and lost ready results.
Reuse the Page completion body for exclusive compatibility and preserve
private task replies across independent renderer output boundaries. Remove
the duplicated protocol-neutral navigation dispatcher and completion loop.
Validate Direct state without a mailbox through the actual renderer
transport, accepted ready-result recovery and Inline compatibility.
Validation: root fmt, workspace Clippy, Nextest (21,393 passed, 19
existing skips), five borrow-boundary doctests, and source-matched
CDP/BiDi/Classic, Playwright, Puppeteer and navigation smoke checks.
Route DOM commands and Page frame inventories, layout metrics and screenshots
through the existing supervised automation workflow. Freeze the original
Page scope for child-frame queries and object registration, preserve typed
errors and exact Native cursors, and remove connection-borrowing dispatch
loops and query helpers. Independent Page inventories keep separate streams.
Exercise direct state access without a mailbox, child-frame projection and
unknown-node errors, recreated hosts with reused literal ids, and distinct
Native frame inventories. Existing DOM fixtures consume complete output
ownership while preserving their semantic assertions.
Run target creation, activation, closing and browser-context removal through
the existing automation workflow controller. Creation owns its admitted blank
document build and preload channel setup; activation reuses the finite surface
and visibility flow. Close and removal reuse the original Target retirement,
disposal, output and recovery owners through the common protocol adapter.
Keep creation and activation completion-owned after their finite admission so
waiter cancellation cannot abandon the original browser transition. Freeze
the actual target host for output projection and creation publication; retain
initial realm/listener and best-effort activation behavior. Delete the old
async automation wrappers and the resulting unused connection helpers.
Validation: root fmt, full workspace Clippy and unfiltered Nextest with default
parallelism; protocol doctests; source-built CLI CDP/Playwright/Puppeteer/BiDi
checks including user-context removal while an author promise is held. Direct
state regressions cover all four lifecycle commands, cancellation before the
first poll and discarded ready creation results.
Route six Input and seven Fetch automation commands through the shared owned
workflow controller. Reuse the existing finite domain admission, native waits,
recovery contexts and typed result owner; remove the old async wrapper loops.
Freeze the original page host for input settlement, downloads, file choosers
and output projection. Keep typed admission causes and canonical document
errors until the protocol boundary. Preserve Fetch metadata before its
independent navigation output boundary and consume only the internal reply.
Supervise Fetch handler revocation during the owned wait and before adopting
a queued ready receipt. Explicit revocation and owner teardown wake weak
lifetime observers without extending the original owner lifetime.
Validation: root fmt, full workspace Clippy and unfiltered Nextest with the
default parallelism; protocol doctests; source-built CLI with CDP, Playwright,
Puppeteer and BiDi, including real keyboard input and request/response-stage
interception with independent progress while blocked.
Run Browser permission, Storage and Emulation automation commands through
one shared supervised workflow and typed result owner. Prepare policy and
Native work synchronously, wait outside protocol state, then adopt results
in finite state turns. Remove the old family-specific async wrappers and
share the Emulation completion logic with CDP.
Keep original Page host and binding authority beside each receipt. Freeze
cookie owner routing and defaults across target activation, reject writes
into recreated contexts, and retain native error sources until transport
projection. Preserve the Runtime output and cancellation contracts.
Move all six neutral Runtime commands, including target/realm lookup,
node materialization, channels and locateNodes, into one ordinary async
workflow using finite state access and the existing command supervisor.
Remove the duplicated preparation/completion and server deferred-reply loops.
Keep the original Page/host/binding authority, typed result, accepted output
and cancellation with their command owner. Recover failed Native output
before adoption, hand channel listeners over at script admission, and release
temporary locateNodes object groups on cancellation. Classic and BiDi use
the same owned wait and move-only completion receipt.
Validate direct-owner before-poll and held-Promise cancellation, ready loss,
recreated hosts, channel progress, context close and actual Native proxy
release. Run root fmt, full workspace Clippy and Nextest, doctests and the
same-source CLI, Playwright, BiDi and Puppeteer suites before committing.
Admit Page and Worker Runtime listeners through the shared ordinary command
workflow and retain their exact target/session, output context and renderer
fence through waits and cancellation. Remove the dedicated listener loop and
its unused nested adapter; restrict the old raw-message async API to tests.
Drive adapter-internal commands with owned tasks while processing protocol
state, renderer and owner completions. Use AdapterReply for their original
responses, and wait for deferred Inspector results before finite completion.
Route every background navigation completion through finite admission and the
existing supervised workflows. Keep failure and download terminals in their
original output context before native cleanup, and remove production renderer
ingress and navigation-completion async fallbacks.
Make ordinary command joins and deferred Runtime response routing synchronous.
Prepare default-placeholder close at admission so native tracing cleanup cannot
revive the target; share the workflow with direct compatibility callers and
remove the replaced cleanup wrappers.
Decode legacy Target messages into ordinary commands with their real session,
renderer policy, cancellation and global reply route. Restore nested replies
for both immediate and background navigation completion without leaking ids.
Replace the raw command loop and exclusive Target execution body with the
shared owned command workflow. Retain accepted replies and renderer fences
across cancelled waiters and discarded state replies, and clear retired Fetch
lifetimes when the same in-flight entry transfers to protected recovery.
Run Page composite commands in the existing supervised command workflow.
Prepare preload, stop, crash and close ownership at admission; keep native
waits outside state access and complete finite commands synchronously.
Share owned navigation commit, streaming response and retirement logic with
Fetch. Preserve current, nested and background navigation reply ownership,
including accepted terminals during later waits, cancellation and ready loss.
Keep stop cleanup scoped to its original request and retain crashed Pages
before awaiting shutdown.
Remove the child-navigation Owned/Inline split, redundant world phases and
old exclusive Page completion/activation wrappers. Carry typed native errors
and use finite state operations for output, attachment and listener updates.
Keep original Native child facts routable through the unbound Document
handoff without granting business access. Preserve their exact Document tree
through adoption and use the captured owner for events and response bodies
when foreground selection changes.
Validate controlled renderer-held peer progress and recovery, successor
navigation ownership, stale world attachments, full workspace checks, source
CLI compatibility, Playwright, Puppeteer and parallel targeted stress. Replace an old stylesheet fixture clock check with
a script-released CSS gate while preserving the parser/DOM ordering checks.
Supervise existing-target sweeps, tab-child attachment and disable cascades in
the original command workflow. Keep initial Documents, binding updates and
session disposal waits outside connection borrows. Remove the old exclusive
sweep and detach loops; compatibility callers reuse the same async flow.
Retain installed policies by weak allocation identity so retired sweeps cannot
attach after disable, replacement or owner closure. Keep provisional sessions
in the original rollback transaction, remove actual commit receipts, and retain
recovery through waiter cancellation and discarded ready results.
Keep independent Page output on its original FIFO while completing the Browser
policy reply. Resolve provisional primaries through their exact Page source
until the frontend route commits, preserving existing sessions' responses.
Restrict retired frontend-release wrappers to tests and preserve typed
initial-Document error causes.
Run the BiDi slow-image HTTP fixture independently of the protocol executor,
retaining its original one-second completion budget and load assertions.
Validate controlled Native holds, synchronous XHR peer progress, replacement
policies, cancellation, ready loss and output order. Run required workspace
checks, parallel stress, and Playwright/Puppeteer against the current CLI.
Run Target.createTarget and Target.attachToTarget completion in the original
supervised command workflow. Keep initial Document installation, binding
updates, surface activation, initial navigation and rollback outside connection
borrows, and reuse that flow in exclusive compatibility callers.
Commit the attachment in the consuming owner turn so a target or parent that
started closing cannot gain a late session. Retain newly admitted rollback in
the original command recovery scope and preserve attached-event-before-reply
ordering through cancellation and discarded ready results.
Box composite waits at their invocation boundaries to keep the legacy actor
stacks bounded. Remove obsolete exclusive background-surface, initial-navigation
and uncommitted-session-disposal wrappers. Preserve Native binding output fences;
use the actual session registry for primary and attached bindings.
Validate controlled Native holds, ready-loss and closing interleavings, an
explicit WebSocket synchronous-XHR gate with peer progress, full workspace
checks, parallel stress, and real clients against the source-built CLI.
Route production scheduler command completion through finite state access and
owned workflows. Move Page Inspector response and Runtime.disable binding waits
outside connection borrows, retaining the original deferred-reply registry,
renderer correlations, output fences and command recovery context. Reuse the
same completion flow in compatibility callers, including Worker completion.
Make protocol-local DOMStorage flushing synchronous and remove its private
prepared payload/slot pipeline and obsolete async projection wrappers. Preserve
typed Native binding failures and their source context. Fence child lifecycle
observation against output already published before its ready response,
without widening unrelated command response boundaries.
Synchronize await correlation snapshots with renderer lease rotation and
consumption so context teardown retires the current call.
Use one async I/O worker per CLI HTTP fixture rather than a CPU-sized pool
in each parallel test process. Keep existing timeout and behavior assertions.
Validate held Native progress, cancelled waiters and lost ready replies, full
workspace checks, protocol doctests, parallel stress, and the source-built CLI
with explicit Worker promise barriers across three Worker types and two clients.
Run main-document lifecycle and download emission plus popup navigation through the existing owner-work supervisor. Retain each exact load interest in the scheduler queue until output handoff, and remove the adapter's private load tasks and completion channel.
Limit production ready-work completion to finite observations. Reuse the renderer navigation workflow and fenced output finalizer for compatibility callers. Classify explicit child frame navigation by its original owner instead of attachment observation timing, preserving Native validation and the parent document.
Validation: root cargo fmt, full workspace Clippy, full Nextest and protocol doctests; source-built CLI compatibility and controlled popup replacement and independent load/cancellation scenarios; parallel stress of owned output and child navigation.
Run complete Page and Worker publications in supervised async workflows with finite state access. Keep each original cursor and Runtime FIFO reservation until output handoff, and remove the duplicate renderer ingress and slot drivers.
Reuse owned Fetch continuations, popup and initial-document installation, navigation and close workflows. Preserve exact load dependencies, independent Native fences, Input automation predecessors, and cancellation output before replacement load. Retain released Runtime output in its existing route FIFO and retire closed Page resources only after their original output tail is projected.
Validation: root cargo fmt, full workspace Clippy, full Nextest and protocol doctests; source-built CLI compatibility, history/Fetch, real clients and worker lifecycle smoke; parallel stress of the observed races.