From 03776063e6181e02706becb2dd3e12e7a8ac032d Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sat, 14 Nov 2026 05:33:34 +0800 Subject: [PATCH] feat(fetch): add event-loop idle wait mode Wait for user timers, native async operations, dedicated workers, WebSockets and receiving MessagePorts using their existing resource owners and Page task sources. Finish a microtask checkpoint before observing exhaustion, drain terminal callbacks, and follow replacement navigations through the shared idle wait driver. Apply the existing absolute timeout to idle readiness and recheck after automation scripts. Keep internal AbortSignal timeouts and transferable-stream plumbing from independently retaining the loop. Add CLI and native observer regressions. --- moli-core/src/page/wait_support.rs | 19 + moli-core/src/runtime/fetch_deadline.rs | 2 + moli-core/src/runtime/mod.rs | 34 +- moli-renderer-v8/src/context_bootstrap.rs | 3 +- .../src/context_bootstrap/message_ports.rs | 4 +- .../context_bootstrap/message_ports/state.rs | 17 + .../src/document_runtime/events.rs | 16 +- moli-renderer-v8/src/host/timers.rs | 11 +- moli-renderer-v8/src/lib.rs | 7 + .../src/native_bridge/abort/statics.rs | 12 +- .../native_bridge/context_host/activity.rs | 30 ++ moli-renderer-v8/src/runtime/mod.rs | 49 +- moli-renderer-v8/src/runtime/owner.rs | 19 +- .../src/runtime/owner/owner_commands.rs | 10 +- .../src/runtime/owner/owner_loop.rs | 4 +- .../src/runtime/owner/page_commands.rs | 42 +- .../src/runtime/owner/page_turn_completion.rs | 19 +- moli-renderer-v8/src/runtime/owner_local.rs | 29 +- .../src/runtime/owner_local_store/bound.rs | 30 +- .../src/runtime/owner_local_store/mod.rs | 14 +- moli-renderer-v8/src/runtime/page_network.rs | 56 +- .../runtime/page_vm/tests/wait_observer.rs | 60 ++- moli-renderer-v8/src/script_vm.rs | 1 + moli-renderer-v8/src/script_vm/event_loop.rs | 39 ++ moli-time/src/timers.rs | 21 + moli/src/app.rs | 12 +- moli/src/app/readiness.rs | 16 +- moli/src/cli.rs | 7 +- moli/tests/fetch_cli.rs | 2 + moli/tests/fetch_cli/idle.rs | 487 ++++++++++++++++++ 30 files changed, 973 insertions(+), 99 deletions(-) create mode 100644 moli-renderer-v8/src/script_vm/event_loop.rs create mode 100644 moli/tests/fetch_cli/idle.rs diff --git a/moli-core/src/page/wait_support.rs b/moli-core/src/page/wait_support.rs index 99e8d0049f2..ee74e77a219 100644 --- a/moli-core/src/page/wait_support.rs +++ b/moli-core/src/page/wait_support.rs @@ -194,4 +194,23 @@ impl Page { RendererPageReply::Unit => Ok(()), ) } + + pub(crate) async fn wait_for_idle( + &mut self, + loader: &ResourceRequestClient, + timeout: Duration, + ) -> Result<()> { + let timeout_ms = timeout.as_millis().min(u128::from(u64::MAX)) as u64; + let (reply, page_state) = self + .handle + .wait_for_idle(timeout_ms, loader.clone()) + .await?; + self.replace_page_state(page_state); + expect_page_reply!( + reply, + "wait for event loop idle page command", + "a unit reply", + RendererPageReply::Unit => Ok(()), + ) + } } diff --git a/moli-core/src/runtime/fetch_deadline.rs b/moli-core/src/runtime/fetch_deadline.rs index 556b98dd902..e9d50128607 100644 --- a/moli-core/src/runtime/fetch_deadline.rs +++ b/moli-core/src/runtime/fetch_deadline.rs @@ -16,6 +16,7 @@ pub enum FetchTimeoutPhase { WaitingForSubresourceResponse, WaitingForSelector, WaitingForScript, + WaitingForIdle, } impl FetchTimeoutPhase { @@ -54,6 +55,7 @@ impl fmt::Display for FetchTimeoutPhase { Self::WaitingForSubresourceResponse => "waiting for a subresource response", Self::WaitingForSelector => "waiting for a selector", Self::WaitingForScript => "waiting for a script to become truthy", + Self::WaitingForIdle => "waiting for idle", }) } } diff --git a/moli-core/src/runtime/mod.rs b/moli-core/src/runtime/mod.rs index 96c73152e79..1fa4268eae3 100644 --- a/moli-core/src/runtime/mod.rs +++ b/moli-core/src/runtime/mod.rs @@ -100,6 +100,7 @@ fn is_fetch_readiness_timeout(error: &anyhow::Error, wait_until: RenderedDomWait RenderedDomWaitUntil::DomStable => "timed out waiting for domstable", RenderedDomWaitUntil::DomContentLoaded | RenderedDomWaitUntil::Load + | RenderedDomWaitUntil::Idle | RenderedDomWaitUntil::Done => return false, }; @@ -179,6 +180,10 @@ pub enum RenderedDomWaitUntil { Load, NetworkIdle, DomStable, + /// Drain user-owned asynchronous work and its callbacks after Load. + /// Future timers and live resources keep this wait pending; an unbacked + /// Promise does not. Unlike NetworkIdle, timeout is an error. + Idle, Done, } @@ -189,7 +194,7 @@ impl RenderedDomWaitUntil { fn base_stage(self) -> PageVmInitStage { match self { Self::DomContentLoaded | Self::DomStable => PageVmInitStage::DomContentLoaded, - Self::Load | Self::NetworkIdle | Self::Done => PageVmInitStage::Load, + Self::Load | Self::NetworkIdle | Self::Idle | Self::Done => PageVmInitStage::Load, } } @@ -510,8 +515,8 @@ impl Browser { } /// Reaches the concrete lifecycle boundary that makes a live Page - /// available. For NetworkIdle and DomStable this is only the Load or DCL - /// base stage; their best-effort observation runs outside materialization. + /// available. For Idle, NetworkIdle and DomStable this is only the Load or + /// DCL base stage; their observations run outside materialization. async fn fetch_document_to_base_stage( &self, request: Request, @@ -729,6 +734,14 @@ impl Browser { .await } + /// Waits for user timers, network operations and live Worker, WebSocket and + /// receiving MessagePort resources to finish, including their callbacks. + pub async fn wait_for_page_idle(&self, page: &mut Page, timeout: Duration) -> Result<()> { + let deadline = FetchDeadline::new(timeout)?; + self.wait_for_page_readiness_with_deadline(page, RenderedDomWaitUntil::Idle, deadline) + .await + } + pub async fn wait_for_selector( &self, page: &mut Page, @@ -819,18 +832,28 @@ impl Browser { .await } - /// Observes NetworkIdle or DomStable with the unspent part of `deadline`. + /// Observes Idle, NetworkIdle or DomStable with the unspent deadline. /// /// A timeout in this observation is deliberately best-effort: the Page /// has already reached its required Load/DCL base stage, so the current /// snapshot is returned with a warning. Errors unrelated to timeout still - /// fail the fetch. Concrete lifecycle modes are no-ops here. + /// fail the fetch. Idle requires resource exhaustion and propagates timeout + /// as an error. Concrete lifecycle modes are no-ops here. pub async fn wait_for_page_readiness_with_deadline( &self, page: &mut Page, wait_until: RenderedDomWaitUntil, deadline: FetchDeadline, ) -> Result<()> { + if wait_until == RenderedDomWaitUntil::Idle { + let loader = self.resource_request_client(); + return deadline + .wait( + FetchTimeoutPhase::WaitingForIdle, + page.wait_for_idle(&loader, deadline.timeout()), + ) + .await; + } if !wait_until.has_best_effort_page_wait() { return Ok(()); } @@ -851,6 +874,7 @@ impl Browser { } RenderedDomWaitUntil::DomContentLoaded | RenderedDomWaitUntil::Load + | RenderedDomWaitUntil::Idle | RenderedDomWaitUntil::Done => unreachable!( "concrete lifecycle modes returned before starting a best-effort Page wait" ), diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs index a8b7f74e488..5118547b4b2 100644 --- a/moli-renderer-v8/src/context_bootstrap.rs +++ b/moli-renderer-v8/src/context_bootstrap.rs @@ -419,7 +419,8 @@ pub(crate) use self::message_ports::{ discard_message_port_channel, dispatch_message_port_events_for_port_collecting_errors, dispatch_one_authorized_message_port_event, ensure_message_port_wrapper_for_id, ensure_message_port_wrapper_for_id_in_realm, message_port_id_from_object, - message_port_transfer_from_object, new_disconnected_message_port_object, + message_port_keeps_event_loop_alive, message_port_transfer_from_object, + new_disconnected_message_port_object, }; pub(crate) use self::microtask_checkpoint::{ install_agent_microtask_checkpoint_tasks, run_end_of_microtask_checkpoint_tasks, diff --git a/moli-renderer-v8/src/context_bootstrap/message_ports.rs b/moli-renderer-v8/src/context_bootstrap/message_ports.rs index 26e758477de..dfe00b7db2f 100644 --- a/moli-renderer-v8/src/context_bootstrap/message_ports.rs +++ b/moli-renderer-v8/src/context_bootstrap/message_ports.rs @@ -24,8 +24,8 @@ pub(crate) use state::{ MessagePortRealmBinding, TransferredMessagePort, detach_message_port_owner_for_transfer, detach_transferred_message_port, discard_message_port_channel, ensure_message_port_wrapper_for_id, ensure_message_port_wrapper_for_id_in_realm, - message_port_id_from_object, message_port_transfer_from_object, - new_disconnected_message_port_object, + message_port_id_from_object, message_port_keeps_event_loop_alive, + message_port_transfer_from_object, new_disconnected_message_port_object, }; pub(in crate::context_bootstrap) use state::{ close_message_port_object, current_message_port_registry, set_internal_message_port_handlers, diff --git a/moli-renderer-v8/src/context_bootstrap/message_ports/state.rs b/moli-renderer-v8/src/context_bootstrap/message_ports/state.rs index 536fd7d11ce..79ffc68f389 100644 --- a/moli-renderer-v8/src/context_bootstrap/message_ports/state.rs +++ b/moli-renderer-v8/src/context_bootstrap/message_ports/state.rs @@ -12,6 +12,7 @@ use crate::{ use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject}; const MESSAGE_PORT_ID_SLOT: &str = "__lmMessagePortId"; +const MESSAGE_PORT_INTERNAL_SLOT: &str = "__lmMessagePortInternal"; /// A closed connection remains transferable; a neutered wrapper does not. #[derive(Clone, Copy, Debug)] @@ -447,6 +448,19 @@ pub(in crate::context_bootstrap::message_ports) fn message_port_is_closed<'s>( message_port_bool_slot(scope, port, MESSAGE_PORT_CLOSED_SLOT).unwrap_or(false) } +/// Inspect native slots and listener storage, without invoking author getters. +pub(crate) fn message_port_keeps_event_loop_alive<'s>( + scope: &mut v8::PinScope<'s, '_>, + port: v8::Local<'s, v8::Object>, +) -> bool { + !message_port_is_closed(scope, port) + && message_port_is_started(scope, port) + && !message_port_bool_slot(scope, port, MESSAGE_PORT_INTERNAL_SLOT).unwrap_or(false) + && ["message", "messageerror"].iter().any(|event_type| { + !simple_object_event_listeners_snapshot(scope, port, event_type).is_empty() + }) +} + fn message_port_onmessage_getter_callback<'s>( scope: &mut v8::PinScope<'s, '_>, args: v8::FunctionCallbackArguments<'s>, @@ -563,6 +577,9 @@ pub(in crate::context_bootstrap) fn set_internal_message_port_handlers<'s>( onmessage: v8::Local<'s, v8::Function>, onmessageerror: v8::Local<'s, v8::Function>, ) { + // Transferable streams use private ports for bookkeeping. A pending read + // without an active producer must not keep the host event loop alive. + set_message_port_bool_slot(scope, port, MESSAGE_PORT_INTERNAL_SLOT, true); set_message_port_event_handler( scope, port, diff --git a/moli-renderer-v8/src/document_runtime/events.rs b/moli-renderer-v8/src/document_runtime/events.rs index 59e39000ce1..610a4ff48dd 100644 --- a/moli-renderer-v8/src/document_runtime/events.rs +++ b/moli-renderer-v8/src/document_runtime/events.rs @@ -92,7 +92,17 @@ impl DocumentRuntime { scope: &mut v8::PinScope<'s, '_>, callback: v8::Local<'s, v8::Function>, ) -> bool { - self.timeouts.queue_internal_task(scope, callback) + self.queue_internal_task_after(scope, callback, 0) + } + + pub(crate) fn queue_internal_task_after<'s>( + &mut self, + scope: &mut v8::PinScope<'s, '_>, + callback: v8::Local<'s, v8::Function>, + delay_ms: u64, + ) -> bool { + self.timeouts + .queue_internal_task_after(scope, callback, delay_ms) } pub(crate) fn queue_timeout_with_receiver<'s>( @@ -322,6 +332,10 @@ impl DocumentRuntime { self.timeouts.ms_to_next() } + pub(crate) fn has_keep_alive_timers(&self) -> bool { + self.timeouts.has_keep_alive_timers() + } + pub(crate) fn next_timeout_deadline(&self) -> Option { self.timeouts.next_deadline() } diff --git a/moli-renderer-v8/src/host/timers.rs b/moli-renderer-v8/src/host/timers.rs index c90e03fa6d8..83be5d7b636 100644 --- a/moli-renderer-v8/src/host/timers.rs +++ b/moli-renderer-v8/src/host/timers.rs @@ -278,10 +278,11 @@ impl HostTimeoutScheduler { /// Browser tasks share the Window task scheduler and its retirement checks, /// but are not JS timer handles that clearTimeout can cancel. /// Returns whether the task was admitted by the owner and Realm checks. - pub(crate) fn queue_internal_task<'s>( + pub(crate) fn queue_internal_task_after<'s>( &mut self, scope: &mut v8::PinScope<'s, '_>, callback: v8::Local<'s, v8::Function>, + delay_ms: u64, ) -> bool { let receiver = scope.get_current_context().global(scope); let Some(callback) = scheduled_timer_function(scope, callback, receiver) else { @@ -302,7 +303,7 @@ impl HostTimeoutScheduler { is_interval: false, extra_args: Vec::new(), }, - 0, + delay_ms, Instant::now(), ); true @@ -968,6 +969,12 @@ impl HostTimeoutScheduler { self.scheduler.ms_to_next(Instant::now()) } + pub(crate) fn has_keep_alive_timers(&self) -> bool { + self.scheduler.has_pending_matching(|task| { + !matches!(task.callback, ScheduledTimerCallback::InternalFunction(_)) + }) + } + pub(crate) fn next_deadline(&self) -> Option { self.scheduler.next_deadline() } diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rs index 95c133bed82..9112bcf418b 100644 --- a/moli-renderer-v8/src/lib.rs +++ b/moli-renderer-v8/src/lib.rs @@ -365,6 +365,13 @@ pub enum PageVmInitStage { Load, } +/// Host observations of a live Page, independent of its browser lifecycle. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum RendererPageIdleWaitMode { + Network, + EventLoop, +} + #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum RendererReplyBoundary { /// Resolve page creation only after the requested lifecycle milestone. diff --git a/moli-renderer-v8/src/native_bridge/abort/statics.rs b/moli-renderer-v8/src/native_bridge/abort/statics.rs index 5d196cbc73e..a0829d24db5 100644 --- a/moli-renderer-v8/src/native_bridge/abort/statics.rs +++ b/moli-renderer-v8/src/native_bridge/abort/statics.rs @@ -54,15 +54,9 @@ pub(crate) fn abort_signal_timeout_callback<'s>( rv.set(signal.into()); return; }; - let timeout_id = host.queue_timeout( - scope, - callback, - parsed.milliseconds, - crate::host::HostTimerOwner::Window, - Vec::new(), - ); - // AbortSignal.timeout() intentionally exposes no cancel handle. - let _ = timeout_id; + // This is browser work, not a user timer: it has no clearTimeout handle + // and does not independently keep an explicit event-loop wait alive. + host.queue_internal_task_after(scope, callback, parsed.milliseconds); rv.set(signal.into()); } diff --git a/moli-renderer-v8/src/native_bridge/context_host/activity.rs b/moli-renderer-v8/src/native_bridge/context_host/activity.rs index 6e923a3ec17..ad6513c07bd 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/activity.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/activity.rs @@ -3,6 +3,36 @@ use super::*; use crate::dom::native::Node; impl PageScriptHost { + /// User-owned resources that can still deliver Window callbacks. Runtime + /// service lanes, inspector queues and storage maintenance are excluded. + pub(crate) fn has_event_loop_keep_alive_resources( + &self, + scope: &mut v8::PinScope<'_, '_>, + ) -> bool { + !self.websockets.is_empty() + || self.workers.values().any(|worker| match &worker.execution { + WorkerExecutionState::Loading { terminated, .. } => !terminated, + // The canonical connection stays registered until both relay + // queues have delivered their terminal markers. A closed + // worker inbox alone could overtake its final postMessage. + WorkerExecutionState::Running { .. } => true, + }) + || self.message_port_wrappers.iter().any(|(port_id, entry)| { + if !self.window_execution_context_identity_is_current(entry.identity) + || self + .message_port_registry + .message_port_peer_id(*port_id) + .is_none() + { + return false; + } + let context = v8::Local::new(scope, &entry.context); + let scope = &mut v8::ContextScope::new(scope, context); + let port = v8::Local::new(scope, &entry.wrapper); + crate::context_bootstrap::message_port_keeps_event_loop_alive(scope, port) + }) + } + pub(crate) fn document_has_browsing_context(&self, document: DomHandle) -> bool { // A detached iframe compatibility window can be a document's defaultView // without registering a browsing context. Check the native association. diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rs index 857f8caf0d7..6366cdcdf32 100644 --- a/moli-renderer-v8/src/runtime/mod.rs +++ b/moli-renderer-v8/src/runtime/mod.rs @@ -777,15 +777,15 @@ impl PageVmFollowedNavigationMetadata { } } -pub(super) enum PageVmNetworkIdleWaitAdvance { +pub(super) enum PageVmIdleWaitAdvance { Completed, TriggeredNavigation, Progressed { - state: PageVmNetworkIdleWaitState, + state: PageVmIdleWaitState, }, Waiting { sleep_for: std::time::Duration, - state: PageVmNetworkIdleWaitState, + state: PageVmIdleWaitState, }, } @@ -796,10 +796,45 @@ pub(super) enum PageVmSubresourceResponseWaitAdvance { Waiting { sleep_for: std::time::Duration }, } -#[derive(Default)] -pub(super) struct PageVmNetworkIdleWaitState { - quiet_since: Option, - observed_activity_epoch: Option, +#[derive(Clone, Copy)] +pub(super) enum PageVmIdleWaitState { + Network { + quiet_since: Option, + observed_activity_epoch: Option, + }, + EventLoop, +} + +impl Default for PageVmIdleWaitState { + fn default() -> Self { + Self::Network { + quiet_since: None, + observed_activity_epoch: None, + } + } +} + +impl PageVmIdleWaitState { + fn new(mode: crate::RendererPageIdleWaitMode) -> Self { + match mode { + crate::RendererPageIdleWaitMode::Network => Self::default(), + crate::RendererPageIdleWaitMode::EventLoop => Self::EventLoop, + } + } + + fn label(self) -> &'static str { + match self { + Self::Network { .. } => "networkidle", + Self::EventLoop => "idle", + } + } + + fn reset(self) -> Self { + match self { + Self::Network { .. } => Self::default(), + Self::EventLoop => Self::EventLoop, + } + } } #[derive(Default)] diff --git a/moli-renderer-v8/src/runtime/owner.rs b/moli-renderer-v8/src/runtime/owner.rs index d05324a4bc5..f145a6b1d4c 100644 --- a/moli-renderer-v8/src/runtime/owner.rs +++ b/moli-renderer-v8/src/runtime/owner.rs @@ -17,8 +17,7 @@ use super::owner_local_store::{ RendererPreparedDocumentResidence, RetiringPageEntry, advance_document_lifecycle_one_page_turn_via_local_task, advance_dom_stable_wait_turn_on_entry_via_local_task, - advance_network_idle_wait_turn_on_entry_via_local_task, - advance_page_owner_one_turn_via_local_task, + advance_idle_wait_turn_on_entry_via_local_task, advance_page_owner_one_turn_via_local_task, advance_pending_phase_one_navigation_on_entry_via_local_task, advance_runtime_command_lifecycle_on_entry_via_local_task, advance_runtime_expression_await_turn_on_entry_via_local_task, @@ -34,7 +33,8 @@ use super::owner_local_store::{ dispatch_async_command_on_entry_via_local_task, finalize_pending_page_creation_on_bound_owner_local_store, follow_pending_location_navigation_one_turn_on_entry_via_local_task, - has_pending_document_lifecycle_turn_on_entry, install_page_vm_on_bound_owner_local_store, + has_pending_document_lifecycle_turn_on_entry, has_ready_page_tasks_on_bound_owner_local_store, + install_page_vm_on_bound_owner_local_store, install_phase_one_blocked_page_on_bound_owner_local_store, next_owner_maintenance_deadline_on_bound_owner_local_store, next_page_task_deadline_on_bound_owner_local_store, observe_document_lifecycle_on_entry, @@ -265,8 +265,9 @@ pub enum RendererOwnerCommand { inspector_session_id: Option, pause_guard: RendererRuntimeInspectorSessionDetachGuard, }, - WaitForNetworkIdle { + WaitForIdle { token: RendererPageToken, + mode: crate::RendererPageIdleWaitMode, timeout_ms: u64, loader: ResourceRequestClient, }, @@ -736,9 +737,9 @@ enum RenderRuntimeTurn { token: RendererPageToken, document: RendererDocumentLifecycleIdentity, }, - WaitLivePageNetworkIdle { + WaitLivePageIdle { token: RendererPageToken, - state: PageVmNetworkIdleWaitState, + state: PageVmIdleWaitState, deadline: Instant, loader: ResourceRequestClient, }, @@ -830,7 +831,7 @@ impl RenderRuntimeTurn { Self::RunDevToolsMainCommand { token, .. } | Self::RunLivePageCommand { token, .. } | Self::ContinueLivePageRuntimeCommandLifecycle { token, .. } - | Self::WaitLivePageNetworkIdle { token, .. } + | Self::WaitLivePageIdle { token, .. } | Self::WaitLivePageDomStable { token, .. } | Self::WaitLivePageSelector { token, .. } | Self::WaitLivePageScriptTruthy { token, .. } @@ -843,7 +844,7 @@ impl RenderRuntimeTurn { fn committed_page_view_deadline(&self) -> Option { match self { - Self::WaitLivePageNetworkIdle { deadline, .. } + Self::WaitLivePageIdle { deadline, .. } | Self::WaitLivePageDomStable { deadline, .. } | Self::WaitLivePageSelector { deadline, .. } | Self::WaitLivePageScriptTruthy { deadline, .. } @@ -1019,7 +1020,7 @@ fn renderer_command_admission_page_token( match command { RendererOwnerCommand::RunAsyncPageCommand { token, .. } | RendererOwnerCommand::RunProtocolPageCommand { token, .. } - | RendererOwnerCommand::WaitForNetworkIdle { token, .. } + | RendererOwnerCommand::WaitForIdle { token, .. } | RendererOwnerCommand::WaitForDomStable { token, .. } => Some(*token), _ => None, } diff --git a/moli-renderer-v8/src/runtime/owner/owner_commands.rs b/moli-renderer-v8/src/runtime/owner/owner_commands.rs index 6f428085811..56fbc1fa312 100644 --- a/moli-renderer-v8/src/runtime/owner/owner_commands.rs +++ b/moli-renderer-v8/src/runtime/owner/owner_commands.rs @@ -786,23 +786,25 @@ impl RendererOwnerHandle { )) .into() } - RendererOwnerCommand::WaitForNetworkIdle { + RendererOwnerCommand::WaitForIdle { token, + mode, timeout_ms, loader, } => { + let state = PageVmIdleWaitState::new(mode); let deadline = match checked_live_page_wait_deadline( Instant::now(), timeout_ms, - "networkidle", + state.label(), ) { Ok(deadline) => deadline, Err(error) => return Err(error).into(), }; RenderRuntimeDispatchOutcome::ContinueNextTurn(Box::new( - RenderRuntimeTurn::WaitLivePageNetworkIdle { + RenderRuntimeTurn::WaitLivePageIdle { token, - state: PageVmNetworkIdleWaitState::default(), + state, deadline, loader, }, diff --git a/moli-renderer-v8/src/runtime/owner/owner_loop.rs b/moli-renderer-v8/src/runtime/owner/owner_loop.rs index 514b534a1ae..726809ba120 100644 --- a/moli-renderer-v8/src/runtime/owner/owner_loop.rs +++ b/moli-renderer-v8/src/runtime/owner/owner_loop.rs @@ -1136,13 +1136,13 @@ impl RendererOwnerHandle { self.signal_internal_document_lifecycle_turn_if_resident(token, document); RenderRuntimeDispatchOutcome::BackgroundComplete(Ok(())) } - RenderRuntimeTurn::WaitLivePageNetworkIdle { + RenderRuntimeTurn::WaitLivePageIdle { token, state, deadline, loader, } => { - self.wait_live_page_network_idle_turn(token, state, deadline, loader) + self.wait_live_page_idle_turn(token, state, deadline, loader) .await } RenderRuntimeTurn::WaitLivePageDomStable { diff --git a/moli-renderer-v8/src/runtime/owner/page_commands.rs b/moli-renderer-v8/src/runtime/owner/page_commands.rs index d88376dd8fb..2dd007a6913 100644 --- a/moli-renderer-v8/src/runtime/owner/page_commands.rs +++ b/moli-renderer-v8/src/runtime/owner/page_commands.rs @@ -426,10 +426,10 @@ impl RendererOwnerHandle { .await } - pub(super) async fn wait_live_page_network_idle_turn( + pub(super) async fn wait_live_page_idle_turn( &self, token: RendererPageToken, - state: PageVmNetworkIdleWaitState, + state: PageVmIdleWaitState, deadline: Instant, loader: ResourceRequestClient, ) -> RenderRuntimeDispatchOutcome { @@ -440,9 +440,9 @@ impl RendererOwnerHandle { let remaining = deadline.saturating_duration_since(Instant::now()); if remaining.is_zero() { self.restore_live_page_entry(token, entry); - return Err(anyhow!("timed out waiting for networkidle")).into(); + return Err(anyhow!("timed out waiting for {}", state.label())).into(); } - let (entry, wait_result) = advance_network_idle_wait_turn_on_entry_via_local_task( + let (mut entry, wait_result) = advance_idle_wait_turn_on_entry_via_local_task( self.state.local_executor.clone(), entry, state, @@ -450,7 +450,21 @@ impl RendererOwnerHandle { ) .await; match wait_result { - Ok(PageVmNetworkIdleWaitAdvance::Completed) => { + Ok(PageVmIdleWaitAdvance::Completed) + if matches!(state, PageVmIdleWaitState::EventLoop) + && has_ready_page_tasks_on_bound_owner_local_store(token, &mut entry) => + { + self.restore_live_page_entry(token, entry); + RenderRuntimeDispatchOutcome::ContinueNextTurn(Box::new( + RenderRuntimeTurn::WaitLivePageIdle { + token, + state, + deadline, + loader, + }, + )) + } + Ok(PageVmIdleWaitAdvance::Completed) => { self.finish_live_page_entry_with_page_state( token, entry, @@ -459,18 +473,22 @@ impl RendererOwnerHandle { ) .await } - Ok(PageVmNetworkIdleWaitAdvance::TriggeredNavigation) => self + Ok(PageVmIdleWaitAdvance::TriggeredNavigation) => self .continue_live_page_pending_navigation( token, entry, PageVmInitStage::Load, 0, - LivePagePendingNavigationCompletion::ContinueNetworkIdle { deadline, loader }, + LivePagePendingNavigationCompletion::ContinueIdle { + state, + deadline, + loader, + }, ), - Ok(PageVmNetworkIdleWaitAdvance::Progressed { state }) => { + Ok(PageVmIdleWaitAdvance::Progressed { state }) => { self.restore_live_page_entry(token, entry); RenderRuntimeDispatchOutcome::ContinueNextTurn(Box::new( - RenderRuntimeTurn::WaitLivePageNetworkIdle { + RenderRuntimeTurn::WaitLivePageIdle { token, state, deadline, @@ -478,10 +496,10 @@ impl RendererOwnerHandle { }, )) } - Ok(PageVmNetworkIdleWaitAdvance::Waiting { sleep_for, state }) => { + Ok(PageVmIdleWaitAdvance::Waiting { sleep_for, state }) => { if Instant::now() >= deadline { self.restore_live_page_entry(token, entry); - Err(anyhow!("timed out waiting for networkidle")).into() + Err(anyhow!("timed out waiting for {}", state.label())).into() } else { self.restore_live_page_entry(token, entry); let ready_at = Instant::now() @@ -489,7 +507,7 @@ impl RendererOwnerHandle { .unwrap_or(deadline) .min(deadline); RenderRuntimeDispatchOutcome::ContinueAfterPageWakeOrDeadline { - turn: Box::new(RenderRuntimeTurn::WaitLivePageNetworkIdle { + turn: Box::new(RenderRuntimeTurn::WaitLivePageIdle { token, state, deadline, diff --git a/moli-renderer-v8/src/runtime/owner/page_turn_completion.rs b/moli-renderer-v8/src/runtime/owner/page_turn_completion.rs index 5a12e01071e..39c176e5542 100644 --- a/moli-renderer-v8/src/runtime/owner/page_turn_completion.rs +++ b/moli-renderer-v8/src/runtime/owner/page_turn_completion.rs @@ -123,7 +123,7 @@ impl RendererOwnerHandle { | RenderRuntimeTurn::RunDevToolsMainCommand { .. } | RenderRuntimeTurn::RunLivePageCommand { .. } | RenderRuntimeTurn::ResumeLivePageDocumentLifecycleAfterReply { .. } - | RenderRuntimeTurn::WaitLivePageNetworkIdle { .. } + | RenderRuntimeTurn::WaitLivePageIdle { .. } | RenderRuntimeTurn::WaitLivePageDomStable { .. } | RenderRuntimeTurn::WaitLivePageSelector { .. } | RenderRuntimeTurn::WaitLivePageScriptTruthy { @@ -388,17 +388,16 @@ impl RendererOwnerHandle { ) .await } - LivePagePendingNavigationCompletion::ContinueNetworkIdle { deadline, loader } => { + LivePagePendingNavigationCompletion::ContinueIdle { + state, + deadline, + loader, + } => { if let Err(error) = self.refresh_live_page_before_wait(token, entry).await { return Err(error).into(); } - self.wait_live_page_network_idle_turn( - token, - PageVmNetworkIdleWaitState::default(), - deadline, - loader, - ) - .await + self.wait_live_page_idle_turn(token, state.reset(), deadline, loader) + .await } LivePagePendingNavigationCompletion::ContinueDomStable { deadline, loader } => { if let Err(error) = self.refresh_live_page_before_wait(token, entry).await { @@ -495,7 +494,7 @@ impl RendererOwnerHandle { ) .await } - LivePagePendingNavigationCompletion::ContinueNetworkIdle { .. } + LivePagePendingNavigationCompletion::ContinueIdle { .. } | LivePagePendingNavigationCompletion::ContinueDomStable { .. } | LivePagePendingNavigationCompletion::ContinueSubresourceResponse { .. } => { self.restore_live_page_entry(token, entry); diff --git a/moli-renderer-v8/src/runtime/owner_local.rs b/moli-renderer-v8/src/runtime/owner_local.rs index 8b606a00460..2e43b59a4cb 100644 --- a/moli-renderer-v8/src/runtime/owner_local.rs +++ b/moli-renderer-v8/src/runtime/owner_local.rs @@ -685,11 +685,35 @@ impl RendererPageHandle { &self, timeout_ms: u64, loader: ResourceRequestClient, + ) -> Result<(RendererPageReply, Arc)> { + self.wait_for_idle_with_mode(crate::RendererPageIdleWaitMode::Network, timeout_ms, loader) + .await + } + + pub async fn wait_for_idle( + &self, + timeout_ms: u64, + loader: ResourceRequestClient, + ) -> Result<(RendererPageReply, Arc)> { + self.wait_for_idle_with_mode( + crate::RendererPageIdleWaitMode::EventLoop, + timeout_ms, + loader, + ) + .await + } + + async fn wait_for_idle_with_mode( + &self, + mode: crate::RendererPageIdleWaitMode, + timeout_ms: u64, + loader: ResourceRequestClient, ) -> Result<(RendererPageReply, Arc)> { match self .render_runtime - .dispatch(RendererOwnerCommand::WaitForNetworkIdle { + .dispatch(RendererOwnerCommand::WaitForIdle { token: self.token(), + mode, timeout_ms, loader, }) @@ -697,7 +721,8 @@ impl RendererPageHandle { { RendererOwnerReply::AsyncPageCommandRan(result) => Ok(result.into_reply_and_state()), _ => Err(anyhow!( - "renderer owner returned non-async page-command reply for wait-for-network-idle" + "renderer owner returned non-async page-command reply for wait-for-{}", + PageVmIdleWaitState::new(mode).label() )), } } diff --git a/moli-renderer-v8/src/runtime/owner_local_store/bound.rs b/moli-renderer-v8/src/runtime/owner_local_store/bound.rs index 5af24c1b0fa..99849f34ccf 100644 --- a/moli-renderer-v8/src/runtime/owner_local_store/bound.rs +++ b/moli-renderer-v8/src/runtime/owner_local_store/bound.rs @@ -541,17 +541,17 @@ pub(in crate::runtime) async fn commit_page_state_on_entry_via_local_task_with_p .await } -pub(in crate::runtime) async fn advance_network_idle_wait_turn_on_entry_via_local_task( +pub(in crate::runtime) async fn advance_idle_wait_turn_on_entry_via_local_task( local_executor: JsLocalExecutor, entry: LivePageEntry, - state: PageVmNetworkIdleWaitState, + state: PageVmIdleWaitState, remaining: std::time::Duration, -) -> (LivePageEntry, Result) { +) -> (LivePageEntry, Result) { run_entry_on_bound_owner_local_store_local_task(local_executor, entry, move |entry| { Box::pin(async move { entry .page_vm_mut() - .advance_network_idle_wait_turn(state, remaining) + .advance_idle_wait_turn(state, remaining) .await }) }) @@ -743,6 +743,28 @@ impl PageReadyDescriptorSnapshot { } } +/// Observe the same runnable sources used by the Page arbiter while a command +/// has its VM checked out. An exhausted resource set must still drain queued +/// completion callbacks before an event-loop idle wait may return. +pub(in crate::runtime) fn has_ready_page_tasks_on_bound_owner_local_store( + token: RendererPageToken, + entry: &mut LivePageEntry, +) -> bool { + with_bound_render_runtime_owner_local_store_session(|session| { + let Some(slot) = session + .store + .page_hosts + .get_mut(&token.local_host_id) + .and_then(|host| host.pages.get_mut(&token.page_id)) + else { + return false; + }; + !page_ready_descriptor_snapshot(entry, &mut slot.task_sources) + .eligible + .is_empty() + }) +} + pub(super) fn page_ready_descriptor_snapshot( entry: &mut LivePageEntry, task_sources: &mut RendererPageOwnedTaskSources, diff --git a/moli-renderer-v8/src/runtime/owner_local_store/mod.rs b/moli-renderer-v8/src/runtime/owner_local_store/mod.rs index 3e17da16898..aaeb8572453 100644 --- a/moli-renderer-v8/src/runtime/owner_local_store/mod.rs +++ b/moli-renderer-v8/src/runtime/owner_local_store/mod.rs @@ -336,7 +336,8 @@ pub(super) enum LivePagePendingNavigationCompletion { reply: Box, capture_policy: super::RendererPageStateCapturePolicy, }, - ContinueNetworkIdle { + ContinueIdle { + state: PageVmIdleWaitState, deadline: std::time::Instant, loader: ResourceRequestClient, }, @@ -372,7 +373,10 @@ impl LivePagePendingNavigationCompletion { Self::CompletePageCreation { .. } => "creating page", Self::CompletePageReplacement { .. } => "replacing page Document", Self::ReplyWithSnapshot { .. } => "refreshing page", - Self::ContinueNetworkIdle { .. } => "waiting for networkidle", + Self::ContinueIdle { state, .. } => match state { + PageVmIdleWaitState::Network { .. } => "waiting for networkidle", + PageVmIdleWaitState::EventLoop => "waiting for idle", + }, Self::ContinueDomStable { .. } => "waiting for domstable", Self::ContinueSubresourceResponse { .. } => "waiting for subresource response", } @@ -392,7 +396,7 @@ impl LivePagePendingNavigationCompletion { Self::CompletePageCreation { .. } | Self::CompletePageReplacement { .. } | Self::ReplyWithSnapshot { .. } - | Self::ContinueNetworkIdle { .. } + | Self::ContinueIdle { .. } | Self::ContinueDomStable { .. } | Self::ContinueSubresourceResponse { .. } => { LivePageNavigationFailureRecipient::Initiator @@ -414,7 +418,7 @@ impl LivePagePendingNavigationCompletion { } => navigation_reply_policy.returns_with_pending_navigation(), Self::Background | Self::ReplyWithSnapshot { .. } - | Self::ContinueNetworkIdle { .. } + | Self::ContinueIdle { .. } | Self::ContinueDomStable { .. } | Self::ContinueSubresourceResponse { .. } => false, } @@ -437,7 +441,7 @@ impl LivePagePendingNavigationCompletion { Self::Background | Self::PublishedPageCreation { .. } | Self::ReplyWithSnapshot { .. } - | Self::ContinueNetworkIdle { .. } + | Self::ContinueIdle { .. } | Self::ContinueDomStable { .. } | Self::ContinueSubresourceResponse { .. } => (Self::Background, true), } diff --git a/moli-renderer-v8/src/runtime/page_network.rs b/moli-renderer-v8/src/runtime/page_network.rs index d5c44fca927..527fec00574 100644 --- a/moli-renderer-v8/src/runtime/page_network.rs +++ b/moli-renderer-v8/src/runtime/page_network.rs @@ -22,15 +22,45 @@ fn network_idle_sleep_for( } impl PageVm { - pub(in crate::runtime) async fn advance_network_idle_wait_turn( + pub(in crate::runtime) async fn advance_idle_wait_turn( &mut self, - mut state: PageVmNetworkIdleWaitState, + mut state: PageVmIdleWaitState, remaining: std::time::Duration, - ) -> Result { + ) -> Result { if self.vm().has_pending_location_navigation() { - return Ok(PageVmNetworkIdleWaitAdvance::TriggeredNavigation); + return Ok(PageVmIdleWaitAdvance::TriggeredNavigation); } + let PageVmIdleWaitState::Network { + quiet_since, + observed_activity_epoch, + } = &mut state + else { + // Resource exhaustion is observed after a real checkpoint, never + // inferred from an empty JavaScript stack or a quiet network. + self.vm_mut().finish_event_loop_idle_checkpoint()?; + if self.vm().has_pending_location_navigation() { + return Ok(PageVmIdleWaitAdvance::TriggeredNavigation); + } + if !self.vm_mut().has_event_loop_keep_alive_work()? + && !self.vm().has_pending_child_document_lifecycle() + && self.page_task_queue.is_empty() + { + return Ok(PageVmIdleWaitAdvance::Completed); + } + let sleep_for = self + .vm() + .ms_to_next_timeout() + .map(std::time::Duration::from_millis) + .unwrap_or(remaining) + .min(remaining); + return if sleep_for.is_zero() { + Ok(PageVmIdleWaitAdvance::Progressed { state }) + } else { + Ok(PageVmIdleWaitAdvance::Waiting { sleep_for, state }) + }; + }; + let pending_requests = self.pending_subresource_request_count(); let pending_child_frame_lifecycle = self.vm().has_pending_child_document_lifecycle(); let activity_epoch = self.vm().subresource_activity_epoch(); @@ -44,27 +74,27 @@ impl PageVm { let pending_idle_work = pending_requests + usize::from(pending_child_frame_lifecycle); let now = std::time::Instant::now(); let quiet_elapsed = if pending_idle_work == 0 { - if state.observed_activity_epoch != Some(activity_epoch) { - state.observed_activity_epoch = Some(activity_epoch); - state.quiet_since = Some(now); + if *observed_activity_epoch != Some(activity_epoch) { + *observed_activity_epoch = Some(activity_epoch); + *quiet_since = Some(now); } - let quiet_since = state.quiet_since.get_or_insert(now); + let quiet_since = quiet_since.get_or_insert(now); let quiet_elapsed = now.saturating_duration_since(*quiet_since); if quiet_elapsed >= NETWORK_IDLE_QUIET_WINDOW { - return Ok(PageVmNetworkIdleWaitAdvance::Completed); + return Ok(PageVmIdleWaitAdvance::Completed); } quiet_elapsed } else { - state.observed_activity_epoch = Some(activity_epoch); - state.quiet_since = None; + *observed_activity_epoch = Some(activity_epoch); + *quiet_since = None; std::time::Duration::ZERO }; let sleep_for = network_idle_sleep_for(ms_to_next, pending_idle_work, quiet_elapsed, remaining); if sleep_for.is_zero() { - Ok(PageVmNetworkIdleWaitAdvance::Progressed { state }) + Ok(PageVmIdleWaitAdvance::Progressed { state }) } else { - Ok(PageVmNetworkIdleWaitAdvance::Waiting { sleep_for, state }) + Ok(PageVmIdleWaitAdvance::Waiting { sleep_for, state }) } } diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/wait_observer.rs b/moli-renderer-v8/src/runtime/page_vm/tests/wait_observer.rs index 0871b0a2170..cdb7ec64073 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/wait_observer.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/wait_observer.rs @@ -1,7 +1,7 @@ use super::*; use crate::page_task_queue::{RendererPageReadyDescriptor, RendererPageSchedulerTask}; -use crate::runtime::{PageVmNetworkIdleWaitAdvance, PageVmNetworkIdleWaitState}; +use crate::runtime::{PageVmIdleWaitAdvance, PageVmIdleWaitState}; #[tokio::test(flavor = "current_thread")] async fn network_idle_wait_observes_deadline_without_checkpointing_the_agent() { @@ -21,15 +21,11 @@ Promise.resolve().then(() => __networkIdleObserverCheckpoint += 1); )?; let advance = page_vm - .advance_network_idle_wait_turn( - PageVmNetworkIdleWaitState::default(), - Duration::from_secs(1), - ) + .advance_idle_wait_turn(PageVmIdleWaitState::default(), Duration::from_secs(1)) .await?; assert!(matches!( advance, - PageVmNetworkIdleWaitAdvance::Waiting { .. } - | PageVmNetworkIdleWaitAdvance::Progressed { .. } + PageVmIdleWaitAdvance::Waiting { .. } | PageVmIdleWaitAdvance::Progressed { .. } )); assert_eq!( page_vm @@ -46,6 +42,56 @@ Promise.resolve().then(() => __networkIdleObserverCheckpoint += 1); .expect("NetworkIdle observer authority test should run"); } +#[tokio::test(flavor = "current_thread")] +async fn event_loop_idle_checkpoints_before_observing_future_work() { + run_page_vm_async_test(async move { + let loader_owner = + crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader"); + let loader = loader_owner.handle(); + let mut page_vm = test_page_vm_with_loader(&loader, Vec::new()); + page_vm + .vm_mut() + .eval_without_microtask_checkpoint_for_test( + r#" +globalThis.__idleCheckpoint = 0; +globalThis.__unbackedPromise = new Promise(() => {}); +Promise.resolve().then(() => { + __idleCheckpoint += 1; + globalThis.__idleTimer = setTimeout(() => {}, 60000); +}); +"queued" +"#, + )?; + + let advance = page_vm + .advance_idle_wait_turn(PageVmIdleWaitState::EventLoop, Duration::from_secs(1)) + .await?; + assert!(matches!( + advance, + PageVmIdleWaitAdvance::Waiting { .. } | PageVmIdleWaitAdvance::Progressed { .. } + )); + assert_eq!( + page_vm + .vm_mut() + .eval_without_microtask_checkpoint_for_test("String(__idleCheckpoint)")?, + "1", + ); + + page_vm + .vm_mut() + .eval_without_microtask_checkpoint_for_test("clearTimeout(__idleTimer); 'cleared'")?; + assert!(matches!( + page_vm + .advance_idle_wait_turn(PageVmIdleWaitState::EventLoop, Duration::from_secs(1)) + .await?, + PageVmIdleWaitAdvance::Completed, + )); + Ok::<_, anyhow::Error>(()) + }) + .await + .expect("event-loop idle checkpoint test should run"); +} + #[tokio::test(flavor = "current_thread")] async fn selected_timer_task_checkpoints_without_a_wait_observer() { run_page_vm_async_test(async move { diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs index 7e78ae33e32..c9cf97024be 100644 --- a/moli-renderer-v8/src/script_vm.rs +++ b/moli-renderer-v8/src/script_vm.rs @@ -799,6 +799,7 @@ mod browsing_contexts; mod child_frame_runtime; mod document_environment; mod document_settings; +mod event_loop; pub(crate) use document_settings::{ DocumentSetting, DocumentSettingEffect, DocumentSettingsApplication, }; diff --git a/moli-renderer-v8/src/script_vm/event_loop.rs b/moli-renderer-v8/src/script_vm/event_loop.rs new file mode 100644 index 00000000000..ab028475b82 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/event_loop.rs @@ -0,0 +1,39 @@ +//! Keep-alive observations for the explicit host event-loop exhaustion wait. +//! +//! These are queries of canonical resource owners, not a second set of +//! counters. Pending Promises without backing work and renderer maintenance +//! do not keep the page alive. Queued task callbacks are checked separately by +//! the Page arbiter before a wait is allowed to finish. + +use super::ScriptVm; +use anyhow::Result; + +impl ScriptVm { + /// The idle observer owns its final checkpoint, separately from selected + /// Page-task completion. Promise reactions may create new keep-alive work. + pub(crate) fn finish_event_loop_idle_checkpoint(&mut self) -> Result<()> { + let result = self.perform_owner_lane_task_microtask_checkpoints(); + self.sync_child_browsing_context_records(); + self.finish_runtime_turn_with_style_drain( + crate::style_engine::StyleInvalidationTurnExitBoundary::RuntimePendingWorkFlush, + result, + ) + } + + pub(crate) fn has_event_loop_keep_alive_work(&mut self) -> Result { + if self.document_runtime.has_keep_alive_timers() + || self.pending_subresource_request_count() > 0 + || self.has_pending_native_module_job() + || self.has_pending_runtime_script_work() + || self.has_pending_webcrypto_tasks() + || self.has_pending_opfs_tasks() + { + return Ok(true); + } + let host = self._context_host.clone(); + self.with_current_main_world_scope(|scope, _| { + Ok(host.borrow().has_event_loop_keep_alive_resources(scope)) + }) + .map(|pending| pending.unwrap_or(false)) + } +} diff --git a/moli-time/src/timers.rs b/moli-time/src/timers.rs index 76f45280b94..dd2ecb75d4e 100644 --- a/moli-time/src/timers.rs +++ b/moli-time/src/timers.rs @@ -201,6 +201,14 @@ impl TimerScheduler { }) } + /// Whether a live timer matches, including timers whose deadlines are in + /// the future. Canceled heap entries do not keep their runtime alive. + pub fn has_pending_matching(&self, mut predicate: impl FnMut(&T) -> bool) -> bool { + self.pending + .iter() + .any(|timer| self.active.contains(&timer.id) && predicate(&timer.payload)) + } + pub fn finish_running(&mut self, id: TimerId) { self.running.remove(&id); self.cancelled_running.remove(&id); @@ -321,6 +329,19 @@ fn timer_precedes(left: &ScheduledTimer, right: &ScheduledTimer) -> boo mod tests { use super::*; + #[test] + fn keep_alive_observes_future_timers_but_not_canceled_or_other_payloads() { + let now = Instant::now(); + let mut scheduler = TimerScheduler::default(); + let id = scheduler.schedule_after("user", 60000, now); + scheduler.schedule_after("internal", 60000, now); + assert!(!scheduler.has_ready_timer(now)); + assert!(scheduler.has_pending_matching(|kind| *kind == "user")); + assert!(scheduler.cancel(id)); + assert!(!scheduler.has_pending_matching(|kind| *kind == "user")); + assert!(scheduler.has_pending_matching(|kind| *kind == "internal")); + } + #[test] fn timers_wait_until_their_deadline_in_every_ready_query() { let now = Instant::now(); diff --git a/moli/src/app.rs b/moli/src/app.rs index 3aa1230c3e2..541f9133adb 100644 --- a/moli/src/app.rs +++ b/moli/src/app.rs @@ -154,6 +154,7 @@ pub async fn run_cli_with_config( .await .context("failed while waiting for page delay")?; } + readiness.wait_for_idle(&browser, &mut page).await?; Ok::<(), anyhow::Error>(()) } .await; @@ -213,9 +214,18 @@ pub async fn run_cli_with_config( eval_output::execute(&mut page, expression) .await .map_err(with_output_context)?; + readiness + .wait_for_idle(&browser, &mut page) + .await + .map_err(with_output_context)?; fetch_dump::render_page_output_async(&mut page, &config.fetch).await } else { - eval_output::evaluate(&mut page, expression).await + async { + let result = eval_output::evaluate(&mut page, expression).await?; + readiness.wait_for_idle(&browser, &mut page).await?; + Ok(result) + } + .await } } else { fetch_dump::render_page_output_async(&mut page, &config.fetch).await diff --git a/moli/src/app/readiness.rs b/moli/src/app/readiness.rs index 066fa375393..2b21d4befb6 100644 --- a/moli/src/app/readiness.rs +++ b/moli/src/app/readiness.rs @@ -70,7 +70,9 @@ impl ReadinessPlan { ) .await } - RenderedDomWaitUntil::NetworkIdle | RenderedDomWaitUntil::DomStable => { + RenderedDomWaitUntil::NetworkIdle + | RenderedDomWaitUntil::DomStable + | RenderedDomWaitUntil::Idle => { browser .fetch_request_document_allow_http_error_with_wait_until_deadline( request, @@ -107,6 +109,17 @@ impl ReadinessPlan { Ok(()) } + + /// Include work scheduled by automation predicates, delays and --eval in + /// the explicit idle lifecycle, sharing the original readiness deadline. + pub(super) async fn wait_for_idle(&self, browser: &Browser, page: &mut Page) -> Result<()> { + if self.wait_until == RenderedDomWaitUntil::Idle { + browser + .wait_for_page_readiness_with_deadline(page, self.wait_until, self.deadline) + .await?; + } + Ok(()) + } } fn rendered_wait_until(wait_until: FetchWaitUntil) -> RenderedDomWaitUntil { @@ -115,6 +128,7 @@ fn rendered_wait_until(wait_until: FetchWaitUntil) -> RenderedDomWaitUntil { FetchWaitUntil::Load => RenderedDomWaitUntil::Load, FetchWaitUntil::NetworkIdle => RenderedDomWaitUntil::NetworkIdle, FetchWaitUntil::DomStable => RenderedDomWaitUntil::DomStable, + FetchWaitUntil::Idle => RenderedDomWaitUntil::Idle, FetchWaitUntil::Done => RenderedDomWaitUntil::Done, } } diff --git a/moli/src/cli.rs b/moli/src/cli.rs index 56b96faccca..af420706715 100644 --- a/moli/src/cli.rs +++ b/moli/src/cli.rs @@ -275,8 +275,8 @@ pub struct FetchArgs { /// Maximum total readiness time in milliseconds. Initial and HTTP-error /// replacement navigations, the selected lifecycle stage, response match, /// selector, and script waits share one absolute deadline. Network-idle and - /// DOM-stable return the current page when it expires. Pass `--log-level warn` - /// to see timeout warnings. + /// DOM-stable return the current page when it expires; idle fails with a + /// timeout error. Pass `--log-level warn` to see timeout warnings. #[arg( short, long = "timeout-ms", @@ -765,6 +765,9 @@ pub enum FetchWaitUntil { Load, NetworkIdle, DomStable, + /// Wait for user async work and callbacks to finish. Active intervals, + /// Workers, WebSockets and receiving MessagePorts keep the wait pending. + Idle, Done, } diff --git a/moli/tests/fetch_cli.rs b/moli/tests/fetch_cli.rs index 6285f091d7c..451f04923d7 100644 --- a/moli/tests/fetch_cli.rs +++ b/moli/tests/fetch_cli.rs @@ -51,6 +51,8 @@ mod disable_js; mod eval; #[path = "fetch_cli/http_fail.rs"] mod http_fail; +#[path = "fetch_cli/idle.rs"] +mod idle; #[path = "fetch_cli/layout_regressions.rs"] mod layout_regressions; #[path = "fetch_cli/markdown.rs"] diff --git a/moli/tests/fetch_cli/idle.rs b/moli/tests/fetch_cli/idle.rs new file mode 100644 index 00000000000..234255b4d78 --- /dev/null +++ b/moli/tests/fetch_cli/idle.rs @@ -0,0 +1,487 @@ +use super::{Output, clean_output, fixture_runtime, run_moli, unique_temp_file_path}; +use anyhow::Result; +use axum::{ + Router, + extract::ws::{Message, WebSocketUpgrade}, + response::{Html, IntoResponse}, + routing::get, +}; +use base64::{Engine as _, engine::general_purpose::STANDARD}; +use std::time::Duration; + +fn document(script: &str) -> String { + format!( + "data:text/html;base64,{}", + STANDARD.encode(format!("
pending
")) + ) +} + +fn run(url: &str, timeout_ms: &str, extra: &[&str]) -> Result { + let mut args = vec![ + "moli", + "fetch", + "--http-no-proxy", + "*", + "--log-level", + "error", + "--wait", + "idle", + "--timeout-ms", + timeout_ms, + ]; + args.extend_from_slice(extra); + args.push(url); + run_moli(args) +} + +fn assert_done(output: Output) { + let stderr = clean_output(&output.stderr); + let stdout = clean_output(&output.stdout); + assert!(output.status.success(), "stderr={stderr}"); + assert!(stdout.contains("
done
"), "stdout={stdout}"); +} + +struct Server { + _runtime: tokio::runtime::Runtime, + task: tokio::task::JoinHandle<()>, + url: String, +} + +impl Server { + fn new(script: &str) -> Result { + let runtime = fixture_runtime()?; + let listener = runtime.block_on(tokio::net::TcpListener::bind("127.0.0.1:0"))?; + let url = format!("http://{}/", listener.local_addr()?); + let html = format!("
pending
"); + let app = Router::new() + .route("/", get(move || { let html = html.clone(); async move { Html(html) } })) + .route("/data", get(|| async { + tokio::time::sleep(Duration::from_millis(100)).await; + "payload" + })) + .route("/worker.js", get(|| async { + ([("content-type", "text/javascript")], + "setTimeout(() => { postMessage('payload'); close(); }, 100)") + })) + .route("/waiting-worker.js", get(|| async { + ([("content-type", "text/javascript")], + "postMessage('ready'); onmessage = () => {}") + })) + .route("/burst-worker.js", get(|| async { + ([("content-type", "text/javascript")], + "for (let i = 0; i < 16; ++i) postMessage(i); close()") + })) + .route("/module.js", get(|| async { + tokio::time::sleep(Duration::from_millis(100)).await; + ([("content-type", "text/javascript")], "export default 'payload'") + })) + .route("/next", get(|| async { Html( + "
pending
" + ) })) + .route("/socket", get(|upgrade: WebSocketUpgrade| async { + upgrade.on_upgrade(|mut socket| async move { + tokio::time::sleep(Duration::from_millis(100)).await; + if socket.send(Message::Text("payload".into())).await.is_ok() { + // Stay open until the client closes, so the test also + // exercises the connection's active lifetime. + while socket.recv().await.is_some() {} + } + }).into_response() + })); + let task = runtime.spawn(async move { axum::serve(listener, app).await.unwrap() }); + Ok(Self { + _runtime: runtime, + task, + url, + }) + } +} + +impl Drop for Server { + fn drop(&mut self) { + self.task.abort(); + } +} + +#[test] +fn idle_accepts_documents_without_a_javascript_realm() -> Result<()> { + for extra in [ + vec!["--dump", "html"], + vec!["--dump", "html", "--disable-js"], + ] { + assert_done(run("data:text/html,
done
", "3000", &extra)?); + } + Ok(()) +} + +#[test] +fn idle_waits_for_future_timers_and_their_microtask_followups() -> Result<()> { + let url = document( + r#" + Promise.resolve().then(() => queueMicrotask(() => { + setTimeout(() => { + document.querySelector('main').textContent = 'first'; + Promise.resolve().then(() => setTimeout(() => { + document.querySelector('main').textContent = 'done'; + }, 30)); + }, 650); + })); + "#, + ); + assert_done(run(&url, "3000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_waits_until_an_interval_is_cleared() -> Result<()> { + let url = document( + r#" + let count = 0; + const id = setInterval(() => { + if (++count === 3) { + clearInterval(id); + queueMicrotask(() => document.querySelector('main').textContent = 'done'); + } + }, 40); + "#, + ); + assert_done(run(&url, "3000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_ignores_canceled_timers_internal_timeouts_and_unbacked_promises() -> Result<()> { + let url = document( + r#" + clearTimeout(setTimeout(() => {}, 60000)); + clearInterval(setInterval(() => {}, 60000)); + globalThis.pending = new Promise(() => {}); + globalThis.signal = AbortSignal.timeout(60000); + queueMicrotask(() => document.querySelector('main').textContent = 'done'); + "#, + ); + assert_done(run(&url, "2000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_waits_for_fetch_and_xhr_callbacks_and_their_timers() -> Result<()> { + let server = Server::new( + r#" + const done = []; + function finish(value) { + done.push(value); + if (done.length === 2) setTimeout(() => { + document.querySelector('main').textContent = + done.every(x => x === 'payload') ? 'done' : 'wrong payload'; + }, 30); + } + fetch('/data').then(r => r.text()).then(finish); + const xhr = new XMLHttpRequest(); + xhr.open('GET', '/data'); + xhr.onloadend = () => Promise.resolve().then(() => finish(xhr.responseText)); + xhr.send(); + "#, + )?; + assert_done(run(&server.url, "5000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_keeps_fetch_alive_until_an_internal_abort_timeout_fires() -> Result<()> { + let server = Server::new( + r#" + fetch('/data', {signal: AbortSignal.timeout(20)}).then( + () => document.querySelector('main').textContent = 'not aborted', + error => setTimeout(() => { + document.querySelector('main').textContent = + error.name === 'TimeoutError' ? 'done' : error.name; + }, 30) + ); + "#, + )?; + assert_done(run(&server.url, "5000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_waits_for_dynamic_module_evaluation_and_its_callbacks() -> Result<()> { + let server = Server::new( + r#" + import('/module.js').then(module => setTimeout(() => { + document.querySelector('main').textContent = module.default === 'payload' ? 'done' : 'wrong payload'; + }, 30)); + "#, + )?; + assert_done(run(&server.url, "5000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_drains_worker_messages_before_the_worker_closes() -> Result<()> { + let server = Server::new( + r#" + const worker = new Worker('/worker.js'); + worker.onmessage = event => queueMicrotask(() => { + document.querySelector('main').textContent = event.data === 'payload' ? 'done' : 'wrong payload'; + }); + "#, + )?; + assert_done(run(&server.url, "5000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_stops_waiting_after_a_worker_is_terminated() -> Result<()> { + let server = Server::new( + r#" + const worker = new Worker('/waiting-worker.js'); + worker.onmessage = event => { + worker.terminate(); + queueMicrotask(() => { + document.querySelector('main').textContent = event.data === 'ready' ? 'done' : 'wrong payload'; + }); + }; + "#, + )?; + assert_done(run(&server.url, "5000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_drains_all_worker_messages_after_immediate_close() -> Result<()> { + let server = Server::new( + r#" + const worker = new Worker('/burst-worker.js'); + const messages = []; + worker.onmessage = event => { + messages.push(event.data); + if (messages.length === 16) queueMicrotask(() => { + document.querySelector('main').textContent = + messages.every((value, index) => value === index) ? 'done' : 'out of order'; + }); + }; + "#, + )?; + assert_done(run(&server.url, "5000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_ignores_a_worker_terminated_while_its_script_is_loading() -> Result<()> { + let server = Server::new( + "const worker = new Worker('/waiting-worker.js'); worker.terminate(); document.querySelector('main').textContent = 'done'", + )?; + assert_done(run(&server.url, "3000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_waits_for_websocket_close_and_its_callback() -> Result<()> { + let server = Server::new( + r#" + const socket = new WebSocket(location.origin.replace('http:', 'ws:') + '/socket'); + let received = false; + socket.onmessage = event => { received = event.data === 'payload'; socket.close(); }; + socket.onclose = () => setTimeout(() => { + document.querySelector('main').textContent = received ? 'done' : 'no message'; + }, 30); + "#, + )?; + assert_done(run(&server.url, "5000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_drains_started_message_ports_and_observes_close() -> Result<()> { + let url = document( + r#" + const channel = new MessageChannel(); + channel.port1.onmessage = event => { + channel.port1.close(); + channel.port2.close(); + queueMicrotask(() => document.querySelector('main').textContent = event.data); + }; + channel.port2.postMessage('done'); + "#, + ); + assert_done(run(&url, "3000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_observes_native_message_port_listeners_without_calling_author_getters() -> Result<()> { + let url = document( + r#" + const c = new MessageChannel(); + c.port1.addEventListener('message', e => { + c.port1.close(); c.port2.close(); + document.querySelector('main').textContent = e.data; + }); + c.port1.start(); + Object.defineProperty(c.port1, 'onmessage', { + get() { throw new Error('must not inspect public properties'); } + }); + c.port2.postMessage('done'); + "#, + ); + assert_done(run(&url, "3000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_ignores_internal_stream_transfer_ports_without_backing_work() -> Result<()> { + let url = document( + r#" + const stream = new ReadableStream(); + globalThis.copy = structuredClone(stream, {transfer: [stream]}); + globalThis.pending = copy.getReader().read(); + queueMicrotask(() => document.querySelector('main').textContent = 'done'); + "#, + ); + assert_done(run(&url, "2000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_ignores_unstarted_ports_and_ports_without_receivers() -> Result<()> { + let url = document( + r#" + const a = new MessageChannel(); + a.port1.addEventListener('message', () => { throw Error('not started'); }); + a.port2.postMessage('queued'); + const b = new MessageChannel(); + b.port1.start(); + b.port2.postMessage('no receiver'); + queueMicrotask(() => document.querySelector('main').textContent = 'done'); + "#, + ); + assert_done(run(&url, "2000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_has_a_strict_timeout_for_resources_that_stay_alive() -> Result<()> { + for script in [ + "setInterval(() => {}, 30)", + "const c = new MessageChannel(); c.port1.onmessage = () => {}", + ] { + let output = run(&document(script), "800", &["--dump", "html"])?; + assert!(!output.status.success()); + assert!(output.stdout.is_empty()); + assert!( + clean_output(&output.stderr).contains("waiting for idle"), + "{}", + clean_output(&output.stderr) + ); + } + Ok(()) +} + +#[test] +fn idle_has_a_strict_timeout_for_live_workers_and_websockets() -> Result<()> { + for script in [ + "globalThis.worker = new Worker('/waiting-worker.js')", + "globalThis.socket = new WebSocket(location.origin.replace('http:', 'ws:') + '/socket')", + ] { + let server = Server::new(script)?; + let output = run(&server.url, "1000", &["--dump", "html"])?; + assert!(!output.status.success()); + assert!(output.stdout.is_empty()); + assert!( + clean_output(&output.stderr).contains("waiting for idle"), + "{}", + clean_output(&output.stderr) + ); + } + Ok(()) +} + +#[test] +fn idle_waits_for_work_started_by_eval_before_exporting() -> Result<()> { + let script = + "setTimeout(() => document.querySelector('main').textContent = 'done', 100); 'value'"; + assert_done(run( + &document(""), + "3000", + &["--dump", "html", "--eval", script], + )?); + let output = run(&document(""), "3000", &["--eval", script])?; + assert!(output.status.success(), "{}", clean_output(&output.stderr)); + assert_eq!(clean_output(&output.stdout), "value\n"); + Ok(()) +} + +#[test] +fn idle_waits_for_work_started_by_eval_file() -> Result<()> { + let path = unique_temp_file_path("wait-idle", "eval.js")?; + std::fs::write( + &path, + "setTimeout(() => document.querySelector('main').textContent = 'done', 100)", + )?; + let output = run( + &document(""), + "3000", + &["--dump", "html", "--eval-file", path.to_str().unwrap()], + ); + std::fs::remove_file(path)?; + assert_done(output?); + Ok(()) +} + +#[test] +fn idle_also_drains_work_created_by_the_readiness_script() -> Result<()> { + assert_done(run( + &document(""), + "3000", + &[ + "--dump", + "html", + "--wait-script", + "(setTimeout(() => document.querySelector('main').textContent='done', 100), true)", + ], + )?); + Ok(()) +} + +#[test] +fn idle_waits_for_child_window_timers_and_releases_removed_windows() -> Result<()> { + let url = document( + r#" + const frame = document.createElement('iframe'); + document.body.append(frame); + const child = frame.contentWindow; + child.setInterval(() => {}, 60000); + child.setTimeout(() => { + frame.remove(); + queueMicrotask(() => document.querySelector('main').textContent = 'done'); + }, 100); + "#, + ); + assert_done(run(&url, "3000", &["--dump", "html"])?); + Ok(()) +} + +#[test] +fn idle_keeps_one_deadline_for_work_started_after_initial_readiness() -> Result<()> { + let output = run( + &document("setTimeout(() => {}, 300)"), + "1000", + &["--dump", "html", "--eval", "setTimeout(() => {}, 800)"], + )?; + assert!(!output.status.success()); + assert!(output.stdout.is_empty()); + assert!( + clean_output(&output.stderr).contains("timed out after 1000 ms while waiting for idle"), + "{}", + clean_output(&output.stderr) + ); + Ok(()) +} + +#[test] +fn idle_follows_navigation_and_keeps_waiting_on_the_replacement_document() -> Result<()> { + let server = Server::new("setTimeout(() => location.href = '/next', 40)")?; + assert_done(run(&server.url, "5000", &["--dump", "html"])?); + Ok(()) +}