Validate the retained generation before entering style resolution. Clone clean styles from the document bucket and reuse the cached Arc for lazy pseudo snapshots.
Restore the Canvas2D and native event dispatch code before dfa4aa3fd0.
Keep the consolidated fixtures and limit Canvas IDL and click checks
to behavior covered by the restored runtime.
Expose the one-argument createImageData overload in the method length.
Invoke registered node handlers in the non-capture listener snapshot,
preserving the slot when a handler is replaced during dispatch.
Retain each manually followed HTTP hop's request/response ExtraInfo and
derive redirect availability from observed exchanges instead of a fixed flag.
Keep wire ExtraInfo when interception changes the logical response, and
preserve buffered redirect metadata without announcing requests twice.
Cover Worker fetch/XHR through two 302 Set-Cookie hops, including synthetic
first-hop redirects that must not produce transport ExtraInfo.
Retain admission cookie metadata in the typed automation event for BiDi, while deferring CDP Cookie headers and ExtraInfo to observed transport data.
Verify a Service Worker supplied iframe script executes without an HTTP script request or invented CDP Cookie header, and keep the prepared metadata available to BiDi.
Close admission under the load mutex when the last consumer retires, before signalling transport cancellation. Reserve new consumers during cache lookup so callback installation cannot race the last cancellation, and discard late completion from cancelled downloads.
Cover cancellation before transport acknowledgement, late success, reserved consumers and same-turn iframe removal followed by a parent script using the same URL.
Keep repeated native request snapshots in the output queue so Fetch overrides refresh captured upload bodies. Mark which snapshots announce a new request and suppress duplicate CDP starts during metadata enrichment.
Check that chained binary, text and empty upload overrides preserve a single requestWillBeSent per request and session.
Prepare initial headers and cookie metadata through the child Document's
request client, including credentials and browser site-context policy.
BiDi beforeRequestSent and terminal events retain this request metadata.
Defer CDP ExtraInfo separately so admission cookie metadata does not consume
the single later transport ExtraInfo event. Test HTTP 200, HTTP 404 and
cross-origin anonymous script requests.
Finish and cancel announced parser-script consumers before transferring
surviving Window loads into the replacement Document registry. Preserve
the original network request identity and ignore late source callbacks.
Test replacement content and networkIdle while the old response is held.
Register futures through the same cancellable consumer path as callbacks.
Retiring one iframe can no longer cancel a download still awaited by a
parent script. Dropping the final pending future still cancels transport.
Test mixed callback/future consumers with explicitly polled futures.
Use Document resource-load leases and shared cache consumer cancellation
for announced child parser scripts. Finish the original request on
retirement, ignore late callbacks, and publish completion independently
of parser-runner lifetime when navigation is cancelled.
Track request ExtraInfo publication separately from enriched cookie
metadata so HTTP-error responses preserve one Cookie ExtraInfo event.
Cover held-response retirement, cancelled srcdoc, late source callbacks,
and repeated metadata enrichment with regression tests.
Commit Browser detach and auto-attach disable synchronously, preserving event
ordering while supervising each native retirement independently. Remove the
synthetic completion objects, test-only serial runner, and obsolete recovery.
Batch script removal with SessionPageUpdates and retain the original disposal
identity for completion. Enqueue target-owned Inspector initialization without
claim/reply observers or a cancellable route. Share endpoint selection and
borrow connection keys/bindings separately from navigation restore snapshots.
Clarify session admission names and separate static policy from Page readiness
selection while retaining the admission token through synchronous redispatch.
Exercise the production Browser commit and supervisor paths in disposal tests.
Supervise each retired session independently so a busy Renderer cannot delay
another target's detach finalizer and successor connection. Preserve Browser
cascade publication and each session's cleanup-before-retirement ordering.
Apply Page subscriptions at command admission and defer only their initial
Document work. Resume without replaying an obsolete enable or chooser setting.
Remove the redundant cleanup owner and unreachable connection replacement.
Cover Primary lane reuse across auto-attach with a held peer, and Page
subscription changes while the initial installer remains pending.
Commit Browser attachment and withdrawal independently of native Page and
Inspector initialization. Keep shared initial builds on the target and bind
queued Main/IO work to its admitted session connection and native agent.
Separate minimum Inspector connect from ordered binding replay, and publish
unobserved initialization facts without snapshots or completion fences.
Retire Browser contributions immediately and supervise cleanup using the
original native authority, including failed or replaced connections.
The fixture renderer is not modal-blocked (the pushed dialog only
publishes connection-level state), so the deferred apply settles as
soon as its dispatch runs instead of staying parked behind a live
modal: the completion arrives as success and finishes cleanly. Assert
that, and cover the scheduler warn-path contract by injecting a
failure directly into the completion. Renderer death while the apply
is parked behind a production modal stays covered by the websocket
integration test.
The deferred attachment binding completion channel is owned by the
connection, so it closes as soon as the connection goes away (and in
tests, as soon as a hand-built receivers struct drops the sender). The
new receive arms sat ahead of the background-event and
renderer-publication arms in the biased select order without a
closed-channel guard, so a closed channel returned None immediately and
starved every input behind it.
Guard the arms with the same is_closed() check the protocol-work
completion arm already uses: a closed deferred channel cannot produce
further completions, so skipping it loses nothing.
Chromium resolves Target.attachToTarget in ~0 ms even when the target
shows a modal alert/confirm/prompt; moli parked the attach response
behind the renderer's modal wait because the attachment binding apply
was awaited before the commit.
Defer the binding apply instead: a dialog that is already published for
the target (or one that opens while the apply waits) hands the
still-queued dispatch to a supervised background wait, and the attach
commits immediately. The apply settles once the renderer frees up and
its completion is consumed by the scheduler with the same failure
tolerance as the synchronous path, minus the response predecessor
fence that no longer orders anything after publication. Renderer FIFO
still keeps the new session's first command behind the bindings.
createTarget/setAutoAttach share the broader dispatch path and remain
follow-up work.