Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(webdriver): project BiDi hook predecessors
ldm019ad99cf154c
diff --git a/moli/src/cdp_scheduler.rs b/moli/src/cdp_scheduler.rsindex a9cad0b6d..7461a8409 100644--- a/moli/src/cdp_scheduler.rs+++ b/moli/src/cdp_scheduler.rs@@ -933,13 +933,15 @@ impl CdpScheduler {pub(crate) async fn execute_internal_protocol_message(&mut self,+ receivers: &mut CdpSchedulerEventReceivers,message: Value,- ) -> ProtocolOutputSequence {+ ) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {let outcome = self.conn.process_message_with_turn_outcome_async(&message.to_string()).await;- self.apply_turn_outcome(outcome)+ self.apply_turn_outcome_at_renderer_owner_boundary(receivers, outcome)+ .await}pub(crate) fn enable_network_listener_for_target(&mut self, target_id: &str) -> bool {@@ -980,30 +982,34 @@ impl CdpScheduler {pub(crate) async fn enable_runtime_listener_for_target(&mut self,+ receivers: &mut CdpSchedulerEventReceivers,target_id: &str,- ) -> ProtocolOutputSequence {+ ) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {let Some(outcome) = self.conn.enable_runtime_listener_for_target(target_id).awaitelse {- return ProtocolOutputSequence::empty();+ return Ok(ProtocolOutputSequence::empty());};- self.apply_turn_outcome(outcome)+ self.apply_turn_outcome_at_renderer_owner_boundary(receivers, outcome)+ .await}pub(crate) async fn disable_runtime_listener_for_target(&mut self,+ receivers: &mut CdpSchedulerEventReceivers,target_id: &str,- ) -> ProtocolOutputSequence {+ ) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {let Some(outcome) = self.conn.disable_runtime_listener_for_target(target_id).awaitelse {- return ProtocolOutputSequence::empty();+ return Ok(ProtocolOutputSequence::empty());};- self.apply_turn_outcome(outcome)+ self.apply_turn_outcome_at_renderer_owner_boundary(receivers, outcome)+ .await}pub(crate) fn replace_target_discovery_enabled(&mut self, enabled: bool) -> bool {@@ -1970,6 +1976,33 @@ impl CdpScheduler {output}+ async fn apply_turn_outcome_at_renderer_owner_boundary(+ &mut self,+ receivers: &mut CdpSchedulerEventReceivers,+ outcome: moli_protocol::CdpTurnOutcome,+ ) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {+ let (output, post_renderer_output, renderer_output_boundary, renderer_output_predecessor) =+ self.materialize_turn_outcome(outcome);+ assert!(+ renderer_output_boundary.is_none(),+ "non-navigation owner turn must not carry a renderer insertion boundary"+ );++ let mut causal_output = ProtocolOutputSequence::empty();+ if let Some(predecessor) = renderer_output_predecessor {+ causal_output.append(+ self.project_renderer_output_predecessor_before_devtools_result(+ receivers,+ &predecessor,+ )+ .await?,+ );+ }+ causal_output.append(output);+ causal_output.append(post_renderer_output);+ Ok(causal_output)+ }+fn materialize_turn_outcome(&mut self,outcome: moli_protocol::CdpTurnOutcome,diff --git a/moli/src/protocol_server/tests/bidi.rs b/moli/src/protocol_server/tests/bidi.rsindex 56a567c76..99e6757e6 100644--- a/moli/src/protocol_server/tests/bidi.rs+++ b/moli/src/protocol_server/tests/bidi.rs@@ -797,6 +797,101 @@ async fn websocket_bidi_classic_session_omits_synthetic_service_worker_runtime()protocol_server.abort();}+#[tokio::test]+async fn websocket_bidi_shared_worker_subscription_projects_runtime_listener_predecessor() {+ let (fixture_addr, _fixture_server) = spawn_shared_worker_fixture_server("bidi-shared-worker");+ let page_url = format!("http://{fixture_addr}/");+ let worker_url = format!("http://{fixture_addr}/shared-worker.js");++ let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;+ let (mut socket, context_id) = bidi_session_with_context(cdp_addr).await;++ let navigate = send_bidi_command_response(+ &mut socket,+ 3,+ "browsingContext.navigate",+ json!({+ "context": context_id.clone(),+ "url": page_url,+ "wait": "complete"+ }),+ )+ .await;+ assert_eq!(navigate["type"], json!("success"), "{navigate:?}");++ let subscribe = send_bidi_command_response(+ &mut socket,+ 4,+ "session.subscribe",+ json!({+ "events": [+ "browsingContext.contextCreated",+ "script.realmCreated"+ ]+ }),+ )+ .await;+ assert_eq!(subscribe["type"], json!("success"), "{subscribe:?}");++ socket+ .send(WsMessage::Text(+ json!({+ "id": 5_u64,+ "method": "script.evaluate",+ "params": {+ "expression": "globalThis.__sharedWorkerProbe('bidi').then(value => JSON.stringify(value))",+ "target": { "context": context_id },+ "awaitPromise": true+ }+ })+ .to_string()+ .into(),+ ))+ .await+ .expect("send shared worker script.evaluate");+ let messages = recv_until_id(&mut socket, 5).await;+ let messages = collect_bidi_messages_until(+ &mut socket,+ messages,+ |messages| {+ let saw_context = messages.iter().any(|message| {+ message["method"] == json!("browsingContext.contextCreated")+ && message["params"]["url"] == json!(worker_url)+ });+ let saw_realm = messages.iter().any(|message| {+ message["method"] == json!("script.realmCreated")+ && message["params"]["type"] == json!("shared-worker")+ });+ saw_context && saw_realm+ },+ "shared worker context and realm events",+ )+ .await;++ let evaluate = bidi_message_by_id(&messages, 5);+ assert_eq!(evaluate["type"], json!("success"), "{messages:#?}");+ let probe: serde_json::Value = serde_json::from_str(+ evaluate["result"]["result"]["value"]+ .as_str()+ .expect("shared worker probe JSON string"),+ )+ .expect("parse shared worker probe JSON");+ assert_eq!(probe["echoed"], json!("bidi"));+ assert_eq!(probe["isSharedWorker"], json!(true));++ let end = send_bidi_command_response(&mut socket, 6, "session.end", json!({})).await;+ assert_eq!(end["type"], json!("success"), "{end:?}");+ let closed = timeout(Duration::from_secs(1), socket.next())+ .await+ .expect("BiDi socket should close after releasing shared worker event sources");+ assert!(matches!(+ closed,+ Some(Ok(WsMessage::Close(_))) | None | Some(Err(_))+ ));++ protocol_server.abort();+}+#[tokio::test]async fn websocket_bidi_session_registry_allocates_unique_ids_across_connections() {let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;diff --git a/moli/src/protocol_server/tests/classic.rs b/moli/src/protocol_server/tests/classic.rsindex 453dfde2f..1946aedb4 100644--- a/moli/src/protocol_server/tests/classic.rs+++ b/moli/src/protocol_server/tests/classic.rs@@ -13823,7 +13823,8 @@ async fn webdriver_classic_service_worker_projection_does_not_pollute_window_han#[tokio::test]async fn webdriver_classic_shared_worker_reuses_instance_and_does_not_pollute_window_handles() {- let (fixture_addr, _fixture_server) = spawn_classic_shared_worker_fixture_server();+ let (fixture_addr, _fixture_server) =+ spawn_shared_worker_fixture_server("classic-shared-worker");let app = build_router(test_state());let session = classic_request_json(app.clone(), Method::POST, "/session").await;@@ -16643,48 +16644,6 @@ fn spawn_classic_service_worker_fixture_server() -> (std::net::SocketAddr, Dedicspawn_dedicated_fixture_server(app, "classic-service-worker")}-fn spawn_classic_shared_worker_fixture_server() -> (std::net::SocketAddr, DedicatedFixtureServer) {- let app = Router::new()- .route(- "/",- get(|| async move {- (- [(header::CONTENT_TYPE.as_str(), "text/html")],- "<!doctype html><html><body>classic shared worker</body></html>",- )- }),- )- .route(- "/shared-worker.js",- get(|| async move {- (- [(header::CONTENT_TYPE.as_str(), "text/javascript")],- "globalThis.__classicSharedWorkerConnectCount = 0;\- self.onconnect = event => {\- globalThis.__classicSharedWorkerConnectCount += 1;\- const port = event.ports[0];\- port.onmessage = message => {\- const data = message.data;\- if (data && data.kind === 'probe') {\- port.postMessage({\- kind: 'probe-result',\- echoed: data.value,\- name,\- pathname: self.location.pathname,\- isSharedWorker: typeof SharedWorkerGlobalScope !== 'undefined' && self instanceof SharedWorkerGlobalScope,\- selfEqualsGlobal: self === globalThis,\- connectCount: globalThis.__classicSharedWorkerConnectCount\- });\- }\- };\- port.start();\- };",- )- }),- );- spawn_dedicated_fixture_server(app, "classic-shared-worker")-}-async fn classic_switch_to_child_frame_and_remove_current_frame(app: Router,session_id: &str,diff --git a/moli/src/protocol_server/tests/mod.rs b/moli/src/protocol_server/tests/mod.rsindex 38db0cf98..9be2b7664 100644--- a/moli/src/protocol_server/tests/mod.rs+++ b/moli/src/protocol_server/tests/mod.rs@@ -3,7 +3,7 @@ use axum::{Router,body::{Body, to_bytes},extract::{WebSocketUpgrade, ws::Message},- http::{Method, Request, StatusCode},+ http::{Method, Request, StatusCode, header},response::IntoResponse,routing::{get, post},};@@ -94,6 +94,65 @@ fn spawn_dedicated_fixture_server()}+fn spawn_shared_worker_fixture_server(+ name: &'static str,+) -> (std::net::SocketAddr, DedicatedFixtureServer) {+ let app = Router::new()+ .route(+ "/",+ get(|| async move {+ (+ [(header::CONTENT_TYPE.as_str(), "text/html")],+ r#"<!doctype html><html><body>shared worker+<script>+globalThis.__sharedWorkerProbe = value => new Promise((resolve, reject) => {+ const timer = setTimeout(() => reject(new Error('shared worker timeout')), 1000);+ const worker = new SharedWorker('/shared-worker.js', 'webdriver-shared-worker-smoke');+ globalThis.__sharedWorkerSmoke = worker;+ worker.port.onmessage = event => {+ if (event.data && event.data.kind === 'probe-result') {+ clearTimeout(timer);+ resolve(event.data);+ }+ };+ worker.port.start();+ worker.port.postMessage({ kind: 'probe', value });+});+</script></body></html>"#,+ )+ }),+ )+ .route(+ "/shared-worker.js",+ get(|| async move {+ (+ [(header::CONTENT_TYPE.as_str(), "text/javascript")],+ "globalThis.__sharedWorkerConnectCount = 0;\+ self.onconnect = event => {\+ globalThis.__sharedWorkerConnectCount += 1;\+ const port = event.ports[0];\+ port.onmessage = message => {\+ const data = message.data;\+ if (data && data.kind === 'probe') {\+ port.postMessage({\+ kind: 'probe-result',\+ echoed: data.value,\+ name,\+ pathname: self.location.pathname,\+ isSharedWorker: typeof SharedWorkerGlobalScope !== 'undefined' && self instanceof SharedWorkerGlobalScope,\+ selfEqualsGlobal: self === globalThis,\+ connectCount: globalThis.__sharedWorkerConnectCount\+ });\+ }\+ };\+ port.start();\+ };",+ )+ }),+ );+ spawn_dedicated_fixture_server(app, name)+}+fn wait_for_dedicated_fixture_ready(addr: std::net::SocketAddr, name: &'static str) {let mut stream = std::net::TcpStream::connect(addr).unwrap_or_else(|error| panic!("connect to {name} fixture readiness route: {error}"));diff --git a/moli/src/protocol_server/webdriver_bidi.rs b/moli/src/protocol_server/webdriver_bidi.rsindex 5158d903f..aad4a1b7f 100644--- a/moli/src/protocol_server/webdriver_bidi.rs+++ b/moli/src/protocol_server/webdriver_bidi.rs@@ -52,6 +52,7 @@ use crate::cdp_scheduler::{CdpScheduler, CdpSchedulerEventReceivers, DevToolsRuntimeCommandProgress,PendingDevToolsRuntimeDeferredReplyExecution, ProtocolAdapterScheduler,ProtocolAdapterSchedulerAdvance, ProtocolAdapterSchedulerInput, ProtocolOutputSequence,+ RendererOutputTransportFailure,};use super::webdriver_files::selected_files_from_paths;@@ -251,7 +252,9 @@ async fn handle_bidi_session_socket_local(}}}- actor.release_event_sources(&mut scheduler).await;+ actor+ .release_event_sources(&mut scheduler, &mut receivers)+ .await;actor.release_session(&mut session_registry.lock());CookieProfileCommit::from_optional_profile_backed_snapshot(initial_cookie_snapshot,@@ -323,10 +326,19 @@ impl BidiSocketActor {pub(in crate::protocol_server) async fn release_event_sources(&mut self,scheduler: &mut CdpScheduler,+ receivers: &mut CdpSchedulerEventReceivers,) {self.release_pending_runtime_command_state(scheduler);let plan = self.bidi.release_event_source_hook_plan();- let _ = execute_bidi_event_source_hook_plan(scheduler, &mut self.bidi, &plan).await;+ let mut events = Vec::new();+ let _ = append_bidi_event_source_hook_plan_events(+ scheduler,+ receivers,+ &mut self.bidi,+ &plan,+ &mut events,+ )+ .await;}fn release_pending_runtime_command_state(&mut self, scheduler: &mut CdpScheduler) {@@ -485,7 +497,8 @@ impl BidiSocketActor {if self.pending_runtime_command.is_none() {return send_bidi_protocol_output(&mut self.socket,- Some(scheduler),+ scheduler,+ receivers,&mut self.bidi,output,owner_context,@@ -506,7 +519,8 @@ impl BidiSocketActor {let Some(mut pending_command) = self.pending_runtime_command.take() else {return send_bidi_protocol_output(&mut self.socket,- Some(scheduler),+ scheduler,+ receivers,&mut self.bidi,output,None,@@ -535,7 +549,8 @@ impl BidiSocketActor {let output = scheduler.route_registered_runtime_inspector_response(response);return send_bidi_protocol_output(&mut self.socket,- Some(scheduler),+ scheduler,+ receivers,&mut self.bidi,output,None,@@ -586,7 +601,8 @@ impl BidiSocketActor {pending_command.pending = Some(pending);let sent = send_bidi_protocol_output(&mut self.socket,- Some(scheduler),+ scheduler,+ receivers,&mut self.bidi,protocol_output,None,@@ -799,8 +815,17 @@ async fn handle_bidi_socket_message(&initial_sources,pending.completion.event_context.as_deref(),);- append_context_created_event_source_hook_events(scheduler, bidi, &mut bidi_events)- .await;+ if !append_context_created_event_source_hook_events(+ scheduler,+ receivers,+ bidi,+ &mut bidi_events,+ )+ .await+ {+ let _ = send_bidi_json_events(socket, bidi_events).await;+ return false;+ }if !send_bidi_json_events(socket, bidi_events).await {return false;}@@ -845,15 +870,34 @@ async fn handle_bidi_socket_message(&command_output.event_sources,command_output.event_context.as_deref(),);- if !renderer_output_transport_terminal {- append_context_created_event_source_hook_events(scheduler, bidi, &mut bidi_events).await;+ if !renderer_output_transport_terminal+ && !append_context_created_event_source_hook_events(+ scheduler,+ receivers,+ bidi,+ &mut bidi_events,+ )+ .await+ {+ let _ = send_bidi_json_events(socket, bidi_events).await;+ return false;}if command_method.as_deref() == Some("session.subscribe")&& command_output.response["type"] == json!("success")&& !renderer_output_transport_terminal{- if let Some(plan) = subscribe_hook_plan.as_ref() {- bidi_events.extend(execute_bidi_event_source_hook_plan(scheduler, bidi, plan).await);+ if let Some(plan) = subscribe_hook_plan.as_ref()+ && !append_bidi_event_source_hook_plan_events(+ scheduler,+ receivers,+ bidi,+ plan,+ &mut bidi_events,+ )+ .await+ {+ let _ = send_bidi_json_events(socket, bidi_events).await;+ return false;}bidi_events.extend(replay_existing_bidi_realm_created_events(@@ -865,21 +909,36 @@ async fn handle_bidi_socket_message();bidi_events.extend(bidi.replay_buffered_bidi_log_entry_events_for_subscriptions());}- bidi_events- .extend(execute_bidi_event_source_hook_plan(scheduler, bidi, &command_hook_plan).await);+ if !append_bidi_event_source_hook_plan_events(+ scheduler,+ receivers,+ bidi,+ &command_hook_plan,+ &mut bidi_events,+ )+ .await+ {+ let _ = send_bidi_json_events(socket, bidi_events).await;+ return false;+ }let mut post_response_bidi_events = subscribed_bidi_events_from_devtools_event_sources(Some(&*scheduler),bidi,&command_output.post_response_event_sources,command_output.event_context.as_deref(),);- if !renderer_output_transport_terminal {- append_context_created_event_source_hook_events(+ if !renderer_output_transport_terminal+ && !append_context_created_event_source_hook_events(scheduler,+ receivers,bidi,&mut post_response_bidi_events,)- .await;+ .await+ {+ let _ = send_bidi_json_events(socket, bidi_events).await;+ let _ = send_bidi_json_events(socket, post_response_bidi_events).await;+ return false;}if !send_bidi_json_events(socket, bidi_events).await {return false;@@ -1002,24 +1061,48 @@ async fn complete_and_send_bidi_pending_runtime_command(&command_output.event_sources,command_output.event_context.as_deref(),);- if !renderer_output_transport_terminal {- append_context_created_event_source_hook_events(scheduler, bidi, &mut bidi_events).await;+ if !renderer_output_transport_terminal+ && !append_context_created_event_source_hook_events(+ scheduler,+ receivers,+ bidi,+ &mut bidi_events,+ )+ .await+ {+ let _ = send_bidi_json_events(socket, bidi_events).await;+ return false;+ }+ if !append_bidi_event_source_hook_plan_events(+ scheduler,+ receivers,+ bidi,+ &command_hook_plan,+ &mut bidi_events,+ )+ .await+ {+ let _ = send_bidi_json_events(socket, bidi_events).await;+ return false;}- bidi_events- .extend(execute_bidi_event_source_hook_plan(scheduler, bidi, &command_hook_plan).await);let mut post_response_bidi_events = subscribed_bidi_events_from_devtools_event_sources(Some(&*scheduler),bidi,&command_output.post_response_event_sources,command_output.event_context.as_deref(),);- if !renderer_output_transport_terminal {- append_context_created_event_source_hook_events(+ if !renderer_output_transport_terminal+ && !append_context_created_event_source_hook_events(scheduler,+ receivers,bidi,&mut post_response_bidi_events,)- .await;+ .await+ {+ let _ = send_bidi_json_events(socket, bidi_events).await;+ let _ = send_bidi_json_events(socket, post_response_bidi_events).await;+ return false;}if !send_bidi_json_events(socket, bidi_events).await {return false;@@ -1106,13 +1189,17 @@ async fn drain_and_send_bidi_navigation_after_response(&background_navigation_sources,event_context,);- if transport_is_live {- append_context_created_event_source_hook_events(+ if transport_is_live+ && !append_context_created_event_source_hook_events(scheduler,+ receivers,bidi,&mut background_navigation_events,)- .await;+ .await+ {+ let _ = send_bidi_json_events(socket, background_navigation_events).await;+ return false;}if !send_bidi_json_events(socket, background_navigation_events).await {return false;@@ -1149,36 +1236,74 @@ fn bidi_command_channel_from_message(message: &serde_json::Value) -> Result<Opti}}-async fn execute_bidi_event_source_hook_plan(+async fn append_bidi_event_source_hook_plan_events(scheduler: &mut CdpScheduler,+ receivers: &mut CdpSchedulerEventReceivers,bidi: &mut BidiConnectionState,plan: &BidiEventSourceHookPlan,-) -> Vec<Value> {- let mut events = Vec::new();+ events: &mut Vec<Value>,+) -> bool {+ match try_append_bidi_event_source_hook_plan_events(scheduler, receivers, bidi, plan, events)+ .await+ {+ Ok(()) => true,+ Err(error) => {+ warn!(+ ?error,+ "BiDi event-source owner turn lost its renderer transport"+ );+ false+ }+ }+}++async fn try_append_bidi_event_source_hook_plan_events(+ scheduler: &mut CdpScheduler,+ receivers: &mut CdpSchedulerEventReceivers,+ bidi: &mut BidiConnectionState,+ plan: &BidiEventSourceHookPlan,+ events: &mut Vec<Value>,+) -> Result<(), DevToolsError> {if let Some(contexts) = plan.runtime_contexts() {if contexts.is_empty() {- let runtime_enable_output = enable_bidi_runtime_protocol_sources(scheduler).await;+ let runtime_enable_result =+ enable_bidi_runtime_protocol_sources(scheduler, receivers).await;+ let runtime_enable_output = materialize_bidi_event_source_hook_output(+ scheduler,+ bidi,+ events,+ runtime_enable_result,+ None,+ )?;if !runtime_enable_output.is_empty() && plan.runtime_events_enabled() {bidi.record_bidi_runtime_events_opened();}extend_bidi_events_from_protocol_output(Some(&*scheduler),bidi,- &mut events,+ events,runtime_enable_output,None,);} else {for context in contexts {- let runtime_enable_output =- scheduler.enable_runtime_listener_for_target(context).await;+ let runtime_enable_result = scheduler+ .enable_runtime_listener_for_target(receivers, context)+ .await;+ let runtime_enable_output = materialize_bidi_event_source_hook_output(+ scheduler,+ bidi,+ events,+ runtime_enable_result,+ Some(context),+ )?;if !runtime_enable_output.is_empty() && plan.records_runtime_context_ownership() {bidi.record_bidi_runtime_event_source_opened(context);}extend_bidi_events_from_protocol_output(Some(&*scheduler),bidi,- &mut events,+ events,runtime_enable_output,Some(context),);@@ -1186,15 +1311,31 @@ async fn execute_bidi_event_source_hook_plan(}}if plan.runtime_events_disabled() {- let runtime_disable_output = disable_bidi_runtime_protocol_sources(scheduler).await;+ let runtime_disable_result =+ disable_bidi_runtime_protocol_sources(scheduler, receivers).await;+ let runtime_disable_output = materialize_bidi_event_source_hook_output(+ scheduler,+ bidi,+ events,+ runtime_disable_result,+ None,+ )?;if !runtime_disable_output.is_empty() {bidi.record_bidi_runtime_events_closed();}}if let Some(contexts) = plan.runtime_disabled_contexts() {for context in contexts {- let runtime_disable_output =- scheduler.disable_runtime_listener_for_target(context).await;+ let runtime_disable_result = scheduler+ .disable_runtime_listener_for_target(receivers, context)+ .await;+ let runtime_disable_output = materialize_bidi_event_source_hook_output(+ scheduler,+ bidi,+ events,+ runtime_disable_result,+ Some(context),+ )?;if !runtime_disable_output.is_empty() {bidi.record_bidi_runtime_event_source_closed(context);}@@ -1202,11 +1343,19 @@ async fn execute_bidi_event_source_hook_plan(}if let Some(contexts) = plan.network_contexts() {if contexts.is_empty() {- let network_enable_output = enable_bidi_network_protocol_sources(scheduler).await;+ let network_enable_result =+ enable_bidi_network_protocol_sources(scheduler, receivers).await;+ let network_enable_output = materialize_bidi_event_source_hook_output(+ scheduler,+ bidi,+ events,+ network_enable_result,+ None,+ )?;extend_bidi_events_from_protocol_output(Some(&*scheduler),bidi,- &mut events,+ events,network_enable_output,None,);@@ -1245,12 +1394,36 @@ async fn execute_bidi_event_source_hook_plan(if plan.download_events_disabled() && scheduler.disable_webdriver_bidi_download_events() {bidi.record_bidi_download_event_source_closed();}- events+ Ok(())+}++fn materialize_bidi_event_source_hook_output(+ scheduler: &CdpScheduler,+ bidi: &mut BidiConnectionState,+ events: &mut Vec<Value>,+ result: Result<ProtocolOutputSequence, RendererOutputTransportFailure>,+ owner_context: Option<&str>,+) -> Result<ProtocolOutputSequence, DevToolsError> {+ match result {+ Ok(output) => Ok(output),+ Err(failure) => {+ let (output, error) = failure.into_parts();+ extend_bidi_events_from_protocol_output(+ Some(scheduler),+ bidi,+ events,+ output,+ owner_context,+ );+ Err(error)+ }+ }}async fn send_bidi_protocol_output(socket: &mut WebSocket,- scheduler: Option<&mut CdpScheduler>,+ scheduler: &mut CdpScheduler,+ receivers: &mut CdpSchedulerEventReceivers,bidi: &mut BidiConnectionState,output: ProtocolOutputSequence,owner_context: Option<&str>,@@ -1263,13 +1436,16 @@ async fn send_bidi_protocol_output(let pending_response =take_pending_navigation_response_from_sources(pending_navigation_response, &sources);let mut events = subscribed_bidi_events_from_devtools_event_sources(- scheduler.as_deref(),+ Some(&*scheduler),bidi,&sources,owner_context,);- if let Some(scheduler) = scheduler {- append_context_created_event_source_hook_events(scheduler, bidi, &mut events).await;+ if !append_context_created_event_source_hook_events(scheduler, receivers, bidi, &mut events)+ .await+ {+ let _ = send_bidi_json_events(socket, events).await;+ return false;}if !send_bidi_json_events(socket, events).await {return false;@@ -1287,11 +1463,12 @@ async fn send_bidi_protocol_output(async fn append_context_created_event_source_hook_events(scheduler: &mut CdpScheduler,+ receivers: &mut CdpSchedulerEventReceivers,bidi: &mut BidiConnectionState,events: &mut Vec<serde_json::Value>,-) {+) -> bool {let plan = bidi.context_created_event_source_hook_plan(events);- events.extend(execute_bidi_event_source_hook_plan(scheduler, bidi, &plan).await);+ append_bidi_event_source_hook_plan_events(scheduler, receivers, bidi, &plan, events).await}struct BidiDevToolsCommandOutput {@@ -1758,37 +1935,49 @@ fn bidi_protocol_message_owner_context(async fn enable_bidi_runtime_protocol_sources(scheduler: &mut CdpScheduler,-) -> ProtocolOutputSequence {+ receivers: &mut CdpSchedulerEventReceivers,+) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {scheduler- .execute_internal_protocol_message(json!({- "id": 0_u64,- "method": "Runtime.enable",- "params": {}- }))+ .execute_internal_protocol_message(+ receivers,+ json!({+ "id": 0_u64,+ "method": "Runtime.enable",+ "params": {}+ }),+ ).await}async fn disable_bidi_runtime_protocol_sources(scheduler: &mut CdpScheduler,-) -> ProtocolOutputSequence {+ receivers: &mut CdpSchedulerEventReceivers,+) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {scheduler- .execute_internal_protocol_message(json!({- "id": 0_u64,- "method": "Runtime.disable",- "params": {}- }))+ .execute_internal_protocol_message(+ receivers,+ json!({+ "id": 0_u64,+ "method": "Runtime.disable",+ "params": {}+ }),+ ).await}async fn enable_bidi_network_protocol_sources(scheduler: &mut CdpScheduler,-) -> ProtocolOutputSequence {+ receivers: &mut CdpSchedulerEventReceivers,+) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {scheduler- .execute_internal_protocol_message(json!({- "id": 0_u64,- "method": "Network.enable",- "params": {}- }))+ .execute_internal_protocol_message(+ receivers,+ json!({+ "id": 0_u64,+ "method": "Network.enable",+ "params": {}+ }),+ ).await}diff --git a/moli/src/protocol_server/webdriver_classic/state.rs b/moli/src/protocol_server/webdriver_classic/state.rsindex fffeb2c2b..bafea6821 100644--- a/moli/src/protocol_server/webdriver_classic/state.rs+++ b/moli/src/protocol_server/webdriver_classic/state.rs@@ -850,8 +850,12 @@ struct ClassicAttachedBidiSocket {}impl ClassicAttachedBidiSocket {- async fn release_session(&mut self, scheduler: &mut CdpScheduler) {- self.actor.release_event_sources(scheduler).await;+ async fn release_session(+ &mut self,+ scheduler: &mut CdpScheduler,+ receivers: &mut CdpSchedulerEventReceivers,+ ) {+ self.actor.release_event_sources(scheduler, receivers).await;self.actor.release_session(&mut self.session_registry.lock());}@@ -1317,13 +1321,17 @@ async fn classic_session_runtime_loop({ClassicSessionRuntimeRequestOutcome::Continue => {}ClassicSessionRuntimeRequestOutcome::AttachedBidi(mut duplicate) => {- duplicate.release_session(&mut scheduler).await;+ duplicate+ .release_session(&mut scheduler, &mut receivers)+ .await;}ClassicSessionRuntimeRequestOutcome::DetachBidi => {detach_bidi = true;}ClassicSessionRuntimeRequestOutcome::Shutdown(cookies) => {- attached.release_session(&mut scheduler).await;+ attached+ .release_session(&mut scheduler, &mut receivers)+ .await;shutdown_cookies = Some(cookies);}}@@ -1334,7 +1342,9 @@ async fn classic_session_runtime_loop(return cookies;}if detach_bidi && let Some(mut attached) = attached_bidi.take() {- attached.release_session(&mut scheduler).await;+ attached+ .release_session(&mut scheduler, &mut receivers)+ .await;}} else {let page_javascript_blocked = scheduler.has_pending_javascript_dialog();