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(websocket): unify message send completion events
ldm011da0d4720df
diff --git a/moli-renderer-v8/src/context_bootstrap/websocket.rs b/moli-renderer-v8/src/context_bootstrap/websocket.rsindex 05f649d71..376829bfc 100644--- a/moli-renderer-v8/src/context_bootstrap/websocket.rs+++ b/moli-renderer-v8/src/context_bootstrap/websocket.rs@@ -50,6 +50,7 @@ const WEBSOCKET_STREAM_PROMISE_RESOLVE_SLOT: &str = "__moliWebSocketStreamPromisconst WEBSOCKET_STREAM_PROMISE_REJECT_SLOT: &str = "__moliWebSocketStreamPromiseReject";const WEBSOCKET_STREAM_SINK_CLOSED_PROMISE_SLOT: &str = "__moliWebSocketStreamSinkClosedPromise";const WEBSOCKET_STREAM_PENDING_WRITES_SLOT: &str = "__moliWebSocketStreamPendingWrites";+const WEBSOCKET_STREAM_SEND_REJECTED_SLOT: &str = "__moliWebSocketStreamSendRejected";const CONNECTING: f64 = 0.0;const OPEN: f64 = 1.0;diff --git a/moli-renderer-v8/src/context_bootstrap/websocket/dispatch.rs b/moli-renderer-v8/src/context_bootstrap/websocket/dispatch.rsindex faa617bbd..268fcc3d9 100644--- a/moli-renderer-v8/src/context_bootstrap/websocket/dispatch.rs+++ b/moli-renderer-v8/src/context_bootstrap/websocket/dispatch.rs@@ -73,11 +73,10 @@ pub(crate) fn dispatch_websocket_event<'s>().into()}- WebSocketEvent::BufferedAmountConsumed { amount, .. } => {- add_buffered_amount(scope, socket, -(*amount as f64));+ WebSocketEvent::SendCompleted { payload_length, .. } => {+ add_buffered_amount(scope, socket, -(*payload_length as f64));WebSocketDispatchResult::Noop}- WebSocketEvent::FrameSent { .. } => WebSocketDispatchResult::Noop,WebSocketEvent::Error { message, .. } => {set_websocket_ready_state(scope, socket, CLOSED);if !message.is_empty() {diff --git a/moli-renderer-v8/src/context_bootstrap/websocket/stream.rs b/moli-renderer-v8/src/context_bootstrap/websocket/stream.rsindex e177ccb73..84803d1b0 100644--- a/moli-renderer-v8/src/context_bootstrap/websocket/stream.rs+++ b/moli-renderer-v8/src/context_bootstrap/websocket/stream.rs@@ -44,6 +44,8 @@ struct WebSocketStreamWritableSinkDeclaration<'scope> {closed: Option<v8::Local<'scope, v8::Value>>,#[webapi(slot = WEBSOCKET_STREAM_PENDING_WRITES_SLOT, init = "array")]pending_writes: (),+ #[webapi(slot = WEBSOCKET_STREAM_SEND_REJECTED_SLOT, init = false)]+ send_rejected: (),#[webapi(method, callback = websocket_stream_sink_write_callback, length = 1)]write: (),#[webapi(method, callback = websocket_stream_sink_close_callback, length = 0)]@@ -208,14 +210,13 @@ pub(super) fn dispatch_websocket_stream_event<'s>(let _ = enqueue_chunk(scope, readable, value.into());WebSocketDispatchResult::Dispatched}- WebSocketEvent::FrameSent { .. } => {+ WebSocketEvent::SendCompleted { .. } => {if resolve_next_websocket_stream_pending_write(scope, stream) {WebSocketDispatchResult::Dispatched} else {WebSocketDispatchResult::Noop}}- WebSocketEvent::BufferedAmountConsumed { .. } => WebSocketDispatchResult::Noop,WebSocketEvent::Error { message, .. } => {let error = new_websocket_error_object(scope, message, Some(1006), "");set_websocket_value_slot(scope, stream, WEBSOCKET_STREAM_ERROR_SLOT, error);@@ -252,7 +253,7 @@ pub(super) fn dispatch_websocket_stream_event<'s>(..} => {if *was_clean {- let mut had_pending_write = false;+ let mut had_interrupted_write = false;if let Some(readable) =websocket_object_slot(scope, stream, WEBSOCKET_STREAM_READABLE_SLOT){@@ -261,8 +262,7 @@ pub(super) fn dispatch_websocket_stream_event<'s>(if let Some(writable) =websocket_object_slot(scope, stream, WEBSOCKET_STREAM_WRITABLE_SLOT){- had_pending_write =- websocket_stream_pending_write_count_for_writable(scope, writable) > 0;+ had_interrupted_write = websocket_stream_has_interrupted_write(scope, writable);let error = websocket_dom_exception_value(scope,"InvalidStateError",@@ -272,7 +272,7 @@ pub(super) fn dispatch_websocket_stream_event<'s>(reject_all_websocket_stream_pending_writes(scope, writable, error);error_writable_stream_with_value(scope, writable, error);}- if had_pending_write {+ if had_interrupted_write {// WPT treats remote close that interrupts a queued write as a// WebSocketStream close error, while the interrupted write and// later writes reject with InvalidStateError from the writable.@@ -429,6 +429,15 @@ fn websocket_stream_sink_write_callback<'s>(if sent {enqueue_websocket_stream_pending_write(scope, args.this(), promise, resolve, reject);} else {+ // Native admission can end before the queued Close reaches this realm.+ // Remember that this write failed even after WritableStream has drained+ // its rejection reactions and no native pending-write record exists.+ set_private_value(+ scope,+ args.this(),+ WEBSOCKET_STREAM_SEND_REJECTED_SLOT,+ v8::Boolean::new(scope, true).into(),+ );let error = websocket_dom_exception_value(scope,"InvalidStateError",@@ -524,14 +533,16 @@ fn websocket_stream_pending_writes_for_stream<'s>(Some((sink, pending))}-fn websocket_stream_pending_write_count_for_writable<'s>(+fn websocket_stream_has_interrupted_write<'s>(scope: &mut v8::PinScope<'s, '_>,writable: v8::Local<'s, v8::Object>,-) -> u32 {- stream_slot_object(scope, writable, WRITABLE_STREAM_SINK_SLOT)- .and_then(|sink| websocket_stream_pending_writes(scope, sink))- .map(|pending| pending.length())- .unwrap_or(0)+) -> bool {+ let Some(sink) = stream_slot_object(scope, writable, WRITABLE_STREAM_SINK_SLOT) else {+ return false;+ };+ websocket_stream_pending_writes(scope, sink).is_some_and(|pending| pending.length() > 0)+ || get_private_value(scope, sink, WEBSOCKET_STREAM_SEND_REJECTED_SLOT)+ .is_some_and(|value| value.boolean_value(scope))}fn websocket_stream_pending_writes<'s>(diff --git a/moli-renderer-v8/src/native_bridge/context_host/websockets/commands.rs b/moli-renderer-v8/src/native_bridge/context_host/websockets/commands.rsindex 7501c2336..d86a3135c 100644--- a/moli-renderer-v8/src/native_bridge/context_host/websockets/commands.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/websockets/commands.rs@@ -1,6 +1,14 @@use super::super::JsContextHost;impl JsContextHost {+ #[cfg(test)]+ pub(crate) fn websocket_connection_for_test(+ &self,+ socket_id: u64,+ ) -> Option<moli_websocket::ConnectionHandle> {+ self.websockets.get(&socket_id)?.connection.clone()+ }+pub(crate) fn signal_websocket_stream_pull(&self, socket_id: u64) {self.page_websocket_sender().signal_readable_pull(socket_id);}diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/basic.rs b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/basic.rsindex 409b9846a..ce9e4d548 100644--- a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/basic.rs+++ b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/basic.rs@@ -20,6 +20,7 @@ async fn websocket_text_echo_delivers_browser_style_async_events() {globalThis.__wsEvents.push(`open:${{socket.readyState}}:${{socket.protocol}}`);socket.send('hello');globalThis.__wsEvents.push(`bufferedAfterSend:${{socket.bufferedAmount}}`);+ Promise.resolve().then(() => globalThis.__wsEvents.push(`bufferedInMicrotask:${{socket.bufferedAmount}}`));}});socket.addEventListener('message', event => {{globalThis.__wsEvents.push(`message:${{event.data}}:${{socket.bufferedAmount}}`);@@ -60,7 +61,7 @@ async fn websocket_text_echo_delivers_browser_style_async_events() {server.await.expect("websocket echo server should finish");assert_eq!(events,- r#"["constructed:0","open:1:","bufferedAfterSend:5","message:hello:0","afterCloseCall:2","close:3:1000:done:true"]"#+ r#"["constructed:0","open:1:","bufferedAfterSend:5","bufferedInMicrotask:5","message:hello:0","afterCloseCall:2","close:3:1000:done:true"]"#);}).await;diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/completion.rs b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/completion.rsindex d00641efe..0334198d4 100644--- a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/completion.rs+++ b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/completion.rs@@ -205,9 +205,10 @@ globalThis.__webSocketInternalStateSocket = new WebSocket({url_literal});.vm().websocket_sender_for_test().event_sender()- .send(moli_websocket::Event::BufferedAmountConsumed {+ .send(moli_websocket::Event::SendCompleted {socket_id,- amount: 0,+ opcode: moli_websocket::FrameOpcode::Text,+ payload_length: 0,}).await,"internal WebSocket transition should enter the typed source"@@ -410,3 +411,122 @@ async fn websocket_selected_dispatcher_owns_checkpoint_and_runtime_follow_up() {}).await;}++#[tokio::test(flavor = "current_thread")]+async fn websocket_stream_send_completion_body_defers_write_reactions() {+ run_page_vm_async_test(async move {+ // This server discards application messages, so the empty write must+ // complete through its own receipt without an incoming echo.+ let (url, server) = spawn_close_after_goodbye_websocket_server().await;+ let url = serde_json::to_string(&url).unwrap();+ let page_vm = test_page_vm();+ let local_executor = page_vm.local_executor.clone();+ local_executor.run(async move {+ let mut page_vm = page_vm;+ page_vm.vm_mut().eval(&format!(r#"+ globalThis.__completionEvents = [];+ globalThis.__completionStream = new WebSocketStream({url});+ __completionStream.opened.then(opened => {{+ globalThis.__completionWriter = opened.writable.getWriter();+ }});+ "queued"+ "#))?;+ let opened = wait_for_websocket_candidate(+ &mut page_vm, claim_ready_websocket_selected_task, "stream open",+ ).await?;+ let socket_id = opened.websocket_owner().unwrap().socket_id();+ let loader = page_vm.request_client.clone();+ page_vm.run_claimed_selected_page_task_for_test(opened, &loader).await?;+ page_vm.vm_mut().eval(r#"+ __completionWriter.write("").then(() => __completionEvents.push("resolved"));+ __completionEvents.push("after-write");+ "queued"+ "#)?;+ let task = wait_for_websocket_candidate(+ &mut page_vm, take_ready_websocket_body_task_for_test, "empty write completion",+ ).await?;+ assert!(matches!(task.event(), moli_websocket::Event::SendCompleted {+ socket_id: actual, payload_length: 0, ..+ } if *actual == socket_id));+ let outcome = page_vm.apply_selected_page_websocket_turn(task)?;+ assert_eq!(outcome.action.target_effect,+ crate::page_task_queue::PageWebSocketTargetEffect::CallbackVisibleWorkAppliedToCurrentDocument);+ assert_eq!(page_vm.vm_mut().eval("__completionEvents.join('|')")?, "after-write",+ "settling a write must leave reactions for selected-task completion");+ // This boundary witness deliberately omits task completion. Dropping+ // the Page then retires its connection and the passive test server.+ Ok::<_, anyhow::Error>(())+ }).await.expect("stream completion body witness");+ server.await.expect("passive completion server");+ }).await;+}++#[tokio::test(flavor = "current_thread")]+async fn websocket_stream_close_remembers_write_rejected_before_close_dispatch() {+ run_page_vm_async_test(async move {+ let (url, server) = spawn_close_after_goodbye_websocket_server().await;+ let url = serde_json::to_string(&url).unwrap();+ let page_vm = test_page_vm();+ let local_executor = page_vm.local_executor.clone();+ local_executor.run(async move {+ let mut page_vm = page_vm;+ page_vm.vm_mut().eval(&format!(r#"+ globalThis.__closeEvents = [];+ globalThis.__closeStream = new WebSocketStream({url});+ __closeStream.opened.then(opened => {{+ globalThis.__closeWriter = opened.writable.getWriter();+ }});+ __closeStream.closed.then(+ () => __closeEvents.push('closed-ok'),+ error => __closeEvents.push(`closed:${{error.constructor === WebSocketError}}:${{error.closeCode}}:${{error.reason}}`)+ );+ "queued"+ "#))?;+ let opened = wait_for_websocket_candidate(+ &mut page_vm, claim_ready_websocket_selected_task, "stream open",+ ).await?;+ let socket_id = opened.websocket_owner().unwrap().socket_id();+ let loader = page_vm.request_client.clone();+ page_vm.run_claimed_selected_page_task_for_test(opened, &loader).await?;+ let connection = page_vm.vm().context_host_weak_for_test().upgrade().unwrap()+ .borrow().websocket_connection_for_test(socket_id).unwrap();+ page_vm.vm_mut().eval(r#"+ __closeWriter.write('Goodbye').then(() => __closeEvents.push('goodbye'));+ __closeWriter.write('queued').catch(error => {+ globalThis.__interruptedWrite = error;+ __closeEvents.push(`write:${error.name}:${error instanceof DOMException}`);+ });+ "queued"+ "#)?;+ // Claim the first send completion to free ingress capacity, but let+ // the peer finish closing before executing its Page task. The next+ // WritableStream write must then fail native admission, with Close+ // still waiting for its own selected Page task.+ let sent = wait_for_websocket_candidate(+ &mut page_vm, claim_ready_websocket_selected_task, "Goodbye completion",+ ).await?;+ tokio::time::timeout(Duration::from_secs(2), server).await??;+ tokio::time::timeout(Duration::from_secs(2), async {+ while !connection.is_closed() {+ tokio::task::yield_now().await;+ }+ }).await?;+ page_vm.run_claimed_selected_page_task_for_test(sent, &loader).await?;+ assert_eq!(page_vm.vm_mut().eval("__closeEvents.join('|')")?,+ "goodbye|write:InvalidStateError:true",+ "the queued write must fail before the Close task is dispatched");+ let closed = wait_for_websocket_candidate(+ &mut page_vm, claim_ready_websocket_selected_task, "peer Close",+ ).await?;+ page_vm.run_claimed_selected_page_task_for_test(closed, &loader).await?;+ page_vm.vm_mut().eval(r#"+ __closeWriter.closed.catch(error => __closeEvents.push(`writer:${error === __interruptedWrite}`));+ __closeWriter.write('later').catch(error => __closeEvents.push(`later:${error === __interruptedWrite}`));+ "checked"+ "#)?;+ assert_eq!(page_vm.vm_mut().eval("__closeEvents.join('|')")?,+ "goodbye|write:InvalidStateError:true|closed:true:1000:goodbye|writer:true|later:true");+ Ok::<_, anyhow::Error>(())+ }).await.expect("close after rejected queued write");+ }).await;+}diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/wpt_target.rs b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/wpt_target.rsindex 2a72397e2..585435cc3 100644--- a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/wpt_target.rs+++ b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/wpt_target.rs@@ -768,7 +768,7 @@ async fn websocket_wpt_target_buffered_amount_binary_payload_lengths() {seen++;// See the unicode bufferedAmount test: the stable contract here is// immediate byte accounting plus eventual drain, not exact- // BufferedAmountConsumed/message event ordering.+ // send-completion/message event ordering.globalThis.__wsEvents.push(`message:${{seen}}:${{event.data.byteLength}}`);if (seen === 3) socket.close(1000, 'buffered-binary');}});diff --git a/moli-renderer-v8/src/script_vm/websocket_event_body.rs b/moli-renderer-v8/src/script_vm/websocket_event_body.rsindex 7b7959dc5..0063c1dac 100644--- a/moli-renderer-v8/src/script_vm/websocket_event_body.rs+++ b/moli-renderer-v8/src/script_vm/websocket_event_body.rs@@ -44,7 +44,7 @@ impl ScriptVm {let previous_owner_context = dispatch_scope.enter(scope);match event {- moli_websocket::Event::FrameSent {+ moli_websocket::Event::SendCompleted {opcode,payload_length,..diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rsindex 16c3dd19e..5fd52e79a 100644--- a/moli-renderer-v8/src/worker/global_scope/fetch.rs+++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs@@ -1411,8 +1411,7 @@ pub(in crate::worker) fn dispatch_worker_websocket_event(| WebSocketEvent::Open { socket_id, .. }| WebSocketEvent::TextMessage { socket_id, .. }| WebSocketEvent::BinaryMessage { socket_id, .. }- | WebSocketEvent::FrameSent { socket_id, .. }- | WebSocketEvent::BufferedAmountConsumed { socket_id, .. }+ | WebSocketEvent::SendCompleted { socket_id, .. }| WebSocketEvent::Error { socket_id, .. }| WebSocketEvent::Closing { socket_id }| WebSocketEvent::Close { socket_id, .. } => *socket_id,@@ -1503,7 +1502,7 @@ pub(in crate::worker) fn dispatch_worker_websocket_event(.with_websocket_socket_id(socket_id),));}- WebSocketEvent::FrameSent {+ WebSocketEvent::SendCompleted {opcode,payload_length,..@@ -1572,8 +1571,7 @@ pub(in crate::worker) fn dispatch_worker_websocket_event(}WebSocketEvent::HandshakeResponse { .. }| WebSocketEvent::TextMessage { .. }- | WebSocketEvent::BinaryMessage { .. }- | WebSocketEvent::BufferedAmountConsumed { .. } => {}+ | WebSocketEvent::BinaryMessage { .. } => {}}for message in parent_messages {let _ = parent_tx.send(message);diff --git a/moli-websocket/src/native_tests.rs b/moli-websocket/src/native_tests.rsindex 9782218a0..29e84a88b 100644--- a/moli-websocket/src/native_tests.rs+++ b/moli-websocket/src/native_tests.rs@@ -28,8 +28,8 @@ async fn native_send_accounting_does_not_require_a_server_echo() {let handle = spawn_connection(70, url, Vec::new(), test_websocket_context(), tx);recv_open_event(&mut rx).await;handle.send_text("without echo".to_owned()).unwrap();- assert_frame_sent(&mut rx, 70, FrameOpcode::Text, 12).await;- assert_buffered_amount_consumed(&mut rx, 70, 12).await;+ assert_send_completed(&mut rx, 70, FrameOpcode::Text, 12).await;+timeout(Duration::from_secs(3), received_rx).await.unwrap()diff --git a/moli-websocket/src/session.rs b/moli-websocket/src/session.rsindex 80946fae9..87de929c9 100644--- a/moli-websocket/src/session.rs+++ b/moli-websocket/src/session.rs@@ -269,7 +269,7 @@ impl Session {&& self.outbox.iter()- .filter(|event| matches!(event, Event::FrameSent { .. }))+ .filter(|event| matches!(event, Event::SendCompleted { .. })).count()>= MAX_QUEUED_MESSAGES{@@ -378,15 +378,11 @@ impl Session {.outgoing.pop_front().expect("completed message is resident");- self.outbox.push_back(Event::FrameSent {+ self.outbox.push_back(Event::SendCompleted {socket_id: self.socket_id,opcode: message.opcode,payload_length: message.data.len(),});- self.outbox.push_back(Event::BufferedAmountConsumed {- socket_id: self.socket_id,- amount: message.data.len(),- });// The admission reservation drops only at native completion.}}diff --git a/moli-websocket/src/session/tests.rs b/moli-websocket/src/session/tests.rsindex 97b8a81d8..ea3ed534d 100644--- a/moli-websocket/src/session/tests.rs+++ b/moli-websocket/src/session/tests.rs@@ -54,8 +54,8 @@ async fn native_close_waits_for_queued_data_before_starting_timeout() {"queued data was interrupted: {premature:?}");resume_tx.send(()).unwrap();- assert_frame_sent(&mut rx, 80, FrameOpcode::Binary, MESSAGE_BYTES).await;- assert_buffered_amount_consumed(&mut rx, 80, MESSAGE_BYTES).await;+ assert_send_completed(&mut rx, 80, FrameOpcode::Binary, MESSAGE_BYTES).await;+assert_close(&mut rx, 80, 1000, "", true).await;timeout(Duration::from_secs(3), server).await@@ -165,8 +165,7 @@ async fn native_fragmented_sends_complete_while_incoming_sink_is_blocked() {.unwrap();assert_text_message(&mut rx, 82, "blocked").await;for _ in 0..2 {- assert_frame_sent(&mut rx, 82, FrameOpcode::Binary, MESSAGE_BYTES).await;- assert_buffered_amount_consumed(&mut rx, 82, MESSAGE_BYTES).await;+ assert_send_completed(&mut rx, 82, FrameOpcode::Binary, MESSAGE_BYTES).await;}handle.close(Some(1000), String::new()).unwrap();assert_closing(&mut rx, 82).await;@@ -209,7 +208,7 @@ async fn completed_send_notifications_bound_further_message_scheduling() {);assert!(matches!(session.outbox.pop_front(),- Some(Event::FrameSent { .. })+ Some(Event::SendCompleted { .. })));for _ in 0..2 {let (frame, flight) = session@@ -224,7 +223,7 @@ async fn completed_send_notifications_bound_further_message_scheduling() {session.outbox.iter()- .filter(|event| matches!(event, Event::FrameSent { .. }))+ .filter(|event| matches!(event, Event::SendCompleted { .. })).count(),MAX_QUEUED_MESSAGES);diff --git a/moli-websocket/src/synthetic.rs b/moli-websocket/src/synthetic.rsindex a8ffd944f..1d6df49d7 100644--- a/moli-websocket/src/synthetic.rs+++ b/moli-websocket/src/synthetic.rs@@ -50,35 +50,25 @@ pub(crate) async fn run_synthetic_websocket_connection(let amount = text.len();send_event(&event_tx,- Event::FrameSent {+ Event::SendCompleted {socket_id,opcode: FrameOpcode::Text,payload_length: amount,},).await?;- send_event(- &event_tx,- Event::BufferedAmountConsumed { socket_id, amount },- )- .await?;}Command::SendBinary(bytes) => {let amount = bytes.len();send_event(&event_tx,- Event::FrameSent {+ Event::SendCompleted {socket_id,opcode: FrameOpcode::Binary,payload_length: amount,},).await?;- send_event(- &event_tx,- Event::BufferedAmountConsumed { socket_id, amount },- )- .await?;}Command::ReceiveText(data) => {send_event(&event_tx, Event::TextMessage { socket_id, data }).await?;diff --git a/moli-websocket/src/test_support.rs b/moli-websocket/src/test_support.rsindex c6ded99c5..a5caacb33 100644--- a/moli-websocket/src/test_support.rs+++ b/moli-websocket/src/test_support.rs@@ -118,8 +118,7 @@ pub async fn recv_open_event(event_rx: &mut mpsc::Receiver<Event>) -> OpenEvent}Event::TextMessage { .. }| Event::BinaryMessage { .. }- | Event::FrameSent { .. }- | Event::BufferedAmountConsumed { .. }+ | Event::SendCompleted { .. }| Event::Closing { .. } => {}}}@@ -140,8 +139,7 @@ pub async fn recv_handshake_failure_events(event_rx: &mut mpsc::Receiver<Event>)}Event::TextMessage { .. }| Event::BinaryMessage { .. }- | Event::FrameSent { .. }- | Event::BufferedAmountConsumed { .. }+ | Event::SendCompleted { .. }| Event::Closing { .. } => {}}};@@ -170,8 +168,7 @@ pub async fn recv_handshake_failure_events(event_rx: &mut mpsc::Receiver<Event>)}Event::TextMessage { .. }| Event::BinaryMessage { .. }- | Event::FrameSent { .. }- | Event::BufferedAmountConsumed { .. }+ | Event::SendCompleted { .. }| Event::Closing { .. } => {}}}@@ -184,14 +181,14 @@ async fn recv_next_event(event_rx: &mut mpsc::Receiver<Event>) -> Event {.expect("websocket event channel should stay open")}-pub async fn assert_frame_sent(+pub async fn assert_send_completed(event_rx: &mut mpsc::Receiver<Event>,expected_socket_id: u64,expected_opcode: FrameOpcode,expected_payload_length: usize,) {match recv_next_event(event_rx).await {- Event::FrameSent {+ Event::SendCompleted {socket_id,opcode,payload_length,@@ -200,21 +197,7 @@ pub async fn assert_frame_sent(assert_eq!(opcode, expected_opcode);assert_eq!(payload_length, expected_payload_length);}- event => panic!("expected frame-sent event, got {event:?}"),- }-}--pub async fn assert_buffered_amount_consumed(- event_rx: &mut mpsc::Receiver<Event>,- expected_socket_id: u64,- expected_amount: usize,-) {- match recv_next_event(event_rx).await {- Event::BufferedAmountConsumed { socket_id, amount } => {- assert_eq!(socket_id, expected_socket_id);- assert_eq!(amount, expected_amount);- }- event => panic!("expected buffered amount event, got {event:?}"),+ event => panic!("expected send completion, got {event:?}"),}}diff --git a/moli-websocket/src/tests.rs b/moli-websocket/src/tests.rsindex c52da93e1..63533f55a 100644--- a/moli-websocket/src/tests.rs+++ b/moli-websocket/src/tests.rs@@ -590,13 +590,13 @@ async fn websocket_synthetic_delivery_stops_after_first_rejected_event() {),).await- .expect("synthetic producer must stop when FrameSent is rejected")+ .expect("synthetic producer must stop when SendCompleted is rejected").expect_err("synthetic event sink is closed");assert!(command_tx.is_closed());assert!(matches!(observed_rx.try_recv(), Ok(Event::Open { .. })));assert!(matches!(observed_rx.try_recv(),- Ok(Event::FrameSent { .. })+ Ok(Event::SendCompleted { .. })));assert!(observed_rx.try_recv().is_err(),@@ -718,7 +718,7 @@ async fn websocket_synthetic_connection_opens_accounts_send_and_closes_cleanly().expect("synthetic frame sent should arrive").expect("synthetic websocket event channel should stay open");match event {- Event::FrameSent {+ Event::SendCompleted {socket_id,opcode,payload_length,@@ -729,17 +729,6 @@ async fn websocket_synthetic_connection_opens_accounts_send_and_closes_cleanly()}event => panic!("expected synthetic websocket frame sent, got {event:?}"),}- let event = timeout(Duration::from_secs(1), event_rx.recv())- .await- .expect("synthetic buffered amount consumption should arrive")- .expect("synthetic websocket event channel should stay open");- match event {- Event::BufferedAmountConsumed { socket_id, amount } => {- assert_eq!(socket_id, 92);- assert_eq!(amount, 5);- }- event => panic!("expected synthetic buffered amount event, got {event:?}"),- }command_tx.close(Some(1000), "done".to_owned())@@ -1228,15 +1217,15 @@ async fn websocket_transport_sends_text_binary_and_reports_buffered_amount_consucommand_tx.send_text("hello".to_owned()).expect("send text command");- assert_frame_sent(&mut event_rx, 4, FrameOpcode::Text, 5).await;- assert_buffered_amount_consumed(&mut event_rx, 4, 5).await;+ assert_send_completed(&mut event_rx, 4, FrameOpcode::Text, 5).await;+assert_text_message(&mut event_rx, 4, "hello").await;command_tx.send_binary(vec![1, 2, 3, 4]).expect("send binary command");- assert_frame_sent(&mut event_rx, 4, FrameOpcode::Binary, 4).await;- assert_buffered_amount_consumed(&mut event_rx, 4, 4).await;+ assert_send_completed(&mut event_rx, 4, FrameOpcode::Binary, 4).await;+assert_binary_message(&mut event_rx, 4, &[1, 2, 3, 4]).await;command_tx@@ -1281,8 +1270,7 @@ async fn websocket_transport_reads_while_sending_many_large_messages() {Event::HandshakeResponse { .. }| Event::Open { .. }| Event::BinaryMessage { .. }- | Event::FrameSent { .. }- | Event::BufferedAmountConsumed { .. }+ | Event::SendCompleted { .. }| Event::Closing { .. } => {}}}diff --git a/moli-websocket/src/types.rs b/moli-websocket/src/types.rsindex 7ba0fd250..584ac80b6 100644--- a/moli-websocket/src/types.rs+++ b/moli-websocket/src/types.rs@@ -42,15 +42,13 @@ pub enum Event {socket_id: u64,data: Vec<u8>,},- FrameSent {+ /// One complete outgoing message, including an empty message.+ /// Drives browser byte accounting, stream writes and CDP message records.+ SendCompleted {socket_id: u64,opcode: FrameOpcode,payload_length: usize,},- BufferedAmountConsumed {- socket_id: u64,- amount: usize,- },Error {socket_id: u64,message: String,@@ -73,8 +71,7 @@ impl Event {| Self::Open { socket_id, .. }| Self::TextMessage { socket_id, .. }| Self::BinaryMessage { socket_id, .. }- | Self::FrameSent { socket_id, .. }- | Self::BufferedAmountConsumed { socket_id, .. }+ | Self::SendCompleted { socket_id, .. }| Self::Error { socket_id, .. }| Self::Closing { socket_id }| Self::Close { socket_id, .. } => *socket_id,