Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
mod broadcast_channel_delivery;
mod child_frame_task;
mod child_module_dependency_fetch_start;
mod child_module_script_terminal;
mod child_modulepreload_event_action;
mod child_navigation_commit;
mod child_realm_materialization;
mod dedicated_worker_client_event;
mod dom_manipulation;
mod dynamic_import_owner_action;
mod element_toggle_event;
mod file_entry_file_callback;
mod file_reading;
mod hash_change_delivery;
mod history_traversal;
mod image_load_event;
mod indexed_db_task;
mod internal_loading;
mod main_document_post_parse;
mod main_document_runtime;
mod main_document_task_owner;
mod main_native_module_task;
mod main_parser_continuation;
mod media_element_event;
mod message_port_delivery;
mod misc_platform_api;
mod module_reaction;
mod modulepreload_start;
mod navigation_and_traversal;
mod navigation_api_task;
mod networking;
mod opfs_task;
mod owner_sources;
mod parse_time;
mod parser_async_module_admission;
mod parser_owned_module_continuation;
mod popup_load_event;
mod post_domcontentloaded_runtime;
mod post_parse_owner_work;
mod ready_signal;
mod rendering_update;
mod resource_completions;
mod senders;
mod service_worker_client_message;
mod service_worker_internal;
mod service_worker_tasks;
mod shared_worker_client_event;
mod storage_event_delivery;
mod stylesheet_task;
mod tasks;
mod text_track_default_mode;
mod text_track_load;
mod user_interaction;
mod v8_foreground_task;
#[cfg(test)]
pub(crate) use v8_foreground_task::RendererPageV8ForegroundTaskSource;
mod view_transition_update;
mod webcrypto_task;
mod websocket_event;
mod window_document_task_source;
mod window_message;
mod worker_host_bridge;
use moli_owner_queue::OwnerTaskSource;
use crate::document_script_scheduler::ParseTimeDocumentScriptEvent;
use crate::native_bridge::WindowDocumentTaskTarget;
use crate::planning::SharedScriptSourceLoad;
use crate::runtime::RendererDocumentToken;
/// PageVm namespace plus the exact Window/Document captured by a queued task.
///
/// Task-source families keep their own typed ids and payloads, but they should
/// not each redefine this authorization identity.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct RendererPageWindowDocumentTaskOwner {
root_document: RendererDocumentToken,
target: WindowDocumentTaskTarget,
}
impl RendererPageWindowDocumentTaskOwner {
pub(crate) const fn new(
root_document: RendererDocumentToken,
target: WindowDocumentTaskTarget,
) -> Self {
Self {
root_document,
target,
}
}
pub(crate) const fn root_document(self) -> RendererDocumentToken {
self.root_document
}
pub(crate) const fn target(self) -> WindowDocumentTaskTarget {
self.target
}
}
/// Scheduler envelope for a concrete exact Window/Document task whose mutable
/// V8/DOM payload remains in the creating `JsContextHost` ledger.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct RendererPageWindowDocumentTask<I, K> {
owner: RendererPageWindowDocumentTaskOwner,
task_id: I,
kind: K,
}
impl<I: Copy, K: Copy> RendererPageWindowDocumentTask<I, K> {
pub(crate) const fn new(
owner: RendererPageWindowDocumentTaskOwner,
task_id: I,
kind: K,
) -> Self {
Self {
owner,
task_id,
kind,
}
}
pub(crate) const fn owner(&self) -> RendererPageWindowDocumentTaskOwner {
self.owner
}
pub(crate) const fn task_id(&self) -> I {
self.task_id
}
pub(crate) const fn kind(&self) -> K {
self.kind
}
}
/// Common settlement of one exact Window/Document event task.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum PageWindowDocumentTaskTargetEffect {
DispatchedToCurrentOwner,
CurrentOwnerHadNoEventTarget,
DiscardedStaleOwner {
current_owner: Option<RendererPageWindowDocumentTaskOwner>,
},
}
/// Common owner-turn fact emitted after an exact Window/Document task settles.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct PageWindowDocumentTaskTurnAction<I, K> {
pub(crate) owner: RendererPageWindowDocumentTaskOwner,
pub(crate) task_id: I,
pub(crate) kind: K,
pub(crate) target_effect: PageWindowDocumentTaskTargetEffect,
}
impl<I, K> PageWindowDocumentTaskTurnAction<I, K> {}
pub(crate) use self::broadcast_channel_delivery::{
PageBroadcastChannelDeliveryDocumentEffect, PageBroadcastChannelDeliveryTurnAction,
PageBroadcastChannelDeliveryTurnOutcome, RendererPageBroadcastChannelDeliveryOwner,
RendererPageBroadcastChannelDeliveryProducer, RendererPageBroadcastChannelDeliverySender,
RendererPageBroadcastChannelDeliveryTask,
};
pub(crate) use self::child_frame_task::{
PageChildClassicScriptSourceLoadTargetEffect, PageChildClassicScriptSourceLoadTurnAction,
PageChildClassicScriptSourceLoadTurnOutcome, PageChildDocumentLifecycleTargetEffect,
PageChildDocumentLifecycleTurnAction, PageChildDocumentLifecycleTurnOutcome,
PageChildDocumentScriptReadyTargetEffect, PageChildDocumentScriptReadyTurnAction,
PageChildDocumentScriptReadyTurnOutcome, PageChildHostLoadTargetEffect,
PageChildHostLoadTurnAction, PageChildHostLoadTurnOutcome,
PageChildParserModuleRootStartTargetEffect, PageChildParserModuleRootStartTurnAction,
PageChildParserModuleRootStartTurnOutcome, RendererPageChildClassicScriptSourceLoadTarget,
RendererPageChildDocumentLifecycleTarget, RendererPageChildDocumentScriptReadyTarget,
RendererPageChildDocumentScriptReadyTaskId, RendererPageChildFrameTask,
RendererPageChildFrameTaskOwner, RendererPageChildFrameTaskSender,
RendererPageChildFrameTaskTarget, RendererPageChildHostLoadTarget,
RendererPageChildParserModuleRootStartTarget,
};
pub(crate) use self::child_module_dependency_fetch_start::{
PageChildModuleDependencyFetchStartTargetEffect, PageChildModuleDependencyFetchStartTurnAction,
PageChildModuleDependencyFetchStartTurnOutcome,
RendererPageChildModuleDependencyFetchStartEnqueue,
RendererPageChildModuleDependencyFetchStartOwner,
RendererPageChildModuleDependencyFetchStartSender,
RendererPageChildModuleDependencyFetchStartTask,
};
pub(crate) use self::child_module_script_terminal::{
PageChildModuleScriptTerminalTargetEffect, PageChildModuleScriptTerminalTurnAction,
PageChildModuleScriptTerminalTurnOutcome, RendererPageChildModuleScriptTerminalOwner,
RendererPageChildModuleScriptTerminalSender, RendererPageChildModuleScriptTerminalTask,
};
pub(crate) use self::child_modulepreload_event_action::{
PageChildModulepreloadEventActionTargetEffect, PageChildModulepreloadEventActionTurnAction,
PageChildModulepreloadEventActionTurnOutcome, RendererPageChildModulepreloadEventActionOwner,
RendererPageChildModulepreloadEventActionSender, RendererPageChildModulepreloadEventActionTask,
};
pub(crate) use self::child_navigation_commit::{
PageChildNavigationCommitTargetEffect, PageChildNavigationCommitTurnAction,
PageChildNavigationCommitTurnOutcome, RendererPageChildNavigationCommitOwner,
RendererPageChildNavigationCommitSender, RendererPageChildNavigationCommitTask,
};
pub(crate) use self::child_realm_materialization::{
PageChildRealmMaterializationTargetEffect, PageChildRealmMaterializationTurnAction,
PageChildRealmMaterializationTurnOutcome, RendererPageChildRealmMaterializationTarget,
};
#[cfg(test)]
pub(crate) use self::dedicated_worker_client_event::RendererDedicatedWorkerClientEventKind;
pub(crate) use self::dedicated_worker_client_event::{
PageDedicatedWorkerClientEventTargetEffect, PageDedicatedWorkerClientEventTurnAction,
PageDedicatedWorkerClientEventTurnOutcome, RendererDedicatedWorkerClientEvent,
RendererDedicatedWorkerMessageEvent, RendererPageDedicatedWorkerClientEventOwner,
RendererPageDedicatedWorkerClientEventProducer, RendererPageDedicatedWorkerClientEventSender,
RendererPageDedicatedWorkerClientEventTask,
};
#[cfg(test)]
pub(crate) use self::dom_manipulation::RendererPageDomManipulationOwner;
pub(crate) use self::dom_manipulation::{
PageDomManipulationTurnAction, PageDomManipulationTurnOutcome,
RendererPageDomManipulationRoute, RendererPageDomManipulationSender,
RendererPageDomManipulationTask,
};
pub(crate) use self::dynamic_import_owner_action::{
PageDynamicImportOwnerActionDocumentEffect, PageDynamicImportOwnerActionTurnAction,
PageDynamicImportOwnerActionTurnOutcome, RendererPageDynamicImportOwnerActionOwner,
RendererPageDynamicImportOwnerActionSender, RendererPageDynamicImportOwnerActionTask,
};
pub(crate) use self::element_toggle_event::{
PageElementToggleEventTargetEffect, PageElementToggleEventTurnAction,
PageElementToggleEventTurnOutcome, RendererPageElementToggleEventCancellation,
RendererPageElementToggleEventData, RendererPageElementToggleEventKind,
RendererPageElementToggleEventOwner, RendererPageElementToggleEventSender,
RendererPageElementToggleEventState, RendererPageElementToggleEventTask,
RendererPageElementToggleEventTaskId,
};
pub(crate) use self::file_entry_file_callback::{
PageFileEntryFileCallbackTargetEffect, PageFileEntryFileCallbackTurnAction,
PageFileEntryFileCallbackTurnOutcome, RendererPageFileEntryFileCallbackOwner,
RendererPageFileEntryFileCallbackSender, RendererPageFileEntryFileCallbackTask,
RendererPageFileEntryFileCallbackTaskId, RendererPageFileEntryFileCallbackTaskKind,
};
pub(crate) use self::file_reading::{
PageFileReadingTargetEffect, PageFileReadingTurnAction, PageFileReadingTurnOutcome,
RendererPageFileReadingOwner, RendererPageFileReadingSender, RendererPageFileReadingTask,
RendererPageFileReadingTaskId, RendererPageFileReadingTaskKind,
};
pub(crate) use self::hash_change_delivery::{
PageHashChangeDeliveryTargetEffect, PageHashChangeDeliveryTurnAction,
PageHashChangeDeliveryTurnOutcome, RendererPageHashChangeData,
RendererPageHashChangeDeliveryOwner, RendererPageHashChangeDeliverySender,
RendererPageHashChangeDeliveryTask,
};
pub(crate) use self::history_traversal::{
PageHistoryTraversalTargetEffect, PageHistoryTraversalTurnAction,
PageHistoryTraversalTurnOutcome, RendererPageHistoryTraversalOwner,
RendererPageHistoryTraversalProducer, RendererPageHistoryTraversalSender,
RendererPageHistoryTraversalTask, RendererPageHistoryTraversalTaskId,
RendererPageHistoryTraversalTaskKind,
};
pub(crate) use self::image_load_event::{
PageImageLoadEventStalePayloadEffect, PageImageLoadEventTargetEffect,
PageImageLoadEventTurnAction, PageImageLoadEventTurnOutcome, RendererPageImageLoadEventKind,
RendererPageImageLoadEventOwner, RendererPageImageLoadEventSender,
RendererPageImageLoadEventTask, RendererPageImageLoadEventTaskId,
};
pub(crate) use self::indexed_db_task::{
PageIndexedDbTaskTargetEffect, PageIndexedDbTaskTurnAction, PageIndexedDbTaskTurnOutcome,
RendererPageIndexedDbTask, RendererPageIndexedDbTaskKind, RendererPageIndexedDbTaskOwner,
RendererPageIndexedDbTaskSender,
};
pub(crate) use self::internal_loading::{
PageInternalLoadingTargetEffect, PageInternalLoadingTurnAction, PageInternalLoadingTurnOutcome,
RendererPageInternalLoadingOwner, RendererPageInternalLoadingSender,
RendererPageInternalLoadingTask,
};
pub(crate) use self::main_document_post_parse::{
MainDocumentCompletionRecheckEffect, MainDocumentPostParseCallbackExecution,
MainDocumentPostParseCallbackSettlement, MainDocumentPostParseExecution,
MainDocumentPostParseOwner, MainDocumentPostParseStateExecution,
MainDocumentPostParseTargetEffect, MainDocumentPostParseTaskEnd, MainDocumentPostParseWork,
MainDocumentScriptLoadDelayEffect,
};
#[cfg(test)]
pub(crate) use self::main_document_runtime::PageMainDocumentRuntimeActionKind;
pub(crate) use self::main_document_runtime::{
PageMainDocumentRuntimeTargetEffect, PageMainDocumentRuntimeTurnAction,
PageMainDocumentRuntimeTurnOutcome, PageRuntimeOwnedModuleContinuationTurnAction,
PageRuntimeScriptAdmissionTargetEffect, PageRuntimeScriptAdmissionTurnAction,
PageRuntimeScriptContinuationTargetEffect, PageRuntimeScriptContinuationTurnAction,
RendererPageMainDocumentRuntimeAction, RendererPageMainDocumentRuntimeAdmissionError,
RendererPageMainDocumentRuntimeOwner, RendererPageMainDocumentRuntimeProducer,
RendererPageMainDocumentRuntimeRouteClosed, RendererPageMainDocumentRuntimeSender,
RendererPageMainDocumentRuntimeTask,
};
pub(crate) use self::main_document_task_owner::RendererPageMainDocumentTaskOwner;
pub(crate) use self::main_native_module_task::{
PageDynamicModuleJobTurnAction, PageMainNativeModuleBodyActivity,
PageMainNativeModuleSettlement, PageMainNativeModuleTargetEffect,
PageNativeModuleOwnerEventTurnAction,
};
pub(crate) use self::main_parser_continuation::{
MainParserContinuationRequest, PageMainParserContinuationTargetEffect,
PageMainParserContinuationTurnAction, PageMainParserContinuationTurnOutcome,
RendererPageMainParserContinuationOwner, RendererPageMainParserContinuationProducer,
RendererPageMainParserContinuationSender, RendererPageMainParserContinuationTask,
};
pub(crate) use self::media_element_event::{
PageMediaElementEventTargetEffect, PageMediaElementEventTurnAction,
PageMediaElementEventTurnOutcome, RendererPageMediaElementEventOwner,
RendererPageMediaElementEventSender, RendererPageMediaElementEventTask,
RendererPageMediaElementEventTaskId, RendererPageMediaElementEventTaskKind,
};
pub(crate) use self::message_port_delivery::{
PageMessagePortDeliveryTargetEffect, PageMessagePortDeliveryTurnAction,
PageMessagePortDeliveryTurnOutcome, RendererPageMessagePortDeliveryOwner,
RendererPageMessagePortDeliveryProducer, RendererPageMessagePortDeliverySender,
RendererPageMessagePortDeliveryTask,
};
pub(crate) use self::misc_platform_api::{
PageMiscPlatformApiTargetEffect, PageMiscPlatformApiTurnAction, PageMiscPlatformApiTurnOutcome,
RendererPageMiscPlatformApiOwner, RendererPageMiscPlatformApiSender,
RendererPageMiscPlatformApiTask, RendererPageMiscPlatformApiTaskId,
RendererPageMiscPlatformApiTaskKind,
};
#[cfg(test)]
pub(crate) use self::module_reaction::PageModuleReactionCurrentEffect;
pub(crate) use self::module_reaction::{
PageModuleReactionApplication, PageModuleReactionFollowup, PageModuleReactionTargetEffect,
PageModuleReactionTurnAction, PageModuleReactionTurnOutcome, RendererPageModuleReactionEvent,
RendererPageModuleReactionOwner, RendererPageModuleReactionSender,
RendererPageModuleReactionTarget, RendererPageModuleReactionTask,
};
pub(crate) use self::modulepreload_start::{
PageModulepreloadStartDocumentEffect, PageModulepreloadStartTurnAction,
PageModulepreloadStartTurnOutcome, RendererPageModulepreloadStartOwner,
RendererPageModulepreloadStartSender, RendererPageModulepreloadStartTask,
};
#[cfg(test)]
pub(crate) use self::navigation_and_traversal::RendererPageNavigationAndTraversalHead;
pub(crate) use self::navigation_and_traversal::{
PageNavigationAndTraversalTurnAction, PageNavigationAndTraversalTurnOutcome,
RendererPageNavigationAndTraversalSender, RendererPageNavigationAndTraversalTask,
};
pub(crate) use self::navigation_api_task::{
PageNavigationApiTaskTargetEffect, PageNavigationApiTaskTurnAction,
PageNavigationApiTaskTurnOutcome, RendererPageNavigationApiTask,
RendererPageNavigationApiTaskId, RendererPageNavigationApiTaskKind,
RendererPageNavigationApiTaskOwner, RendererPageNavigationApiTaskProducer,
RendererPageNavigationApiTaskSender,
};
pub(crate) use self::networking::{
PageNetworkingTurnAction, PageNetworkingTurnOutcome, RendererPageNetworkingRoute,
RendererPageNetworkingTask,
};
#[cfg(test)]
pub(crate) use self::networking::{RendererPageNetworkingOwner, RendererPageNetworkingSource};
pub(crate) use self::opfs_task::{
PageOpfsTaskTargetEffect, PageOpfsTaskTurnAction, PageOpfsTaskTurnOutcome,
RendererPageOpfsTask, RendererPageOpfsTaskId, RendererPageOpfsTaskOwner,
RendererPageOpfsTaskProducer, RendererPageOpfsTaskSender,
};
#[cfg(test)]
pub(crate) use self::owner_sources::{
RendererPageModulepreloadStartTestSource, RendererPageOwnedTaskSourcesTestHarness,
RendererPageResourceCompletionTestSource,
};
pub(crate) use self::owner_sources::{
RendererPageOwnedTaskSources, RendererPageReadyDescriptor, RendererPageSchedulerTask,
RendererPageTaskProducerRoutes, RendererPageTaskSourceKind, RendererPageTimerSelection,
};
pub(crate) use self::parser_async_module_admission::{
PageParserAsyncModuleAdmissionTargetEffect, PageParserAsyncModuleAdmissionTurnAction,
};
pub(crate) use self::parser_owned_module_continuation::{
PageParserOwnedModuleContinuationBodyActivity, PageParserOwnedModuleContinuationTargetEffect,
PageParserOwnedModuleContinuationTurnAction,
};
pub(crate) use self::popup_load_event::{
PagePopupLoadEventTargetEffect, PagePopupLoadEventTurnAction, PagePopupLoadEventTurnOutcome,
RendererPagePopupLoadEventOwner, RendererPagePopupLoadEventSender,
RendererPagePopupLoadEventTask,
};
pub(crate) use self::post_parse_owner_work::{
PostParseLifecycleQueueStats, PostParseLifecycleWork, PostParsePageOwnedWork,
post_parse_lifecycle_queue_stats,
};
use self::ready_signal::RendererPageTaskReadySignal;
#[cfg(test)]
pub(crate) use self::rendering_update::RendererPageRenderingUpdateHead;
pub(crate) use self::rendering_update::{
PageRenderingUpdateTargetEffect, PageRenderingUpdateTurnAction, PageRenderingUpdateTurnOutcome,
RendererPageRenderingUpdateOwner, RendererPageRenderingUpdateSender,
RendererPageRenderingUpdateTask, RendererPageRenderingUpdateTaskId,
RendererPageRenderingUpdateTaskKind,
};
#[cfg(test)]
pub(crate) use self::resource_completions::RendererResourceCompletionTestHarness;
pub(super) use self::resource_completions::{
RendererOwnerWake, RendererOwnerWakeSender, RendererOwnerWakeSource,
RendererResourceCompletionSender, RendererTopLevelNavigationHandoff,
};
pub(crate) use self::senders::PageRuntimeWakeSignal;
#[cfg(test)]
pub(crate) use self::senders::RendererPageTaskTestResidence;
pub(super) use self::senders::{
MainDocumentRuntimeContinuationSender, PageRuntimeWakeSender, PageTaskSender,
RendererTopLevelNavigationHandoffSender, RuntimePageTaskSender,
};
pub(crate) use self::senders::{PageRuntimeTaskSource, RendererPageJsContextTaskSenders};
#[cfg(test)]
pub(crate) use self::service_worker_client_message::RendererPageServiceWorkerClientMessageOwner;
pub(crate) use self::service_worker_client_message::{
PageServiceWorkerClientMessageTargetEffect, PageServiceWorkerClientMessageTurnAction,
PageServiceWorkerClientMessageTurnOutcome, RendererPageServiceWorkerClientMessageSender,
RendererPageServiceWorkerClientMessageTask, ServiceWorkerClientMessageCallbackEffect,
ServiceWorkerClientMessageEventKind,
};
#[cfg(test)]
pub(crate) use self::service_worker_internal::RendererServiceWorkerInternalTaskKind;
pub(crate) use self::service_worker_internal::{
PageServiceWorkerInternalTargetEffect, PageServiceWorkerInternalTurnAction,
PageServiceWorkerInternalTurnOutcome, RendererPageServiceWorkerInternalSender,
RendererPageServiceWorkerInternalTask, RendererServiceWorkerInternalTask,
ServiceWorkerInternalCallbackEffect,
};
pub(crate) use self::service_worker_tasks::RendererPageServiceWorkerTaskSender;
#[cfg(test)]
pub(crate) use self::service_worker_tasks::RendererPageServiceWorkerTestHarness;
#[cfg(test)]
pub(crate) use self::shared_worker_client_event::RendererSharedWorkerClientEventKind;
pub(crate) use self::shared_worker_client_event::{
PageSharedWorkerClientEventTargetEffect, PageSharedWorkerClientEventTurnAction,
PageSharedWorkerClientEventTurnOutcome, RendererPageSharedWorkerClientEventOwner,
RendererPageSharedWorkerClientEventProducer, RendererPageSharedWorkerClientEventRealmSender,
RendererPageSharedWorkerClientEventSender, RendererPageSharedWorkerClientEventTask,
};
pub(crate) use self::storage_event_delivery::{
PageStorageEventDeliveryTargetEffect, PageStorageEventDeliveryTurnAction,
PageStorageEventDeliveryTurnOutcome, RendererPageStorageEventData,
RendererPageStorageEventDeliveryOwner, RendererPageStorageEventDeliverySender,
RendererPageStorageEventDeliveryTask,
};
#[cfg(test)]
pub(crate) use self::stylesheet_task::RendererPageStylesheetTaskTestResidence;
pub(crate) use self::stylesheet_task::{
PageConnectedStyleEventTargetEffect, PageConnectedStyleEventTurnAction,
PageConnectedStyleEventTurnOutcome, PageConnectedStyleLoadDelayEffect,
PageStylesheetNetworkingTargetEffect, PageStylesheetNetworkingTurnAction,
PageStylesheetNetworkingTurnOutcome, RendererPageConnectedStyleEventTask,
RendererPageStylesheetCompletion, RendererPageStylesheetNetworkingTask,
RendererPageStylesheetTaskOwner, RendererPageStylesheetTaskProducer,
RendererPageStylesheetTaskSender,
};
pub(super) use self::tasks::{
ContentSecurityPolicyViolationEventTask, MainDocumentMetaRefreshNavigationTask,
PageOwnedInternalLoadingTask, PageOwnedInternalLoadingTaskEffect, PageTask,
WindowScriptFailureReportTask,
};
pub(crate) use self::text_track_default_mode::{
PageTextTrackDefaultModeTargetEffect, PageTextTrackDefaultModeTurnAction,
PageTextTrackDefaultModeTurnOutcome, RendererPageTextTrackDefaultModeOwner,
RendererPageTextTrackDefaultModeSender, RendererPageTextTrackDefaultModeTask,
RendererPageTextTrackDefaultModeTaskId, RendererPageTextTrackDefaultModeTaskKind,
};
pub(crate) use self::text_track_load::{
PageTextTrackLoadStalePayloadEffect, PageTextTrackLoadTargetEffect,
PageTextTrackLoadTurnAction, PageTextTrackLoadTurnOutcome, RendererPageTextTrackLoadOwner,
RendererPageTextTrackLoadRouteClosed, RendererPageTextTrackLoadSender,
RendererPageTextTrackLoadTask, RendererPageTextTrackLoadTaskId,
RendererPageTextTrackLoadTaskKind,
};
pub(crate) use self::user_interaction::{
PageUserInteractionBodyEffect, PageUserInteractionTargetEffect, PageUserInteractionTurnAction,
PageUserInteractionTurnOutcome, RendererPageUserInteractionEventKind,
RendererPageUserInteractionOwner, RendererPageUserInteractionSender,
RendererPageUserInteractionTask, RendererPageUserInteractionTaskId,
RendererPageUserInteractionTaskKind,
};
#[cfg(test)]
pub(crate) use self::v8_foreground_task::RendererPageV8ForegroundTaskOwner;
pub(crate) use self::v8_foreground_task::{
PageV8ForegroundTaskEffect, PageV8ForegroundTaskTurnAction, PageV8ForegroundTaskTurnOutcome,
RendererPageV8ForegroundTask, RendererPageV8ForegroundTaskSender,
};
pub(crate) use self::view_transition_update::{
PageViewTransitionUpdateTargetEffect, PageViewTransitionUpdateTurnAction,
PageViewTransitionUpdateTurnOutcome, RendererPageViewTransitionUpdateOwner,
RendererPageViewTransitionUpdateSender, RendererPageViewTransitionUpdateTask,
RendererPageViewTransitionUpdateTaskId,
};
pub(crate) use self::webcrypto_task::{
PageWebCryptoTaskTargetEffect, PageWebCryptoTaskTurnAction, PageWebCryptoTaskTurnOutcome,
RendererPageWebCryptoTask, RendererPageWebCryptoTaskId, RendererPageWebCryptoTaskOwner,
RendererPageWebCryptoTaskProducer, RendererPageWebCryptoTaskSender,
};
#[cfg(test)]
pub(crate) use self::websocket_event::RendererPageWebSocketOwner;
pub(crate) use self::websocket_event::{
PageWebSocketBodyEffect, PageWebSocketTargetEffect, PageWebSocketTurnAction,
PageWebSocketTurnOutcome, RendererPageWebSocketReadiness, RendererPageWebSocketSender,
RendererPageWebSocketTask,
};
pub(crate) use self::window_message::{
PageWindowMessageTargetEffect, PageWindowMessageTurnAction, PageWindowMessageTurnOutcome,
RendererPageWindowMessageOwner, RendererPageWindowMessageSender, RendererPageWindowMessageTask,
RendererPageWindowMessageTaskId,
};
pub(crate) use self::worker_host_bridge::{
PageWorkerHostBridgeCurrentEffect, PageWorkerHostBridgeTargetEffect,
PageWorkerHostBridgeTurnAction, PageWorkerHostBridgeTurnOutcome,
RendererPageWorkerHostBridgeOwner, RendererPageWorkerHostBridgeTask,
RendererWorkerHostBridgeEventSender, is_worker_host_bridge_message,
};
/// Minimal page-owned task queue.
///
/// This queue is deliberately narrow:
/// - FIFO task storage
/// - no general task source taxonomy yet
/// - currently only script-adjacent page tasks flow through it:
/// - script execution turns
/// - DOMContentLoaded dispatch
/// - window load dispatch
///
/// The important structural change is that page-owned JS work now has an
/// explicit queueing step before execution. That makes it possible to evolve
/// toward a more standard task/checkpoint model without keeping
/// `ParseTimeCoordinator` as the place that directly executes whichever ready
/// scripts the scheduler happened to return.
///
/// In other words:
/// - `LocalSet` gives us a stable owner lane
/// - `PageTaskQueue` starts giving that lane explicit work units
/// - a future page/document event loop can grow from this queue instead of from
/// ad-hoc "run the ready script right now" call paths
#[derive(Debug)]
pub(super) struct PageTaskQueue {
task_source: OwnerTaskSource<PageTask>,
parse_time_document_script_source: OwnerTaskSource<ParseTimeDocumentScriptEvent>,
post_parse_work_source: OwnerTaskSource<PostParsePageOwnedWork>,
page_runtime_task_source: PageRuntimeTaskSource,
}
/// Low-level test fixture over the production Page task route and queue.
///
/// The fixture, rather than [`PageTaskQueue`] or [`PageRuntimeTaskSource`],
/// owns the unique source consumer. Tests can therefore inspect or execute a
/// production task without adding test-only state to either production type.
#[cfg(test)]
pub(crate) struct PageTaskQueueTestHarness {
queue: PageTaskQueue,
residence: RendererPageTaskTestResidence,
}
#[cfg(test)]
impl std::ops::Deref for PageTaskQueueTestHarness {
type Target = PageTaskQueue;
fn deref(&self) -> &Self::Target {
&self.queue
}
}
#[cfg(test)]
impl std::ops::DerefMut for PageTaskQueueTestHarness {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.queue
}
}
#[cfg(test)]
impl PageTaskQueueTestHarness {
pub(crate) fn new() -> Self {
Self::new_with_owner_wake(None)
}
pub(crate) fn new_with_owner_wake(owner_wake: Option<RendererOwnerWakeSender>) -> Self {
let residence = RendererPageTaskTestResidence::new(owner_wake);
Self::new_with_residence(residence)
}
pub(crate) fn new_with_residence(residence: RendererPageTaskTestResidence) -> Self {
Self {
queue: PageTaskQueue::new_with_page_runtime_task_source(residence.runtime_source()),
residence,
}
}
pub(crate) fn task_sources(&self) -> RendererPageOwnedTaskSourcesTestHarness {
self.residence.task_sources()
}
pub(crate) fn residence(&self) -> RendererPageTaskTestResidence {
self.residence.clone()
}
}
impl PageTaskQueue {
pub(super) fn new_with_page_runtime_task_source(
page_runtime_task_source: PageRuntimeTaskSource,
) -> Self {
Self {
task_source: OwnerTaskSource::new(),
parse_time_document_script_source: OwnerTaskSource::new(),
post_parse_work_source: OwnerTaskSource::new(),
page_runtime_task_source,
}
}
pub(super) fn resource_completion_sender(
&self,
) -> Option<crate::page_resource_completion::RendererPageResourceCompletionSender> {
self.page_runtime_task_source.resource_completion_sender()
}
pub(super) fn page_task_producer_routes_match(
&self,
sources: &RendererPageOwnedTaskSources,
) -> bool {
self.page_runtime_task_source
.page_task_producer_routes_match(sources)
}
pub(super) async fn wait_for_page_runtime_wake(&self) {
self.page_runtime_task_source.wait().await;
}
/// Wait for a producer-side arrival without treating already-buffered local
/// work as a new wake. This is a test observation hook over production
/// sources; it does not select or execute a task.
#[cfg(test)]
pub(crate) async fn wait_for_injected_task_arrival_without_timeout(&mut self) -> bool {
tokio::select! {
biased;
arrived = self.post_parse_work_source.wait_for_wake_arrival() => arrived,
_ = self.page_runtime_task_source.wait() => true,
arrived = self.task_source.wait_for_wake_arrival() => arrived,
}
}
pub(super) fn enqueue_front_post_parse_work_preserving_order<I>(&mut self, work: I)
where
I: IntoIterator<Item = PostParsePageOwnedWork>,
{
let work: Vec<PostParsePageOwnedWork> = work.into_iter().collect();
for item in work.into_iter().rev() {
self.post_parse_work_source
.enqueue_parser_boundary_local(item);
}
}
pub(super) fn extend_post_parse_work<I>(&mut self, work: I)
where
I: IntoIterator<Item = PostParsePageOwnedWork>,
{
let mut work: Vec<PostParsePageOwnedWork> = work.into_iter().collect();
work.sort_by_key(PostParsePageOwnedWork::phase_sort_key);
self.post_parse_work_source.extend_local(work);
}
pub(super) fn post_parse_pop_front(&mut self) -> Option<PostParsePageOwnedWork> {
self.complete_ready_source_loads();
self.post_parse_work_source.pop_front()
}
pub(super) fn post_parse_front(&mut self) -> Option<&PostParsePageOwnedWork> {
self.complete_ready_source_loads();
self.post_parse_work_source.front()
}
/// Discard work whose lifetime is bounded by this concrete PageVm.
///
/// Page-runtime sources are deliberately excluded: their container lives
/// in the stable Page script environment and survives Document
/// replacement. The stable Page slot clears them only when the Page is
/// retired.
pub(super) fn clear_document_owned_tasks(&mut self) {
self.task_source.clear_local();
self.parse_time_document_script_source.clear_local();
self.post_parse_work_source.clear_local();
}
pub(super) fn front(&mut self) -> Option<&PageTask> {
let _ = self.complete_ready_source_loads();
self.task_source.front()
}
pub(crate) fn pending_task_source_load(&mut self) -> Option<SharedScriptSourceLoad> {
let _ = self.complete_ready_source_loads();
self.post_parse_work_source
.front()
.and_then(PostParsePageOwnedWork::pending_source_load)
}
pub(super) fn is_empty(&mut self) -> bool {
let _ = self.complete_ready_source_loads();
self.task_source.is_empty()
&& self.parse_time_document_script_source.is_empty()
&& self.post_parse_work_source.is_empty()
}
pub(crate) fn complete_ready_source_loads(&mut self) -> bool {
let source_load_wake = self.page_runtime_task_source.page_runtime_wake_sender();
let mut completed = false;
self.post_parse_work_source.with_tasks_mut(|tasks| {
for task in tasks.iter_mut() {
completed |= refresh_page_owned_source_load(task, &source_load_wake);
}
promote_ready_post_parse_async_work_over_waiting_source_loads(tasks);
});
completed
}
}
fn promote_ready_post_parse_async_work_over_waiting_source_loads(
tasks: &mut std::collections::VecDeque<PostParsePageOwnedWork>,
) {
let Some(mut insert_at) = tasks
.iter()
.position(PostParsePageOwnedWork::is_waiting_for_source_load)
else {
return;
};
let mut index = insert_at + 1;
while index < tasks.len() {
if tasks[index].is_async_phase_document_script()
&& !tasks[index].is_waiting_for_source_load()
{
let work = tasks
.remove(index)
.expect("ready async owner work index should still be present");
tasks.insert(insert_at, work);
insert_at += 1;
index += 1;
} else {
index += 1;
}
}
}
fn refresh_page_owned_source_load(
work: &mut PostParsePageOwnedWork,
source_load_wake: &PageRuntimeWakeSender,
) -> bool {
if work.complete_source_load_if_ready() {
return true;
}
let Some(source_load) = work.claim_source_load_completion_wake() else {
return false;
};
let source_load_wake = source_load_wake.clone();
source_load.register_completion_wake(move || {
let _ = source_load_wake.send_document_lifecycle_wake();
});
false
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dom::NodeId;
use crate::{
document_script_scheduler::{
DocumentScriptExecutionLane, PageOwnedDocumentScriptWork, ParseTimeDocumentScriptEvent,
ParseTimeDocumentScriptTask,
},
host::{ScriptEventKind, ScriptEventTask},
planning::{
PreparedScript, PreparedScriptSourceLoadOutcome, ScriptSource, SharedScriptSourceLoad,
},
runtime::RendererPageToken,
types::{
AsyncSubresourceFetchCompletion, ScriptKind, ScriptMode, ScriptRun, ScriptSourceKind,
},
};
use moli_websocket::Event as WebSocketEvent;
use url::Url;
fn prepared_script(position: usize) -> PreparedScript {
PreparedScript {
position,
node_id: NodeId::new(position + 1),
kind: ScriptKind::Classic,
mode: ScriptMode::Async,
source_kind: ScriptSourceKind::External,
fetch_metadata: crate::planning::ScriptFetchMetadata::default(),
source: ScriptSource::External,
url: Url::parse(&format!("https://example.com/{position}.js")).unwrap(),
base_url: Url::parse(&format!("https://example.com/{position}.js")).unwrap(),
initiator_url: Url::parse("https://example.com/index.html").unwrap(),
host_script_handle: None,
}
}
fn post_parse_document_script_work(
lane: DocumentScriptExecutionLane,
script: PreparedScript,
) -> PostParsePageOwnedWork {
PostParsePageOwnedWork::document_script_work(PageOwnedDocumentScriptWork::script(
lane, script,
))
}
fn post_parse_document_script_work_waiting_for_source(
lane: DocumentScriptExecutionLane,
script: PreparedScript,
source_load: SharedScriptSourceLoad,
) -> PostParsePageOwnedWork {
PostParsePageOwnedWork::document_script_work(
PageOwnedDocumentScriptWork::script_waiting_for_source(lane, script, source_load),
)
}
fn is_async_phase_document_script_work(work: &PostParsePageOwnedWork, position: usize) -> bool {
work.as_page_task().is_none()
&& work.is_async_phase_document_script()
&& work
.as_script()
.is_some_and(|script| script.position == position)
}
fn skipped_script_run(position: usize) -> ScriptRun {
ScriptRun::skipped(
NodeId::new(position + 1),
ScriptKind::Classic,
ScriptMode::Normal,
ScriptSourceKind::Inline,
Url::parse(&format!("https://example.com/{position}.js")).unwrap(),
crate::types::ScriptSkipReason::NotInMainDocument,
)
}
fn record_document_script_run_task(position: usize) -> PageTask {
PageTask::RecordDocumentScriptRun {
position,
run: skipped_script_run(position),
}
}
fn source_load_outcome_ok(source: impl Into<String>) -> PreparedScriptSourceLoadOutcome {
PreparedScriptSourceLoadOutcome {
source_result: Ok(source.into()),
source_bytes: None,
network_result: None,
}
}
fn async_subresource_completion(internal_id: u64) -> AsyncSubresourceFetchCompletion {
AsyncSubresourceFetchCompletion {
internal_id,
request_url: Url::parse("https://example.com/api").unwrap(),
request_method: "GET".to_owned(),
request_headers: Vec::new().into(),
request_body: None,
response_status_text: None,
skip_fetch_security_validation: false,
response_filter: None,
network_error_text: None,
result: Err("test failure".to_owned()).into(),
}
}
#[tokio::test]
async fn renderer_resource_completion_sender_wakes_owner_queue() {
let mut queue = RendererResourceCompletionTestHarness::new();
let sender = queue.sender();
sender
.send_async_subresource(async_subresource_completion(7))
.expect("resource completion should send");
assert!(queue.wait_for_arrival_without_timeout().await);
let completion = queue
.pop_next_async_subresource_event()
.expect("completion should be queued");
assert!(matches!(
completion,
crate::types::AsyncSubresourceFetchEvent::Completion(completion)
if completion.internal_id == 7
));
assert!(!queue.has_ready_completion());
}
#[tokio::test]
async fn distinct_resource_and_websocket_capabilities_signal_the_same_page_owner() {
let (wake_tx, mut wake_rx) = tokio::sync::mpsc::unbounded_channel();
let page_token = RendererPageToken::new_for_testing(crate::PageId::new_for_testing(1));
let owner_wake = RendererOwnerWakeSender::new(wake_tx, page_token);
let residence = RendererPageTaskTestResidence::new(Some(owner_wake.clone()));
let root_document = residence.root_document();
let senders = residence
.runtime_source()
.bound_task_producer_senders(root_document)
.expect("test Page residence must expose all typed producer routes");
let (js_context, _, resource_completion, _, _, _) = senders.into_parts();
let resource_sender = RendererResourceCompletionSender::for_page_scheduler(
resource_completion,
root_document,
);
let websocket_sender = js_context.websocket().clone();
resource_sender
.send_async_subresource(async_subresource_completion(7))
.expect("async subresource completion should send");
assert_eq!(
wake_rx
.try_recv()
.expect("async subresource should wake owner")
.page_id()
.as_u64(),
1
);
assert!(
websocket_sender
.event_sender()
.send(WebSocketEvent::Close {
socket_id: 11,
code: 1005,
reason: String::new(),
was_clean: true,
})
.await
);
assert_eq!(
wake_rx
.try_recv()
.expect("websocket event should wake owner")
.page_id()
.as_u64(),
1
);
}
#[test]
fn resource_completion_queue_is_independent_from_page_task_queue_clear() {
let mut page_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
let mut resource_queue = RendererResourceCompletionTestHarness::new();
let sender = resource_queue.sender();
page_queue.enqueue_parser_boundary(PageTask::DispatchWindowLoad);
sender
.send_async_subresource(async_subresource_completion(11))
.expect("resource completion should send");
page_queue.clear_document_owned_tasks();
assert!(page_queue.parse_time_pop_front().is_none());
let completion = resource_queue
.pop_next_async_subresource_event()
.expect("resource completion must not live in PageTaskQueue");
assert!(matches!(
completion,
crate::types::AsyncSubresourceFetchEvent::Completion(completion)
if completion.internal_id == 11
));
}
#[test]
fn ready_post_parse_async_source_load_becomes_page_owned_script_work() {
let mut queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
queue.extend_post_parse_work([post_parse_document_script_work_waiting_for_source(
DocumentScriptExecutionLane::AsyncPhase,
prepared_script(1),
SharedScriptSourceLoad::ready_ok("window.readyAsync = 1;"),
)]);
let front = queue.post_parse_front().expect("ready async work");
assert!(!front.is_waiting_for_source_load());
assert!(front.as_page_task().is_none());
assert!(matches!(
front,
PostParsePageOwnedWork::DocumentScript(work)
if matches!(
work.as_ref(),
PageOwnedDocumentScriptWork::Script {
lane: DocumentScriptExecutionLane::AsyncPhase,
script,
..
} if matches!(
&script.source,
ScriptSource::Loaded(source)
if source == "window.readyAsync = 1;"
)
)
));
}
#[test]
fn failed_post_parse_async_source_load_becomes_page_owned_source_failure() {
let mut queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
queue.extend_post_parse_work([post_parse_document_script_work_waiting_for_source(
DocumentScriptExecutionLane::AsyncPhase,
prepared_script(1),
SharedScriptSourceLoad::ready_err("synthetic source load failure"),
)]);
let front = queue.post_parse_front().expect("ready async failure work");
assert!(!front.is_waiting_for_source_load());
assert!(front.as_page_task().is_none());
assert!(matches!(
front,
PostParsePageOwnedWork::DocumentScript(work)
if matches!(
work.as_ref(),
PageOwnedDocumentScriptWork::AsyncSourceFailure {
lane: crate::document_script_scheduler::DocumentScriptSourceFailureLane::AsyncPhase,
script,
failure,
..
} if matches!(&script.source, ScriptSource::External)
&& failure.message() == "synthetic source load failure"
)
));
}
#[tokio::test]
async fn ready_async_phase_script_bypasses_pending_async_source_load() {
let mut queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
queue.extend_post_parse_work([
PostParsePageOwnedWork::lifecycle_work(PostParseLifecycleWork::test_domcontentloaded()),
post_parse_document_script_work_waiting_for_source(
DocumentScriptExecutionLane::AsyncPhase,
prepared_script(1),
SharedScriptSourceLoad::spawn_for_test(std::future::pending()),
),
post_parse_document_script_work(
DocumentScriptExecutionLane::AsyncPhase,
prepared_script(2).with_loaded_source("ready".to_owned()),
),
PostParsePageOwnedWork::lifecycle_work(PostParseLifecycleWork::test_window_load()),
]);
assert!(
queue
.post_parse_pop_front()
.is_some_and(|work| work.is_domcontentloaded_task())
);
let first_async = queue
.post_parse_pop_front()
.expect("ready async should bypass pending async");
assert!(is_async_phase_document_script_work(&first_async, 2));
assert!(
queue
.post_parse_front()
.is_some_and(PostParsePageOwnedWork::is_waiting_for_source_load)
);
}
#[tokio::test]
async fn ready_async_phase_script_bypasses_pending_defer_source_load() {
let mut queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
queue.extend_post_parse_work([
post_parse_document_script_work_waiting_for_source(
DocumentScriptExecutionLane::ClassicDefer,
prepared_script(1),
SharedScriptSourceLoad::spawn_for_test(std::future::pending()),
),
PostParsePageOwnedWork::lifecycle_work(PostParseLifecycleWork::test_domcontentloaded()),
post_parse_document_script_work(
DocumentScriptExecutionLane::AsyncPhase,
prepared_script(2).with_loaded_source("ready".to_owned()),
),
PostParsePageOwnedWork::lifecycle_work(PostParseLifecycleWork::test_window_load()),
]);
let first = queue
.post_parse_pop_front()
.expect("ready async should bypass pending defer");
assert!(is_async_phase_document_script_work(&first, 2));
assert!(
queue
.post_parse_front()
.is_some_and(PostParsePageOwnedWork::is_waiting_for_source_load)
);
}
#[test]
fn lifecycle_page_tasks_do_not_reenter_parse_time_scheduler_followup() {
assert!(
!PageTask::SeedDocumentOwnedBlockingStylesheets(Vec::new())
.allows_parse_time_scheduler_followup_turn()
);
assert!(!PageTask::DispatchDomContentLoaded.allows_parse_time_scheduler_followup_turn());
assert!(!PageTask::DispatchWindowLoad.allows_parse_time_scheduler_followup_turn());
}
#[test]
fn lifecycle_page_tasks_keep_distinct_phase_labels() {
assert_eq!(
PageTask::SeedDocumentOwnedBlockingStylesheets(Vec::new()).phase_label(),
"stylesheet seed task"
);
assert_eq!(
PageTask::DispatchDomContentLoaded.phase_label(),
"domcontentloaded task"
);
}
#[test]
fn parser_boundary_tasks_are_visible_after_production_wake_admission() {
let mut queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
let sender = queue.parser_boundary_sender();
sender.send(PageTask::DispatchDomContentLoaded).unwrap();
assert!(queue.parse_time_front().is_none());
queue.accept_ready_parse_time_wakes();
assert!(matches!(
queue.parse_time_pop_front(),
Some(PageTask::DispatchDomContentLoaded)
));
}
#[test]
fn parser_boundary_task_arriving_after_empty_poll_is_visible_after_admission() {
let mut queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
let sender = queue.parser_boundary_sender();
assert!(queue.parse_time_pop_front().is_none());
let _ = sender.send(PageTask::DispatchWindowLoad);
queue.accept_ready_parse_time_wakes();
assert!(matches!(
queue.parse_time_pop_front(),
Some(PageTask::DispatchWindowLoad)
));
}
#[test]
fn admitted_parser_boundary_tasks_precede_existing_local_parse_time_work() {
let mut queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
queue.enqueue_parser_boundary(PageTask::DispatchDomContentLoaded);
let sender = queue.parser_boundary_sender();
sender
.send(PageTask::window_script_failure_report(
WindowScriptFailureReportTask::new("boom", Some("/tmp/failure.mjs".to_owned())),
))
.unwrap();
queue.accept_ready_parse_time_wakes();
assert!(matches!(
queue.parse_time_pop_front(),
Some(PageTask::ReportWindowScriptFailure(WindowScriptFailureReportTask {
message,
filename,
..
})) if message == "boom" && filename.as_deref() == Some("/tmp/failure.mjs")
));
assert!(matches!(
queue.parse_time_pop_front(),
Some(PageTask::DispatchDomContentLoaded)
));
}
#[test]
fn parse_time_turn_accepts_ready_parser_boundary_work_before_polling() {
let mut queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
let sender = queue.parser_boundary_sender();
sender
.send(PageTask::window_script_failure_report(
WindowScriptFailureReportTask::new("boom", None),
))
.unwrap();
assert!(queue.parse_time_front().is_none());
queue.accept_ready_parse_time_wakes();
assert!(matches!(
queue.parse_time_pop_front(),
Some(PageTask::ReportWindowScriptFailure(WindowScriptFailureReportTask {
message,
..
})) if message == "boom"
));
}
#[test]
fn open_stream_document_admission_requires_a_concrete_parse_time_payload() {
let mut queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
assert!(
!queue.admit_ready_parse_time_document_work(),
"an empty stable source must not manufacture a Document owner turn"
);
queue
.parse_time_document_script_sender()
.send(ParseTimeDocumentScriptEvent::async_completion(
NodeId::new(89),
source_load_outcome_ok("ready"),
))
.expect("test completion should enter the stable source");
assert!(queue.admit_ready_parse_time_document_work());
assert!(matches!(
queue.parse_time_document_script_pop_front(),
Some(ParseTimeDocumentScriptEvent::AsyncCompletion(_))
));
assert!(!queue.admit_ready_parse_time_document_work());
}
#[test]
fn phase_transition_collects_ready_parse_time_lifecycle_wakes() {
let mut queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
queue.enqueue_parse_time_document_script_task(Some(
ParseTimeDocumentScriptTask::classic_async_script_for_test(prepared_script(7)),
));
queue
.parser_boundary_sender()
.send(PageTask::window_script_failure_report(
WindowScriptFailureReportTask::new("boom", None),
))
.unwrap();
let lifecycle_work = queue.take_parse_time_lifecycle_work();
assert!(matches!(
lifecycle_work[0].as_lifecycle_work(),
Some(PostParseLifecycleWork::ReportWindowScriptFailure(
WindowScriptFailureReportTask { message, .. }
)) if message == "boom"
));
assert!(matches!(
queue.parse_time_document_script_pop_front(),
Some(ParseTimeDocumentScriptEvent::ReadyTask(task))
if matches!(task.as_ref(), ParseTimeDocumentScriptTask::ClassicAsyncScript(_))
));
assert!(queue.take_parse_time_lifecycle_work().is_empty());
}
#[tokio::test]
async fn waiting_for_injected_arrival_ignores_existing_local_tasks() {
let mut queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
queue.enqueue_parser_boundary(PageTask::DispatchDomContentLoaded);
let arrived = tokio::time::timeout(
std::time::Duration::from_millis(5),
queue.wait_for_injected_task_arrival_without_timeout(),
)
.await;
assert!(arrived.is_err());
assert!(matches!(
queue.parse_time_pop_front(),
Some(PageTask::DispatchDomContentLoaded)
));
}
#[tokio::test]
async fn pending_post_parse_source_load_wakes_its_durable_owner_queue() {
let (finish_tx, finish_rx) = tokio::sync::oneshot::channel();
let source_load = SharedScriptSourceLoad::spawn_for_test(async move {
finish_rx.await.expect("source completion signal");
Ok("window.asyncReady = true;".to_owned())
});
let (owner_wake_tx, mut owner_wake_rx) = tokio::sync::mpsc::unbounded_channel();
let page_token = RendererPageToken::new_for_testing(crate::PageId::new_for_testing(8));
let mut queue = crate::page_task_queue::PageTaskQueueTestHarness::new_with_owner_wake(
Some(RendererOwnerWakeSender::new(owner_wake_tx, page_token)),
);
queue.extend_post_parse_work([PostParsePageOwnedWork::document_script_work(
PageOwnedDocumentScriptWork::script_waiting_for_source(
DocumentScriptExecutionLane::AsyncPhase,
prepared_script(1),
source_load,
),
)]);
assert!(
queue
.post_parse_front()
.expect("pending post-parse script")
.is_waiting_for_source_load()
);
finish_tx.send(()).expect("finish source load");
assert!(
tokio::time::timeout(
std::time::Duration::from_secs(1),
queue.wait_for_injected_task_arrival_without_timeout(),
)
.await
.expect("source terminal should wake the page-owned queue")
);
let owner_wake = owner_wake_rx
.recv()
.await
.expect("source terminal should wake the renderer owner");
assert_eq!(
owner_wake.source_for_test(),
RendererOwnerWakeSource::Runtime(
crate::runtime::RendererOwnerRuntimeActivitySource::DocumentLifecycleTurn
)
);
assert!(
!queue
.post_parse_front()
.expect("ready post-parse script")
.is_waiting_for_source_load()
);
}
#[tokio::test]
async fn local_runtime_wake_does_not_manufacture_an_owner_task() {
let (owner_wake_tx, mut owner_wake_rx) = tokio::sync::mpsc::unbounded_channel();
let page_token = RendererPageToken::new_for_testing(crate::PageId::new_for_testing(9));
let source = PageRuntimeTaskSource::new(Some(RendererOwnerWakeSender::new(
owner_wake_tx,
page_token,
)));
source
.page_runtime_wake_sender()
.send_wake()
.expect("local runtime wake is infallible");
tokio::time::timeout(std::time::Duration::from_secs(1), source.wait())
.await
.expect("local runtime observer should receive its durable wake");
assert!(
owner_wake_rx.try_recv().is_err(),
"a payload-free runtime wake must not manufacture an owner Page turn"
);
}
#[test]
fn take_parse_time_document_script_events_removes_only_typed_events() {
let mut queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
let parser_boundary = queue.parser_boundary_sender();
for task in [
PageTask::SeedDocumentOwnedBlockingStylesheets(Vec::new()),
record_document_script_run_task(1),
PageTask::DispatchDomContentLoaded,
PageTask::DispatchWindowLoad,
] {
parser_boundary.send(task).expect("parser-boundary task");
}
queue.accept_ready_parse_time_wakes();
queue.enqueue_parse_time_document_script_task(Some(
ParseTimeDocumentScriptTask::classic_async_script_for_test(prepared_script(1)),
));
queue.enqueue_parse_time_document_script_event(
ParseTimeDocumentScriptEvent::async_completion(
NodeId::new(99),
source_load_outcome_ok("ready"),
),
);
let parse_time = queue.take_parse_time_document_script_events();
assert!(matches!(
&parse_time[0],
ParseTimeDocumentScriptEvent::ReadyTask(task)
if matches!(task.as_ref(), ParseTimeDocumentScriptTask::ClassicAsyncScript(_))
));
assert!(matches!(
parse_time[1],
ParseTimeDocumentScriptEvent::AsyncCompletion(_)
));
let lifecycle = queue.take_parse_time_lifecycle_work();
assert_eq!(lifecycle.len(), 4);
assert!(lifecycle.iter().any(|work| {
matches!(
work.as_lifecycle_work(),
Some(PostParseLifecycleWork::RecordDocumentScriptRun { position: 1, .. })
)
}));
assert!(queue.take_parse_time_lifecycle_work().is_empty());
}
#[tokio::test]
async fn parse_time_wait_observes_producer_arrival_without_timing_delay() {
let mut queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
let sender = queue.parse_time_document_script_sender();
let send = async move {
sender
.send(ParseTimeDocumentScriptEvent::async_completion(
NodeId::new(88),
source_load_outcome_ok("ready"),
))
.unwrap();
};
let (arrived, ()) = tokio::join!(
queue.wait_for_parse_time_injected_task_arrival_without_timeout(),
send
);
assert!(arrived);
let Some(ParseTimeDocumentScriptEvent::AsyncCompletion(completion)) =
queue.parse_time_document_script_pop_front()
else {
panic!("expected async completion event");
};
let (node_id, outcome) = completion.into_parts();
assert_eq!(node_id, NodeId::new(88));
assert!(matches!(
outcome.source_result,
Ok(ref source) if source == "ready"
));
}
#[test]
fn script_event_tasks_do_not_reenter_parse_time_async_lane() {
assert!(
!PageTask::script_event(ScriptEventTask::new(ScriptEventKind::Load, "load"))
.allows_parse_time_scheduler_followup_turn()
);
assert!(
!PageTask::script_event(ScriptEventTask::new(ScriptEventKind::Error, "error"))
.belongs_to_parse_time_async_lane()
);
assert!(
PageTask::script_event(ScriptEventTask::new(ScriptEventKind::Load, "load"))
.is_script_event_task()
);
}
}