Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(history): reuse navigation traversals only for the same key

ldm0b7bcb21292df
diff --git a/moli-renderer-v8/src/native_bridge/history_queue.rs b/moli-renderer-v8/src/native_bridge/history_queue.rs
index 131a31a94..9f62f4513 100644
--- a/moli-renderer-v8/src/native_bridge/history_queue.rs
+++ b/moli-renderer-v8/src/native_bridge/history_queue.rs
@@ -141,14 +141,18 @@ impl HistoryQueueState {
) -> Option<RendererPageHistoryTraversalTaskId> {
// History API requests are ordered steps, including a same-document
// traversal followed by a cross-document traversal. Only Navigation
- // API requests with result promises can share a pending task.
+ // API requests for the same destination key can share a pending task;
+ // a different destination must retain its own position in the queue.
if result.is_some()
+ && target_key.is_some()
&& let Some(pending) =
self.pending_history_traversal_tasks
.iter_mut()
.find_map(|queued| match &mut queued.action {
PendingHistoryTraversalAction::SameDocument(pending)
- if pending.target == target && !pending.results.is_empty() =>
+ if pending.target == target
+ && pending.target_key == target_key
+ && !pending.results.is_empty() =>
{
Some(pending)
}
@@ -156,10 +160,6 @@ impl HistoryQueueState {
| PendingHistoryTraversalAction::ChildCrossDocument(_) => None,
})
{
- pending.target_index = target_index;
- pending.joint_step = joint_step;
- pending.target_key = target_key;
- pending.info = info;
if let Some(result) = result {
pending.results.push(result);
}
@@ -536,26 +536,23 @@ impl JsContextHost {
Option<RendererPageHistoryTraversalProducer>,
)> {
let execution_context = self.current_runtime_window_execution_context_identity(scope)?;
- if let Some(existing_index) = self
- .history_queue
- .pending_history_traversal_tasks
- .iter()
- .position(|queued| {
- matches!(
- &queued.action,
+ if target_key.is_some()
+ && let Some(result) = self
+ .history_queue
+ .pending_history_traversal_tasks
+ .iter()
+ .find_map(|queued| match &queued.action {
PendingHistoryTraversalAction::SameDocument(pending)
- if pending.target == target
- && pending.target_index == target_index
- )
- })
- && let PendingHistoryTraversalAction::SameDocument(pending) =
- &mut self.history_queue.pending_history_traversal_tasks[existing_index].action
- && !pending.results.is_empty()
+ if pending.target == target && pending.target_key == target_key =>
+ {
+ pending.results.first()
+ }
+ PendingHistoryTraversalAction::SameDocument(_)
+ | PendingHistoryTraversalAction::ChildCrossDocument(_) => None,
+ })
{
- pending.joint_step = joint_step;
- pending.target_key = target_key;
- pending.info = info.map(|info| v8::Global::new(scope, info));
- let result = &pending.results[0];
+ // Repeated requests share the original tracker, including its
+ // destination and info, even if a History task also targets it.
let committed_resolver = v8::Local::new(scope, &result.committed_resolver);
let finished_resolver = v8::Local::new(scope, &result.finished_resolver);
return Some((
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/navigation.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/navigation.rs
index 260e539c0..1b08b017e 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/navigation.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/navigation.rs
@@ -4690,7 +4690,68 @@ async fn traversal_navigate_destination_index_tracks_entry_identity() {
);
}
#[tokio::test]
-async fn repeated_traverse_to_reuses_pending_navigation_promises() {
+async fn traverse_to_preserves_intervening_history_back() {
+ let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
+ let mut vm =
+ new_storage_page_task_executor_test_vm_with_loader("https://example.com/base", &loader);
+
+ let setup = vm
+ .eval(
+ r##"
+ (() => {
+ history.replaceState(null, "", "#0");
+ const keys = [navigation.currentEntry.key];
+ for (let i = 1; i <= 3; i++) {
+ history.pushState(null, "", `#${i}`);
+ keys.push(navigation.currentEntry.key);
+ }
+ const probe = globalThis.__lmMixedTraversals = {
+ popstate: [], committed: [], finished: []
+ };
+ onpopstate = () => probe.popstate.push(location.hash);
+ const observe = (label, result) => {
+ result.committed.then(
+ entry => probe.committed.push(`${label}:${new URL(entry.url).hash}:${location.hash}`),
+ error => probe.committed.push(`${label}:rejected:${error.name}`)
+ );
+ result.finished.then(
+ entry => probe.finished.push(`${label}:${new URL(entry.url).hash}`),
+ error => probe.finished.push(`${label}:rejected:${error.name}`)
+ );
+ };
+ const first = navigation.traverseTo(keys[2]);
+ observe("first", first);
+ history.back();
+ const last = navigation.traverseTo(keys[0]);
+ observe("last", last);
+ return [location.hash, first.committed !== last.committed,
+ first.finished !== last.finished].join("|");
+ })()
+ "##,
+ )
+ .expect("mixed traversal requests should queue in one script turn");
+ assert_eq!(setup, "#3|true|true");
+
+ let mut executed = Vec::new();
+ for _ in 0..4 {
+ executed.push(
+ vm.run_one_history_traversal_executor_turn(&loader)
+ .await
+ .expect("mixed history traversal should execute"),
+ );
+ }
+ let settled = vm
+ .eval("JSON.stringify({hash: location.hash, ...__lmMixedTraversals})")
+ .expect("mixed traversal results should be inspectable");
+ assert_eq!(
+ settled,
+ r##"{"hash":"#0","popstate":["#2","#1","#0"],"committed":["first:#2:#2","last:#0:#0"],"finished":["first:#2","last:#0"]}"##
+ );
+ assert_eq!(executed, [true, true, true, false]);
+}
+
+#[tokio::test]
+async fn repeated_traverse_to_reuses_promises_after_history_request() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let mut vm =
new_storage_page_task_executor_test_vm_with_loader("https://example.com/base", &loader);
@@ -4699,11 +4760,64 @@ async fn repeated_traverse_to_reuses_pending_navigation_promises() {
.eval(
r##"
(() => {
+ history.pushState(null, "", "#1");
const key = navigation.currentEntry.key;
- navigation.navigate("#one");
+ history.pushState(null, "", "#2");
+ history.back();
const first = navigation.traverseTo(key);
const second = navigation.traverseTo(key);
+ globalThis.__lmRepeatedAfterHistory = [];
+ for (const [label, result] of [["first", first], ["second", second]]) {
+ result.finished.then(
+ entry => __lmRepeatedAfterHistory.push(`${label}:${new URL(entry.url).hash}`),
+ error => __lmRepeatedAfterHistory.push(`${label}:rejected:${error.name}`)
+ );
+ }
+ return [first !== second, first.committed === second.committed,
+ first.finished === second.finished].join("|");
+ })()
+ "##,
+ )
+ .expect("a History request should not hide a matching Navigation request");
+ assert_eq!(setup, "true|true|true");
+
+ for _ in 0..2 {
+ assert!(
+ vm.run_one_history_traversal_executor_turn(&loader)
+ .await
+ .expect("History and Navigation requests should execute separately")
+ );
+ }
+ assert_eq!(
+ vm.eval("[location.hash, ...__lmRepeatedAfterHistory].join('|')")
+ .expect("both callers should finish at their shared destination"),
+ "#1|first:#1|second:#1"
+ );
+ assert!(
+ !vm.run_one_history_traversal_executor_turn(&loader)
+ .await
+ .expect("the repeated Navigation request should not add another task")
+ );
+}
+
+#[tokio::test]
+async fn repeated_traverse_to_reuses_pending_navigation_promises() {
+ let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
+ let mut vm =
+ new_storage_page_task_executor_test_vm_with_loader("https://example.com/base", &loader);
+
+ let setup = vm
+ .eval(
+ r##"
+ (() => {
+ const key = navigation.currentEntry.key;
+ navigation.navigate("#one");
+ const first = navigation.traverseTo(key, { info: "first" });
+ const second = navigation.traverseTo(key, { info: "second" });
globalThis.__lmRepeatedTraverseTo = { first, second, log: [] };
+ navigation.addEventListener("navigate", event => {
+ __lmRepeatedTraverseTo.log.push(`info:${event.info}`);
+ }, { once: true });
first.finished.then(
entry => globalThis.__lmRepeatedTraverseTo.log.push(`finished:${entry.url}:${location.hash}`),
error => globalThis.__lmRepeatedTraverseTo.log.push(`rejected:${error.name}`)
@@ -4727,5 +4841,10 @@ async fn repeated_traverse_to_reuses_pending_navigation_promises() {
let settled = vm
.eval("globalThis.__lmRepeatedTraverseTo.log.join('|')")
.expect("repeated traverseTo settlement should evaluate");
- assert_eq!(settled, "finished:https://example.com/base:");
+ assert_eq!(settled, "info:first|finished:https://example.com/base:");
+ assert!(
+ !vm.run_one_history_traversal_executor_turn(&loader)
+ .await
+ .expect("repeated traverseTo should share one traversal task")
+ );
}