Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
refactor(cdp): centralize target session disposal
ldm064d9a9fce721
diff --git a/moli-core/src/page/mod.rs b/moli-core/src/page/mod.rsindex dc1e7227d..f4e2608a9 100644--- a/moli-core/src/page/mod.rs+++ b/moli-core/src/page/mod.rs@@ -82,13 +82,13 @@ pub use moli_renderer_v8::network::{RendererNetworkResourceLoadResponse, RendererPreparedNetworkResourceLoad,};pub use moli_renderer_v8::{- DevToolsSessionKey, RendererActivityDiagnostics, RendererAgentAttachmentId,- RendererAutofillAddressField, RendererAutofillCreditCard, RendererAutofillTriggerOutcome,- RendererAutofillTriggerRequest, RendererCaptureScreencastFrameReply,- RendererCaptureScreencastFrameRequest, RendererCaptureScreenshotReply,- RendererCaptureScreenshotRequest, RendererCommandTurnCompletion, RendererCommandTurnOutput,- RendererDedicatedWorkerTargetEvent, RendererDedicatedWorkerTargetInfo,- RendererDevToolsAgentToken, RendererDocumentHitTestResult,+ CompletedWorkerRuntimeInspectorCommandDispatch, DevToolsSessionKey,+ RendererActivityDiagnostics, RendererAgentAttachmentId, RendererAutofillAddressField,+ RendererAutofillCreditCard, RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest,+ RendererCaptureScreencastFrameReply, RendererCaptureScreencastFrameRequest,+ RendererCaptureScreenshotReply, RendererCaptureScreenshotRequest,+ RendererCommandTurnCompletion, RendererCommandTurnOutput, RendererDedicatedWorkerTargetEvent,+ RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken, RendererDocumentHitTestResult,RendererDocumentIsolateAccountingDiagnostics, RendererDocumentLifecycleEvent,RendererDocumentLifecycleEventKind, RendererDocumentLifecycleIdentity,RendererDocumentLifecycleMilestone, RendererDocumentLifecycleSnapshot,diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rsindex 3c50b125b..a137f2daf 100644--- a/moli-protocol/src/conn.rs+++ b/moli-protocol/src/conn.rs@@ -122,6 +122,7 @@ pub use moli_protocol_cdp::{use target::DEFAULT_BROWSER_CONTEXT_ID;pub(crate) use target::{CdpSessionRoute, DefaultTargetLifecycle, TargetActivationTransition, TargetHandlerAccessMode,+ TargetWorkerProtocolAttachmentIdentity,};#[derive(Clone, Debug)]@@ -558,12 +559,12 @@ pub(crate) use state::{DedicatedWorkerTargetState, DevToolsBrowserIdentityOverride, DevToolsConsoleOutputSessionState,DevToolsLogViolationThreshold, DocumentNavigationToken, DuplicatePendingRendererCommand,EmulatedNetworkConditions, EmulatedViewportSurface, InspectorCommandDispatch,- NETWORK_ERROR_PAGE_URL, NavigationResultProjection, NavigationSourceDocumentSecurityContext,- NetworkErrorPageNavigation, PageScreencastConfig, PageScreencastFormat,- PendingBidiChannelListener, PendingInspectorAwait, PendingRendererCommandKey,- PerformanceTimeDomain, PreparedRendererCallDispatch, ProfilerAction, ProfilerInspectorCommand,- RendererCommandCorrelation, RendererCommandDescriptor, RendererCommandReplay,- RendererDocumentLifecycleObservation, RendererDocumentLifecycleObserver,+ NETWORK_ERROR_PAGE_URL, NavigationEngineHandoff, NavigationResultProjection,+ NavigationSourceDocumentSecurityContext, NetworkErrorPageNavigation, PageScreencastConfig,+ PageScreencastFormat, PendingBidiChannelListener, PendingInspectorAwait,+ PendingRendererCommandKey, PerformanceTimeDomain, PreparedRendererCallDispatch, ProfilerAction,+ ProfilerInspectorCommand, RendererCommandCorrelation, RendererCommandDescriptor,+ RendererCommandReplay, RendererDocumentLifecycleObservation, RendererDocumentLifecycleObserver,RendererMainDocumentCommitSeed, RendererPageResidenceIdentity,ServiceWorkerRuntimeExceptionSnapshot, ServiceWorkerTargetState, SharedWorkerTargetState,SiteDataClearOptions, TargetIdentityState, TargetInitialEmptyDocumentCreator, TargetOwnerState,@@ -585,12 +586,11 @@ pub(crate) use state::{};pub(crate) use target::{PreparedTargetAttach, PreparedTargetHostClosure, PreparedTargetHostDelta,- TargetAttachSessionCommit, TargetBindingCleanupAction, TargetClosureCleanupPlan,- TargetSessionDetachCleanupPlan,+ TargetAttachSessionCommit, TargetBindingCleanupAction, TargetBindingCleanupPlan,+ TargetClosureCleanupPlan, TargetEventPlan, TargetSessionDetachCleanupPlan,};use target::{- TargetClosurePlan, TargetControlPlane, TargetEventPlan, TargetHostDelta,- target_destroyed_automation_events,+ TargetClosurePlan, TargetControlPlane, TargetHostDelta, target_destroyed_automation_events,};pub(crate) use top_level_navigation_work::TopLevelLocationNavigationOwnerAction;@@ -2628,7 +2628,7 @@ impl CdpConnection {// navigate_id-gated abort emission; the only thing we must avoid here// is letting the stale background engine displace the live one.let is_current = completion.is_current_for_connection(self);- let completion = completion.materialize_with_engine_retention(self, is_current);+ let completion = completion.materialize_with_engine_replacement(self, is_current);if let Some(started) = timing_started {tracing::info!(target: "moli_cdp_nav_timing",@@ -2957,7 +2957,7 @@ impl CdpConnection {);}let is_current = completion.is_current_for_connection(self);- let (token, state, navigation, engine) = completion.into_parts();+ let (token, state, navigation, engine_handoff) = completion.into_parts();if !is_current {crate::domains::page::push_superseded_navigation_result(out, &state);return;@@ -2972,7 +2972,7 @@ impl CdpConnection {command_context,).await;- if let Some(engine) = engine {+ if let Some(engine) = engine_handoff.into_replacement() {self.adopt_loaded_navigation_engine_for_owner(&navigation_owner, engine);}if let Some(started) = timing_started {diff --git a/moli-protocol/src/conn/browser_context/target_session_owner.rs b/moli-protocol/src/conn/browser_context/target_session_owner.rsindex c924390f4..ac2b9fd80 100644--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs@@ -824,28 +824,6 @@ impl<'a> TargetSessionOwnerMut<'a> {Some(())}- pub(super) async fn close_page_target_async(&mut self) -> Option<ClosedPageTarget> {- let mut target = self.browser_context.page_targets.remove(&self.target_id)?;- self.browser_context- .forget_target_opener_references_for_target(&self.target_id);- self.browser_context- .forget_target_window_names_for_target(&self.target_id);- self.browser_context- .forget_target_popup_id_for_target(&self.target_id);- let auxiliary_session_ids = target- .devtools_sessions- .attached_session_ids()- .map(str::to_owned)- .collect::<Vec<_>>();- let primary_session_id = target.detach_session();- target.close_page_async().await;- Some(ClosedPageTarget {- target_id: self.target_id.clone(),- primary_session_id,- auxiliary_session_ids,- })- }-pub(super) fn runtime_slot_mut(&mut self) -> &mut TargetRuntimeSlot {&mut self.target_mut().runtime_slot}@@ -1345,29 +1323,34 @@ impl CdpConnection {.await}- pub(crate) async fn close_page_target_for_route_async(- &mut self,- session_id: Option<&str>,- owner_route: Option<&CdpSessionRoute>,- ) -> Option<ClosedPageTarget> {- let collected_network_data_artifacts = self- .target_session_owner_ref_for_route(session_id, owner_route)?- .runtime_slot()- .collected_network_data_artifacts();- let closed = self- .target_session_owner_mut_for_route(session_id, owner_route)?- .close_page_target_async()- .await?;- self.record_collected_network_data_artifacts(collected_network_data_artifacts);- Some(closed)- }-- pub(crate) async fn close_background_page_target_for_target_close_async(+ async fn close_page_target_for_target_close_async(&mut self,target_id: &str,out: &mut Vec<BackgroundProtocolEvent>,reason: &'static str,) -> Option<ClosedPageTarget> {+ let primary_route = self.target_session_route_for_target_id(target_id)?;+ let session_owners = self+ .page_event_session_ids_for_route(None, Some(&primary_route))+ .into_iter()+ .map(|session_id| {+ session_id+ .as_deref()+ .map(CommandOwnerScope::for_session)+ .unwrap_or_else(|| CommandOwnerScope::for_route(primary_route.clone()))+ })+ .collect::<Vec<_>>();+ let mut claimed_await_events = Vec::new();+ for owner in &session_owners {+ self.fail_pending_inspector_awaits_for_owner_background_events_into(+ out,+ &mut claimed_await_events,+ owner,+ reason,+ );+ }+ out.extend(claimed_await_events);+let (mut target,primary_session_id,@@ -1375,18 +1358,15 @@ impl CdpConnection {collected_network_data_artifacts,) = {let browser_context = self.browser_context.as_mut()?;- let mut target = browser_context.remove_background_target(target_id)?;+ let target = browser_context.take_page_target_for_close(target_id)?;let collected_network_data_artifacts =target.runtime_slot.collected_network_data_artifacts();- browser_context.forget_target_opener_references_for_target(target_id);- browser_context.forget_target_window_names_for_target(target_id);- browser_context.forget_target_popup_id_for_target(target_id);let auxiliary_session_ids = target.devtools_sessions.attached_session_ids().map(str::to_owned).collect::<Vec<_>>();- let primary_session_id = target.detach_session();+ let primary_session_id = target.session_id().map(str::to_owned);(target,primary_session_id,@@ -1397,21 +1377,6 @@ impl CdpConnection {target.close_page_async().await;self.record_collected_network_data_artifacts(collected_network_data_artifacts);- let mut affected_sessions = Vec::new();- if let Some(session_id) = primary_session_id.as_deref() {- affected_sessions.push(session_id);- }- for session_id in &auxiliary_session_ids {- affected_sessions.push(session_id.as_str());- }- CdpConnection::fail_pending_inspector_awaits_from_page_session_state_for_sessions_background_events_into(- out,- &mut target,- primary_session_id.as_deref(),- &affected_sessions,- reason,- );-Some(ClosedPageTarget {target_id: target_id.to_owned(),primary_session_id,@@ -1419,35 +1384,35 @@ impl CdpConnection {})}+ pub(crate) async fn close_background_page_target_for_target_close_async(+ &mut self,+ target_id: &str,+ out: &mut Vec<BackgroundProtocolEvent>,+ reason: &'static str,+ ) -> Option<ClosedPageTarget> {+ let is_background = self+ .browser_context+ .as_ref()+ .is_some_and(|browser_context| {+ browser_context.page_target(target_id).is_some()+ && !browser_context.is_active_target(target_id)+ });+ if !is_background {+ return None;+ }+ self.close_page_target_for_target_close_async(target_id, out, reason)+ .await+ }+pub(crate) async fn close_active_page_target_for_target_close_async(&mut self,out: &mut Vec<BackgroundProtocolEvent>,+ reason: &'static str,) -> Option<ClosedPageTarget> {- let (- target_id,- primary_session_id,- auxiliary_session_ids,- collected_network_data_artifacts,- ) = {- let browser_context = self.browser_context.as_mut()?;- let target_id = browser_context.active_target_id_owned()?;- let primary_session_id = browser_context.active_session_id_owned();- let auxiliary_session_ids =- browser_context.remove_auxiliary_sessions_for_target(&target_id);- let collected_network_data_artifacts = browser_context- .active_page_target()- .runtime_slot- .collected_network_data_artifacts();- browser_context.clear_active_target_session_scoped_state_without_loaded_page();- browser_context.remove_active_page_target_async().await;- (- target_id,- primary_session_id,- auxiliary_session_ids,- collected_network_data_artifacts,- )- };- self.record_collected_network_data_artifacts(collected_network_data_artifacts);+ let target_id = self.browser_context.as_ref()?.active_target_id_owned()?;+ let closed = self+ .close_page_target_for_target_close_async(&target_id, out, reason)+ .await?;let promoted_target_id = if let Some(browser_context) = self.browser_context.as_mut() {browser_context.promote_last_background_target_to_active_async()@@ -1470,11 +1435,7 @@ impl CdpConnection {);}- Some(ClosedPageTarget {- target_id,- primary_session_id,- auxiliary_session_ids,- })+ Some(closed)}pub(crate) async fn rollback_incomplete_popup_target_without_event_async(@@ -1495,46 +1456,20 @@ impl CdpConnection {let mut page_session_ids = Vec::new();if let Some(browser_context_id) = browser_context_id {- let is_active_target = self- .browser_context_by_id(&browser_context_id)- .is_some_and(|browser_context| browser_context.is_active_target(target_id));- if is_active_target {- if let Some(browser_context) = self.browser_context_by_id_mut(&browser_context_id) {- if let Some((_target_id, session_id)) = browser_context.active_target_identity()- && let Some(session_id) = session_id- {- page_session_ids.push(session_id);- }- page_session_ids- .extend(browser_context.remove_auxiliary_sessions_for_target(target_id));- browser_context.remove_active_page_target_async().await;- }- } else {- let close_background_target = {- let Some(browser_context) = self.browser_context_by_id_mut(&browser_context_id)- else {- return;- };- let target = browser_context.remove_background_target(target_id);- browser_context.forget_target_opener_references_for_target(target_id);- browser_context.forget_target_window_names_for_target(target_id);- browser_context.forget_target_popup_id_for_target(target_id);- target.map(|mut target| {- page_session_ids.extend(- target- .devtools_sessions- .attached_session_ids()- .map(str::to_owned),- );- if let Some(session_id) = target.detach_session() {- page_session_ids.push(session_id);- }- target- })- };- if let Some(mut target) = close_background_target {- target.close_page_async().await;+ let target = self+ .browser_context_by_id_mut(&browser_context_id)+ .and_then(|browser_context| browser_context.take_page_target_for_close(target_id));+ if let Some(mut target) = target {+ page_session_ids.extend(+ target+ .devtools_sessions+ .attached_session_ids()+ .map(str::to_owned),+ );+ if let Some(session_id) = target.session_id() {+ page_session_ids.push(session_id.to_owned());}+ target.close_page_async().await;}}diff --git a/moli-protocol/src/conn/fetch_support.rs b/moli-protocol/src/conn/fetch_support.rsindex 15b0dc611..51696d13b 100644--- a/moli-protocol/src/conn/fetch_support.rs+++ b/moli-protocol/src/conn/fetch_support.rs@@ -1564,7 +1564,7 @@ impl DocumentBodySource {} => {if !has_response_override && let Some(prepared_document) = prepared_document {let (engine, navigation) = prepared_document.resume_streaming(response, None);- return Ok(navigation.with_navigation_engine(engine));+ return Ok(navigation.with_navigation_engine_replacement(engine));}conn.build_navigation_from_streaming_raw_response_with_response_override_for_navigation_async(navigation,diff --git a/moli-protocol/src/conn/page_state/fetch_state.rs b/moli-protocol/src/conn/page_state/fetch_state.rsindex 67231353c..89cb9abae 100644--- a/moli-protocol/src/conn/page_state/fetch_state.rs+++ b/moli-protocol/src/conn/page_state/fetch_state.rs@@ -505,24 +505,6 @@ mod tests {assert!(read.eof);}- #[tokio::test]- async fn clearing_session_scoped_state_clears_in_flight_subresources() {- let mut bc = BrowserContext::new_with_page_for_test("BID-1", "TID-1");- bc.register_in_flight_subresource_fetch_request(- Some("INT-SUB-2".to_owned()),- pending_subresource_fetch(2),- );-- bc.clear_active_target_session_scoped_state_async()- .await- .unwrap();- assert!(- !bc.active_page_target()- .fetch_owner- .has_in_flight_subresource_fetches_for_test()- );- }-#[test]fn network_and_io_stream_ids_cross_u32_max_without_reuse() {let mut bc = BrowserContext::new_with_page_for_test("BID-1", "TID-1");diff --git a/moli-protocol/src/conn/page_state/loaded.rs b/moli-protocol/src/conn/page_state/loaded.rsindex 27eb2e45b..ca19d4f6d 100644--- a/moli-protocol/src/conn/page_state/loaded.rs+++ b/moli-protocol/src/conn/page_state/loaded.rs@@ -41,11 +41,6 @@ impl BrowserContext {.and_then(|host| host.runtime_slot.page_attachment_id())}- fn clear_active_target_session_scoped_state_fields(&mut self) {- self.active_page_target_mut()- .clear_session_scoped_state_fields(false);- }-#[cfg(test)]fn clear_active_target_loaded_document_session_state(&mut self) {for session in self.active_page_target_mut().devtools_sessions.states_mut() {@@ -112,69 +107,12 @@ impl BrowserContext {.ingest_owner_page_observable_output_updates()}- pub(crate) async fn clear_active_target_session_scoped_state_async(- &mut self,- ) -> Result<(), String> {- self.clear_active_target_session_scoped_state_preserving_attached_async(false)- .await- }-- pub(crate) async fn clear_active_target_primary_session_scoped_state_async(- &mut self,- ) -> Result<(), String> {- self.clear_active_target_session_scoped_state_preserving_attached_async(true)- .await- }-- async fn clear_active_target_session_scoped_state_preserving_attached_async(- &mut self,- preserve_attached_sessions: bool,- ) -> Result<(), String> {- self.active_page_target_mut()- .clear_session_scoped_state_fields(preserve_attached_sessions);- let emulated_media: moli_core::page::EmulatedMediaOverrides =- (&self.active_page_target().emulated_media).into();- if let Some(page) = self.active_page_target_mut().runtime_slot.loaded_page_mut() {- page.set_extra_http_headers_async(&[])- .await- .map_err(|error| format!("failed to clear page extra headers: {error}"))?;- page.set_network_offline_async(false)- .await- .map_err(|error| format!("failed to clear page offline state: {error}"))?;- page.set_bypass_service_worker_async(false)- .await- .map_err(|error| format!("failed to clear page service worker bypass: {error}"))?;- page.set_blocked_url_patterns_async(&[])- .await- .map_err(|error| format!("failed to clear page blocked URLs: {error}"))?;- page.set_script_execution_disabled_async(false)- .await- .map_err(|error| {- format!("failed to clear page script execution disabled state: {error}")- })?;- page.set_cpu_throttling_rate_async(1.0)- .await- .map_err(|error| format!("failed to clear page CPU throttling rate: {error}"))?;- page.set_emulated_media_async(&emulated_media)- .await- .map_err(|error| format!("failed to clear page emulated media: {error}"))?;- }- self.apply_surface_overrides_to_loaded_page_async().await?;- Ok(())- }-- pub(crate) fn clear_active_target_session_scoped_state_without_loaded_page(&mut self) {- self.clear_active_target_session_scoped_state_fields();- }-+ #[cfg(test)]pub(crate) async fn remove_active_page_target_async(&mut self) -> bool {let Some(target_id) = self.active_target_id_owned() else {return false;};- self.forget_target_opener_references_for_target(&target_id);- self.forget_target_window_names_for_target(&target_id);- self.forget_target_popup_id_for_target(&target_id);- let Some(mut host) = self.page_targets.remove(&target_id) else {+ let Some(mut host) = self.take_page_target_for_close(&target_id) else {return false;};host.close_page_async().await;diff --git a/moli-protocol/src/conn/page_state/parked.rs b/moli-protocol/src/conn/page_state/parked.rsindex 325e2fc1d..e2d30cf3f 100644--- a/moli-protocol/src/conn/page_state/parked.rs+++ b/moli-protocol/src/conn/page_state/parked.rs@@ -10,11 +10,12 @@ use crate::devtools_runtime::{use moli_core::network::SharedWebStorageStore;impl BrowserContext {- pub fn remove_background_target(&mut self, target_id: &str) -> Option<PageTargetHost> {- if self.is_active_target(target_id) {- return None;- }- self.page_targets.remove(target_id)+ pub(crate) fn take_page_target_for_close(&mut self, target_id: &str) -> Option<PageTargetHost> {+ let target = self.page_targets.remove(target_id)?;+ self.forget_target_opener_references_for_target(target_id);+ self.forget_target_window_names_for_target(target_id);+ self.forget_target_popup_id_for_target(target_id);+ Some(target)}pub(crate) fn stage_background_target(@@ -315,7 +316,14 @@ impl BrowserContext {target.runtime_slot.remove_network_session_observation_cursor(Some(session_id));- target.devtools_sessions.remove_attached(session_id);+ let disposed = target.devtools_sessions.dispose(+ session_id,+ &moli_page_types::DevToolsSessionKey::Attached(session_id.to_owned()),+ );+ debug_assert!(+ disposed.is_some(),+ "attached session must remain registered until disposal"+ );}Some(target_id)}@@ -323,7 +331,7 @@ impl BrowserContext {pub(crate) async fn clear_target_session_overrides_async(&mut self,session_id: &str,- ) -> Result<bool, String> {+ ) -> anyhow::Result<bool> {let Some((target_id, session_key)) = self.page_targets.iter().find_map(|target| {target.devtools_sessions@@ -372,75 +380,64 @@ impl BrowserContext {).await.map_err(|error| {- format!("failed to restore detached session network request policy: {error}")+ anyhow::anyhow!(+ "failed to restore detached session network request policy: {error}"+ )})?;}if delta.locale {page.set_locale_override_async(effective_locale.as_deref()).await- .map_err(|error| format!("failed to restore detached session locale: {error}"))?;+ .map_err(|error| {+ anyhow::anyhow!("failed to restore detached session locale: {error}")+ })?;}if delta.timezone {page.set_timezone_override_async(effective_timezone.as_deref()).await- .map_err(|error| format!("failed to restore detached session timezone: {error}"))?;+ .map_err(|error| {+ anyhow::anyhow!("failed to restore detached session timezone: {error}")+ })?;}Ok(browser_identity_changed)}- pub(crate) fn remove_auxiliary_sessions_for_target(&mut self, target_id: &str) -> Vec<String> {- let session_ids = self.auxiliary_session_ids_for_target(target_id);- for session_id in &session_ids {- let _ = self.remove_auxiliary_session(session_id);- }- session_ids- }-- pub(crate) async fn clear_background_target_session_binding_and_scoped_state_async(+ pub(crate) async fn dispose_primary_page_session_async(&mut self,+ target_id: &str,session_id: &str,- ) -> Result<Option<String>, String> {- let Some(target_id) = self- .background_targets_mut()- .find(|target| target.is_session(session_id))- .map(|target| {- target.detach_session();- let target_id = target.target_id().to_owned();- target.runtime_slot.disable_primary_network_events();- target- .runtime_slot- .clear_session_scoped_network_observation_artifacts();- target- .runtime_slot- .request_id_allocator()- .reset_fetch_navigation_request_counter();- target- .runtime_slot- .request_id_allocator()- .reset_subresource_fetch_request_counter();- target_id- })- else {- return Ok(None);+ ) -> anyhow::Result<bool> {+ let is_active = self.is_active_target(target_id);+ let Some(target) = self.page_target_mut(target_id) else {+ return Ok(false);};+ if !target.is_session(session_id) {+ return Ok(false);+ }+ target.clear_primary_session_scoped_state_fields();- let cleared_emulated_media = moli_core::page::EmulatedMediaOverrides::default();- self.background_target_mut(&target_id)- .expect("background target must exist")- .clear_session_scoped_state_fields(true);- self.background_target_mut(&target_id)- .expect("background target must exist")- .runtime_slot- .remove_network_session_observation_cursor(Some(session_id));-- let effective_headers = self.effective_extra_headers_for_target(&target_id);+ let effective_headers = self.effective_extra_headers_for_target(target_id);let target = self- .page_target(&target_id)- .expect("background target must remain registered");+ .page_target(target_id)+ .expect("disposing page target must remain registered");let effective_policy = target.effective_policy();+ let effective_locale = effective_policy+ .locale_override()+ .map(str::to_owned)+ .or_else(|| self.default_locale_override.clone());+ let effective_timezone = effective_policy+ .timezone_override()+ .map(str::to_owned)+ .or_else(|| self.default_timezone_override.clone());+ let surface_script = if is_active {+ self.generated_surface_override_script_for_active_target()+ } else {+ self.generated_surface_override_script_for_parked_target(target_id)+ };+ let cleared_emulated_media = moli_core::page::EmulatedMediaOverrides::default();if let Some(page) = self- .background_target_mut(&target_id)+ .page_target_mut(target_id).and_then(|target| target.runtime_slot.loaded_page_mut()){page.set_network_request_policy_async(@@ -450,59 +447,46 @@ impl BrowserContext {effective_policy.blocked_url_patterns(),).await- .map_err(|error| format!("failed to clear page network request policy: {error}"))?;+ .map_err(|error| {+ anyhow::anyhow!("failed to clear page network request policy: {error}")+ })?;page.set_network_offline_async(false).await- .map_err(|error| format!("failed to clear page offline state: {error}"))?;+ .map_err(|error| anyhow::anyhow!("failed to clear page offline state: {error}"))?;page.set_script_execution_disabled_async(false).await.map_err(|error| {- format!("failed to clear page script execution disabled state: {error}")+ anyhow::anyhow!("failed to clear page script execution disabled state: {error}")+ })?;+ page.set_cpu_throttling_rate_async(1.0)+ .await+ .map_err(|error| {+ anyhow::anyhow!("failed to clear page CPU throttling rate: {error}")})?;page.set_emulated_media_async(&cleared_emulated_media).await- .map_err(|error| format!("failed to clear page emulated media: {error}"))?;+ .map_err(|error| anyhow::anyhow!("failed to clear page emulated media: {error}"))?;+ page.set_locale_override_async(effective_locale.as_deref())+ .await+ .map_err(|error| anyhow::anyhow!("failed to restore page locale: {error}"))?;+ page.set_timezone_override_async(effective_timezone.as_deref())+ .await+ .map_err(|error| anyhow::anyhow!("failed to restore page timezone: {error}"))?;+ if let Some(surface_script) = surface_script {+ page.run_page_surface_override_script_async(&surface_script.source)+ .await+ .map_err(|error| {+ anyhow::anyhow!("failed to restore page surface overrides: {error}")+ })?;+ }}- Ok(Some(target_id))- }-- pub(crate) fn clear_background_target_primary_auto_attached_session(- &mut self,- session_id: &str,- ) -> Option<String> {- let target_id = self- .background_targets_mut()- .find(|target| target.is_session(session_id))- .map(|target| {- target.detach_session();- let target_id = target.target_id().to_owned();- target.runtime_slot.disable_primary_network_events();- target- .runtime_slot- .clear_session_scoped_network_observation_artifacts();- target- .runtime_slot- .request_id_allocator()- .reset_fetch_navigation_request_counter();- target- .runtime_slot- .request_id_allocator()- .reset_subresource_fetch_request_counter();- target_id- })?;- let target = self- .page_target_mut(&target_id)- .expect("background target must remain registered");- target.devtools_sessions.reset(true);- target.runtime_slot.disable_primary_network_events();- target.network_policy.clear_session_scoped_state();- target.fetch_owner.reset_config();- self.background_target_mut(&target_id)- .expect("background target must exist")- .runtime_slot- .remove_network_session_observation_cursor(Some(session_id));- Some(target_id)+ let disposed = self+ .page_target_mut(target_id)+ .expect("disposing page target must remain registered")+ .devtools_sessions+ .dispose(session_id, &moli_page_types::DevToolsSessionKey::Primary);+ Ok(disposed.is_some())}#[cfg(test)]@@ -550,52 +534,6 @@ impl BrowserContext {))}- pub(crate) async fn clear_active_target_session_binding_and_scoped_state_async(- &mut self,- ) -> Result<(), String> {- let target_id = self.active_target_id_owned();- let auxiliary_inspector_session_ids = target_id- .as_deref()- .map(|target_id| self.auxiliary_session_ids_for_target(target_id))- .unwrap_or_default();- if let Some(page) = self.active_page_target_mut().runtime_slot.loaded_page_mut() {- for session_id in &auxiliary_inspector_session_ids {- page.detach_runtime_inspector_session_async(Some(session_id))- .await- .map_err(|error| {- format!("failed to detach auxiliary renderer inspector session: {error}")- })?;- }- page.detach_runtime_inspector_session_async(None)- .await- .map_err(|error| {- format!("failed to detach primary renderer inspector session: {error}")- })?;- }- self.clear_active_target_session_scoped_state_async()- .await?;- self.detach_active_session();- for session_id in auxiliary_inspector_session_ids {- self.active_page_target_mut()- .runtime_slot- .remove_auxiliary_network_session(&session_id);- }- Ok(())- }-- pub(crate) async fn clear_active_target_primary_auto_attached_session_async(- &mut self,- ) -> Result<Option<String>, String> {- let target_id = self.active_target_id_owned();- if self.active_session_id().is_none() {- return Ok(None);- }- self.clear_active_target_primary_session_scoped_state_async()- .await?;- self.detach_active_session();- Ok(target_id)- }-pub(crate) fn release_primary_session_binding_preserving_frontend_state(&mut self,session_id: &str,diff --git a/moli-protocol/src/conn/page_state/surfaces.rs b/moli-protocol/src/conn/page_state/surfaces.rsindex f4510da8a..a90fc1192 100644--- a/moli-protocol/src/conn/page_state/surfaces.rs+++ b/moli-protocol/src/conn/page_state/surfaces.rs@@ -673,72 +673,92 @@ impl BrowserContext {}impl CdpConnection {- pub(crate) async fn remove_document_start_scripts_for_detached_session_best_effort_async(+ pub(crate) async fn remove_document_start_scripts_for_detached_session_async(&mut self,session_id: &str,- ) {+ ) -> anyhow::Result<()> {let renderer_inspector_session_id =self.target_renderer_runtime_inspector_session_id_for_session(Some(session_id));let devtools_session = moli_page_types::DevToolsSessionKey::from_wire_session_id(renderer_inspector_session_id.as_deref(),);let registry_keys = self- .with_target_owner_state_for_session_mut(Some(session_id), |owner_state| {- owner_state.take_document_start_script_registry_keys_for_session(&devtools_session)+ .target_owner_state_for_session(Some(session_id))+ .map(|owner_state| {+ owner_state.document_start_script_registry_keys_for_session(&devtools_session)}).unwrap_or_default();+ let has_loaded_page = self+ .runtime_session_owner_slot_mut(Some(session_id))+ .ok()+ .is_some_and(|slot| slot.loaded_page().is_some());+ if !has_loaded_page {+ let _ = self.with_target_owner_state_for_session_mut(Some(session_id), |owner_state| {+ owner_state.remove_document_start_scripts_for_session(&devtools_session)+ });+ return Ok(());+ }+for registry_key in registry_keys {let pending = self.runtime_session_owner_slot_mut(Some(session_id)).ok().and_then(|slot| slot.loaded_page_mut())- .map(|page| page.start_remove_document_start_script_by_registry_key(®istry_key));- let Some(pending) = pending else {- continue;- };- let pending = match pending {- Ok(pending) => pending,- Err(error) => {- tracing::debug!(- %error,- session_id,- registry_key,- "failed to start detached-session document-start script cleanup"- );- continue;- }- };- let completion = match pending.wait().await {- Ok(completion) => completion,- Err(error) => {- tracing::debug!(- %error,- session_id,- registry_key,- "detached-session document-start script cleanup was canceled"- );- continue;- }- };- let Some(page) = self+ .ok_or_else(|| {+ anyhow::anyhow!(+ "page disappeared while removing detached-session document-start scripts"+ )+ })?+ .start_remove_document_start_script_by_registry_key(®istry_key)+ .map_err(|error| {+ anyhow::anyhow!(+ "failed to start detached-session document-start script cleanup: {error}"+ )+ })?;+ let completion = pending.wait().await.map_err(|error| {+ anyhow::anyhow!(+ "detached-session document-start script cleanup was canceled: {error}"+ )+ })?;+ let page = self.runtime_session_owner_slot_mut(Some(session_id)).ok().and_then(|slot| slot.loaded_page_mut())- else {- continue;- };- if let Err(error) = page.finish_unit_runtime_page_command(+ .ok_or_else(|| {+ anyhow::anyhow!(+ "page disappeared while finishing detached-session document-start script cleanup"+ )+ })?;+ page.finish_unit_runtime_page_command(completion,"remove detached-session document-start script",- ) {- tracing::debug!(- %error,- session_id,- registry_key,- "failed to finish detached-session document-start script cleanup"- );- }+ )+ .map_err(|error| {+ anyhow::anyhow!(+ "failed to finish detached-session document-start script cleanup: {error}"+ )+ })?;+ self.with_target_owner_state_for_session_mut(Some(session_id), |owner_state| {+ owner_state.remove_document_start_script_registry_key_for_session(+ &devtools_session,+ ®istry_key,+ )+ })+ .ok_or_else(|| {+ anyhow::anyhow!("session owner disappeared during document-start script cleanup")+ })?;}++ // Scripts without a renderer registry key never require a renderer+ // round trip. Successful keyed removals have already been committed,+ // so a later retry cannot revisit a renderer object that is gone.+ self.with_target_owner_state_for_session_mut(Some(session_id), |owner_state| {+ owner_state.remove_document_start_scripts_for_session(&devtools_session)+ })+ .ok_or_else(|| {+ anyhow::anyhow!("session owner disappeared during document-start script cleanup")+ })?;+ Ok(())}}diff --git a/moli-protocol/src/conn/runtime_eval.rs b/moli-protocol/src/conn/runtime_eval.rsindex 99150f614..063fe3aaf 100644--- a/moli-protocol/src/conn/runtime_eval.rs+++ b/moli-protocol/src/conn/runtime_eval.rs@@ -229,25 +229,6 @@ enum BidiChannelListenerRoute {Event(BackgroundProtocolEvent),}-fn unregister_runtime_remote_object_group_from_page_target(- page_session_state: &mut PageTargetHost,- session_id: Option<&str>,- object_group: &str,-) {- if let Some(session_id) = session_id- && let Some(state) = page_session_state- .devtools_sessions- .attached_mut(session_id)- {- state.unregister_runtime_remote_object_group(object_group);- return;- }- page_session_state- .devtools_sessions- .primary_mut()- .unregister_runtime_remote_object_group(object_group);-}-#[derive(Debug)]pub(crate) struct OwnerRuntimeResponse {command_id: u64,@@ -397,15 +378,6 @@ impl RuntimeProtocolResponseRoute {Self::DevToolsSession => None,}}-- fn into_command_reply_receiver(self) -> Option<RuntimeInspectorResponseReceiver> {- match self {- Self::CommandReply(receiver) => receiver,- Self::DevToolsSession => {- panic!("a DevTools session response cannot become a command reply")- }- }- }}enum PendingRuntimeProtocolMessageDispatchKind {@@ -416,13 +388,13 @@ enum PendingRuntimeProtocolMessageDispatchKind {pub struct PendingSharedWorkerRuntimeProtocolMessageDispatch {session_id: Option<String>,pending: SharedWorkerRuntimeProtocolDispatchFuture,- deferred_response_rx: Option<RuntimeInspectorResponseReceiver>,+ response_route: RuntimeProtocolResponseRoute,}pub struct PendingServiceWorkerRuntimeProtocolMessageDispatch {session_id: Option<String>,pending: ServiceWorkerRuntimeProtocolDispatchFuture,- deferred_response_rx: Option<RuntimeInspectorResponseReceiver>,+ response_route: RuntimeProtocolResponseRoute,}pub struct PendingMoliDiagnosticsDispatch {@@ -461,14 +433,41 @@ pub struct CompletedRuntimeProtocolMessageDispatch {pub struct CompletedSharedWorkerRuntimeProtocolMessageDispatch {session_id: Option<String>,- messages: Vec<RendererRuntimeInspectorMessage>,- deferred_response_rx: Option<RuntimeInspectorResponseReceiver>,+ dispatch: CompletedWorkerRuntimeProtocolDispatch,+ response_route: RuntimeProtocolResponseRoute,}pub struct CompletedServiceWorkerRuntimeProtocolMessageDispatch {session_id: Option<String>,+ dispatch: CompletedWorkerRuntimeProtocolDispatch,+ response_route: RuntimeProtocolResponseRoute,+}++struct CompletedWorkerRuntimeProtocolDispatch {messages: Vec<RendererRuntimeInspectorMessage>,- deferred_response_rx: Option<RuntimeInspectorResponseReceiver>,+ session_response_predecessor: Option<RendererOutputFence>,+ session_response_succeeded: Option<bool>,+}++impl CompletedWorkerRuntimeProtocolDispatch {+ fn command_reply(messages: Vec<RendererRuntimeInspectorMessage>) -> Self {+ Self {+ messages,+ session_response_predecessor: None,+ session_response_succeeded: None,+ }+ }++ fn devtools_session(+ completed: moli_core::page::CompletedWorkerRuntimeInspectorCommandDispatch,+ ) -> Self {+ let (messages, predecessor, response_succeeded) = completed.into_parts();+ Self {+ messages,+ session_response_predecessor: Some(predecessor),+ session_response_succeeded: Some(response_succeeded),+ }+ }}pub struct CompletedMoliDiagnosticsDispatch {@@ -540,9 +539,9 @@ pub struct CompletedRuntimeChildDefaultContextLookupDispatch {}type SharedWorkerRuntimeProtocolDispatchFuture =- Pin<Box<dyn Future<Output = Result<Vec<RendererRuntimeInspectorMessage>, String>>>>;+ Pin<Box<dyn Future<Output = Result<CompletedWorkerRuntimeProtocolDispatch, String>>>>;type ServiceWorkerRuntimeProtocolDispatchFuture =- Pin<Box<dyn Future<Output = Result<Vec<RendererRuntimeInspectorMessage>, String>>>>;+ Pin<Box<dyn Future<Output = Result<CompletedWorkerRuntimeProtocolDispatch, String>>>>;#[derive(Clone, Debug)]struct RuntimeProtocolMessagePageRoute {@@ -621,11 +620,11 @@ impl PendingRuntimeProtocolMessageDispatch {impl PendingSharedWorkerRuntimeProtocolMessageDispatch {pub async fn wait(self) -> Result<CompletedSharedWorkerRuntimeProtocolMessageDispatch, String> {- let messages = self.pending.await?;+ let dispatch = self.pending.await?;Ok(CompletedSharedWorkerRuntimeProtocolMessageDispatch {session_id: self.session_id,- messages,- deferred_response_rx: self.deferred_response_rx,+ dispatch,+ response_route: self.response_route,})}}@@ -634,11 +633,11 @@ impl PendingServiceWorkerRuntimeProtocolMessageDispatch {pub async fn wait(self,) -> Result<CompletedServiceWorkerRuntimeProtocolMessageDispatch, String> {- let messages = self.pending.await?;+ let dispatch = self.pending.await?;Ok(CompletedServiceWorkerRuntimeProtocolMessageDispatch {session_id: self.session_id,- messages,- deferred_response_rx: self.deferred_response_rx,+ dispatch,+ response_route: self.response_route,})}}@@ -699,7 +698,19 @@ impl CompletedSharedWorkerRuntimeProtocolMessageDispatch {pub(crate) fn take_deferred_response_receiver(&mut self,) -> Option<RuntimeInspectorResponseReceiver> {- self.deferred_response_rx.take()+ self.response_route.take_command_reply_receiver()+ }++ pub(crate) const fn response_delivery(&self) -> RendererInspectorResponseDelivery {+ self.response_route.delivery()+ }++ pub(crate) fn session_response_predecessor(&self) -> Option<RendererOutputFence> {+ self.dispatch.session_response_predecessor.clone()+ }++ pub(crate) fn session_response_succeeded(&self) -> Option<bool> {+ self.dispatch.session_response_succeeded}}@@ -707,7 +718,19 @@ impl CompletedServiceWorkerRuntimeProtocolMessageDispatch {pub(crate) fn take_deferred_response_receiver(&mut self,) -> Option<RuntimeInspectorResponseReceiver> {- self.deferred_response_rx.take()+ self.response_route.take_command_reply_receiver()+ }++ pub(crate) const fn response_delivery(&self) -> RendererInspectorResponseDelivery {+ self.response_route.delivery()+ }++ pub(crate) fn session_response_predecessor(&self) -> Option<RendererOutputFence> {+ self.dispatch.session_response_predecessor.clone()+ }++ pub(crate) fn session_response_succeeded(&self) -> Option<bool> {+ self.dispatch.session_response_succeeded}}@@ -1025,12 +1048,30 @@ impl CdpConnection {&self,session_id: Option<&str>,renderer_call_id: RendererCallId,- dispatched_attachment_id: RendererAgentAttachmentId,+ dispatched_attachment_id: Option<RendererAgentAttachmentId>,) -> Option<RendererCommandDescriptor> {+ if let Some(owner_session_id) = session_id+ && let Some(target) = self.shared_worker_target_for_session(session_id)+ {+ return target.renderer_command_descriptor_for_renderer_if_attachment_matches(+ owner_session_id,+ renderer_call_id,+ dispatched_attachment_id,+ );+ }+ if let Some(owner_session_id) = session_id+ && let Some(target) = self.service_worker_target_for_session(session_id)+ {+ return target.renderer_command_descriptor_for_renderer_if_attachment_matches(+ owner_session_id,+ renderer_call_id,+ dispatched_attachment_id,+ );+ }self.target_devtools_session_state_for_session(session_id)?.renderer_command_descriptor_for_renderer_if_attachment_matches(renderer_call_id,- Some(dispatched_attachment_id),+ dispatched_attachment_id,)}@@ -1985,63 +2026,6 @@ impl CdpConnection {.is_some_and(DevToolsSessionState::has_pending_inspector_awaits)}- pub(crate) fn fail_pending_inspector_awaits_from_page_session_state_for_sessions_background_events_into(- out: &mut Vec<BackgroundProtocolEvent>,- page_session_state: &mut PageTargetHost,- primary_session_id: Option<&str>,- session_ids: &[&str],- reason: &'static str,- ) {- for (cdp_id, entry) in page_session_state- .devtools_sessions- .drain_pending_inspector_awaits_for_sessions(session_ids)- {- if let Some(listener) = entry.bidi_channel_listener() {- unregister_runtime_remote_object_group_from_page_target(- page_session_state,- entry.session_id(),- listener.channel_object_group(),- );- continue;- }- push_pending_inspector_await_error_background_event(- out,- cdp_id,- entry.session_id(),- reason,- );- }- if let Some(primary_session_id) = primary_session_id- && session_ids.contains(&primary_session_id)- {- let terminated = page_session_state- .devtools_sessions- .primary_mut()- .terminate_all_renderer_calls(reason);- push_terminated_renderer_call_error_background_events(- out,- terminated,- Some(primary_session_id),- reason,- );- }- for session_id in session_ids {- let Some(state) = page_session_state- .devtools_sessions- .attached_mut(session_id)- else {- continue;- };- let terminated = state.terminate_all_renderer_calls(reason);- push_terminated_renderer_call_error_background_events(- out,- terminated,- Some(session_id),- reason,- );- }- }-pub(crate) fn fail_pending_inspector_awaits_from_shared_worker_target_session_background_events_into(out: &mut Vec<BackgroundProtocolEvent>,target: &mut SharedWorkerTargetState,@@ -3788,7 +3772,24 @@ impl CdpConnection {) {self.restore_frontend_command_ids_in_devtools_session_output_with_projection(session_id,- dispatched_attachment_id,+ Some(dispatched_attachment_id),+ messages,+ true,+ );+ }++ /// Resolves terminal responses carried by a Worker target's concrete+ /// renderer output stream. Worker Inspector sessions do not use a Page+ /// attachment id; the exact worker session lifetime is validated by the+ /// prepared-output authority at the same ingress boundary.+ pub(crate) fn restore_frontend_command_ids_in_worker_devtools_session_output(+ &mut self,+ session_id: &str,+ messages: &mut Vec<RendererRuntimeInspectorMessage>,+ ) {+ self.restore_frontend_command_ids_in_devtools_session_output_with_projection(+ Some(session_id),+ None,messages,true,);@@ -3811,7 +3812,7 @@ impl CdpConnection {) {self.restore_frontend_command_ids_in_devtools_session_output_with_projection(session_id,- dispatched_attachment_id,+ Some(dispatched_attachment_id),messages,false,);@@ -3820,7 +3821,7 @@ impl CdpConnection {fn restore_frontend_command_ids_in_devtools_session_output_with_projection(&mut self,session_id: Option<&str>,- dispatched_attachment_id: RendererAgentAttachmentId,+ dispatched_attachment_id: Option<RendererAgentAttachmentId>,messages: &mut Vec<RendererRuntimeInspectorMessage>,project_runtime_object_ownership: bool,) {@@ -3846,13 +3847,13 @@ impl CdpConnection {.take_frontend_command_for_renderer_if_attachment_matches_for_session_owner(session_id,renderer_call_id,- Some(dispatched_attachment_id),+ dispatched_attachment_id,)else {tracing::debug!(session_id,renderer_call_id = renderer_call_id.get(),- attachment_id = dispatched_attachment_id.get(),+ attachment_id = ?dispatched_attachment_id.map(RendererAgentAttachmentId::get),"dropping DevTools session response without a live renderer correlation");return false;@@ -4648,6 +4649,7 @@ impl CdpConnection {session_id,raw_json,None,+ RuntimeProtocolResponseRoute::command_reply_without_receiver(),)}@@ -4658,37 +4660,22 @@ impl CdpConnection {command_id: u64,) -> Result<PendingSharedWorkerRuntimeProtocolMessageDispatch, String> {self.shared_worker_runtime_target_for_session(session_id)?;- let (correlation, raw_json, response_sender, response_route) =+ let (_correlation, raw_json, response_sender, response_route) =self.prepare_renderer_call_for_session_owner(session_id, descriptor, command_id, None)?;- debug_assert_eq!(- response_route.delivery(),- RendererInspectorResponseDelivery::CommandReply,- "worker responses have not migrated to the page DevTools session output"- );- let response_receiver = response_route- .into_command_reply_receiver()- .expect("CommandReply worker dispatch must allocate a response receiver");- let result = self.start_shared_worker_runtime_protocol_message_for_session_with_optional_deferred_response(+ self.start_shared_worker_runtime_protocol_message_for_session_with_optional_deferred_response(session_id,raw_json,- Some((response_sender, response_receiver)),- );- if result.is_err() {- let removed =- self.take_renderer_call_for_frontend_for_session_owner(session_id, command_id);- debug_assert_eq!(removed, Some(correlation));- }- result+ Some(response_sender),+ response_route,+ )}fn start_shared_worker_runtime_protocol_message_for_session_with_optional_deferred_response(&mut self,session_id: Option<&str>,raw_json: String,- deferred_response: Option<(- RendererRuntimeInspectorResponseSender,- RuntimeInspectorResponseReceiver,- )>,+ response_sender: Option<RendererRuntimeInspectorResponseSender>,+ response_route: RuntimeProtocolResponseRoute,) -> Result<PendingSharedWorkerRuntimeProtocolMessageDispatch, String> {let route = self.shared_worker_runtime_target_for_session(session_id)?;let renderer_runtime = self@@ -4697,24 +4684,51 @@ impl CdpConnection {.ok_or_else(|| "UnknownSession".to_owned())?;let worker = route.worker;let inspector_session_id = session_id.map(str::to_owned);- let (deferred_response, deferred_response_rx) = match deferred_response {- Some((deferred_response, rx)) => (Some(deferred_response), Some(rx)),- None => (None, None),- };- let pending: SharedWorkerRuntimeProtocolDispatchFuture = match (worker, deferred_response) {- (WorkerRuntimeTarget::Shared(instance_id), Some(deferred_response)) => {+ let response_delivery = response_route.delivery();+ let pending: SharedWorkerRuntimeProtocolDispatchFuture = match (+ worker,+ response_sender,+ response_delivery,+ ) {+ (+ WorkerRuntimeTarget::Shared(instance_id),+ Some(response),+ RendererInspectorResponseDelivery::CommandReply,+ ) => Box::pin(async move {+ renderer_runtime+ .dispatch_shared_worker_runtime_protocol_message_with_deferred_response(+ instance_id,+ inspector_session_id,+ raw_json,+ response,+ )+ .await+ .map(CompletedWorkerRuntimeProtocolDispatch::command_reply)+ }),+ (+ WorkerRuntimeTarget::Shared(instance_id),+ Some(response),+ RendererInspectorResponseDelivery::DevToolsSession,+ ) => {+ let inspector_session_id =+ inspector_session_id.ok_or_else(|| "UnknownSession".to_owned())?;Box::pin(async move {renderer_runtime- .dispatch_shared_worker_runtime_protocol_message_with_deferred_response(+ .dispatch_shared_worker_runtime_protocol_message_with_devtools_session_response(instance_id,inspector_session_id,raw_json,- deferred_response,+ response,).await+ .map(CompletedWorkerRuntimeProtocolDispatch::devtools_session)})}- (WorkerRuntimeTarget::Shared(instance_id), None) => Box::pin(async move {+ (+ WorkerRuntimeTarget::Shared(instance_id),+ None,+ RendererInspectorResponseDelivery::CommandReply,+ ) => Box::pin(async move {renderer_runtime.dispatch_shared_worker_runtime_protocol_message(instance_id,@@ -4722,20 +4736,47 @@ impl CdpConnection {raw_json,).await+ .map(CompletedWorkerRuntimeProtocolDispatch::command_reply)}),- (WorkerRuntimeTarget::Dedicated(instance_id), Some(deferred_response)) => {+ (+ WorkerRuntimeTarget::Dedicated(instance_id),+ Some(response),+ RendererInspectorResponseDelivery::CommandReply,+ ) => Box::pin(async move {+ renderer_runtime+ .dispatch_dedicated_worker_runtime_protocol_message_with_deferred_response(+ instance_id,+ inspector_session_id,+ raw_json,+ response,+ )+ .await+ .map(CompletedWorkerRuntimeProtocolDispatch::command_reply)+ }),+ (+ WorkerRuntimeTarget::Dedicated(instance_id),+ Some(response),+ RendererInspectorResponseDelivery::DevToolsSession,+ ) => {+ let inspector_session_id =+ inspector_session_id.ok_or_else(|| "UnknownSession".to_owned())?;Box::pin(async move {renderer_runtime- .dispatch_dedicated_worker_runtime_protocol_message_with_deferred_response(+ .dispatch_dedicated_worker_runtime_protocol_message_with_devtools_session_response(instance_id,inspector_session_id,raw_json,- deferred_response,+ response,).await+ .map(CompletedWorkerRuntimeProtocolDispatch::devtools_session)})}- (WorkerRuntimeTarget::Dedicated(instance_id), None) => Box::pin(async move {+ (+ WorkerRuntimeTarget::Dedicated(instance_id),+ None,+ RendererInspectorResponseDelivery::CommandReply,+ ) => Box::pin(async move {renderer_runtime.dispatch_dedicated_worker_runtime_protocol_message(instance_id,@@ -4743,12 +4784,16 @@ impl CdpConnection {raw_json,).await+ .map(CompletedWorkerRuntimeProtocolDispatch::command_reply)}),+ (_, None, RendererInspectorResponseDelivery::DevToolsSession) => {+ return Err("DevToolsSessionResponseSenderMissing".to_owned());+ }};Ok(PendingSharedWorkerRuntimeProtocolMessageDispatch {session_id: session_id.map(str::to_owned),pending,- deferred_response_rx,+ response_route,})}@@ -4788,9 +4833,9 @@ impl CdpConnection {self.restore_frontend_command_ids_in_runtime_messages(completed.session_id.as_deref(),None,- &mut completed.messages,+ &mut completed.dispatch.messages,);- Ok(completed.messages)+ Ok(completed.dispatch.messages)}pub(crate) fn start_service_worker_runtime_protocol_message_for_session(@@ -4804,6 +4849,7 @@ impl CdpConnection {session_id,raw_json,None,+ RuntimeProtocolResponseRoute::command_reply_without_receiver(),)}@@ -4814,37 +4860,22 @@ impl CdpConnection {command_id: u64,) -> Result<PendingServiceWorkerRuntimeProtocolMessageDispatch, String> {self.service_worker_runtime_target_for_session(session_id)?;- let (correlation, raw_json, response_sender, response_route) =+ let (_correlation, raw_json, response_sender, response_route) =self.prepare_renderer_call_for_session_owner(session_id, descriptor, command_id, None)?;- debug_assert_eq!(- response_route.delivery(),- RendererInspectorResponseDelivery::CommandReply,- "worker responses have not migrated to the page DevTools session output"- );- let response_receiver = response_route- .into_command_reply_receiver()- .expect("CommandReply worker dispatch must allocate a response receiver");- let result = self.start_service_worker_runtime_protocol_message_for_session_with_optional_deferred_response(+ self.start_service_worker_runtime_protocol_message_for_session_with_optional_deferred_response(session_id,raw_json,- Some((response_sender, response_receiver)),- );- if result.is_err() {- let removed =- self.take_renderer_call_for_frontend_for_session_owner(session_id, command_id);- debug_assert_eq!(removed, Some(correlation));- }- result+ Some(response_sender),+ response_route,+ )}fn start_service_worker_runtime_protocol_message_for_session_with_optional_deferred_response(&mut self,session_id: Option<&str>,raw_json: String,- deferred_response: Option<(- RendererRuntimeInspectorResponseSender,- RuntimeInspectorResponseReceiver,- )>,+ response_sender: Option<RendererRuntimeInspectorResponseSender>,+ response_route: RuntimeProtocolResponseRoute,) -> Result<PendingServiceWorkerRuntimeProtocolMessageDispatch, String> {let route = self.service_worker_runtime_target_for_session(session_id)?;let renderer_runtime = self@@ -4853,36 +4884,50 @@ impl CdpConnection {.ok_or_else(|| "UnknownSession".to_owned())?;let version_id = route.version_id;let inspector_session_id = session_id.map(str::to_owned);- let (deferred_response, deferred_response_rx) = match deferred_response {- Some((deferred_response, rx)) => (Some(deferred_response), Some(rx)),- None => (None, None),- };- let pending =- Box::pin(async move {- match deferred_response {- Some(deferred_response) => renderer_runtime+ let response_delivery = response_route.delivery();+ let pending: ServiceWorkerRuntimeProtocolDispatchFuture = Box::pin(async move {+ match (response_sender, response_delivery) {+ (Some(response), RendererInspectorResponseDelivery::CommandReply) => {+ renderer_runtime.dispatch_service_worker_runtime_protocol_message_with_deferred_response(version_id,inspector_session_id,raw_json,- deferred_response,+ response,)- .await,- None => {- renderer_runtime- .dispatch_service_worker_runtime_protocol_message(+ .await+ .map(CompletedWorkerRuntimeProtocolDispatch::command_reply)+ }+ (Some(response), RendererInspectorResponseDelivery::DevToolsSession) => {+ let inspector_session_id =+ inspector_session_id.ok_or_else(|| "UnknownSession".to_owned())?;+ renderer_runtime+ .dispatch_service_worker_runtime_protocol_message_with_devtools_session_response(version_id,inspector_session_id,raw_json,+ response,).await- }+ .map(CompletedWorkerRuntimeProtocolDispatch::devtools_session)}- });+ (None, RendererInspectorResponseDelivery::CommandReply) => renderer_runtime+ .dispatch_service_worker_runtime_protocol_message(+ version_id,+ inspector_session_id,+ raw_json,+ )+ .await+ .map(CompletedWorkerRuntimeProtocolDispatch::command_reply),+ (None, RendererInspectorResponseDelivery::DevToolsSession) => {+ Err("DevToolsSessionResponseSenderMissing".to_owned())+ }+ }+ });Ok(PendingServiceWorkerRuntimeProtocolMessageDispatch {session_id: session_id.map(str::to_owned),pending,- deferred_response_rx,+ response_route,})}@@ -4893,9 +4938,9 @@ impl CdpConnection {self.restore_frontend_command_ids_in_runtime_messages(completed.session_id.as_deref(),None,- &mut completed.messages,+ &mut completed.dispatch.messages,);- Ok(completed.messages)+ Ok(completed.dispatch.messages)}pub(crate) fn start_moli_diagnostics(diff --git a/moli-protocol/src/conn/runtime_load.rs b/moli-protocol/src/conn/runtime_load.rsindex 6427f5dcf..c4c5b16dc 100644--- a/moli-protocol/src/conn/runtime_load.rs+++ b/moli-protocol/src/conn/runtime_load.rs@@ -305,7 +305,7 @@ pub struct ResponseCommitReady {response_status: u16,response_headers: Vec<(String, String)>,response_from_cache: bool,- navigation_engine: Option<NavigationEngine>,+ navigation_engine_handoff: NavigationEngineHandoff,timing_started: Option<std::time::Instant>,main_document_commit: Option<Arc<RendererMainDocumentCommit>>,network_error_page: Option<NetworkErrorPageNavigation>,@@ -399,8 +399,8 @@ impl ResponseCommitReady {.issue_commit_permit()}- pub(crate) fn with_navigation_engine(mut self, engine: NavigationEngine) -> Self {- self.navigation_engine = Some(engine);+ pub(crate) fn with_navigation_engine_replacement(mut self, engine: NavigationEngine) -> Self {+ self.navigation_engine_handoff = NavigationEngineHandoff::replacement(engine);self}@@ -492,7 +492,10 @@ impl ResponseCommitReady {renderer_output_predecessor: diagnostics.renderer_output_predecessor,main_document_commit: self.main_document_commit.take(),document_progress_transfer,- navigation_engine: self.navigation_engine.take(),+ navigation_engine_handoff: std::mem::replace(+ &mut self.navigation_engine_handoff,+ NavigationEngineHandoff::retained_by_owner(),+ ),network_error_page: self.network_error_page.take(),})}@@ -588,7 +591,7 @@ impl PausedResponsePreparedDocument {response_status: self.response_status,response_headers: self.response_headers,response_from_cache: self.response_from_cache,- navigation_engine: None,+ navigation_engine_handoff: NavigationEngineHandoff::retained_by_owner(),timing_started: self.timing_started,main_document_commit: self.main_document_commit,network_error_page: None,@@ -1437,7 +1440,7 @@ async fn build_navigation_from_streaming_raw_response_with_engine_async(response_status,response_headers,response_from_cache,- navigation_engine: None,+ navigation_engine_handoff: NavigationEngineHandoff::retained_by_owner(),timing_started: timing_enabled.then_some(timing_started),main_document_commit,network_error_page: None,@@ -1530,7 +1533,7 @@ async fn build_navigation_from_streaming_raw_response_with_engine_async(response_status,response_headers,response_from_cache,- navigation_engine: None,+ navigation_engine_handoff: NavigationEngineHandoff::retained_by_owner(),timing_started: timing_enabled.then_some(timing_started),main_document_commit,network_error_page: None,@@ -2414,8 +2417,9 @@ impl CdpConnection {).await{- return navigation- .map(|navigation| navigation.with_navigation_engine(inline_engine));+ return navigation.map(|navigation| {+ navigation.with_navigation_engine_replacement(inline_engine)+ });}if let Some(navigation) = load_data_url_navigation_with_engine_async(&mut inline_engine,@@ -2428,8 +2432,9 @@ impl CdpConnection {).await{- return navigation- .map(|navigation| navigation.with_navigation_engine(inline_engine));+ return navigation.map(|navigation| {+ navigation.with_navigation_engine_replacement(inline_engine)+ });}}@@ -2789,8 +2794,8 @@ impl CdpConnection {}pub async fn load_page_via_runtime_async(&mut self, raw_url: &str) -> Result<Page, String> {- let navigation = self.load_navigation_via_runtime_async(raw_url).await?;- if let Some(engine) = navigation.navigation_engine {+ let mut navigation = self.load_navigation_via_runtime_async(raw_url).await?;+ if let Some(engine) = navigation.take_navigation_engine_replacement() {let page_owner = self.browser_context.as_ref().and_then(|context| {Some((context.id.clone(), context.active_target_id()?.to_owned()))});@@ -3138,7 +3143,7 @@ impl CdpConnection {false,network_progress,),- navigation_engine: None,+ navigation_engine_handoff: NavigationEngineHandoff::retained_by_owner(),network_error_page: None,})}@@ -3436,7 +3441,7 @@ impl CdpConnection {false,network_progress,),- navigation_engine: None,+ navigation_engine_handoff: NavigationEngineHandoff::retained_by_owner(),network_error_page: None,})}@@ -3633,7 +3638,7 @@ impl CdpConnection {).await?;Ok(NavigationLoadOutcome::response_commit_ready(- navigation.with_navigation_engine(engine),+ navigation.with_navigation_engine_replacement(engine),))}@@ -3786,7 +3791,7 @@ impl CdpConnection {RendererReplyBoundary::Stage,).await?;- Ok(navigation.with_navigation_engine(engine))+ Ok(navigation.with_navigation_engine_replacement(engine))}pub(crate) async fn collect_navigation_streaming_raw_response_async(@@ -4055,7 +4060,7 @@ async fn prepare_captured_document_response_with_engine_async(response_status,response_headers,response_from_cache,- navigation_engine: None,+ navigation_engine_handoff: NavigationEngineHandoff::retained_by_owner(),timing_started: None,main_document_commit,network_error_page,diff --git a/moli-protocol/src/conn/state/browser_context.rs b/moli-protocol/src/conn/state/browser_context.rsindex e352ff33b..e1681eb12 100644--- a/moli-protocol/src/conn/state/browser_context.rs+++ b/moli-protocol/src/conn/state/browser_context.rs@@ -1713,6 +1713,7 @@ impl BrowserContext {.attach_session(session_id.into());}+ #[cfg(test)]pub(crate) fn detach_active_session(&mut self) -> Option<String> {self.page_targets.active_mut()?.detach_session()}diff --git a/moli-protocol/src/conn/state/devtools_session.rs b/moli-protocol/src/conn/state/devtools_session.rsindex e23acd8c3..fcfdd651a 100644--- a/moli-protocol/src/conn/state/devtools_session.rs+++ b/moli-protocol/src/conn/state/devtools_session.rs@@ -133,11 +133,6 @@ impl DevToolsSessionRegistry {.get(&DevToolsSessionKey::Attached(session_id.to_owned()))}- pub(crate) fn attached_mut(&mut self, session_id: &str) -> Option<&mut DevToolsSessionState> {- self.states- .get_mut(&DevToolsSessionKey::Attached(session_id.to_owned()))- }-pub(crate) fn ensure_attached(&mut self, session_id: &str) -> &mut DevToolsSessionState {if !self.states@@ -160,10 +155,31 @@ impl DevToolsSessionRegistry {removed}- pub(crate) fn clear_attached(&mut self) {- self.states- .retain(|key, _state| matches!(key, DevToolsSessionKey::Primary));- self.attached_order.clear();+ /// Removes one wire session and all domain-handler state it owns.+ ///+ /// The primary handler slot remains allocated for the renderer's implicit+ /// root Inspector session, but its state is replaced atomically. Attached+ /// sessions are removed from both the state map and attachment order.+ pub(crate) fn dispose(+ &mut self,+ session_id: &str,+ session_key: &DevToolsSessionKey,+ ) -> Option<DevToolsSessionState> {+ match session_key {+ DevToolsSessionKey::Primary => {+ if self.primary_session_id() != Some(session_id) {+ return None;+ }+ self.primary_session_id = None;+ Some(std::mem::take(self.primary_mut()))+ }+ DevToolsSessionKey::Attached(attached_session_id)+ if attached_session_id == session_id =>+ {+ self.remove_attached(session_id)+ }+ DevToolsSessionKey::Attached(_) => None,+ }}pub(crate) fn attached_len(&self) -> usize {@@ -384,13 +400,6 @@ impl DevToolsSessionRegistry {self.states.values_mut()}- pub(crate) fn reset(&mut self, preserve_attached_sessions: bool) {- *self.primary_mut() = DevToolsSessionState::default();- if !preserve_attached_sessions {- self.clear_attached();- }- }-pub(crate) fn has_non_default_state(&self) -> bool {self.primary() != &DevToolsSessionState::default() || !self.attached_is_empty()}@@ -406,15 +415,6 @@ impl DevToolsSessionRegistry {.sum()}- pub(crate) fn drain_pending_inspector_awaits_for_sessions(- &mut self,- session_ids: &[&str],- ) -> Vec<(u64, PendingInspectorAwait)> {- self.states_mut()- .flat_map(|state| state.drain_pending_inspector_awaits_for_sessions(session_ids))- .collect()- }-pub(crate) fn prepare_renderer_call_replacements(&mut self,primary_session_id: Option<&str>,@@ -915,14 +915,6 @@ impl DevToolsSessionState {self.pending_inspector_awaits.drain_all()}- pub(crate) fn drain_pending_inspector_awaits_for_sessions(- &mut self,- session_ids: &[&str],- ) -> Vec<(u64, PendingInspectorAwait)> {- self.pending_inspector_awaits- .drain_for_sessions(session_ids)- }-pub(crate) fn register_runtime_remote_object_ids<I>(&mut self, object_ids: I)whereI: IntoIterator<Item = String>,@@ -1428,13 +1420,71 @@ mod tests {assert!(sessions.has_pending_inspector_awaits());assert_eq!(sessions.pending_inspector_await_count(), 2);- let drained = sessions.drain_pending_inspector_awaits_for_sessions(&["SID-attached"]);- assert_eq!(drained.len(), 1);+ let disposed = sessions+ .dispose(+ "SID-attached",+ &DevToolsSessionKey::Attached("SID-attached".to_owned()),+ )+ .expect("attached session should be disposed");+ assert_eq!(disposed.pending_inspector_await_count(), 1);assert_eq!(sessions.pending_inspector_await_count(), 1);- sessions.remove_attached("SID-attached");+ assert!(sessions.attached_is_empty());assert_eq!(sessions.pending_inspector_await_count(), 1);- sessions.reset(false);+ *sessions.primary_mut() = DevToolsSessionState::default();assert!(!sessions.has_pending_inspector_awaits());}++ #[test]+ fn registry_dispose_is_exactly_once_and_preserves_peer_sessions() {+ let mut sessions = DevToolsSessionRegistry::default();+ sessions.attach_primary("SID-primary".to_owned());+ sessions+ .primary_mut()+ .runtime_bindings+ .push(binding("primary"));+ sessions+ .ensure_attached("SID-attached")+ .runtime_bindings+ .push(binding("attached"));++ let disposed_attached = sessions+ .dispose(+ "SID-attached",+ &DevToolsSessionKey::Attached("SID-attached".to_owned()),+ )+ .expect("attached session should be disposed");+ assert_eq!(+ disposed_attached.runtime_bindings,+ vec![binding("attached")]+ );+ assert!(sessions.attached_is_empty());+ assert_eq!(sessions.primary_session_id(), Some("SID-primary"));+ assert_eq!(+ sessions.primary().runtime_bindings,+ vec![binding("primary")]+ );+ assert!(+ sessions+ .dispose(+ "SID-attached",+ &DevToolsSessionKey::Attached("SID-attached".to_owned()),+ )+ .is_none(),+ "a disposed session must not settle twice"+ );++ let disposed_primary = sessions+ .dispose("SID-primary", &DevToolsSessionKey::Primary)+ .expect("primary session should be disposed");+ assert_eq!(disposed_primary.runtime_bindings, vec![binding("primary")]);+ assert_eq!(sessions.primary_session_id(), None);+ assert_eq!(sessions.primary(), &DevToolsSessionState::default());+ assert!(+ sessions+ .dispose("SID-primary", &DevToolsSessionKey::Primary)+ .is_none(),+ "primary disposal must also be exactly once"+ );+ }}diff --git a/moli-protocol/src/conn/state/fetch.rs b/moli-protocol/src/conn/state/fetch.rsindex 2845e7b0f..4bbe4a457 100644--- a/moli-protocol/src/conn/state/fetch.rs+++ b/moli-protocol/src/conn/state/fetch.rs@@ -1158,6 +1158,7 @@ impl TargetFetchConfig {})}+ #[cfg(test)]pub(crate) fn reset(&mut self) {*self = Self::default();}@@ -1763,6 +1764,7 @@ impl TargetFetchOwner {self.config.remove_network_intercept(intercept_id)}+ #[cfg(test)]pub(crate) fn reset_config(&mut self) {self.config.reset();}diff --git a/moli-protocol/src/conn/state/mod.rs b/moli-protocol/src/conn/state/mod.rsindex f52b11a3d..28cb5a590 100644--- a/moli-protocol/src/conn/state/mod.rs+++ b/moli-protocol/src/conn/state/mod.rs@@ -138,6 +138,7 @@ pub use navigation_outcome::{NavigationRequestLoadPolicy, TargetInfo,};pub(crate) use navigation_outcome::{- NETWORK_ERROR_PAGE_URL, NavigationResultProjection, NavigationSourceDocumentSecurityContext,- NetworkErrorPageNavigation, RendererMainDocumentCommitSeed,+ NETWORK_ERROR_PAGE_URL, NavigationEngineHandoff, NavigationResultProjection,+ NavigationSourceDocumentSecurityContext, NetworkErrorPageNavigation,+ RendererMainDocumentCommitSeed,};diff --git a/moli-protocol/src/conn/state/navigation_outcome.rs b/moli-protocol/src/conn/state/navigation_outcome.rsindex 840c4383a..05265997a 100644--- a/moli-protocol/src/conn/state/navigation_outcome.rs+++ b/moli-protocol/src/conn/state/navigation_outcome.rs@@ -19,6 +19,35 @@ use super::browser_context::BrowserContext;pub(crate) const NETWORK_ERROR_PAGE_URL: &str = "chrome-error://chromewebdata/";+/// What must happen to the navigation engine after a completed load is+/// committed.+///+/// Foreground loads borrow the engine already installed on their target.+/// Background loads own a temporary engine and must return it to that exact+/// target after commit. Keeping this distinction explicit prevents an omitted+/// replacement handoff from silently looking like a valid background load.+#[derive(Debug)]+pub(crate) struct NavigationEngineHandoff(Option<NavigationEngine>);++impl NavigationEngineHandoff {+ pub(crate) fn retained_by_owner() -> Self {+ Self(None)+ }++ pub(crate) fn replacement(engine: NavigationEngine) -> Self {+ Self(Some(engine))+ }++ pub(crate) fn into_replacement(self) -> Option<NavigationEngine> {+ self.0+ }++ #[cfg(test)]+ pub(crate) fn replacement_ref(&self) -> Option<&NavigationEngine> {+ self.0.as_ref()+ }+}+#[derive(Clone, Debug)]pub(crate) struct NetworkErrorPageNavigation {error_text: String,@@ -194,16 +223,29 @@ pub struct LoadedNavigation {pub renderer_output_predecessor: Option<moli_core::RendererOutputFence>,pub(crate) main_document_commit: Option<Arc<RendererMainDocumentCommit>>,pub(crate) document_progress_transfer: CompletedDocumentProgressTransfer,- pub(crate) navigation_engine: Option<NavigationEngine>,+ pub(crate) navigation_engine_handoff: NavigationEngineHandoff,pub(crate) network_error_page: Option<NetworkErrorPageNavigation>,}impl LoadedNavigation {- pub(crate) fn with_navigation_engine(mut self, engine: NavigationEngine) -> Self {- self.navigation_engine = Some(engine);+ pub(crate) fn with_navigation_engine_replacement(mut self, engine: NavigationEngine) -> Self {+ self.navigation_engine_handoff = NavigationEngineHandoff::replacement(engine);self}+ pub(crate) fn take_navigation_engine_replacement(&mut self) -> Option<NavigationEngine> {+ std::mem::replace(+ &mut self.navigation_engine_handoff,+ NavigationEngineHandoff::retained_by_owner(),+ )+ .into_replacement()+ }++ #[cfg(test)]+ pub(crate) fn navigation_engine_replacement(&self) -> Option<&NavigationEngine> {+ self.navigation_engine_handoff.replacement_ref()+ }+#[cfg(test)]pub(crate) fn response_body(&self) -> String {self.document_progress_transfer@@ -253,12 +295,14 @@ impl NavigationLoadOutcome {Self::NetworkFailure(error_text)}- pub(crate) fn with_navigation_engine(self, engine: NavigationEngine) -> Self {+ pub(crate) fn with_navigation_engine_replacement(self, engine: NavigationEngine) -> Self {match self {Self::ResponseCommitReady(navigation) => {- Self::response_commit_ready(navigation.with_navigation_engine(engine))+ Self::response_commit_ready(navigation.with_navigation_engine_replacement(engine))+ }+ Self::Loaded(navigation) => {+ Self::loaded(navigation.with_navigation_engine_replacement(engine))}- Self::Loaded(navigation) => Self::loaded(navigation.with_navigation_engine(engine)),Self::Download(navigation) => Self::Download(navigation),Self::NetworkFailure(error_text) => Self::NetworkFailure(error_text),}diff --git a/moli-protocol/src/conn/state/parking.rs b/moli-protocol/src/conn/state/parking.rsindex a72baa32b..11b13dc06 100644--- a/moli-protocol/src/conn/state/parking.rs+++ b/moli-protocol/src/conn/state/parking.rs@@ -308,33 +308,6 @@ impl TargetPendingInspectorAwaitRegistry {}Some(entry)}-- pub(crate) fn drain_for_sessions(- &mut self,- session_ids: &[&str],- ) -> Vec<(u64, PendingInspectorAwait)> {- if self.entries.is_empty() || session_ids.is_empty() {- return Vec::new();- }- let to_remove: Vec<FrontendCommandId> = self- .entries- .iter()- .filter_map(|(id, entry)| {- entry- .session_id- .as_deref()- .filter(|sid| session_ids.contains(sid))- .map(|_| *id)- })- .collect();- to_remove- .into_iter()- .filter_map(|id| {- self.remove_for_cancellation(id)- .map(|entry| (id.get(), entry))- })- .collect()- }}#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]@@ -533,21 +506,41 @@ impl TargetOwnerState {.any(|(_, script)| script.has_bidi_channel_argument)}- pub(crate) fn take_document_start_script_registry_keys_for_session(- &mut self,+ pub(crate) fn document_start_script_registry_keys_for_session(+ &self,devtools_session: &DevToolsSessionKey,) -> Vec<String> {- let mut registry_keys = Vec::new();- self.document_start_scripts.retain(|(_, script)| {- if script.devtools_session.as_ref() != Some(devtools_session) {- return true;- }- if let Some(registry_key) = script.registry_key.clone() {- registry_keys.push(registry_key);- }- false- });- registry_keys+ self.document_start_scripts+ .iter()+ .filter_map(|(_, script)| {+ (script.devtools_session.as_ref() == Some(devtools_session))+ .then(|| script.registry_key.clone())+ .flatten()+ })+ .collect()+ }++ pub(crate) fn remove_document_start_scripts_for_session(+ &mut self,+ devtools_session: &DevToolsSessionKey,+ ) {+ self.document_start_scripts+ .retain(|(_, script)| script.devtools_session.as_ref() != Some(devtools_session));+ }++ pub(crate) fn remove_document_start_script_registry_key_for_session(+ &mut self,+ devtools_session: &DevToolsSessionKey,+ registry_key: &str,+ ) -> bool {+ let Some(index) = self.document_start_scripts.iter().position(|(_, script)| {+ script.devtools_session.as_ref() == Some(devtools_session)+ && script.registry_key.as_deref() == Some(registry_key)+ }) else {+ return false;+ };+ self.document_start_scripts.remove(index);+ true}pub(crate) fn begin_initial_empty_document(diff --git a/moli-protocol/src/conn/state/runtime_slot.rs b/moli-protocol/src/conn/state/runtime_slot.rsindex e0d30d741..3c552efc5 100644--- a/moli-protocol/src/conn/state/runtime_slot.rs+++ b/moli-protocol/src/conn/state/runtime_slot.rs@@ -70,16 +70,6 @@ pub(crate) struct TargetNetworkRequestIdAllocator<'a> {}impl TargetNetworkRequestIdAllocator<'_> {- pub(crate) fn reset_fetch_navigation_request_counter(&mut self) {- self.runtime_slot.request_counters.next_fetch_request_id = 0;- }-- pub(crate) fn reset_subresource_fetch_request_counter(&mut self) {- self.runtime_slot- .request_counters- .next_subresource_fetch_request_id = 0;- }-pub(crate) fn allocate_fetch_navigation_request_id(&mut self) -> String {self.runtime_slot.request_counters.next_fetch_request_id += 1;format!(@@ -1238,11 +1228,6 @@ impl TargetRuntimeSlot {.synthetic_websocket_socket_id_for_request(request_id)}- pub(crate) fn clear_session_scoped_network_observation_artifacts(&mut self) {- self.network_agent- .clear_session_scoped_observation_artifacts();- }-pub(crate) fn reset_all_target_scoped_network_artifacts(&mut self) {self.network_agent.reset_all_target_scoped_artifacts();}diff --git a/moli-protocol/src/conn/state/service_worker_target.rs b/moli-protocol/src/conn/state/service_worker_target.rsindex 80515b1e3..64babf567 100644--- a/moli-protocol/src/conn/state/service_worker_target.rs+++ b/moli-protocol/src/conn/state/service_worker_target.rs@@ -1016,6 +1016,19 @@ impl ServiceWorkerTargetState {)}+ pub(crate) fn renderer_command_descriptor_for_renderer_if_attachment_matches(+ &self,+ owner_session_id: &str,+ renderer_call_id: moli_page_types::RendererCallId,+ dispatched_attachment_id: Option<moli_page_types::RendererAgentAttachmentId>,+ ) -> Option<RendererCommandDescriptor> {+ self.session_state(owner_session_id)?+ .renderer_command_descriptor_for_renderer_if_attachment_matches(+ renderer_call_id,+ dispatched_attachment_id,+ )+ }+pub(crate) fn has_pending_inspector_awaits(&self) -> bool {self.sessions.values()diff --git a/moli-protocol/src/conn/state/session.rs b/moli-protocol/src/conn/state/session.rsindex 89d19cb99..4fedf0d2d 100644--- a/moli-protocol/src/conn/state/session.rs+++ b/moli-protocol/src/conn/state/session.rs@@ -1,6 +1,5 @@use super::devtools_session::DevToolsNetworkSessionState;use super::emulation::EmulatedMediaOverrides;-use super::fetch::TargetFetchOwner;use super::javascript_dialog::TargetJavaScriptDialogState;use super::page_target_host::PageTargetHost;use crate::domains::audits_output_state::TargetAuditsSessionState;@@ -200,12 +199,8 @@ impl PageTargetHost {|| self.fetch_owner.config_snapshot() != super::fetch::TargetFetchConfig::default()}- pub(crate) fn clear_session_scoped_state_fields(- &mut self,- preserve_auxiliary_devtools_sessions: bool,- ) {- self.devtools_sessions- .reset(preserve_auxiliary_devtools_sessions);+ pub(crate) fn clear_primary_session_scoped_state_fields(&mut self) {+ *self.devtools_sessions.primary_mut() = Default::default();self.runtime_slot.disable_primary_network_events();self.network_policy.clear_session_scoped_state();self.http_proxy_override = None;@@ -221,13 +216,9 @@ impl PageTargetHost {self.focus_emulation_enabled = false;self.script_execution_disabled = false;self.css_enabled = false;- self.fetch_owner = TargetFetchOwner::default();- self.runtime_slot- .clear_session_scoped_network_observation_artifacts();+ self.fetch_owner.remove_fetch_session(None);self.runtime_slot- .request_id_allocator()- .reset_fetch_navigation_request_counter();- self.owner_state.clear_observable_output_state();+ .remove_network_session_observation_cursor(None);}}diff --git a/moli-protocol/src/conn/state/shared_worker_target.rs b/moli-protocol/src/conn/state/shared_worker_target.rsindex 2141d067c..c5e7d8d71 100644--- a/moli-protocol/src/conn/state/shared_worker_target.rs+++ b/moli-protocol/src/conn/state/shared_worker_target.rs@@ -681,6 +681,19 @@ impl SharedWorkerTargetState {)}+ pub(crate) fn renderer_command_descriptor_for_renderer_if_attachment_matches(+ &self,+ owner_session_id: &str,+ renderer_call_id: moli_page_types::RendererCallId,+ dispatched_attachment_id: Option<moli_page_types::RendererAgentAttachmentId>,+ ) -> Option<RendererCommandDescriptor> {+ self.session_state(owner_session_id)?+ .renderer_command_descriptor_for_renderer_if_attachment_matches(+ renderer_call_id,+ dispatched_attachment_id,+ )+ }+pub(crate) fn remove_pending_inspector_await(&mut self,owner_session_id: &str,diff --git a/moli-protocol/src/conn/target/mod.rs b/moli-protocol/src/conn/target/mod.rsindex f697ad9f5..ca21c295a 100644--- a/moli-protocol/src/conn/target/mod.rs+++ b/moli-protocol/src/conn/target/mod.rs@@ -27,3 +27,4 @@ pub(crate) use transaction::{TargetBindingCleanupAction, TargetBindingCleanupPlan, TargetClosureCleanupPlan,TargetEventPlan, TargetSessionDetachCleanupPlan,};+pub(crate) use worker_session::TargetWorkerProtocolAttachmentIdentity;diff --git a/moli-protocol/src/conn/target/session_binding.rs b/moli-protocol/src/conn/target/session_binding.rsindex 4e476820a..180cf94cd 100644--- a/moli-protocol/src/conn/target/session_binding.rs+++ b/moli-protocol/src/conn/target/session_binding.rs@@ -11,7 +11,7 @@ impl CdpConnection {pub(crate) async fn clear_target_session_overrides_async(&mut self,session_id: &str,- ) -> Result<(), String> {+ ) -> anyhow::Result<()> {let browser_identity_changed = match self.browser_context.as_mut() {Some(browser_context) => {browser_context@@ -24,16 +24,17 @@ impl CdpConnection {return Ok(());}- let Some(pending) =- self.start_rebuild_resource_runtime_for_session_owner(Some(session_id))?+ let Some(pending) = self+ .start_rebuild_resource_runtime_for_session_owner(Some(session_id))+ .map_err(anyhow::Error::msg)?else {return Ok(());};- let completion = pending- .wait()- .await- .map_err(|error| format!("failed to restore detached session user agent: {error}"))?;+ let completion = pending.wait().await.map_err(|error| {+ anyhow::anyhow!("failed to restore detached session user agent: {error}")+ })?;self.finish_rebuild_resource_runtime_for_session_owner(Some(session_id), completion)+ .map_err(anyhow::Error::msg)}pub(crate) fn is_browser_session_id(&self, session_id: Option<&str>) -> bool {@@ -674,8 +675,26 @@ impl CdpConnection {}if let Some(cleanup_plan) = rollback_plan.cleanup_plan() {- self.execute_target_binding_cleanup_without_event_async(cleanup_plan)- .await;+ if let Err(error) = self+ .remove_document_start_scripts_for_detached_session_async(cleanup_plan.session_id())+ .await+ {+ tracing::warn!(+ session_id = rollback_plan.session_id(),+ %error,+ "failed to remove target scripts during attach rollback"+ );+ }+ if let Err(error) = self+ .execute_target_binding_cleanup_without_event_async(cleanup_plan)+ .await+ {+ tracing::warn!(+ session_id = rollback_plan.session_id(),+ %error,+ "failed to clean prepared target binding during attach rollback"+ );+ }}self.rollback_attached_session_without_event(rollback_plan.session_id())}@@ -700,25 +719,18 @@ impl CdpConnection {pub(crate) async fn execute_target_binding_cleanup_without_event_async(&mut self,cleanup_plan: &TargetBindingCleanupPlan,- ) {- self.remove_document_start_scripts_for_detached_session_best_effort_async(- cleanup_plan.session_id(),- )- .await;+ ) -> anyhow::Result<()> {match cleanup_plan.action() {TargetBindingCleanupAction::PageTarget {target_id,session_key: moli_page_types::DevToolsSessionKey::Primary,} => {if let Some(bc) = self.browser_context.as_mut() {- if bc.is_active_target(target_id) {- let _ = bc- .clear_active_target_primary_auto_attached_session_async()- .await;- } else {- let _ = bc.clear_background_target_primary_auto_attached_session(- cleanup_plan.session_id(),- );+ let disposed = bc+ .dispose_primary_page_session_async(target_id, cleanup_plan.session_id())+ .await?;+ if !disposed {+ anyhow::bail!("InvalidSessionId");}}}@@ -750,27 +762,28 @@ impl CdpConnection {}TargetBindingCleanupAction::None => {}}+ Ok(())}pub(crate) async fn execute_target_binding_cleanup_for_session_without_event_async(&mut self,session_id: &str,- ) -> bool {+ ) -> anyhow::Result<bool> {let Some(route) = self.session_route(Some(session_id)) else {- return false;+ return Ok(false);};self.cancel_tracing_for_session_owner_async(Some(session_id)).await;let cleanup_plan = TargetBindingCleanupPlan::from_route(session_id, &route);self.execute_target_binding_cleanup_without_event_async(&cleanup_plan)- .await;- true+ .await?;+ Ok(true)}pub(crate) async fn detach_session_with_binding_cleanup_event_plan_async(&mut self,cleanup_plan: TargetSessionDetachCleanupPlan,- ) -> TargetEventPlan {+ ) -> anyhow::Result<TargetEventPlan> {let session_id = cleanup_plan.session_id().to_owned();let target_id = cleanup_plan.target_id().to_owned();let reason = cleanup_plan.reason().map(str::to_owned);@@ -781,21 +794,24 @@ impl CdpConnection {.attached_session_owner_session_id(&session_id)}).map(str::to_owned);- let _ = self+ let cleaned = self.execute_target_binding_cleanup_for_session_without_event_async(&session_id)- .await;- self.detach_known_session_event_plan(+ .await?;+ if !cleaned {+ anyhow::bail!("InvalidSessionId");+ }+ Ok(self.detach_known_session_event_plan(&target_id,&session_id,reason.as_deref(),parent_session_id.as_deref(),- )+ ))}pub(crate) async fn detach_dedicated_worker_session_with_binding_cleanup_event_plan_async(&mut self,cleanup_plan: TargetSessionDetachCleanupPlan,- ) -> TargetEventPlan {+ ) -> anyhow::Result<TargetEventPlan> {let session_id = cleanup_plan.session_id().to_owned();let target_id = cleanup_plan.target_id().to_owned();let reason = cleanup_plan.reason().map(str::to_owned);@@ -806,15 +822,20 @@ impl CdpConnection {.attached_session_owner_session_id(&session_id)}).map(str::to_owned);- let _ = self+ let cleaned = self.execute_target_binding_cleanup_for_session_without_event_async(&session_id)- .await;- self.detach_known_session_event_plan_with_attached_state_delta(- &target_id,- &session_id,- reason.as_deref(),- parent_session_id.as_deref(),- false,+ .await?;+ if !cleaned {+ anyhow::bail!("InvalidSessionId");+ }+ Ok(+ self.detach_known_session_event_plan_with_attached_state_delta(+ &target_id,+ &session_id,+ reason.as_deref(),+ parent_session_id.as_deref(),+ false,+ ),)}@@ -838,245 +859,6 @@ impl CdpConnection {)}- pub(crate) async fn detach_target_sessions_with_binding_cleanup_event_plan_async(- &mut self,- cleanup_plan: TargetClosureCleanupPlan,- parent_session_id: Option<&str>,- ) -> TargetEventPlan {- let target_id = cleanup_plan.target_id().to_owned();- let reason = cleanup_plan.reason().map(str::to_owned);- let session_ids = cleanup_plan- .session_ids()- .map(str::to_owned)- .collect::<Vec<_>>();- let mut plan = TargetEventPlan::default();- for session_id in session_ids {- if self- .execute_target_binding_cleanup_for_session_without_event_async(&session_id)- .await- {- plan.extend(self.detach_known_session_event_plan(- &target_id,- &session_id,- reason.as_deref(),- parent_session_id,- ));- }- }- plan- }-- pub(crate) async fn detach_active_target_session_binding_event_plan_async(- &mut self,- cleanup_plan: TargetSessionDetachCleanupPlan,- ) -> Result<TargetEventPlan, String> {- let session_id = cleanup_plan.session_id().to_owned();- let target_id = cleanup_plan.target_id().to_owned();- let reason = cleanup_plan.reason().map(str::to_owned);- let parent_session_id = cleanup_plan.parent_session_id().map(str::to_owned);- self.remove_document_start_scripts_for_detached_session_best_effort_async(&session_id)- .await;- self.clear_active_target_session_binding_for_detach_async()- .await?;- Ok(self.detach_known_session_event_plan(- &target_id,- &session_id,- reason.as_deref(),- parent_session_id.as_deref(),- ))- }-- pub(crate) async fn detach_background_target_session_binding_event_plan_async(- &mut self,- cleanup_plan: TargetSessionDetachCleanupPlan,- ) -> Result<Option<TargetEventPlan>, String> {- let session_id = cleanup_plan.session_id().to_owned();- let target_id = cleanup_plan.target_id().to_owned();- let reason = cleanup_plan.reason().map(str::to_owned);- let parent_session_id = cleanup_plan.parent_session_id().map(str::to_owned);- self.remove_document_start_scripts_for_detached_session_best_effort_async(&session_id)- .await;- let Some(detached_target_id) = self- .clear_background_target_session_binding_for_detach_async(&session_id)- .await?- else {- return Ok(None);- };- debug_assert_eq!(detached_target_id, target_id);- Ok(Some(self.detach_known_session_event_plan(- &target_id,- &session_id,- reason.as_deref(),- parent_session_id.as_deref(),- )))- }-- pub(crate) fn background_target_session_detach_cleanup_plans(- &self,- reason: Option<&str>,- parent_session_id: Option<&str>,- ) -> Vec<TargetSessionDetachCleanupPlan> {- self.browser_context- .as_ref()- .map(|bc| {- bc.background_targets()- .filter_map(|target| {- Some(TargetSessionDetachCleanupPlan::new(- target.target_id().to_owned(),- target.session_id()?.to_owned(),- reason,- parent_session_id,- ))- })- .collect()- })- .unwrap_or_default()- }-- pub(crate) async fn clear_active_target_session_binding_for_detach_async(- &mut self,- ) -> Result<(), String> {- let Some(bc) = self.browser_context.as_mut() else {- return Ok(());- };- bc.clear_active_target_session_binding_and_scoped_state_async()- .await- }-- pub(crate) async fn clear_background_target_session_binding_for_detach_async(- &mut self,- session_id: &str,- ) -> Result<Option<String>, String> {- let Some(bc) = self.browser_context.as_mut() else {- return Ok(None);- };- bc.clear_background_target_session_binding_and_scoped_state_async(session_id)- .await- }-- pub(crate) async fn detach_all_shared_worker_target_sessions_event_plan_async(- &mut self,- reason: Option<&str>,- parent_session_id: Option<&str>,- ) -> TargetEventPlan {- let target_ids = self- .browser_context- .as_ref()- .map(|bc| {- bc.shared_worker_targets- .values()- .filter(|target| target.has_session())- .map(|target| target.target_id.clone())- .collect::<Vec<_>>()- })- .unwrap_or_default();- let mut plan = TargetEventPlan::default();- for target_id in target_ids {- let session_ids = self- .browser_context- .as_ref()- .and_then(|bc| bc.shared_worker_target(&target_id))- .map(|target| target.session_ids())- .unwrap_or_default();- for session_id in session_ids {- if self- .execute_target_binding_cleanup_for_session_without_event_async(&session_id)- .await- {- plan.extend(self.detach_known_session_event_plan(- &target_id,- &session_id,- reason,- parent_session_id,- ));- }- }- }- plan- }-- pub(crate) async fn detach_all_service_worker_target_sessions_event_plan_async(- &mut self,- reason: Option<&str>,- parent_session_id: Option<&str>,- ) -> TargetEventPlan {- let target_ids = self- .browser_context- .as_ref()- .map(|bc| {- bc.service_worker_targets- .values()- .filter(|target| target.has_session())- .map(|target| target.target_id.clone())- .collect::<Vec<_>>()- })- .unwrap_or_default();- let mut plan = TargetEventPlan::default();- for target_id in target_ids {- let session_ids = self- .browser_context- .as_ref()- .and_then(|bc| bc.service_worker_target(&target_id))- .map(|target| target.session_ids())- .unwrap_or_default();- for session_id in session_ids {- if self- .execute_target_binding_cleanup_for_session_without_event_async(&session_id)- .await- {- plan.extend(self.detach_known_session_event_plan(- &target_id,- &session_id,- reason,- parent_session_id,- ));- }- }- }- plan- }-- pub(crate) async fn detach_all_dedicated_worker_target_sessions_event_plan_async(- &mut self,- reason: Option<&str>,- parent_session_id: Option<&str>,- ) -> TargetEventPlan {- let target_ids = self- .browser_context- .as_ref()- .map(|bc| {- bc.dedicated_worker_targets- .values()- .filter(|target| target.has_session())- .map(|target| target.target_id.clone())- .collect::<Vec<_>>()- })- .unwrap_or_default();- let mut plan = TargetEventPlan::default();- for target_id in target_ids {- let session_ids = self- .browser_context- .as_ref()- .and_then(|bc| bc.dedicated_worker_target(&target_id))- .map(|target| target.session_ids())- .unwrap_or_default();- for session_id in session_ids {- if self- .execute_target_binding_cleanup_for_session_without_event_async(&session_id)- .await- {- plan.extend(self.detach_known_session_event_plan(- &target_id,- &session_id,- reason,- parent_session_id,- ));- }- }- }- plan- }-fn clear_detached_target_session_owner_state(&mut self, session_id: &str) {self.download_behavior.set_browser_events_enabled_for_session(Some(session_id), false);diff --git a/moli-protocol/src/conn/target/worker_session.rs b/moli-protocol/src/conn/target/worker_session.rsindex 942710e4d..ccfdb460d 100644--- a/moli-protocol/src/conn/target/worker_session.rs+++ b/moli-protocol/src/conn/target/worker_session.rs@@ -1,11 +1,134 @@use crate::conn::{- CdpConnection, DedicatedWorkerTargetState, ServiceWorkerTargetState, SharedWorkerTargetState,- TargetSharedWorkerProtocolAttachmentIdentity,+ CdpConnection, DedicatedWorkerTargetState, RendererPageResidenceIdentity,+ ServiceWorkerTargetState, SharedWorkerTargetState,+ TargetServiceWorkerProtocolAttachmentIdentity, TargetSharedWorkerProtocolAttachmentIdentity,};+use moli_core::RendererOutputResidenceIdentity;use super::CdpSessionRoute;+#[derive(Clone, Debug, PartialEq, Eq)]+pub(crate) enum TargetWorkerProtocolAttachmentIdentity {+ SharedOrDedicated(TargetSharedWorkerProtocolAttachmentIdentity),+ Service(TargetServiceWorkerProtocolAttachmentIdentity),+}++impl TargetWorkerProtocolAttachmentIdentity {+ pub(crate) fn session_id(&self) -> &str {+ match self {+ Self::SharedOrDedicated(identity) => identity.session_id(),+ Self::Service(identity) => identity.session_id(),+ }+ }++ pub(crate) fn target_id(&self) -> &str {+ match self {+ Self::SharedOrDedicated(identity) => identity.target_id(),+ Self::Service(identity) => identity.target_id(),+ }+ }++ pub(crate) fn is_current(&self) -> bool {+ match self {+ Self::SharedOrDedicated(identity) => identity.is_current(),+ Self::Service(identity) => identity.is_current(),+ }+ }+}+impl CdpConnection {+ /// Captures the exact live Worker attachment addressed by one renderer+ /// output stream and DevTools session.+ ///+ /// A browser-context stream owner is intentionally insufficient here: a+ /// context can contain many workers and Pages. Matching the concrete+ /// residence prevents a late response from following the active Page or a+ /// replacement Worker that happens to reuse connection-local ids.+ pub(crate) fn worker_protocol_attachment_identity_for_renderer_output(+ &self,+ session_id: &str,+ residence: RendererOutputResidenceIdentity,+ ) -> Option<TargetWorkerProtocolAttachmentIdentity> {+ match self.session_route(Some(session_id))? {+ CdpSessionRoute::SharedWorkerTarget {+ browser_context_id,+ target_id,+ } => {+ let RendererOutputResidenceIdentity::SharedWorker {+ browser_context_runtime_id,+ instance_id,+ } = residence+ else {+ return None;+ };+ let browser_context = self.browser_context_by_id(&browser_context_id)?;+ if !browser_context+ .routes_renderer_browser_context_runtime(browser_context_runtime_id)+ {+ return None;+ }+ let target = browser_context.shared_worker_target(&target_id)?;+ if target.renderer_instance_id.as_u64() != instance_id {+ return None;+ }+ target+ .protocol_attachment_identity(&browser_context_id, session_id)+ .map(TargetWorkerProtocolAttachmentIdentity::SharedOrDedicated)+ }+ CdpSessionRoute::DedicatedWorkerTarget {+ browser_context_id,+ target_id,+ } => {+ let renderer_page = RendererPageResidenceIdentity::from_residence(residence)?;+ let browser_context = self.browser_context_by_id(&browser_context_id)?;+ let target = browser_context.dedicated_worker_target(&target_id)?;+ let owner_target_id = target.owner_page.target_id()?;+ let owner_target = browser_context.page_target(owner_target_id)?;+ if !owner_target+ .runtime_slot()+ .routes_current_renderer_page_owner(+ renderer_page,+ target.owner_page.page_attachment_id(),+ )+ {+ return None;+ }+ target+ .protocol_attachment_identity(&browser_context_id, session_id)+ .map(TargetWorkerProtocolAttachmentIdentity::SharedOrDedicated)+ }+ CdpSessionRoute::ServiceWorkerTarget {+ browser_context_id,+ target_id,+ } => {+ let RendererOutputResidenceIdentity::ServiceWorker {+ browser_context_runtime_id,+ version_id,+ } = residence+ else {+ return None;+ };+ let browser_context = self.browser_context_by_id(&browser_context_id)?;+ if !browser_context+ .routes_renderer_browser_context_runtime(browser_context_runtime_id)+ {+ return None;+ }+ let target = browser_context.service_worker_target(&target_id)?;+ if target.renderer_version_id != version_id {+ return None;+ }+ target+ .protocol_attachment_identity(&browser_context_id, session_id)+ .map(TargetWorkerProtocolAttachmentIdentity::Service)+ }+ CdpSessionRoute::Browser+ | CdpSessionRoute::BrowserContext { .. }+ | CdpSessionRoute::TabTarget { .. }+ | CdpSessionRoute::PageTarget { .. } => None,+ }+ }+pub(crate) fn shared_worker_target_for_session(&self,session_id: Option<&str>,diff --git a/moli-protocol/src/conn/tests/resource_runtime.rs b/moli-protocol/src/conn/tests/resource_runtime.rsindex f294d35df..3ec9ef5aa 100644--- a/moli-protocol/src/conn/tests/resource_runtime.rs+++ b/moli-protocol/src/conn/tests/resource_runtime.rs@@ -135,8 +135,7 @@ async fn buffered_navigation_for_inactive_session_carries_its_target_engine() {let loaded =commit_navigation_outcome_for_session_test(&mut conn, outcome, Some("SID-target")).await;let target_engine = loaded- .navigation_engine- .as_ref()+ .navigation_engine_replacement().expect("target-scoped buffered navigation must carry its engine to commit");let target_renderer_owner = target_engine.renderer_owner_id_for_diagnostics();diff --git a/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs b/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rsindex 9241454b8..1897f9e95 100644--- a/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs+++ b/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs@@ -71,6 +71,7 @@ impl PreparedProtocolOutputs {pub(in crate::domains::activity) fn from_renderer_observation(conn: &mut CdpConnection,owner: &CommandOwnerScope,+ source_residence: moli_core::RendererOutputResidenceIdentity,source_renderer_agent: moli_core::page::RendererDevToolsAgentToken,observation: &RendererProtocolObservation,) -> Self {@@ -113,6 +114,30 @@ impl PreparedProtocolOutputs {.append_to_output_sink(&mut prepared);}RendererProtocolObservation::RuntimeInspector(batch) => {+ let worker_output = match source_residence {+ moli_core::RendererOutputResidenceIdentity::SharedWorker { .. }+ | moli_core::RendererOutputResidenceIdentity::ServiceWorker { .. } => true,+ moli_core::RendererOutputResidenceIdentity::Page { .. } => batch+ .session+ .wire_session_id()+ .and_then(|session_id| conn.session_route(Some(session_id)))+ .is_some_and(|route| {+ matches!(+ route,+ crate::conn::CdpSessionRoute::DedicatedWorkerTarget { .. }+ )+ }),+ };+ if worker_output {+ crate::domains::runtime::RuntimePreparedOutputs::+ from_worker_renderer_runtime_inspector_message_batch(+ conn,+ source_residence,+ batch,+ )+ .append_to_output_sink(&mut prepared);+ return prepared;+ }let source_batches = vec![batch.clone()];let batches = conn.route_current_renderer_inspector_output_for_owner(owner,diff --git a/moli-protocol/src/domains/activity/output_ingress/renderer.rs b/moli-protocol/src/domains/activity/output_ingress/renderer.rsindex 3e0d2768c..7949a8e18 100644--- a/moli-protocol/src/domains/activity/output_ingress/renderer.rs+++ b/moli-protocol/src/domains/activity/output_ingress/renderer.rs@@ -232,6 +232,7 @@ async fn project_renderer_output_records_for_route(PreparedProtocolOutputs::from_renderer_observation(conn,owner,+ cursor.stream().residence(),cursor.stream().renderer_agent(),&observation,)diff --git a/moli-protocol/src/domains/activity/publication_route.rs b/moli-protocol/src/domains/activity/publication_route.rsindex d271f5db0..534233e16 100644--- a/moli-protocol/src/domains/activity/publication_route.rs+++ b/moli-protocol/src/domains/activity/publication_route.rs@@ -46,7 +46,7 @@ pub(crate) enum RendererPublicationRoute {/// are retained by the target; every other historical record is stale.#[derive(Clone, Copy, Debug, Eq, PartialEq)]pub(crate) enum RendererPublicationProjection {- CurrentPage,+ CurrentOwner,RetiringNetworkOnly,}@@ -118,18 +118,19 @@ impl RendererPublicationOwner {pub(crate) fn resolve(&self, conn: &CdpConnection) -> Option<RendererPublicationRoute> {match self {Self::BrowserContext { browser_context_id } => {- let browser_context = conn+ if !conn.browser_context.iter().chain(conn.inactive_browser_contexts.iter())- .find(|browser_context| browser_context.id == *browser_context_id)?;+ .any(|browser_context| browser_context.id == *browser_context_id)+ {+ return None;+ }Some(RendererPublicationRoute::UnattachedOwner {- owner_route: CdpSessionRoute::PageTarget {- browser_context_id: browser_context.id.clone(),- target_id: browser_context.active_target_id()?.to_owned(),- session_key: moli_page_types::DevToolsSessionKey::Primary,+ owner_route: CdpSessionRoute::BrowserContext {+ browser_context_id: browser_context_id.clone(),},- projection: RendererPublicationProjection::CurrentPage,+ projection: RendererPublicationProjection::CurrentOwner,})}Self::PageTarget {@@ -149,7 +150,7 @@ impl RendererPublicationOwner {*renderer_page,page_owner.page_attachment_id(),) {- Some(RendererPublicationProjection::CurrentPage)+ Some(RendererPublicationProjection::CurrentOwner)} else if runtime_slot.routes_retiring_renderer_page_owner(*renderer_page,page_owner.page_attachment_id(),diff --git a/moli-protocol/src/domains/activity/runtime_command_barrier.rs b/moli-protocol/src/domains/activity/runtime_command_barrier.rsindex 2e4079f40..921b16c71 100644--- a/moli-protocol/src/domains/activity/runtime_command_barrier.rs+++ b/moli-protocol/src/domains/activity/runtime_command_barrier.rs@@ -480,7 +480,8 @@ impl RuntimeCommandOutputBarriers {#[cfg(test)]mod tests {use moli_core::{- RendererOwnerAction, RendererProtocolObservation, RendererRuntimeCommandCausalIdentity,+ RendererOutputResidenceIdentity, RendererOwnerAction, RendererProtocolObservation,+ RendererRuntimeCommandCausalIdentity,page::{DevToolsSessionKey, RendererDocumentLifecycleIdentity,RendererDocumentSourcedSameDocumentNavigation,@@ -730,12 +731,16 @@ mod tests {let mut barriers = RuntimeCommandOutputBarriers::default();let permit = admit_registered_command(&mut conn, &mut barriers, 2);let cause = renderer_cause_for_permit(&conn, &permit);- let agent_token = conn+ let page = conn.runtime_session_owner_slot(Some(SESSION_ID)).expect("loaded Page should retain its runtime slot").loaded_page()- .expect("runtime slot should retain the loaded Page")- .renderer_devtools_agent_token();+ .expect("runtime slot should retain the loaded Page");+ let agent_token = page.renderer_devtools_agent_token();+ let source_residence = RendererOutputResidenceIdentity::Page {+ owner_local_host_id: page.renderer_owner_local_host_id(),+ page_id: page.renderer_page_id(),+ };let observation = RendererProtocolObservation::RuntimeInspector(RendererRuntimeInspectorMessageBatch::new_after_command_response(agent_token,@@ -756,6 +761,7 @@ mod tests {super::super::output_ingress::PreparedProtocolOutputs::from_renderer_observation(&mut conn,&crate::conn::CommandOwnerScope::for_session(SESSION_ID),+ source_residence,agent_token,&observation,);diff --git a/moli-protocol/src/domains/activity/scheduler_work.rs b/moli-protocol/src/domains/activity/scheduler_work.rsindex f37fb688c..9d2560ac9 100644--- a/moli-protocol/src/domains/activity/scheduler_work.rs+++ b/moli-protocol/src/domains/activity/scheduler_work.rs@@ -125,7 +125,6 @@ impl fmt::Debug for ProtocolSchedulerWork {}ProtocolSchedulerWorkPayload::PageTargetTerminationOwnerAction(action) => {debug- .field("action", &action.kind()).field("session_id", &action.owner_scope().session_id()).field("target_id", &action.target_id());}diff --git a/moli-protocol/src/domains/emulation.rs b/moli-protocol/src/domains/emulation.rsindex 47797d2db..681ed1e4c 100644--- a/moli-protocol/src/domains/emulation.rs+++ b/moli-protocol/src/domains/emulation.rs@@ -2573,7 +2573,7 @@ fn loaded_page_mut_for_target_configuration<'a>(pub(crate) async fn clear_emulated_media_for_detached_session_async(conn: &mut CdpConnection,session_id: &str,-) -> Result<(), String> {+) -> anyhow::Result<()> {// Chromium's InspectorEmulationAgent::disable clears media overrides even// though the resulting settings are observable by every session on the// target. Match that contract when detach preserves the loaded page.@@ -2597,7 +2597,9 @@ pub(crate) async fn clear_emulated_media_for_detached_session_async(};page.set_emulated_media_async(&page_overrides).await- .map_err(|error| format!("failed to clear detached session emulated media: {error}"))+ .map_err(|error| {+ anyhow::anyhow!("failed to clear detached session emulated media: {error}")+ })}fn single_pending_emulation_dispatch(diff --git a/moli-protocol/src/domains/network/agent.rs b/moli-protocol/src/domains/network/agent.rsindex 5ad463284..b45769fa0 100644--- a/moli-protocol/src/domains/network/agent.rs+++ b/moli-protocol/src/domains/network/agent.rs@@ -860,10 +860,6 @@ impl TargetNetworkAgentState {.request_id_for_websocket_socket(socket_id, request_id_allocator)}- pub(crate) fn clear_session_scoped_observation_artifacts(&mut self) {- self.artifacts.clear_session_scoped_observation_artifacts();- }-pub(crate) fn reset_all_target_scoped_artifacts(&mut self) {self.artifacts.reset_all_target_scoped_artifacts();}@@ -1549,12 +1545,6 @@ impl TargetNetworkArtifacts {.set_request_id_for_socket_if_absent(socket_id, request_id);}- pub(crate) fn clear_session_scoped_observation_artifacts(&mut self) {- self.body_artifacts.clear_session_scoped();- self.subresource_network_artifacts.clear_request_ids();- self.websocket_network_artifacts.clear_all();- }-pub(crate) fn reset_all_target_scoped_artifacts(&mut self) {self.request_id_allocator.reset();self.body_artifacts.reset_all();@@ -2282,7 +2272,7 @@ mod tests {}#[test]- fn body_artifacts_clear_response_bodies_and_io_streams_together() {+ fn target_artifact_reset_clears_response_bodies_and_io_streams_together() {let mut agent = TargetNetworkAgentState::default();agent.record_captured_response_body("REQ-1".to_owned(), "response body".to_owned(), [None]);@@ -2290,17 +2280,8 @@ mod tests {assert!(agent.has_captured_response_body("REQ-1"));assert!(!agent.io_streams_empty());- agent.clear_session_scoped_observation_artifacts();- assert!(!agent.has_captured_response_body("REQ-1"));- assert!(agent.io_streams_empty());-- agent.record_captured_response_body("REQ-2".to_owned(), "response body".to_owned(), [None]);- agent.insert_io_stream("STREAM-2".to_owned(), b"stream body".to_vec(), 0);- assert!(agent.has_captured_response_body("REQ-2"));- assert!(!agent.io_streams_empty());-agent.reset_all_target_scoped_artifacts();- assert!(!agent.has_captured_response_body("REQ-2"));+ assert!(!agent.has_captured_response_body("REQ-1"));assert!(agent.io_streams_empty());}diff --git a/moli-protocol/src/domains/network/main_document_progress/mod.rs b/moli-protocol/src/domains/network/main_document_progress/mod.rsindex 8f1b15640..bbfb41049 100644--- a/moli-protocol/src/domains/network/main_document_progress/mod.rs+++ b/moli-protocol/src/domains/network/main_document_progress/mod.rs@@ -4,11 +4,11 @@ mod gate;mod tests;use moli_cookie_jar::{StoredCookieQueryReport, StoredCookieSetReport};+use moli_core::RendererOutputFence;use moli_core::page::{NavigationRedirect, Page, RendererMainDocumentCommit, RendererPageCreationArtifacts,RendererPendingDownloadActivation, RendererRuntimeRealmInfo, SubresourceRequestInitiatorType,};-use moli_core::{RendererOutputFence, runtime::NavigationEngine};use moli_fetch::{NegotiatedHttpVersion, NetworkExchangeObservation, NetworkObservationJournal, RedirectInfo,StreamingRawResponse,@@ -19,7 +19,7 @@ use url::Url;use crate::conn::{BackgroundEventSender, BackgroundProtocolEvent, CapturedBody, CdpConnection,CompletedDownloadBodyArtifact, DownloadNavigation, LoadedNavigation, NavigationDispatchState,- NavigationLoadOutcome, ResponseCommitReady, TargetRuntimeSlot,+ NavigationEngineHandoff, NavigationLoadOutcome, ResponseCommitReady, TargetRuntimeSlot,};#[cfg(test)]@@ -42,7 +42,7 @@ pub(crate) struct MaterializedLoadedDocumentProgress {pub(crate) renderer_output_predecessor: Option<RendererOutputFence>,pub(crate) main_document_commit: Option<Arc<RendererMainDocumentCommit>>,pub(crate) progress_gate: MainDocumentProgressGate,- pub(crate) navigation_engine: Option<NavigationEngine>,+ pub(crate) navigation_engine_handoff: NavigationEngineHandoff,pub(crate) network_error_page: Option<crate::conn::NetworkErrorPageNavigation>,}@@ -309,7 +309,7 @@ pub(crate) fn materialize_loaded_navigation_progress(renderer_output_predecessor,main_document_commit,document_progress_transfer,- navigation_engine,+ navigation_engine_handoff,network_error_page,..} = navigation;@@ -330,7 +330,7 @@ pub(crate) fn materialize_loaded_navigation_progress(renderer_output_predecessor,main_document_commit,progress_gate,- navigation_engine,+ navigation_engine_handoff,network_error_page,}}diff --git a/moli-protocol/src/domains/page.rs b/moli-protocol/src/domains/page.rsindex dadc1082e..161203618 100644--- a/moli-protocol/src/domains/page.rs+++ b/moli-protocol/src/domains/page.rs@@ -121,8 +121,7 @@ use prepared_navigation::{PagePreparedSameDocumentNavigation, PagePreparedTopLevelLocationNavigation,};pub(crate) use termination::{- PageTargetTerminationKind, PageTargetTerminationOwnerAction,- complete_page_target_termination_owner_action_async,+ PageTargetTerminationOwnerAction, complete_page_target_termination_owner_action_async,fail_pending_fetch_state_background_events_async, take_pending_fetch_state,};diff --git a/moli-protocol/src/domains/page/navigation.rs b/moli-protocol/src/domains/page/navigation.rsindex b2af61e1f..fa51b11d7 100644--- a/moli-protocol/src/domains/page/navigation.rs+++ b/moli-protocol/src/domains/page/navigation.rs@@ -23,9 +23,10 @@ use url::Url;use crate::conn::{BackgroundNavigationLoadJob, BackgroundProtocolEvent, CapturedBody, CdpConnection,CdpSessionRoute, Cmd, CommandDispatchContext, CommandOwnerScope, DocumentNavigationToken,- FetchRequestStage, NavigationDispatchState, NavigationLoadOutcome, NavigationRequestLoadPolicy,- NavigationResultProjection, NavigationSourceDocumentSecurityContext, PendingFetchNavigation,- ResponseStageUrlMatchPolicy, monotonic_timestamp_seconds,+ FetchRequestStage, NavigationDispatchState, NavigationEngineHandoff, NavigationLoadOutcome,+ NavigationRequestLoadPolicy, NavigationResultProjection,+ NavigationSourceDocumentSecurityContext, PendingFetchNavigation, ResponseStageUrlMatchPolicy,+ monotonic_timestamp_seconds,};use moli_cookie_jar::{NetworkCookieRequestContext, StoredCookieQueryReport};@@ -398,7 +399,7 @@ pub(crate) struct MaterializedNavigationCompletion {token: DocumentNavigationToken,state: NavigationDispatchState,navigation: network::MaterializedNavigationLoadOutcome,- engine: Option<NavigationEngine>,+ engine_handoff: NavigationEngineHandoff,}impl MaterializedNavigationCompletion {@@ -411,12 +412,12 @@ impl MaterializedNavigationCompletion {token,state,navigation,- engine: None,+ engine_handoff: NavigationEngineHandoff::retained_by_owner(),}}- pub(crate) fn with_navigation_engine(mut self, engine: NavigationEngine) -> Self {- self.engine = Some(engine);+ pub(crate) fn with_navigation_engine_replacement(mut self, engine: NavigationEngine) -> Self {+ self.engine_handoff = NavigationEngineHandoff::replacement(engine);self}@@ -446,9 +447,9 @@ impl MaterializedNavigationCompletion {DocumentNavigationToken,NavigationDispatchState,network::MaterializedNavigationLoadOutcome,- Option<NavigationEngine>,+ NavigationEngineHandoff,) {- (self.token, self.state, self.navigation, self.engine)+ (self.token, self.state, self.navigation, self.engine_handoff)}}@@ -597,15 +598,16 @@ impl BackgroundNavigationLifecycleCompletion {}/// Materialize the background navigation outcome into a queued- /// `MaterializedNavigationCompletion`. `retain_engine` should be `false`+ /// `MaterializedNavigationCompletion`. `replace_owner_engine` should be+ /// `false`/// when the completion's token is no longer current — stale completions/// still flow into the materialized queue so the drain can emit a/// terminal abort response for any outstanding `navigate_id`, but the/// stale background engine must not keep a renderer owner alive.- pub(crate) fn materialize_with_engine_retention(+ pub(crate) fn materialize_with_engine_replacement(self,conn: &mut CdpConnection,- retain_engine: bool,+ replace_owner_engine: bool,) -> MaterializedNavigationCompletion {let Self {token,@@ -614,7 +616,7 @@ impl BackgroundNavigationLifecycleCompletion {navigation,ready_at: _,} = self;- let should_retain_engine = retain_engine+ let should_replace_owner_engine = replace_owner_engine&& matches!(navigation,Ok(NavigationLoadOutcome::ResponseCommitReady(_)@@ -622,8 +624,8 @@ impl BackgroundNavigationLifecycleCompletion {);let navigation = network::materialize_navigation_load_result(conn, &state, navigation);let completion = MaterializedNavigationCompletion::new(token, state, navigation);- if should_retain_engine {- completion.with_navigation_engine(engine)+ if should_replace_owner_engine {+ completion.with_navigation_engine_replacement(engine)} else {completion}@@ -3172,15 +3174,15 @@ pub(super) async fn complete_pending_navigate_load_command(state.owner.session_owner_route(),&token,);- let should_retain_engine = is_current+ let should_replace_owner_engine = is_current&& matches!(navigation,Ok(NavigationLoadOutcome::ResponseCommitReady(_) | NavigationLoadOutcome::Loaded(_)));let navigation = network::materialize_navigation_load_result(conn, &state, navigation);let completion = MaterializedNavigationCompletion::new(token, state, navigation);- let completion = if should_retain_engine {- completion.with_navigation_engine(engine)+ let completion = if should_replace_owner_engine {+ completion.with_navigation_engine_replacement(engine)} else {completion};diff --git a/moli-protocol/src/domains/page/navigation_commit.rs b/moli-protocol/src/domains/page/navigation_commit.rsindex d9d605769..51eb78b6b 100644--- a/moli-protocol/src/domains/page/navigation_commit.rs+++ b/moli-protocol/src/domains/page/navigation_commit.rs@@ -42,7 +42,7 @@ pub(super) async fn commit_loaded_navigation_async(renderer_output_predecessor,main_document_commit,progress_gate,- navigation_engine,+ navigation_engine_handoff,network_error_page,} = navigation;let target_url = network_error_page@@ -135,7 +135,7 @@ pub(super) async fn commit_loaded_navigation_async(navigation_activity.defer_initial_renderer_document_lifecycle_events_until_load_boundary(deferred_initial_renderer_document_lifecycle_events,);- if let Some(engine) = navigation_engine {+ if let Some(engine) = navigation_engine_handoff.into_replacement() {conn.adopt_loaded_navigation_engine_for_owner(&navigation_activity.state().owner, engine);}diff --git a/moli-protocol/src/domains/page/termination.rs b/moli-protocol/src/domains/page/termination.rsindex 684a35789..03a5303c2 100644--- a/moli-protocol/src/domains/page/termination.rs+++ b/moli-protocol/src/domains/page/termination.rs@@ -10,29 +10,17 @@ use moli_core::RendererOutputFence;use super::{PageCommandTaskStep, complete_materialized_navigation_into_buffer_async};use crate::domains::command_output::{CommandOutputBuffer, CommandOutputPlan};-#[derive(Clone, Copy, Debug, Eq, PartialEq)]-pub(crate) enum PageTargetTerminationKind {- PageClose,- TargetClose,-}-#[derive(Debug)]pub(crate) struct PageTargetTerminationOwnerAction {owner_scope: CommandOwnerScope,target_id: String,- kind: PageTargetTerminationKind,}impl PageTargetTerminationOwnerAction {- pub(crate) fn new(- owner_scope: CommandOwnerScope,- target_id: String,- kind: PageTargetTerminationKind,- ) -> Self {+ pub(crate) fn new(owner_scope: CommandOwnerScope, target_id: String) -> Self {Self {owner_scope,target_id,- kind,}}@@ -44,12 +32,8 @@ impl PageTargetTerminationOwnerAction {&self.target_id}- pub(crate) fn kind(&self) -> PageTargetTerminationKind {- self.kind- }-- fn into_parts(self) -> (CommandOwnerScope, String, PageTargetTerminationKind) {- (self.owner_scope, self.target_id, self.kind)+ fn into_parts(self) -> (CommandOwnerScope, String) {+ (self.owner_scope, self.target_id)}}@@ -691,7 +675,6 @@ pub(super) async fn complete_close_command_dispatch(conn.publish_page_target_termination_owner_action(PageTargetTerminationOwnerAction::new(owner.clone(),target_id,- PageTargetTerminationKind::PageClose,));complete_success_with_background_events(out)}@@ -700,7 +683,7 @@ pub(crate) async fn complete_page_target_termination_owner_action_async(conn: &mut CdpConnection,action: PageTargetTerminationOwnerAction,) -> crate::conn::CdpTurnOutcome {- let (owner_scope, expected_target_id, kind) = action.into_parts();+ let (owner_scope, expected_target_id) = action.into_parts();let mut out = Vec::new();let current_target_id = conn.target_owner_identity_for_route(@@ -715,33 +698,20 @@ pub(crate) async fn complete_page_target_termination_owner_action_async();}let target_host_closure = conn.prepare_target_host_closure(&expected_target_id);- let closed = match kind {- PageTargetTerminationKind::PageClose => {- conn.close_page_target_for_route_async(- owner_scope.session_id(),- owner_scope.session_owner_route(),- )+ let is_active_target = conn+ .browser_context+ .as_ref()+ .is_some_and(|browser_context| browser_context.is_active_target(&expected_target_id));+ let closed = if is_active_target {+ conn.close_active_page_target_for_target_close_async(&mut out, "Target closed").await- }- PageTargetTerminationKind::TargetClose => {- let is_active_target = conn- .browser_context- .as_ref()- .is_some_and(|browser_context| {- browser_context.is_active_target(&expected_target_id)- });- if is_active_target {- conn.close_active_page_target_for_target_close_async(&mut out)- .await- } else {- conn.close_background_page_target_for_target_close_async(- &expected_target_id,- &mut out,- "Target closed",- )- .await- }- }+ } else {+ conn.close_background_page_target_for_target_close_async(+ &expected_target_id,+ &mut out,+ "Target closed",+ )+ .await};let Some(closed) = closed else {return crate::conn::CdpTurnOutcome::new_with_protocol_events(diff --git a/moli-protocol/src/domains/page/tests/document_content.rs b/moli-protocol/src/domains/page/tests/document_content.rsindex 336e24906..731014973 100644--- a/moli-protocol/src/domains/page/tests/document_content.rs+++ b/moli-protocol/src/domains/page/tests/document_content.rs@@ -14,7 +14,7 @@ async fn install_document_content_test_page(ctx: &mut TestContext, url: &str) {.load_navigation_via_runtime_for_session_owner_async(Some("SID-1"), url).await.expect("document-content test page should load");- let navigation_engine = navigation.navigation_engine.take();+ let navigation_engine = navigation.take_navigation_engine_replacement();let artifacts = navigation.page_creation_artifacts;{let browser_context = ctx.conn.browser_context.as_mut().expect("browser context");diff --git a/moli-protocol/src/domains/page/tests/lifecycle.rs b/moli-protocol/src/domains/page/tests/lifecycle.rsindex 283316ab3..068ad3c27 100644--- a/moli-protocol/src/domains/page/tests/lifecycle.rs+++ b/moli-protocol/src/domains/page/tests/lifecycle.rs@@ -276,7 +276,7 @@ async fn install_runtime_document_replacement_test_page(ctx: &mut TestContext) -.load_navigation_via_runtime_async("data:text/html,<body>initial</body>").await.expect("runtime replacement fixture page should load");- let navigation_engine = navigation.navigation_engine.take();+ let navigation_engine = navigation.take_navigation_engine_replacement();let artifacts = navigation.page_creation_artifacts;ctx.conn.browser_context@@ -829,7 +829,7 @@ async fn set_lifecycle_events_enabled_replays_loaded_page_events() {.load_navigation_via_runtime_async("data:text/html,<body>hello</body>").await.expect("page should load");- let navigation_engine = navigation.navigation_engine.take();+ let navigation_engine = navigation.take_navigation_engine_replacement();let dom_timestamp = navigation.page_creation_artifacts.lifecycle_snapshot@@ -911,7 +911,7 @@ async fn set_lifecycle_events_enabled_replays_only_protocol_visible_load_state().load_navigation_via_runtime_async("data:text/html,<body>visible lifecycle</body>").await.expect("page should load");- let navigation_engine = navigation.navigation_engine.take();+ let navigation_engine = navigation.take_navigation_engine_replacement();let artifacts = navigation.page_creation_artifacts;ctx.conn.browser_context@@ -1014,7 +1014,7 @@ async fn set_lifecycle_events_enabled_is_session_local_for_active_auxiliary_sess.load_navigation_via_runtime_async("data:text/html,<body>active auxiliary lifecycle</body>").await.expect("page should load");- let navigation_engine = navigation.navigation_engine.take();+ let navigation_engine = navigation.take_navigation_engine_replacement();let artifacts = navigation.page_creation_artifacts;let browser_context = ctx.conn.browser_context.as_mut().unwrap();browser_contextdiff --git a/moli-protocol/src/domains/profiler.rs b/moli-protocol/src/domains/profiler.rsindex abb66d2fb..8974807db 100644--- a/moli-protocol/src/domains/profiler.rs+++ b/moli-protocol/src/domains/profiler.rs@@ -857,13 +857,20 @@ mod tests {.await;assert_eq!(aux_enable["result"], json!({}));- ctx.conn- .browser_context- .as_mut()- .expect("browser context")- .clear_active_target_session_binding_and_scoped_state_async()- .await- .expect("target session detach should clear scoped state");+ let detach = process_and_take_response(+ &mut ctx,+ json!({+ "id": 53,+ "method": "Target.detachFromTarget",+ "params": {+ "targetId": "TID-profiler",+ "sessionId": "SID-profiler-old"+ }+ }),+ 53,+ )+ .await;+ assert_eq!(detach["result"], json!({}));{let browser_context = ctx.conn.browser_context.as_ref().expect("browser context");@@ -872,8 +879,9 @@ mod tests {browser_context.active_page_target().devtools_sessions- .attached_is_empty(),- "detaching the primary target session must drop active auxiliary inspector session state"+ .attached("SID-profiler-aux-old")+ .is_some(),+ "detaching the primary target session must preserve independent auxiliary sessions");}@@ -885,11 +893,11 @@ mod tests {let start_without_enable = process_and_take_response(&mut ctx,json!({- "id": 53,+ "id": 54,"sessionId": "SID-profiler-new","method": "Profiler.start"}),- 53,+ 54,).await;assert_eq!(start_without_enable["error"]["code"], json!(-32000));diff --git a/moli-protocol/src/domains/runtime/activity.rs b/moli-protocol/src/domains/runtime/activity.rsindex 0cafdb91d..e7101725d 100644--- a/moli-protocol/src/domains/runtime/activity.rs+++ b/moli-protocol/src/domains/runtime/activity.rs@@ -64,6 +64,7 @@ struct RuntimeInspectorMessageBatch {#[derive(Clone, Debug, PartialEq)]enum RuntimeInspectorMessageAuthority {CurrentPage(crate::conn::TargetPageProtocolAttachmentIdentity),+ CurrentWorker(crate::conn::TargetWorkerProtocolAttachmentIdentity),AuthorizedRetiredTerminal {browser_context_id: String,target_id: Option<String>,@@ -75,6 +76,7 @@ impl RuntimeInspectorMessageAuthority {fn session_id(&self) -> Option<&str> {match self {Self::CurrentPage(attachment) => attachment.session_id(),+ Self::CurrentWorker(attachment) => Some(attachment.session_id()),Self::AuthorizedRetiredTerminal { session_id, .. } => session_id.as_deref(),}}@@ -84,6 +86,7 @@ impl RuntimeInspectorMessageAuthority {Self::CurrentPage(attachment) => {conn.target_page_protocol_attachment_identity_is_current(attachment)}+ Self::CurrentWorker(attachment) => attachment.is_current(),Self::AuthorizedRetiredTerminal {browser_context_id,target_id,@@ -108,6 +111,9 @@ impl RuntimeInspectorMessageAuthority {Self::CurrentPage(attachment) => Some(crate::conn::CommandOwnerScope::for_page_attachment(attachment),),+ Self::CurrentWorker(attachment) => {+ Some(CommandOwnerScope::for_session(attachment.session_id()))+ }Self::AuthorizedRetiredTerminal { .. } => None,}}@@ -347,6 +353,53 @@ impl RuntimePreparedOutputs {outputs}+ pub(crate) fn from_worker_renderer_runtime_inspector_message_batch(+ conn: &mut CdpConnection,+ residence: moli_core::RendererOutputResidenceIdentity,+ batch: &RendererRuntimeInspectorMessageBatch,+ ) -> Self {+ let Some(session_id) = batch.session.wire_session_id() else {+ return Self::default();+ };+ let Some(attachment) =+ conn.worker_protocol_attachment_identity_for_renderer_output(session_id, residence)+ else {+ return Self::default();+ };+ let mut renderer_messages = batch.messages.clone();+ conn.restore_frontend_command_ids_in_worker_devtools_session_output(+ session_id,+ &mut renderer_messages,+ );+ if renderer_messages.is_empty() {+ return Self::default();+ }+ let target_id = attachment.target_id().to_owned();+ let prepared = RuntimeInspectorMessageBatch {+ authority: RuntimeInspectorMessageAuthority::CurrentWorker(attachment),+ messages: renderer_messages+ .into_iter()+ .map(|message| {+ RuntimeInspectorMessage::from_renderer_message(message, Some(&target_id))+ })+ .collect(),+ // Worker contexts never own Page/BiDi preload-channel listeners.+ created_execution_context_ids: Vec::new(),+ };+ let mut outputs = Self::default();+ match batch.command_response_order() {+ RendererRuntimeInspectorMessageResponseOrder::BeforeCommandResponse => {+ outputs.inspector_message_batches.push(prepared);+ }+ RendererRuntimeInspectorMessageResponseOrder::AfterCommandResponse => {+ outputs+ .post_response_inspector_message_batches+ .push(prepared);+ }+ }+ outputs+ }+/// Preserves only terminal session responses from an attachment that was/// current when the response lease was claimed but retired before its Page/// journal crossed protocol ingress.diff --git a/moli-protocol/src/domains/runtime/dispatcher.rs b/moli-protocol/src/domains/runtime/dispatcher.rsindex 52b89ab99..e4278a68c 100644--- a/moli-protocol/src/domains/runtime/dispatcher.rs+++ b/moli-protocol/src/domains/runtime/dispatcher.rs@@ -424,6 +424,9 @@ impl RuntimeInspectorRoutedOutput {push_runtime_protocol_event_or_background_event(plan, command_id, event);}plan.extend_post_response_events(self.post_response_events);+ if let Some(predecessor) = self.renderer_output_predecessor {+ plan.set_renderer_output_predecessor(predecessor);+ }}}@@ -1292,22 +1295,25 @@ fn start_heap_profiler_inspector_shared_worker_command_dispatch());}- let pending =- match start_shared_worker_frontend_inspector_dispatch(conn, cmd, cmd.json.to_owned()) {- Ok(pending) => pending,- Err(message)- if matches!(- action,- HeapProfilerAction::Enable | HeapProfilerAction::Disable- ) && (message == "NoDocumentLoaded"- || worker_runtime_is_unavailable(&message)) =>- {- return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());- }- Err(message) => {- return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(message));- }- };+ let pending = match start_shared_worker_frontend_inspector_dispatch(+ conn,+ cmd,+ cmd.json.to_owned(),+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),+ ) {+ Ok(pending) => pending,+ Err(message)+ if matches!(+ action,+ HeapProfilerAction::Enable | HeapProfilerAction::Disable+ ) && (message == "NoDocumentLoaded" || worker_runtime_is_unavailable(&message)) =>+ {+ return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());+ }+ Err(message) => {+ return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(message));+ }+ };let object_group = heap_profiler_object_group_for_command_result(cmd, action);RuntimeCommandTaskStep::Pending(Box::new(PendingRuntimeCommandDispatch {@@ -1391,6 +1397,7 @@ fn start_profiler_inspector_shared_worker_command_dispatch(conn,cmd,dispatch.into_inspector_json(),+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),) {Ok(pending) => pending,Err(message) => {@@ -1513,21 +1520,25 @@ fn start_console_inspector_shared_worker_command_dispatch());}- let pending =- match start_shared_worker_frontend_inspector_dispatch(conn, cmd, cmd.json.to_owned()) {- Ok(pending) => pending,- Err(message) if worker_runtime_is_unavailable(&message) => {- if !apply_console_output_state_for_session(conn, cmd.session_id, action) {- return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(- "UnknownSession".to_owned(),- ));- }- return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());- }- Err(message) => {- return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(message));+ let pending = match start_shared_worker_frontend_inspector_dispatch(+ conn,+ cmd,+ cmd.json.to_owned(),+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),+ ) {+ Ok(pending) => pending,+ Err(message) if worker_runtime_is_unavailable(&message) => {+ if !apply_console_output_state_for_session(conn, cmd.session_id, action) {+ return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(+ "UnknownSession".to_owned(),+ ));}- };+ return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());+ }+ Err(message) => {+ return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(message));+ }+ };RuntimeCommandTaskStep::Pending(Box::new(PendingRuntimeCommandDispatch {command_id: cmd.id,@@ -1572,23 +1583,25 @@ fn start_console_inspector_service_worker_command_dispatch());}- let pending =- match start_service_worker_frontend_inspector_dispatch(conn, cmd, cmd.json.to_owned()) {- Ok(pending) => pending,- Err(message) if message == "ServiceWorkerRuntimeUnavailable" => {- if !apply_console_output_state_for_session(conn, cmd.session_id, action) {- return RuntimeCommandTaskStep::Complete(service_worker_runtime_error_plan(- "UnknownSession".to_owned(),- ));- }- return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());- }- Err(message) => {+ let pending = match start_service_worker_frontend_inspector_dispatch(+ conn,+ cmd,+ cmd.json.to_owned(),+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),+ ) {+ Ok(pending) => pending,+ Err(message) if message == "ServiceWorkerRuntimeUnavailable" => {+ if !apply_console_output_state_for_session(conn, cmd.session_id, action) {return RuntimeCommandTaskStep::Complete(service_worker_runtime_error_plan(- message,+ "UnknownSession".to_owned(),));}- };+ return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());+ }+ Err(message) => {+ return RuntimeCommandTaskStep::Complete(service_worker_runtime_error_plan(message));+ }+ };RuntimeCommandTaskStep::Pending(Box::new(PendingRuntimeCommandDispatch {command_id: cmd.id,@@ -1991,12 +2004,13 @@ fn start_shared_worker_frontend_inspector_dispatch(conn: &mut CdpConnection,cmd: &Cmd<'_>,inspector_json: String,+ response_delivery: RendererInspectorResponseDelivery,) -> Result<PendingSharedWorkerRuntimeProtocolMessageDispatch, String> {if let Some(command_id) = cmd.id {let descriptor = RendererCommandDescriptor::from_frontend_policy(inspector_json,cmd.renderer_policy(),- RendererInspectorResponseDelivery::CommandReply,+ response_delivery,);conn.start_shared_worker_runtime_protocol_message_for_session_with_deferred_response(cmd.session_id,@@ -2015,12 +2029,13 @@ fn start_service_worker_frontend_inspector_dispatch(conn: &mut CdpConnection,cmd: &Cmd<'_>,inspector_json: String,+ response_delivery: RendererInspectorResponseDelivery,) -> Result<PendingServiceWorkerRuntimeProtocolMessageDispatch, String> {if let Some(command_id) = cmd.id {let descriptor = RendererCommandDescriptor::from_frontend_policy(inspector_json,cmd.renderer_policy(),- RendererInspectorResponseDelivery::CommandReply,+ response_delivery,);conn.start_service_worker_runtime_protocol_message_for_session_with_deferred_response(cmd.session_id,@@ -9206,7 +9221,17 @@ fn start_pending_shared_worker_runtime_inspector_command(action.label(),).map_err(|error| error.to_string())?;- let pending = match start_shared_worker_frontend_inspector_dispatch(conn, cmd, inspector_json) {+ let response_delivery = if await_promise {+ RendererInspectorResponseDelivery::CommandReply+ } else {+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession)+ };+ let pending = match start_shared_worker_frontend_inspector_dispatch(+ conn,+ cmd,+ inspector_json,+ response_delivery,+ ) {Ok(pending) => pending,Err(message) => {forget_pre_registered_runtime_await(conn, pre_registered_await, &owner_scope);@@ -9268,8 +9293,17 @@ fn start_pending_service_worker_runtime_inspector_command(action.label(),).map_err(|error| error.to_string())?;- let pending = match start_service_worker_frontend_inspector_dispatch(conn, cmd, inspector_json)- {+ let response_delivery = if await_promise {+ RendererInspectorResponseDelivery::CommandReply+ } else {+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession)+ };+ let pending = match start_service_worker_frontend_inspector_dispatch(+ conn,+ cmd,+ inspector_json,+ response_delivery,+ ) {Ok(pending) => pending,Err(message) => {forget_pre_registered_runtime_await(conn, pre_registered_await, &owner_scope);@@ -9422,13 +9456,28 @@ async fn complete_pending_shared_worker_runtime_inspector_command(binding_effect: Option<SharedWorkerRuntimeBindingEffect>,timing_started: Option<std::time::Instant>,) -> RuntimeCommandTaskStep {- let (messages, mut renderer_response_rx) = match completed_inspector {+ let (+ messages,+ mut renderer_response_rx,+ response_delivery,+ session_response_predecessor,+ session_response_succeeded,+ ) = match completed_inspector {Ok(mut completed_protocol) => {+ let response_delivery = completed_protocol.response_delivery();+ let session_response_predecessor = completed_protocol.session_response_predecessor();+ let session_response_succeeded = completed_protocol.session_response_succeeded();let renderer_response_rx = completed_protocol.take_deferred_response_receiver();match conn.complete_shared_worker_runtime_protocol_message_for_session(completed_protocol){- Ok(messages) => (messages, renderer_response_rx),+ Ok(messages) => (+ messages,+ renderer_response_rx,+ response_delivery,+ session_response_predecessor,+ session_response_succeeded,+ ),Err(message) => {return complete_shared_worker_runtime_inspector_error(conn, completed, message,@@ -9453,6 +9502,9 @@ async fn complete_pending_shared_worker_runtime_inspector_command(let mut plan = CommandOutputPlan::default();let mut routed_output = RuntimeInspectorRoutedOutput::default();+ if let Some(predecessor) = session_response_predecessor {+ routed_output.set_renderer_output_predecessor(predecessor);+ }let mut saw_current_response = route_inspector_messages_into_routed_output(conn,messages,@@ -9460,7 +9512,14 @@ async fn complete_pending_shared_worker_runtime_inspector_command(&completed.owner_scope,&mut routed_output,);- if !completed.wait_for_deferred_reply+ if saw_current_response {+ renderer_response_rx.take();+ }+ if response_delivery == RendererInspectorResponseDelivery::DevToolsSession {+ renderer_response_rx.take();+ }+ if response_delivery == RendererInspectorResponseDelivery::CommandReply+ && !completed.wait_for_deferred_reply&& let Some(renderer_response_rx) = renderer_response_rx.take(){saw_current_response |= route_registered_runtime_response_receiver_into(@@ -9472,7 +9531,8 @@ async fn complete_pending_shared_worker_runtime_inspector_command().await;}- if completed.wait_for_deferred_reply+ if response_delivery == RendererInspectorResponseDelivery::CommandReply+ && completed.wait_for_deferred_reply&& (renderer_response_rx.is_some() || !saw_current_response)&& completed.command_id.is_some(){@@ -9483,7 +9543,8 @@ async fn complete_pending_shared_worker_runtime_inspector_command(renderer_response_rx,);}- let succeeded = routed_output.command_response_succeeded(completed.command_id);+ let succeeded = session_response_succeeded+ .unwrap_or_else(|| routed_output.command_response_succeeded(completed.command_id));apply_shared_worker_runtime_completion_projection(conn,completed.session_id(),@@ -9494,10 +9555,17 @@ async fn complete_pending_shared_worker_runtime_inspector_command(if let Some(console_action) = console_action_from_protocol_method(completed.action)&& !apply_console_output_state_for_session(conn, completed.session_id(), console_action){- return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(format!(- "ConsoleCommandCompletionFailed: {}",- completed.action- )));+ let message = format!("ConsoleCommandCompletionFailed: {}", completed.action);+ if session_response_succeeded.is_some() {+ tracing::warn!(+ command_id = completed.command_id,+ session_id = completed.session_id(),+ error = %message,+ "could not apply shared-worker projection after the terminal response was published"+ );+ } else {+ return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(message));+ }}if let Some(effect) = binding_effect {match apply_shared_worker_runtime_binding_effect_after_success(@@ -9559,13 +9627,28 @@ async fn complete_pending_service_worker_runtime_inspector_command(completed_inspector: Result<CompletedServiceWorkerRuntimeProtocolMessageDispatch, String>,timing_started: Option<std::time::Instant>,) -> RuntimeCommandTaskStep {- let (messages, mut renderer_response_rx) = match completed_inspector {+ let (+ messages,+ mut renderer_response_rx,+ response_delivery,+ session_response_predecessor,+ session_response_succeeded,+ ) = match completed_inspector {Ok(mut completed_protocol) => {+ let response_delivery = completed_protocol.response_delivery();+ let session_response_predecessor = completed_protocol.session_response_predecessor();+ let session_response_succeeded = completed_protocol.session_response_succeeded();let renderer_response_rx = completed_protocol.take_deferred_response_receiver();match conn.complete_service_worker_runtime_protocol_message_for_session(completed_protocol){- Ok(messages) => (messages, renderer_response_rx),+ Ok(messages) => (+ messages,+ renderer_response_rx,+ response_delivery,+ session_response_predecessor,+ session_response_succeeded,+ ),Err(message) => {return complete_service_worker_runtime_inspector_error(conn, completed, message,@@ -9590,6 +9673,9 @@ async fn complete_pending_service_worker_runtime_inspector_command(let mut plan = CommandOutputPlan::default();let mut routed_output = RuntimeInspectorRoutedOutput::default();+ if let Some(predecessor) = session_response_predecessor {+ routed_output.set_renderer_output_predecessor(predecessor);+ }let mut saw_current_response = route_inspector_messages_into_routed_output(conn,messages,@@ -9597,7 +9683,14 @@ async fn complete_pending_service_worker_runtime_inspector_command(&completed.owner_scope,&mut routed_output,);- if !completed.wait_for_deferred_reply+ if saw_current_response {+ renderer_response_rx.take();+ }+ if response_delivery == RendererInspectorResponseDelivery::DevToolsSession {+ renderer_response_rx.take();+ }+ if response_delivery == RendererInspectorResponseDelivery::CommandReply+ && !completed.wait_for_deferred_reply&& let Some(renderer_response_rx) = renderer_response_rx.take(){saw_current_response |= route_registered_runtime_response_receiver_into(@@ -9609,7 +9702,8 @@ async fn complete_pending_service_worker_runtime_inspector_command().await;}- if completed.wait_for_deferred_reply+ if response_delivery == RendererInspectorResponseDelivery::CommandReply+ && completed.wait_for_deferred_reply&& (renderer_response_rx.is_some() || !saw_current_response)&& completed.command_id.is_some(){@@ -9620,7 +9714,8 @@ async fn complete_pending_service_worker_runtime_inspector_command(renderer_response_rx,);}- let succeeded = routed_output.command_response_succeeded(completed.command_id);+ let succeeded = session_response_succeeded+ .unwrap_or_else(|| routed_output.command_response_succeeded(completed.command_id));apply_service_worker_runtime_completion_projection(conn,completed.session_id(),@@ -9631,10 +9726,17 @@ async fn complete_pending_service_worker_runtime_inspector_command(&& let Some(console_action) = console_action_from_protocol_method(completed.action)&& !apply_console_output_state_for_session(conn, completed.session_id(), console_action){- return RuntimeCommandTaskStep::Complete(service_worker_runtime_error_plan(format!(- "ConsoleCommandCompletionFailed: {}",- completed.action- )));+ let message = format!("ConsoleCommandCompletionFailed: {}", completed.action);+ if session_response_succeeded.is_some() {+ tracing::warn!(+ command_id = completed.command_id,+ session_id = completed.session_id(),+ error = %message,+ "could not apply service-worker projection after the terminal response was published"+ );+ } else {+ return RuntimeCommandTaskStep::Complete(service_worker_runtime_error_plan(message));+ }}if succeeded {routed_output.register_object_group_for_success(@@ -9725,7 +9827,18 @@ fn complete_shared_worker_runtime_inspector_error(message: String,) -> RuntimeCommandTaskStep {if let Some(command_id) = completed.command_id {+ let renderer_call = conn+ .take_renderer_call_for_frontend_for_session_owner(completed.session_id(), command_id);conn.forget_pending_inspector_await(command_id, completed.session_id());+ if renderer_call.is_none() {+ tracing::debug!(+ command_id,+ session_id = completed.session_id(),+ error = %message,+ "ignored shared-worker completion after another route settled the frontend call"+ );+ return RuntimeCommandTaskStep::Complete(CommandOutputPlan::default());+ }}match completed.action {"enable" if message == "NoDocumentLoaded" || worker_runtime_is_unavailable(&message) => {@@ -9815,7 +9928,18 @@ fn complete_service_worker_runtime_inspector_error(message: String,) -> RuntimeCommandTaskStep {if let Some(command_id) = completed.command_id {+ let renderer_call = conn+ .take_renderer_call_for_frontend_for_session_owner(completed.session_id(), command_id);conn.forget_pending_inspector_await(command_id, completed.session_id());+ if renderer_call.is_none() {+ tracing::debug!(+ command_id,+ session_id = completed.session_id(),+ error = %message,+ "ignored service-worker completion after another route settled the frontend call"+ );+ return RuntimeCommandTaskStep::Complete(CommandOutputPlan::default());+ }}match completed.action {"enable"diff --git a/moli-protocol/src/domains/target.rs b/moli-protocol/src/domains/target.rsindex 24625b738..f05acf793 100644--- a/moli-protocol/src/domains/target.rs+++ b/moli-protocol/src/domains/target.rs@@ -25,6 +25,7 @@ mod info;mod popup;#[cfg(test)]mod protocol_neutral_tests;+mod session_disposal;#[cfg(test)]mod tests;mod worker_target;@@ -184,17 +185,17 @@ pub(in crate::domains::target) async fn clear_detached_target_fetch_state_backgrconn: &mut CdpConnection,out: &mut Vec<BackgroundProtocolEvent>,session_id: &str,-) {+) -> Option<moli_core::RendererOutputFence> {clear_detached_target_owner_fetch_state_background_events_async(conn, out, Some(session_id))- .await;+ .await}async fn clear_detached_target_owner_fetch_state_background_events_async(conn: &mut CdpConnection,out: &mut Vec<BackgroundProtocolEvent>,session_id: Option<&str>,-) {- let Some((pending_fetch_state, pending_page_command)) =+) -> Option<moli_core::RendererOutputFence> {+ let (pending_fetch_state, pending_page_command) =(match conn.start_disable_fetch_for_session_owner(session_id) {Ok(disable_state) => disable_state,Err(error) => {@@ -203,12 +204,9 @@ async fn clear_detached_target_owner_fetch_state_background_events_async(error,"failed to disable Fetch interception while detaching target owner");- return;+ return None;}- })- else {- return;- };+ })?;if let Some(pending_page_command) = pending_page_command {match pending_page_command.wait().await {@@ -252,7 +250,7 @@ async fn clear_detached_target_owner_fetch_state_background_events_async(// Target-owner teardown has no command response to fence. The concrete// renderer publication remains ordered on its own stream and will reach// protocol ingress independently.- let _ = page::fail_pending_fetch_state_background_events_async(+ page::fail_pending_fetch_state_background_events_async(conn,out,session_id,@@ -265,7 +263,7 @@ async fn clear_detached_target_owner_fetch_state_background_events_async(pending_subresource_auths,pending_subresource_responses,)- .await;+ .await}impl CdpConnection {@@ -282,7 +280,7 @@ impl CdpConnection {None,"Inspector detached",);- clear_detached_target_owner_fetch_state_background_events_async(+ let _ = clear_detached_target_owner_fetch_state_background_events_async(self,side_effects.background_events_mut(),None,@@ -1095,6 +1093,7 @@ fn select_browser_context_for_target(#[cfg(test)]mod devtools_runtime_entry_tests {+ use crate::conn::RendererCommandDescriptor;use crate::devtools_runtime::{AutomationEvent, DevToolsActivateTargetCommand, DevToolsCloseTargetCommand,DevToolsCommand, DevToolsCommandContext, DevToolsCreateTargetCommand,@@ -1256,6 +1255,10 @@ mod devtools_runtime_entry_tests {let mut browser_context = BrowserContext::new("BID-runtime-ready-close".to_owned());browser_context.set_active_target_id("TID-runtime-ready-close");browser_context.attach_active_session("SID-runtime-ready-close");+ assert!(browser_context.assign_auxiliary_session_to_target(+ "TID-runtime-ready-close",+ "SID-runtime-ready-close-aux".to_owned(),+ ));conn.browser_context = Some(browser_context);let page = conn.load_page_via_runtime_async("data:text/html,<p>runtime ready close</p>")@@ -1276,6 +1279,31 @@ mod devtools_runtime_entry_tests {.is_some(),"test must cover scheduler-deferred Runtime await owner cleanup");+ conn.register_pending_inspector_await(7102, Some("SID-runtime-ready-close-aux"));+ let auxiliary_dispatch = conn+ .try_register_renderer_call_for_session_owner(+ Some("SID-runtime-ready-close-aux"),+ 7102,+ None,+ RendererCommandDescriptor::from_synthesized_payload(+ json!({+ "id": 7102,+ "method": "Runtime.evaluate",+ "params": { "expression": "new Promise(() => {})" },+ })+ .to_string(),+ )+ .expect("test Runtime command should parse"),+ )+ .expect("auxiliary renderer command should register");+ assert!(+ conn.claim_pending_inspector_await_for_scheduler_deferred_reply(+ 7102,+ &crate::conn::CommandOwnerScope::for_session("SID-runtime-ready-close-aux",),+ )+ .is_some(),+ "test must cover an auxiliary scheduler-deferred Runtime await"+ );let (result, protocol_events) = execute_devtools_target_command_async_with_protocol_events(&mut conn,@@ -1306,6 +1334,15 @@ mod devtools_runtime_entry_tests {&& response.error() == Some("Target closed"))),"pending Runtime await cancellation must remain a typed runtime-ready event");+ assert!(+ protocol_events.iter().any(|event| event+ .as_runtime_inspector_response_ready()+ .is_some_and(|response| response.command_id() == 7102+ && response.error() == Some("Target closed")+ && response.has_bound_renderer_call_id())),+ "an auxiliary claimed await must settle through its correlated typed response before the Page route retires"+ );+ drop(auxiliary_dispatch);assert!(protocol_events.iter().all(|event| {event.protocol_message().is_none_or(|message| {diff --git a/moli-protocol/src/domains/target/attachment.rs b/moli-protocol/src/domains/target/attachment.rsindex 245c96bf1..083230c5a 100644--- a/moli-protocol/src/domains/target/attachment.rs+++ b/moli-protocol/src/domains/target/attachment.rs@@ -601,408 +601,78 @@ async fn detach_from_target_inner_async(out.push_success();return;}- if conn.browser_context.is_none() {- out.push_success();- return;- }- if let Some(session_id) = params.session_id.as_deref()- && let Some(tab_target_id) = conn- .tab_target_id_for_session_id(session_id)- .map(str::to_owned)- {- if let Some(requested_target_id) = params.target_id.as_deref()- && requested_target_id != tab_target_id- {- out.push_error(-31998, "UnknownTargetId");+ if let Some(session_id) = params.session_id.as_deref() {+ let Some(route) = conn.session_route(Some(session_id)) else {+ out.push_error(-31998, "InvalidSessionId");return;- }- out.push_success();- let event_plan = conn- .detach_session_with_binding_cleanup_event_plan_async(- crate::conn::TargetSessionDetachCleanupPlan::new(- tab_target_id,- session_id,- None,- command_session_id,- ),- )- .await;- out.target_events_mut().extend_background_events(event_plan);- return;- }- if let Some(session_id) = params.session_id.as_deref()- && let Some(target_id) = conn- .browser_context- .as_ref()- .and_then(|bc| bc.auxiliary_target_id_for_session(session_id))- .map(str::to_owned)- {- if let Some(requested_target_id) = params.target_id.as_deref()- && requested_target_id != target_id- {- out.push_error(-31998, "UnknownTargetId");+ };+ let Some(target_id) = detach_session_route_target_id(&route).map(str::to_owned) else {+ out.push_error(-31998, "InvalidSessionId");return;- }- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(- out.background_events_mut(),- command_context.protocol_events_mut(),- Some(session_id),- "Target detached",- );- let _ = conn- .detach_runtime_inspector_session_for_session_owner_async(Some(session_id))- .await;- super::auto_attach::clear_detached_session_target_overrides_best_effort(conn, session_id)- .await;- super::clear_detached_target_fetch_state_background_events_async(+ };+ match super::session_disposal::dispose_target_session_async(conn,- out.background_events_mut(),- session_id,- )- .await;- out.push_success();- let event_plan = conn- .detach_session_with_binding_cleanup_event_plan_async(- crate::conn::TargetSessionDetachCleanupPlan::new(- target_id,- session_id,- None,- command_session_id,- ),- )- .await;- out.target_events_mut().extend_background_events(event_plan);- return;- }- if let Some(session_id) = params.session_id.as_deref()- && let Some(target_id) = conn- .browser_context- .as_ref()- .and_then(|bc| bc.dedicated_worker_target_id_for_session(session_id))- .map(str::to_owned)- {- if let Some(requested_target_id) = params.target_id.as_deref()- && requested_target_id != target_id- {- out.push_error(-31998, "UnknownTargetId");- return;- }- let renderer_detach = conn.browser_context.as_ref().and_then(|bc| {- bc.dedicated_worker_target(&target_id)- .map(|target| (bc.renderer_runtime(), target.renderer_instance_id))- });- conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(session_id)- .await;- out.push_success();- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(out.background_events_mut(),command_context.protocol_events_mut(),- Some(session_id),- "Target detached",- );- if let Some((renderer_runtime, instance_id)) = renderer_detach {- renderer_runtime.detach_dedicated_worker_runtime_inspector_session(- instance_id,- Some(session_id.to_owned()),- );- }- let event_plan = conn- .detach_session_with_binding_cleanup_event_plan_async(- crate::conn::TargetSessionDetachCleanupPlan::new(target_id, session_id, None, None),- )- .await;- out.target_events_mut().extend_background_events(event_plan);- return;- }- if let Some(session_id) = params.session_id.as_deref()- && let Some(target_id) = conn- .browser_context- .as_ref()- .and_then(|bc| bc.shared_worker_target_id_for_session(session_id))- .map(str::to_owned)- {- if let Some(requested_target_id) = params.target_id.as_deref()- && requested_target_id != target_id+ crate::conn::TargetSessionDetachCleanupPlan::new(+ target_id,+ session_id,+ None,+ command_session_id,+ ),+ )+ .await{- out.push_error(-31998, "UnknownTargetId");- return;- }- let renderer_detach = conn.browser_context.as_ref().and_then(|bc| {- bc.shared_worker_target(&target_id)- .map(|target| (bc.renderer_runtime(), target.renderer_instance_id))- });- conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(session_id)- .await;- out.push_success();- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(- out.background_events_mut(),- command_context.protocol_events_mut(),- Some(session_id),- "Target detached",- );- if let Some((renderer_runtime, instance_id)) = renderer_detach {- renderer_runtime.detach_shared_worker_runtime_inspector_session(- instance_id,- Some(session_id.to_owned()),- );+ Ok(outcome) => {+ let (event_plan, predecessor) = outcome.into_parts();+ if let Some(predecessor) = predecessor {+ command_context.set_renderer_output_predecessor(predecessor);+ }+ out.push_success();+ out.target_events_mut().extend_background_events(event_plan);+ }+ Err(error) => out.push_error(-32000, error.to_string()),}- let event_plan = conn- .detach_session_with_binding_cleanup_event_plan_async(- crate::conn::TargetSessionDetachCleanupPlan::new(target_id, session_id, None, None),- )- .await;- out.target_events_mut().extend_background_events(event_plan);return;}- if let Some(session_id) = params.session_id.as_deref()- && let Some(target_id) = conn- .browser_context- .as_ref()- .and_then(|bc| bc.service_worker_target_id_for_session(session_id))- .map(str::to_owned)- {- if let Some(requested_target_id) = params.target_id.as_deref()- && requested_target_id != target_id- {- out.push_error(-31998, "UnknownTargetId");- return;- }+ if conn.browser_context.is_none() {out.push_success();- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(- out.background_events_mut(),- command_context.protocol_events_mut(),- Some(session_id),- "Target detached",- );- super::set_service_worker_pause_on_start_owner(conn, Some(session_id), false);- let event_plan = conn- .detach_session_with_binding_cleanup_event_plan_async(- crate::conn::TargetSessionDetachCleanupPlan::new(target_id, session_id, None, None),- )- .await;- out.target_events_mut().extend_background_events(event_plan);return;}- if let Some(session_id) = params.session_id.as_deref() {- let background_target_id = conn.browser_context.as_ref().and_then(|bc| {- bc.background_targets()- .find(|target| target.is_session(session_id))- .map(|target| target.target_id().to_owned())- });- if let Some(target_id) = background_target_id.as_deref() {- if let Some(requested_target_id) = params.target_id.as_deref()- && requested_target_id != target_id- {- out.push_error(-31998, "UnknownTargetId");- return;- }- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(- out.background_events_mut(),- command_context.protocol_events_mut(),- Some(session_id),- "Target detached",- );- let _ = conn- .detach_runtime_inspector_session_for_session_owner_async(Some(session_id))- .await;- match conn- .detach_background_target_session_binding_event_plan_async(- crate::conn::TargetSessionDetachCleanupPlan::new(- target_id,- session_id,- None,- command_session_id,- ),- )- .await- {- Ok(Some(event_plan)) => {- out.push_success();- out.target_events_mut().extend_background_events(event_plan);- return;- }- Ok(None) => {}- Err(message) => {- out.push_error(-32000, message);- return;- }- }- }- }if let Some(target_id) = params.target_id.as_deref() {- let shared_worker_detach_plan = conn.browser_context.as_ref().and_then(|bc| {- bc.shared_worker_target(target_id).map(|target| {- (- bc.renderer_runtime(),- target.renderer_instance_id,- target.session_ids(),- )- })- });- if conn- .browser_context- .as_ref()- .is_some_and(|bc| bc.has_shared_worker_target(target_id))- {- out.push_success();- for session_id in shared_worker_detach_plan- .as_ref()- .map(|(_, _, sessions)| sessions.as_slice())- .unwrap_or_default()- {- conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(- session_id,- )- .await;- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(- out.background_events_mut(),- command_context.protocol_events_mut(),- Some(session_id),- "Target detached",- );- }- if let Some((renderer_runtime, instance_id, session_ids)) = &shared_worker_detach_plan {- for session_id in session_ids {- renderer_runtime.detach_shared_worker_runtime_inspector_session(- *instance_id,- Some(session_id.clone()),- );- }- }- let detached_sessions = shared_worker_detach_plan- .as_ref()- .map(|(_, _, sessions)| sessions.clone())- .unwrap_or_default();- if !detached_sessions.is_empty() {- let event_plan = conn- .detach_target_sessions_with_binding_cleanup_event_plan_async(- crate::conn::TargetClosureCleanupPlan::new(- target_id,- None,- detached_sessions,- ),- None,- )- .await;- out.target_events_mut().extend_background_events(event_plan);- }- return;- }- let dedicated_worker_detach_plan = conn.browser_context.as_ref().and_then(|bc| {- bc.dedicated_worker_target(target_id).map(|target| {- (- bc.renderer_runtime(),- target.renderer_instance_id,- target.session_ids(),- )- })+ let worker_session_ids = conn.browser_context.as_ref().and_then(|browser_context| {+ browser_context+ .shared_worker_target(target_id)+ .map(|target| target.session_ids())+ .or_else(|| {+ browser_context+ .dedicated_worker_target(target_id)+ .map(|target| target.session_ids())+ })+ .or_else(|| {+ browser_context+ .service_worker_target(target_id)+ .map(|target| target.session_ids())+ })});- if conn- .browser_context- .as_ref()- .is_some_and(|bc| bc.has_dedicated_worker_target(target_id))- {- out.push_success();- for session_id in dedicated_worker_detach_plan- .as_ref()- .map(|(_, _, sessions)| sessions.as_slice())- .unwrap_or_default()+ if let Some(session_ids) = worker_session_ids {+ match dispose_target_sessions_async(conn, out, command_context, target_id, session_ids)+ .await{- conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(- session_id,- )- .await;- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(- out.background_events_mut(),- command_context.protocol_events_mut(),- Some(session_id),- "Target detached",- );- }- if let Some((renderer_runtime, instance_id, session_ids)) =- &dedicated_worker_detach_plan- {- for session_id in session_ids {- renderer_runtime.detach_dedicated_worker_runtime_inspector_session(- *instance_id,- Some(session_id.clone()),- );- }- }- let detached_sessions = dedicated_worker_detach_plan- .as_ref()- .map(|(_, _, sessions)| sessions.clone())- .unwrap_or_default();- if !detached_sessions.is_empty() {- let event_plan = conn- .detach_target_sessions_with_binding_cleanup_event_plan_async(- crate::conn::TargetClosureCleanupPlan::new(- target_id,- None,- detached_sessions,- ),- None,- )- .await;- out.target_events_mut().extend_background_events(event_plan);- }- return;- }- if conn- .browser_context- .as_ref()- .is_some_and(|bc| bc.has_service_worker_target(target_id))- {- out.push_success();- let service_worker_session_ids: Vec<String> = conn- .browser_context- .as_ref()- .and_then(|bc| bc.service_worker_target(target_id))- .map(|target| target.session_ids())- .unwrap_or_default();- for session_id in &service_worker_session_ids {- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(- out.background_events_mut(),- command_context.protocol_events_mut(),- Some(session_id.as_str()),- "Target detached",- );- super::set_service_worker_pause_on_start_owner(- conn,- Some(session_id.as_str()),- false,- );- }- if !service_worker_session_ids.is_empty() {- let event_plan = conn- .detach_target_sessions_with_binding_cleanup_event_plan_async(- crate::conn::TargetClosureCleanupPlan::new(- target_id,- None,- service_worker_session_ids,- ),- None,- )- .await;- out.target_events_mut().extend_background_events(event_plan);+ Ok(()) => out.push_success(),+ Err(error) => out.push_error(-32000, error.to_string()),}return;}}- let Some(bc) = conn.browser_context.as_mut() else {- out.push_success();- return;- };- let Some((target_id, Some(current_session_id))) = bc.active_target_identity() else {+ let Some((target_id, Some(current_session_id))) = conn+ .browser_context+ .as_ref()+ .and_then(BrowserContext::active_target_identity)+ else {out.push_success();return;};- if let Some(session_id) = params.session_id.as_deref()- && session_id != current_session_id- {- out.push_error(-31998, "InvalidSessionId");- return;- }if let Some(requested_target_id) = params.target_id.as_deref()&& requested_target_id != target_id{@@ -1010,56 +680,48 @@ async fn detach_from_target_inner_async(return;}- out.push_success();-- let (- pending_navigations,- pending_auth_navigations,- pending_response_navigations,- pending_subresource_fetches,- pending_subresource_auths,- pending_subresource_responses,- ) = page::take_pending_fetch_state(conn, Some(¤t_session_id));-- let renderer_output_predecessor = page::fail_pending_fetch_state_background_events_async(+ match super::session_disposal::dispose_target_session_async(conn,out.background_events_mut(),- Some(¤t_session_id),- "Target detached",- "Target detached",- pending_navigations,- pending_auth_navigations,- pending_response_navigations,- pending_subresource_fetches,- pending_subresource_auths,- pending_subresource_responses,+ command_context.protocol_events_mut(),+ crate::conn::TargetSessionDetachCleanupPlan::new(target_id, current_session_id, None, None),)- .await;- if let Some(predecessor) = renderer_output_predecessor {- command_context.set_renderer_output_predecessor(predecessor);+ .await+ {+ Ok(outcome) => {+ let (event_plan, predecessor) = outcome.into_parts();+ if let Some(predecessor) = predecessor {+ command_context.set_renderer_output_predecessor(predecessor);+ }+ out.push_success();+ out.target_events_mut().extend_background_events(event_plan);+ }+ Err(error) => out.push_error(-32000, error.to_string()),}+}- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(- out.background_events_mut(),- command_context.protocol_events_mut(),- Some(¤t_session_id),- "Target detached",- );-- let _ = conn- .detach_runtime_inspector_session_for_session_owner_async(Some(¤t_session_id))- .await;- let event_plan = conn- .detach_session_with_binding_cleanup_event_plan_async(- crate::conn::TargetSessionDetachCleanupPlan::new(- target_id,- current_session_id,- None,- None,- ),+async fn dispose_target_sessions_async(+ conn: &mut CdpConnection,+ out: &mut TargetCommandOutput,+ command_context: &mut crate::conn::CommandDispatchContext,+ target_id: &str,+ session_ids: Vec<String>,+) -> anyhow::Result<()> {+ for session_id in session_ids {+ let outcome = super::session_disposal::dispose_target_session_async(+ conn,+ out.background_events_mut(),+ command_context.protocol_events_mut(),+ crate::conn::TargetSessionDetachCleanupPlan::new(target_id, &session_id, None, None),)- .await;- out.target_events_mut().extend_background_events(event_plan);+ .await?;+ let (event_plan, predecessor) = outcome.into_parts();+ if let Some(predecessor) = predecessor {+ command_context.set_renderer_output_predecessor(predecessor);+ }+ out.target_events_mut().extend_background_events(event_plan);+ }+ Ok(())}fn detach_session_route_target_id(route: &crate::conn::CdpSessionRoute) -> Option<&str> {diff --git a/moli-protocol/src/domains/target/auto_attach.rs b/moli-protocol/src/domains/target/auto_attach.rsindex 8de471196..b0319d341 100644--- a/moli-protocol/src/domains/target/auto_attach.rs+++ b/moli-protocol/src/domains/target/auto_attach.rs@@ -789,114 +789,70 @@ async fn set_auto_attach_inner_async(continue;}- if let Some((target_id, Some(session_id))) = conn+ let sessions_to_dispose = conn.browser_context.as_ref()- .and_then(BrowserContext::active_target_identity)- {- events::fail_pending_fetch_state_for_target_background_events_async(- conn,- out.background_events_mut(),- Some(&session_id),- "Target detached",- )- .await;-- let event_plan = conn- .detach_active_target_session_binding_event_plan_async(- crate::conn::TargetSessionDetachCleanupPlan::new(- target_id, session_id, None, None,- ),- )- .await- .expect("clearing session-scoped state during auto-attach reset should succeed");- out.extend_background_events(event_plan);- }-- let detached_background_targets =- conn.background_target_session_detach_cleanup_plans(None, None);- for cleanup_plan in detached_background_targets {- if let Some(event_plan) = conn- .detach_background_target_session_binding_event_plan_async(cleanup_plan)- .await- .expect("clearing background target session-scoped state during auto-attach reset should succeed")- {- out.extend_background_events(event_plan);- }- }-- let shared_worker_sessions_to_release = conn- .browser_context- .as_ref()- .map(|bc| {- bc.shared_worker_targets- .values()- .flat_map(|target| target.session_ids())- .collect::<Vec<_>>()+ .map(|browser_context| {+ let mut sessions = browser_context+ .active_target_identity()+ .and_then(|(target_id, session_id)| {+ session_id.map(|session_id| (target_id, session_id))+ })+ .into_iter()+ .collect::<Vec<_>>();+ sessions.extend(browser_context.background_targets().filter_map(|target| {+ Some((+ target.target_id().to_owned(),+ target.session_id()?.to_owned(),+ ))+ }));+ sessions.extend(browser_context.shared_worker_targets.values().flat_map(+ |target| {+ target+ .session_ids()+ .into_iter()+ .map(|session_id| (target.target_id.clone(), session_id))+ },+ ));+ sessions.extend(browser_context.dedicated_worker_targets.values().flat_map(+ |target| {+ target+ .session_ids()+ .into_iter()+ .map(|session_id| (target.target_id.clone(), session_id))+ },+ ));+ sessions.extend(browser_context.service_worker_targets.values().flat_map(+ |target| {+ target+ .session_ids()+ .into_iter()+ .map(|session_id| (target.target_id.clone(), session_id))+ },+ ));+ sessions}).unwrap_or_default();- for session_id in &shared_worker_sessions_to_release {- conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(- session_id,- )- .await;- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(+ for (target_id, session_id) in sessions_to_dispose {+ let outcome = super::session_disposal::dispose_target_session_async(+ conn,out.background_events_mut(),command_context.protocol_events_mut(),- Some(session_id),- "Target detached",- );- }-- let shared_worker_event_plan = conn- .detach_all_shared_worker_target_sessions_event_plan_async(None, None)- .await;- out.extend_background_events(shared_worker_event_plan);-- let dedicated_worker_sessions_to_release = conn- .browser_context- .as_ref()- .map(|bc| {- bc.dedicated_worker_targets- .values()- .flat_map(|target| target.session_ids())- .collect::<Vec<_>>()- })- .unwrap_or_default();- for session_id in &dedicated_worker_sessions_to_release {- conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(- session_id,+ crate::conn::TargetSessionDetachCleanupPlan::new(+ target_id,+ &session_id,+ None,+ None,+ ),)- .await;- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(- out.background_events_mut(),- command_context.protocol_events_mut(),- Some(session_id),- "Target detached",- );- }- let dedicated_worker_event_plan = conn- .detach_all_dedicated_worker_target_sessions_event_plan_async(None, None)- .await;- out.extend_background_events(dedicated_worker_event_plan);-- let service_worker_sessions_to_detach = conn- .browser_context- .as_ref()- .map(|bc| {- bc.service_worker_targets- .values()- .flat_map(|target| target.session_ids())- .collect::<Vec<_>>()- })- .unwrap_or_default();- let service_worker_event_plan = conn- .detach_all_service_worker_target_sessions_event_plan_async(None, None)- .await;- for session_id in service_worker_sessions_to_detach {- super::set_service_worker_pause_on_start_owner(conn, Some(&session_id), false);+ .await+ .expect("target session cleanup during auto-attach reset should succeed");+ let (event_plan, predecessor) = outcome.into_parts();+ if let Some(predecessor) = predecessor {+ command_context.set_renderer_output_predecessor(predecessor);+ }+ out.extend_background_events(event_plan);}- out.extend_background_events(service_worker_event_plan);}}@@ -1056,22 +1012,27 @@ pub(super) async fn release_attached_sessions_for_root_frontend_async(conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);continue;}- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(- out.background_events_mut(),- command_context.protocol_events_mut(),- Some(&session_id),- "Target detached",- );- super::clear_detached_target_fetch_state_background_events_async(+ let predecessor = match super::session_disposal::dispose_page_session_runtime_state_async(conn,out.background_events_mut(),+ command_context.protocol_events_mut(),&session_id,)- .await;- let _ = conn- .detach_runtime_inspector_session_for_session_owner_async(Some(&session_id))- .await;- clear_detached_session_target_overrides_best_effort(conn, &session_id).await;+ .await+ {+ Ok(predecessor) => predecessor,+ Err(error) => {+ tracing::warn!(+ session_id,+ %error,+ "failed to dispose root-owned page session runtime state"+ );+ continue;+ }+ };+ if let Some(predecessor) = predecessor {+ command_context.set_renderer_output_predecessor(predecessor);+ }if !conn.release_primary_target_session_binding_without_event(&session_id) {conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);}@@ -1108,178 +1069,46 @@ async fn detach_attached_session_for_owner_async(conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);return;};- match cleanup_plan.action().clone() {- crate::conn::TargetBindingCleanupAction::PageTarget {- target_id,- session_key,- } => {- // A parent-session detach cascade bypasses the direct- // Target.detachFromTarget path. Release the renderer inspector- // here before resetting protocol state so the replacement primary- // session gets a fresh Runtime.enable context inventory.- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(- out.background_events_mut(),- command_context.protocol_events_mut(),- Some(session_id),- "Target detached",- );- let _ = conn- .detach_runtime_inspector_session_for_session_owner_async(Some(session_id))- .await;- if matches!(- session_key,- moli_page_types::DevToolsSessionKey::Attached(_)- ) {- clear_detached_session_target_overrides_best_effort(conn, session_id).await;- super::clear_detached_target_fetch_state_background_events_async(- conn,- out.background_events_mut(),- session_id,- )- .await;- } else if conn- .browser_context- .as_ref()- .is_some_and(|browser_context| browser_context.is_active_target(&target_id))- {- events::fail_pending_fetch_state_for_target_background_events_async(- conn,- out.background_events_mut(),- Some(session_id),- "Target detached",- )- .await;- } else {- clear_detached_session_target_overrides_best_effort(conn, session_id).await;- }- let event_plan = conn- .detach_session_with_binding_cleanup_event_plan_async(- crate::conn::TargetSessionDetachCleanupPlan::new(- target_id, session_id, None, None,- ),- )- .await;- out.extend_background_events(event_plan);+ let target_id = match cleanup_plan.action() {+ crate::conn::TargetBindingCleanupAction::PageTarget { target_id, .. }+ | crate::conn::TargetBindingCleanupAction::SharedWorkerTarget { target_id }+ | crate::conn::TargetBindingCleanupAction::DedicatedWorkerTarget { target_id }+ | crate::conn::TargetBindingCleanupAction::ServiceWorkerTarget { target_id } => {+ target_id.clone()}crate::conn::TargetBindingCleanupAction::TabTarget { tab_target_id } => {- let event_plan = conn- .detach_session_with_binding_cleanup_event_plan_async(- crate::conn::TargetSessionDetachCleanupPlan::new(- tab_target_id,- session_id,- None,- None,- ),- )- .await;- out.extend_background_events(event_plan);+ tab_target_id.clone()}- crate::conn::TargetBindingCleanupAction::SharedWorkerTarget { target_id } => {- let renderer_detach = conn.browser_context.as_ref().and_then(|bc| {- bc.shared_worker_target(&target_id)- .map(|target| (bc.renderer_runtime(), target.renderer_instance_id))- });- conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(- session_id,- )- .await;- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(- out.background_events_mut(),- command_context.protocol_events_mut(),- Some(session_id),- "Target detached",- );- if let Some((renderer_runtime, instance_id)) = renderer_detach {- renderer_runtime.detach_shared_worker_runtime_inspector_session(- instance_id,- Some(session_id.to_owned()),- );- }- let event_plan = conn- .detach_session_with_binding_cleanup_event_plan_async(- crate::conn::TargetSessionDetachCleanupPlan::new(- target_id, session_id, None, None,- ),- )- .await;- out.extend_background_events(event_plan);+ crate::conn::TargetBindingCleanupAction::None => {+ conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);+ return;}- crate::conn::TargetBindingCleanupAction::DedicatedWorkerTarget { target_id } => {- let renderer_detach = conn.browser_context.as_ref().and_then(|bc| {- bc.dedicated_worker_target(&target_id)- .map(|target| (bc.renderer_runtime(), target.renderer_instance_id))- });- conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(- session_id,- )- .await;- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(- out.background_events_mut(),- command_context.protocol_events_mut(),- Some(session_id),- "Target detached",- );- if let Some((renderer_runtime, instance_id)) = renderer_detach {- renderer_runtime.detach_dedicated_worker_runtime_inspector_session(- instance_id,- Some(session_id.to_owned()),- );+ };+ match super::session_disposal::dispose_target_session_async(+ conn,+ out.background_events_mut(),+ command_context.protocol_events_mut(),+ crate::conn::TargetSessionDetachCleanupPlan::new(target_id, session_id, None, None),+ )+ .await+ {+ Ok(outcome) => {+ let (event_plan, predecessor) = outcome.into_parts();+ if let Some(predecessor) = predecessor {+ command_context.set_renderer_output_predecessor(predecessor);}- let event_plan = conn- .detach_session_with_binding_cleanup_event_plan_async(- crate::conn::TargetSessionDetachCleanupPlan::new(- target_id, session_id, None, None,- ),- )- .await;out.extend_background_events(event_plan);}- crate::conn::TargetBindingCleanupAction::ServiceWorkerTarget { target_id } => {- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(- out.background_events_mut(),- command_context.protocol_events_mut(),- Some(session_id),- "Target detached",+ Err(error) => {+ tracing::warn!(+ session_id,+ %error,+ "failed to dispose auto-attached target session");- super::set_service_worker_pause_on_start_owner(conn, Some(session_id), false);- let event_plan = conn- .detach_session_with_binding_cleanup_event_plan_async(- crate::conn::TargetSessionDetachCleanupPlan::new(- target_id, session_id, None, None,- ),- )- .await;- out.extend_background_events(event_plan);- }- crate::conn::TargetBindingCleanupAction::None => {- conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);}}}-pub(super) async fn clear_detached_session_target_overrides_best_effort(- conn: &mut CdpConnection,- session_id: &str,-) {- if let Err(error) =- crate::domains::emulation::clear_emulated_media_for_detached_session_async(conn, session_id)- .await- {- tracing::warn!(- session_id,- error,- "failed to clear emulated media while detaching target session"- );- }- if let Err(error) = conn.clear_target_session_overrides_async(session_id).await {- tracing::warn!(- session_id,- error,- "failed to restore target overrides while detaching target session"- );- }-}-async fn ensure_initial_document_for_attached_page_targets_async(conn: &mut CdpConnection,attached_targets: &[(String, String)],diff --git a/moli-protocol/src/domains/target/browser_context_disposal.rs b/moli-protocol/src/domains/target/browser_context_disposal.rsindex 4ed3e1bbb..147f37352 100644--- a/moli-protocol/src/domains/target/browser_context_disposal.rs+++ b/moli-protocol/src/domains/target/browser_context_disposal.rs@@ -256,8 +256,11 @@ async fn close_page_target(.as_ref().is_some_and(|browser_context| browser_context.is_active_target(&target_id));let closed = if is_active_target {- conn.close_active_page_target_for_target_close_async(out.background_events_mut())- .await+ conn.close_active_page_target_for_target_close_async(+ out.background_events_mut(),+ DISPOSE_REASON,+ )+ .await} else {conn.close_background_page_target_for_target_close_async(&target_id,diff --git a/moli-protocol/src/domains/target/closing.rs b/moli-protocol/src/domains/target/closing.rsindex e0404d852..545e680a3 100644--- a/moli-protocol/src/domains/target/closing.rs+++ b/moli-protocol/src/domains/target/closing.rs@@ -266,11 +266,8 @@ async fn settle_target_close_after_pending_fetches_async(owner_scope: crate::conn::CommandOwnerScope,target_id: String,) {- let action = crate::domains::page::PageTargetTerminationOwnerAction::new(- owner_scope,- target_id,- crate::domains::page::PageTargetTerminationKind::TargetClose,- );+ let action =+ crate::domains::page::PageTargetTerminationOwnerAction::new(owner_scope, target_id);if let Some(predecessor) = renderer_output_predecessor {command_context.set_renderer_output_predecessor(predecessor);conn.publish_page_target_termination_owner_action(action);diff --git a/moli-protocol/src/domains/target/session_disposal.rs b/moli-protocol/src/domains/target/session_disposal.rsnew file mode 100644index 000000000..557938284--- /dev/null+++ b/moli-protocol/src/domains/target/session_disposal.rs@@ -0,0 +1,177 @@+use crate::conn::{+ BackgroundProtocolEvent, CdpConnection, TargetBindingCleanupAction, TargetBindingCleanupPlan,+ TargetEventPlan, TargetSessionDetachCleanupPlan,+};++pub(super) struct TargetSessionDisposalOutcome {+ event_plan: TargetEventPlan,+ renderer_output_predecessor: Option<moli_core::RendererOutputFence>,+}++impl TargetSessionDisposalOutcome {+ pub(super) fn into_parts(self) -> (TargetEventPlan, Option<moli_core::RendererOutputFence>) {+ (self.event_plan, self.renderer_output_predecessor)+ }+}++pub(super) async fn dispose_target_session_async(+ conn: &mut CdpConnection,+ background_events: &mut Vec<BackgroundProtocolEvent>,+ protocol_events: &mut Vec<BackgroundProtocolEvent>,+ cleanup_plan: TargetSessionDetachCleanupPlan,+) -> anyhow::Result<TargetSessionDisposalOutcome> {+ let session_id = cleanup_plan.session_id().to_owned();+ let route = conn+ .session_route(Some(&session_id))+ .ok_or_else(|| anyhow::anyhow!("InvalidSessionId"))?;+ let binding_plan = TargetBindingCleanupPlan::from_route(&session_id, &route);+ let expected_target_id = cleanup_plan.target_id();+ let action_target_id = match binding_plan.action() {+ TargetBindingCleanupAction::None => None,+ TargetBindingCleanupAction::PageTarget { target_id, .. }+ | TargetBindingCleanupAction::SharedWorkerTarget { target_id }+ | TargetBindingCleanupAction::DedicatedWorkerTarget { target_id }+ | TargetBindingCleanupAction::ServiceWorkerTarget { target_id } => Some(target_id.as_str()),+ TargetBindingCleanupAction::TabTarget { tab_target_id } => Some(tab_target_id.as_str()),+ };+ if action_target_id.is_some_and(|target_id| target_id != expected_target_id) {+ anyhow::bail!("UnknownTargetId");+ }++ let mut renderer_output_predecessor = None;+ match binding_plan.action() {+ TargetBindingCleanupAction::PageTarget { .. } => {+ renderer_output_predecessor = dispose_page_session_runtime_state_async(+ conn,+ background_events,+ protocol_events,+ &session_id,+ )+ .await?;+ }+ TargetBindingCleanupAction::SharedWorkerTarget { target_id } => {+ let renderer_detach = conn.browser_context.as_ref().and_then(|browser_context| {+ browser_context+ .shared_worker_target(target_id)+ .map(|target| {+ (+ browser_context.renderer_runtime(),+ target.renderer_instance_id,+ )+ })+ });+ conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(+ &session_id,+ )+ .await;+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(+ background_events,+ protocol_events,+ Some(&session_id),+ "Target detached",+ );+ if let Some((renderer_runtime, instance_id)) = renderer_detach {+ renderer_runtime.detach_shared_worker_runtime_inspector_session(+ instance_id,+ Some(session_id.clone()),+ );+ }+ }+ TargetBindingCleanupAction::DedicatedWorkerTarget { target_id } => {+ let renderer_detach = conn.browser_context.as_ref().and_then(|browser_context| {+ browser_context+ .dedicated_worker_target(target_id)+ .map(|target| {+ (+ browser_context.renderer_runtime(),+ target.renderer_instance_id,+ )+ })+ });+ conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(+ &session_id,+ )+ .await;+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(+ background_events,+ protocol_events,+ Some(&session_id),+ "Target detached",+ );+ if let Some((renderer_runtime, instance_id)) = renderer_detach {+ renderer_runtime.detach_dedicated_worker_runtime_inspector_session(+ instance_id,+ Some(session_id.clone()),+ );+ }+ }+ TargetBindingCleanupAction::ServiceWorkerTarget { .. } => {+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(+ background_events,+ protocol_events,+ Some(&session_id),+ "Target detached",+ );+ super::set_service_worker_pause_on_start_owner(conn, Some(&session_id), false);+ }+ TargetBindingCleanupAction::TabTarget { .. } => {}+ TargetBindingCleanupAction::None => anyhow::bail!("InvalidSessionId"),+ }++ let event_plan = conn+ .detach_session_with_binding_cleanup_event_plan_async(cleanup_plan)+ .await?;+ Ok(TargetSessionDisposalOutcome {+ event_plan,+ renderer_output_predecessor,+ })+}++pub(super) async fn dispose_page_session_runtime_state_async(+ conn: &mut CdpConnection,+ background_events: &mut Vec<BackgroundProtocolEvent>,+ protocol_events: &mut Vec<BackgroundProtocolEvent>,+ session_id: &str,+) -> anyhow::Result<Option<moli_core::RendererOutputFence>> {+ let renderer_output_predecessor =+ super::clear_detached_target_fetch_state_background_events_async(+ conn,+ background_events,+ session_id,+ )+ .await;+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(+ background_events,+ protocol_events,+ Some(session_id),+ "Target detached",+ );++ // Document-start scripts are renderer-owned resources. Remove them before+ // detaching the Inspector session that carries the cleanup commands.+ conn.remove_document_start_scripts_for_detached_session_async(session_id)+ .await?;+ clear_page_session_target_state_async(conn, session_id).await?;+ if let Err(error) = conn+ .detach_runtime_inspector_session_for_session_owner_async(Some(session_id))+ .await+ {+ tracing::debug!(+ session_id,+ %error,+ "renderer Inspector session was already unavailable during disposal"+ );+ }+ Ok(renderer_output_predecessor)+}++async fn clear_page_session_target_state_async(+ conn: &mut CdpConnection,+ session_id: &str,+) -> anyhow::Result<()> {+ crate::domains::emulation::clear_emulated_media_for_detached_session_async(conn, session_id)+ .await?;+ conn.clear_target_session_overrides_async(session_id)+ .await?;+ Ok(())+}diff --git a/moli-protocol/src/domains/target/tests/tests_target_attachment.rs b/moli-protocol/src/domains/target/tests/tests_target_attachment.rsindex cf2ae3578..4bde11821 100644--- a/moli-protocol/src/domains/target/tests/tests_target_attachment.rs+++ b/moli-protocol/src/domains/target/tests/tests_target_attachment.rs@@ -1665,7 +1665,8 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(}ctx.sent.clear();- let baseline_session_count = page_renderer_inspector_session_count(&mut ctx).await;+ let baseline_session_count =+ page_renderer_inspector_session_count(&mut ctx, "before Runtime.enable").await;ctx.process_async(json!({"id": 120_001,"sessionId": "SID-detach-primary",@@ -1683,7 +1684,7 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(ctx.sent.clear();assert_eq!(- page_renderer_inspector_session_count(&mut ctx).await,+ page_renderer_inspector_session_count(&mut ctx, "after both sessions enabled").await,baseline_session_count + 1,"primary Runtime.enable must reuse the target default Inspector session while auxiliary Runtime.enable adds one session");@@ -1712,7 +1713,7 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session("auxiliary detach must publish exactly one target detach event");assert_eq!(- page_renderer_inspector_session_count(&mut ctx).await,+ page_renderer_inspector_session_count(&mut ctx, "after auxiliary detach").await,baseline_session_count,"auxiliary detach should drop only that renderer V8 inspector session");@@ -1745,12 +1746,27 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(ctx.expect_result(120_006, json!({}), Some("SID-detach-aux-replacement"));ctx.sent.clear();assert_eq!(- page_renderer_inspector_session_count(&mut ctx).await,+ page_renderer_inspector_session_count(&mut ctx, "after replacement auxiliary enable").await,baseline_session_count + 1);-+ ctx.process_async(json!({+ "id": 120_007,+ "sessionId": "SID-detach-aux-replacement",+ "method": "Network.enable"+ }))+ .await;+ ctx.expect_result(120_007, json!({}), Some("SID-detach-aux-replacement"));ctx.process_async(json!({"id": 120_008,+ "sessionId": "SID-detach-aux-replacement",+ "method": "Network.setCacheDisabled",+ "params": { "cacheDisabled": true }+ }))+ .await;+ ctx.expect_result(120_008, json!({}), Some("SID-detach-aux-replacement"));++ ctx.process_async(json!({+ "id": 120_009,"method": "Target.detachFromTarget","params": {"targetId": "TID-detach-inspector",@@ -1758,7 +1774,7 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(}})).await;- ctx.expect_result(120_008, json!({}), None);+ ctx.expect_result(120_009, json!({}), None);ctx.expect_event("Target.detachedFromTarget",Some(&json!({@@ -1773,13 +1789,12 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session("primary detach must publish exactly one target detach event");assert_eq!(- page_renderer_inspector_session_count(&mut ctx).await,- 1,- "primary target detach must preserve same-target auxiliary renderer V8 inspector sessions"+ page_renderer_inspector_session_count(&mut ctx, "after primary detach").await,+ baseline_session_count,+ "primary detach must release the default Inspector session while preserving the attached replacement session");-ctx.process_async(json!({- "id": 120_009,+ "id": 120_010,"sessionId": "SID-detach-primary","method": "Runtime.evaluate","params": {@@ -1788,10 +1803,21 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(}})).await;- ctx.expect_error(120_009, -32001, "Unknown sessionId");+ ctx.expect_error(120_010, -32001, "Unknown sessionId");++ let bc = ctx.conn.browser_context.as_ref().unwrap();+ assert_eq!(+ bc.auxiliary_target_id_for_session("SID-detach-aux-replacement"),+ Some("TID-detach-inspector"),+ "detaching primary must preserve the attached session binding"+ );+ assert!(+ bc.active_page_target().effective_policy().cache_disabled(),+ "detaching primary must preserve the attached Network handler state"+ );ctx.process_async(json!({- "id": 120_010,+ "id": 120_011,"sessionId": "SID-detach-aux-replacement","method": "Runtime.evaluate","params": {@@ -1800,11 +1826,11 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(}})).await;- let evaluation = take_response_by_id(&mut ctx, 120_010);+ let evaluation = take_response_by_id(&mut ctx, 120_011);assert_eq!(evaluation["result"]["result"]["value"], json!(42));ctx.process_async(json!({- "id": 120_011,+ "id": 120_012,"method": "Target.detachFromTarget","params": {"targetId": "TID-detach-inspector",@@ -1812,7 +1838,7 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(}})).await;- ctx.expect_result(120_011, json!({}), None);+ ctx.expect_result(120_012, json!({}), None);ctx.expect_event("Target.detachedFromTarget",Some(&json!({@@ -1820,10 +1846,34 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session("sessionId": "SID-detach-aux-replacement"})),);+ ctx.process_async(json!({+ "id": 120_013,+ "sessionId": "SID-detach-aux-replacement",+ "method": "Runtime.evaluate",+ "params": {+ "expression": "21 + 21",+ "returnByValue": true+ }+ }))+ .await;+ ctx.expect_error(120_013, -32001, "Unknown sessionId");++ ctx.conn+ .browser_context+ .as_mut()+ .expect("browser context")+ .attach_active_session("SID-detach-diagnostic");+ ctx.process_async(json!({+ "id": 120_014,+ "sessionId": "SID-detach-diagnostic",+ "method": "Runtime.enable"+ }))+ .await;+ ctx.expect_result(120_014, json!({}), Some("SID-detach-diagnostic"));assert_eq!(- page_renderer_inspector_session_count(&mut ctx).await,- 0,- "detaching the final auxiliary session should release its renderer V8 inspector session"+ page_renderer_inspector_session_count(&mut ctx, "after fresh primary attach").await,+ baseline_session_count,+ "a fresh primary session must not observe a leaked auxiliary renderer session");}@@ -2002,16 +2052,24 @@ async fn detach_from_target_removes_only_selected_session_document_start_scripts);}-async fn page_renderer_inspector_session_count(ctx: &mut TestContext) -> u64 {- let response = ctx+async fn page_renderer_inspector_session_count(ctx: &mut TestContext, stage: &str) -> u64 {+ let page = ctx.conn.browser_context.as_mut().and_then(|bc| bc.active_page_target_mut().runtime_slot.loaded_page_mut())- .expect("active target should still have a loaded page")+ .expect("active target should still have a loaded page");+ // This diagnostic deliberately runs on the primary Inspector route. It+ // bypasses CdpConnection's session-aware Page accessor, so bind that route+ // explicitly instead of inheriting whichever auxiliary session the prior+ // command happened to stamp on the Page facade.+ page.set_renderer_devtools_command_session_id(None);+ let response = page.runtime_heap_usage_async().await- .expect("runtime heap usage diagnostics should be available");+ .unwrap_or_else(|error| {+ panic!("runtime heap usage diagnostics should be available {stage}: {error}")+ });u64::try_from(response.moli.runtime.inspector_session_count).expect("inspector session count should fit u64")}diff --git a/moli-protocol/src/domains/target/tests/tests_target_basics.rs b/moli-protocol/src/domains/target/tests/tests_target_basics.rsindex 434ccf21a..db773359e 100644--- a/moli-protocol/src/domains/target/tests/tests_target_basics.rs+++ b/moli-protocol/src/domains/target/tests/tests_target_basics.rs@@ -42,6 +42,12 @@ async fn close_active_target_fails_only_active_owner_pending_awaits() {let mut bc = BrowserContext::new("BID-await-owner".into());bc.set_active_target_id("TID-active-await".to_owned());bc.attach_active_session("SID-active-await".to_owned());+ assert!(+ bc.assign_auxiliary_session_to_target(+ "TID-active-await",+ "SID-active-aux-await".to_owned(),+ )+ );bc.insert_page_target_host(PageTargetHost::with_url("TID-bg-await".to_owned(),Some("SID-bg-await".to_owned()),@@ -50,6 +56,8 @@ async fn close_active_target_fails_only_active_owner_pending_awaits() {ctx.conn.browser_context = Some(bc);ctx.conn.register_pending_inspector_await(1041201, Some("SID-active-await"));+ ctx.conn+ .register_pending_inspector_await(1041203, Some("SID-active-aux-await"));ctx.conn.register_pending_inspector_await(1041202, Some("SID-bg-await"));@@ -65,11 +73,16 @@ async fn close_active_target_fails_only_active_owner_pending_awaits() {let active_failed = take_response_by_id(&mut ctx, 1041201);assert_eq!(active_failed["sessionId"], json!("SID-active-await"));assert_eq!(active_failed["error"]["message"], json!("Target closed"));+ let auxiliary_failed = take_response_by_id(&mut ctx, 1041203);+ assert_eq!(auxiliary_failed["sessionId"], json!("SID-active-aux-await"));+ assert_eq!(auxiliary_failed["error"]["message"], json!("Target closed"));assert!(- ctx.take_all()- .into_iter()- .all(|message| message["id"] != json!(1041202)),- "closing the active target must not fail the background owner's pending await"+ ctx.take_all().into_iter().all(|message| {+ message["id"] != json!(1041201)+ && message["id"] != json!(1041202)+ && message["id"] != json!(1041203)+ }),+ "target-local awaits must settle exactly once without touching the background owner");assert!(ctx.conndiff --git a/moli-protocol/src/domains/target/worker_target.rs b/moli-protocol/src/domains/target/worker_target.rsindex a883e6ed9..9c4ed1534 100644--- a/moli-protocol/src/domains/target/worker_target.rs+++ b/moli-protocol/src/domains/target/worker_target.rs@@ -1251,7 +1251,8 @@ async fn commit_dedicated_worker_retirement_output_async(conn.detach_dedicated_worker_session_with_binding_cleanup_event_plan_async(cleanup_plan,)- .await,+ .await+ .expect("retired dedicated-worker session cleanup should succeed"),);}WorkerTargetLifecycleOutput::DedicatedWorkerDestroyed {@@ -2960,7 +2961,8 @@ async fn emit_target_lifecycle_events();let event_plan = conn.detach_session_with_binding_cleanup_event_plan_async(cleanup_plan)- .await;+ .await+ .expect("retired shared-worker session cleanup should succeed");side_effects.extend_background_events(event_plan);retirement.retire();}@@ -2983,7 +2985,8 @@ async fn emit_target_lifecycle_events();let event_plan = conn.detach_session_with_binding_cleanup_event_plan_async(cleanup_plan)- .await;+ .await+ .expect("retired service-worker session cleanup should succeed");side_effects.extend_background_events(event_plan);retirement.retire();}diff --git a/moli-protocol/src/domains/tracing/tests.rs b/moli-protocol/src/domains/tracing/tests.rsindex 81fc080af..5242f24da 100644--- a/moli-protocol/src/domains/tracing/tests.rs+++ b/moli-protocol/src/domains/tracing/tests.rs@@ -286,6 +286,7 @@ async fn owner_cleanup_cancels_trace_without_emitting_completion() {ctx.conn.execute_target_binding_cleanup_for_session_without_event_async("SID-peer").await+ .unwrap());assert!(!ctx.conn.tracing_state.is_active());assert!(@@ -362,7 +363,7 @@ async fn owner_cleanup_waits_for_cpu_trace_release_before_replacement_start() {).await.expect("owner detach should wait for CPU trace cancellation");- assert!(cleaned);+ assert!(cleaned.unwrap());assert!(stop_tasks > 0);assert!(!ctx.conn.tracing_state.is_active());diff --git a/moli-protocol/src/testing.rs b/moli-protocol/src/testing.rsindex d8e7ffe7e..9194dfebb 100644--- a/moli-protocol/src/testing.rs+++ b/moli-protocol/src/testing.rs@@ -312,8 +312,8 @@ impl TestContext {.target_owner_identity_for_route(owner.session_id(), owner.session_owner_route()).expect("navigation fixture requires an installed browser context");let target_id = target_id.expect("navigation fixture requires an exact target");+ let navigation_engine = navigation.take_navigation_engine_replacement();let renderer_output_predecessor = navigation.renderer_output_predecessor;- let navigation_engine = navigation.navigation_engine.take();let page_creation_artifacts = navigation.page_creation_artifacts;let final_url = navigation.final_url;let main_document_commit = navigationdiff --git a/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs b/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rsindex 33a4ac519..991c3a4dd 100644--- a/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs+++ b/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs@@ -162,7 +162,7 @@ pub(crate) fn dispatch_worker_event<'s>(| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }| WorkerToParentMessage::SharedWorkerClosed- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_) => false,+ | WorkerToParentMessage::RuntimeInspectorResponse(_) => false,}}diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rsindex 2290b9cbd..caefe1fc7 100644--- a/moli-renderer-v8/src/lib.rs+++ b/moli-renderer-v8/src/lib.rs@@ -215,18 +215,19 @@ pub use local_executor::is_on_js_local_executor;pub use native_bridge::element::ClientRect as RendererClientRect;pub use runtime::RendererRuntimeInspectorMessageResponseOrder;pub use runtime::{- DetachedParserScriptFetchContinuation, DevToolsSessionKey, ExternalRawDocumentBodyStream,- JsRuntime, JsRuntimeOwner, PageId, PendingHtmlPage, PreparedRendererDocument,- RendererAccessibilityPayloadsForObjectId, RendererActivityDiagnostics,- RendererAgentAttachmentId, RendererAutofillAddressField, RendererAutofillCreditCard,- RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest, RendererBrowserContextRuntime,- RendererBrowserContextRuntimeId, RendererBrowserContextRuntimeOwner,- RendererBrowserContextRuntimeOwnerAccess, RendererCaptureScreencastFrameReply,- RendererCaptureScreencastFrameRequest, RendererCaptureScreenshotReply,- RendererCaptureScreenshotRequest, RendererCapturedScreencastFrame, RendererCapturedScreenshot,- RendererCommandTurnCompletion, RendererCommandTurnOutput, RendererCountEntry,- RendererDedicatedWorkerTargetEvent, RendererDedicatedWorkerTargetInfo,- RendererDevToolsAgentToken, RendererDevToolsMainCommandEnvelope, RendererDocumentBoxModel,+ CompletedWorkerRuntimeInspectorCommandDispatch, DetachedParserScriptFetchContinuation,+ DevToolsSessionKey, ExternalRawDocumentBodyStream, JsRuntime, JsRuntimeOwner, PageId,+ PendingHtmlPage, PreparedRendererDocument, RendererAccessibilityPayloadsForObjectId,+ RendererActivityDiagnostics, RendererAgentAttachmentId, RendererAutofillAddressField,+ RendererAutofillCreditCard, RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest,+ RendererBrowserContextRuntime, RendererBrowserContextRuntimeId,+ RendererBrowserContextRuntimeOwner, RendererBrowserContextRuntimeOwnerAccess,+ RendererCaptureScreencastFrameReply, RendererCaptureScreencastFrameRequest,+ RendererCaptureScreenshotReply, RendererCaptureScreenshotRequest,+ RendererCapturedScreencastFrame, RendererCapturedScreenshot, RendererCommandTurnCompletion,+ RendererCommandTurnOutput, RendererCountEntry, RendererDedicatedWorkerTargetEvent,+ RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken,+ RendererDevToolsMainCommandEnvelope, RendererDocumentBoxModel,RendererDocumentChildNodeSnapshotEvent, RendererDocumentChildNodeSnapshotEvents,RendererDocumentChildNodeSnapshots, RendererDocumentCommitPermit,RendererDocumentFrontendNodeIdsResolution, RendererDocumentHitTestResult,diff --git a/moli-renderer-v8/src/native_bridge/context_host/activity.rs b/moli-renderer-v8/src/native_bridge/context_host/activity.rsindex 8cc8aef60..88a526d9f 100644--- a/moli-renderer-v8/src/native_bridge/context_host/activity.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/activity.rs@@ -39,6 +39,26 @@ impl JsContextHost {self.output_journal = Some(output_journal);}+ pub(crate) fn renderer_output_journal(+ &self,+ ) -> Option<crate::runtime::RendererTurnOutputJournal> {+ self.output_journal.clone()+ }++ pub(crate) fn publish_worker_runtime_inspector_response(+ &self,+ publication: crate::runtime::RendererRuntimeInspectorResponsePublication,+ ) -> bool {+ let Some(output_journal) = self.output_journal.as_ref() else {+ return false;+ };+ self.publish_live_turn_output_prefix();+ let predecessor = output_journal+ .last_published_cursor()+ .map(|cursor| output_journal.declare_fence(cursor));+ publication.commit(predecessor).is_ok()+ }+/// Appends a browser-owner action to the one concrete sink for this turn.////// Command turns retain a distinct response boundary, but they use thediff --git a/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs b/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rsindex b07f532e6..53b032cc9 100644--- a/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs@@ -158,7 +158,11 @@ impl JsContextHost {.browser_context_runtime().allocate_dedicated_worker_instance_id();self.browser_context_runtime()- .attach_dedicated_worker_devtools_handle(renderer_instance_id, &worker_handle);+ .attach_dedicated_worker_devtools_handle(+ renderer_instance_id,+ &worker_handle,+ self.renderer_output_journal(),+ );let client_event_producer = self.dedicated_worker_client_event_producer(worker_id, &owner);Self::start_worker_message_relay(worker_id,@@ -544,7 +548,11 @@ impl JsContextHost {.map(|state| state.renderer_instance_id).expect("loading DedicatedWorker must retain its renderer instance identity");self.browser_context_runtime()- .attach_dedicated_worker_devtools_handle(renderer_instance_id, &worker_handle);+ .attach_dedicated_worker_devtools_handle(+ renderer_instance_id,+ &worker_handle,+ self.renderer_output_journal(),+ );for message in pending_messages {worker_handle.post_message(message);}diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime.rs b/moli-renderer-v8/src/runtime/browser_context_runtime.rsindex 83874a1e2..59bfa4b0f 100644--- a/moli-renderer-v8/src/runtime/browser_context_runtime.rs+++ b/moli-renderer-v8/src/runtime/browser_context_runtime.rs@@ -181,12 +181,18 @@ struct RendererBrowserContextRuntimeInner {next_child_document_loader_id: AtomicU64,next_detached_parser_script_fetch_id: AtomicU64,next_dedicated_worker_instance_id: AtomicU64,- dedicated_worker_devtools_handles: Mutex<HashMap<u64, crate::worker::WorkerDevToolsHandle>>,+ dedicated_worker_devtools_targets: Mutex<HashMap<u64, DedicatedWorkerDevToolsTarget>>,dedicated_worker_pause_on_start_for_devtools: AtomicBool,javascript_dialog_handler_enabled: AtomicBool,renderer_output_transport_tx: RendererOutputTransportSenderSlot,}+#[derive(Clone, Debug)]+struct DedicatedWorkerDevToolsTarget {+ handle: crate::worker::WorkerDevToolsHandle,+ output_journal: Option<super::RendererTurnOutputJournal>,+}+#[derive(Debug)]struct DetachedParserScriptFetchContinuationInner {script: PreparedScript,@@ -309,10 +315,10 @@ impl Drop for RendererBrowserContextRuntimeInner {}fn terminate_browser_context_resource_producers(inner: &RendererBrowserContextRuntimeInner) {- let dedicated_worker_handles =- std::mem::take(&mut *inner.dedicated_worker_devtools_handles.lock());- for handle in dedicated_worker_handles.into_values() {- let _ = handle.terminate_for_devtools();+ let dedicated_worker_targets =+ std::mem::take(&mut *inner.dedicated_worker_devtools_targets.lock());+ for target in dedicated_worker_targets.into_values() {+ let _ = target.handle.terminate_for_devtools();}if let Some(shared_worker_runtime) = inner.shared_worker_runtime.get() {shared_worker_runtime.terminate_all_for_context_shutdown();@@ -527,7 +533,7 @@ impl RendererBrowserContextRuntime {next_child_document_loader_id: AtomicU64::default(),next_detached_parser_script_fetch_id: AtomicU64::default(),next_dedicated_worker_instance_id: AtomicU64::default(),- dedicated_worker_devtools_handles: Mutex::new(HashMap::new()),+ dedicated_worker_devtools_targets: Mutex::new(HashMap::new()),dedicated_worker_pause_on_start_for_devtools: AtomicBool::new(false),javascript_dialog_handler_enabled: AtomicBool::new(false),renderer_output_transport_tx,diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs b/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rsindex a4d0b5d16..9e1bacd9d 100644--- a/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs+++ b/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs@@ -3,7 +3,7 @@ use tokio::sync::oneshot;use crate::runtime::{RendererRuntimeInspectorMessage, RendererRuntimeInspectorResponseSender};use crate::worker::{WorkerDevToolsHandle, WorkerHandle};-use super::RendererBrowserContextRuntime;+use super::{DedicatedWorkerDevToolsTarget, RendererBrowserContextRuntime};impl RendererBrowserContextRuntime {/// Allocates a browser-context-unique identity for one DedicatedWorker@@ -20,16 +20,20 @@ impl RendererBrowserContextRuntime {&self,instance_id: u64,handle: &WorkerHandle,+ output_journal: Option<crate::runtime::RendererTurnOutputJournal>,) {- self.inner- .dedicated_worker_devtools_handles- .lock()- .insert(instance_id, handle.devtools_handle());+ self.inner.dedicated_worker_devtools_targets.lock().insert(+ instance_id,+ DedicatedWorkerDevToolsTarget {+ handle: handle.devtools_handle(),+ output_journal,+ },+ );}pub(crate) fn unregister_dedicated_worker_devtools_handle(&self, instance_id: u64) {self.inner- .dedicated_worker_devtools_handles+ .dedicated_worker_devtools_targets.lock().remove(&instance_id);}@@ -48,7 +52,18 @@ impl RendererBrowserContextRuntime {fn dedicated_worker_devtools_handle(&self, instance_id: u64) -> Option<WorkerDevToolsHandle> {self.inner- .dedicated_worker_devtools_handles+ .dedicated_worker_devtools_targets+ .lock()+ .get(&instance_id)+ .map(|target| target.handle.clone())+ }++ fn dedicated_worker_devtools_target(+ &self,+ instance_id: u64,+ ) -> Option<DedicatedWorkerDevToolsTarget> {+ self.inner+ .dedicated_worker_devtools_targets.lock().get(&instance_id).cloned()@@ -85,6 +100,40 @@ impl RendererBrowserContextRuntime {.await}+ pub async fn dispatch_dedicated_worker_runtime_protocol_message_with_devtools_session_response(+ &self,+ instance_id: u64,+ inspector_session_id: String,+ raw_json: String,+ response: RendererRuntimeInspectorResponseSender,+ ) -> Result<crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch, String> {+ let Some(target) = self.dedicated_worker_devtools_target(instance_id) else {+ return Err("DedicatedWorkerRuntimeUnavailable".to_owned());+ };+ let Some(output_journal) = target.output_journal else {+ return Err("DedicatedWorkerRuntimeUnavailable".to_owned());+ };+ let response = response+ .route_to_worker_devtools_session_output(inspector_session_id.clone(), output_journal);+ let settlement = response+ .take_session_response_settlement_receiver()+ .expect("a Worker DevTools response must own one settlement receiver");+ let (response_tx, response_rx) = oneshot::channel();+ if !target.handle.dispatch_runtime_protocol_message(+ Some(inspector_session_id),+ raw_json,+ Some(response),+ response_tx,+ ) {+ return Err("DedicatedWorkerRuntimeUnavailable".to_owned());+ }+ let dispatch = response_rx+ .await+ .map_err(|_| "DedicatedWorkerRuntimeUnavailable".to_owned())?;+ crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch::finish(dispatch, settlement)+ .await+ }+async fn dispatch_dedicated_worker_runtime_protocol_message_with_optional_deferred_response(&self,instance_id: u64,diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime/service_worker_runtime.rs b/moli-renderer-v8/src/runtime/browser_context_runtime/service_worker_runtime.rsindex a3a018f93..cb747b447 100644--- a/moli-renderer-v8/src/runtime/browser_context_runtime/service_worker_runtime.rs+++ b/moli-renderer-v8/src/runtime/browser_context_runtime/service_worker_runtime.rs@@ -414,6 +414,24 @@ impl RendererBrowserContextRuntime {.await}+ pub async fn dispatch_service_worker_runtime_protocol_message_with_devtools_session_response(+ &self,+ version_id: u64,+ inspector_session_id: String,+ raw_json: String,+ response: RendererRuntimeInspectorResponseSender,+ ) -> Result<crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch, String> {+ self.inner+ .service_worker_runtime+ .dispatch_runtime_protocol_message_with_devtools_session_response(+ ServiceWorkerVersionId::from_u64_for_binding(version_id),+ inspector_session_id,+ raw_json,+ response,+ )+ .await+ }+pub fn detach_service_worker_runtime_inspector_session(&self,version_id: u64,diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime/shared_workers.rs b/moli-renderer-v8/src/runtime/browser_context_runtime/shared_workers.rsindex 7806dc2c9..f19677784 100644--- a/moli-renderer-v8/src/runtime/browser_context_runtime/shared_workers.rs+++ b/moli-renderer-v8/src/runtime/browser_context_runtime/shared_workers.rs@@ -479,6 +479,24 @@ impl RendererBrowserContextRuntime {.await}+ pub async fn dispatch_shared_worker_runtime_protocol_message_with_devtools_session_response(+ &self,+ instance_id: SharedWorkerInstanceId,+ inspector_session_id: String,+ raw_json: String,+ response: RendererRuntimeInspectorResponseSender,+ ) -> Result<crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch, String> {+ self.inner+ .shared_worker_runtime+ .dispatch_runtime_protocol_message_with_devtools_session_response(+ instance_id,+ inspector_session_id,+ raw_json,+ response,+ )+ .await+ }+pub fn detach_shared_worker_runtime_inspector_session(&self,instance_id: SharedWorkerInstanceId,diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rsindex 8972bd1fc..f301b0c93 100644--- a/moli-renderer-v8/src/runtime/mod.rs+++ b/moli-renderer-v8/src/runtime/mod.rs@@ -307,7 +307,8 @@ pub use self::page_state::RendererPageState;use self::page_surface::RendererPageTable;pub use self::page_surface::RendererRuntimeInspectorMessageResponseOrder;pub use self::page_surface::{- DevToolsSessionKey, RendererAccessibilityPayloadsForObjectId, RendererActivityDiagnostics,+ CompletedWorkerRuntimeInspectorCommandDispatch, DevToolsSessionKey,+ RendererAccessibilityPayloadsForObjectId, RendererActivityDiagnostics,RendererAgentAttachmentId, RendererAutofillAddressField, RendererAutofillCreditCard,RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest,RendererCaptureScreencastFrameReply, RendererCaptureScreenshotReply,diff --git a/moli-renderer-v8/src/runtime/page_surface.rs b/moli-renderer-v8/src/runtime/page_surface.rsindex d0d1ee1a1..11d6e225b 100644--- a/moli-renderer-v8/src/runtime/page_surface.rs+++ b/moli-renderer-v8/src/runtime/page_surface.rs@@ -2740,6 +2740,50 @@ impl RendererRuntimeInspectorSessionResponseSettlement {}}+/// Result of one Worker Inspector command whose terminal response was+/// committed to the target's concrete renderer output stream.+///+/// The immediate messages contain only non-terminal Inspector output returned+/// by dispatch. The response itself is owned by `predecessor` and reaches the+/// frontend through the same target journal as surrounding Worker events.+#[derive(Debug)]+pub struct CompletedWorkerRuntimeInspectorCommandDispatch {+ messages: Vec<RendererRuntimeInspectorMessage>,+ predecessor: RendererOutputFence,+ response_succeeded: bool,+}++impl CompletedWorkerRuntimeInspectorCommandDispatch {+ pub fn into_parts(+ self,+ ) -> (+ Vec<RendererRuntimeInspectorMessage>,+ RendererOutputFence,+ bool,+ ) {+ (self.messages, self.predecessor, self.response_succeeded)+ }++ pub(crate) async fn finish(+ dispatch: Result<Vec<RendererRuntimeInspectorMessage>, String>,+ settlement: oneshot::Receiver<RendererRuntimeInspectorSessionResponseSettlement>,+ ) -> Result<Self, String> {+ match settlement.await {+ Ok(settlement) => {+ let (predecessor, response_succeeded) = settlement.into_parts();+ Ok(Self {+ messages: dispatch.unwrap_or_default(),+ predecessor,+ response_succeeded,+ })+ }+ Err(_) => Err(dispatch+ .err()+ .unwrap_or_else(|| "WorkerRuntimeInspectorResponseCanceled".to_owned())),+ }+ }+}+impl RendererRuntimeInspectorResponsePublication {pub(crate) fn commit(self,@@ -3248,7 +3292,7 @@ impl RendererRuntimeInspectorResponseLease {pub(crate) struct RendererDevToolsSessionOutputHost {agent_token: RendererDevToolsAgentToken,session: DevToolsSessionKey,- attachment_id: RendererAgentAttachmentId,+ attachment_id: Option<RendererAgentAttachmentId>,output_journal: RendererTurnOutputJournal,}@@ -3262,7 +3306,16 @@ impl RendererDevToolsSessionOutputHost {Self {agent_token,session,- attachment_id,+ attachment_id: Some(attachment_id),+ output_journal,+ }+ }++ fn for_worker(session_id: String, output_journal: RendererTurnOutputJournal) -> Self {+ Self {+ agent_token: output_journal.stream().renderer_agent(),+ session: DevToolsSessionKey::Attached(session_id),+ attachment_id: None,output_journal,}}@@ -3271,7 +3324,7 @@ impl RendererDevToolsSessionOutputHost {&self,completion: RendererRuntimeInspectorAsyncCompletion,) -> Result<RendererOutputFence, RendererRuntimeInspectorAsyncCompletion> {- if completion.renderer_agent_attachment_id() != Some(self.attachment_id) {+ if completion.renderer_agent_attachment_id() != self.attachment_id {return Err(completion);}if completion@@ -3293,7 +3346,9 @@ impl RendererDevToolsSessionOutputHost {messages,);batch.v8_state_update = v8_state_update;- batch.bind_renderer_agent_attachment(self.attachment_id);+ if let Some(attachment_id) = self.attachment_id {+ batch.bind_renderer_agent_attachment(attachment_id);+ }if !batch.has_resolved_source_identities() {return Err(completion);}@@ -3384,7 +3439,7 @@ impl RendererRuntimeInspectorResponseDestination {enum RendererRuntimeInspectorResponsePublicationBoundary {Immediate,PageOwner(RendererOwnerWakeSender),- SharedWorkerParent(tokio::sync::mpsc::UnboundedSender<crate::worker::WorkerToParentMessage>),+ WorkerParent(tokio::sync::mpsc::UnboundedSender<crate::worker::WorkerToParentMessage>),}#[derive(Clone)]@@ -3468,12 +3523,12 @@ impl RendererRuntimeInspectorResponseSender {self}- pub(crate) fn defer_publication_to_shared_worker_parent(+ pub(crate) fn defer_publication_to_worker_parent(mut self,parent_tx: tokio::sync::mpsc::UnboundedSender<crate::worker::WorkerToParentMessage>,) -> Self {self.publication_boundary =- RendererRuntimeInspectorResponsePublicationBoundary::SharedWorkerParent(parent_tx);+ RendererRuntimeInspectorResponsePublicationBoundary::WorkerParent(parent_tx);self}@@ -3484,8 +3539,7 @@ impl RendererRuntimeInspectorResponseSender {host: RendererDevToolsSessionOutputHost,) -> Self {assert_eq!(- self.attachment_id,- Some(host.attachment_id),+ self.attachment_id, host.attachment_id,"a DevTools session response host must belong to the command attachment");self.destination = match self.destination {@@ -3502,6 +3556,17 @@ impl RendererRuntimeInspectorResponseSender {self}+ pub(crate) fn route_to_worker_devtools_session_output(+ self,+ session_id: String,+ output_journal: RendererTurnOutputJournal,+ ) -> Self {+ self.route_to_devtools_session_output(RendererDevToolsSessionOutputHost::for_worker(+ session_id,+ output_journal,+ ))+ }+pub fn send(self, message: Value) -> Result<(), RendererRuntimeInspectorAsyncCompletion> {self.send_output(RendererRuntimeCommandOutput::from_inspector_message(RendererRuntimeInspectorMessage::from_v8_inspector_message(message),@@ -3533,16 +3598,15 @@ impl RendererRuntimeInspectorResponseSender {RendererRuntimeInspectorResponsePublicationBoundary::PageOwner(owner_wake) => {owner_wake.defer_runtime_inspector_response_publication(publication)}- RendererRuntimeInspectorResponsePublicationBoundary::SharedWorkerParent(parent_tx) => {+ RendererRuntimeInspectorResponsePublicationBoundary::WorkerParent(parent_tx) => {match parent_tx.send(- crate::worker::WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(- publication,- ),+ crate::worker::WorkerToParentMessage::RuntimeInspectorResponse(publication),) {Ok(()) => Ok(()),Err(error) => {- let crate::worker::WorkerToParentMessage::- SharedWorkerRuntimeInspectorResponse(publication) = error.0+ let crate::worker::WorkerToParentMessage::RuntimeInspectorResponse(+ publication,+ ) = error.0else {unreachable!("the failed send must return the submitted publication")};diff --git a/moli-renderer-v8/src/script_vm/worker_host_bridge_body.rs b/moli-renderer-v8/src/script_vm/worker_host_bridge_body.rsindex 3c0f436bd..f3121fbf8 100644--- a/moli-renderer-v8/src/script_vm/worker_host_bridge_body.rs+++ b/moli-renderer-v8/src/script_vm/worker_host_bridge_body.rs@@ -286,6 +286,27 @@ impl ScriptVm {instance_id,message,} => self.apply_shared_worker_host_bridge_record_body(instance_id, *message),+ WorkerRuntimeEvent::Message {+ message,+ worker_id: _,+ } if matches!(+ message.as_ref(),+ WorkerToParentMessage::RuntimeInspectorResponse(_)+ ) =>+ {+ let WorkerToParentMessage::RuntimeInspectorResponse(publication) = *message else {+ unreachable!("the guarded Worker response variant must still match")+ };+ let published = self+ ._context_host+ .borrow()+ .publish_worker_runtime_inspector_response(publication);+ Ok(if published {+ WorkerHostBridgeBodyEffect::StateAppliedWithoutPageContext+ } else {+ WorkerHostBridgeBodyEffect::ExactTargetUnavailable+ })+ }WorkerRuntimeEvent::Message { worker_id, message } => {self.apply_dedicated_worker_host_bridge_record_body(worker_id, *message)}@@ -470,7 +491,7 @@ impl ScriptVm {| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }| WorkerToParentMessage::SharedWorkerClosed- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_) => {}+ | WorkerToParentMessage::RuntimeInspectorResponse(_) => {}}Ok(())}diff --git a/moli-renderer-v8/src/service_worker_runtime/host.rs b/moli-renderer-v8/src/service_worker_runtime/host.rsindex e7ea573da..d355365b3 100644--- a/moli-renderer-v8/src/service_worker_runtime/host.rs+++ b/moli-renderer-v8/src/service_worker_runtime/host.rs@@ -854,9 +854,11 @@ fn spawn_parent_message_pump(messages,);}+ WorkerToParentMessage::RuntimeInspectorResponse(publication) => {+ let _ = publication.commit(None);+ }WorkerToParentMessage::Post(_)| WorkerToParentMessage::SharedWorkerClosed- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)| WorkerToParentMessage::SubresourceNetwork(_)| WorkerToParentMessage::PendingSubresourceFetch(_)| WorkerToParentMessage::PendingSubresourceFetchCanceled { .. }diff --git a/moli-renderer-v8/src/service_worker_runtime/service.rs b/moli-renderer-v8/src/service_worker_runtime/service.rsindex d422a4ed9..ca90c8ddc 100644--- a/moli-renderer-v8/src/service_worker_runtime/service.rs+++ b/moli-renderer-v8/src/service_worker_runtime/service.rs@@ -385,6 +385,13 @@ impl ServiceWorkerRuntimeService {Some(host.clone())}+ pub(super) fn target_output_journal(+ &self,+ version_id: ServiceWorkerVersionId,+ ) -> Option<crate::runtime::RendererTurnOutputJournal> {+ self.inner.state.lock().target_output_journal(version_id)+ }+pub(super) fn enqueue_target_console_message(&self,version_id: ServiceWorkerVersionId,diff --git a/moli-renderer-v8/src/service_worker_runtime/service/runtime_protocol.rs b/moli-renderer-v8/src/service_worker_runtime/service/runtime_protocol.rsindex 3761766a3..c18a9dea9 100644--- a/moli-renderer-v8/src/service_worker_runtime/service/runtime_protocol.rs+++ b/moli-renderer-v8/src/service_worker_runtime/service/runtime_protocol.rs@@ -38,6 +38,35 @@ impl ServiceWorkerRuntimeService {.await}+ pub(crate) async fn dispatch_runtime_protocol_message_with_devtools_session_response(+ &self,+ version_id: ServiceWorkerVersionId,+ inspector_session_id: String,+ raw_json: String,+ response: RendererRuntimeInspectorResponseSender,+ ) -> Result<crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch, String> {+ let Some(host) = self.running_host_for_version(version_id) else {+ return Err("ServiceWorkerRuntimeUnavailable".to_owned());+ };+ let Some(output_journal) = self.target_output_journal(version_id) else {+ return Err("ServiceWorkerRuntimeUnavailable".to_owned());+ };+ let response = response+ .route_to_worker_devtools_session_output(inspector_session_id.clone(), output_journal);+ let settlement = response+ .take_session_response_settlement_receiver()+ .expect("a Worker DevTools response must own one settlement receiver");+ let dispatch = host+ .dispatch_worker_runtime_protocol_message_with_deferred_response(+ Some(inspector_session_id),+ raw_json,+ response,+ )+ .await;+ crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch::finish(dispatch, settlement)+ .await+ }+pub(crate) fn detach_runtime_inspector_session(&self,version_id: ServiceWorkerVersionId,diff --git a/moli-renderer-v8/src/service_worker_runtime/state.rs b/moli-renderer-v8/src/service_worker_runtime/state.rsindex ae9560b69..bb397bde3 100644--- a/moli-renderer-v8/src/service_worker_runtime/state.rs+++ b/moli-renderer-v8/src/service_worker_runtime/state.rs@@ -355,6 +355,13 @@ impl ServiceWorkerRuntimeState {self.live_target_run(version_id).as_ref() == Some(run)}+ pub(super) fn target_output_journal(+ &self,+ version_id: ServiceWorkerVersionId,+ ) -> Option<crate::runtime::RendererTurnOutputJournal> {+ self.target_output_streams.journal(version_id)+ }+pub(super) fn record_target_created(&mut self,registration_id: ServiceWorkerRegistrationId,diff --git a/moli-renderer-v8/src/service_worker_runtime/target_output_streams.rs b/moli-renderer-v8/src/service_worker_runtime/target_output_streams.rsindex 9539d4770..02c82daf4 100644--- a/moli-renderer-v8/src/service_worker_runtime/target_output_streams.rs+++ b/moli-renderer-v8/src/service_worker_runtime/target_output_streams.rs@@ -92,6 +92,13 @@ impl ServiceWorkerTargetOutputStreams {journal.publish_record(Self::record(event));}+ pub(super) fn journal(+ &self,+ version_id: ServiceWorkerVersionId,+ ) -> Option<RendererTurnOutputJournal> {+ self.state.lock().live.get(&version_id).cloned()+ }+pub(super) fn publish_destroyed(&self,version_id: ServiceWorkerVersionId,diff --git a/moli-renderer-v8/src/shared_worker_runtime/events.rs b/moli-renderer-v8/src/shared_worker_runtime/events.rsindex dffbb5090..bc81e89af 100644--- a/moli-renderer-v8/src/shared_worker_runtime/events.rs+++ b/moli-renderer-v8/src/shared_worker_runtime/events.rs@@ -52,7 +52,7 @@ impl RendererSharedWorkerHost {self.begin_runtime_response_retirement();self.notify_worker_closed();}- WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(publication) => {+ WorkerToParentMessage::RuntimeInspectorResponse(publication) => {self.publish_runtime_inspector_response(publication);}WorkerToParentMessage::ServiceWorkerLifecycleCompleted(_) => {diff --git a/moli-renderer-v8/src/shared_worker_runtime/protocol_routing.rs b/moli-renderer-v8/src/shared_worker_runtime/protocol_routing.rsindex 9d470368e..92b577da0 100644--- a/moli-renderer-v8/src/shared_worker_runtime/protocol_routing.rs+++ b/moli-renderer-v8/src/shared_worker_runtime/protocol_routing.rs@@ -36,6 +36,34 @@ impl SharedWorkerRuntimeService {.await}+ pub(crate) async fn dispatch_runtime_protocol_message_with_devtools_session_response(+ &self,+ instance_id: SharedWorkerInstanceId,+ inspector_session_id: String,+ raw_json: String,+ response: RendererRuntimeInspectorResponseSender,+ ) -> Result<crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch, String> {+ let Some(host) = self.running_host_for_instance(instance_id) else {+ return Err("SharedWorkerRuntimeUnavailable".to_owned());+ };+ let response = response.route_to_worker_devtools_session_output(+ inspector_session_id.clone(),+ host.target_output().clone(),+ );+ let settlement = response+ .take_session_response_settlement_receiver()+ .expect("a Worker DevTools response must own one settlement receiver");+ let dispatch = host+ .dispatch_runtime_protocol_message_with_deferred_response(+ Some(inspector_session_id),+ raw_json,+ response,+ )+ .await;+ crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch::finish(dispatch, settlement)+ .await+ }+pub(crate) fn detach_runtime_inspector_session(&self,instance_id: SharedWorkerInstanceId,diff --git a/moli-renderer-v8/src/worker/handle.rs b/moli-renderer-v8/src/worker/handle.rsindex 53e883c4b..91e00e446 100644--- a/moli-renderer-v8/src/worker/handle.rs+++ b/moli-renderer-v8/src/worker/handle.rs@@ -289,16 +289,14 @@ pub(crate) enum WorkerToParentMessage {Console(WorkerConsoleMessage),/// A SharedWorker global is closing and its owner service should remove the instance.SharedWorkerClosed,- /// A SharedWorker V8 Inspector response waiting for the worker target's- /// concrete output boundary.+ /// A V8 Inspector response waiting for its Worker target's concrete output+ /// boundary.///- /// This travels on the same worker-to-parent FIFO as `SharedWorkerClosed`.- /// The host can therefore bind the response to the exact worker-stream- /// cursor that precedes it instead of racing a separate response channel- /// against target retirement.- SharedWorkerRuntimeInspectorResponse(- crate::runtime::RendererRuntimeInspectorResponsePublication,- ),+ /// This travels on the same worker-to-parent FIFO as lifecycle and runtime+ /// observations. The host can therefore bind the response to the exact+ /// target-stream cursor that precedes it instead of racing a separate+ /// response channel against target retirement.+ RuntimeInspectorResponse(crate::runtime::RendererRuntimeInspectorResponsePublication),/// A Service Worker lifecycle event finished dispatch and all `waitUntil()` promises.ServiceWorkerLifecycleCompleted(ServiceWorkerLifecycleCompletion),/// A Service Worker fetch event finished dispatch and `respondWith()` settled or fell back.diff --git a/moli-renderer-v8/src/worker/thread/runtime_inspector.rs b/moli-renderer-v8/src/worker/thread/runtime_inspector.rsindex 41711872d..2c61d4701 100644--- a/moli-renderer-v8/src/worker/thread/runtime_inspector.rs+++ b/moli-renderer-v8/src/worker/thread/runtime_inspector.rs@@ -526,13 +526,16 @@ impl WorkerRuntimeInspector {deferred_response,response_tx,} => {- let deferred_response = if self.shared_worker {- deferred_response.map(|response| {- response.defer_publication_to_shared_worker_parent(self.parent_tx.clone())- })- } else {- deferred_response- };+ let deferred_response = deferred_response.map(|response| {+ if self.shared_worker+ || response.response_delivery()+ == moli_page_types::RendererInspectorResponseDelivery::DevToolsSession+ {+ response.defer_publication_to_worker_parent(self.parent_tx.clone())+ } else {+ response+ }+ });let result = with_scoped_inspector_microtasks(isolate, || {self.dispatch_protocol_message_scoped(inspector_session_id.as_deref(),diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle.rsindex 7ba4c1be6..f70ea2a41 100644--- a/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs+++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs@@ -1855,7 +1855,7 @@ async fn dispatch_service_worker_fetch_event_and_handled_console_for_test(| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}if let (Some(completion), Some(handled_console)) =@@ -2253,7 +2253,7 @@ async fn service_worker_fetch_respond_with_readable_stream_body_posts_stream_chu| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -4262,7 +4262,7 @@ async fn service_worker_skip_waiting_posts_runtime_request() {| WorkerToParentMessage::Console(_)| WorkerToParentMessage::RuntimeInspectorMessages(_)| WorkerToParentMessage::Post(_)- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -4352,7 +4352,7 @@ async fn service_worker_clients_claim_posts_runtime_request() {| WorkerToParentMessage::RuntimeInspectorMessages(_)| WorkerToParentMessage::Post(_)| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -4620,7 +4620,7 @@ async fn service_worker_clients_match_all_and_get_resolve_from_parent_query_resu| WorkerToParentMessage::RuntimeInspectorMessages(_)| WorkerToParentMessage::Post(_)| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -4739,7 +4739,7 @@ async fn service_worker_worker_client_query_builds_base_client_object() {}WorkerToParentMessage::Console(_)| WorkerToParentMessage::RuntimeInspectorMessages(_)- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}other => panic!("unexpected worker message: {other:?}"),}@@ -4929,7 +4929,7 @@ self.addEventListener("message", event => {| WorkerToParentMessage::RuntimeInspectorMessages(_)| WorkerToParentMessage::Post(_)| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -5073,7 +5073,7 @@ self.addEventListener("message", event => {| WorkerToParentMessage::RuntimeInspectorMessages(_)| WorkerToParentMessage::Post(_)| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -5285,7 +5285,7 @@ self.addEventListener("message", event => {| WorkerToParentMessage::RuntimeInspectorMessages(_)| WorkerToParentMessage::Post(_)| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -5429,7 +5429,7 @@ self.addEventListener("message", event => {| WorkerToParentMessage::RuntimeInspectorMessages(_)| WorkerToParentMessage::Post(_)| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -5646,7 +5646,7 @@ self.addEventListener("message", event => {| WorkerToParentMessage::RuntimeInspectorMessages(_)| WorkerToParentMessage::Post(_)| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}WorkerToParentMessage::ServiceWorkerClientsOpenWindow(open_window) => {panic!(@@ -7098,7 +7098,7 @@ self.addEventListener("notificationclick", event => {| WorkerToParentMessage::RuntimeInspectorMessages(_)| WorkerToParentMessage::Post(_)| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -7258,7 +7258,7 @@ self.addEventListener("notificationclose", event => {| WorkerToParentMessage::RuntimeInspectorMessages(_)| WorkerToParentMessage::Post(_)| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -9467,7 +9467,7 @@ async fn worker_error_report_ignores_throwing_accessors() {| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => panic!("expected worker error"),}}diff --git a/moli-renderer-v8/src/worker/thread/tests/mod.rs b/moli-renderer-v8/src/worker/thread/tests/mod.rsindex 513bedaaf..bd002398f 100644--- a/moli-renderer-v8/src/worker/thread/tests/mod.rs+++ b/moli-renderer-v8/src/worker/thread/tests/mod.rs@@ -368,7 +368,7 @@ async fn dispatch_service_worker_lifecycle_event_for_test(| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -464,7 +464,7 @@ async fn dispatch_service_worker_fetch_event_with_request_for_test(| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -550,7 +550,7 @@ async fn dispatch_service_worker_message_event_object_for_test(| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -613,7 +613,7 @@ async fn dispatch_service_worker_notification_event_for_test(| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -682,7 +682,7 @@ async fn dispatch_service_worker_push_event_for_test(| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -753,7 +753,7 @@ async fn dispatch_service_worker_sync_event_for_test(| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}@@ -825,7 +825,7 @@ async fn dispatch_service_worker_periodic_sync_event_for_test(| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)+ | WorkerToParentMessage::RuntimeInspectorResponse(_)| WorkerToParentMessage::SharedWorkerClosed => {}}}