Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(renderer): defer idle callbacks while page work is pending
ldm0c0e189a0fbad
diff --git a/moli-renderer-v8/src/document_runtime/events.rs b/moli-renderer-v8/src/document_runtime/events.rsindex 3e177408b..9ee3afa07 100644--- a/moli-renderer-v8/src/document_runtime/events.rs+++ b/moli-renderer-v8/src/document_runtime/events.rs@@ -271,14 +271,23 @@ impl DocumentRuntime {pub(crate) fn run_next_timeout_body(&mut self,scope: &mut v8::PinScope<'_, '_>,+ selection: crate::page_task_queue::RendererPageTimerSelection,) -> HostTimeoutRunResult {- self.timeouts.run_next_body(scope)+ self.timeouts.run_next_body(scope, selection)}+ #[cfg(test)]pub(crate) fn has_ready_timeout(&self) -> bool {self.timeouts.has_ready_timer()}+ pub(crate) fn next_ready_timeout_deadline(+ &self,+ selection: crate::page_task_queue::RendererPageTimerSelection,+ ) -> Option<std::time::Instant> {+ self.timeouts.next_ready_timer_deadline(selection)+ }+pub(crate) fn ms_to_next_timeout(&self) -> Option<u64> {self.timeouts.ms_to_next()}diff --git a/moli-renderer-v8/src/host/timers.rs b/moli-renderer-v8/src/host/timers.rsindex 3fd9d0ecd..4e50b8350 100644--- a/moli-renderer-v8/src/host/timers.rs+++ b/moli-renderer-v8/src/host/timers.rs@@ -15,6 +15,7 @@ use crate::{active_lightweight_popup_id, current_runtime_observable_context_token,lightweight_popup_id_from_window,},+ page_task_queue::RendererPageTimerSelection,script_provenance::CompiledStringProvenance,util::{context_host_ptr_from_global_bridge, create_script_origin_with_base_url, get_private_value,@@ -189,6 +190,24 @@ struct ScheduledTimerTask {extra_args: Vec<v8::Global<v8::Value>>,}+impl ScheduledTimerTask {+ fn is_unexpired_idle_callback_at(&self, now_ms: f64) -> bool {+ let ScheduledTimerCallback::WindowWebIdl(callback) = &self.callback else {+ return false;+ };+ callback.is_unexpired_idle_callback_at(now_ms)+ }++ fn matches_selection(&self, selection: RendererPageTimerSelection, now_ms: f64) -> bool {+ match selection {+ RendererPageTimerSelection::AnyReady => true,+ RendererPageTimerSelection::ExcludeUnexpiredIdleCallbacks => {+ !self.is_unexpired_idle_callback_at(now_ms)+ }+ }+ }+}+const MIN_DELAY_TIMER_READY_EARLY_ALLOWANCE: Duration = Duration::from_millis(1);#[cfg(not(test))]const TIMER_CALLBACK_WATCHDOG_TIMEOUT: Duration = Duration::from_secs(8);@@ -707,21 +726,37 @@ impl HostTimeoutScheduler {pub(crate) fn run_next_body(&mut self,scope: &mut v8::PinScope<'_, '_>,+ selection: RendererPageTimerSelection,) -> HostTimeoutRunResult {- let Some(timer) = self- .scheduler- .take_next_ready(Instant::now(), min_delay_ready_allowance())- else {+ let now_ms = crate::window_host::current_time_ms();+ let Some(timer) = self.scheduler.take_next_ready_matching(+ Instant::now(),+ min_delay_ready_allowance(),+ |task| task.matches_selection(selection, now_ms),+ ) else {return HostTimeoutRunResult::Idle;};self.run_timer(scope, timer)}+ #[cfg(test)]pub(crate) fn has_ready_timer(&self) -> bool {self.scheduler.has_ready_timer(Instant::now(), min_delay_ready_allowance())}+ pub(crate) fn next_ready_timer_deadline(+ &self,+ selection: RendererPageTimerSelection,+ ) -> Option<Instant> {+ let now_ms = crate::window_host::current_time_ms();+ self.scheduler.next_ready_deadline_matching(+ Instant::now(),+ min_delay_ready_allowance(),+ |task| task.matches_selection(selection, now_ms),+ )+ }+fn run_timer(&mut self,scope: &mut v8::PinScope<'_, '_>,diff --git a/moli-renderer-v8/src/host/window_callbacks.rs b/moli-renderer-v8/src/host/window_callbacks.rsindex 0aa90fd7d..e7c2b8cc6 100644--- a/moli-renderer-v8/src/host/window_callbacks.rs+++ b/moli-renderer-v8/src/host/window_callbacks.rs@@ -71,6 +71,17 @@ impl ScheduledWindowWebIdlCallback {.map(WindowExecutionContextIdentity::realm_token)}+ pub(super) fn is_unexpired_idle_callback_at(&self, now_ms: f64) -> bool {+ match self.kind {+ WindowWebIdlCallbackTaskKind::Idle {+ timeout_deadline_ms,+ } => timeout_deadline_ms < 0.0 || now_ms < timeout_deadline_ms,+ WindowWebIdlCallbackTaskKind::Timer+ | WindowWebIdlCallbackTaskKind::AnimationFrame { .. }+ | WindowWebIdlCallbackTaskKind::GeolocationError { .. } => false,+ }+ }+pub(super) fn is_geolocation_watch<'s>(&self,scope: &mut v8::PinScope<'s, '_>,diff --git a/moli-renderer-v8/src/page_task_queue.rs b/moli-renderer-v8/src/page_task_queue.rsindex d32eb81de..3c710f8ac 100644--- a/moli-renderer-v8/src/page_task_queue.rs+++ b/moli-renderer-v8/src/page_task_queue.rs@@ -361,7 +361,7 @@ pub(crate) use self::owner_sources::{};pub(crate) use self::owner_sources::{RendererPageOwnedTaskSources, RendererPageReadyDescriptor, RendererPageSchedulerTask,- RendererPageTaskProducerRoutes, RendererPageTaskSourceKind,+ RendererPageTaskProducerRoutes, RendererPageTaskSourceKind, RendererPageTimerSelection,};pub(crate) use self::parser_async_module_admission::{PageParserAsyncModuleAdmissionTargetEffect, PageParserAsyncModuleAdmissionTurnAction,diff --git a/moli-renderer-v8/src/page_task_queue/owner_sources.rs b/moli-renderer-v8/src/page_task_queue/owner_sources.rsindex 6637ee016..220590255 100644--- a/moli-renderer-v8/src/page_task_queue/owner_sources.rs+++ b/moli-renderer-v8/src/page_task_queue/owner_sources.rs@@ -238,6 +238,12 @@ pub(crate) struct RendererPageTaskProducerRoutes {/// for arbitration and source-local eligibility. Exact executable identity is/// part of each task payload and is interpreted only after dequeue by the lane/// executor.+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(crate) enum RendererPageTimerSelection {+ AnyReady,+ ExcludeUnexpiredIdleCallbacks,+}+#[derive(Clone, Copy, Debug, Eq, PartialEq)]pub(crate) enum RendererPageReadyDescriptor {ActionWindow {@@ -358,6 +364,7 @@ pub(crate) enum RendererPageReadyDescriptor {},Timer {deadline: Instant,+ selection: RendererPageTimerSelection,},}@@ -478,7 +485,7 @@ impl RendererPageReadyDescriptor {| Self::ModulepreloadStart { ready }| Self::Networking { ready, .. }| Self::WebSocket { ready, .. } => ready.ready_at,- Self::ActionWindow { deadline } | Self::Timer { deadline } => deadline,+ Self::ActionWindow { deadline } | Self::Timer { deadline, .. } => deadline,}}@@ -599,6 +606,7 @@ pub(crate) enum RendererPageSchedulerTask {WebSocket(RendererPageWebSocketTask),Timer {deadline: Instant,+ selection: RendererPageTimerSelection,},}@@ -1487,9 +1495,13 @@ impl RendererPageOwnedTaskSources {);RendererPageSchedulerTask::WebSocket(task)}- RendererPageReadyDescriptor::Timer { deadline } => {- RendererPageSchedulerTask::Timer { deadline }- }+ RendererPageReadyDescriptor::Timer {+ deadline,+ selection,+ } => RendererPageSchedulerTask::Timer {+ deadline,+ selection,+ },}}diff --git a/moli-renderer-v8/src/runtime/owner_local_store/bound.rs b/moli-renderer-v8/src/runtime/owner_local_store/bound.rsindex 53892a70e..453d9c27b 100644--- a/moli-renderer-v8/src/runtime/owner_local_store/bound.rs+++ b/moli-renderer-v8/src/runtime/owner_local_store/bound.rs@@ -712,11 +712,12 @@ pub(super) fn page_ready_descriptor_snapshot() -> PageReadyDescriptorSnapshot {let mut descriptors = task_sources.ready_descriptors();let stable_source_was_ready = !descriptors.is_empty();+ descriptors.retain(|descriptor| {+ entry+ .page_vm_mut()+ .page_ready_descriptor_is_eligible(*descriptor)+ });let mut due_deadline_was_ready = false;- if let Some(timer) = entry.page_vm().due_page_timer_ready_descriptor() {- descriptors.push(timer);- due_deadline_was_ready = true;- }if let Some(action_window) = entry.page_vm().due_page_action_window_ready_descriptor(std::time::Instant::now())@@ -724,11 +725,18 @@ pub(super) fn page_ready_descriptor_snapshot(descriptors.push(action_window);due_deadline_was_ready = true;}- descriptors.retain(|descriptor| {- entry- .page_vm_mut()- .page_ready_descriptor_is_eligible(*descriptor)- });+ let timer_selection = if descriptors.is_empty() {+ crate::page_task_queue::RendererPageTimerSelection::AnyReady+ } else {+ crate::page_task_queue::RendererPageTimerSelection::ExcludeUnexpiredIdleCallbacks+ };+ if let Some(timer) = entry+ .page_vm()+ .due_page_timer_ready_descriptor(timer_selection)+ {+ descriptors.push(timer);+ due_deadline_was_ready = true;+ }PageReadyDescriptorSnapshot {eligible: descriptors,stable_source_was_ready,diff --git a/moli-renderer-v8/src/runtime/page_turn_scheduler.rs b/moli-renderer-v8/src/runtime/page_turn_scheduler.rsindex c4c37d4e6..731449d61 100644--- a/moli-renderer-v8/src/runtime/page_turn_scheduler.rs+++ b/moli-renderer-v8/src/runtime/page_turn_scheduler.rs@@ -12,6 +12,8 @@//! identifies or authorizes work for the current document. Typed queued work//! must carry and validate its exact execution-context/document identity.+#[cfg(test)]+use crate::page_task_queue::RendererPageTimerSelection;use crate::page_task_queue::{RendererOwnerWakeSource, RendererPageReadyDescriptor, RendererPageTaskSourceKind,};@@ -1008,6 +1010,7 @@ mod tests {},RendererPageTaskSourceKind::Timer => RendererPageReadyDescriptor::Timer {deadline: runnable_since,+ selection: RendererPageTimerSelection::AnyReady,},RendererPageTaskSourceKind::DomManipulation => {broadcast_channel_descriptor(runnable_since, order)@@ -1436,7 +1439,10 @@ mod tests {let selected = scheduler.select_ready_descriptor([dynamic_import_descriptor(base + std::time::Duration::from_millis(2), 1),- RendererPageReadyDescriptor::Timer { deadline: base },+ RendererPageReadyDescriptor::Timer {+ deadline: base,+ selection: RendererPageTimerSelection::AnyReady,+ },]).expect("one ready descriptor should be selected");@@ -1469,6 +1475,7 @@ mod tests {dynamic_import_descriptor(runnable_at, 1),RendererPageReadyDescriptor::Timer {deadline: runnable_at,+ selection: RendererPageTimerSelection::AnyReady,},]).expect("one tied descriptor should be selected");@@ -1514,6 +1521,7 @@ mod tests {resource_descriptor(base + std::time::Duration::from_millis(2), 3),RendererPageReadyDescriptor::Timer {deadline: base + std::time::Duration::from_millis(3),+ selection: RendererPageTimerSelection::AnyReady,},broadcast_channel_descriptor(base + std::time::Duration::from_millis(4), 4),window_message_descriptor(base + std::time::Duration::from_millis(5), 5),diff --git a/moli-renderer-v8/src/runtime/page_vm/mod.rs b/moli-renderer-v8/src/runtime/page_vm/mod.rsindex fa2bd5c66..6becd7f39 100644--- a/moli-renderer-v8/src/runtime/page_vm/mod.rs+++ b/moli-renderer-v8/src/runtime/page_vm/mod.rs@@ -2917,13 +2917,20 @@ impl PageVm {&mut self,loader: &ResourceRequestClient,) -> Result<bool> {- let Some(crate::page_task_queue::RendererPageReadyDescriptor::Timer { deadline }) =- self.due_page_timer_ready_descriptor()+ let Some(crate::page_task_queue::RendererPageReadyDescriptor::Timer {+ deadline,+ selection,+ }) = self.due_page_timer_ready_descriptor(+ crate::page_task_queue::RendererPageTimerSelection::AnyReady,+ )else {return Ok(false);};Box::pin(self.apply_selected_page_scheduler_task(- crate::page_task_queue::RendererPageSchedulerTask::Timer { deadline },+ crate::page_task_queue::RendererPageSchedulerTask::Timer {+ deadline,+ selection,+ },loader,)).await?;diff --git a/moli-renderer-v8/src/runtime/page_vm/page_timer.rs b/moli-renderer-v8/src/runtime/page_vm/page_timer.rsindex 800dc0e76..da985ecfe 100644--- a/moli-renderer-v8/src/runtime/page_vm/page_timer.rs+++ b/moli-renderer-v8/src/runtime/page_vm/page_timer.rs@@ -2,6 +2,7 @@ use std::time::Instant;use anyhow::{Result, ensure};+use crate::page_task_queue::RendererPageTimerSelection;use crate::runtime::PageOwnerTurnOutcome;use super::PageVm;@@ -33,11 +34,11 @@ impl PageVm {pub(in crate::runtime) fn apply_selected_page_timer_turn(&mut self,expected_deadline: Instant,+ selection: RendererPageTimerSelection,) -> Result<PageOwnerTurnOutcome<PageTimerTurnAction>> {- let actual_deadline = self.vm().next_timeout_deadline();- let action = if actual_deadline == Some(expected_deadline) && self.vm().has_ready_timeout()- {- let body = self.vm_mut().run_next_due_timer_callback_body()?;+ let actual_deadline = self.vm().next_ready_timeout_deadline(selection);+ let action = if actual_deadline == Some(expected_deadline) {+ let body = self.vm_mut().run_next_due_timer_callback_body(selection)?;ensure!(body.consumed_heap_head(),"a validated due timer descriptor must consume its selected heap head"diff --git a/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs b/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rsindex 259ee9c5f..f45fa2e4f 100644--- a/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs+++ b/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs@@ -1,5 +1,7 @@use super::PageVm;-use crate::page_task_queue::{RendererPageReadyDescriptor, RendererPageWindowDocumentTaskOwner};+use crate::page_task_queue::{+ RendererPageReadyDescriptor, RendererPageTimerSelection, RendererPageWindowDocumentTaskOwner,+};/// Proof that the Page arbiter matched a scheduler task against its exact/// PageVm namespace and Window/Document ledger slot.@@ -120,11 +122,13 @@ impl PageVm {pub(in crate::runtime) fn due_page_timer_ready_descriptor(&self,+ selection: RendererPageTimerSelection,) -> Option<RendererPageReadyDescriptor> {self.vm()- .has_ready_timeout()- .then(|| self.vm().next_timeout_deadline())- .flatten()- .map(|deadline| RendererPageReadyDescriptor::Timer { deadline })+ .next_ready_timeout_deadline(selection)+ .map(|deadline| RendererPageReadyDescriptor::Timer {+ deadline,+ selection,+ })}}diff --git a/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs b/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rsindex 2236d8ae9..cca600a1c 100644--- a/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs+++ b/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs@@ -360,8 +360,11 @@ impl PageVm {.await?;Ok(())}- RendererPageSchedulerTask::Timer { deadline } => {- let outcome = self.apply_selected_page_timer_turn(deadline)?;+ RendererPageSchedulerTask::Timer {+ deadline,+ selection,+ } => {+ let outcome = self.apply_selected_page_timer_turn(deadline, selection)?;if matches!(outcome.action, PageTimerTurnAction::Consumed { .. }) {self.finish_selected_page_callback_task(loader).await?;}diff --git a/moli-renderer-v8/src/runtime/page_vm/test_support.rs b/moli-renderer-v8/src/runtime/page_vm/test_support.rsindex ed1e60125..e8ff61434 100644--- a/moli-renderer-v8/src/runtime/page_vm/test_support.rs+++ b/moli-renderer-v8/src/runtime/page_vm/test_support.rs@@ -62,9 +62,14 @@ impl PageVm {task} else if let Some(crate::page_task_queue::RendererPageReadyDescriptor::Timer {deadline,- }) = self.due_page_timer_ready_descriptor()- {- crate::page_task_queue::RendererPageSchedulerTask::Timer { deadline }+ selection,+ }) = self.due_page_timer_ready_descriptor(+ crate::page_task_queue::RendererPageTimerSelection::AnyReady,+ ) {+ crate::page_task_queue::RendererPageSchedulerTask::Timer {+ deadline,+ selection,+ }} else {return Ok(false);};@@ -226,15 +231,19 @@ impl PageVmTaskExecutorTestHarness {.checked_add(std::time::Duration::from_millis(3_200)).unwrap_or_else(std::time::Instant::now);for _ in 0..10_000 {- if let Some(crate::page_task_queue::RendererPageReadyDescriptor::Timer { deadline }) =- self.page_vm.due_page_timer_ready_descriptor()- {+ if let Some(crate::page_task_queue::RendererPageReadyDescriptor::Timer {+ deadline,+ selection,+ }) = self.page_vm.due_page_timer_ready_descriptor(+ crate::page_task_queue::RendererPageTimerSelection::AnyReady,+ ) {self.selected_task_local_set.run_until(self.page_vm.apply_selected_page_scheduler_task_on_owner_lane_for_test(crate::page_task_queue::RendererPageSchedulerTask::Timer {deadline,+ selection,},loader.clone(),),diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/timer.rs b/moli-renderer-v8/src/runtime/page_vm/tests/timer.rsindex f5dc2764f..05ba57070 100644--- a/moli-renderer-v8/src/runtime/page_vm/tests/timer.rs+++ b/moli-renderer-v8/src/runtime/page_vm/tests/timer.rs@@ -1,14 +1,18 @@use super::*;use super::super::page_timer::PageTimerTurnAction;-use crate::page_task_queue::{RendererPageReadyDescriptor, RendererPageSchedulerTask};+use crate::page_task_queue::{+ RendererPageReadyDescriptor, RendererPageSchedulerTask, RendererPageTimerSelection,+};++const ANY_READY_TIMER: RendererPageTimerSelection = RendererPageTimerSelection::AnyReady;fn due_timer_deadline(page_vm: &PageVm) -> Instant {match page_vm- .due_page_timer_ready_descriptor()+ .due_page_timer_ready_descriptor(ANY_READY_TIMER).expect("a due timer descriptor should be ready"){- RendererPageReadyDescriptor::Timer { deadline } => deadline,+ RendererPageReadyDescriptor::Timer { deadline, .. } => deadline,other => panic!("expected timer descriptor, got {other:?}"),}}@@ -20,7 +24,10 @@ async fn run_timer_through_selected_dispatcher() -> anyhow::Result<()> {page_vm.apply_selected_page_scheduler_task_on_owner_lane_for_test(- RendererPageSchedulerTask::Timer { deadline },+ RendererPageSchedulerTask::Timer {+ deadline,+ selection: ANY_READY_TIMER,+ },loader.clone(),).await?;@@ -67,7 +74,9 @@ setTimeout(() => {r#"["first","microtask:first","second","microtask:second"]"#);assert!(- page_vm.due_page_timer_ready_descriptor().is_none(),+ page_vm+ .due_page_timer_ready_descriptor(ANY_READY_TIMER)+ .is_none(),"two timer tasks must consume exactly two selected turns");Ok::<_, anyhow::Error>(())@@ -94,7 +103,7 @@ setTimeout(() => {)?;let deadline = due_timer_deadline(&page_vm);- let body = page_vm.apply_selected_page_timer_turn(deadline)?;+ let body = page_vm.apply_selected_page_timer_turn(deadline, ANY_READY_TIMER)?;assert_eq!(body.action, PageTimerTurnAction::Consumed { deadline });assert_eq!(page_vm.vm_mut().eval("__timerBodyBoundary.join('|')")?,@@ -260,7 +269,7 @@ setTimeout(() => {.checked_add(Duration::from_nanos(1)).expect("test deadline should be representable");- let stale = page_vm.apply_selected_page_timer_turn(stale_deadline)?;+ let stale = page_vm.apply_selected_page_timer_turn(stale_deadline, ANY_READY_TIMER)?;assert_eq!(stale.action,PageTimerTurnAction::NoLongerRunnable {@@ -309,7 +318,11 @@ async fn timer_deadline_observation_cannot_consume_a_due_timer() {"false","reading the timer deadline must not steal the scheduler-owned timer");- assert!(page_vm.due_page_timer_ready_descriptor().is_some());+ assert!(+ page_vm+ .due_page_timer_ready_descriptor(ANY_READY_TIMER)+ .is_some()+ );Ok(())},)@@ -331,7 +344,9 @@ async fn timer_is_not_runnable_before_its_deadline() {assert!(page_vm.vm().next_timeout_deadline().is_some());assert!(- page_vm.due_page_timer_ready_descriptor().is_none(),+ page_vm+ .due_page_timer_ready_descriptor(ANY_READY_TIMER)+ .is_none(),"a future heap entry is a deadline, not a runnable Page task");assert_eq!(page_vm.vm_mut().eval("String(__futureTimerRan)")?, "false");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.rsindex 983a665ce..0871b0a21 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@@ -65,15 +65,20 @@ setTimeout(() => {)?;let deadline = match page_vm- .due_page_timer_ready_descriptor()+ .due_page_timer_ready_descriptor(+ crate::page_task_queue::RendererPageTimerSelection::AnyReady,+ ).expect("the zero-delay timer should be scheduler-visible"){- RendererPageReadyDescriptor::Timer { deadline } => deadline,+ RendererPageReadyDescriptor::Timer { deadline, .. } => deadline,other => panic!("expected a timer descriptor, got {other:?}"),};page_vm.apply_selected_page_scheduler_task_on_owner_lane_for_test(- RendererPageSchedulerTask::Timer { deadline },+ RendererPageSchedulerTask::Timer {+ deadline,+ selection: crate::page_task_queue::RendererPageTimerSelection::AnyReady,+ },loader,).await?;diff --git a/moli-renderer-v8/src/runtime/phase_one/document_write_resource_tests.rs b/moli-renderer-v8/src/runtime/phase_one/document_write_resource_tests.rsindex cfaefdeb2..4c894bcb9 100644--- a/moli-renderer-v8/src/runtime/phase_one/document_write_resource_tests.rs+++ b/moli-renderer-v8/src/runtime/phase_one/document_write_resource_tests.rs@@ -449,7 +449,9 @@ async fn resume_standalone_document_write_page(let mut descriptors = vec![crate::page_task_queue::RendererPageReadyDescriptor::Networking { ready, owner },];- if let Some(timer) = runtime.page_vm.due_page_timer_ready_descriptor() {+ if let Some(timer) = runtime.page_vm.due_page_timer_ready_descriptor(+ crate::page_task_queue::RendererPageTimerSelection::AnyReady,+ ) {descriptors.push(timer);}let selected = crate::runtime::page_turn_scheduler::PageTurnScheduler::new(())@@ -464,11 +466,17 @@ async fn resume_standalone_document_write_page()?.expect("selected standalone resource head must be executable");}- crate::page_task_queue::RendererPageReadyDescriptor::Timer { deadline } => {+ crate::page_task_queue::RendererPageReadyDescriptor::Timer {+ deadline,+ selection,+ } => {runtime.page_vm.apply_selected_page_scheduler_task(- crate::page_task_queue::RendererPageSchedulerTask::Timer { deadline },+ crate::page_task_queue::RendererPageSchedulerTask::Timer {+ deadline,+ selection,+ },&loader,).await?;diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rsindex fcaa29c7a..ac82e1e1b 100644--- a/moli-renderer-v8/src/script_vm.rs+++ b/moli-renderer-v8/src/script_vm.rs@@ -5833,8 +5833,11 @@ impl ScriptVm {/// This method deliberately does not checkpoint, synchronize child/// records, or run runtime follow-up. The selected Page-task dispatcher/// commits that completion exactly once after the body returns.- pub(crate) fn run_next_due_timer_callback_body(&mut self) -> Result<HostTimeoutRunResult> {- let result = self.run_next_timeout_body()?;+ pub(crate) fn run_next_due_timer_callback_body(+ &mut self,+ selection: crate::page_task_queue::RendererPageTimerSelection,+ ) -> Result<HostTimeoutRunResult> {+ let result = self.run_next_timeout_body(selection)?;if let HostTimeoutRunResult::CallbackError(error) = &result {self.record_runtime_warning(format_args!("timer callback dispatch failed: {error}"));}@@ -5851,7 +5854,9 @@ impl ScriptVm {&mut self,loader: &ResourceRequestClient,) -> Result<bool> {- let result = self.run_next_due_timer_callback_body()?;+ let result = self.run_next_due_timer_callback_body(+ crate::page_task_queue::RendererPageTimerSelection::AnyReady,+ )?;if !result.consumed_heap_head() {return Ok(false);}diff --git a/moli-renderer-v8/src/script_vm/page_task_enqueue.rs b/moli-renderer-v8/src/script_vm/page_task_enqueue.rsindex b2721e5de..5e243ce85 100644--- a/moli-renderer-v8/src/script_vm/page_task_enqueue.rs+++ b/moli-renderer-v8/src/script_vm/page_task_enqueue.rs@@ -782,7 +782,10 @@ impl ScriptVm {////// Production callers must enter through the selected Page timer task,/// which commits the single task-end callback completion.- pub(super) fn run_next_timeout_body(&mut self) -> Result<HostTimeoutRunResult> {+ pub(super) fn run_next_timeout_body(+ &mut self,+ selection: crate::page_task_queue::RendererPageTimerSelection,+ ) -> Result<HostTimeoutRunResult> {#[cfg(test)]if let Some(message) = self.test_next_timeout_failure.take() {return Err(anyhow!("{message}"));@@ -796,7 +799,7 @@ impl ScriptVm {// creates the V8 context scope and does not access or move// `document_runtime`; the render owner lane runs this// synchronously on one thread.- Ok(unsafe { &mut *document_runtime }.run_next_timeout_body(scope))+ Ok(unsafe { &mut *document_runtime }.run_next_timeout_body(scope, selection))})}@@ -809,7 +812,8 @@ impl ScriptVm {/// bypassed.#[cfg(test)]pub(crate) fn run_next_timeout_for_test(&mut self) -> Result<HostTimeoutRunResult> {- let result = self.run_next_timeout_body()?;+ let result = self+ .run_next_timeout_body(crate::page_task_queue::RendererPageTimerSelection::AnyReady)?;if result.consumed_heap_head() {self.perform_owner_lane_task_microtask_checkpoints()?;self.sync_child_browsing_context_records();@@ -826,10 +830,18 @@ impl ScriptVm {self.document_runtime.ms_to_next_timeout()}+ #[cfg(test)]pub(crate) fn has_ready_timeout(&self) -> bool {self.document_runtime.has_ready_timeout()}+ pub(crate) fn next_ready_timeout_deadline(+ &self,+ selection: crate::page_task_queue::RendererPageTimerSelection,+ ) -> Option<Instant> {+ self.document_runtime.next_ready_timeout_deadline(selection)+ }+pub(crate) fn next_timeout_deadline(&self) -> Option<Instant> {self.document_runtime.next_timeout_deadline()}diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/idle_callbacks.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/idle_callbacks.rsindex de405de02..7fddfd44c 100644--- a/moli-renderer-v8/src/script_vm/tests/browser_api/idle_callbacks.rs+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/idle_callbacks.rs@@ -41,6 +41,40 @@ async fn idle_callback_timeout_is_a_deadline_not_a_dispatch_delay() {);}+#[tokio::test]+async fn idle_callback_does_not_overtake_queued_javascript_url_navigation() {+ let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");+ let mut vm = new_storage_page_task_executor_test_vm_with_loader(+ "https://idle-after-javascript-url.test/",+ &loader,+ );+ vm.eval(+ r#"+globalThis.__javascriptUrlIdleOrder = [];+const frame = document.createElement("iframe");+(document.body || document.documentElement || document).appendChild(frame);+const child = frame.contentWindow;+child.location.href =+ "javascript:parent.__javascriptUrlIdleOrder.push('javascript-url')";+child.requestIdleCallback(() => __javascriptUrlIdleOrder.push("idle"));+"#,+ )+ .expect("javascript URL and idle callback should queue");+ advance_page_task_executor_until_eval_equals(+ &mut vm,+ &loader,+ "String(__javascriptUrlIdleOrder.length)",+ "2",+ "javascript URL must run before the page becomes idle",+ )+ .await;+ assert_eq!(+ vm.eval("__javascriptUrlIdleOrder.join('|')")+ .expect("javascript URL idle order should evaluate"),+ "javascript-url|idle"+ );+}+#[tokio::test]async fn idle_deadline_declared_shape_keeps_state_private() {let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");diff --git a/moli-time/src/timers.rs b/moli-time/src/timers.rsindex 86b7e32fe..087a39279 100644--- a/moli-time/src/timers.rs+++ b/moli-time/src/timers.rs@@ -167,34 +167,12 @@ impl<T> TimerScheduler<T> {&mut self,now: Instant,allowance: TimerReadyAllowance,- mut predicate: F,+ predicate: F,) -> Option<ReadyTimer<T>>whereF: FnMut(&T) -> bool,{- let mut first_non_ready = None;- let mut selected = None;- for timer in &self.pending {- if !self.active.contains(&timer.id) {- continue;- }- if !timer_ready(timer.run_at, timer.delay_ms, now, allowance) {- if first_non_ready.is_none_or(|current| timer_precedes(timer, current)) {- first_non_ready = Some(timer);- }- continue;- }- if predicate(&timer.payload)- && selected.is_none_or(|current| timer_precedes(timer, current))- {- selected = Some(timer);- }- }-- let selected = selected?;- if first_non_ready.is_some_and(|barrier| timer_precedes(barrier, selected)) {- return None;- }+ let selected = self.next_ready_matching_timer(now, allowance, predicate)?;let selected_id = selected.id;let selected_sequence = selected.sequence;@@ -266,6 +244,19 @@ impl<T> TimerScheduler<T> {})}+ pub fn next_ready_deadline_matching<F>(+ &self,+ now: Instant,+ allowance: TimerReadyAllowance,+ predicate: F,+ ) -> Option<Instant>+ where+ F: FnMut(&T) -> bool,+ {+ self.next_ready_matching_timer(now, allowance, predicate)+ .map(|timer| timer.run_at)+ }+pub fn next_deadline(&self) -> Option<Instant> {self.pending.iter()@@ -312,6 +303,41 @@ impl<T> TimerScheduler<T> {}}}++ fn next_ready_matching_timer<F>(+ &self,+ now: Instant,+ allowance: TimerReadyAllowance,+ mut predicate: F,+ ) -> Option<&ScheduledTimer<T>>+ where+ F: FnMut(&T) -> bool,+ {+ let mut first_non_ready = None;+ let mut selected = None;+ for timer in &self.pending {+ if !self.active.contains(&timer.id) {+ continue;+ }+ if !timer_ready(timer.run_at, timer.delay_ms, now, allowance) {+ if first_non_ready.is_none_or(|current| timer_precedes(timer, current)) {+ first_non_ready = Some(timer);+ }+ continue;+ }+ if predicate(&timer.payload)+ && selected.is_none_or(|current| timer_precedes(timer, current))+ {+ selected = Some(timer);+ }+ }++ let selected = selected?;+ if first_non_ready.is_some_and(|barrier| timer_precedes(barrier, selected)) {+ return None;+ }+ Some(selected)+ }}fn timer_precedes<T>(left: &ScheduledTimer<T>, right: &ScheduledTimer<T>) -> bool {@@ -440,6 +466,53 @@ mod tests {scheduler.finish_running(ready.id);}+ #[test]+ fn matching_ready_deadline_observes_selection_and_cancelled_timers() {+ let now = Instant::now();+ let mut scheduler = TimerScheduler::default();+ let cancelled = scheduler.schedule_after("cancelled", 0, now);+ scheduler.schedule_after("skipped", 0, now);+ scheduler.schedule_after("selected", 1, now);+ scheduler.cancel(cancelled);++ assert_eq!(+ scheduler+ .next_ready_deadline_matching(now, TimerReadyAllowance::NONE, |payload| *payload+ == "selected",),+ None+ );+ assert_eq!(+ scheduler.next_ready_deadline_matching(+ now + Duration::from_millis(1),+ TimerReadyAllowance::NONE,+ |payload| *payload == "selected",+ ),+ Some(now + Duration::from_millis(1))+ );+ }++ #[test]+ fn matching_ready_deadline_respects_an_earlier_non_ready_barrier() {+ let now = Instant::now();+ let mut scheduler = TimerScheduler::default();+ scheduler.schedule_after("barrier", 2, now);+ scheduler.schedule_after("selected", 1, now + Duration::from_micros(1_500));+ let allowance = TimerReadyAllowance {+ max_delay_ms: 1,+ allowance: Duration::from_millis(1),+ };++ assert_eq!(+ scheduler.next_ready_deadline_matching(+ now + Duration::from_micros(1_500),+ allowance,+ |payload| *payload == "selected",+ ),+ None,+ "a later timer admitted by early allowance must not overtake the heap head"+ );+ }+#[test]fn ms_to_next_rounds_future_submillisecond_deadline_up() {let now = Instant::now();