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 crate::{
context_bootstrap::dispatch_window_promise_rejection_event,
exception_reporting::log_unhandled_promise_rejection,
native_bridge::{JsContextHost, WindowExecutionContextBinding},
util::context_host_ptr_from_global_bridge,
};
use std::{
cell::RefCell,
pin::pin,
rc::{Rc, Weak},
time::Instant,
};
const MAX_REPORTED_WINDOW_PROMISE_REJECTIONS: usize = 1024;
#[derive(Clone)]
struct PendingPromiseRejection {
promise: v8::Global<v8::Promise>,
reason: Option<v8::Global<v8::Value>>,
// Promise events follow the exact realm where V8 first reported the
// rejection. The strict binding restores both the V8 context and the
// registry-backed LocalWindow/access-policy identity.
realm: WindowExecutionContextBinding,
}
#[derive(Clone)]
pub(crate) struct PromiseRejectDispatchSlot {
pub(super) host_weak: Weak<RefCell<JsContextHost>>,
pending_unhandled_rejections: Rc<RefCell<Vec<PendingPromiseRejection>>>,
reported_unhandled_rejections: Rc<RefCell<Vec<PendingPromiseRejection>>>,
}
#[derive(Clone)]
struct PromiseRejectDispatchState {
host: Rc<RefCell<JsContextHost>>,
pending: Rc<RefCell<Vec<PendingPromiseRejection>>>,
reported: Rc<RefCell<Vec<PendingPromiseRejection>>>,
}
#[derive(Default)]
struct AgentPendingPromiseRejections(Vec<PromiseRejectDispatchState>);
fn queue_agent_promise_rejection_state(
scope: &mut v8::PinScope<'_, '_>,
state: &PromiseRejectDispatchState,
) {
if scope.get_slot::<AgentPendingPromiseRejections>().is_none() {
assert!(scope.set_slot(AgentPendingPromiseRejections::default()));
}
let pending = &mut scope
.get_slot_mut::<AgentPendingPromiseRejections>()
.unwrap()
.0;
if !pending
.iter()
.any(|previous| Rc::ptr_eq(&previous.pending, &state.pending))
{
pending.push(state.clone());
}
}
fn flush_agent_pending_promise_rejections(scope: &mut v8::PinScope<'_, '_>) -> usize {
let pending = scope
.get_slot_mut::<AgentPendingPromiseRejections>()
.map(|pending| std::mem::take(&mut pending.0))
.unwrap_or_default();
pending
.into_iter()
.map(|state| flush_promise_rejection_state(scope, state))
.sum()
}
pub(super) fn promise_reject_dispatch_slot(
host_rc: Rc<RefCell<JsContextHost>>,
) -> PromiseRejectDispatchSlot {
PromiseRejectDispatchSlot {
host_weak: Rc::downgrade(&host_rc),
pending_unhandled_rejections: Rc::new(RefCell::new(Vec::new())),
reported_unhandled_rejections: Rc::new(RefCell::new(Vec::new())),
}
}
pub(super) fn install_promise_reject_dispatch_for_context(
context: v8::Local<'_, v8::Context>,
slot: &PromiseRejectDispatchSlot,
) {
let _previous = context.set_slot(Rc::new(slot.clone()));
}
fn promise_reject_dispatch_state(
scope: &mut v8::PinScope<'_, '_>,
) -> Option<PromiseRejectDispatchState> {
scope
.get_current_context()
.get_slot::<PromiseRejectDispatchSlot>()
.as_deref()
.and_then(|slot| {
Some(PromiseRejectDispatchState {
host: slot.host_weak.upgrade()?,
pending: slot.pending_unhandled_rejections.clone(),
reported: slot.reported_unhandled_rejections.clone(),
})
})
}
#[cfg(test)]
pub(super) fn promise_reject_dispatch_is_available_for_test(
scope: &mut v8::PinScope<'_, '_>,
) -> bool {
promise_reject_dispatch_state(scope).is_some()
}
pub(super) fn clear_promise_rejection_dispatch_state(slot: &PromiseRejectDispatchSlot) {
slot.pending_unhandled_rejections.borrow_mut().clear();
slot.reported_unhandled_rejections.borrow_mut().clear();
}
fn pending_promise_rejection_matches<'s>(
scope: &mut v8::PinScope<'s, '_>,
rejection: &PendingPromiseRejection,
promise: v8::Local<'s, v8::Promise>,
) -> bool {
v8::Local::new(scope, &rejection.promise).strict_equals(promise.into())
}
fn remember_reported_promise_rejection(
reported: &Rc<RefCell<Vec<PendingPromiseRejection>>>,
rejection: PendingPromiseRejection,
) {
let mut reported = reported.borrow_mut();
if reported.len() >= MAX_REPORTED_WINDOW_PROMISE_REJECTIONS {
reported.remove(0);
}
reported.push(rejection);
}
fn flush_promise_rejection_state(
scope: &mut v8::PinScope<'_, '_>,
state: PromiseRejectDispatchState,
) -> usize {
let pending = std::mem::take(&mut *state.pending.borrow_mut());
let pending_len = pending.len();
let host_ptr: *mut JsContextHost = (*state.host).as_ptr();
state
.reported
.borrow_mut()
.retain(|rejection| rejection.realm.is_current(unsafe { &*host_ptr }));
for rejection in pending {
let _ = rejection
.realm
.with_current_scope(scope, host_ptr, |scope, dispatch_scope| {
let promise = v8::Local::new(scope, &rejection.promise);
let reason = rejection
.reason
.as_ref()
.map(|reason| v8::Local::new(scope, reason));
let outcome = dispatch_window_promise_rejection_event(
scope,
host_ptr,
dispatch_scope,
"unhandledrejection",
promise,
reason,
);
// A handler added by the `unhandledrejection` listener must not
// synchronously turn this notification into `rejectionhandled`.
// Only promises that remain unhandled after dispatch belong in
// the outstanding reported-rejection set.
if !promise.has_handler() {
remember_reported_promise_rejection(&state.reported, rejection.clone());
}
if matches!(outcome, Ok(true)) {
log_unhandled_promise_rejection(scope, reason);
}
});
}
pending_len
}
pub(crate) fn perform_microtask_checkpoint_and_report_pending_promise_rejections(
scope: &mut v8::PinScope<'_, '_>,
) {
let trace_enabled = moli_trace::cdp_runtime_trace_enabled();
let dom_binding_trace_enabled = trace_enabled && moli_trace::dom_binding_timing_enabled();
let trace_started = trace_enabled.then(Instant::now);
if trace_started.is_some() {
tracing::info!(
target: "moli_cdp_runtime",
stage = "microtask_checkpoint_start",
);
let _ = moli_trace::take_promise_hook_stats();
if dom_binding_trace_enabled {
let _ = moli_trace::take_dom_binding_operation_stats();
}
}
let checkpoint_started = trace_enabled.then(Instant::now);
scope.perform_microtask_checkpoint();
if let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) {
let host = unsafe { &mut *host_ptr };
crate::native_bridge::restore_deferred_active_child_window_scope_if_present(scope, host);
crate::native_bridge::restore_deferred_active_lightweight_popup_scope_if_present(
scope, host,
);
host.finish_deferred_child_subresource_request_scope_pop();
}
let promise_stats = if trace_enabled {
moli_trace::take_promise_hook_stats()
} else {
moli_trace::PromiseHookStats::default()
};
let dom_binding_stats = if dom_binding_trace_enabled {
moli_trace::take_dom_binding_operation_stats()
} else {
Vec::new()
};
let dom_operation_count: u64 = dom_binding_stats.iter().map(|stat| stat.count).sum();
let dom_total_us: u128 = dom_binding_stats.iter().map(|stat| stat.total_us).sum();
let dom_max = dom_binding_stats
.iter()
.max_by_key(|stat| stat.max_us)
.map(|stat| (stat.op, stat.max_us))
.unwrap_or(("<none>", 0));
let dom_operations = dom_binding_stats
.iter()
.map(|stat| {
format!(
"{}:count={},total_us={},max_us={}",
stat.op, stat.count, stat.total_us, stat.max_us
)
})
.collect::<Vec<_>>()
.join(";");
if let Some(started) = checkpoint_started {
tracing::info!(
target: "moli_cdp_runtime",
stage = "microtask_checkpoint_v8_done",
promise_init_count = promise_stats.init_count,
promise_resolve_count = promise_stats.resolve_count,
promise_reaction_before_count = promise_stats.reaction_before_count,
promise_reaction_after_count = promise_stats.reaction_after_count,
dom_operation_count,
dom_total_us,
dom_max_op = dom_max.0,
dom_max_op_us = dom_max.1,
dom_operations = %dom_operations,
elapsed_us = %started.elapsed().as_micros(),
);
}
let flush_started = trace_enabled.then(Instant::now);
let pending_rejections = flush_agent_pending_promise_rejections(scope);
crate::context_bootstrap::run_end_of_microtask_checkpoint_tasks(scope);
if let Some(host) = context_host_ptr_from_global_bridge(scope)
&& let Some(environment) = unsafe { &*host }.page_script_environment()
{
environment.finish_related_page_turn_completions();
}
if let Some(started) = flush_started {
tracing::info!(
target: "moli_cdp_runtime",
stage = "microtask_checkpoint_rejection_flush_done",
pending_rejections,
elapsed_us = %started.elapsed().as_micros(),
);
}
if let Some(started) = trace_started {
tracing::info!(
target: "moli_cdp_runtime",
stage = "microtask_checkpoint_done",
pending_rejections,
promise_init_count = promise_stats.init_count,
promise_resolve_count = promise_stats.resolve_count,
promise_reaction_before_count = promise_stats.reaction_before_count,
promise_reaction_after_count = promise_stats.reaction_after_count,
dom_operation_count,
dom_total_us,
dom_max_op = dom_max.0,
dom_max_op_us = dom_max.1,
dom_operations = %dom_operations,
elapsed_us = %started.elapsed().as_micros(),
);
}
}
pub(super) unsafe extern "C" fn promise_trace_hook(
hook_type: v8::PromiseHookType,
_promise: v8::Local<v8::Promise>,
_parent: v8::Local<v8::Value>,
) {
match hook_type {
v8::PromiseHookType::Init => moli_trace::record_promise_hook_init(),
v8::PromiseHookType::Resolve => moli_trace::record_promise_hook_resolve(),
// V8 documents Before/After as PromiseReactionJob boundaries. Counting
// Before gives the number of promise reaction callbacks entered during
// the currently active trace window.
v8::PromiseHookType::Before => moli_trace::record_promise_reaction_before(),
v8::PromiseHookType::After => moli_trace::record_promise_reaction_after(),
}
}
pub(super) unsafe extern "C" fn promise_reject_callback(message: v8::PromiseRejectMessage<'_>) {
let scope = pin!(unsafe { v8::CallbackScope::new(&message) });
let scope = &mut scope.init();
let context = scope.get_current_context();
let scope = &mut v8::ContextScope::new(scope, context);
let Some(state) = promise_reject_dispatch_state(scope) else {
return;
};
let host_ptr: *mut JsContextHost = (*state.host).as_ptr();
match message.get_event() {
v8::PromiseRejectEvent::PromiseRejectWithNoHandler => {
let Some(realm) =
unsafe { &*host_ptr }.current_runtime_window_execution_context_binding(scope)
else {
return;
};
let promise = message.get_promise();
queue_agent_promise_rejection_state(scope, &state);
let mut pending = state.pending.borrow_mut();
if pending
.iter()
.any(|rejection| pending_promise_rejection_matches(scope, rejection, promise))
{
return;
}
pending.push(PendingPromiseRejection {
promise: v8::Global::new(scope, promise),
reason: message
.get_value()
.map(|reason| v8::Global::new(scope, reason)),
realm,
});
}
v8::PromiseRejectEvent::PromiseHandlerAddedAfterReject => {
let promise = message.get_promise();
let mut pending = state.pending.borrow_mut();
if let Some(index) = pending
.iter()
.position(|rejection| pending_promise_rejection_matches(scope, rejection, promise))
{
pending.swap_remove(index);
return;
}
drop(pending);
let reported = {
let mut reported = state.reported.borrow_mut();
reported
.iter()
.position(|rejection| {
pending_promise_rejection_matches(scope, rejection, promise)
})
.map(|index| reported.swap_remove(index))
};
let Some(rejection) = reported else {
return;
};
let _ = rejection
.realm
.with_current_scope(scope, host_ptr, |scope, dispatch_scope| {
let promise = v8::Local::new(scope, &rejection.promise);
let reason = rejection
.reason
.as_ref()
.map(|reason| v8::Local::new(scope, reason));
let _ = dispatch_window_promise_rejection_event(
scope,
host_ptr,
dispatch_scope,
"rejectionhandled",
promise,
reason,
);
});
}
_ => {}
}
}
pub(super) unsafe extern "C" fn failed_access_check_callback(
target: v8::Local<'_, v8::Object>,
_access_type: v8::AccessType,
_data: v8::Local<'_, v8::Value>,
) {
let scope = pin!(unsafe { v8::CallbackScope::new(target) });
let scope = &mut scope.init();
let accessing_context = scope.get_current_context();
let target_context = target.get_creation_context(scope);
if moli_trace::window_message_trace_enabled() {
tracing::info!(
target: "moli_window_message_trace",
accessing_is_target = target_context == Some(accessing_context),
stage = "window_cross_origin_failed_access",
);
}
crate::native_bridge::throw_cross_origin_location_security_error(scope);
}