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(dom): preserve AbortSignal dependency order during reentrant aborts
ldm03ea89722bc4a
diff --git a/moli-core/tests/fixtures/runtime/abort_signal_dependencies.js b/moli-core/tests/fixtures/runtime/abort_signal_dependencies.jsnew file mode 100644index 000000000..1c7e4e3fe--- /dev/null+++ b/moli-core/tests/fixtures/runtime/abort_signal_dependencies.js@@ -0,0 +1,117 @@+function runAbortSignalDependencyProbe(scenario) {+ const errors = [];+ const events = [];+ const check = (condition, label) => { if (!condition) errors.push(label); };+ const checkReason = (signal, reason, label) => {+ check(signal.aborted && signal.reason === reason, label);+ let caught = false;+ try { signal.throwIfAborted(); }+ catch (error) { caught = true; check(error === reason, label + ': thrown reason'); }+ check(caught, label + ': throwIfAborted throws');+ };++ try {+ if (scenario === 'graph') {+ const first = new AbortController();+ const second = new AbortController();+ const empty = AbortSignal.any([]);+ const emptyClone = AbortSignal.any([empty]);+ const signals = [first.signal];+ signals.push(AbortSignal.any([first.signal, second.signal]));+ signals.push(AbortSignal.any([first.signal]));+ signals.push(AbortSignal.any([signals[1]]));+ signals.push(AbortSignal.any([signals[3], signals[1], first.signal, second.signal]));+ signals.push(AbortSignal.any([emptyClone, first.signal]));+ const reason = {source: 'first'};+ signals.forEach((signal, index) => signal.addEventListener('abort', event => {+ events.push(String(index));+ check(event.target === signal, 'target ' + index);+ signals.forEach((dependent, i) => checkReason(dependent, reason, index + '/' + i));+ checkReason(AbortSignal.any([emptyClone, signals[4], second.signal]), reason, 'late composite');+ }));+ first.abort(reason);+ second.abort({source: 'second'});+ signals.forEach((signal, index) => checkReason(signal, reason, 'final ' + index));+ check(!empty.aborted && empty.reason === undefined, 'empty signal stays pending');+ check(!emptyClone.aborted && emptyClone.reason === undefined, 'empty composite stays pending');+ } else if (scenario === 'reentrant') {+ const first = new AbortController();+ const second = new AbortController();+ const shared = AbortSignal.any([first.signal, second.signal]);+ const secondary = AbortSignal.any([second.signal]);+ const nested = AbortSignal.any([shared, secondary]);+ const firstReason = {source: 'first'};+ const secondReason = {source: 'second'};+ first.signal.addEventListener('abort', () => {+ events.push('first');+ checkReason(shared, firstReason, 'shared before reentry');+ checkReason(nested, firstReason, 'nested before reentry');+ second.abort(secondReason);+ });+ second.signal.addEventListener('abort', () => {+ events.push('second');+ checkReason(shared, firstReason, 'shared during reentry');+ checkReason(nested, firstReason, 'nested during reentry');+ checkReason(secondary, secondReason, 'secondary during reentry');+ for (const [sources, reason] of [+ [[secondary, shared], secondReason], [[shared, secondary], firstReason]+ ]) {+ const late = AbortSignal.any(sources);+ checkReason(late, reason, 'already aborted input order');+ late.onabort = () => errors.push('already aborted composite dispatched again');+ }+ });+ secondary.onabort = () => {+ events.push('secondary');+ first.abort({source: 'repeat'});+ };+ shared.onabort = () => events.push('shared');+ nested.onabort = () => events.push('nested');+ first.abort(firstReason);+ checkReason(shared, firstReason, 'shared final reason');+ checkReason(nested, firstReason, 'nested final reason');+ checkReason(secondary, secondReason, 'secondary final reason');+ } else if (scenario === 'listeners') {+ const controller = new AbortController();+ const first = AbortSignal.any([controller.signal]);+ const last = AbortSignal.any([first]);+ const targets = [new EventTarget()];+ if (typeof document !== 'undefined') targets.push(document.createElement('div'));+ const counts = targets.map(() => 0);+ targets.forEach((target, index) => target.addEventListener('probe', () => {+ counts[index]++;+ }, {signal: first}));+ const dispatch = () => targets.forEach(target => target.dispatchEvent(new Event('probe')));+ const removed = () => errors.push('removed dependent listener fired');+ const removedLast = () => errors.push('removed nested listener fired');+ first.addEventListener('abort', removed);+ last.addEventListener('abort', removedLast);+ last.addEventListener('abort', () => events.push('last'));+ first.addEventListener('abort', () => {+ events.push('first');+ dispatch();+ check(counts.every(count => count === 1), 'listener removal precedes dependent event');+ last.removeEventListener('abort', removedLast);+ last.addEventListener('abort', () => events.push('late-last'));+ first.addEventListener('abort', () => errors.push('listener added to active dispatch fired'));+ });+ controller.signal.addEventListener('abort', () => {+ events.push('source');+ check(first.aborted && last.aborted, 'dependent state precedes source event');+ dispatch();+ check(counts.every(count => count === 1), 'dependent algorithms wait for source event');+ first.removeEventListener('abort', removed);+ first.addEventListener('abort', () => events.push('added'));+ first.onabort = () => events.push('handler');+ });+ controller.abort('reason');+ dispatch();+ check(counts.every(count => count === 1), 'listeners remain removed');+ } else {+ errors.push('unknown scenario ' + scenario);+ }+ } catch (error) {+ errors.push(String(error));+ }+ return {errors, events};+}diff --git a/moli-core/tests/web_apis.rs b/moli-core/tests/web_apis.rsindex e67c74ad9..6754f9316 100644--- a/moli-core/tests/web_apis.rs+++ b/moli-core/tests/web_apis.rs@@ -16,6 +16,8 @@ use moli_fetch::FetchConfig;use support::FixtureServer;use tokio::time::Duration;+#[path = "web_apis/abort_signal.rs"]+mod abort_signal;fn diagnostic_global<'a>(page: &'a moli_core::page::Page,name: &str,diff --git a/moli-core/tests/web_apis/abort_signal.rs b/moli-core/tests/web_apis/abort_signal.rsnew file mode 100644index 000000000..fd57f4395--- /dev/null+++ b/moli-core/tests/web_apis/abort_signal.rs@@ -0,0 +1,51 @@+use super::*;++async fn assert_abort_signal_dependencies(scenario: &str, events: &[&str]) -> Result<()> {+ let server = FixtureServer::spawn().await?;+ let browser = Browser::new(AppConfig::default())?;+ let source = format!(+ "{}\nfinish(runAbortSignalDependencyProbe({}));",+ include_str!("../fixtures/runtime/abort_signal_dependencies.js"),+ serde_json::to_string(scenario)?,+ );+ for target in ["window", "child", "worker"] {+ let observed = tokio::time::timeout(+ Duration::from_secs(10),+ super::pipe_disturbed::run_probe(&browser, &server, target, &source),+ )+ .await??;+ assert_eq!(+ observed,+ serde_json::json!({"errors": [], "events": events}),+ "{scenario}/{target}"+ );+ }+ server.shutdown().await;+ Ok(())+}++#[tokio::test(flavor = "multi_thread")]+async fn abort_signal_any_flattens_nested_sources_and_marks_all_dependents_before_events()+-> Result<()> {+ assert_abort_signal_dependencies("graph", &["0", "1", "2", "3", "4", "5"]).await+}++#[tokio::test(flavor = "multi_thread")]+async fn abort_signal_any_preserves_first_reason_and_event_order_during_reentrant_abort()+-> Result<()> {+ assert_abort_signal_dependencies(+ "reentrant",+ &["first", "second", "secondary", "shared", "nested"],+ )+ .await+}++#[tokio::test(flavor = "multi_thread")]+async fn abort_signal_any_runs_listener_removal_before_dispatch_and_snapshots_each_event()+-> Result<()> {+ assert_abort_signal_dependencies(+ "listeners",+ &["source", "first", "added", "handler", "last", "late-last"],+ )+ .await+}diff --git a/moli-renderer-v8/src/native_bridge/abort.rs b/moli-renderer-v8/src/native_bridge/abort.rsindex df8ae4051..686db7237 100644--- a/moli-renderer-v8/src/native_bridge/abort.rs+++ b/moli-renderer-v8/src/native_bridge/abort.rs@@ -1,4 +1,4 @@-use std::collections::HashMap;+use std::collections::{HashMap, HashSet};use super::super::document_runtime::EventTargetHandle;use super::super::util::{get_private_value, set_private_value};@@ -53,6 +53,8 @@ struct AbortSignalState {reason: Option<v8::Global<v8::Value>>,abort_algorithms: Vec<v8::Global<v8::Function>>,linked_target_listeners: Vec<AbortLinkedTargetListener>,+ // None for a source; Some (including empty) for a dependent signal's ordered roots.+ source_signals: Option<Vec<u32>>,dependent_signals: Vec<u32>,}@@ -66,7 +68,6 @@ struct AbortLinkedTargetListener {struct AbortSignalDispatch {algorithms: Vec<v8::Global<v8::Function>>,linked_target_listeners: Vec<AbortLinkedTargetListener>,- dependent_signals: Vec<u32>,}impl AbortStore {@@ -275,12 +276,12 @@ impl AbortStore {}}- fn take_signal_abort<'s>(+ fn prepare_signal_abort<'s>(&mut self,scope: &mut v8::PinScope<'s, '_>,signal: v8::Local<'s, v8::Object>,reason: v8::Local<'s, v8::Value>,- ) -> Option<AbortSignalDispatch> {+ ) -> Option<Vec<(u32, v8::Local<'s, v8::Object>)>> {let signal_id = Self::signal_id_from_object(scope, signal)?;let state = self.signal_state_mut(signal_id)?;if state.aborted {@@ -288,23 +289,61 @@ impl AbortStore {}state.aborted = true;state.reason = Some(v8::Global::new(scope, reason));+ let dependent_signals = state.dependent_signals.clone();+ // Publish every reason before any author callback can reenter abort.+ let mut signals = vec![(signal_id, signal)];+ for dependent_signal_id in dependent_signals {+ let Some(state) = self.signal_state_mut(dependent_signal_id) else {+ continue;+ };+ if state.aborted {+ continue;+ }+ state.aborted = true;+ state.reason = Some(v8::Global::new(scope, reason));+ if let Some(signal) = &state.signal {+ signals.push((dependent_signal_id, v8::Local::new(scope, signal)));+ }+ }+ Some(signals)+ }++ fn take_signal_abort_steps(&mut self, signal_id: u32) -> Option<AbortSignalDispatch> {+ let state = self.signal_state_mut(signal_id)?;Some(AbortSignalDispatch {algorithms: std::mem::take(&mut state.abort_algorithms),linked_target_listeners: std::mem::take(&mut state.linked_target_listeners),- dependent_signals: state.dependent_signals.clone(),})}- pub(super) fn link_dependent_signal(+ fn set_signal_sources(&mut self,- source_signal_id: u32,dependent_signal_id: u32,+ input_signal_ids: impl IntoIterator<Item = u32>,) {- let Some(state) = self.signal_state_mut(source_signal_id) else {- return;- };- if !state.dependent_signals.contains(&dependent_signal_id) {- state.dependent_signals.push(dependent_signal_id);+ let mut sources = Vec::new();+ let mut seen = HashSet::new();+ for input_signal_id in input_signal_ids {+ let Some(state) = self.signal_state(input_signal_id) else {+ continue;+ };+ let roots = state+ .source_signals+ .as_deref()+ .unwrap_or(std::slice::from_ref(&input_signal_id));+ for &source_signal_id in roots {+ if seen.insert(source_signal_id) {+ sources.push(source_signal_id);+ }+ }+ }+ for &source_signal_id in &sources {+ if let Some(state) = self.signal_state_mut(source_signal_id) {+ state.dependent_signals.push(dependent_signal_id);+ }+ }+ if let Some(state) = self.signal_state_mut(dependent_signal_id) {+ state.source_signals = Some(sources);}}}@@ -320,31 +359,32 @@ pub(crate) fn abort_signal<'s>(let Some(host_ptr) = crate::util::context_host_ptr_from_global_bridge(scope) else {return;};- let dispatch = unsafe { &mut *host_ptr }+ let signals = unsafe { &mut *host_ptr }.native_bridge_mut().abort- .take_signal_abort(scope, signal, reason);- let Some(dispatch) = dispatch else {+ .prepare_signal_abort(scope, signal, reason);+ let Some(signals) = signals else {return;};- event::invoke_abort_algorithms(scope, signal, reason, dispatch.algorithms);- abort_signal_events::dispatch_abort(scope, signal);- for linked in dispatch.linked_target_listeners {- unsafe { &mut *host_ptr }.remove_registered_event_listener_by_id(- linked.target,- &linked.event_type,- linked.callback_id,- linked.capture,- );- }- for dependent_signal_id in dispatch.dependent_signals {- let signal = unsafe { &mut *host_ptr }+ for (signal_id, signal) in signals {+ let dispatch = unsafe { &mut *host_ptr }.native_bridge_mut().abort- .signal_object(scope, dependent_signal_id);- if let Some(signal) = signal {- abort_signal(scope, signal, reason);+ .take_signal_abort_steps(signal_id);+ let Some(dispatch) = dispatch else {+ continue;+ };+ event::invoke_abort_algorithms(scope, signal, reason, dispatch.algorithms);+ for linked in dispatch.linked_target_listeners {+ unsafe { &mut *host_ptr }.remove_registered_event_listener_by_id(+ linked.target,+ &linked.event_type,+ linked.callback_id,+ linked.capture,+ );}+ // Snapshot listeners after earlier signals and abort algorithms.+ abort_signal_events::dispatch_abort(scope, signal);}}diff --git a/moli-renderer-v8/src/native_bridge/abort/statics.rs b/moli-renderer-v8/src/native_bridge/abort/statics.rsindex b62d7ad9a..3b8512b1b 100644--- a/moli-renderer-v8/src/native_bridge/abort/statics.rs+++ b/moli-renderer-v8/src/native_bridge/abort/statics.rs@@ -110,14 +110,12 @@ pub(crate) fn abort_signal_any_callback<'s>(return;}- for source_signal in signals {- let Some(source_signal_id) = AbortStore::signal_id_from_object(scope, source_signal) else {- continue;- };- host.native_bridge_mut()- .abort- .link_dependent_signal(source_signal_id, composite_signal_id);- }+ host.native_bridge_mut().abort.set_signal_sources(+ composite_signal_id,+ signals+ .into_iter()+ .filter_map(|signal| AbortStore::signal_id_from_object(scope, signal)),+ );rv.set(signal.into());}diff --git a/moli-renderer-v8/src/worker/abort.rs b/moli-renderer-v8/src/worker/abort.rsindex 503286ebc..eb34e1856 100644--- a/moli-renderer-v8/src/worker/abort.rs+++ b/moli-renderer-v8/src/worker/abort.rs@@ -1,4 +1,4 @@-use std::collections::HashMap;+use std::collections::{HashMap, HashSet};use std::{cell::RefCell, rc::Rc};use crate::exception_reporting::invoke_callback;@@ -30,6 +30,8 @@ pub(super) struct WorkerAbortSignalState {aborted: bool,reason: Option<v8::Global<v8::Value>>,abort_algorithms: Vec<v8::Global<v8::Function>>,+ // None for a source; Some (including empty) for a dependent signal's ordered roots.+ source_signals: Option<Vec<u32>>,dependent_signals: Vec<u32>,}@@ -199,12 +201,34 @@ impl WorkerAbortStore {true}- fn link_dependent_signal(&mut self, source_signal_id: u32, dependent_signal_id: u32) {- let Some(state) = self.signal_state_mut(source_signal_id) else {- return;- };- if !state.dependent_signals.contains(&dependent_signal_id) {- state.dependent_signals.push(dependent_signal_id);+ fn set_signal_sources(+ &mut self,+ dependent_signal_id: u32,+ input_signal_ids: impl IntoIterator<Item = u32>,+ ) {+ let mut sources = Vec::new();+ let mut seen = HashSet::new();+ for input_signal_id in input_signal_ids {+ let Some(state) = self.signal_state(input_signal_id) else {+ continue;+ };+ let roots = state+ .source_signals+ .as_deref()+ .unwrap_or(std::slice::from_ref(&input_signal_id));+ for &source_signal_id in roots {+ if seen.insert(source_signal_id) {+ sources.push(source_signal_id);+ }+ }+ }+ for &source_signal_id in &sources {+ if let Some(state) = self.signal_state_mut(source_signal_id) {+ state.dependent_signals.push(dependent_signal_id);+ }+ }+ if let Some(state) = self.signal_state_mut(dependent_signal_id) {+ state.source_signals = Some(sources);}}}@@ -218,7 +242,7 @@ fn abort_worker_signal<'s>(let Some(signal_id) = WorkerAbortStore::signal_id_from_object(scope, signal) else {return;};- let Some((abort_algorithms, dependent_signals)) = ({+ let signals_to_abort = {let mut store = store.borrow_mut();let Some(state) = store.signal_state_mut(signal_id) else {return;@@ -229,25 +253,50 @@ fn abort_worker_signal<'s>(state.aborted = true;state.reason = Some(v8::Global::new(scope, reason));set_private_value(scope, signal, WORKER_ABORT_SIGNAL_REASON_SLOT, reason);- let abort_algorithms = std::mem::take(&mut state.abort_algorithms);- Some((abort_algorithms, state.dependent_signals.clone()))- }) else {- return;+ let dependent_signals = state.dependent_signals.clone();++ // Mark the complete dependency list before callbacks can reenter abort().+ let mut signals_to_abort = vec![(signal_id, signal)];+ for dependent_signal_id in dependent_signals {+ let Some(state) = store.signal_state_mut(dependent_signal_id) else {+ continue;+ };+ if state.aborted {+ continue;+ }+ state.aborted = true;+ state.reason = Some(v8::Global::new(scope, reason));+ if let Some(signal) = &state.signal {+ let signal = v8::Local::new(scope, signal);+ set_private_value(scope, signal, WORKER_ABORT_SIGNAL_REASON_SLOT, reason);+ signals_to_abort.push((dependent_signal_id, signal));+ }+ }+ signals_to_abort};+ for (signal_id, signal) in signals_to_abort {+ run_worker_abort_steps(store, scope, signal, signal_id, reason);+ }+}+fn run_worker_abort_steps<'s>(+ store: &Rc<RefCell<WorkerAbortStore>>,+ scope: &mut v8::PinScope<'s, '_>,+ signal: v8::Local<'s, v8::Object>,+ signal_id: u32,+ reason: v8::Local<'s, v8::Value>,+) {+ let abort_algorithms = {+ let mut store = store.borrow_mut();+ let Some(state) = store.signal_state_mut(signal_id) else {+ return;+ };+ std::mem::take(&mut state.abort_algorithms)+ };reject_worker_fetches_for_signal(scope, signal_id, reason);invoke_worker_abort_algorithms(scope, signal, reason, abort_algorithms);+ // Snapshot listeners after earlier signals and abort algorithms.abort_signal_events::dispatch_abort(scope, signal);- for dependent_signal_id in dependent_signals {- let dependent_signal = {- let store = store.borrow();- store.signal_object(scope, dependent_signal_id)- };- let Some(dependent_signal) = dependent_signal else {- continue;- };- abort_worker_signal(store, scope, dependent_signal, reason);- }}fn invoke_worker_abort_algorithms<'s>(@@ -559,15 +608,12 @@ pub(crate) fn worker_abort_signal_any_callback<'s>(rv.set(signal.into());return;}- for source_signal in signals {- let Some(source_signal_id) = WorkerAbortStore::signal_id_from_object(scope, source_signal)- else {- continue;- };- store- .borrow_mut()- .link_dependent_signal(source_signal_id, composite_signal_id);- }+ store.borrow_mut().set_signal_sources(+ composite_signal_id,+ signals+ .into_iter()+ .filter_map(|signal| WorkerAbortStore::signal_id_from_object(scope, signal)),+ );rv.set(signal.into());}