Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use std::{convert::Infallible, future::Future, pin::Pin};
use anyhow::Result;
use crate::document_script_scheduler::{
DocumentModuleScriptReadyWork, DocumentScriptExecutionHooks, DocumentScriptExecutionOutcome,
DocumentScriptExecutionRunner, DocumentScriptExecutionStartReport,
DocumentScriptReadyActionRoute, DocumentScriptReadyWorkOwner, MainDocumentReadyActionRoute,
ParserModuleGraphTerminalWork,
};
use crate::frame_owner_model::{DocumentLoadDelayTokenId, FrameDocumentTaskOwner};
use crate::module_script_continuation::{
MainDocumentModuleGraphReadyTarget, MainDocumentModuleGraphReadyWork, MainParserDocumentOwner,
MainParserOwnedDocumentScriptWork, MainParserOwnedModuleScriptEvaluation,
MainParserOwnedModuleScriptFailure, ModuleScriptContinuation,
};
use crate::network::ResourceRequestClient;
use crate::parser_script::action::ParserClassicScriptNextOwnerAction;
use crate::script_vm::{
ParserModuleTerminalDisposition, ParserOwnedModuleSuccessTerminal, PreparedScriptBodyActivity,
};
use super::super::main_document_ready_gate::{
claim_main_document_ready_dispatch, report_main_document_ready_owner_mismatch,
};
use super::{
PageOwnedScriptFailureClassification, PageVm,
parser_task_completion::MainParserContinuationTaskEffect,
};
pub(super) struct MainParserOwnedDocumentScriptOwner<'page, 'loader> {
page_vm: &'page mut PageVm,
loader: &'loader ResourceRequestClient,
}
type MainParserOwnedModuleReadyInput = DocumentModuleScriptReadyWork<
MainDocumentModuleGraphReadyWork,
MainParserOwnedModuleScriptFailure,
MainParserOwnedModuleScriptEvaluation,
>;
struct MainParserOwnedModuleExecutionHooks<'page, 'loader> {
page_vm: &'page mut PageVm,
loader: &'loader ResourceRequestClient,
terminal_disposition: ParserModuleTerminalDisposition,
}
#[derive(Debug)]
pub(super) enum MainParserModuleExecution {
Settled {
outcome: DocumentScriptExecutionOutcome,
task_effect: MainParserContinuationTaskEffect,
},
TerminalForSelectedTask {
outcome: DocumentScriptExecutionOutcome,
terminal: ParserOwnedModuleSuccessTerminal,
},
}
impl MainParserModuleExecution {
pub(super) fn settled(outcome: DocumentScriptExecutionOutcome) -> Self {
Self::Settled {
outcome,
task_effect: MainParserContinuationTaskEffect::NotApplied,
}
}
pub(super) fn settled_with_task_effect(
outcome: DocumentScriptExecutionOutcome,
task_effect: MainParserContinuationTaskEffect,
) -> Self {
Self::Settled {
outcome,
task_effect,
}
}
}
impl<'page, 'loader> MainParserOwnedDocumentScriptOwner<'page, 'loader> {
pub(super) fn new(page_vm: &'page mut PageVm, loader: &'loader ResourceRequestClient) -> Self {
Self { page_vm, loader }
}
/// Consume at most one exact ready parser-owned module action.
///
/// The stable source reservation represents one scheduler task. Stale
/// queue entries may be discarded while claiming it, but once one current
/// action is claimed this function never scans forward to execute another
/// action in the same selected turn.
pub(super) async fn run_next_ready_work(&mut self) -> Result<MainParserContinuationTaskEffect> {
let Some(work) = self.take_next_claimed_ready_work() else {
return Ok(MainParserContinuationTaskEffect::NotApplied);
};
let task_owner = work.payload_document_owner().task_owner();
match work.run_with_ready_owner(self).await? {
MainParserModuleExecution::Settled {
outcome,
task_effect,
} => {
tracing::debug!(
?task_owner,
?outcome,
?task_effect,
"settled one selected parser-owned module continuation"
);
Ok(task_effect)
}
MainParserModuleExecution::TerminalForSelectedTask { outcome, terminal } => {
tracing::debug!(
?task_owner,
?outcome,
"returned parser-owned module terminal to its selected task"
);
Ok(self
.page_vm
.dispatch_parser_module_terminal(task_owner, terminal))
}
}
}
fn take_next_claimed_ready_work(&mut self) -> Option<MainParserOwnedDocumentScriptWork> {
let current_owner = self
.page_vm
.vm()
.current_main_document_task_owner()
.map(MainParserDocumentOwner::new);
self.page_vm
.vm_mut()
.document_runtime
.parser_module_document_scripts_mut()
.take_next_claimed_ready_dispatch::<MainDocumentReadyActionRoute, _, _, _>(
|dispatch| {
claim_main_document_ready_dispatch(dispatch, current_owner, "parser-owned")
},
|mismatch| {
report_main_document_ready_owner_mismatch(mismatch, "parser-owned");
},
)
}
async fn run_parser_module_ready_with_shared_runner(
&mut self,
work: MainParserOwnedModuleReadyInput,
terminal_disposition: ParserModuleTerminalDisposition,
) -> Result<MainParserModuleExecution> {
let hooks = MainParserOwnedModuleExecutionHooks {
page_vm: self.page_vm,
loader: self.loader,
terminal_disposition,
};
let mut runner = DocumentScriptExecutionRunner::new(hooks);
runner.run_ready_work(work).await
}
pub(super) async fn run_parser_deferred_module_terminal(
&mut self,
owner: FrameDocumentTaskOwner,
terminal: ParserModuleGraphTerminalWork<
MainDocumentModuleGraphReadyTarget,
MainParserOwnedModuleScriptFailure,
>,
load_delay_token: DocumentLoadDelayTokenId,
) -> Result<MainParserModuleExecution> {
let ready = match terminal {
ParserModuleGraphTerminalWork::Ready(work) => {
DocumentModuleScriptReadyWork::GraphReady(*work)
}
ParserModuleGraphTerminalWork::Failed(failure) => {
DocumentModuleScriptReadyWork::GraphFailed(failure)
}
};
let result = self
.run_parser_module_ready_with_shared_runner(
ready,
ParserModuleTerminalDisposition::ReturnToSelectedParserTask,
)
.await;
let released = self
.page_vm
.vm_mut()
.release_main_parser_deferred_script_load_delay(owner, load_delay_token);
tracing::debug!(
?owner,
?load_delay_token,
released,
outcome = ?result.as_ref().ok(),
"settled main parser module-defer lifecycle ownership after terminal execution"
);
result
}
}
impl MainParserOwnedModuleExecutionHooks<'_, '_> {
fn complete_graph_failure(
&mut self,
owned_failure: MainParserOwnedModuleScriptFailure,
) -> MainParserModuleExecution {
let failure = owned_failure.into_action();
if self.terminal_disposition
== ParserModuleTerminalDisposition::CompleteWithinModuleSettlement
{
let _ = self
.page_vm
.complete_notified_module_script_graph_failures(std::iter::once((
failure.continuation,
failure.error,
)));
return MainParserModuleExecution::settled(DocumentScriptExecutionOutcome::Progressed);
}
let failure_classification = PageOwnedScriptFailureClassification::from_module_load_error(
&failure.continuation.script,
&failure.error,
);
let outcome = self.page_vm.complete_module_script_failure_for_runner(
failure.continuation,
failure.error.message().to_owned(),
failure_classification,
PreparedScriptBodyActivity::NotEntered,
self.terminal_disposition,
);
let (run, execution) = outcome;
self.page_vm.report.runs.push(run);
execution
}
}
impl DocumentScriptExecutionHooks for MainParserOwnedModuleExecutionHooks<'_, '_> {
type Ready = MainParserOwnedModuleReadyInput;
type PreparedWork = MainParserOwnedModuleReadyInput;
type PrepareFollowup = DocumentScriptExecutionOutcome;
type ExecutionResult = MainParserModuleExecution;
type PostExecutionFollowup = MainParserModuleExecution;
type Output = MainParserModuleExecution;
type ExecuteFuture<'owner>
= Pin<Box<dyn Future<Output = Result<MainParserModuleExecution>> + 'owner>>
where
Self: 'owner;
fn prepare_execution(
&mut self,
ready: Self::Ready,
) -> DocumentScriptExecutionStartReport<Self::PreparedWork, Self::PrepareFollowup> {
DocumentScriptExecutionStartReport::execute(
ready,
DocumentScriptExecutionOutcome::Progressed,
)
}
fn execute_work(&mut self, work: Self::PreparedWork) -> Self::ExecuteFuture<'_> {
Box::pin(async move {
match work {
DocumentModuleScriptReadyWork::GraphReady(graph_ready) => {
self.page_vm
.finish_ready_completed_module_script(
self.loader,
ModuleScriptContinuation::from_main_document_graph_ready_work(
graph_ready,
),
self.terminal_disposition,
)
.await
}
DocumentModuleScriptReadyWork::GraphFailed(owned_failure) => {
Ok(self.complete_graph_failure(owned_failure))
}
DocumentModuleScriptReadyWork::EvaluationCompleted(owned_evaluation) => {
self.page_vm
.run_ready_module_evaluation_completion(
self.loader,
Some(owned_evaluation.into_action()),
self.terminal_disposition,
)
.await
}
}
})
}
fn prepare_post_execution_followup(
&mut self,
execution_result: Self::ExecutionResult,
) -> Result<Self::PostExecutionFollowup> {
Ok(execution_result)
}
fn apply_post_execution_followup(
&mut self,
followup: Self::PostExecutionFollowup,
) -> Result<Self::Output> {
Ok(followup)
}
fn outcome_for_dropped_ready(
&mut self,
prepare_followup: Self::PrepareFollowup,
) -> Result<Self::Output> {
Ok(MainParserModuleExecution::settled(prepare_followup))
}
}
impl<'page, 'loader>
DocumentScriptReadyWorkOwner<
MainDocumentModuleGraphReadyTarget,
MainParserOwnedModuleScriptEvaluation,
MainParserOwnedModuleScriptFailure,
Infallible,
Infallible,
> for MainParserOwnedDocumentScriptOwner<'page, 'loader>
{
type Output<'owner>
= Pin<Box<dyn Future<Output = Result<MainParserModuleExecution>> + 'owner>>
where
Self: 'owner;
fn run_module_script_ready_work<'owner>(
&'owner mut self,
work: MainParserOwnedModuleReadyInput,
) -> Self::Output<'owner> {
Box::pin(async move {
self.run_parser_module_ready_with_shared_runner(
work,
ParserModuleTerminalDisposition::ReturnToSelectedParserTask,
)
.await
})
}
fn run_parser_classic_ready_work<'owner>(
&'owner mut self,
work: ParserClassicScriptNextOwnerAction<Infallible, Infallible>,
) -> Self::Output<'owner> {
Box::pin(async move {
match work {
ParserClassicScriptNextOwnerAction::Ready(ready) => match ready {},
ParserClassicScriptNextOwnerAction::SourceFailed(failure) => match failure {},
}
})
}
}