Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(abort): release native roots after signal termination

ldm074b0a83ec240
diff --git a/moli-renderer-v8/src/native_bridge/abort.rs b/moli-renderer-v8/src/native_bridge/abort.rs
index 859d20402..cb46af71b 100644
--- a/moli-renderer-v8/src/native_bridge/abort.rs
+++ b/moli-renderer-v8/src/native_bridge/abort.rs
@@ -208,7 +208,11 @@ impl AbortStore {
detached: self.detached,
..AbortSignalState::default()
};
- state.signal = Some(crate::util::RealmObjectHandle::new(scope, signal));
+ state.signal = Some(if aborted {
+ crate::util::RealmObjectHandle::weak(scope, signal)
+ } else {
+ crate::util::RealmObjectHandle::new(scope, signal)
+ });
self.signals.insert(signal_id, state);
let passive_state = v8::Object::new(scope);
set_private_value(
@@ -240,7 +244,8 @@ impl AbortStore {
controller: v8::Local<'_, v8::Object>,
signal: v8::Local<'s, v8::Object>,
) {
- let signal_id = self.init_signal(scope, signal, false, None);
+ let signal_id = Self::signal_id_from_object(scope, signal)
+ .expect("AbortController signal was initialized by its native factory");
let controller_id = self.alloc_controller_id();
self.controllers.insert(controller_id, signal_id);
set_private_value(
@@ -380,6 +385,10 @@ impl AbortStore {
return None;
}
state.aborted = true;
+ // The dispatch snapshot roots this signal through all synchronous abort
+ // steps. Its stored reason may reference the signal or a captured stack;
+ // the completed registry must not turn that V8 graph into a Rust root.
+ state.signal = Some(crate::util::RealmObjectHandle::weak(scope, signal));
let dependent_signals = state.dependent_signals.clone();
// Publish every reason before any author callback can reenter abort.
let mut signals = vec![(signal_id, signal)];
@@ -397,6 +406,7 @@ impl AbortStore {
.and_then(|signal| signal.to_local(scope))
{
Self::publish_signal_abort(scope, signal, reason);
+ state.signal = Some(crate::util::RealmObjectHandle::weak(scope, signal));
signals.push((dependent_signal_id, signal));
}
}
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/abort_signal_events.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/abort_signal_events.rs
index 7e9a26c48..77f2d2843 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/abort_signal_events.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/abort_signal_events.rs
@@ -2,6 +2,42 @@ use super::*;
const PROBE: &str = include_str!("abort_signal_events.js");
+#[test]
+fn aborted_signals_release_native_roots_and_preserve_live_reason_identity() {
+ let mut vm = new_parsed_test_vm("https://abort-signal-gc.test/", "<!doctype html><body>");
+ vm.eval(r#"(() => {
+ globalThis.abortWeakGraphs=[];
+ for(const mode of ['controller','static','dependent']) (() => {
+ const reason={};
+ const controller=new AbortController();
+ const source=controller.signal;
+ const signal=mode==='static'?AbortSignal.abort(reason):mode==='dependent'?AbortSignal.any([source]):source;
+ reason.controller=controller;reason.source=source;reason.signal=signal;
+ controller.abort(reason);
+ abortWeakGraphs.push([controller,source,signal,reason].map(value=>new WeakRef(value)));
+ })();
+ const controller=new AbortController(),reason={controller};
+ controller.abort(reason);
+ globalThis.retainedAbortSignal=controller.signal;
+ globalThis.retainedAbortReason=new WeakRef(reason);
+ })()"#).unwrap();
+ vm.renderer_document_isolate
+ .clone()
+ .with_entered_renderer_document_isolate(|isolate| {
+ isolate.clear_kept_objects();
+ isolate.low_memory_notification();
+ Ok(())
+ })
+ .unwrap();
+ assert_eq!(vm.eval(r#"JSON.stringify([
+ abortWeakGraphs.every(graph=>graph.every(ref=>ref.deref()===undefined)),
+ retainedAbortSignal.aborted,
+ retainedAbortSignal.reason===retainedAbortReason.deref(),
+ AbortSignal.any([retainedAbortSignal]).reason===retainedAbortSignal.reason,
+ (()=>{try{retainedAbortSignal.throwIfAborted();}catch(error){return error===retainedAbortSignal.reason;}})()
+ ])"#).unwrap(), "[true,true,true,true,true]");
+}
+
fn run_probe(expression: &str) -> serde_json::Value {
let mut vm = new_parsed_test_vm("https://abort-signal-events.test/", "<!doctype html><body>");
let result = vm
diff --git a/moli-renderer-v8/src/util.rs b/moli-renderer-v8/src/util.rs
index 13a40f1b6..e722be5b4 100644
--- a/moli-renderer-v8/src/util.rs
+++ b/moli-renderer-v8/src/util.rs
@@ -93,6 +93,14 @@ pub(crate) enum RealmObjectHandle {
}
impl RealmObjectHandle {
+ /// Completed native state keeps identity without rooting the object's JS graph.
+ pub(crate) fn weak(
+ scope: &mut v8::PinScope<'_, '_>,
+ object: v8::Local<'_, v8::Object>,
+ ) -> Self {
+ Self::Traced(v8::Weak::new(scope, object))
+ }
+
pub(crate) fn new(scope: &mut v8::PinScope<'_, '_>, object: v8::Local<'_, v8::Object>) -> Self {
if page_context_is_detached_document(scope.get_current_context()) {
Self::traced(scope, object)
diff --git a/moli-renderer-v8/src/worker/abort.rs b/moli-renderer-v8/src/worker/abort.rs
index eb34e1856..6ad22ecae 100644
--- a/moli-renderer-v8/src/worker/abort.rs
+++ b/moli-renderer-v8/src/worker/abort.rs
@@ -16,6 +16,9 @@ const WORKER_ABORT_CONTROLLER_ID_SLOT: &str = "__lmWorkerAbortControllerId";
const WORKER_ABORT_CONTROLLER_SIGNAL_SLOT: &str = "__lmWorkerAbortControllerSignal";
const WORKER_ABORT_SIGNAL_REASON_SLOT: &str = "__lmWorkerAbortSignalReason";
+#[cfg(test)]
+mod tests;
+
#[derive(Default)]
pub(super) struct WorkerAbortStore {
next_signal_id: u32,
@@ -26,9 +29,8 @@ pub(super) struct WorkerAbortStore {
#[derive(Default)]
pub(super) struct WorkerAbortSignalState {
- signal: Option<v8::Global<v8::Object>>,
+ signal: Option<crate::util::RealmObjectHandle>,
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>>,
@@ -84,10 +86,11 @@ impl WorkerAbortStore {
aborted,
..WorkerAbortSignalState::default()
};
- state.signal = Some(v8::Global::new(scope, signal));
- if let Some(reason) = reason {
- state.reason = Some(v8::Global::new(scope, reason));
- }
+ state.signal = Some(if aborted {
+ crate::util::RealmObjectHandle::weak(scope, signal)
+ } else {
+ crate::util::RealmObjectHandle::new(scope, signal)
+ });
self.signals.insert(signal_id, state);
set_private_value(
scope,
@@ -108,7 +111,8 @@ impl WorkerAbortStore {
controller: v8::Local<'_, v8::Object>,
signal: v8::Local<'s, v8::Object>,
) {
- let signal_id = self.init_signal(scope, signal, false, None);
+ let signal_id = Self::signal_id_from_object(scope, signal)
+ .expect("AbortController signal was initialized by its native factory");
let controller_id = self.alloc_controller_id();
self.controllers.insert(controller_id, signal_id);
set_private_value(
@@ -140,7 +144,7 @@ impl WorkerAbortStore {
) -> Option<v8::Local<'s, v8::Object>> {
self.signal_state(id)
.and_then(|state| state.signal.as_ref())
- .map(|signal| v8::Local::new(scope, signal))
+ .and_then(|signal| signal.to_local(scope))
}
fn signal_reason<'s>(
@@ -148,10 +152,8 @@ impl WorkerAbortStore {
scope: &mut v8::PinScope<'s, '_>,
signal: v8::Local<'s, v8::Object>,
) -> Option<v8::Local<'s, v8::Value>> {
- Self::signal_id_from_object(scope, signal)
- .and_then(|id| self.signal_state(id))
- .and_then(|state| state.reason.as_ref())
- .map(|reason| v8::Local::new(scope, reason))
+ Self::signal_id_from_object(scope, signal).and_then(|id| self.signal_state(id))?;
+ get_private_value(scope, signal, WORKER_ABORT_SIGNAL_REASON_SLOT)
}
pub(super) fn signal_aborted<'s>(
@@ -251,8 +253,10 @@ fn abort_worker_signal<'s>(
return;
}
state.aborted = true;
- state.reason = Some(v8::Global::new(scope, reason));
set_private_value(scope, signal, WORKER_ABORT_SIGNAL_REASON_SLOT, reason);
+ // The local dispatch snapshot keeps the source and dependents alive.
+ // A completed registry retains neither their objects nor their reasons.
+ state.signal = Some(crate::util::RealmObjectHandle::weak(scope, signal));
let dependent_signals = state.dependent_signals.clone();
// Mark the complete dependency list before callbacks can reenter abort().
@@ -265,10 +269,13 @@ fn abort_worker_signal<'s>(
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);
+ if let Some(signal) = state
+ .signal
+ .as_ref()
+ .and_then(|signal| signal.to_local(scope))
+ {
set_private_value(scope, signal, WORKER_ABORT_SIGNAL_REASON_SLOT, reason);
+ state.signal = Some(crate::util::RealmObjectHandle::weak(scope, signal));
signals_to_abort.push((dependent_signal_id, signal));
}
}
@@ -595,13 +602,14 @@ pub(crate) fn worker_abort_signal_any_callback<'s>(
else {
continue;
};
- let Some(reason) = store
- .borrow()
- .signal_state(source_signal_id)
- .filter(|signal_state| signal_state.aborted)
- .and_then(|signal_state| signal_state.reason.as_ref())
- .map(|reason| v8::Local::new(scope, reason))
- else {
+ let reason = {
+ let store = store.borrow();
+ store
+ .signal_state(source_signal_id)
+ .filter(|signal_state| signal_state.aborted)
+ .and_then(|_| store.signal_reason(scope, *source_signal))
+ };
+ let Some(reason) = reason else {
continue;
};
abort_worker_signal(&store, scope, signal, reason);
diff --git a/moli-renderer-v8/src/worker/abort/tests.rs b/moli-renderer-v8/src/worker/abort/tests.rs
new file mode 100644
index 000000000..dc6d2242a
--- /dev/null
+++ b/moli-renderer-v8/src/worker/abort/tests.rs
@@ -0,0 +1,67 @@
+use super::*;
+
+#[test]
+fn completed_worker_abort_state_preserves_live_reasons_without_rooting_cycles() {
+ crate::ensure_v8_for_test();
+ let mut isolate = v8::Isolate::new(v8::CreateParams::default());
+ let mut store = WorkerAbortStore::default();
+ let context;
+ let mut ids = [0; 2];
+ {
+ let scope = std::pin::pin!(v8::HandleScope::new(&mut isolate));
+ let scope = &mut scope.init();
+ let local = v8::Context::new(scope, Default::default());
+ context = v8::Global::new(scope, local);
+ let scope = &mut v8::ContextScope::new(scope, local);
+ let global = local.global(scope);
+ for (index, retained) in [false, true].into_iter().enumerate() {
+ let signal = v8::Object::new(scope);
+ let reason = v8::Object::new(scope);
+ let key = v8str(scope, "signal");
+ assert_eq!(reason.set(scope, key.into(), signal.into()), Some(true));
+ let id = store.init_signal(scope, signal, true, Some(reason.into()));
+ let key = v8str(scope, "signal");
+ assert_eq!(global.set(scope, key.into(), signal.into()), Some(true));
+ let source = v8str(scope, "new WeakRef(signal)");
+ let script = v8::Script::compile(scope, source, None).unwrap();
+ let weak = crate::script_execution::execute_compiled_script(scope, script).unwrap();
+ let key = v8str(
+ scope,
+ if retained {
+ "retainedWeak"
+ } else {
+ "abandonedWeak"
+ },
+ );
+ assert_eq!(global.set(scope, key.into(), weak), Some(true));
+ ids[index] = id;
+ }
+ }
+ isolate.clear_kept_objects();
+ isolate.low_memory_notification();
+ let scope = std::pin::pin!(v8::HandleScope::new(&mut isolate));
+ let scope = &mut scope.init();
+ let local = v8::Local::new(scope, &context);
+ let scope = &mut v8::ContextScope::new(scope, local);
+ assert!(store.signal_object(scope, ids[0]).is_none());
+ let signal = store.signal_object(scope, ids[1]).unwrap();
+ let reason = store.signal_reason(scope, signal).unwrap();
+ let reason = v8::Local::<v8::Object>::try_from(reason).unwrap();
+ let key = v8str(scope, "signal");
+ assert!(
+ reason
+ .get(scope, key.into())
+ .unwrap()
+ .strict_equals(signal.into())
+ );
+ let source = v8str(
+ scope,
+ "abandonedWeak.deref() === undefined && retainedWeak.deref() === signal",
+ );
+ let script = v8::Script::compile(scope, source, None).unwrap();
+ assert!(
+ crate::script_execution::execute_compiled_script(scope, script)
+ .unwrap()
+ .is_true()
+ );
+}