diff --git a/moli-renderer-v8/src/context_bootstrap/performance_runtime/fetch_timing.rs b/moli-renderer-v8/src/context_bootstrap/performance_runtime/fetch_timing.rs index 4c65df1c52c..8616600333c 100644 --- a/moli-renderer-v8/src/context_bootstrap/performance_runtime/fetch_timing.rs +++ b/moli-renderer-v8/src/context_bootstrap/performance_runtime/fetch_timing.rs @@ -42,6 +42,29 @@ impl FetchResourceTiming { self.response_start_unix_millis.set(Some(self.now())); } + /// Use the transport's header boundary even when Worker JS delayed delivery. + pub(crate) fn response_started_at(&self, start: Option) { + self.response_start_unix_millis + .set(start.map(|instant| self.unix_millis(instant))); + } + + pub(crate) fn completed_at( + &self, + mut entry: ResourcePerformanceEntry, + end: std::time::Instant, + ) -> ResourcePerformanceEntry { + entry.end_unix_millis = Some(self.unix_millis(end)); + entry + } + + fn unix_millis(&self, instant: std::time::Instant) -> f64 { + self.start_unix_millis + + instant + .saturating_duration_since(self.started) + .as_secs_f64() + * 1000.0 + } + pub(crate) fn completed( &self, url: &Url, diff --git a/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs b/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs index a063b96b1ab..675d332f582 100644 --- a/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs +++ b/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs @@ -33,6 +33,7 @@ pub(crate) struct ControlledFetchStream { pub(super) body_source_id: Option, response: Option>, delivered: usize, + timing: crate::worker::WorkerResourceTiming, } struct StreamedFetchResponse { @@ -65,6 +66,7 @@ impl ControlledFetchStream { request_url: Arc, load: crate::network::loads::ResourceLoadLease, resource_timing: FetchResourceTiming, + timing: crate::worker::WorkerResourceTiming, ) -> Self { Self { completion, @@ -80,6 +82,7 @@ impl ControlledFetchStream { body_source_id: None, response: None, delivered: 0, + timing, } } @@ -90,6 +93,7 @@ impl ControlledFetchStream { network_request_headers: Option>, body: ResourceInterceptionBody, ) -> Result<(), String> { + self.timing.observe_head(&head); super::super::validate_fetch_response_headers( &self.request_origin, &head, @@ -167,6 +171,7 @@ impl ControlledFetchStream { .expect("response precedes body") .handle; self.delivered += bytes.len(); + self.timing.observe_chunk(bytes.len()); self.interception .publish_network(ScriptNetworkOutputItem::SubresourceDataReceived( SubresourceDataReceived::new(handle, bytes.len(), bytes.len()), @@ -184,6 +189,7 @@ impl ControlledFetchStream { } pub(super) fn finish(&mut self, result: Result<(), String>) { + self.timing.complete(); let response = *self .response .take() @@ -235,6 +241,7 @@ impl super::ControlledResourceLoad { fetch_id: u32, resource_timing: FetchResourceTiming, integrity: String, + timing: crate::worker::WorkerResourceTiming, ) { // Network/CDP correlation follows redirects; Resource Timing names // the original request, including when interception rewrites its URL. @@ -259,6 +266,7 @@ impl super::ControlledResourceLoad { Arc::clone(&request_url), self.load.clone(), resource_timing.clone(), + timing.clone(), )); let result = self.run_inner((integrity.is_empty() && self.info.resource_type != crate::types::SubresourceResourceType::Font).then_some(&mut stream)).await; let result = self.normalize_cancellation(result); @@ -270,6 +278,7 @@ impl super::ControlledResourceLoad { stream.finish(result.map(|_| ())); self.load.finish(); self.publish_completed(); + let _ = completion.send(WorkerFetchEvent::ResourceTiming { fetch_id, timing }); return; } let (mut result, headers) = match result { @@ -317,6 +326,17 @@ impl super::ControlledResourceLoad { result = Err(error); } } + if let Ok(delivered) = &result { + let head = delivered.response.head(); + timing.observe_head(&head); + timing.observe_chunk(delivered.response.body_bytes().len()); + if let Some(filter) = self.response_filter.clone() { + timing.select_response(&head, filter, delivered.response.body_bytes().len(), true); + } + } else { + timing.discard_response(); + } + timing.complete(); let mut record = super::result::XhrLoadResult::new(self.info.clone(), result, headers); if let Err(error) = &record.result { record.network_record = failure_record(&self.info, network_error(error)); @@ -380,6 +400,7 @@ impl super::ControlledResourceLoad { let _ = completion.send(WorkerFetchEvent::Completion(Box::new( crate::worker::WorkerFetchCompletion { fetch_id, result }, ))); + let _ = completion.send(WorkerFetchEvent::ResourceTiming { fetch_id, timing }); } } diff --git a/moli-renderer-v8/src/network_host/controlled_resource/result.rs b/moli-renderer-v8/src/network_host/controlled_resource/result.rs index b3e57a87f52..2f51eb7b507 100644 --- a/moli-renderer-v8/src/network_host/controlled_resource/result.rs +++ b/moli-renderer-v8/src/network_host/controlled_resource/result.rs @@ -111,6 +111,7 @@ pub(crate) fn start_buffered_xhr( cancel: FetchCancelHandle, preflight_headers: Vec<(String, String)>, control: Option, + on_completed: impl FnOnce(&XhrLoadResult) + Send + 'static, ) -> crossbeam_channel::Receiver> { let (tx, rx) = crossbeam_channel::bounded(1); load.task_runner().spawn(async move { @@ -148,6 +149,7 @@ pub(crate) fn start_buffered_xhr( XhrLoadResult::new(info, result.map(BufferedXhrResponse::from_response), None) } }; + on_completed(&completed); let _ = tx.send(Ok(completed)); }); rx @@ -216,6 +218,7 @@ mod tests { from_cache: false, cache_state: Default::default(), negotiated_http_version: None, + preload_state: Default::default(), }, body: ResourceInterceptionBody::from_complete(captured), }; diff --git a/moli-renderer-v8/src/network_host/xhr/bindings/open.rs b/moli-renderer-v8/src/network_host/xhr/bindings/open.rs index a1012a6be09..1becfe8243b 100644 --- a/moli-renderer-v8/src/network_host/xhr/bindings/open.rs +++ b/moli-renderer-v8/src/network_host/xhr/bindings/open.rs @@ -81,6 +81,7 @@ pub(super) fn xhr_open_callback<'s>( } let previous_ready_state = xhr_ready_state(scope, xhr); terminate_window_xhr_fetch(scope, xhr); + crate::worker::try_worker_xhr_terminate_fetch(scope, xhr); super::super::delivery::clear_xhr_request_timers(scope, xhr); let open_generation = xhr_state_number_property(scope, xhr, XHR_OPEN_GENERATION_SLOT).unwrap_or(0.0); diff --git a/moli-renderer-v8/src/network_host/xhr/send.rs b/moli-renderer-v8/src/network_host/xhr/send.rs index ec14e608a46..a9040bcba6e 100644 --- a/moli-renderer-v8/src/network_host/xhr/send.rs +++ b/moli-renderer-v8/src/network_host/xhr/send.rs @@ -365,6 +365,7 @@ fn send_synchronous_network_xhr( cancel_handle.clone(), preflight_headers, control, + |_| {}, ); let result = match wait_for_synchronous_load( response_rx, diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs index acae153efb1..0cb51aebdcf 100644 --- a/moli-renderer-v8/src/worker/global_scope/fetch.rs +++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs @@ -95,6 +95,7 @@ pub(in crate::worker) fn record_worker_subresource_failure_with_handle( if let Some(output) = &state.interception_context { output.record_subresource_network(record); } + } fn worker_fetch_script_metadata( @@ -970,6 +971,21 @@ pub(super) fn start_worker_resource_fetch<'s>( return Some(rejected); } + let request_origin = worker_global_origin(scope).unwrap_or(moli_url::WebOrigin::Opaque); + let timing = WorkerResourceTiming::new( + scope, + resolved_url.clone(), + request_origin, + WorkerTimingRequest::Fetch { + method: method.clone(), + mode: request_mode, + credentials: credentials_mode, + redirect: redirect_mode, + policy: policy_context, + font: kind == WorkerFetchKind::Font, + }, + ); + let report_only_violation = { let state_ref = state.borrow(); worker_content_security_policy_report_only_violation( @@ -1137,13 +1153,15 @@ pub(super) fn start_worker_resource_fetch<'s>( native_load::start( scope, &state, - native_load::NativeWorkerFetchRequest { request, blob_url_entry, kind, font_face }, + native_load::NativeWorkerFetchRequest { request, blob_url_entry, kind, font_face, timing }, + document_url, signal_id, request_metadata, policy_context, ) } + } pub(in crate::worker) fn reject_worker_fetches_for_signal<'s>( @@ -1172,12 +1190,10 @@ pub(in crate::worker) fn reject_worker_fetches_for_signal<'s>( rejected }; for (_, pending) in rejected { - crate::context_bootstrap::record_resource_performance_entry( - scope, - pending.resource_timing.failed(&pending.request_url), - ); + pending.timing.abort(scope); pending.load.cancel(); if let Some(body_source_id) = pending.streaming_body_source_id { + error_pending_network_body_stream_with_reason( scope, body_source_id, @@ -1196,12 +1212,18 @@ pub(in crate::worker) fn drain_worker_fetch_completion( event: WorkerFetchEvent, ) { match event { + WorkerFetchEvent::ResourceTiming { fetch_id, timing } => { + if !state.borrow().pending_fetches.contains_key(&fetch_id) { + timing.publish(scope); + } + } WorkerFetchEvent::PolicyViolations(violations) => { for violation in violations { dispatch_worker_content_security_policy_violation_event_for_state( scope, state, &violation, ); } + } WorkerFetchEvent::Completion(completion) => { drain_worker_fetch_completion_result(scope, state, *completion) @@ -1273,10 +1295,7 @@ pub(in crate::worker) fn finish_worker_streaming_fetch( close_pending_network_body_stream(scope, finished.body_source_id); } Err(error_text) => { - crate::context_bootstrap::record_resource_performance_entry( - scope, - pending.resource_timing.failed(&pending.request_url), - ); + pending.timing.publish(scope); let reason = v8_string(scope, &error_text) .map(|message| v8::Exception::type_error(scope, message)) .unwrap_or_else(|| v8::undefined(scope).into()); @@ -1295,6 +1314,7 @@ pub(in crate::worker) fn drain_worker_fetch_completion_result( state: &Rc>, completion: WorkerFetchCompletion, ) { + let Some(pending) = state .borrow_mut() .pending_fetches @@ -1331,10 +1351,8 @@ pub(in crate::worker) fn drain_worker_fetch_completion_result( let _ = resolver.resolve(scope, response_obj.into()); } Err(message) => { - crate::context_bootstrap::record_resource_performance_entry( - scope, - pending.resource_timing.failed(&pending.request_url), - ); + pending.timing.reject(scope); + if let Some(message) = v8_string(scope, &message) { let _ = resolver.reject(scope, v8::Exception::type_error(scope, message)); } else { diff --git a/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs b/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs index dbba6d1e0b1..9cad78531be 100644 --- a/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs +++ b/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs @@ -4,6 +4,7 @@ pub(super) struct NativeWorkerFetchRequest<'s> { pub(super) request: Request, pub(super) blob_url_entry: Option, pub(super) kind: WorkerFetchKind, + pub(super) timing: WorkerResourceTiming, pub(super) font_face: Option>, } @@ -16,10 +17,11 @@ pub(super) fn start<'s>( metadata: ServiceWorkerFetchRequestMetadata, policy_context: SubresourcePolicyContext, ) -> Option> { - let NativeWorkerFetchRequest { request, blob_url_entry, kind, font_face } = request; + let NativeWorkerFetchRequest { request, blob_url_entry, kind, font_face, timing } = request; let resolver = v8::PromiseResolver::new(scope)?; let promise = resolver.get_promise(scope); let cancel = FetchCancelHandle::new(); + timing.begin_transport(cancel.clone()); let load = state.borrow().loader.register_load( kind.resource_type().into(), if metadata.keepalive { @@ -66,6 +68,7 @@ pub(super) fn start<'s>( font_face: font_face.map(|face| v8::Global::new(scope, face)), resolver: v8::Global::new(scope, resolver), resource_timing: resource_timing.clone(), + timing: timing.clone(), signal_id, load: load.clone(), request_url: request.url.clone(), @@ -88,7 +91,7 @@ pub(super) fn start<'s>( .fetch_load(request, info, load, cancel, policy_context) .with_blob_url_entry(blob_url_entry) .with_service_worker(service_worker, service_worker_client, metadata) - .run_fetch(completion, fetch_id, resource_timing, integrity) + .run_fetch(completion, fetch_id, resource_timing, integrity, timing) .await; }); Some(promise) diff --git a/moli-renderer-v8/src/worker/global_scope/mod.rs b/moli-renderer-v8/src/worker/global_scope/mod.rs index f7cf479fefb..bbd8b6a747a 100644 --- a/moli-renderer-v8/src/worker/global_scope/mod.rs +++ b/moli-renderer-v8/src/worker/global_scope/mod.rs @@ -111,6 +111,7 @@ mod nested_workers; mod network_state; mod origin; mod performance; +mod resource_timing; mod service_worker_api; mod service_worker_results; mod state; @@ -203,6 +204,8 @@ use network_state::{merge_worker_request_headers, next_fetch_id, next_xhr_id, wo pub(crate) use origin::worker_global_origin; use origin::{WorkerGlobalOriginDeclaration, WorkerGlobalOriginPrototypeDeclaration}; use performance::monotonic_unix_epoch_millis; +pub(crate) use resource_timing::WorkerResourceTiming; +use resource_timing::WorkerTimingRequest; pub(super) use service_worker_results::{ PendingServiceWorkerClientFocus, PendingServiceWorkerClientNavigate, PendingServiceWorkerClientQuery, PendingServiceWorkerClientQueryType, diff --git a/moli-renderer-v8/src/worker/global_scope/network_state.rs b/moli-renderer-v8/src/worker/global_scope/network_state.rs index 0bc5110dced..039c5337ba2 100644 --- a/moli-renderer-v8/src/worker/global_scope/network_state.rs +++ b/moli-renderer-v8/src/worker/global_scope/network_state.rs @@ -3,6 +3,7 @@ use super::*; pub(in crate::worker) struct PendingWorkerFetch { + pub(super) timing: WorkerResourceTiming, pub(in crate::worker) kind: fetch::WorkerFetchKind, pub(in crate::worker) font_face: Option>, pub(in crate::worker) resolver: v8::Global, @@ -22,6 +23,10 @@ pub(crate) enum WorkerFetchEvent { StreamingStarted(WorkerFetchStreamingStarted), StreamingChunk(WorkerFetchStreamingChunk), StreamingFinished(WorkerFetchStreamingFinished), + ResourceTiming { + fetch_id: u32, + timing: WorkerResourceTiming, + }, } pub(crate) struct WorkerFetchCompletion { @@ -57,6 +62,7 @@ pub(crate) struct WorkerFetchResponse { } pub(in crate::worker) struct PendingWorkerXhr { + pub(super) timing: WorkerResourceTiming, pub(in crate::worker) xhr: v8::Global, pub(in crate::worker) credentials_mode: RequestCredentialsMode, @@ -116,6 +122,10 @@ pub(in crate::worker) struct WorkerWebSocketState { } pub(in crate::worker) enum WorkerXhrEvent { + ResourceTiming { + xhr_id: Option, + timing: WorkerResourceTiming, + }, Upload { xhr_id: u32, event: moli_fetch::UploadEvent, diff --git a/moli-renderer-v8/src/worker/global_scope/resource_timing.rs b/moli-renderer-v8/src/worker/global_scope/resource_timing.rs new file mode 100644 index 00000000000..b3cb4e5f05f --- /dev/null +++ b/moli-renderer-v8/src/worker/global_scope/resource_timing.rs @@ -0,0 +1,289 @@ +//! Request-owned Resource Timing, independent of CDP capture and JS receivers. + +use parking_lot::Mutex; +use std::sync::Arc; +use std::time::Instant; + +use moli_fetch::{ + FetchCancelHandle, RequestCredentialsMode, RequestMode, RequestRedirectMode, ResponseHead, +}; +use moli_url::WebOrigin; +use url::Url; + +use crate::context_bootstrap::{FetchResourceTiming, ResourcePerformanceEntry}; +use crate::network_host::{ + FetchResponseRequest, validate_cors_response_chain, validate_fetch_response_headers, +}; +use crate::types::{AsyncSubresourceFetchResponseFilter, SubresourcePolicyContext}; + +pub(super) enum WorkerTimingRequest { + Fetch { + method: String, + mode: RequestMode, + credentials: RequestCredentialsMode, + redirect: RequestRedirectMode, + policy: SubresourcePolicyContext, + font: bool, + }, + Xhr { + credentials: RequestCredentialsMode, + }, +} + +impl WorkerTimingRequest { + fn filter( + &self, + origin: &WebOrigin, + head: &ResponseHead, + ) -> Option { + let (method, mode, credentials, redirect) = match self { + Self::Fetch { + method, + mode, + credentials, + redirect, + policy, + .. + } => { + validate_fetch_response_headers(origin, head, *mode, *credentials, *policy).ok()?; + (method.as_str(), *mode, *credentials, *redirect) + } + Self::Xhr { credentials } => { + validate_cors_response_chain(origin, head, *credentials).ok()?; + ( + "GET", + RequestMode::Cors, + *credentials, + RequestRedirectMode::Follow, + ) + } + }; + Some( + FetchResponseRequest { + method, + mode, + redirect_mode: redirect, + } + .network_response_filter(origin, head, credentials), + ) + } + + fn initiator_type(&self) -> &'static str { + match self { + Self::Fetch { font: true, .. } => "css", + Self::Fetch { font: false, .. } => "fetch", + Self::Xhr { .. } => "xmlhttprequest", + } + } +} + +/// IO owns observations; the Worker owner selects the response and publishes. +/// A terminal IO event also retains this owner after abort/open retires the +/// pending JS request, so an already completed response cannot lose its entry. +#[derive(Clone)] +pub(crate) struct WorkerResourceTiming(Arc); + +struct WorkerResourceTimingInner { + name: Url, + origin: WebOrigin, + request: WorkerTimingRequest, + state: Mutex, +} + +struct WorkerResourceTimingState { + clock: FetchResourceTiming, + transport: Option, + response: Option<(ResponseHead, AsyncSubresourceFetchResponseFilter)>, + body_size: usize, + completed_at: Option, + synthetic_response_start: Option, + awaiting_selection: bool, + aborted: bool, + reported: bool, +} + +impl WorkerResourceTiming { + pub(super) fn new( + scope: &mut v8::PinScope<'_, '_>, + name: Url, + origin: WebOrigin, + request: WorkerTimingRequest, + ) -> Self { + let clock = FetchResourceTiming::capture_for_initiator_type( + scope, + &origin, + request.initiator_type(), + ); + Self(Arc::new(WorkerResourceTimingInner { + name, + origin, + request, + state: Mutex::new(WorkerResourceTimingState { + clock, + transport: None, + response: None, + body_size: 0, + completed_at: None, + synthetic_response_start: None, + awaiting_selection: false, + aborted: false, + reported: false, + }), + })) + } + + pub(crate) fn origin(&self) -> &WebOrigin { + &self.0.origin + } + + pub(crate) fn begin_transport(&self, cancel: FetchCancelHandle) { + let mut state = self.0.state.lock(); + state.transport = Some(cancel); + state.response = None; + state.body_size = 0; + state.completed_at = None; + state.synthetic_response_start = None; + state.awaiting_selection = false; + state.aborted = false; + } + + pub(crate) fn observe_head(&self, head: &ResponseHead) { + let filter = self.0.request.filter(&self.0.origin, head); + let mut state = self.0.state.lock(); + state.response = filter.map(|filter| (head.clone(), filter)); + } + + pub(crate) fn observe_chunk(&self, size: usize) { + let mut state = self.0.state.lock(); + state.body_size = state.body_size.saturating_add(size); + } + + pub(crate) fn complete(&self) { + let mut state = self.0.state.lock(); + state.completed_at.get_or_insert_with(Instant::now); + } + + pub(crate) fn pause(&self) { + self.0.state.lock().awaiting_selection = true; + } + + pub(crate) fn discard_response(&self) { + let mut state = self.0.state.lock(); + state.transport = None; + state.response = None; + state.body_size = 0; + state.completed_at = Some(Instant::now()); + state.synthetic_response_start = None; + } + + pub(crate) fn begin_synthetic_response(&self) { + self.discard_response(); + let mut state = self.0.state.lock(); + state.synthetic_response_start = state.completed_at; + } + + pub(crate) fn select_response( + &self, + head: &ResponseHead, + filter: AsyncSubresourceFetchResponseFilter, + body_size: usize, + synthetic: bool, + ) { + let mut state = self.0.state.lock(); + if synthetic && state.synthetic_response_start.is_none() { + // A fulfilled/intercepted response is a new client handover. The + // transport that previously supplied a challenge is not its clock. + state.transport = None; + let now = Instant::now(); + state.synthetic_response_start = Some(now); + state.completed_at = Some(now); + } + state.response = Some((head.clone(), filter)); + state.body_size = body_size; + state.awaiting_selection = false; + } + + pub(crate) fn publish(&self, scope: &mut v8::PinScope<'_, '_>) { + self.publish_entry(scope, false, false); + } + + pub(crate) fn reject(&self, scope: &mut v8::PinScope<'_, '_>) { + self.publish_entry(scope, true, false); + } + + pub(crate) fn abort(&self, scope: &mut v8::PinScope<'_, '_>) { + { + let mut state = self.0.state.lock(); + state.aborted = true; + if !state.awaiting_selection + && state.transport.as_ref().is_some_and(|transport| { + transport.response_timing().response_end_at().is_some() + }) + { + // IO has committed its terminal but its Worker delivery may + // still be queued behind running JS. Let that event report. + return; + } + } + self.publish_entry(scope, false, true); + } + + fn publish_entry(&self, scope: &mut v8::PinScope<'_, '_>, rejected: bool, aborted: bool) { + if let Some(entry) = self.take_entry(rejected, aborted) { + crate::context_bootstrap::record_resource_performance_entry(scope, entry); + } + } + + fn take_entry(&self, rejected: bool, aborted: bool) -> Option { + let mut state = self.0.state.lock(); + if state.reported || !matches!(self.0.name.scheme(), "http" | "https") { + return None; + } + state.reported = true; + let aborted = aborted || state.aborted; + let native = state + .transport + .as_ref() + .map(FetchCancelHandle::response_timing); + let completed = !state.awaiting_selection + && native.is_some_and(|timing| timing.response_end_at().is_some()); + let end = if aborted && !completed { + Instant::now() + } else { + native + .and_then(|timing| timing.response_end_at()) + .or(state.completed_at) + .unwrap_or_else(Instant::now) + }; + let start = native + .and_then(|timing| timing.response_started_at()) + .or(state.synthetic_response_start); + state.clock.response_started_at(start); + let body_size = if aborted && !completed { + 0 + } else { + state.body_size + }; + let mode = match &self.0.request { + WorkerTimingRequest::Fetch { mode, .. } => *mode, + WorkerTimingRequest::Xhr { .. } => RequestMode::Cors, + }; + let entry = if !rejected && let Some((head, filter)) = &state.response { + let mut entry = state.clock.completed( + &self.0.name, + &self.0.origin, + mode, + head, + body_size, + Some(filter), + ); + if aborted { + entry.mark_aborted(completed); + } + entry + } else { + state.clock.failed(&self.0.name) + }; + Some(state.clock.completed_at(entry, end)) + } +} diff --git a/moli-renderer-v8/src/worker/global_scope/xhr.rs b/moli-renderer-v8/src/worker/global_scope/xhr.rs index 1d30fcfeb61..3bbc8c27f4d 100644 --- a/moli-renderer-v8/src/worker/global_scope/xhr.rs +++ b/moli-renderer-v8/src/worker/global_scope/xhr.rs @@ -8,6 +8,7 @@ use std::time::{Duration, SystemTime, UNIX_EPOCH}; pub(in crate::worker) struct PreparedWorkerXhrSendRequest { pub(in crate::worker) use_cors_preflight: bool, + timing: WorkerResourceTiming, document_url: Url, resolved_url: Url, blob_url_entry: Option, @@ -227,6 +228,7 @@ pub(in crate::worker) fn worker_xhr_timeout_callback( let pending = state.borrow_mut().pending_xhrs.remove(&scheduled_xhr_id); if let Some(pending) = pending { + pending.timing.abort(scope); pending.load.cancel(); } apply_xhr_timeout(scope, xhr); @@ -406,6 +408,7 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( state.pending_xhrs.insert( xhr_id, PendingWorkerXhr { + timing: prepared.timing.clone(), xhr: v8::Global::new(scope, xhr), credentials_mode: prepared.credentials_mode, @@ -432,6 +435,8 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( let completion_tx = state.borrow().xhr_completion_tx.clone(); let info = worker_xhr_info(&prepared); let request = worker_xhr_request(&state.borrow(), &prepared); + let timing = prepared.timing.clone(); + timing.begin_transport(cancel_handle.clone()); load.task_runner().spawn(async move { let mut request = request; if let Some(body) = request.body.as_ref() { @@ -451,13 +456,22 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( ) .run() .await; + if let Ok(response) = &completed.result { + timing.observe_head(&response.head()); + timing.observe_chunk(response.body_bytes().len()); + } else { + timing.discard_response(); + } + timing.complete(); let _ = completion_tx.send(WorkerXhrEvent::Completion(Box::new(WorkerXhrCompletion { xhr_id, local_request: None, csp_violations: completed.csp_violations, result: completed.result, }))); + let _ = completion_tx.send(WorkerXhrEvent::ResourceTiming { xhr_id: Some(xhr_id), timing }); }); + true } @@ -516,7 +530,9 @@ fn send_synchronous_worker_xhr( loader: crate::network::context::WorkerResourceLoader, control: ControlledXhrContext, ) { + let timing = prepared.timing.clone(); let request_url_text = prepared.resolved_url.to_string(); + let request = worker_xhr_request(&state.borrow(), &prepared); let cancel = state.borrow().network_cancel.child_for_subrequest(); let Some(load) = loader.register_load( @@ -524,6 +540,7 @@ fn send_synchronous_worker_xhr( ResourceLoadDisposition::Ordinary, Some(cancel.clone()), ) else { + timing.reject(scope); throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "NetworkError"); return; }; @@ -532,6 +549,10 @@ fn send_synchronous_worker_xhr( .as_ref() .map(|timeout| after(timeout.wait_delay)) .unwrap_or_else(never); + + timing.begin_transport(cancel.clone()); + let worker_timing = timing.clone(); + let completion_tx = state.borrow().xhr_completion_tx.clone(); let response_rx = start_buffered_xhr( request, worker_xhr_info(&prepared), @@ -539,16 +560,28 @@ fn send_synchronous_worker_xhr( cancel, prepared.request_headers.to_byte_strings(), Some(control), + move |completed| { + if let Ok(response) = &completed.result { + worker_timing.observe_head(&response.head()); + worker_timing.observe_chunk(response.body_bytes().len()); + } else { + worker_timing.discard_response(); + } + worker_timing.complete(); + let _ = completion_tx.send(WorkerXhrEvent::ResourceTiming { xhr_id: None, timing: worker_timing }); + }, ); let result = select! { recv(response_rx) -> result => result.unwrap_or_else(|_| Err("worker sync XHR resource task dropped response channel".into())), recv(timeout_rx) -> _ => { + timing.abort(scope); load.cancel(); throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "TimeoutError"); return; } }; if state.borrow().network_cancel.is_cancelled() { + timing.abort(scope); return; } // The loader has already published the network result independently of JS. @@ -562,14 +595,17 @@ fn send_synchronous_worker_xhr( match result.map(|completion| completion.result) { Ok(Ok(mut response)) => { response.headers = filter_cors_exposed_response_headers( - &worker_global_origin(scope).unwrap_or(moli_url::WebOrigin::Opaque), + timing.origin(), &response.head(), prepared.credentials_mode, ); + timing.publish(scope); apply_xhr_response(scope, xhr, response); } Ok(Err(_)) | Err(_) => { + timing.publish(scope); throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "NetworkError") + } } } @@ -599,6 +635,17 @@ fn worker_xhr_open_generation_changed( pub(crate) fn try_worker_xhr_abort_callback( scope: &mut v8::PinScope<'_, '_>, xhr: v8::Local<'_, v8::Object>, +) -> bool { + if !try_worker_xhr_terminate_fetch(scope, xhr) { + return false; + } + crate::network_host::finish_xhr_abort(scope, xhr); + true +} + +pub(crate) fn try_worker_xhr_terminate_fetch( + scope: &mut v8::PinScope<'_, '_>, + xhr: v8::Local<'_, v8::Object>, ) -> bool { let Some(state) = get_worker_state(scope) else { return false; @@ -614,10 +661,10 @@ pub(crate) fn try_worker_xhr_abort_callback( None }; if let Some(pending) = pending { + pending.timing.abort(scope); pending.load.cancel(); } - crate::network_host::finish_xhr_abort(scope, xhr); true } @@ -627,6 +674,11 @@ pub(in crate::worker) fn drain_worker_xhr_event( event: WorkerXhrEvent, ) { match event { + WorkerXhrEvent::ResourceTiming { xhr_id, timing } => { + if xhr_id.is_none_or(|id| !state.borrow().pending_xhrs.contains_key(&id)) { + timing.publish(scope); + } + } WorkerXhrEvent::Upload { xhr_id, event } => { let xhr = { let state = state.borrow(); @@ -638,6 +690,7 @@ pub(in crate::worker) fn drain_worker_xhr_event( if !apply_xhr_upload_event(scope, xhr, u64::from(xhr_id), event) && let Some(pending) = state.borrow_mut().pending_xhrs.remove(&xhr_id) { + pending.timing.abort(scope); pending.load.cancel(); } } @@ -665,10 +718,12 @@ pub(in crate::worker) fn drain_worker_xhr_completion( || xhr_state_bool_property(scope, xhr, XHR_ABORTED_SLOT).unwrap_or(false) { if let Some(pending) = state.borrow_mut().pending_xhrs.remove(&completion.xhr_id) { + pending.timing.abort(scope); pending.load.cancel(); } return; } + let Some(pending) = state.borrow_mut().pending_xhrs.remove(&completion.xhr_id) else { return; }; @@ -692,16 +747,26 @@ pub(in crate::worker) fn drain_worker_xhr_completion( } match completion.result { Ok(response) => { + if completion.local_request.is_some() { + pending.timing.observe_head(&response.head()); + pending.timing.observe_chunk(response.body_bytes().len()); + pending.timing.complete(); + } let (mut head, body) = response.into_body(); head.headers = filter_cors_exposed_response_headers( - state.borrow().request_origin(), + pending.timing.origin(), &head, pending.credentials_mode, pending.load.request_client().web_security_disabled(), ); + pending.timing.publish(scope); apply_xhr_response_body_source(scope, xhr, head, body); + + } + Err(_) => { + pending.timing.publish(scope); + apply_xhr_failure(scope, xhr); } - Err(_) => apply_xhr_failure(scope, xhr), } } @@ -730,7 +795,17 @@ pub(in crate::worker) fn prepare_worker_xhr_send_request<'s>( RequestCredentialsMode::SameOrigin }; + let request_origin = worker_global_origin(scope).unwrap_or(moli_url::WebOrigin::Opaque); + let timing = WorkerResourceTiming::new( + scope, + resolved_url.clone(), + request_origin, + WorkerTimingRequest::Xhr { + credentials: credentials_mode, + }, + ); Ok(PreparedWorkerXhrSendRequest { + timing, use_cors_preflight: capture_xhr_upload_listener_flag(scope, xhr), document_url, resolved_url, diff --git a/moli-renderer-v8/src/worker/mod.rs b/moli-renderer-v8/src/worker/mod.rs index 24ca7be0ed3..b1fa998b195 100644 --- a/moli-renderer-v8/src/worker/mod.rs +++ b/moli-renderer-v8/src/worker/mod.rs @@ -17,6 +17,7 @@ mod codec_tasks; mod data_url; mod file_reading_tasks; mod global_scope; +pub(crate) use global_scope::WorkerResourceTiming; mod handle; mod inspector_task_runner; mod module_mime; @@ -58,17 +59,17 @@ pub(crate) use global_scope::{ register_worker_opfs_move_task, register_worker_opfs_task, register_worker_webcrypto_task, register_worker_websocket, reserve_nested_worker_context, send_worker_websocket_binary, send_worker_websocket_blob, send_worker_websocket_text, service_worker_runtime_identity, - start_worker_font_face_fetch, try_worker_xhr_abort_callback, try_worker_xhr_reschedule_timeout_after_timeout_change, - try_worker_xhr_send_callback, worker_allows_eval_code_generation_by_csp, + start_worker_font_face_fetch, try_worker_xhr_abort_callback, + try_worker_xhr_reschedule_timeout_after_timeout_change, try_worker_xhr_send_callback, + try_worker_xhr_terminate_fetch, worker_allows_eval_code_generation_by_csp, worker_allows_trusted_type_policy_name_by_csp, worker_allows_trusted_types_eval, - worker_allows_wasm_code_generation_by_csp, - worker_broadcast_channel_registry, worker_broadcast_channel_storage_key, - worker_broadcast_channel_wake_sender, worker_broadcast_channel_wrapper, - worker_content_security_policy_snapshot, worker_current_script_url, worker_global_is_closed, - worker_global_origin, worker_message_port_registry, worker_message_port_wake_sender, - worker_message_port_wrapper, worker_notification_permission_state, - worker_opfs_directory_iterator_registry, worker_opfs_handle_registry, - worker_realm_secure_context_available, worker_referrer_policy, + worker_allows_wasm_code_generation_by_csp, worker_broadcast_channel_registry, + worker_broadcast_channel_storage_key, worker_broadcast_channel_wake_sender, + worker_broadcast_channel_wrapper, worker_content_security_policy_snapshot, + worker_current_script_url, worker_global_is_closed, worker_global_origin, + worker_message_port_registry, worker_message_port_wake_sender, worker_message_port_wrapper, + worker_notification_permission_state, worker_opfs_directory_iterator_registry, + worker_opfs_handle_registry, worker_realm_secure_context_available, worker_referrer_policy, worker_service_worker_control_state, worker_storage_key, worker_storage_partition_identity, worker_termination_requested, worker_trusted_types_for_script_requirements, }; diff --git a/moli-renderer-v8/src/worker/thread/tests/performance_resource_timing.rs b/moli-renderer-v8/src/worker/thread/tests/performance_resource_timing.rs index 1d9a8a9f436..228a2c57a1e 100644 --- a/moli-renderer-v8/src/worker/thread/tests/performance_resource_timing.rs +++ b/moli-renderer-v8/src/worker/thread/tests/performance_resource_timing.rs @@ -58,6 +58,71 @@ fn import_resource_client() -> crate::network::ResourceRequestClientOwner { ResourceRequestClient::new(&config).unwrap() } +#[tokio::test] +async fn worker_fetch_and_xhr_publish_native_resource_timing() { + ensure_v8(); + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let base = format!("http://{}", listener.local_addr().unwrap()); + let script_base = base.clone(); + let server = tokio::spawn(async move { + let mut connections = tokio::task::JoinSet::new(); + loop { + tokio::select! { + accepted = listener.accept() => { + let (mut stream, _) = accepted.unwrap(); + let script_base = script_base.clone(); + connections.spawn(async move { + let Ok(request) = read_http_request_head(&mut stream).await else { return }; + let target = request.lines().next().unwrap().split_whitespace().nth(1).unwrap(); + if target.starts_with("/timing-redirect") { + let _ = stream.write_all(b"HTTP/1.1 302 Found\r\nLocation: /timing-data?redirected=1\r\nContent-Length: 0\r\nConnection: close\r\n\r\n").await; + return; + } + let body = if target.starts_with("/timing-origin-import.js") { + format!("globalThis.__timingImportedFetch = fetch('{script_base}/timing-data?fromImportedScript=1').then(response => response.text()); globalThis.__timingImportedNoCorsFetch = fetch('{script_base}/timing-html?fromImportedScript=1', {{mode: 'no-cors'}}).then(response => response.text());") + } else { "/* worker transport body */".to_owned() }; + let status = if target.starts_with("/timing-404") { "404 Not Found" } else { "200 OK" }; + let cors = if target.starts_with("/timing-cors-deny") { "" } else { "Access-Control-Allow-Origin: *\r\n" }; + let tao = if target.contains("tao=1") { "Timing-Allow-Origin: *\r\n" } else { "" }; + let length = body.len() + if target.starts_with("/timing-broken") { 10 } else { 0 }; + let mime = if target.starts_with("/timing-html") { "text/html" } else { "text/javascript" }; + let head = format!("HTTP/1.1 {status}\r\nContent-Type: {mime}\r\n{cors}{tao}Cross-Origin-Resource-Policy: cross-origin\r\nCache-Control: no-store\r\nContent-Length: {length}\r\nConnection: close\r\n\r\n"); + if stream.write_all(head.as_bytes()).await.is_err() { return; } + if target.starts_with("/timing-delay") || target.starts_with("/timing-hang") { + tokio::time::sleep(Duration::from_millis(150)).await; + } + let _ = stream.write_all(body.as_bytes()).await; + }); + } + Some(result) = connections.join_next() => { result.unwrap(); } + } + } + }); + let source = format!( + r#"const probe = {}; + probe({}).then(result => {{ postMessage(result); close(); }}, + error => {{ postMessage({{error: String(error.stack || error)}}); close(); }});"#, + include_str!("../../../../tests/fixtures/worker-network-resource-timing.js"), + serde_json::to_string(&base).unwrap(), + ); + let mut worker = spawn_worker_with_request_client( + source, + format!("{base}/worker.js"), + import_resource_client(), + ); + let result: serde_json::Value = + serde_json::from_str(&recv_post_json(&mut worker).await).unwrap(); + let checks = result["checks"] + .as_array() + .unwrap_or_else(|| panic!("{result:#}")); + assert_eq!(checks.len(), 86, "{result:#}"); + let failures: Vec<_> = checks.iter().filter(|row| row["passed"] != true).collect(); + assert!(failures.is_empty(), "{failures:#?}\n{result:#}"); + assert!(timeout(TIMEOUT, worker.recv()).await.unwrap().is_none()); + server.abort(); + assert!(server.await.unwrap_err().is_cancelled()); +} + #[tokio::test] async fn worker_import_scripts_publish_native_resources_and_process_buffer_overflow() { ensure_v8(); diff --git a/moli-renderer-v8/tests/fixtures/worker-network-resource-timing.js b/moli-renderer-v8/tests/fixtures/worker-network-resource-timing.js new file mode 100644 index 00000000000..ccff5022e06 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/worker-network-resource-timing.js @@ -0,0 +1,126 @@ +async base => { + const checks=[],observations={}; const p=performance; const Entry=PerformanceResourceTiming; + const test=(name,callback)=>{try{if(!callback())throw Error('assertion failed');checks.push({name,passed:true});}catch(error){checks.push({name,passed:false,details:String(error)});}}; + const tick=()=>new Promise(resolve=>setTimeout(resolve,0)); + const rows=url=>p.getEntriesByName(url,'resource'); + // Opaque text() reads a null public body; its network terminal is a + // separate task. Observe that task instead of treating one timer as a barrier. + const waitForEntry=url=>rows(url).length?Promise.resolve():new Promise((resolve,reject)=>{ + const observer=new PerformanceObserver(list=>{ + if(list.getEntries().some(entry=>entry.name===url)){clearTimeout(timer);observer.disconnect();resolve();} + }); + observer.observe({type:'resource',buffered:true}); + const timer=setTimeout(()=>{observer.disconnect();reject(Error('Missing resource entry: '+url));},2000); + }); + const snapshot=url=>rows(url).map(e=>({name:e.name,initiatorType:e.initiatorType,startTime:e.startTime,duration:e.duration,responseStart:e.responseStart,responseEnd:e.responseEnd,responseStatus:e.responseStatus,transferSize:e.transferSize,encodedBodySize:e.encodedBodySize,decodedBodySize:e.decodedBodySize,nextHopProtocol:e.nextHopProtocol})); + const verify=(label,url,initiator,status)=>{ + const e=rows(url)[0]; observations[label]=snapshot(url); + test(label+': one entry by completion',()=>rows(url).length===1); + test(label+': native resource entry',()=>e instanceof Entry&&e.entryType==='resource'&&e.initiatorType===initiator); + test(label+': requested URL',()=>e.name===url); + test(label+': status',()=>e.responseStatus===status); + test(label+': monotonic timing',()=>e.startTime>=0&&e.duration>=0&&e.responseEnd>=e.startTime&&e.responseEnd<=p.now()+.1); + }; + for(const [label,path] of [['fetch','/timing-data#fragment'],['fetch 404','/timing-404'],['fetch redirect','/timing-redirect']]){ + p.clearResourceTimings();const url=base+path;const r=await fetch(url);await r.text();verify(label,url,'fetch',label==='fetch 404'?404:200); + } + p.clearResourceTimings();{ + const url=base+'/timing-delay';const response=await fetch(url);const clone=response.clone(); + test('streaming fetch waits for EOF',()=>rows(url).length===0); + await response.text();verify('streaming fetch',url,'fetch',200);await clone.text();test('cloned response does not duplicate timing',()=>rows(url).length===1); + } + const xhr=(url,sync)=>sync?new Promise((resolve,reject)=>{try{const x=new XMLHttpRequest();x.open('GET',url,false);x.send();resolve(x);}catch(e){reject(e);}}):new Promise((resolve,reject)=>{const x=new XMLHttpRequest();x.open('GET',url);x.onload=()=>resolve(x);x.onerror=()=>reject(Error('XHR error'));x.send();}); + for(const sync of [false,true]){ + p.clearResourceTimings();const url=base+'/timing-data?xhr='+sync;await xhr(url,sync);verify('XHR '+sync,url,'xmlhttprequest',200); + } + for(const tao of [false,true]){ + p.clearResourceTimings();const url=base.replace('127.0.0.1','localhost')+'/timing-data?cors=1'+(tao?'&tao=1':'');await(await fetch(url)).text();verify('CORS '+tao,url,'fetch',200); + test('CORS '+tao+': readable body sizes',()=>rows(url)[0].decodedBodySize>0); + test('CORS '+tao+': TAO connection fields',()=>tao?rows(url)[0].responseStart>0&&rows(url)[0].transferSize>0:rows(url)[0].responseStart===0&&rows(url)[0].transferSize===0); + } + for(const tao of [false,true]){ + p.clearResourceTimings();const url=base.replace('127.0.0.1','localhost')+'/timing-data?opaque=1'+(tao?'&tao=1':'');await(await fetch(url,{mode:'no-cors'})).text();await waitForEntry(url);observations['opaque '+tao]=snapshot(url); + } + for(const [label,path]of [['broken body','/timing-broken'],['CORS rejection','/timing-cors-deny']]){ + p.clearResourceTimings();const url=(label==='CORS rejection'?base.replace('127.0.0.1','localhost'):base)+path;try{await(await fetch(url)).text();}catch{}await tick();observations[label]=snapshot(url); + } + for(const afterHeaders of [false,true]){ + p.clearResourceTimings();const url=base+'/timing-hang?abort='+afterHeaders;const c=new AbortController();const promise=fetch(url,{signal:c.signal}); + if(afterHeaders){const r=await promise;c.abort();try{await r.text();}catch{}} + else{c.abort();try{await promise;}catch{}} + await tick();observations['abort '+afterHeaders]=snapshot(url); + } + p.clearResourceTimings();await(await fetch('data:text/plain,local')).text();await tick();observations.local=p.getEntriesByType('resource').map(e=>e.name); + const descriptor=Object.getOwnPropertyDescriptor(globalThis,'performance');const url=base+'/timing-data?shadow=1'; + try{Object.defineProperty(globalThis,'performance',{value:{},configurable:true});await(await fetch(url)).text();} + finally{if(descriptor)Object.defineProperty(globalThis,'performance',descriptor);else delete globalThis.performance;} + test('native Performance survives author shadowing',()=>rows(url).length===1); + + test('opaque body information remains hidden',()=>[false,true].every(tao=>{ + const entries=observations['opaque '+tao]; + return entries.length===1&&entries[0].responseStatus===0&&entries[0].encodedBodySize===0&&entries[0].decodedBodySize===0; + })); + test('broken body retains status and received bytes',()=>{ + const e=observations['broken body'][0];return e&&e.responseStatus===200&&e.encodedBodySize===27&&e.decodedBodySize===27; + }); + test('CORS rejection hides response metadata',()=>{ + const e=observations['CORS rejection'][0];return e&&e.responseStatus===0&&e.responseStart===0&&e.transferSize===0&&e.decodedBodySize===0; + }); + test('early abort reports one failed entry',()=>{ + const entries=observations['abort false'];const e=entries[0];return entries.length===1&&e.responseStatus===0&&e.responseStart===0&&e.transferSize===0; + }); + test('abort after headers retains allowed connection timing',()=>{ + const entries=observations['abort true'];const e=entries[0];return entries.length===1&&e.responseStatus===0&&e.responseStart>0&&e.transferSize===300&&e.decodedBodySize===0; + }); + test('data URL does not create a resource entry',()=>observations.local.length===0); + for(const sync of [false,true]){ + p.clearResourceTimings();const url=base.replace('127.0.0.1','localhost')+'/timing-data?corsXhr='+sync; + await xhr(url,sync);verify('CORS XHR '+sync,url,'xmlhttprequest',200); + test('CORS XHR '+sync+': readable sizes without TAO',()=>rows(url)[0].decodedBodySize===27&&rows(url)[0].transferSize===0); + p.clearResourceTimings();const broken=base+'/timing-broken?xhr='+sync; + try{await xhr(broken,sync);}catch{} + const entries=rows(broken);const e=entries[0];observations['broken XHR '+sync]=snapshot(broken); + test('broken XHR '+sync+': retains received bytes',()=>entries.length===1&&e.responseStatus===200&&e.decodedBodySize===27); + } + for(const kind of ['abort','timeout']){ + p.clearResourceTimings();const url=base+'/timing-hang?xhr='+kind;const x=new XMLHttpRequest(); + await new Promise(resolve=>{ + x.open('GET',url);x.onloadend=resolve;if(kind==='timeout')x.timeout=20; + x.send();if(kind==='abort')x.abort(); + }); + await tick();const entries=rows(url);const e=entries[0];observations['XHR '+kind]=snapshot(url); + test('XHR '+kind+': one failure before loadend',()=>entries.length===1&&e.responseStatus===0&&e.decodedBodySize===0); + } + p.clearResourceTimings();{ + const old=base+'/timing-hang?xhr=replaced';const url=base+'/timing-data?xhr=replacement';const x=new XMLHttpRequest();let aborts=0; + x.onabort=()=>aborts++; + await new Promise((resolve,reject)=>{ + x.open('GET',old);x.send();x.open('GET',url);x.onload=resolve;x.onerror=reject;x.send(); + }); + verify('reopened XHR',url,'xmlhttprequest',200);await tick();const entries=rows(old); + test('XHR open retires the old timing owner',()=>entries.length===1&&entries[0].responseStatus===0); + test('XHR open does not dispatch abort',()=>aborts===0); + } + p.clearResourceTimings();{ + const url=base+'/timing-data?fromImportedScript=1'; + importScripts(base.replace('127.0.0.1','localhost')+'/timing-origin-import.js'); + await globalThis.__timingImportedFetch; + verify('fetch from imported script',url,'fetch',200); + test('imported script keeps the Worker origin',()=>rows(url)[0].responseStart>0&&rows(url)[0].transferSize>0); + const body=await globalThis.__timingImportedNoCorsFetch; + const noCors=rows(base+'/timing-html?fromImportedScript=1'); + test('imported script no-cors HTML stays readable for its Worker origin',()=>body==='/* worker transport body */'); + test('imported script no-cors timing remains same-origin',()=>noCors.length===1&&noCors[0].responseStatus===200&&noCors[0].responseStart>0); + + } + p.clearResourceTimings();{ + const url=base+'/timing-delay?lateAbort=1';const controller=new AbortController(); + const response=await fetch(url,{signal:controller.signal}); + const blockStart=p.now();while(p.now()-blockStart<450){} + const blockEnd=p.now();controller.abort();try{await response.text();}catch{} + await waitForEntry(url);const entries=rows(url);const e=entries[0];observations.lateAbort=snapshot(url); + test('late JS abort preserves completed bytes and reports abort status',()=>entries.length===1&&e.responseStatus===0&&e.decodedBodySize===27); + test('response end precedes delayed Worker delivery',()=>e.responseEnd