Skip to content

armgit / moli

Public Imported from GitHub
0

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

test(renderer): split page VM test scenarios

ldm0983e2e10d351
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/extracted.rs b/moli-renderer-v8/src/runtime/page_vm/tests/extracted.rs
new file mode 100644
index 000000000..1c913ebbb
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/extracted.rs
@@ -0,0 +1,15 @@
+use super::super::*;
+use super::*;
+use crate::frame_owner_model::DocumentId;
+use crate::types::SubresourceResponseWaitCriteria;
+
+mod child_document_scripts;
+mod child_module_graphs;
+mod document_script_tasks;
+mod main_document_scripts;
+mod main_module_graphs;
+mod modulepreload;
+mod navigation_lifecycle;
+mod page_task_dispatch;
+mod parser_module_tasks;
+mod resource_completion_tasks;
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/extracted/child_document_scripts.rs b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/child_document_scripts.rs
new file mode 100644
index 000000000..3ca7cf29d
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/child_document_scripts.rs
@@ -0,0 +1,2409 @@
+use super::*;
+
+#[tokio::test]
+async fn page_vm_child_classic_resource_completion_queues_child_frame_work() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-classic.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childClassicWaitEvents.push("external:" + (globalThis === self));
+parent.__childClassicWaitEvents.push("current:" + document.currentScript.id);
+globalThis.__childClassicWaitValue = 91;
+"#
+ .to_owned(),
+ Duration::from_millis(200),
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm =
+ test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ first,
+ first_events,
+ bootstrap_source,
+ blocked_host_load_before_completion,
+ blocked_host_load_pump_before_completion,
+ events_after_blocked_host_load_before_completion,
+ followup_sources,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let script_url = format!("{base_url}/child-classic.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childClassicWaitEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childClassicWaitEvents.push("load");
+ frame.srcdoc = `
+ <script id="external-classic" src="{script_url}"><\/script>
+ <script id="after-external-classic">
+ parent.__childClassicWaitEvents.push(
+ "inline:" + globalThis.__childClassicWaitValue
+ );
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "child classic srcdoc navigation commit",
+ )
+ .await;
+ let bootstrap_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ run_expected_child_realm_materialization_for_wait(
+ &mut page_vm,
+ "child classic exact realm",
+ )
+ .await;
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childClassicWaitEvents.join('|')")?,
+ "",
+ "pending child external classic script should block inline script and load"
+ );
+ let blocked_host_load_before_completion = page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ChildHostLoad,
+ &loader,
+ )
+ .await?;
+ let blocked_host_load_pump_before_completion =
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_blocked_host_load_before_completion = page_vm
+ .vm_mut()
+ .eval("__childClassicWaitEvents.join('|')")?;
+
+ let page_resource_queue = page_vm.page_resource_completion_queue();
+ if !page_resource_queue.has_ready_completion() {
+ tokio::time::timeout(
+ Duration::from_secs(2),
+ page_vm.page_task_queue.wait_for_page_runtime_wake(),
+ )
+ .await
+ .expect("child classic completion should arrive before timeout");
+ }
+ let (_, queued_completion) = page_resource_queue
+ .pop_front()
+ .expect("child classic completion should remain queued");
+ let completion_owner = queued_completion.owner();
+ let completion = match queued_completion.into_terminal() {
+ RendererPageResourceTerminal::ChildClassicScript { completion } => completion,
+ other => panic!("expected child classic completion, got {other:?}"),
+ };
+ let root_document = page_vm.document_lifecycle.identity().document;
+ assert!(
+ completion.network_result.is_some(),
+ "loader-backed child classic completion must retain its Network fact"
+ );
+ let expected_network_frame_id = completion.network_attribution.frame_id.clone();
+ let expected_network_document_url =
+ completion.network_attribution.document_url.clone();
+ let expected_network_request_url =
+ completion.network_attribution.request_url.clone();
+ let _ = page_vm.vm_mut().take_network_output();
+ let activity_epoch_before_completion =
+ page_vm.vm().subresource_activity_epoch();
+ let first = page_vm
+ .apply_selected_page_resource_completion_turn(
+ RendererPageResourceCompletion::child_classic_script(
+ root_document,
+ completion,
+ ),
+ )?;
+ assert_eq!(first.action.owner, completion_owner);
+ assert_eq!(
+ first.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ first.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ assert!(
+ page_vm.vm().subresource_activity_epoch()
+ > activity_epoch_before_completion,
+ "a current child classic Network terminal must advance current Document activity"
+ );
+ let (network_records, websocket_events, websocket_lifecycle_events) =
+ split_network_output_items(page_vm.vm_mut().take_network_output());
+ assert!(websocket_events.is_empty());
+ assert!(websocket_lifecycle_events.is_empty());
+ assert_eq!(network_records.len(), 1);
+ let network_record = &network_records[0];
+ assert_eq!(
+ network_record.frame_id(),
+ expected_network_frame_id.as_deref(),
+ "consumer must use producer-captured child frame attribution"
+ );
+ assert_eq!(
+ network_record.document_url(),
+ &expected_network_document_url
+ );
+ assert_eq!(network_record.url(), &expected_network_request_url);
+ assert_eq!(network_record.resource_type(), SubresourceResourceType::Script);
+ assert_eq!(
+ network_record.request_initiator_type(),
+ SubresourceRequestInitiatorType::Script
+ );
+ assert!(matches!(
+ network_record.outcome(),
+ SubresourceNetworkOutcome::Success { .. }
+ ));
+ let first_events = page_vm
+ .vm_mut()
+ .eval("__childClassicWaitEvents.join('|')")?;
+ let mut followup_sources = Vec::new();
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "child classic external execution",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childClassicWaitEvents.join('|')")?,
+ "external:true|current:external-classic",
+ "first DocumentScriptReady should execute the external classic script without parser continuation or iframe load"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "child classic parser continuation",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childClassicWaitEvents.join('|')")?,
+ "external:true|current:external-classic|inline:91",
+ "second DocumentScriptReady should run parser continuation without iframe load"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "child classic parser EOF interactive transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "child classic DOMContentLoaded transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "child classic complete transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "child classic iframe load",
+ )
+ .await,
+ );
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childClassicWaitEvents.join('|')")?;
+ assert_eq!(
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ None,
+ "child classic follow-up sequence should not leave extra child frame task work"
+ );
+
+ Ok::<_, anyhow::Error>((
+ first,
+ first_events,
+ bootstrap_source,
+ blocked_host_load_before_completion,
+ blocked_host_load_pump_before_completion,
+ events_after_blocked_host_load_before_completion,
+ followup_sources,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child classic deferred completion test should run");
+
+ assert!(matches!(
+ first.action.source(),
+ RendererOwnerResourceActivitySource::ChildClassicScript
+ ));
+ assert_eq!(
+ first.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ first.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ assert_eq!(
+ first_events, "",
+ "resource completion turn should not inline-run child classic script"
+ );
+ assert_eq!(
+ bootstrap_source,
+ Some(ChildFrameSemanticTurnKind::ClassicScriptSourceLoad),
+ "child classic bootstrap should start the external source load with one explicit source turn"
+ );
+ assert!(
+ !blocked_host_load_before_completion,
+ "HostLoad source should report no progress while parser-blocking classic source is pending"
+ );
+ assert_eq!(
+ blocked_host_load_pump_before_completion, None,
+ "blocked lifecycle must not produce a HostLoad task in the stable child-frame family"
+ );
+ assert_eq!(
+ events_after_blocked_host_load_before_completion, "",
+ "no HostLoad delivery may exist before classic source completion"
+ );
+ assert_eq!(
+ followup_sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::HostLoad
+ ],
+ "child classic completion should progress through script, parser continuation, interactive, DOMContentLoaded, complete, and HostLoad turns"
+ );
+ assert_eq!(
+ final_events,
+ "external:true|current:external-classic|inline:91|load",
+ "explicit later wait turns should run queued child classic work"
+ );
+
+ server
+ .await
+ .expect("child classic wait-path server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_parser_blocking_classic_waits_for_preceding_stylesheet() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_concurrent_path_response_http_server(vec![(
+ "/parser-blocking.css",
+ "HTTP/1.1 200 OK",
+ ":root { --child-parser-style-gate: stylesheet-ready; }".to_owned(),
+ Duration::from_millis(180),
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ navigation_source,
+ completion,
+ events_after_completion,
+ followup_sources,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childParserStylesheetEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childParserStylesheetEvents.push("load");
+ frame.srcdoc = `
+ <link rel="stylesheet" href="{base_url}/parser-blocking.css">
+ <script>
+ parent.__childParserStylesheetEvents.push(
+ "script:" + getComputedStyle(document.documentElement)
+ .getPropertyValue("--child-parser-style-gate").trim() + ":" + document.readyState
+ );
+ <\/script>
+ <body></body>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let navigation_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "stylesheet-gated child srcdoc navigation commit",
+ )
+ .await;
+ let materialization = page_vm
+ .run_child_realm_materialization_body_for_test()?
+ .expect("child parser stylesheet fixture should queue one typed realm turn");
+ assert_eq!(
+ materialization.action.target_effect,
+ crate::page_task_queue::PageChildRealmMaterializationTargetEffect::MaterializedCurrentOwnerWithoutDocumentStartScript
+ );
+
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childParserStylesheetEvents.join('|')")?,
+ "",
+ "parser-blocking classic must remain pending while its preparation-time stylesheet snapshot is unresolved"
+ );
+ assert!(
+ !page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ChildHostLoad,
+ &loader,
+ )
+ .await?,
+ "HostLoad must not bypass a stylesheet-blocked parser"
+ );
+
+ let page_resource_queue = page_vm.page_resource_completion_queue();
+ if !page_resource_queue.has_ready_completion() {
+ tokio::time::timeout(
+ Duration::from_secs(2),
+ page_vm.page_task_queue.wait_for_page_runtime_wake(),
+ )
+ .await
+ .expect("child stylesheet completion should arrive");
+ }
+ let (_, queued_completion) = page_resource_queue
+ .pop_front()
+ .expect("child stylesheet completion should remain queued");
+ let completion_owner = queued_completion.owner();
+ let completion = match queued_completion.into_terminal() {
+ RendererPageResourceTerminal::ChildBlockingStylesheet { completion } => {
+ completion
+ }
+ other => panic!("expected child stylesheet completion, got {other:?}"),
+ };
+ let root_document = page_vm.document_lifecycle.identity().document;
+ let completion = page_vm
+ .apply_selected_page_resource_completion_turn(
+ RendererPageResourceCompletion::child_blocking_stylesheet(
+ root_document,
+ completion,
+ ),
+ )?;
+ assert_eq!(completion.action.owner, completion_owner);
+ let events_after_completion = page_vm
+ .vm_mut()
+ .eval("__childParserStylesheetEvents.join('|')")?;
+
+ let mut followup_sources = Vec::new();
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "stylesheet-released child parser-blocking classic",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childParserStylesheetEvents.join('|')")?,
+ "script:stylesheet-ready:complete",
+ "stylesheet source must be installed before the parser-blocking script executes"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "stylesheet-gated child interactive transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "stylesheet-gated child DOMContentLoaded transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "stylesheet-gated child complete transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "stylesheet-gated child iframe load",
+ )
+ .await,
+ );
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childParserStylesheetEvents.join('|')")?;
+ assert_eq!(page_vm.run_next_child_frame_task_source_for_semantic_test().await, None);
+
+ Ok::<_, anyhow::Error>((
+ navigation_source,
+ completion,
+ events_after_completion,
+ followup_sources,
+ final_events,
+ ))
+ })
+ .await
+ .expect("child parser stylesheet test should run");
+
+ assert_eq!(navigation_source, ChildFrameSemanticTurnKind::NavigationCommit);
+ assert_eq!(
+ completion.action.source(),
+ RendererOwnerResourceActivitySource::ChildBlockingStylesheet
+ );
+ assert_eq!(
+ completion.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ completion.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+ assert_eq!(
+ events_after_completion, "",
+ "stylesheet resource completion must not inline-run child script"
+ );
+ assert_eq!(
+ followup_sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::HostLoad,
+ ]
+ );
+ assert_eq!(final_events, "script:stylesheet-ready:complete|load");
+ server.await.expect("child parser stylesheet server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_parser_defer_preserves_cross_kind_document_order() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_concurrent_path_response_http_server(vec![
+ (
+ "/first-module.js",
+ "HTTP/1.1 200 OK",
+ r#"parent.__childMixedDeferEvents.push("first-module");"#.to_owned(),
+ Duration::from_millis(220),
+ ),
+ (
+ "/second-classic.js",
+ "HTTP/1.1 200 OK",
+ r#"parent.__childMixedDeferEvents.push("second-classic");"#.to_owned(),
+ Duration::ZERO,
+ ),
+ (
+ "/third-classic.js",
+ "HTTP/1.1 200 OK",
+ r#"parent.__childMixedDeferEvents.push("third-classic");"#.to_owned(),
+ Duration::from_millis(420),
+ ),
+ (
+ "/fourth-module.js",
+ "HTTP/1.1 200 OK",
+ r#"parent.__childMixedDeferEvents.push("fourth-module");"#.to_owned(),
+ Duration::from_millis(20),
+ ),
+ ])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ completion_sources,
+ execution_sources,
+ lifecycle_sources,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childMixedDeferEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childMixedDeferEvents.push("load");
+ frame.srcdoc = `
+ <script>parent.__childMixedDeferEvents.push("before");<\/script>
+ <script id="first-module" type="module" src="{base_url}/first-module.js"><\/script>
+ <script id="second-classic" defer src="{base_url}/second-classic.js"><\/script>
+ <script id="third-classic" defer src="{base_url}/third-classic.js"><\/script>
+ <script id="fourth-module" type="module" src="{base_url}/fourth-module.js"><\/script>
+ <script>
+ for (const id of ["first-module", "second-classic", "third-classic", "fourth-module"]) {{
+ document.getElementById(id).addEventListener("load", () => {{
+ parent.__childMixedDeferEvents.push(id + "-load");
+ }});
+ }}
+ parent.__childMixedDeferEvents.push("after");
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let mut bootstrap_sources = Vec::new();
+ for _ in 0..12 {
+ let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
+ break;
+ };
+ bootstrap_sources.push(source);
+ if source == ChildFrameSemanticTurnKind::DocumentLifecycle
+ && bootstrap_sources
+ .iter()
+ .filter(|source| {
+ **source == ChildFrameSemanticTurnKind::ParserModuleRootStart
+ })
+ .count()
+ == 2
+ {
+ break;
+ }
+ }
+ assert_eq!(
+ page_vm.vm_mut().eval("__childMixedDeferEvents.join('|')")?,
+ "before|after",
+ "parser EOF must not execute any mixed parser-deferred script"
+ );
+ assert!(
+ bootstrap_sources.contains(&ChildFrameSemanticTurnKind::DocumentLifecycle),
+ "mixed parser-deferred document should reach interactive"
+ );
+ assert_eq!(
+ bootstrap_sources
+ .iter()
+ .filter(|source| **source == ChildFrameSemanticTurnKind::ParserModuleRootStart)
+ .count(),
+ 2,
+ "both module roots should start before terminal ordering is tested"
+ );
+
+ let mut completion_sources = Vec::new();
+ let mut terminal_turn_count = 0;
+ for completion_index in 0..3 {
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .unwrap_or_else(|_| {
+ panic!(
+ "mixed parser-deferred completion {completion_index} should arrive"
+ )
+ });
+ }
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ completion_sources.push(completion.action.source());
+ if completion.action.source()
+ == RendererOwnerResourceActivitySource::ModuleGraphFetch
+ {
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "mixed child module terminal",
+ )
+ .await;
+ terminal_turn_count += 1;
+ }
+ assert_eq!(
+ page_vm.vm_mut().eval("__childMixedDeferEvents.join('|')")?,
+ "before|after",
+ "out-of-order completions and retained terminals must not execute a later parser-deferred script"
+ );
+ }
+
+ assert_eq!(
+ completion_sources,
+ vec![
+ RendererOwnerResourceActivitySource::ChildClassicScript,
+ RendererOwnerResourceActivitySource::ModuleGraphFetch,
+ RendererOwnerResourceActivitySource::ModuleGraphFetch,
+ ],
+ "network timing should make later classic and module work terminal before the first module"
+ );
+ assert_eq!(terminal_turn_count, 2);
+
+ let mut execution_sources = Vec::new();
+ execution_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "first mixed parser-deferred module",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm.vm_mut().eval("__childMixedDeferEvents.join('|')")?,
+ "before|after|first-module|first-module-load",
+ "earlier module must execute before the already-ready later classic"
+ );
+ execution_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "second mixed parser-deferred classic",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm.vm_mut().eval("__childMixedDeferEvents.join('|')")?,
+ "before|after|first-module|first-module-load|second-classic|second-classic-load",
+ "second classic should execute only after the first module finishes"
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("third classic completion should arrive");
+ }
+ let third_completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ completion_sources.push(third_completion.action.source());
+
+ execution_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "third mixed parser-deferred classic",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm.vm_mut().eval("__childMixedDeferEvents.join('|')")?,
+ "before|after|first-module|first-module-load|second-classic|second-classic-load|third-classic|third-classic-load",
+ "third classic must execute before the already-terminal fourth module"
+ );
+ execution_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "fourth mixed parser-deferred module",
+ )
+ .await,
+ );
+
+ let lifecycle_sources = vec![
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "mixed parser-deferred DOMContentLoaded",
+ )
+ .await,
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "mixed parser-deferred complete transition",
+ )
+ .await,
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "mixed parser-deferred iframe load",
+ )
+ .await,
+ ];
+ let final_events = page_vm.vm_mut().eval("__childMixedDeferEvents.join('|')")?;
+ assert_eq!(page_vm.run_next_child_frame_task_source_for_semantic_test().await, None);
+
+ Ok::<_, anyhow::Error>((
+ completion_sources,
+ execution_sources,
+ lifecycle_sources,
+ final_events,
+ ))
+ })
+ .await
+ .expect("mixed child parser-deferred ordering test should run");
+
+ assert_eq!(
+ completion_sources.last(),
+ Some(&RendererOwnerResourceActivitySource::ChildClassicScript)
+ );
+ assert_eq!(
+ execution_sources,
+ vec![ChildFrameSemanticTurnKind::DocumentScriptReady; 4]
+ );
+ assert_eq!(
+ lifecycle_sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::HostLoad,
+ ],
+ "DCL, complete, and iframe load must remain later lifecycle turns"
+ );
+ assert_eq!(
+ final_events,
+ "before|after|first-module|first-module-load|second-classic|second-classic-load|third-classic|third-classic-load|fourth-module|fourth-module-load|load",
+ "mixed parser-deferred scripts must execute in one cross-kind document order"
+ );
+
+ server
+ .await
+ .expect("mixed child parser-deferred ordering server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_document_completion_queues_document_script_ready_work() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-document.html",
+ "HTTP/1.1 200 OK",
+ r#"
+<!doctype html>
+<script>
+parent.__childDocumentLoadWaitEvents.push("child-script:" + (globalThis === self));
+globalThis.__childDocumentLoadWaitValue = 42;
+</script>
+"#
+ .to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ first,
+ first_events,
+ realm_pending_after_first,
+ host_load_pending_after_completion,
+ first_followup_source,
+ events_after_first_followup,
+ lifecycle_ready_after_first_followup,
+ interactive_source,
+ host_load_source,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let child_url = format!("{base_url}/child-document.html");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childDocumentLoadWaitEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childDocumentLoadWaitEvents.push("frameload");
+ frame.src = "{child_url}";
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+ let startup_sources =
+ drive_child_frame_task_sources_until_resource_completion_ready(
+ &mut page_vm,
+ 8,
+ )
+ .await;
+ assert!(
+ startup_sources.contains(&ChildFrameSemanticTurnKind::NavigationCommit),
+ "external child document startup should begin from an explicit NavigationCommit source: {startup_sources:?}"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childDocumentLoadWaitEvents.join('|')")?,
+ "",
+ "child document script and frame load should wait for document completion"
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child document completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child document completion sender should remain open"
+ );
+ }
+
+ let first = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let first_events = page_vm
+ .vm_mut()
+ .eval("__childDocumentLoadWaitEvents.join('|')")?;
+ let realm_pending_after_first = page_vm
+ .vm()
+ .has_pending_child_frame_realm_materialization();
+ run_expected_pending_child_realm_materialization_turn(
+ &mut page_vm,
+ "child document parser realm prerequisite",
+ )?;
+ let host_load_pending_after_completion = page_vm
+ .has_ready_child_frame_semantic_turn_for_test(ChildFrameSemanticTurnKind::HostLoad);
+
+ let first_followup_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "child document parser script execution",
+ )
+ .await;
+ let events_after_first_followup = page_vm
+ .vm_mut()
+ .eval("__childDocumentLoadWaitEvents.join('|')")?;
+ let lifecycle_ready_after_first_followup = page_vm
+ .has_ready_child_frame_semantic_turn_for_test(
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ );
+
+ let interactive_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "child document parser EOF interactive transition",
+ )
+ .await;
+ let host_load_source = run_child_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "child document iframe load",
+ )
+ .await;
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childDocumentLoadWaitEvents.join('|')")?;
+ assert_eq!(
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ None,
+ "child document completion sequence should not leave extra child frame task work"
+ );
+
+ Ok::<_, anyhow::Error>((
+ first,
+ first_events,
+ realm_pending_after_first,
+ host_load_pending_after_completion,
+ first_followup_source,
+ events_after_first_followup,
+ lifecycle_ready_after_first_followup,
+ interactive_source,
+ host_load_source,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child document deferred completion test should run");
+
+ assert!(matches!(
+ first.action.source(),
+ RendererOwnerResourceActivitySource::ChildDocument
+ ));
+ assert_eq!(
+ first_events, "",
+ "child document completion turn should not inline-run child document script or frame load"
+ );
+ assert!(
+ realm_pending_after_first,
+ "child document completion must leave a typed realm prerequisite queued"
+ );
+ assert!(
+ !host_load_pending_after_completion,
+ "child document completion should not wake HostLoad while initial parser work is pending"
+ );
+ assert_eq!(
+ first_followup_source,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "first child frame task turn should run document-script ready work"
+ );
+ assert_eq!(
+ events_after_first_followup, "child-script:true",
+ "first child frame task turn should run document-script ready work, not iframe load"
+ );
+ assert!(
+ lifecycle_ready_after_first_followup,
+ "document-script ready should make the later lifecycle turn runnable"
+ );
+ assert_eq!(
+ interactive_source,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "parser EOF should become interactive before HostLoad"
+ );
+ assert_eq!(
+ host_load_source,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "iframe load should remain a later HostLoad source"
+ );
+ assert_eq!(
+ final_events,
+ "child-script:true|frameload",
+ "explicit later HostLoad turn should dispatch iframe load"
+ );
+
+ server
+ .await
+ .expect("child document wait-path server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_document_ready_work_runs_one_item_per_turn() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![
+ (
+ "/child-a.html",
+ "HTTP/1.1 200 OK",
+ r#"
+<script>
+parent.__multiChildDocumentEvents.push("child-a-script:" + (globalThis === self));
+</script>
+"#
+ .to_owned(),
+ Duration::ZERO,
+ ),
+ (
+ "/child-b.html",
+ "HTTP/1.1 200 OK",
+ r#"
+<script>
+parent.__multiChildDocumentEvents.push("child-b-script:" + (globalThis === self));
+</script>
+"#
+ .to_owned(),
+ Duration::ZERO,
+ ),
+ ])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let (owner_wake_tx, mut owner_wake_rx) = tokio::sync::mpsc::unbounded_channel();
+ let owner_wake = crate::page_task_queue::RendererOwnerWakeSender::new(
+ owner_wake_tx,
+ crate::runtime::RendererPageToken::new_for_testing(PageId::new_for_testing(1)),
+ );
+ let runtime_hooks =
+ PageVmRuntimeHooks::standalone_with_owner_wake_without_owner_reservation_for_test(
+ owner_wake,
+ );
+ let page_vm = test_page_vm_with_loader_document_url_and_hooks(
+ &loader,
+ Vec::new(),
+ document_url,
+ runtime_hooks,
+ );
+ let mut page_resource_queue = page_vm.page_resource_completion_queue();
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ completion_sources,
+ events_after_completions,
+ first_script_ready_source,
+ events_after_first_script_ready,
+ second_script_ready_source,
+ events_after_second_script_ready,
+ lifecycle_ready_after_second_script,
+ lifecycle_sources,
+ first_host_load_source,
+ events_after_first_host_load,
+ second_host_load_source,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let child_a_url = format!("{base_url}/child-a.html");
+ let child_b_url = format!("{base_url}/child-b.html");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__multiChildDocumentEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ for (const [name, url] of [["a", "{child_a_url}"], ["b", "{child_b_url}"]]) {{
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__multiChildDocumentEvents.push("frame-" + name + "-load");
+ frame.src = url;
+ body.appendChild(frame);
+ }}
+}})()
+"#
+ ))?;
+ let startup_sources = vec![
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "first external child navigation start",
+ )
+ .await,
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "second external child navigation start",
+ )
+ .await,
+ ];
+ assert_eq!(
+ startup_sources
+ .iter()
+ .filter(|source| **source == ChildFrameSemanticTurnKind::NavigationCommit)
+ .count(),
+ 2,
+ "each child document startup should consume one NavigationCommit source: {startup_sources:?}"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__multiChildDocumentEvents.join('|')")?,
+ "",
+ "child documents should wait for external document completions"
+ );
+
+ let mut completion_sources = Vec::new();
+ for label in ["first child document", "second child document"] {
+ child_document_completion::wait_for_page_resource_completion(
+ &mut page_resource_queue,
+ &mut owner_wake_rx,
+ label,
+ )
+ .await;
+ let completion = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_resource_queue)?
+ .expect("child document completion should consume one typed Page turn");
+ completion_sources.push(completion.action.source);
+ }
+ for label in ["first child realm", "second child realm"] {
+ run_expected_pending_child_realm_materialization_turn(
+ &mut page_vm,
+ label,
+ )?;
+ }
+ let events_after_completions = page_vm
+ .vm_mut()
+ .eval("__multiChildDocumentEvents.join('|')")?;
+
+ let first_script_ready_source =
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_first_script_ready = page_vm
+ .vm_mut()
+ .eval("__multiChildDocumentEvents.join('|')")?;
+ let second_script_ready_source =
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_second_script_ready = page_vm
+ .vm_mut()
+ .eval("__multiChildDocumentEvents.join('|')")?;
+ let lifecycle_ready_after_second_script = page_vm
+ .has_ready_child_frame_semantic_turn_for_test(
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ );
+ let lifecycle_sources = vec![
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ ];
+ let first_host_load_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_first_host_load = page_vm
+ .vm_mut()
+ .eval("__multiChildDocumentEvents.join('|')")?;
+
+ let second_host_load_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__multiChildDocumentEvents.join('|')")?;
+ assert_eq!(
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ None,
+ "multi-child document completion sequence should not leave extra child frame task work"
+ );
+
+ Ok::<_, anyhow::Error>((
+ completion_sources,
+ events_after_completions,
+ first_script_ready_source,
+ events_after_first_script_ready,
+ second_script_ready_source,
+ events_after_second_script_ready,
+ lifecycle_ready_after_second_script,
+ lifecycle_sources,
+ first_host_load_source,
+ events_after_first_host_load,
+ second_host_load_source,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm multi child document ready-work test should run");
+
+ assert_eq!(
+ completion_sources,
+ vec![
+ RendererOwnerResourceActivitySource::ChildDocument,
+ RendererOwnerResourceActivitySource::ChildDocument,
+ ]
+ );
+ assert_eq!(
+ events_after_completions, "",
+ "document completion turns should not inline-run either child document"
+ );
+ assert_eq!(
+ first_script_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "first child frame task turn should run only one document-script ready item"
+ );
+ let first_turn_ran_a = events_after_first_script_ready.contains("child-a-script:true");
+ let first_turn_ran_b = events_after_first_script_ready.contains("child-b-script:true");
+ assert_ne!(
+ first_turn_ran_a, first_turn_ran_b,
+ "first document-script ready turn should run exactly one child script; events: {events_after_first_script_ready}"
+ );
+ assert_eq!(
+ second_script_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "the stable child-frame family must preserve the already-enqueued second script ahead of lifecycle work produced by the first"
+ );
+ for expected in ["child-a-script:true", "child-b-script:true"] {
+ assert!(
+ events_after_second_script_ready.contains(expected),
+ "second document-script ready turn should run both child scripts across two turns; events: {events_after_second_script_ready}"
+ );
+ }
+ for unexpected in ["frame-a-load", "frame-b-load"] {
+ assert!(
+ !events_after_second_script_ready.contains(unexpected),
+ "second document-script ready turn should still not dispatch iframe load inline; events: {events_after_second_script_ready}"
+ );
+ }
+ assert!(
+ lifecycle_ready_after_second_script,
+ "both scripts should leave the oldest exact-Document lifecycle action at the family head"
+ );
+ assert_eq!(
+ lifecycle_sources,
+ vec![Some(ChildFrameSemanticTurnKind::DocumentLifecycle); 6],
+ "interactive, DOMContentLoaded and complete must each consume one lifecycle turn per child"
+ );
+ assert_eq!(
+ first_host_load_source,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "first iframe load should remain a later HostLoad source"
+ );
+ let first_host_load_dispatched_a =
+ events_after_first_host_load.contains("frame-a-load");
+ let first_host_load_dispatched_b =
+ events_after_first_host_load.contains("frame-b-load");
+ assert_ne!(
+ first_host_load_dispatched_a,
+ first_host_load_dispatched_b,
+ "first HostLoad turn should dispatch exactly one iframe load; events: {events_after_first_host_load}"
+ );
+ assert_eq!(
+ second_host_load_source,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "second iframe load should remain a separate HostLoad source"
+ );
+ for expected in [
+ "child-a-script:true",
+ "child-b-script:true",
+ "frame-a-load",
+ "frame-b-load",
+ ] {
+ assert!(
+ final_events.contains(expected),
+ "explicit script-ready and HostLoad turns should finish both child documents; final events: {final_events}"
+ );
+ }
+
+ server
+ .await
+ .expect("multi child document wait-path server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_document_script_ready_leaves_complete_and_load_for_later_sources() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child.html",
+ "HTTP/1.1 200 OK",
+ r#"
+<script>
+parent.__childReadyHostLoadEvents.push("child-script:" + (globalThis === self));
+</script>
+"#
+ .to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ bootstrap_source,
+ completion_source,
+ host_load_pending_after_completion,
+ script_ready_source,
+ events_after_script_ready,
+ lifecycle_ready_after_script,
+ interactive_source,
+ host_load_source,
+ events_after_host_load,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let child_url = format!("{base_url}/child.html");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childReadyHostLoadEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childReadyHostLoadEvents.push("frame-load");
+ frame.src = "{child_url}";
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let bootstrap_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childReadyHostLoadEvents.join('|')")?,
+ "",
+ "NavigationCommit should start the child document load without dispatching load"
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child document completion should arrive before timeout");
+ assert!(arrived, "child document completion sender should remain open");
+ }
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let completion_source = completion.action.source();
+ let host_load_pending_after_completion = page_vm
+ .has_ready_child_frame_semantic_turn_for_test(ChildFrameSemanticTurnKind::HostLoad);
+ run_expected_pending_child_realm_materialization_turn(
+ &mut page_vm,
+ "child script-ready realm prerequisite",
+ )?;
+
+ let script_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_script_ready = page_vm
+ .vm_mut()
+ .eval("__childReadyHostLoadEvents.join('|')")?;
+ let lifecycle_ready_after_script = page_vm
+ .has_ready_child_frame_semantic_turn_for_test(
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ );
+
+ let interactive_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let host_load_source = Some(
+ run_child_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "child document iframe load",
+ )
+ .await,
+ );
+ let events_after_host_load = page_vm
+ .vm_mut()
+ .eval("__childReadyHostLoadEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ bootstrap_source,
+ completion_source,
+ host_load_pending_after_completion,
+ script_ready_source,
+ events_after_script_ready,
+ lifecycle_ready_after_script,
+ interactive_source,
+ host_load_source,
+ events_after_host_load,
+ ))
+ })
+ .await
+ .expect("page vm child script-ready host-load boundary test should run");
+
+ assert_eq!(
+ bootstrap_source,
+ Some(ChildFrameSemanticTurnKind::NavigationCommit),
+ "bootstrap child frame turn should commit navigation before lifecycle delivery"
+ );
+ assert_eq!(
+ completion_source,
+ RendererOwnerResourceActivitySource::ChildDocument
+ );
+ assert!(
+ !host_load_pending_after_completion,
+ "child document completion should not leave HostLoad pending before document-script ready work runs"
+ );
+ assert_eq!(
+ script_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "child document completion follow-up should run document-script ready work"
+ );
+ assert_eq!(
+ events_after_script_ready, "child-script:true",
+ "DocumentScriptReady should run the child script but not dispatch iframe load inline"
+ );
+ assert!(
+ lifecycle_ready_after_script,
+ "DocumentScriptReady should make the later lifecycle turn runnable"
+ );
+ assert_eq!(
+ interactive_source,
+ Some(ChildFrameSemanticTurnKind::DocumentLifecycle),
+ "parser EOF should dispatch interactive before HostLoad"
+ );
+ assert_eq!(
+ host_load_source,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "HostLoad should be the source that dispatches iframe load"
+ );
+ assert_eq!(
+ events_after_host_load, "child-script:true|frame-load",
+ "iframe load should dispatch only on the HostLoad turn"
+ );
+
+ server
+ .await
+ .expect("child document host-load boundary server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_input_event_commits_child_navigation_before_document_script_ready() {
+ let page_vm = test_page_vm();
+ let local_executor = page_vm.local_executor.clone();
+
+ let input = run_on_page_vm_local_executor(local_executor, async move {
+ let mut page_vm = page_vm;
+ page_vm.vm_mut().eval(
+ r#"
+(() => {
+ globalThis.__inputReadyEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const button = document.createElement("button");
+ button.textContent = "create child";
+ button.style.cssText = "display:block;width:100px;height:20px";
+ button.addEventListener("click", () => {
+ __inputReadyEvents.push("click");
+ const frame = document.createElement("iframe");
+ frame.onload = () => __inputReadyEvents.push("frame-load");
+ frame.srcdoc = `<script>parent.__inputReadyEvents.push("child-script:" + (globalThis === self));<\/script>`;
+ body.appendChild(frame);
+ });
+ body.appendChild(button);
+})()
+"#,
+ )?;
+
+ page_vm.vm_mut().publish_layout_for_test()?;
+
+ let mouse_down_handled = page_vm
+ .vm_mut()
+ .dispatch_mouse_event_at_point(10.0, 10.0, "mousedown", 0, None, 0.0, 0.0)?
+ .handled;
+ let mouse_up_handled = page_vm
+ .vm_mut()
+ .dispatch_mouse_event_at_point(10.0, 10.0, "mouseup", 0, Some(0), 0.0, 0.0)?
+ .handled;
+ let events_after_click = page_vm.vm_mut().eval("__inputReadyEvents.join('|')")?;
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "input-created child navigation commit",
+ )
+ .await;
+ run_expected_child_realm_materialization_for_wait(
+ &mut page_vm,
+ "input-created child realm",
+ )
+ .await;
+ let script_ready_source = page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await;
+ let events_after_script_ready = page_vm.vm_mut().eval("__inputReadyEvents.join('|')")?;
+ let host_load_source = Some(
+ run_child_interactive_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "input-created child iframe load",
+ )
+ .await,
+ );
+ let events_after_host_load = page_vm.vm_mut().eval("__inputReadyEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ mouse_down_handled,
+ mouse_up_handled,
+ events_after_click,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ events_after_host_load,
+ ))
+ });
+ let (
+ mouse_down_handled,
+ mouse_up_handled,
+ events_after_click,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ events_after_host_load,
+ ) = run_page_vm_async_test(input)
+ .await
+ .expect("input ready-work source test should run");
+
+ assert!(mouse_down_handled, "mousedown should hit the button");
+ assert!(
+ mouse_up_handled,
+ "mouseup should hit the button and dispatch click"
+ );
+ assert_eq!(
+ events_after_click, "click",
+ "input click should create the child frame without running its parser script inline"
+ );
+ assert_eq!(
+ script_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "input-created child parser work should follow its navigation commit"
+ );
+ assert_eq!(
+ events_after_script_ready, "click|child-script:true",
+ "child parser work should run on the later DocumentScriptReady turn"
+ );
+ assert_eq!(
+ host_load_source,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "iframe load should remain a separate HostLoad turn after input dispatch"
+ );
+ assert_eq!(
+ events_after_host_load, "click|child-script:true|frame-load",
+ "iframe load should dispatch only on the HostLoad turn"
+ );
+}
+#[tokio::test]
+async fn page_vm_message_port_event_commits_child_navigation_before_document_script_ready() {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse("https://example.com/message-port-child-navigation").unwrap();
+ let (page_vm, _resource_source, mut owner_wake_rx) =
+ page_vm_with_bound_task_sources_and_owner_wake(&loader, document_url);
+ let local_executor = page_vm.local_executor.clone();
+ let selected_task_local_set = tokio::task::LocalSet::new();
+
+ let (
+ completion_sources,
+ message_port_turns,
+ events_after_message,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ events_after_host_load,
+ ) = selected_task_local_set
+ .run_until(local_executor.run(async move {
+ let mut page_vm = page_vm;
+ page_vm.vm_mut().eval(
+ r#"
+(() => {
+ globalThis.__messagePortReadyEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const workerSource = `
+ onmessage = (event) => {
+ if (event.data !== "connect") {
+ return;
+ }
+ const port = event.ports[0];
+ port.postMessage("go");
+ };
+ `;
+ globalThis.__messagePortReadyWorker = new Worker(
+ "data:text/javascript," + encodeURIComponent(workerSource)
+ );
+ globalThis.__messagePortReadyChannel = new MessageChannel();
+ const channel = globalThis.__messagePortReadyChannel;
+ channel.port1.onmessage = (event) => {
+ __messagePortReadyEvents.push("message:" + event.data);
+ const frame = document.createElement("iframe");
+ frame.onload = () => __messagePortReadyEvents.push("frame-load");
+ frame.srcdoc = `<script>parent.__messagePortReadyEvents.push("child-script:" + (globalThis === self));<\/script>`;
+ body.appendChild(frame);
+ };
+ globalThis.__messagePortReadyWorker.postMessage("connect", [channel.port2]);
+})()
+"#,
+ )?;
+
+ let mut completion_sources = Vec::new();
+ let mut message_port_turns = 0;
+ let events_after_message = loop {
+ if page_vm
+ .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::DedicatedWorkerClientEvent,
+ &loader,
+ )
+ .await?
+ {
+ completion_sources.push(RendererOwnerResourceActivitySource::Worker);
+ } else if page_vm
+ .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::MessagePortDelivery, &loader)
+ .await?
+ {
+ message_port_turns += 1;
+ } else if page_vm.has_ready_page_websocket_task_for_test() {
+ let completion_source = page_vm
+ .run_exact_page_websocket_selected_task_for_test().await?
+ .expect("ready Worker completion should remain available");
+ completion_sources.push(completion_source);
+ } else {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ async {
+ tokio::select! {
+ wake = owner_wake_rx.recv() => wake.is_some(),
+ arrived = page_vm.wait_for_page_websocket_task_for_test() => arrived,
+ }
+ },
+ )
+ .await
+ .expect("MessagePort/worker completion should arrive before timeout");
+ assert!(
+ arrived,
+ "Worker completion sender should remain open"
+ );
+ }
+ let events = page_vm
+ .vm_mut()
+ .eval("__messagePortReadyEvents.join('|')")?;
+ if events == "message:go" {
+ break events;
+ }
+ assert!(
+ completion_sources.len() + message_port_turns < 16,
+ "MessagePort handler should run after bounded turns; sources: {completion_sources:?}, message_port_turns={message_port_turns}, events: {events}"
+ );
+ };
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "MessagePort-created child navigation commit",
+ )
+ .await;
+ run_expected_child_realm_materialization_for_wait(
+ &mut page_vm,
+ "MessagePort-created child realm",
+ )
+ .await;
+ let script_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_script_ready = page_vm
+ .vm_mut()
+ .eval("__messagePortReadyEvents.join('|')")?;
+ let host_load_source = Some(
+ run_child_interactive_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "MessagePort-created child iframe load",
+ )
+ .await,
+ );
+ let events_after_host_load = page_vm
+ .vm_mut()
+ .eval("__messagePortReadyEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ completion_sources,
+ message_port_turns,
+ events_after_message,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ events_after_host_load,
+ ))
+ }))
+ .await
+ .expect("MessagePort ready-work source test should run");
+
+ assert_eq!(
+ message_port_turns, 1,
+ "one Worker reply should be consumed by one typed MessagePort turn; completion sources: {completion_sources:?}"
+ );
+ assert_eq!(
+ events_after_message, "message:go",
+ "MessagePort handler should create the child frame without running its parser script inline"
+ );
+ assert_eq!(
+ script_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "MessagePort-created child parser work should follow its navigation commit"
+ );
+ assert_eq!(
+ events_after_script_ready, "message:go|child-script:true",
+ "child parser work should run on the later DocumentScriptReady turn"
+ );
+ assert_eq!(
+ host_load_source,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "iframe load should remain a separate HostLoad turn after MessagePort dispatch"
+ );
+ assert_eq!(
+ events_after_host_load, "message:go|child-script:true|frame-load",
+ "iframe load should dispatch only on the HostLoad turn"
+ );
+}
+#[tokio::test]
+async fn page_vm_broadcast_channel_commits_child_navigation_before_document_script_ready() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/broadcast-ready-worker.js",
+ "HTTP/1.1 200 OK",
+ r#"
+const sender = new BroadcastChannel("broadcast-ready-work");
+sender.postMessage("go");
+"#
+ .to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let (page_vm, _typed_resource_source, mut owner_wake_rx) =
+ page_vm_with_bound_task_sources_and_owner_wake(&loader, document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ completion_sources,
+ events_after_broadcast,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ events_after_host_load,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let worker_url = format!("{base_url}/broadcast-ready-worker.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__broadcastReadyEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ globalThis.__broadcastReadyReceiver = new BroadcastChannel("broadcast-ready-work");
+ __broadcastReadyReceiver.onmessage = (event) => {{
+ __broadcastReadyEvents.push("message:" + event.data);
+ const frame = document.createElement("iframe");
+ frame.onload = () => __broadcastReadyEvents.push("frame-load");
+ frame.srcdoc = `<script>parent.__broadcastReadyEvents.push("child-script:" + (globalThis === self));<\/script>`;
+ body.appendChild(frame);
+ }};
+ globalThis.__broadcastReadyWorker = new Worker("{worker_url}");
+}})()
+"#
+ ))?;
+
+ let mut completion_sources = Vec::new();
+ let events_after_broadcast = loop {
+ if page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::DomManipulation(PageDomManipulationTestFamily::BroadcastChannel),
+ &loader,
+ )
+ .await?
+ {
+ completion_sources
+ .push(RendererOwnerResourceActivitySource::BroadcastChannel);
+ let events = page_vm.vm_mut().eval("__broadcastReadyEvents.join('|')")?;
+ if events == "message:go" {
+ break events;
+ }
+ continue;
+ }
+ if page_vm
+ .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::DedicatedWorkerClientEvent,
+ &loader,
+ )
+ .await?
+ {
+ completion_sources.push(RendererOwnerResourceActivitySource::Worker);
+ continue;
+ }
+ if !page_vm.has_ready_page_websocket_task_for_test() {
+ let websocket_arrival = page_vm.wait_for_page_websocket_task_for_test();
+ tokio::pin!(websocket_arrival);
+ tokio::time::timeout(Duration::from_secs(2), async {
+ tokio::select! {
+ arrived = &mut websocket_arrival => {
+ assert!(
+ arrived,
+ "BroadcastChannel/worker completion sender should remain open"
+ );
+ }
+ wake = owner_wake_rx.recv() => {
+ assert!(
+ wake.is_some(),
+ "typed BroadcastChannel owner wake sender should remain open"
+ );
+ }
+ }
+ })
+ .await
+ .expect("BroadcastChannel/worker work should arrive before timeout");
+ continue;
+ }
+ let completion_source = page_vm
+ .run_exact_page_websocket_selected_task_for_test().await?
+ .expect("BroadcastChannel/worker completion should be ready");
+ completion_sources.push(completion_source);
+ let events = page_vm.vm_mut().eval("__broadcastReadyEvents.join('|')")?;
+ if events == "message:go" {
+ break events;
+ }
+ assert!(
+ completion_sources.len() < 16,
+ "BroadcastChannel handler should run after bounded completions; sources: {completion_sources:?}, events: {events}"
+ );
+ };
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "BroadcastChannel-created child navigation commit",
+ )
+ .await;
+ run_expected_child_realm_materialization_for_wait(
+ &mut page_vm,
+ "BroadcastChannel-created child realm",
+ )
+ .await;
+ let script_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_script_ready =
+ page_vm.vm_mut().eval("__broadcastReadyEvents.join('|')")?;
+ let host_load_source = Some(
+ run_child_interactive_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "BroadcastChannel-created child iframe load",
+ )
+ .await,
+ );
+ let events_after_host_load =
+ page_vm.vm_mut().eval("__broadcastReadyEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ completion_sources,
+ events_after_broadcast,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ events_after_host_load,
+ ))
+ })
+ .await
+ .expect("BroadcastChannel ready-work source test should run");
+
+ assert!(
+ completion_sources.contains(&RendererOwnerResourceActivitySource::BroadcastChannel),
+ "BroadcastChannel handler should be driven by a BroadcastChannel completion: {completion_sources:?}"
+ );
+ assert_eq!(
+ events_after_broadcast, "message:go",
+ "BroadcastChannel handler should create the child frame without running its parser script inline"
+ );
+ assert_eq!(
+ script_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "BroadcastChannel-created child parser work should follow its navigation commit"
+ );
+ assert_eq!(
+ events_after_script_ready, "message:go|child-script:true",
+ "child parser work should run on the later DocumentScriptReady turn"
+ );
+ assert_eq!(
+ host_load_source,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "iframe load should remain a separate HostLoad turn after BroadcastChannel dispatch"
+ );
+ assert_eq!(
+ events_after_host_load, "message:go|child-script:true|frame-load",
+ "iframe load should dispatch only on the HostLoad turn"
+ );
+
+ server
+ .await
+ .expect("BroadcastChannel ready-work worker server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn child_document_write_nested_external_classic_blocks_domcontentloaded() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-written-classic.js",
+ "HTTP/1.1 200 OK",
+ "parent.__childWrittenEvents.push('external');".to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (events_after_outer, source_load_source, events_after_external, final_events) =
+ local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let script_url = format!("{base_url}/child-written-classic.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childWrittenEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => __childWrittenEvents.push("load");
+ frame.srcdoc = `<script>
+ parent.__childWrittenEvents.push("outer");
+ document.write("<script>parent.__childWrittenEvents.push('nested');<\\/script>");
+ document.write("<script src='{script_url}'><\\/script>");
+ document.addEventListener("DOMContentLoaded", () => parent.__childWrittenEvents.push("dcl"));
+ <\/script>`;
+ body.appendChild(frame);
+}})()
+"#,
+ ))?;
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "nested document.write child navigation commit",
+ )
+ .await;
+ run_expected_child_realm_materialization_for_wait(
+ &mut page_vm,
+ "nested document.write child realm",
+ )
+ .await;
+ assert_eq!(
+ page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "outer parser script should run before its written external source starts"
+ );
+ let events_after_outer =
+ page_vm.vm_mut().eval("__childWrittenEvents.join('|')")?;
+ let source_load_source = page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await;
+ if !page_vm
+ .page_resource_completion_queue()
+ .has_ready_completion()
+ {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("written external completion should arrive before timeout");
+ assert!(
+ arrived,
+ "written external completion sender should remain open"
+ );
+ }
+ let _ = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "written external classic execution",
+ )
+ .await;
+ let events_after_external =
+ page_vm.vm_mut().eval("__childWrittenEvents.join('|')")?;
+ run_child_interactive_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "nested document.write child load",
+ )
+ .await;
+ let final_events = page_vm.vm_mut().eval("__childWrittenEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ events_after_outer,
+ source_load_source,
+ events_after_external,
+ final_events,
+ ))
+ })
+ .await
+ .expect("nested child document.write test should run");
+
+ assert_eq!(events_after_outer, "outer|nested");
+ assert_eq!(
+ source_load_source,
+ Some(ChildFrameSemanticTurnKind::ClassicScriptSourceLoad),
+ "the written external script should start before the parser resumes"
+ );
+ assert_eq!(events_after_external, "outer|nested|external");
+ assert_eq!(final_events, "outer|nested|external|dcl|load");
+
+ server
+ .await
+ .expect("nested child document.write server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn child_document_close_defers_while_written_external_classic_blocks_parser() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-close-blocker.js",
+ "HTTP/1.1 200 OK",
+ "parent.__childCloseEvents.push('external:' + Boolean(document.getElementById('after-blocker')));"
+ .to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ events_after_close,
+ source_load_source,
+ events_after_external,
+ final_events,
+ tail_exists,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ page_vm.vm_mut().eval(
+ r#"
+(() => {
+ globalThis.__childCloseEvents = [];
+ const frame = document.createElement("iframe");
+ frame.id = "child-close-frame";
+ document.body.appendChild(frame);
+})()
+"#,
+ )?;
+ materialize_child_realm_through_page_turn_for_test(
+ &mut page_vm,
+ "child-close-frame",
+ )?;
+
+ let script_url = format!("{base_url}/child-close-blocker.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ const frame = document.getElementById("child-close-frame");
+ frame.onload = () => __childCloseEvents.push("load");
+ const childDocument = frame.contentDocument;
+ childDocument.open();
+ childDocument.addEventListener("DOMContentLoaded", () => __childCloseEvents.push("dcl"));
+ childDocument.write(`<script src="{script_url}"><\/script><main id="after-blocker">tail</main>`);
+ childDocument.close();
+ __childCloseEvents.push("after-close");
+}})()
+"#,
+ ))?;
+ let events_after_close = page_vm.vm_mut().eval("__childCloseEvents.join('|')")?;
+ let source_load_source =
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::ClassicScriptSourceLoad,
+ "document.close delayed external classic source load",
+ )
+ .await;
+ if !page_vm
+ .page_resource_completion_queue()
+ .has_ready_completion()
+ {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child close blocker completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child close blocker completion sender should remain open"
+ );
+ }
+ let _ = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "document.close delayed external classic execution",
+ )
+ .await;
+ let events_after_external =
+ page_vm.vm_mut().eval("__childCloseEvents.join('|')")?;
+ run_child_interactive_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "document.close delayed child load",
+ )
+ .await;
+ let final_events = page_vm.vm_mut().eval("__childCloseEvents.join('|')")?;
+ let tail_exists = page_vm.vm_mut().eval(
+ "String(Boolean(document.getElementById('child-close-frame').contentDocument.getElementById('after-blocker')))",
+ )?;
+
+ Ok::<_, anyhow::Error>((
+ events_after_close,
+ source_load_source,
+ events_after_external,
+ final_events,
+ tail_exists,
+ ))
+ })
+ .await
+ .expect("child document.close delayed EOF test should run");
+
+ assert_eq!(
+ events_after_close, "after-close",
+ "document.close() should return without executing or bypassing the blocker"
+ );
+ assert_eq!(
+ source_load_source,
+ ChildFrameSemanticTurnKind::ClassicScriptSourceLoad
+ );
+ assert_eq!(
+ events_after_external, "after-close|external:false",
+ "the external parser-blocking script must run before future markup is parsed"
+ );
+ assert_eq!(final_events, "after-close|external:false|dcl|load");
+ assert_eq!(tail_exists, "true");
+
+ server
+ .await
+ .expect("child close blocker server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_window_load_navigation_uses_navigation_commit_followup() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-load-navigate.html",
+ "HTTP/1.1 200 OK",
+ r#"
+<script>
+parent.__childLoadNavigationEvents.push("child-script");
+const clickOrder = [];
+addEventListener("click", event => {
+ clickOrder.push("before");
+ onclick = () => {
+ clickOrder.push("property");
+ return false;
+ };
+ event.stopPropagation();
+});
+onclick = () => clickOrder.push("stale");
+addEventListener("click", () => clickOrder.push("after"));
+const clickDispatchResult = document.dispatchEvent(new Event("click", {
+ bubbles: true,
+ cancelable: true
+}));
+parent.__childLoadNavigationEvents.push("click:" + clickOrder.join(",") + ":" + clickDispatchResult);
+onerror = function(message, source, line, column, error, extra) {
+ parent.__childLoadNavigationEvents.push([
+ "child-error",
+ arguments.length,
+ message,
+ source.endsWith("child-load-navigate.html"),
+ line > 0,
+ column > 0,
+ error && error.message,
+ extra === undefined
+ ].join(":"));
+ return true;
+};
+const marker = new Error("child-error-marker");
+const errorDispatchResult = dispatchEvent(new ErrorEvent("error", {
+ cancelable: true,
+ message: marker.message,
+ filename: location.href,
+ lineno: 7,
+ colno: 9,
+ error: marker
+}));
+parent.__childLoadNavigationEvents.push("error-dispatch:" + errorDispatchResult);
+addEventListener("load", () => parent.__childLoadNavigationEvents.push("load-listener-before"));
+onload = () => {
+ parent.__childLoadNavigationEvents.push("child-load");
+ location.href = "data:text/html,<!doctype html><script>parent.postMessage('can navigate', '*')<\/script>";
+};
+addEventListener("load", () => parent.__childLoadNavigationEvents.push("load-listener-after"));
+</script>
+"#
+ .to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let loader_for_task = loader.clone();
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ bootstrap_source,
+ completion_source,
+ script_ready_source,
+ events_after_script_ready,
+ interactive_source,
+ host_load_source,
+ events_after_host_load,
+ pending_after_host_load,
+ navigation_commit_source,
+ events_after_navigation_commit,
+ navigation_script_ready_source,
+ events_after_navigation_script_ready,
+ message_ready_after_navigation_script,
+ message_endpoints_after_navigation_script,
+ events_after_window_message,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let child_url = format!("{base_url}/child-load-navigate.html");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childLoadNavigationEvents = [];
+ addEventListener("message", event => __childLoadNavigationEvents.push(event.data));
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.src = "{child_url}";
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let bootstrap_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child document completion should arrive before timeout");
+ assert!(arrived, "child document completion sender should remain open");
+ }
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let completion_source = completion.action.source();
+ run_expected_pending_child_realm_materialization_turn(
+ &mut page_vm,
+ "child window-load realm prerequisite",
+ )?;
+
+ let script_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_script_ready = page_vm
+ .vm_mut()
+ .eval("__childLoadNavigationEvents.join('|')")?;
+
+ let interactive_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let host_load_source = Some(
+ run_child_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "child window-load navigation initial load",
+ )
+ .await,
+ );
+ let events_after_host_load = page_vm
+ .vm_mut()
+ .eval("__childLoadNavigationEvents.join('|')")?;
+ let pending_after_host_load = page_vm
+ .vm()
+ .has_pending_child_navigation_commit_for_test();
+ let navigation_commit_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "child window load navigation commit",
+ )
+ .await;
+ let events_after_navigation_commit = page_vm
+ .vm_mut()
+ .eval("__childLoadNavigationEvents.join('|')")?;
+ run_expected_pending_child_realm_materialization_turn(
+ &mut page_vm,
+ "child window-load navigation realm prerequisite",
+ )?;
+ let navigation_script_ready_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "child window load navigation script",
+ )
+ .await;
+ let events_after_navigation_script_ready = page_vm
+ .vm_mut()
+ .eval("__childLoadNavigationEvents.join('|')")?;
+ let message_endpoints_after_navigation_script =
+ page_vm.vm().pending_window_message_endpoints_for_test();
+ let message_ready_after_navigation_script = page_vm
+ .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::WindowMessage, &loader_for_task)
+ .await?;
+ let events_after_window_message = page_vm
+ .vm_mut()
+ .eval("__childLoadNavigationEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ bootstrap_source,
+ completion_source,
+ script_ready_source,
+ events_after_script_ready,
+ interactive_source,
+ host_load_source,
+ events_after_host_load,
+ pending_after_host_load,
+ navigation_commit_source,
+ events_after_navigation_commit,
+ navigation_script_ready_source,
+ events_after_navigation_script_ready,
+ message_ready_after_navigation_script,
+ message_endpoints_after_navigation_script,
+ events_after_window_message,
+ ))
+ })
+ .await
+ .expect("child load navigation host-load follow-up test should run");
+
+ assert_eq!(
+ bootstrap_source,
+ Some(ChildFrameSemanticTurnKind::NavigationCommit),
+ "bootstrap child frame turn should commit navigation before lifecycle delivery"
+ );
+ assert_eq!(
+ completion_source,
+ RendererOwnerResourceActivitySource::ChildDocument
+ );
+ assert_eq!(
+ script_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady)
+ );
+ assert_eq!(
+ events_after_script_ready,
+ "child-script|click:before,property,after:false|child-error:5:child-error-marker:true:true:true:child-error-marker:true|error-dispatch:false",
+ "DocumentScriptReady should not dispatch child window load inline"
+ );
+ assert_eq!(
+ interactive_source,
+ Some(ChildFrameSemanticTurnKind::DocumentLifecycle),
+ "child document should become interactive before its window load"
+ );
+ assert_eq!(
+ host_load_source,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "child window load should dispatch on a HostLoad turn"
+ );
+ assert_eq!(
+ events_after_host_load,
+ "child-script|click:before,property,after:false|child-error:5:child-error-marker:true:true:true:child-error-marker:true|error-dispatch:false|load-listener-before|child-load|load-listener-after",
+ "HostLoad should invoke one registration-ordered child window load dispatch without finishing navigation inline"
+ );
+ assert!(
+ pending_after_host_load,
+ "child window load navigation should leave follow-up child frame work"
+ );
+ assert_eq!(
+ navigation_commit_source,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "navigation queued by child window load should commit through NavigationCommit"
+ );
+ assert_eq!(
+ events_after_navigation_commit,
+ "child-script|click:before,property,after:false|child-error:5:child-error-marker:true:true:true:child-error-marker:true|error-dispatch:false|load-listener-before|child-load|load-listener-after",
+ "NavigationCommit should not deliver the child postMessage inline"
+ );
+ assert_eq!(
+ navigation_script_ready_source,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "data-url navigation script should run from DocumentScriptReady"
+ );
+ assert_eq!(
+ events_after_navigation_script_ready,
+ "child-script|click:before,property,after:false|child-error:5:child-error-marker:true:true:true:child-error-marker:true|error-dispatch:false|load-listener-before|child-load|load-listener-after",
+ "navigation script should queue a parent window-message task without delivering it inline"
+ );
+ assert!(
+ message_ready_after_navigation_script,
+ "child navigation script should queue a ready parent window-message task"
+ );
+ assert_eq!(
+ message_endpoints_after_navigation_script.len(),
+ 1,
+ "child navigation script should queue exactly one window-message task: {message_endpoints_after_navigation_script:?}"
+ );
+ assert!(
+ matches!(
+ message_endpoints_after_navigation_script.as_slice(),
+ [(
+ PendingWindowMessageEndpoint::TopWindow,
+ PendingWindowMessageEndpoint::ChildWindow(_)
+ )]
+ ),
+ "child navigation script should target the top window from the child: {message_endpoints_after_navigation_script:?}"
+ );
+ assert_eq!(
+ events_after_window_message,
+ "child-script|click:before,property,after:false|child-error:5:child-error-marker:true:true:true:child-error-marker:true|error-dispatch:false|load-listener-before|child-load|load-listener-after|can navigate",
+ "advancing the ready window-message task should deliver the child navigation postMessage"
+ );
+
+ server
+ .await
+ .expect("child load navigation host-load follow-up server should finish");
+ })
+ .await;
+}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/extracted/child_module_graphs.rs b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/child_module_graphs.rs
new file mode 100644
index 000000000..81b0248a3
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/child_module_graphs.rs
@@ -0,0 +1,2965 @@
+use super::*;
+
+#[tokio::test(flavor = "current_thread")]
+async fn stale_child_module_completions_preserve_network_and_run_one_terminal_per_turn() {
+ run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm();
+ let root_document = page_vm.document_lifecycle.identity().document;
+ page_vm.vm_mut().eval(
+ "const staleModuleFrame = document.createElement('iframe'); \
+ staleModuleFrame.id = 'stale-module-frame'; \
+ document.body.appendChild(staleModuleFrame);",
+ )?;
+ let child_handle = page_vm
+ .vm()
+ .element_handle_by_id_for_test("stale-module-frame")
+ .expect("same-Page stale module fixture should install a child handle");
+ materialize_child_realm_through_page_turn_for_test(&mut page_vm, "stale-module-frame")?;
+ let current_child_owner = page_vm
+ .vm()
+ .current_child_document_task_owner(child_handle)
+ .expect("same-Page stale module fixture should install a child owner");
+ let current_module_target = page_vm
+ .vm()
+ .current_child_document_module_fetch_target(child_handle)
+ .expect("same-Page stale module fixture should install a child realm");
+ assert_eq!(current_module_target.task_owner(), current_child_owner);
+ let stale_owner = FrameDocumentTaskOwner::new(
+ crate::frame_owner_model::FrameSchedulerLaneId(
+ current_child_owner.scheduler_lane_id.0 + 1,
+ ),
+ current_child_owner.local_window_id,
+ current_child_owner.document_id,
+ );
+ let mut queue = RendererPageNetworkingSource::new_for_test();
+ queue.enqueue_local_for_test(
+ RendererPageResourceCompletion::child_parser_module_root_fetch(
+ root_document,
+ test_child_parser_module_root_completion(
+ child_handle,
+ stale_owner,
+ 47,
+ "stale-child-module-root",
+ Some("stale child module root failed"),
+ ),
+ ),
+ );
+ queue.enqueue_local_for_test(
+ RendererPageResourceCompletion::child_module_dependency_fetch(
+ root_document,
+ test_child_module_dependency_completion(
+ child_handle,
+ stale_owner,
+ 53,
+ "stale-child-module-dependency",
+ Some("stale child module dependency failed"),
+ ),
+ ),
+ );
+ queue.enqueue_local_for_test(RendererPageResourceCompletion::child_modulepreload_fetch(
+ root_document,
+ test_child_modulepreload_completion_for_target(
+ ChildDocumentModuleFetchTarget::new(child_handle, stale_owner, FrameRealmId(109)),
+ 57,
+ "stale-child-modulepreload",
+ Some("stale child modulepreload failed"),
+ ),
+ ));
+ queue.enqueue_local_for_test(RendererPageResourceCompletion::child_modulepreload_fetch(
+ root_document,
+ test_child_modulepreload_completion_for_target(
+ ChildDocumentModuleFetchTarget::new(child_handle, stale_owner, FrameRealmId(109)),
+ 59,
+ "stale-child-module-no-network",
+ None,
+ ),
+ ));
+ let activity_epoch_before = page_vm.vm().subresource_activity_epoch();
+ let expected_owner = RendererPageResourceCompletionOwner::child_module_fetch(
+ root_document,
+ ChildDocumentModuleFetchTarget::new(child_handle, stale_owner, FrameRealmId(109)),
+ );
+ let expected_current_owner = RendererPageResourceCompletionOwner::child_module_fetch(
+ root_document,
+ current_module_target,
+ );
+
+ let root = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)?
+ .expect("stale root module terminal should consume one owner turn");
+ assert_eq!(root.action.owner, expected_owner);
+ assert_eq!(
+ root.action.document_effect,
+ PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
+ current_owner: Some(expected_current_owner),
+ }
+ );
+ assert_eq!(
+ root.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ assert!(queue.has_ready_completion());
+
+ let dependency = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)?
+ .expect("stale dependency module terminal should consume its own owner turn");
+ assert_eq!(dependency.action.owner, expected_owner);
+ assert_eq!(
+ dependency.action.document_effect,
+ PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
+ current_owner: Some(expected_current_owner),
+ }
+ );
+ assert_eq!(
+ dependency.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ assert!(queue.has_ready_completion());
+
+ let modulepreload = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)?
+ .expect("stale modulepreload terminal should consume its own owner turn");
+ assert_eq!(modulepreload.action.owner, expected_owner);
+ assert_eq!(
+ modulepreload.action.document_effect,
+ PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
+ current_owner: Some(expected_current_owner),
+ }
+ );
+ assert_eq!(
+ modulepreload.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ assert!(queue.has_ready_completion());
+
+ let no_network = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)?
+ .expect("stale no-Network module terminal should consume its own owner turn");
+ assert_eq!(no_network.action.owner, expected_owner);
+ assert_eq!(
+ no_network.action.document_effect,
+ PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
+ current_owner: Some(expected_current_owner),
+ }
+ );
+ assert_eq!(
+ no_network.action.output_effect,
+ PageResourceCompletionOutputEffect::None,
+ "a stale module terminal without a Network fact must not synthesize output"
+ );
+
+ assert!(!queue.has_ready_completion());
+ assert_eq!(
+ page_vm.vm().subresource_activity_epoch(),
+ activity_epoch_before,
+ "retired child module Network facts must not become current Document activity"
+ );
+
+ let (network_records, websocket_events, websocket_lifecycle_events) =
+ split_network_output_items(page_vm.vm_mut().take_network_output());
+ assert!(websocket_events.is_empty());
+ assert!(websocket_lifecycle_events.is_empty());
+ assert_eq!(network_records.len(), 3);
+ assert_eq!(
+ network_records
+ .iter()
+ .map(|record| record.frame_id())
+ .collect::<Vec<_>>(),
+ vec![
+ Some("stale-child-module-root-frame"),
+ Some("stale-child-module-dependency-frame"),
+ Some("stale-child-modulepreload-frame"),
+ ]
+ );
+ assert!(network_records.iter().all(|record| {
+ record.resource_type() == SubresourceResourceType::Script
+ && record.request_initiator_type() == SubresourceRequestInitiatorType::Parser
+ }));
+ assert_eq!(
+ network_records[0].outcome(),
+ &SubresourceNetworkOutcome::Failure {
+ error_text: "stale child module root failed".to_owned(),
+ }
+ );
+ assert_eq!(
+ network_records[1].outcome(),
+ &SubresourceNetworkOutcome::Failure {
+ error_text: "stale child module dependency failed".to_owned(),
+ }
+ );
+ assert_eq!(
+ network_records[2].outcome(),
+ &SubresourceNetworkOutcome::Failure {
+ error_text: "stale child modulepreload failed".to_owned(),
+ }
+ );
+ Ok::<_, anyhow::Error>(())
+ })
+ .await
+ .expect("stale child module completion test should run");
+}
+#[tokio::test(flavor = "current_thread")]
+async fn child_module_completion_rejects_replaced_realm_with_same_document_owner() {
+ run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm();
+ page_vm.vm_mut().eval(
+ "const realmReplacementFrame = document.createElement('iframe'); \
+ realmReplacementFrame.id = 'realm-replacement-frame'; \
+ document.body.appendChild(realmReplacementFrame);",
+ )?;
+ let child_handle = page_vm
+ .vm()
+ .element_handle_by_id_for_test("realm-replacement-frame")
+ .expect("realm replacement fixture should install a child handle");
+ materialize_child_realm_through_page_turn_for_test(
+ &mut page_vm,
+ "realm-replacement-frame",
+ )?;
+ let retired_target = page_vm
+ .vm()
+ .current_child_document_module_fetch_target(child_handle)
+ .expect("first child realm should have an exact module target");
+ let root_completion = test_child_parser_module_root_completion_for_target(
+ retired_target,
+ 61,
+ "stale-child-module-root-realm",
+ Some("retired child realm root fetch failed"),
+ );
+ let dependency_completion = test_child_module_dependency_completion_for_target(
+ retired_target,
+ 67,
+ "stale-child-module-dependency-realm",
+ Some("retired child realm dependency fetch failed"),
+ );
+ let modulepreload_completion = test_child_modulepreload_completion_for_target(
+ retired_target,
+ 71,
+ "stale-child-modulepreload-realm",
+ Some("retired child realm modulepreload failed"),
+ );
+
+ page_vm
+ .vm_mut()
+ .retire_child_frame_realm_for_test(child_handle);
+ materialize_child_realm_through_page_turn_for_test(
+ &mut page_vm,
+ "realm-replacement-frame",
+ )?;
+ let current_target = page_vm
+ .vm()
+ .current_child_document_module_fetch_target(child_handle)
+ .expect("replacement child realm should have an exact module target");
+ assert_eq!(current_target.child_handle(), retired_target.child_handle());
+ assert_eq!(current_target.task_owner(), retired_target.task_owner());
+ assert_ne!(
+ current_target.realm_id(),
+ retired_target.realm_id(),
+ "realm replacement must preserve the Document owner while changing execution identity"
+ );
+
+ let root_document = page_vm.document_lifecycle.identity().document;
+ let expected_owner = RendererPageResourceCompletionOwner::child_module_fetch(
+ root_document,
+ retired_target,
+ );
+ let expected_current_owner = RendererPageResourceCompletionOwner::child_module_fetch(
+ root_document,
+ current_target,
+ );
+ let activity_epoch_before = page_vm.vm().subresource_activity_epoch();
+ let mut queue = RendererPageNetworkingSource::new_for_test();
+ queue.enqueue_local_for_test(
+ RendererPageResourceCompletion::child_parser_module_root_fetch(
+ root_document,
+ root_completion,
+ ),
+ );
+ queue.enqueue_local_for_test(
+ RendererPageResourceCompletion::child_module_dependency_fetch(
+ root_document,
+ dependency_completion,
+ ),
+ );
+ queue.enqueue_local_for_test(
+ RendererPageResourceCompletion::child_modulepreload_fetch(
+ root_document,
+ modulepreload_completion,
+ ),
+ );
+
+ let root_outcome = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)?
+ .expect("retired-realm terminal should consume exactly one owner turn");
+ assert_eq!(root_outcome.action.owner, expected_owner);
+ assert_eq!(
+ root_outcome.action.document_effect,
+ PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
+ current_owner: Some(expected_current_owner),
+ }
+ );
+ assert_eq!(
+ root_outcome.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ let dependency_outcome = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)?
+ .expect("retired-realm dependency must consume a second owner turn");
+ assert_eq!(dependency_outcome.action.owner, expected_owner);
+ assert_eq!(
+ dependency_outcome.action.document_effect,
+ PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
+ current_owner: Some(expected_current_owner),
+ }
+ );
+ assert_eq!(
+ dependency_outcome.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ let modulepreload_outcome = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)?
+ .expect("retired-realm modulepreload must consume a third owner turn");
+ assert_eq!(modulepreload_outcome.action.owner, expected_owner);
+ assert_eq!(
+ modulepreload_outcome.action.document_effect,
+ PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
+ current_owner: Some(expected_current_owner),
+ }
+ );
+ assert_eq!(
+ modulepreload_outcome.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ assert_eq!(
+ page_vm.vm().subresource_activity_epoch(),
+ activity_epoch_before,
+ "historical Network output from a retired realm must not become current Document activity"
+ );
+
+ let (network_records, websocket_events, websocket_lifecycle_events) =
+ split_network_output_items(page_vm.vm_mut().take_network_output());
+ assert!(websocket_events.is_empty());
+ assert!(websocket_lifecycle_events.is_empty());
+ assert_eq!(network_records.len(), 3);
+ assert_eq!(
+ network_records[0].frame_id(),
+ Some("stale-child-module-root-realm-frame")
+ );
+ assert_eq!(
+ network_records[0].outcome(),
+ &SubresourceNetworkOutcome::Failure {
+ error_text: "retired child realm root fetch failed".to_owned(),
+ }
+ );
+ assert_eq!(
+ network_records[1].frame_id(),
+ Some("stale-child-module-dependency-realm-frame")
+ );
+ assert_eq!(
+ network_records[1].outcome(),
+ &SubresourceNetworkOutcome::Failure {
+ error_text: "retired child realm dependency fetch failed".to_owned(),
+ }
+ );
+ assert_eq!(
+ network_records[2].frame_id(),
+ Some("stale-child-modulepreload-realm-frame")
+ );
+ assert_eq!(
+ network_records[2].outcome(),
+ &SubresourceNetworkOutcome::Failure {
+ error_text: "retired child realm modulepreload failed".to_owned(),
+ }
+ );
+ Ok::<_, anyhow::Error>(())
+ })
+ .await
+ .expect("same-Document stale child realm test should run");
+}
+#[tokio::test(flavor = "current_thread")]
+async fn production_child_module_route_reaches_exact_realm_page_turn() {
+ run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm();
+ page_vm.vm_mut().eval(
+ "const productionModuleFrame = document.createElement('iframe'); \
+ productionModuleFrame.id = 'production-module-frame'; \
+ document.body.appendChild(productionModuleFrame);",
+ )?;
+ let child_handle = page_vm
+ .vm()
+ .element_handle_by_id_for_test("production-module-frame")
+ .expect("production route fixture should install a child handle");
+ materialize_child_realm_through_page_turn_for_test(
+ &mut page_vm,
+ "production-module-frame",
+ )?;
+ let target = page_vm
+ .vm()
+ .current_child_document_module_fetch_target(child_handle)
+ .expect("production route fixture should expose an exact module target");
+ let root_document = page_vm.document_lifecycle.identity().document;
+
+ let (wake_tx, mut wake_rx) = tokio::sync::mpsc::unbounded_channel();
+ let token = crate::runtime::RendererPageToken::new_for_testing(root_document.page_id);
+ let owner_wake = crate::page_task_queue::RendererOwnerWakeSender::new(wake_tx, token);
+ let mut page_queue = RendererPageNetworkingSource::new_owner_attached(
+ crate::page_task_queue::PageRuntimeWakeSignal::default(),
+ owner_wake.clone(),
+ );
+ let sender =
+ crate::page_task_queue::RendererResourceCompletionSender::for_page_resource_test(
+ page_queue.sender(),
+ root_document,
+ );
+ let activity_epoch_before = page_vm.vm().subresource_activity_epoch();
+ sender
+ .send_child_parser_module_root_fetch(
+ test_child_parser_module_root_completion_for_target(
+ target,
+ 67,
+ "production-child-module-route",
+ Some("production routed module fetch failed"),
+ ),
+ )
+ .expect("production sender should enqueue the typed child module terminal");
+
+ assert_eq!(
+ wake_rx
+ .try_recv()
+ .expect("accepted production terminal should publish one Page wake")
+ .page_id(),
+ root_document.page_id
+ );
+ assert!(
+ wake_rx.try_recv().is_err(),
+ "one accepted terminal must not publish a duplicate wake"
+ );
+
+ let outcome = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_queue)?
+ .expect("production-routed terminal should execute through the typed Page turn");
+ assert_eq!(
+ outcome.action.owner,
+ RendererPageResourceCompletionOwner::child_module_fetch(root_document, target)
+ );
+ assert_eq!(
+ outcome.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ outcome.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ assert!(!page_queue.has_ready_completion());
+ assert!(
+ page_vm.vm().subresource_activity_epoch() > activity_epoch_before,
+ "current-target Network output must be attributed to current Document activity"
+ );
+
+ let (network_records, websocket_events, websocket_lifecycle_events) =
+ split_network_output_items(page_vm.vm_mut().take_network_output());
+ assert!(websocket_events.is_empty());
+ assert!(websocket_lifecycle_events.is_empty());
+ assert_eq!(network_records.len(), 1);
+ assert_eq!(
+ network_records[0].frame_id(),
+ Some("production-child-module-route-frame")
+ );
+ Ok::<_, anyhow::Error>(())
+ })
+ .await
+ .expect("production child module stable-route test should run");
+}
+#[tokio::test]
+async fn page_vm_child_module_defer_preserves_document_order_when_second_graph_finishes_first() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_concurrent_path_response_http_server(vec![
+ (
+ "/first-module-defer.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childModuleDeferOrderEvents.push("first-module:" + (globalThis === self));
+globalThis.__childModuleDeferOrderFirst = 1;
+"#
+ .to_owned(),
+ Duration::from_millis(350),
+ ),
+ (
+ "/second-module-defer.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childModuleDeferOrderEvents.push("second-module:" + (globalThis === self));
+globalThis.__childModuleDeferOrderSecond = 2;
+"#
+ .to_owned(),
+ Duration::ZERO,
+ ),
+ ])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ second_completion,
+ events_after_second_completion,
+ events_after_second_module_owner,
+ first_completion,
+ events_after_first_completion,
+ bootstrap_sources,
+ events_after_first_module_owner,
+ followup_sources,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let first_script_url = format!("{base_url}/first-module-defer.js");
+ let second_script_url = format!("{base_url}/second-module-defer.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childModuleDeferOrderEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childModuleDeferOrderEvents.push("load");
+ frame.srcdoc = `
+ <script>parent.__childModuleDeferOrderEvents.push("before:" + (globalThis === self));<\/script>
+ <script id="first-module-defer" type="module" src="{first_script_url}"><\/script>
+ <script id="second-module-defer" type="module" src="{second_script_url}"><\/script>
+ <script>
+ document.getElementById("first-module-defer").addEventListener("load", () => {{
+ parent.__childModuleDeferOrderEvents.push("first-load");
+ }});
+ document.getElementById("second-module-defer").addEventListener("load", () => {{
+ parent.__childModuleDeferOrderEvents.push("second-load");
+ }});
+ parent.__childModuleDeferOrderEvents.push(
+ "after:" + String(globalThis.__childModuleDeferOrderFirst) + ":" +
+ String(globalThis.__childModuleDeferOrderSecond)
+ );
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let mut bootstrap_sources = Vec::new();
+ let mut bootstrap_events = String::new();
+ for _ in 0..10 {
+ let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
+ break;
+ };
+ bootstrap_sources.push(source);
+ bootstrap_events = page_vm
+ .vm_mut()
+ .eval("__childModuleDeferOrderEvents.join('|')")?;
+ if bootstrap_sources
+ .iter()
+ .filter(|source| **source == ChildFrameSemanticTurnKind::ParserModuleRootStart)
+ .count()
+ == 2
+ && bootstrap_sources
+ .contains(&ChildFrameSemanticTurnKind::DocumentLifecycle)
+ && bootstrap_events == "before:true|after:undefined:undefined"
+ {
+ break;
+ }
+ }
+ assert_eq!(
+ bootstrap_events,
+ "before:true|after:undefined:undefined",
+ "child parser should continue past both parser module-defer scripts without evaluating them"
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("second child module-defer completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child module-defer completion sender should remain open"
+ );
+ }
+ let second_completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let events_after_second_completion = page_vm
+ .vm_mut()
+ .eval("__childModuleDeferOrderEvents.join('|')")?;
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "later child module-defer terminal",
+ )
+ .await;
+ let events_after_second_module_owner = page_vm
+ .vm_mut()
+ .eval("__childModuleDeferOrderEvents.join('|')")?;
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("first child module-defer completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child module-defer completion sender should remain open"
+ );
+ }
+ let first_completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let events_after_first_completion = page_vm
+ .vm_mut()
+ .eval("__childModuleDeferOrderEvents.join('|')")?;
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "earlier child module-defer terminal",
+ )
+ .await;
+ let events_after_first_module_owner = page_vm
+ .vm_mut()
+ .eval("__childModuleDeferOrderEvents.join('|')")?;
+
+ let mut followup_sources = Vec::new();
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "first child module-defer execution",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childModuleDeferOrderEvents.join('|')")?,
+ "before:true|after:undefined:undefined|first-module:true|first-load",
+ "first ordered DocumentScriptReady should execute the earlier module-defer without second module or iframe load"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "second child module-defer execution",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childModuleDeferOrderEvents.join('|')")?,
+ "before:true|after:undefined:undefined|first-module:true|first-load|second-module:true|second-load",
+ "second ordered DocumentScriptReady should run only after the earlier module-defer completes"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "ordered child module-defer DOMContentLoaded transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "ordered child module-defer complete transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "ordered child module-defer iframe load",
+ )
+ .await,
+ );
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childModuleDeferOrderEvents.join('|')")?;
+ assert_eq!(
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ None,
+ "child module-defer ordering sequence should not leave extra child frame task work"
+ );
+
+ Ok::<_, anyhow::Error>((
+ second_completion,
+ events_after_second_completion,
+ events_after_second_module_owner,
+ first_completion,
+ events_after_first_completion,
+ bootstrap_sources,
+ events_after_first_module_owner,
+ followup_sources,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child module-defer ordering test should run");
+
+ assert!(matches!(
+ second_completion.action.source(),
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ ));
+ assert_eq!(
+ bootstrap_sources
+ .iter()
+ .filter(|source| **source == ChildFrameSemanticTurnKind::ParserModuleRootStart)
+ .count(),
+ 2,
+ "child module-defer ordering bootstrap should start both parser-module roots explicitly: {bootstrap_sources:?}"
+ );
+ assert_eq!(
+ events_after_second_completion, "before:true|after:undefined:undefined",
+ "faster second module graph completion must not evaluate before earlier parser module"
+ );
+ assert_eq!(
+ events_after_second_module_owner, "before:true|after:undefined:undefined",
+ "later terminal source must only retain the terminal behind the earlier parser module"
+ );
+ assert!(matches!(
+ first_completion.action.source(),
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ ));
+ assert_eq!(
+ events_after_first_completion, "before:true|after:undefined:undefined",
+ "first module graph completion turn should still not inline-run script"
+ );
+ assert_eq!(
+ events_after_first_module_owner, "before:true|after:undefined:undefined",
+ "ModuleScriptTerminal should only enqueue ordered document-script work"
+ );
+ assert_eq!(
+ followup_sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::HostLoad
+ ],
+ "ordered child module-defer scripts should execute through two script-ready turns, DOMContentLoaded, and complete before HostLoad"
+ );
+ assert_eq!(
+ final_events,
+ "before:true|after:undefined:undefined|first-module:true|first-load|second-module:true|second-load|load",
+ "module-defer scripts should execute in document order even when the second graph finishes first"
+ );
+
+ server
+ .await
+ .expect("child module-defer ordering server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_module_defer_retains_later_graph_failure_behind_earlier_graph() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_concurrent_path_response_http_server(vec![
+ (
+ "/first-module-defer-success.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childModuleDeferFailureOrderEvents.push("first-module:" + (globalThis === self));
+globalThis.__childModuleDeferFailureOrderFirst = 1;
+"#
+ .to_owned(),
+ Duration::from_millis(350),
+ ),
+ (
+ "/second-module-defer-failure.js",
+ "HTTP/1.1 200 OK",
+ "import {".to_owned(),
+ Duration::ZERO,
+ ),
+ ])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ second_completion,
+ events_after_second_completion,
+ events_after_second_module_owner,
+ source_after_second_module_owner,
+ events_after_blocked_second_terminal,
+ first_completion,
+ events_after_first_completion,
+ bootstrap_sources,
+ events_after_first_module_owner,
+ followup_sources,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let first_script_url = format!("{base_url}/first-module-defer-success.js");
+ let second_script_url = format!("{base_url}/second-module-defer-failure.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childModuleDeferFailureOrderEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childModuleDeferFailureOrderEvents.push("load");
+ frame.srcdoc = `
+ <script>parent.__childModuleDeferFailureOrderEvents.push("before:" + (globalThis === self));<\/script>
+ <script id="first-module-defer-success" type="module" src="{first_script_url}"><\/script>
+ <script id="second-module-defer-failure" type="module" src="{second_script_url}"><\/script>
+ <script>
+ document.getElementById("first-module-defer-success").addEventListener("load", () => {{
+ parent.__childModuleDeferFailureOrderEvents.push("first-load");
+ }});
+ document.getElementById("first-module-defer-success").addEventListener("error", () => {{
+ parent.__childModuleDeferFailureOrderEvents.push("first-error");
+ }});
+ document.getElementById("second-module-defer-failure").addEventListener("load", () => {{
+ parent.__childModuleDeferFailureOrderEvents.push("second-load");
+ }});
+ document.getElementById("second-module-defer-failure").addEventListener("error", () => {{
+ parent.__childModuleDeferFailureOrderEvents.push("second-error");
+ }});
+ parent.__childModuleDeferFailureOrderEvents.push(
+ "after:" + String(globalThis.__childModuleDeferFailureOrderFirst)
+ );
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let mut bootstrap_sources = Vec::new();
+ let mut bootstrap_events = String::new();
+ for _ in 0..10 {
+ let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
+ break;
+ };
+ bootstrap_sources.push(source);
+ bootstrap_events = page_vm
+ .vm_mut()
+ .eval("__childModuleDeferFailureOrderEvents.join('|')")?;
+ if bootstrap_sources
+ .iter()
+ .filter(|source| **source == ChildFrameSemanticTurnKind::ParserModuleRootStart)
+ .count()
+ == 2
+ && bootstrap_sources
+ .contains(&ChildFrameSemanticTurnKind::DocumentLifecycle)
+ && bootstrap_events == "before:true|after:undefined"
+ {
+ break;
+ }
+ }
+ assert_eq!(
+ bootstrap_events, "before:true|after:undefined",
+ "child parser should continue past success/failure module-defer siblings without evaluating them"
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("second child module-defer failure should arrive before timeout");
+ assert!(
+ arrived,
+ "child module-defer completion sender should remain open"
+ );
+ }
+ let second_completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let events_after_second_completion = page_vm
+ .vm_mut()
+ .eval("__childModuleDeferFailureOrderEvents.join('|')")?;
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "later failing child module-defer terminal",
+ )
+ .await;
+ let events_after_second_module_owner = page_vm
+ .vm_mut()
+ .eval("__childModuleDeferFailureOrderEvents.join('|')")?;
+ let source_after_second_module_owner =
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_blocked_second_terminal = page_vm
+ .vm_mut()
+ .eval("__childModuleDeferFailureOrderEvents.join('|')")?;
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("first child module-defer success should arrive before timeout");
+ assert!(
+ arrived,
+ "child module-defer completion sender should remain open"
+ );
+ }
+ let first_completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let events_after_first_completion = page_vm
+ .vm_mut()
+ .eval("__childModuleDeferFailureOrderEvents.join('|')")?;
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "earlier successful child module-defer terminal",
+ )
+ .await;
+ let events_after_first_module_owner = page_vm
+ .vm_mut()
+ .eval("__childModuleDeferFailureOrderEvents.join('|')")?;
+
+ let mut followup_sources = Vec::new();
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "first successful child module-defer execution",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childModuleDeferFailureOrderEvents.join('|')")?,
+ "before:true|after:undefined|first-module:true|first-load",
+ "first ordered DocumentScriptReady should execute the earlier successful module before later error dispatch"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "second failing child module-defer dispatch",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childModuleDeferFailureOrderEvents.join('|')")?,
+ "before:true|after:undefined|first-module:true|first-load|second-error",
+ "later graph failure should dispatch only after the earlier module-defer completes"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "ordered child module-defer graph-failure DOMContentLoaded transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "ordered child module-defer graph-failure complete transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "ordered child module-defer graph-failure iframe load",
+ )
+ .await,
+ );
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childModuleDeferFailureOrderEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ second_completion,
+ events_after_second_completion,
+ events_after_second_module_owner,
+ source_after_second_module_owner,
+ events_after_blocked_second_terminal,
+ first_completion,
+ events_after_first_completion,
+ bootstrap_sources,
+ events_after_first_module_owner,
+ followup_sources,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child module-defer graph-failure ordering test should run");
+
+ assert!(matches!(
+ second_completion.action.source(),
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ ));
+ assert_eq!(
+ bootstrap_sources
+ .iter()
+ .filter(|source| **source == ChildFrameSemanticTurnKind::ParserModuleRootStart)
+ .count(),
+ 2,
+ "child module-defer failure ordering bootstrap should start both roots explicitly: {bootstrap_sources:?}"
+ );
+ assert_eq!(
+ events_after_second_completion, "before:true|after:undefined",
+ "faster second graph failure completion must not dispatch script error before earlier parser module"
+ );
+ assert_eq!(
+ events_after_second_module_owner, "before:true|after:undefined",
+ "later graph failure terminal must be retained behind the earlier parser module"
+ );
+ assert_eq!(
+ source_after_second_module_owner, None,
+ "retained later graph failure should not wake DocumentScriptReady before the earlier graph finishes"
+ );
+ assert_eq!(
+ events_after_blocked_second_terminal, "before:true|after:undefined",
+ "blocked later graph failure should not dispatch script error or iframe load"
+ );
+ assert!(matches!(
+ first_completion.action.source(),
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ ));
+ assert_eq!(
+ events_after_first_completion, "before:true|after:undefined",
+ "first graph completion turn should not inline-run script"
+ );
+ assert_eq!(
+ events_after_first_module_owner, "before:true|after:undefined",
+ "ModuleScriptTerminal should only enqueue ordered document-script work"
+ );
+ assert_eq!(
+ followup_sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::HostLoad
+ ],
+ "ordered child module-defer success/failure should finish through ready turns, DOMContentLoaded, and complete before HostLoad"
+ );
+ assert_eq!(
+ final_events,
+ "before:true|after:undefined|first-module:true|first-load|second-error|load",
+ "later graph failure should preserve parser module document order and keep iframe load on HostLoad"
+ );
+
+ server
+ .await
+ .expect("child module-defer graph-failure ordering server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_parser_module_root_completion_queues_module_script_terminal_work() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-parser-module.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childParserModuleWaitEvents.push("module:" + (globalThis === self));
+globalThis.__childParserModuleWaitValue = 188;
+"#
+ .to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let (owner_wake_tx, owner_wake_rx) = tokio::sync::mpsc::unbounded_channel();
+ let owner_wake = crate::page_task_queue::RendererOwnerWakeSender::new(
+ owner_wake_tx,
+ crate::runtime::RendererPageToken::new_for_testing(crate::PageId::new_for_testing(1)),
+ );
+ let runtime_hooks =
+ PageVmRuntimeHooks::standalone_with_owner_wake_without_owner_reservation_for_test(
+ owner_wake,
+ );
+ let page_vm = test_page_vm_with_loader_document_url_and_hooks(
+ &loader,
+ Vec::new(),
+ document_url,
+ runtime_hooks,
+ );
+ let page_resource_queue = page_vm.page_resource_completion_queue();
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ first,
+ first_events,
+ bootstrap_sources,
+ events_after_module_owner,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let mut page_resource_queue = page_resource_queue;
+ let mut owner_wake_rx = owner_wake_rx;
+ let script_url = format!("{base_url}/child-parser-module.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childParserModuleWaitEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childParserModuleWaitEvents.push("frame-load");
+ frame.srcdoc = `
+ <script>
+ parent.__childParserModuleWaitEvents.push(
+ "before:" + (globalThis === self) + ":" + document.currentScript.isConnected
+ );
+ <\/script>
+ <script id="external-module" type="module" src="{script_url}"><\/script>
+ <script>
+ document.getElementById("external-module").addEventListener("load", () => {{
+ parent.__childParserModuleWaitEvents.push("script-load");
+ }});
+ parent.__childParserModuleWaitEvents.push(
+ "after:" + String(globalThis.__childParserModuleWaitValue)
+ );
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+ let mut bootstrap_sources = Vec::new();
+ let mut bootstrap_events = String::new();
+ for _ in 0..8 {
+ let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
+ break;
+ };
+ bootstrap_sources.push(source);
+ bootstrap_events = page_vm
+ .vm_mut()
+ .eval("__childParserModuleWaitEvents.join('|')")?;
+ if bootstrap_sources
+ .contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart)
+ && bootstrap_sources
+ .iter()
+ .filter(|source| {
+ **source == ChildFrameSemanticTurnKind::DocumentScriptReady
+ })
+ .count()
+ == 2
+ && bootstrap_sources
+ .contains(&ChildFrameSemanticTurnKind::DocumentLifecycle)
+ && bootstrap_events == "before:true:true|after:undefined"
+ {
+ break;
+ }
+ }
+ assert_eq!(
+ bootstrap_events,
+ "before:true:true|after:undefined",
+ "parser should continue past child module-defer script while root fetch is pending; sources={bootstrap_sources:?}"
+ );
+
+ if !page_resource_queue.has_ready_completion() {
+ tokio::time::timeout(Duration::from_secs(2), async {
+ while !page_resource_queue.has_ready_completion() {
+ owner_wake_rx
+ .recv()
+ .await
+ .expect("owner wake route should remain open");
+ }
+ })
+ .await
+ .expect("child parser module completion should arrive before timeout");
+ }
+
+ let _ = page_vm.vm_mut().take_network_output();
+ let activity_epoch_before_completion =
+ page_vm.vm().subresource_activity_epoch();
+ let first = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_resource_queue)?
+ .expect("production child module completion should consume one typed turn");
+ assert!(
+ !page_resource_queue.has_ready_completion(),
+ "the production root terminal must be consumed exactly once"
+ );
+ assert_eq!(
+ first.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ first.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ assert!(
+ page_vm.vm().subresource_activity_epoch()
+ > activity_epoch_before_completion,
+ "a current child module Network terminal must advance current Document activity"
+ );
+ let (network_records, websocket_events, websocket_lifecycle_events) =
+ split_network_output_items(page_vm.vm_mut().take_network_output());
+ assert!(websocket_events.is_empty());
+ assert!(websocket_lifecycle_events.is_empty());
+ assert_eq!(network_records.len(), 1);
+ let network_record = &network_records[0];
+ assert!(
+ network_record.frame_id().is_some(),
+ "producer must retain the child frame attribution"
+ );
+ assert_eq!(network_record.document_url().as_str(), "about:srcdoc");
+ assert_eq!(network_record.url().as_str(), script_url);
+ assert_eq!(
+ network_record.request_initiator_type(),
+ SubresourceRequestInitiatorType::Parser
+ );
+ let first_events = page_vm
+ .vm_mut()
+ .eval("__childParserModuleWaitEvents.join('|')")?;
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "child parser-module root terminal",
+ )
+ .await;
+ let events_after_module_owner = page_vm
+ .vm_mut()
+ .eval("__childParserModuleWaitEvents.join('|')")?;
+ let script_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_script_ready = page_vm
+ .vm_mut()
+ .eval("__childParserModuleWaitEvents.join('|')")?;
+ let host_load_source = Some(
+ run_child_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "child parser-module iframe load",
+ )
+ .await,
+ );
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childParserModuleWaitEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ first,
+ first_events,
+ bootstrap_sources,
+ events_after_module_owner,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child parser module deferred completion test should run");
+
+ assert!(matches!(
+ first.action.source(),
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ ));
+ assert_eq!(
+ first_events, "before:true:true|after:undefined",
+ "resource completion turn should not inline-run child parser module graph"
+ );
+ assert_eq!(
+ bootstrap_sources,
+ vec![
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ ChildFrameSemanticTurnKind::RealmMaterialization,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::ParserModuleRootStart,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle
+ ],
+ "the typed root fetch-start must preserve parser discovery FIFO, then the parser should run the following inline script and reach interactive"
+ );
+ assert_eq!(
+ events_after_module_owner, "before:true:true|after:undefined",
+ "ModuleScriptTerminal should not execute the module-defer script inline"
+ );
+ assert_eq!(
+ script_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "module-defer graph-ready work should execute through DocumentScriptReady"
+ );
+ assert_eq!(
+ events_after_script_ready,
+ "before:true:true|after:undefined|module:true|script-load",
+ "DocumentScriptReady should run the module-defer script and dispatch its script load without iframe load"
+ );
+ assert_eq!(
+ host_load_source,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "iframe load should remain a later HostLoad source after module-defer execution"
+ );
+ assert_eq!(
+ final_events,
+ "before:true:true|after:undefined|module:true|script-load|frame-load",
+ "HostLoad should dispatch iframe load only after module-defer execution completes"
+ );
+
+ server
+ .await
+ .expect("child parser module wait-path server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_module_script_blocks_host_load_until_evaluation_finishes() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-load-module.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childModuleHostLoadEvents.push("module:" + (globalThis === self));
+globalThis.__childModuleHostLoadValue = 203;
+"#
+ .to_owned(),
+ Duration::from_millis(200),
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ initial_host_load_before_root_fetch,
+ navigation_commit_source,
+ first_document_script_ready_before_root_fetch,
+ host_load_attempt_before_root_fetch,
+ events_after_pre_root_host_load_attempt,
+ pre_completion_sources,
+ events_before_completion,
+ resource_ready_before_wait,
+ completion_source,
+ events_after_module_owner,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let script_url = format!("{base_url}/child-load-module.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childModuleHostLoadEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childModuleHostLoadEvents.push("frame-load");
+ frame.srcdoc = `
+ <script>parent.__childModuleHostLoadEvents.push("before:" + (globalThis === self));<\/script>
+ <script id="load-module" type="module" src="{script_url}"><\/script>
+ <script>
+ document.getElementById("load-module").addEventListener("load", () => {{
+ parent.__childModuleHostLoadEvents.push("script-load");
+ }});
+ parent.__childModuleHostLoadEvents.push(
+ "after:" + String(globalThis.__childModuleHostLoadValue)
+ );
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let initial_host_load_before_root_fetch = page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ChildHostLoad,
+ &loader,
+ )
+ .await?;
+ let navigation_commit_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ run_expected_child_realm_materialization_for_wait(
+ &mut page_vm,
+ "child parser-module exact realm",
+ )
+ .await;
+ let first_document_script_ready_before_root_fetch =
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await
+ == Some(ChildFrameSemanticTurnKind::DocumentScriptReady);
+ let host_load_attempt_before_root_fetch = page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ChildHostLoad,
+ &loader,
+ )
+ .await?;
+ let events_after_pre_root_host_load_attempt = page_vm
+ .vm_mut()
+ .eval("__childModuleHostLoadEvents.join('|')")?;
+
+ let mut pre_completion_sources = Vec::new();
+ let mut events_before_completion = String::new();
+ for _ in 0..8 {
+ let source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ events_before_completion = page_vm
+ .vm_mut()
+ .eval("__childModuleHostLoadEvents.join('|')")?;
+ if let Some(source) = source {
+ pre_completion_sources.push(source);
+ }
+ if source.is_none()
+ || page_vm.has_ready_page_websocket_task_for_test()
+ || events_before_completion.contains("frame-load")
+ {
+ break;
+ }
+ }
+ let resource_ready_before_wait = page_vm
+ .page_resource_completion_queue()
+ .has_ready_completion();
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child module completion should arrive before timeout");
+ assert!(arrived, "child module completion sender should remain open");
+ }
+
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let completion_source = completion.action.source();
+
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "child module HostLoad-gate terminal",
+ )
+ .await;
+ let events_after_module_owner = page_vm
+ .vm_mut()
+ .eval("__childModuleHostLoadEvents.join('|')")?;
+ let script_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_script_ready = page_vm
+ .vm_mut()
+ .eval("__childModuleHostLoadEvents.join('|')")?;
+
+ let host_load_source = Some(
+ run_child_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "child module iframe load",
+ )
+ .await,
+ );
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childModuleHostLoadEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ initial_host_load_before_root_fetch,
+ navigation_commit_source,
+ first_document_script_ready_before_root_fetch,
+ host_load_attempt_before_root_fetch,
+ events_after_pre_root_host_load_attempt,
+ pre_completion_sources,
+ events_before_completion,
+ resource_ready_before_wait,
+ completion_source,
+ events_after_module_owner,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child module HostLoad gate test should run");
+
+ assert!(
+ !initial_host_load_before_root_fetch,
+ "HostLoad source should not progress while initial document-script ready work is pending"
+ );
+ assert_eq!(
+ navigation_commit_source,
+ Some(ChildFrameSemanticTurnKind::NavigationCommit),
+ "child navigation must install the active Document before its parser-script turns"
+ );
+ assert!(
+ first_document_script_ready_before_root_fetch,
+ "the initial child DocumentScriptReady turn should enqueue parser-module root fetch work"
+ );
+ assert!(
+ !host_load_attempt_before_root_fetch,
+ "HostLoad source should make no progress while parser-module root fetch work is still queued"
+ );
+ assert!(
+ !events_after_pre_root_host_load_attempt.contains("frame-load"),
+ "queued parser-module root fetch work must block iframe load before source priority runs it"
+ );
+ assert!(
+ pre_completion_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
+ "pre-completion turns should start the module root fetch from its typed source: {pre_completion_sources:?}"
+ );
+ assert!(
+ !pre_completion_sources.contains(&ChildFrameSemanticTurnKind::HostLoad),
+ "blocked bootstrap HostLoad should not re-ready itself before module source completion: {pre_completion_sources:?}"
+ );
+ assert!(
+ !resource_ready_before_wait,
+ "delayed module response should leave a window to prove HostLoad is gated before completion"
+ );
+ assert_eq!(
+ events_before_completion, "before:true|after:undefined",
+ "pending module script must block iframe load before resource completion"
+ );
+ assert_eq!(
+ completion_source,
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ );
+ assert_eq!(
+ events_after_module_owner, "before:true|after:undefined",
+ "ModuleScriptTerminal should not execute the module or dispatch iframe load inline"
+ );
+ assert_eq!(
+ script_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "module graph-ready work should execute through DocumentScriptReady"
+ );
+ assert_eq!(
+ events_after_script_ready,
+ "before:true|after:undefined|module:true|script-load",
+ "module evaluation should dispatch script load but not iframe load inline"
+ );
+ assert_eq!(
+ host_load_source,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "iframe load should remain a later HostLoad source"
+ );
+ assert_eq!(
+ final_events,
+ "before:true|after:undefined|module:true|script-load|frame-load",
+ "HostLoad should dispatch iframe load only after module evaluation finishes"
+ );
+
+ server
+ .await
+ .expect("child module HostLoad gate server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_module_tla_releases_lifecycle_after_evaluation_starts() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-tla-module.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childModuleTlaHostLoadEvents.push("module-start:" + (globalThis === self));
+await new Promise(resolve => {
+ parent.__resolveChildModuleTlaHostLoad = resolve;
+ parent.__childModuleTlaHostLoadEvents.push("module-pending");
+});
+globalThis.__childModuleTlaHostLoadValue = 409;
+parent.__childModuleTlaHostLoadEvents.push("module-after");
+"#
+ .to_owned(),
+ Duration::from_millis(200),
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ pre_completion_sources,
+ events_before_completion,
+ resource_ready_before_wait,
+ completion_source,
+ events_after_module_owner,
+ graph_ready_source,
+ events_after_pending_evaluation,
+ host_load_source_while_tla_pending,
+ events_after_host_load,
+ parent_completion_recheck_source,
+ events_after_module_reaction,
+ evaluation_completion_source,
+ final_events,
+ ) = local_executor
+ // Keep this large, stateful scenario off nextest's comparatively
+ // small test-thread stack; pinning does not add a scheduler turn.
+ .run(Box::pin(async move {
+ let mut page_vm = page_vm;
+ let script_url = format!("{base_url}/child-tla-module.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childModuleTlaHostLoadEvents = [];
+ delete globalThis.__resolveChildModuleTlaHostLoad;
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childModuleTlaHostLoadEvents.push("frame-load");
+ frame.srcdoc = `
+ <script>parent.__childModuleTlaHostLoadEvents.push("before:" + (globalThis === self));<\/script>
+ <script id="tla-module" type="module" src="{script_url}"><\/script>
+ <script>
+ document.getElementById("tla-module").addEventListener("load", () => {{
+ parent.__childModuleTlaHostLoadEvents.push("script-load");
+ }});
+ document.getElementById("tla-module").addEventListener("error", () => {{
+ parent.__childModuleTlaHostLoadEvents.push("script-error");
+ }});
+ parent.__childModuleTlaHostLoadEvents.push(
+ "after:" + String(globalThis.__childModuleTlaHostLoadValue)
+ );
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let mut pre_completion_sources = Vec::new();
+ let mut events_before_completion = String::new();
+ for _ in 0..8 {
+ let source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ events_before_completion = page_vm
+ .vm_mut()
+ .eval("__childModuleTlaHostLoadEvents.join('|')")?;
+ if let Some(source) = source {
+ pre_completion_sources.push(source);
+ }
+ if source.is_none()
+ || page_vm.has_ready_page_websocket_task_for_test()
+ || events_before_completion.contains("frame-load")
+ {
+ break;
+ }
+ }
+ let resource_ready_before_wait = page_vm
+ .page_resource_completion_queue()
+ .has_ready_completion();
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child TLA module completion should arrive before timeout");
+ assert!(arrived, "child TLA module completion sender should remain open");
+ }
+
+ let loader = page_vm.main_document_resource_loader();
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let completion_source = completion.action.source();
+
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "child TLA module terminal",
+ )
+ .await;
+ let events_after_module_owner = page_vm
+ .vm_mut()
+ .eval("__childModuleTlaHostLoadEvents.join('|')")?;
+ let graph_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_pending_evaluation = page_vm
+ .vm_mut()
+ .eval("__childModuleTlaHostLoadEvents.join('|')")?;
+
+ let host_load_source_while_tla_pending = Some(
+ run_child_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "child module TLA iframe load",
+ )
+ .await,
+ );
+ let events_after_host_load = page_vm
+ .vm_mut()
+ .eval("__childModuleTlaHostLoadEvents.join('|')")?;
+ let parent_completion_recheck = page_vm
+ .run_page_main_document_runtime_body_for_test(loader.request_client())
+ .await?
+ .expect("child HostLoad must publish one typed parent completion recheck");
+
+ page_vm
+ .vm_mut()
+ .eval("__resolveChildModuleTlaHostLoad(); 'ok'")?;
+ assert!(
+ page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ModuleReaction,
+ loader.request_client(),
+ )
+ .await?,
+ "resolved child TLA should enqueue one typed module reaction"
+ );
+ let events_after_module_reaction = page_vm
+ .vm_mut()
+ .eval("__childModuleTlaHostLoadEvents.join('|')")?;
+
+ let evaluation_completion_source =
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childModuleTlaHostLoadEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ pre_completion_sources,
+ events_before_completion,
+ resource_ready_before_wait,
+ completion_source,
+ events_after_module_owner,
+ graph_ready_source,
+ events_after_pending_evaluation,
+ host_load_source_while_tla_pending,
+ events_after_host_load,
+ parent_completion_recheck.action,
+ events_after_module_reaction,
+ evaluation_completion_source,
+ final_events,
+ ))
+ }))
+ .await
+ .expect("page vm child TLA module HostLoad gate test should run");
+
+ assert!(
+ pre_completion_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
+ "pre-completion turns should start the module root fetch from its typed source: {pre_completion_sources:?}"
+ );
+ assert!(
+ !resource_ready_before_wait,
+ "delayed TLA module response should leave a window to prove HostLoad is gated before completion"
+ );
+ assert_eq!(
+ events_before_completion, "before:true|after:undefined",
+ "pending TLA module script must block iframe load before resource completion"
+ );
+ assert_eq!(
+ completion_source,
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ );
+ assert_eq!(
+ events_after_module_owner, "before:true|after:undefined",
+ "ModuleScriptTerminal should not start TLA evaluation or dispatch iframe load inline"
+ );
+ assert_eq!(
+ graph_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "module graph-ready work should start TLA evaluation through DocumentScriptReady"
+ );
+ assert_eq!(
+ events_after_pending_evaluation,
+ "before:true|after:undefined|module-start:true|module-pending|script-load",
+ "starting TLA should complete the static module script and dispatch its load event"
+ );
+ assert_eq!(
+ host_load_source_while_tla_pending,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "the evaluation promise must not keep the child lifecycle blocked"
+ );
+ assert_eq!(
+ events_after_host_load,
+ "before:true|after:undefined|module-start:true|module-pending|script-load|frame-load",
+ "iframe load should run after the static module execution turn while TLA remains pending"
+ );
+ assert_eq!(
+ parent_completion_recheck_source.kind(),
+ crate::page_task_queue::PageMainDocumentRuntimeActionKind::PostParseWork,
+ "child HostLoad completion should publish one concrete parent completion recheck task"
+ );
+ assert_eq!(
+ parent_completion_recheck_source.target_effect(),
+ crate::page_task_queue::PageMainDocumentRuntimeTargetEffect::AppliedToCurrentOwner,
+ "the exact parent completion recheck must apply through the main-Document arbiter"
+ );
+ assert_eq!(
+ events_after_module_reaction,
+ "before:true|after:undefined|module-start:true|module-pending|script-load|frame-load|module-after",
+ "module reaction should finish evaluation after document load without redispatching lifecycle events"
+ );
+ assert_eq!(
+ evaluation_completion_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "fulfilled TLA continuation should re-enter DocumentScriptReady"
+ );
+ assert_eq!(
+ final_events,
+ "before:true|after:undefined|module-start:true|module-pending|script-load|frame-load|module-after",
+ "TLA completion must not dispatch duplicate script or iframe load events"
+ );
+
+ server
+ .await
+ .expect("child TLA module HostLoad gate server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_dynamic_import_does_not_block_host_load() {
+ run_page_vm_async_test(async move {
+ #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+ enum PostLoadProgressSource {
+ TypedMainDocumentRuntime {
+ kind: crate::page_task_queue::PageMainDocumentRuntimeActionKind,
+ effect: crate::page_task_queue::PageMainDocumentRuntimeTargetEffect,
+ },
+ TypedDynamicImportOwnerAction,
+ }
+
+ let (base_url, server) = spawn_path_response_http_server(vec![
+ (
+ "/child-dynamic-root.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childDynamicImportHostLoadEvents.push("module-start:" + (globalThis === self));
+import("./child-dynamic-leaf.js").then(
+ () => parent.__childDynamicImportHostLoadEvents.push(
+ "dynamic-fulfilled:" + String(globalThis.__childDynamicImportLeafValue)
+ ),
+ () => parent.__childDynamicImportHostLoadEvents.push("dynamic-rejected")
+);
+parent.__childDynamicImportHostLoadEvents.push("module-after");
+"#
+ .to_owned(),
+ Duration::ZERO,
+ ),
+ (
+ "/child-dynamic-leaf.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childDynamicImportHostLoadEvents.push("dynamic-module:" + (globalThis === self));
+globalThis.__childDynamicImportLeafValue = 701;
+"#
+ .to_owned(),
+ Duration::from_millis(500),
+ ),
+ ])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let (owner_wake_tx, owner_wake_rx) = tokio::sync::mpsc::unbounded_channel();
+ let owner_wake = crate::page_task_queue::RendererOwnerWakeSender::new(
+ owner_wake_tx,
+ crate::runtime::RendererPageToken::new_for_testing(crate::PageId::new_for_testing(2)),
+ );
+ let runtime_hooks =
+ PageVmRuntimeHooks::standalone_with_owner_wake_without_owner_reservation_for_test(
+ owner_wake,
+ );
+ let page_vm = test_page_vm_with_loader_document_url_and_hooks(
+ &loader,
+ Vec::new(),
+ document_url,
+ runtime_hooks,
+ );
+ let page_resource_queue = page_vm.page_resource_completion_queue();
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ startup_sources,
+ events_before_completion,
+ completion_source,
+ events_after_module_terminal,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ events_after_host_load,
+ post_load_progress_sources,
+ events_after_dynamic_fetch_scheduled,
+ dynamic_fetch_completion_source,
+ host_load_pending_after_dynamic_fetch_completion,
+ dynamic_owner_action_applied,
+ events_after_dynamic_owner_action_body,
+ events_after_dynamic_owner_action,
+ host_load_pending_after_dynamic_owner_action,
+ ) = local_executor
+ // Keep this large, stateful scenario off nextest's comparatively
+ // small test-thread stack; pinning does not add a scheduler turn.
+ .run(Box::pin(async move {
+ let mut page_vm = page_vm;
+ let mut page_resource_queue = page_resource_queue;
+ let mut owner_wake_rx = owner_wake_rx;
+ let root_url = format!("{base_url}/child-dynamic-root.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childDynamicImportHostLoadEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childDynamicImportHostLoadEvents.push("frame-load");
+ frame.srcdoc = `
+ <base href="{base_url}/">
+ <script>parent.__childDynamicImportHostLoadEvents.push("before:" + (globalThis === self));<\/script>
+ <script id="dynamic-root" type="module" src="{root_url}"><\/script>
+ <script>
+ document.getElementById("dynamic-root").addEventListener("load", () => {{
+ parent.__childDynamicImportHostLoadEvents.push("script-load");
+ }});
+ document.getElementById("dynamic-root").addEventListener("error", () => {{
+ parent.__childDynamicImportHostLoadEvents.push("script-error");
+ }});
+ parent.__childDynamicImportHostLoadEvents.push(
+ "after:" + String(globalThis.__childDynamicImportLeafValue)
+ );
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let mut startup_sources = Vec::new();
+ for _ in 0..8 {
+ if page_resource_queue.has_ready_completion() {
+ break;
+ }
+ let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
+ break;
+ };
+ startup_sources.push(source);
+ }
+ let events_before_completion = page_vm
+ .vm_mut()
+ .eval("__childDynamicImportHostLoadEvents.join('|')")?;
+
+ if !page_resource_queue.has_ready_completion() {
+ tokio::time::timeout(Duration::from_secs(2), async {
+ while !page_resource_queue.has_ready_completion() {
+ owner_wake_rx
+ .recv()
+ .await
+ .expect("owner-attached dynamic-import route should remain open");
+ }
+ })
+ .await
+ .expect("child dynamic root completion should arrive before timeout");
+ }
+
+ let completion = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_resource_queue)?
+ .expect("typed child root completion should consume one Page turn");
+ let completion_source = completion.action.source();
+ let (root_network_records, root_websocket_events, root_websocket_lifecycle) =
+ split_network_output_items(page_vm.vm_mut().take_network_output());
+ assert!(root_websocket_events.is_empty());
+ assert!(root_websocket_lifecycle.is_empty());
+ assert_eq!(root_network_records.len(), 1);
+ assert_eq!(
+ root_network_records[0].request_initiator_type(),
+ SubresourceRequestInitiatorType::Parser
+ );
+
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "child dynamic import root terminal fanout",
+ )
+ .await;
+ let events_after_module_terminal = page_vm
+ .vm_mut()
+ .eval("__childDynamicImportHostLoadEvents.join('|')")?;
+
+ let script_ready_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "child dynamic import root module execution",
+ )
+ .await;
+ let events_after_script_ready = page_vm
+ .vm_mut()
+ .eval("__childDynamicImportHostLoadEvents.join('|')")?;
+
+ let host_load_source = run_child_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "child dynamic import iframe load before dynamic fetch",
+ )
+ .await;
+ let events_after_host_load = page_vm
+ .vm_mut()
+ .eval("__childDynamicImportHostLoadEvents.join('|')")?;
+
+ let mut post_load_progress_sources = Vec::new();
+ let mut events_after_dynamic_fetch_scheduled = String::new();
+ for _ in 0..8 {
+ if page_resource_queue.has_ready_completion() {
+ break;
+ }
+ if let Some(outcome) = page_vm
+ .run_page_main_document_runtime_body_for_test(&loader)
+ .await?
+ {
+ post_load_progress_sources.push(
+ PostLoadProgressSource::TypedMainDocumentRuntime {
+ kind: outcome.action.kind(),
+ effect: outcome.action.target_effect(),
+ },
+ );
+ events_after_dynamic_fetch_scheduled = page_vm
+ .vm_mut()
+ .eval("__childDynamicImportHostLoadEvents.join('|')")?;
+ continue;
+ }
+ if page_vm.page_task_executor_sources_for_test().dynamic_import_owner_action()
+ .has_ready_task()
+ {
+ let action = page_vm
+ .run_page_dynamic_import_owner_action_body_for_test()
+ .expect("typed dynamic-import owner action should win its Page turn");
+ let crate::page_task_queue::PageDynamicImportOwnerActionDocumentEffect::AppliedToCurrentOwner {
+ outcome,
+ } = action.action.document_effect
+ else {
+ panic!("current dynamic-import owner action must not be stale: {action:?}");
+ };
+ assert!(
+ outcome.waiting_fetch_was_scheduled(),
+ "the first typed owner action should schedule the dynamic fetch"
+ );
+ page_vm
+ .finish_selected_page_task_completion(
+ action.action.into_page_task_completion(),
+ &loader,
+ )
+ .await?;
+ post_load_progress_sources
+ .push(PostLoadProgressSource::TypedDynamicImportOwnerAction);
+ events_after_dynamic_fetch_scheduled = page_vm
+ .vm_mut()
+ .eval("__childDynamicImportHostLoadEvents.join('|')")?;
+ continue;
+ }
+ break;
+ }
+
+ if !page_resource_queue.has_ready_completion() {
+ tokio::time::timeout(Duration::from_secs(2), async {
+ while !page_resource_queue.has_ready_completion() {
+ owner_wake_rx.recv().await.expect(
+ "owner-attached dynamic-import completion route should remain open",
+ );
+ }
+ })
+ .await
+ .unwrap_or_else(|_| {
+ panic!(
+ "child dynamic import completion should arrive before timeout: progress={post_load_progress_sources:?} events={events_after_dynamic_fetch_scheduled}"
+ )
+ });
+ }
+ let activity_epoch_before_dynamic_completion =
+ page_vm.vm().subresource_activity_epoch();
+ let dynamic_fetch_completion = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_resource_queue)?
+ .expect("child dynamic import fetch completion should be ready");
+ assert_eq!(
+ dynamic_fetch_completion.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ dynamic_fetch_completion.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+ assert!(
+ page_vm.vm().subresource_activity_epoch()
+ > activity_epoch_before_dynamic_completion,
+ "a current dynamic-import Network fact must advance current Document activity"
+ );
+ assert!(
+ !page_resource_queue.has_ready_completion(),
+ "one producer terminal must be consumed exactly once"
+ );
+ let (dynamic_network_records, dynamic_websocket_events, dynamic_websocket_lifecycle) =
+ split_network_output_items(page_vm.vm_mut().take_network_output());
+ assert!(dynamic_websocket_events.is_empty());
+ assert!(dynamic_websocket_lifecycle.is_empty());
+ assert_eq!(dynamic_network_records.len(), 1);
+ assert_eq!(
+ dynamic_network_records[0].url().as_str(),
+ format!("{base_url}/child-dynamic-leaf.js")
+ );
+ assert_eq!(
+ dynamic_network_records[0].request_initiator_type(),
+ SubresourceRequestInitiatorType::Script
+ );
+ let dynamic_fetch_completion_source = dynamic_fetch_completion.action.source();
+ let host_load_pending_after_dynamic_fetch_completion = page_vm
+ .has_ready_child_frame_semantic_turn_for_test(ChildFrameSemanticTurnKind::HostLoad);
+
+ let dynamic_owner_action = page_vm
+ .run_page_dynamic_import_owner_action_body_for_test()
+ .expect("dynamic-import ready action should consume one typed Page turn");
+ let crate::page_task_queue::PageDynamicImportOwnerActionDocumentEffect::AppliedToCurrentOwner {
+ outcome: dynamic_owner_action_outcome,
+ } = dynamic_owner_action.action.document_effect
+ else {
+ panic!("current dynamic-import ready action must not be stale: {dynamic_owner_action:?}");
+ };
+ let dynamic_owner_action_applied =
+ dynamic_owner_action_outcome.evaluation_import_was_resolved();
+ let events_after_dynamic_owner_action_body = page_vm
+ .vm_mut()
+ .eval_without_microtask_checkpoint_for_test(
+ "__childDynamicImportHostLoadEvents.join('|')",
+ )?;
+ page_vm
+ .finish_selected_page_task_completion(
+ dynamic_owner_action.action.into_page_task_completion(),
+ &loader,
+ )
+ .await?;
+ let events_after_dynamic_owner_action = page_vm
+ .vm_mut()
+ .eval_without_microtask_checkpoint_for_test(
+ "__childDynamicImportHostLoadEvents.join('|')",
+ )?;
+ let host_load_pending_after_dynamic_owner_action = page_vm
+ .has_ready_child_frame_semantic_turn_for_test(ChildFrameSemanticTurnKind::HostLoad);
+
+ Ok::<_, anyhow::Error>((
+ startup_sources,
+ events_before_completion,
+ completion_source,
+ events_after_module_terminal,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ events_after_host_load,
+ post_load_progress_sources,
+ events_after_dynamic_fetch_scheduled,
+ dynamic_fetch_completion_source,
+ host_load_pending_after_dynamic_fetch_completion,
+ dynamic_owner_action_applied,
+ events_after_dynamic_owner_action_body,
+ events_after_dynamic_owner_action,
+ host_load_pending_after_dynamic_owner_action,
+ ))
+ }))
+ .await
+ .expect("page vm child dynamic import HostLoad proof should run");
+
+ assert!(
+ startup_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
+ "child dynamic import startup should start the root module fetch from a typed source: {startup_sources:?}"
+ );
+ assert_eq!(
+ events_before_completion, "before:true|after:undefined",
+ "pending root module should not run dynamic import or dispatch iframe load before completion"
+ );
+ assert_eq!(
+ completion_source,
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ );
+ assert_eq!(
+ events_after_module_terminal, "before:true|after:undefined",
+ "ModuleScriptTerminal should not execute the root module inline"
+ );
+ assert_eq!(
+ script_ready_source,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "root module graph-ready work should execute through DocumentScriptReady"
+ );
+ assert_eq!(
+ events_after_script_ready,
+ "before:true|after:undefined|module-start:true|module-after|script-load",
+ "DocumentScriptReady should execute the root module and dispatch script load without iframe load or dynamic import completion"
+ );
+ assert_eq!(
+ host_load_source,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "iframe load should remain a HostLoad turn after the root module script queues dynamic import"
+ );
+ assert_eq!(
+ events_after_host_load,
+ "before:true|after:undefined|module-start:true|module-after|script-load|frame-load",
+ "HostLoad should dispatch iframe load before dynamic import fetch scheduling or completion"
+ );
+ assert!(
+ post_load_progress_sources.contains(
+ &PostLoadProgressSource::TypedMainDocumentRuntime {
+ kind: crate::page_task_queue::PageMainDocumentRuntimeActionKind::DynamicModuleJob,
+ effect: crate::page_task_queue::PageMainDocumentRuntimeTargetEffect::AppliedToCurrentOwner,
+ },
+ ),
+ "dynamic import should advance through its concrete exact-main-Document task: {post_load_progress_sources:?}"
+ );
+ let dynamic_module_job = PostLoadProgressSource::TypedMainDocumentRuntime {
+ kind: crate::page_task_queue::PageMainDocumentRuntimeActionKind::DynamicModuleJob,
+ effect: crate::page_task_queue::PageMainDocumentRuntimeTargetEffect::AppliedToCurrentOwner,
+ };
+ let materialize_position = post_load_progress_sources
+ .iter()
+ .position(|source| *source == dynamic_module_job)
+ .expect("dynamic import should expose its concrete graph-advance turn");
+ let owner_action_position = post_load_progress_sources
+ .iter()
+ .position(|source| *source == PostLoadProgressSource::TypedDynamicImportOwnerAction)
+ .expect("dynamic import graph advance should publish an exact child owner action");
+ assert!(
+ owner_action_position > materialize_position,
+ "the exact child owner action must follow its graph advance without imposing a cross-source adjacency rule: {post_load_progress_sources:?}"
+ );
+ assert_eq!(
+ events_after_dynamic_fetch_scheduled,
+ "before:true|after:undefined|module-start:true|module-after|script-load|frame-load",
+ "dynamic import runtime work should schedule fetch without executing the dynamic module after iframe load"
+ );
+ assert_eq!(
+ dynamic_fetch_completion_source,
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ );
+ assert!(
+ !host_load_pending_after_dynamic_fetch_completion,
+ "dynamic import fetch completion should not queue HostLoad after the iframe has already loaded"
+ );
+ assert!(
+ dynamic_owner_action_applied,
+ "dynamic import ready action should resolve from the typed Page source"
+ );
+ assert_eq!(
+ events_after_dynamic_owner_action_body,
+ "before:true|after:undefined|module-start:true|module-after|script-load|frame-load|dynamic-module:true",
+ "DynamicImportOwnerAction body must leave the user import reaction for selected-task completion"
+ );
+ assert_eq!(
+ events_after_dynamic_owner_action,
+ "before:true|after:undefined|module-start:true|module-after|script-load|frame-load|dynamic-module:true|dynamic-fulfilled:701",
+ "selected-task completion should fulfill the child dynamic import after the body returns"
+ );
+ assert!(
+ !host_load_pending_after_dynamic_owner_action,
+ "dynamic import ready action should not requeue HostLoad"
+ );
+
+ server
+ .await
+ .expect("child dynamic import HostLoad proof server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_module_graph_failure_blocks_host_load_until_error_dispatches() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-bad-module.js",
+ "HTTP/1.1 200 OK",
+ "import {".to_owned(),
+ Duration::from_millis(200),
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ pre_completion_sources,
+ events_before_completion,
+ resource_ready_before_wait,
+ completion_source,
+ events_after_module_owner,
+ graph_failure_source,
+ events_after_graph_failure,
+ host_load_source,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let script_url = format!("{base_url}/child-bad-module.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childModuleFailureHostLoadEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childModuleFailureHostLoadEvents.push("frame-load");
+ frame.srcdoc = `
+ <script>parent.__childModuleFailureHostLoadEvents.push("before:" + (globalThis === self));<\/script>
+ <script id="bad-module" type="module" src="{script_url}"><\/script>
+ <script>
+ document.getElementById("bad-module").addEventListener("load", () => {{
+ parent.__childModuleFailureHostLoadEvents.push("script-load");
+ }});
+ document.getElementById("bad-module").addEventListener("error", () => {{
+ parent.__childModuleFailureHostLoadEvents.push("script-error");
+ }});
+ parent.__childModuleFailureHostLoadEvents.push("after");
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let mut pre_completion_sources = Vec::new();
+ let mut events_before_completion = String::new();
+ for _ in 0..8 {
+ let source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ events_before_completion = page_vm
+ .vm_mut()
+ .eval("__childModuleFailureHostLoadEvents.join('|')")?;
+ if let Some(source) = source {
+ pre_completion_sources.push(source);
+ }
+ if source.is_none()
+ || page_vm.has_ready_page_websocket_task_for_test()
+ || events_before_completion.contains("frame-load")
+ {
+ break;
+ }
+ }
+ let resource_ready_before_wait = page_vm
+ .page_resource_completion_queue()
+ .has_ready_completion();
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child bad module completion should arrive before timeout");
+ assert!(arrived, "child bad module completion sender should remain open");
+ }
+
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let completion_source = completion.action.source();
+
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "child graph-failure module terminal",
+ )
+ .await;
+ let events_after_module_owner = page_vm
+ .vm_mut()
+ .eval("__childModuleFailureHostLoadEvents.join('|')")?;
+
+ let graph_failure_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_graph_failure = page_vm
+ .vm_mut()
+ .eval("__childModuleFailureHostLoadEvents.join('|')")?;
+
+ let host_load_source = Some(
+ run_child_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "child module graph-failure iframe load",
+ )
+ .await,
+ );
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childModuleFailureHostLoadEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ pre_completion_sources,
+ events_before_completion,
+ resource_ready_before_wait,
+ completion_source,
+ events_after_module_owner,
+ graph_failure_source,
+ events_after_graph_failure,
+ host_load_source,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child bad module HostLoad gate test should run");
+
+ assert!(
+ pre_completion_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
+ "pre-completion turns should start the module root fetch from its typed source: {pre_completion_sources:?}"
+ );
+ assert!(
+ !resource_ready_before_wait,
+ "delayed bad module response should leave a window to prove HostLoad is gated before completion"
+ );
+ assert_eq!(
+ events_before_completion, "before:true|after",
+ "pending bad module script must block iframe load before resource completion"
+ );
+ assert_eq!(
+ completion_source,
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ );
+ assert_eq!(
+ events_after_module_owner, "before:true|after",
+ "module owner event should not dispatch script error or iframe load inline"
+ );
+ assert_eq!(
+ graph_failure_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "graph failure should dispatch through DocumentScriptReady"
+ );
+ assert_eq!(
+ events_after_graph_failure, "before:true|after|script-error",
+ "graph failure should dispatch script error without iframe load"
+ );
+ assert_eq!(
+ host_load_source,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "iframe load should remain a later HostLoad source after graph failure"
+ );
+ assert_eq!(
+ final_events, "before:true|after|script-error|frame-load",
+ "HostLoad should dispatch iframe load only after graph failure finalizes"
+ );
+
+ server
+ .await
+ .expect("child bad module HostLoad gate server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_module_dependency_completion_queues_module_script_terminal_work() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![
+ (
+ "/child-root-module.js",
+ "HTTP/1.1 200 OK",
+ r#"
+import { depValue } from "./child-dependency.js";
+parent.__childModuleDependencyWaitEvents.push("root:" + depValue);
+globalThis.__childModuleDependencyWaitValue = depValue;
+"#
+ .to_owned(),
+ Duration::ZERO,
+ ),
+ (
+ "/child-dependency.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childModuleDependencyWaitEvents.push("dep:" + (globalThis === self));
+export const depValue = "dep-value";
+"#
+ .to_owned(),
+ Duration::ZERO,
+ ),
+ ])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ dependency,
+ events_after_dependency_completion,
+ followup_sources,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let root_url = format!("{base_url}/child-root-module.js");
+ let dependency_url = format!("{base_url}/child-dependency.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childModuleDependencyWaitEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childModuleDependencyWaitEvents.push("frame-load");
+ frame.srcdoc = `
+ <script>parent.__childModuleDependencyWaitEvents.push("before:" + (globalThis === self));<\/script>
+ <script id="external-module" type="module" src="{root_url}"><\/script>
+ <script>
+ document.getElementById("external-module").addEventListener("load", () => {{
+ parent.__childModuleDependencyWaitEvents.push("script-load");
+ }});
+ parent.__childModuleDependencyWaitEvents.push(
+ "after:" + String(globalThis.__childModuleDependencyWaitValue)
+ );
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+ let startup_sources =
+ drive_child_frame_task_sources_until_resource_completion_ready(
+ &mut page_vm,
+ 8,
+ )
+ .await;
+ assert!(
+ startup_sources.contains(&ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "child module dependency startup should reach DocumentScriptReady without test drain: {startup_sources:?}"
+ );
+ assert!(
+ startup_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
+ "child module dependency startup should start the root fetch from its typed source: {startup_sources:?}"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childModuleDependencyWaitEvents.join('|')")?,
+ "before:true|after:undefined",
+ "parser should continue past child module script while dependency fetches are pending"
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child parser module root completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child parser module root completion sender should remain open"
+ );
+ }
+
+ let root = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ assert_eq!(
+ root.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ root.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ root.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "child dependency root terminal",
+ )
+ .await;
+ let (root_network_records, _, _) =
+ split_network_output_items(page_vm.vm_mut().take_network_output());
+ assert_eq!(root_network_records.len(), 1);
+ assert_eq!(root_network_records[0].url().as_str(), root_url);
+ assert!(
+ page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ChildModuleDependencyFetchStart,
+ &loader,
+ )
+ .await?,
+ "module terminal should queue one selected dependency-start task",
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child module dependency completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child module dependency completion sender should remain open"
+ );
+ }
+
+ let activity_epoch_before_dependency =
+ page_vm.vm().subresource_activity_epoch();
+ let dependency =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ assert_eq!(
+ dependency.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ dependency.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ assert!(
+ page_vm.vm().subresource_activity_epoch()
+ > activity_epoch_before_dependency,
+ "a current child dependency Network terminal must advance current Document activity"
+ );
+ let (dependency_network_records, _, _) =
+ split_network_output_items(page_vm.vm_mut().take_network_output());
+ assert_eq!(dependency_network_records.len(), 1);
+ let dependency_network_record = &dependency_network_records[0];
+ assert_eq!(dependency_network_record.url().as_str(), dependency_url);
+ assert!(dependency_network_record.frame_id().is_some());
+ assert_eq!(
+ dependency_network_record.request_initiator_type(),
+ SubresourceRequestInitiatorType::Parser
+ );
+ let events_after_dependency_completion = page_vm
+ .vm_mut()
+ .eval("__childModuleDependencyWaitEvents.join('|')")?;
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "child module dependency terminal fanout",
+ )
+ .await;
+ let mut followup_sources = Vec::new();
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childModuleDependencyWaitEvents.join('|')")?,
+ "before:true|after:undefined",
+ "dependency terminal fanout should not execute the module graph inline"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "child module dependency graph-ready execution",
+ )
+ .await,
+ );
+ let events_after_graph_ready = page_vm
+ .vm_mut()
+ .eval("__childModuleDependencyWaitEvents.join('|')")?;
+ assert_eq!(
+ events_after_graph_ready,
+ "before:true|after:undefined|dep:true|root:dep-value|script-load",
+ "dependency graph-ready execution should dispatch script load without iframe load"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "child module dependency DOMContentLoaded transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "child module dependency complete transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "child module dependency iframe load",
+ )
+ .await,
+ );
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childModuleDependencyWaitEvents.join('|')")?;
+ assert_eq!(
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ None,
+ "child module dependency follow-up sequence should not leave extra child frame task work"
+ );
+
+ Ok::<_, anyhow::Error>((
+ dependency,
+ events_after_dependency_completion,
+ followup_sources,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child module dependency deferred completion test should run");
+
+ assert!(matches!(
+ dependency.action.source(),
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ ));
+ assert_eq!(
+ events_after_dependency_completion, "before:true|after:undefined",
+ "dependency completion turn should not inline-run child module graph"
+ );
+ assert_eq!(
+ followup_sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::HostLoad
+ ],
+ "graph-ready, DOMContentLoaded, complete, and HostLoad must remain separate child turns after typed terminal fanout"
+ );
+ assert_eq!(
+ final_events,
+ "before:true|after:undefined|dep:true|root:dep-value|script-load|frame-load",
+ "explicit later turns should run queued child module graph work before iframe load"
+ );
+
+ server
+ .await
+ .expect("child module dependency wait-path server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_module_dependency_failure_queues_graph_failed_before_host_load() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![
+ (
+ "/child-root-module.js",
+ "HTTP/1.1 200 OK",
+ r#"
+import { depValue } from "./missing-child-dependency.js";
+parent.__childModuleDependencyFailureEvents.push("root:" + depValue);
+"#
+ .to_owned(),
+ Duration::ZERO,
+ ),
+ (
+ "/missing-child-dependency.js",
+ "HTTP/1.1 404 Not Found",
+ "missing dependency".to_owned(),
+ Duration::ZERO,
+ ),
+ ])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ dependency,
+ events_after_dependency_completion,
+ followup_sources,
+ events_after_graph_failure,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let root_url = format!("{base_url}/child-root-module.js");
+ let dependency_url = format!("{base_url}/missing-child-dependency.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childModuleDependencyFailureEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childModuleDependencyFailureEvents.push("frame-load");
+ frame.srcdoc = `
+ <script>parent.__childModuleDependencyFailureEvents.push("before:" + (globalThis === self));<\/script>
+ <script id="external-module" type="module" src="{root_url}"><\/script>
+ <script>
+ document.getElementById("external-module").addEventListener("load", () => {{
+ parent.__childModuleDependencyFailureEvents.push("script-load");
+ }});
+ document.getElementById("external-module").addEventListener("error", () => {{
+ parent.__childModuleDependencyFailureEvents.push("script-error");
+ }});
+ parent.__childModuleDependencyFailureEvents.push("after:" + String(globalThis.__childModuleDependencyFailureValue));
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+ let startup_sources =
+ drive_child_frame_task_sources_until_resource_completion_ready(
+ &mut page_vm,
+ 8,
+ )
+ .await;
+ assert!(
+ startup_sources.contains(&ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "child module dependency failure startup should reach DocumentScriptReady without test drain: {startup_sources:?}"
+ );
+ assert!(
+ startup_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
+ "child module dependency failure startup should start the root fetch from its typed source: {startup_sources:?}"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childModuleDependencyFailureEvents.join('|')")?,
+ "before:true|after:undefined",
+ "parser should continue past child module script while dependency fetch is pending"
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child parser module root completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child parser module root completion sender should remain open"
+ );
+ }
+
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "child dependency-failure root terminal",
+ )
+ .await;
+ let _ = page_vm.vm_mut().take_network_output();
+ assert!(
+ page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ChildModuleDependencyFetchStart,
+ &loader,
+ )
+ .await?,
+ "module terminal should queue one selected dependency-start task",
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect(
+ "child module dependency failure completion should arrive before timeout",
+ );
+ assert!(
+ arrived,
+ "child module dependency failure completion sender should remain open"
+ );
+ }
+
+ let dependency =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ assert_eq!(
+ dependency.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ dependency.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ let (dependency_network_records, _, _) =
+ split_network_output_items(page_vm.vm_mut().take_network_output());
+ assert_eq!(dependency_network_records.len(), 1);
+ assert_eq!(
+ dependency_network_records[0].url().as_str(),
+ dependency_url
+ );
+ assert!(matches!(
+ dependency_network_records[0].outcome(),
+ SubresourceNetworkOutcome::Success { status: 404, .. }
+ ));
+ let events_after_dependency_completion = page_vm
+ .vm_mut()
+ .eval("__childModuleDependencyFailureEvents.join('|')")?;
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "child module dependency failure terminal fanout",
+ )
+ .await;
+ let mut followup_sources = Vec::new();
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childModuleDependencyFailureEvents.join('|')")?,
+ "before:true|after:undefined",
+ "dependency failure terminal fanout should not dispatch script error or iframe load inline"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "child module dependency graph-failed dispatch",
+ )
+ .await,
+ );
+ let events_after_graph_failure = page_vm
+ .vm_mut()
+ .eval("__childModuleDependencyFailureEvents.join('|')")?;
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "child module dependency failure DOMContentLoaded transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "child module dependency failure complete transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "child module dependency failure iframe load",
+ )
+ .await,
+ );
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childModuleDependencyFailureEvents.join('|')")?;
+ assert_eq!(
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ None,
+ "child module dependency failure sequence should not leave extra child frame task work"
+ );
+
+ Ok::<_, anyhow::Error>((
+ dependency,
+ events_after_dependency_completion,
+ followup_sources,
+ events_after_graph_failure,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child module dependency failure test should run");
+
+ assert!(matches!(
+ dependency.action.source(),
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ ));
+ assert_eq!(
+ events_after_dependency_completion, "before:true|after:undefined",
+ "dependency failure completion turn should not inline-dispatch script error"
+ );
+ assert_eq!(
+ followup_sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::HostLoad
+ ],
+ "graph-failed dispatch, DOMContentLoaded, complete, and HostLoad must remain separate child turns after typed terminal fanout"
+ );
+ assert_eq!(
+ events_after_graph_failure, "before:true|after:undefined|script-error",
+ "graph-failed work should dispatch script error without iframe load"
+ );
+ assert_eq!(
+ final_events, "before:true|after:undefined|script-error|frame-load",
+ "HostLoad should dispatch iframe load only after dependency failure finalizes"
+ );
+
+ server
+ .await
+ .expect("child module dependency failure server should finish");
+ })
+ .await;
+}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/extracted/document_script_tasks.rs b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/document_script_tasks.rs
new file mode 100644
index 000000000..00b863513
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/document_script_tasks.rs
@@ -0,0 +1,1314 @@
+use super::*;
+
+#[tokio::test(flavor = "current_thread")]
+async fn stale_child_classic_completion_preserves_network_without_document_activity() {
+ run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm();
+ let root_document = page_vm.document_lifecycle.identity().document;
+ let child_handle = crate::dom::native::NativeNodeId::new(401);
+ let stale_owner = FrameDocumentTaskOwner::new(
+ crate::frame_owner_model::FrameSchedulerLaneId(4),
+ crate::frame_owner_model::LocalWindowId(5),
+ DocumentId(6),
+ );
+ let mut queue = RendererPageNetworkingSource::new_for_test();
+ queue.enqueue_local_for_test(RendererPageResourceCompletion::child_classic_script(
+ root_document,
+ ChildClassicScriptLoadCompletion {
+ owner: stale_owner,
+ load_id: 7,
+ handle: child_handle,
+ script_handle: crate::dom::native::NativeNodeId::new(402),
+ result: Ok("globalThis.__staleChildClassicRan = true".to_owned()),
+ network_result: Some(Arc::new(Err(
+ "stale child classic request failed".to_owned()
+ ))),
+ network_attribution: ChildClassicScriptNetworkAttribution {
+ frame_id: Some("stale-child-classic-frame".to_owned()),
+ document_url: Url::parse("https://stale-child.test/classic-document").unwrap(),
+ request_url: Url::parse("https://stale-child.test/classic.js").unwrap(),
+ },
+ },
+ ));
+ let activity_epoch_before = page_vm.vm().subresource_activity_epoch();
+
+ let outcome = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)
+ .expect("stale child classic arbitration should succeed")
+ .expect("stale child classic completion should consume one bounded turn");
+ assert_eq!(
+ outcome.action,
+ PageResourceCompletionTurnAction {
+ source: RendererOwnerResourceActivitySource::ChildClassicScript,
+ owner: RendererPageResourceCompletionOwner::child_document(
+ root_document,
+ child_handle,
+ stale_owner,
+ ),
+ document_effect: PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
+ current_owner: None,
+ },
+ body_activity: PageResourceCompletionBodyActivity::NoPageCodeOrEventDispatch,
+ post_checkpoint_effect: PageResourceCompletionPostCheckpointEffect::None,
+ output_effect: PageResourceCompletionOutputEffect::CaptureRequired,
+ }
+ );
+
+ assert!(!queue.has_ready_completion());
+ assert_eq!(
+ page_vm.vm().subresource_activity_epoch(),
+ activity_epoch_before,
+ "a retired child classic request must not become current Document activity"
+ );
+ let (network_records, websocket_events, websocket_lifecycle_events) =
+ split_network_output_items(page_vm.vm_mut().take_network_output());
+ assert!(websocket_events.is_empty());
+ assert!(websocket_lifecycle_events.is_empty());
+ assert_eq!(network_records.len(), 1);
+ let network_record = &network_records[0];
+ assert_eq!(network_record.frame_id(), Some("stale-child-classic-frame"));
+ assert_eq!(
+ network_record.document_url().as_str(),
+ "https://stale-child.test/classic-document"
+ );
+ assert_eq!(
+ network_record.url().as_str(),
+ "https://stale-child.test/classic.js"
+ );
+ assert_eq!(
+ network_record.resource_type(),
+ SubresourceResourceType::Script
+ );
+ assert_eq!(
+ network_record.request_initiator_type(),
+ SubresourceRequestInitiatorType::Script
+ );
+ assert_eq!(
+ network_record.outcome(),
+ &SubresourceNetworkOutcome::Failure {
+ error_text: "stale child classic request failed".to_owned(),
+ }
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__staleChildClassicRan)")
+ .expect("current main Document should remain observable"),
+ "undefined"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn child_classic_completion_queue_runs_exactly_one_terminal_per_owner_turn() {
+ run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm();
+ let root_document = page_vm.document_lifecycle.identity().document;
+ let child_handle = crate::dom::native::NativeNodeId::new(411);
+ let stale_owner = FrameDocumentTaskOwner::new(
+ crate::frame_owner_model::FrameSchedulerLaneId(12),
+ crate::frame_owner_model::LocalWindowId(13),
+ DocumentId(14),
+ );
+ let completion = |load_id, script_handle| ChildClassicScriptLoadCompletion {
+ owner: stale_owner,
+ load_id,
+ handle: child_handle,
+ script_handle: crate::dom::native::NativeNodeId::new(script_handle),
+ result: Ok(format!("globalThis.__staleChildClassic{load_id} = true")),
+ network_result: None,
+ network_attribution: ChildClassicScriptNetworkAttribution {
+ frame_id: Some("stale-child-classic-turn-frame".to_owned()),
+ document_url: Url::parse("https://stale-child-turn.test/document").unwrap(),
+ request_url: Url::parse(&format!(
+ "https://stale-child-turn.test/script-{load_id}.js"
+ ))
+ .unwrap(),
+ },
+ };
+ let mut queue = RendererPageNetworkingSource::new_for_test();
+ queue.enqueue_local_for_test(RendererPageResourceCompletion::child_classic_script(
+ root_document,
+ completion(1, 412),
+ ));
+ queue.enqueue_local_for_test(RendererPageResourceCompletion::child_classic_script(
+ root_document,
+ completion(2, 413),
+ ));
+
+ let first = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)
+ .expect("first child classic turn should arbitrate")
+ .expect("first child classic terminal should be consumed");
+ assert_eq!(
+ first.action.document_effect,
+ PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
+ current_owner: None,
+ }
+ );
+ assert_eq!(
+ first.action.output_effect,
+ PageResourceCompletionOutputEffect::None,
+ "a stale terminal without Network output must not synthesize an output wake"
+ );
+
+ assert!(
+ queue.has_ready_completion(),
+ "one owner turn must not drain the second typed terminal"
+ );
+
+ let second = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)
+ .expect("second child classic turn should arbitrate")
+ .expect("second child classic terminal should be consumed");
+ assert_eq!(
+ second.action.output_effect,
+ PageResourceCompletionOutputEffect::None
+ );
+
+ assert!(!queue.has_ready_completion());
+ assert!(page_vm.vm_mut().take_network_output().is_empty());
+ for load_id in [1, 2] {
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval(&format!("String(globalThis.__staleChildClassic{load_id})"))
+ .expect("current Document should remain observable"),
+ "undefined"
+ );
+ }
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_defer_classic_runs_between_interactive_and_domcontentloaded() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-defer-classic.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childClassicDeferWaitEvents.push("defer:" + (globalThis === self));
+parent.__childClassicDeferWaitEvents.push("defer-ready:" + document.readyState);
+parent.__childClassicDeferWaitEvents.push("current:" + document.currentScript.id);
+globalThis.__childClassicDeferWaitValue = 73;
+"#
+ .to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ first,
+ first_events,
+ bootstrap_sources,
+ followup_sources,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let script_url = format!("{base_url}/child-defer-classic.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childClassicDeferWaitEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childClassicDeferWaitEvents.push("load");
+ frame.srcdoc = `
+ <script>parent.__childClassicDeferWaitEvents.push("before:" + (globalThis === self));<\/script>
+ <script id="external-defer-classic" defer src="{script_url}"><\/script>
+ <script>
+ document.getElementById("external-defer-classic").addEventListener("load", () => {{
+ parent.__childClassicDeferWaitEvents.push("script-load");
+ }});
+ document.addEventListener("readystatechange", () => {{
+ parent.__childClassicDeferWaitEvents.push("ready:" + document.readyState);
+ }});
+ document.addEventListener("DOMContentLoaded", () => {{
+ parent.__childClassicDeferWaitEvents.push("dcl:" + document.readyState);
+ }});
+ parent.__childClassicDeferWaitEvents.push(
+ "after:" + String(globalThis.__childClassicDeferWaitValue)
+ );
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+ let mut bootstrap_sources = Vec::new();
+ let mut bootstrap_events = String::new();
+ for _ in 0..8 {
+ let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
+ break;
+ };
+ bootstrap_sources.push(source);
+ bootstrap_events = page_vm
+ .vm_mut()
+ .eval("__childClassicDeferWaitEvents.join('|')")?;
+ if bootstrap_events == "before:true|after:undefined|ready:interactive" {
+ break;
+ }
+ }
+ assert_eq!(
+ bootstrap_events,
+ "before:true|after:undefined|ready:interactive",
+ "parser EOF should dispatch interactive before the deferred script or load"
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child defer classic completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child defer classic completion sender should remain open"
+ );
+ }
+
+ let first =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let first_events = page_vm
+ .vm_mut()
+ .eval("__childClassicDeferWaitEvents.join('|')")?;
+ let mut followup_sources = Vec::new();
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "child defer classic execution",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childClassicDeferWaitEvents.join('|')")?,
+ "before:true|after:undefined|ready:interactive|defer:true|defer-ready:interactive|current:external-defer-classic|script-load",
+ "DocumentScriptReady should run defer after interactive and before DOMContentLoaded or iframe load"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "child defer classic DOMContentLoaded transition",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childClassicDeferWaitEvents.join('|')")?,
+ "before:true|after:undefined|ready:interactive|defer:true|defer-ready:interactive|current:external-defer-classic|script-load|dcl:interactive",
+ "DOMContentLoaded should run on its own lifecycle turn after defer and before complete/load"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "child defer classic complete transition",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childClassicDeferWaitEvents.join('|')")?,
+ "before:true|after:undefined|ready:interactive|defer:true|defer-ready:interactive|current:external-defer-classic|script-load|dcl:interactive|ready:complete",
+ "document complete must be a lifecycle turn after defer and DOMContentLoaded"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "child defer classic iframe load",
+ )
+ .await,
+ );
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childClassicDeferWaitEvents.join('|')")?;
+ assert_eq!(
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ None,
+ "child defer classic follow-up sequence should not leave extra child frame task work"
+ );
+
+ Ok::<_, anyhow::Error>((
+ first,
+ first_events,
+ bootstrap_sources,
+ followup_sources,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child defer classic deferred completion test should run");
+
+ assert!(matches!(
+ first.action.source(),
+ RendererOwnerResourceActivitySource::ChildClassicScript
+ ));
+ assert_eq!(
+ first.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ first.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ assert_eq!(
+ first_events, "before:true|after:undefined|ready:interactive",
+ "source completion turn should not inline-run child defer classic script"
+ );
+ assert_eq!(
+ bootstrap_sources,
+ vec![
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ ChildFrameSemanticTurnKind::RealmMaterialization,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle
+ ],
+ "child defer classic bootstrap should end with the document-owned interactive turn"
+ );
+ assert_eq!(
+ followup_sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::HostLoad
+ ],
+ "child defer classic should progress through script, DCL, complete, and later HostLoad turns"
+ );
+ assert_eq!(
+ final_events,
+ "before:true|after:undefined|ready:interactive|defer:true|defer-ready:interactive|current:external-defer-classic|script-load|dcl:interactive|ready:complete|load",
+ "defer must run after interactive and before the later HostLoad DCL/complete/load delivery"
+ );
+
+ server
+ .await
+ .expect("child defer classic wait-path server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_defer_classic_source_failure_releases_parser_order_slot() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/missing-child-defer.js",
+ "HTTP/1.1 404 Not Found",
+ "missing".to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (completion, events_after_completion, followup_sources, final_events) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let script_url = format!("{base_url}/missing-child-defer.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childClassicDeferFailureEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childClassicDeferFailureEvents.push("load");
+ frame.srcdoc = `
+ <script>parent.__childClassicDeferFailureEvents.push("before");<\/script>
+ <script id="failed-defer" defer src="{script_url}"><\/script>
+ <script>
+ document.getElementById("failed-defer").addEventListener("error", () => {{
+ parent.__childClassicDeferFailureEvents.push("script-error");
+ }});
+ document.addEventListener("readystatechange", () => {{
+ parent.__childClassicDeferFailureEvents.push("ready:" + document.readyState);
+ }});
+ document.addEventListener("DOMContentLoaded", () => {{
+ parent.__childClassicDeferFailureEvents.push("dcl");
+ }});
+ parent.__childClassicDeferFailureEvents.push("after");
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ for _ in 0..8 {
+ let Some(_) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
+ break;
+ };
+ if page_vm
+ .vm_mut()
+ .eval("__childClassicDeferFailureEvents.join('|')")?
+ == "before|after|ready:interactive"
+ {
+ break;
+ }
+ }
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childClassicDeferFailureEvents.join('|')")?,
+ "before|after|ready:interactive",
+ "failed defer must keep DCL gated while its source completion is pending"
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("failed child defer completion should arrive");
+ }
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let events_after_completion = page_vm
+ .vm_mut()
+ .eval("__childClassicDeferFailureEvents.join('|')")?;
+
+ let mut followup_sources = Vec::new();
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "failed child defer source terminal",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childClassicDeferFailureEvents.join('|')")?,
+ "before|after|ready:interactive|script-error",
+ "source failure must dispatch error and release defer ordering without resuming the parser"
+ );
+ for (source, label) in [
+ (
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "failed child defer DOMContentLoaded",
+ ),
+ (
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "failed child defer complete transition",
+ ),
+ (
+ ChildFrameSemanticTurnKind::HostLoad,
+ "failed child defer iframe load",
+ ),
+ ] {
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(&mut page_vm, source, label)
+ .await,
+ );
+ }
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childClassicDeferFailureEvents.join('|')")?;
+ assert_eq!(page_vm.run_next_child_frame_task_source_for_semantic_test().await, None);
+
+ Ok::<_, anyhow::Error>((
+ completion,
+ events_after_completion,
+ followup_sources,
+ final_events,
+ ))
+ })
+ .await
+ .expect("child defer source-failure order test should run");
+
+ assert!(matches!(
+ completion.action.source(),
+ RendererOwnerResourceActivitySource::ChildClassicScript
+ ));
+ assert_eq!(
+ completion.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ completion.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ assert_eq!(
+ events_after_completion, "before|after|ready:interactive",
+ "resource completion must not report or finalize the failed script inline"
+ );
+ assert_eq!(
+ followup_sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::HostLoad,
+ ]
+ );
+ assert_eq!(
+ final_events,
+ "before|after|ready:interactive|script-error|dcl|ready:complete|load"
+ );
+ server
+ .await
+ .expect("failed child defer source server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_async_classic_handoff_queues_document_script_ready_work() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-async-classic.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childClassicAsyncWaitEvents.push("async:" + (globalThis === self));
+parent.__childClassicAsyncWaitEvents.push("current:" + document.currentScript.id);
+globalThis.__childClassicAsyncWaitValue = 41;
+"#
+ .to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ first,
+ first_events,
+ bootstrap_sources,
+ followup_sources,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let script_url = format!("{base_url}/child-async-classic.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childClassicAsyncWaitEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childClassicAsyncWaitEvents.push("load");
+ frame.srcdoc = `
+ <script>parent.__childClassicAsyncWaitEvents.push("before:" + (globalThis === self));<\/script>
+ <script id="external-async-classic" async src="{script_url}"><\/script>
+ <script>
+ document.getElementById("external-async-classic").addEventListener("load", () => {{
+ parent.__childClassicAsyncWaitEvents.push("script-load");
+ }});
+ document.addEventListener("DOMContentLoaded", () => {{
+ parent.__childClassicAsyncWaitEvents.push("dcl:" + document.readyState);
+ }});
+ parent.__childClassicAsyncWaitEvents.push(
+ "after:" + String(globalThis.__childClassicAsyncWaitValue)
+ );
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+ let mut bootstrap_sources = Vec::new();
+ let mut bootstrap_events = String::new();
+ for _ in 0..8 {
+ let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
+ break;
+ };
+ bootstrap_sources.push(source);
+ bootstrap_events = page_vm
+ .vm_mut()
+ .eval("__childClassicAsyncWaitEvents.join('|')")?;
+ if bootstrap_events == "before:true|after:undefined|dcl:interactive" {
+ break;
+ }
+ }
+ assert_eq!(
+ bootstrap_events,
+ "before:true|after:undefined|dcl:interactive",
+ "async classic must not block the document-owned DOMContentLoaded transition"
+ );
+ assert_eq!(
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ None,
+ "the document-owned async classic delay must keep HostLoad blocked until source completion is applied"
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child async classic completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child async classic completion sender should remain open"
+ );
+ }
+
+ let first =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let first_events = page_vm
+ .vm_mut()
+ .eval("__childClassicAsyncWaitEvents.join('|')")?;
+ let mut followup_sources = Vec::new();
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "child async classic execution",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childClassicAsyncWaitEvents.join('|')")?,
+ "before:true|after:undefined|dcl:interactive|async:true|current:external-async-classic|script-load",
+ "DocumentScriptReady should execute child async classic and dispatch its script load without iframe load"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "child async classic complete transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "child async classic iframe load",
+ )
+ .await,
+ );
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childClassicAsyncWaitEvents.join('|')")?;
+ assert_eq!(
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ None,
+ "child async classic follow-up sequence should not leave extra child frame task work"
+ );
+
+ Ok::<_, anyhow::Error>((
+ first,
+ first_events,
+ bootstrap_sources,
+ followup_sources,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child async classic deferred completion test should run");
+
+ assert!(matches!(
+ first.action.source(),
+ RendererOwnerResourceActivitySource::ChildClassicScript
+ ));
+ assert_eq!(
+ first.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ first.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ assert_eq!(
+ first_events, "before:true|after:undefined|dcl:interactive",
+ "source completion turn should not inline-run child async classic script"
+ );
+ assert_eq!(
+ bootstrap_sources,
+ vec![
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ ChildFrameSemanticTurnKind::RealmMaterialization,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle
+ ],
+ "child async bootstrap should dispatch interactive and DCL before the later async completion"
+ );
+ assert_eq!(
+ followup_sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::HostLoad
+ ],
+ "child async classic source completion should progress through script execution, complete, and later HostLoad turns"
+ );
+ assert_eq!(
+ final_events,
+ "before:true|after:undefined|dcl:interactive|async:true|current:external-async-classic|script-load|load",
+ "explicit later wait turns should run queued child async classic work"
+ );
+
+ server
+ .await
+ .expect("child async classic wait-path server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_defer_classic_preserves_document_order_when_second_source_finishes_first() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_concurrent_path_response_http_server(vec![
+ (
+ "/first-defer-classic.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childClassicDeferOrderEvents.push("first:" + (globalThis === self));
+parent.__childClassicDeferOrderEvents.push("current:" + document.currentScript.id);
+"#
+ .to_owned(),
+ Duration::from_millis(150),
+ ),
+ (
+ "/second-defer-classic.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childClassicDeferOrderEvents.push("second:" + (globalThis === self));
+parent.__childClassicDeferOrderEvents.push("current:" + document.currentScript.id);
+"#
+ .to_owned(),
+ Duration::ZERO,
+ ),
+ ])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ second_completion,
+ events_after_second_completion,
+ first_completion,
+ events_after_first_completion,
+ bootstrap_sources,
+ followup_sources,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let first_script_url = format!("{base_url}/first-defer-classic.js");
+ let second_script_url = format!("{base_url}/second-defer-classic.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childClassicDeferOrderEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childClassicDeferOrderEvents.push("load");
+ frame.srcdoc = `
+ <script>parent.__childClassicDeferOrderEvents.push("before:" + (globalThis === self));<\/script>
+ <script id="first-defer-classic" defer src="{first_script_url}"><\/script>
+ <script id="second-defer-classic" defer src="{second_script_url}"><\/script>
+ <script>
+ document.getElementById("first-defer-classic").addEventListener("load", () => {{
+ parent.__childClassicDeferOrderEvents.push("first-load");
+ }});
+ document.getElementById("second-defer-classic").addEventListener("load", () => {{
+ parent.__childClassicDeferOrderEvents.push("second-load");
+ }});
+ parent.__childClassicDeferOrderEvents.push("after");
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+ let mut bootstrap_sources = Vec::new();
+ let mut bootstrap_events = String::new();
+ for _ in 0..8 {
+ let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
+ break;
+ };
+ bootstrap_sources.push(source);
+ bootstrap_events = page_vm
+ .vm_mut()
+ .eval("__childClassicDeferOrderEvents.join('|')")?;
+ if source == ChildFrameSemanticTurnKind::DocumentLifecycle {
+ break;
+ }
+ }
+ assert_eq!(
+ bootstrap_events,
+ "before:true|after",
+ "child parser should continue past both defer classics without firing load"
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("second child defer classic completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child defer classic completion sender should remain open"
+ );
+ }
+ let second_completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let events_after_second_completion = page_vm
+ .vm_mut()
+ .eval("__childClassicDeferOrderEvents.join('|')")?;
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("first child defer classic completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child defer classic completion sender should remain open"
+ );
+ }
+ let first_completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let events_after_first_completion = page_vm
+ .vm_mut()
+ .eval("__childClassicDeferOrderEvents.join('|')")?;
+ let mut followup_sources = Vec::new();
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "first child defer classic execution",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childClassicDeferOrderEvents.join('|')")?,
+ "before:true|after|first:true|current:first-defer-classic|first-load",
+ "first ordered DocumentScriptReady should execute the earlier defer classic without second defer or iframe load"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "second child defer classic execution",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childClassicDeferOrderEvents.join('|')")?,
+ "before:true|after|first:true|current:first-defer-classic|first-load|second:true|current:second-defer-classic|second-load",
+ "second ordered DocumentScriptReady should run only after the earlier defer classic completes"
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "ordered child defer classic DOMContentLoaded transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "ordered child defer classic complete transition",
+ )
+ .await,
+ );
+ followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "ordered child defer classic iframe load",
+ )
+ .await,
+ );
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childClassicDeferOrderEvents.join('|')")?;
+ assert_eq!(
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ None,
+ "child defer ordering sequence should not leave extra child frame task work"
+ );
+
+ Ok::<_, anyhow::Error>((
+ second_completion,
+ events_after_second_completion,
+ first_completion,
+ events_after_first_completion,
+ bootstrap_sources,
+ followup_sources,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child defer classic ordering test should run");
+
+ assert!(matches!(
+ second_completion.action.source(),
+ RendererOwnerResourceActivitySource::ChildClassicScript
+ ));
+ assert_eq!(
+ second_completion.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ second_completion.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ assert_eq!(
+ bootstrap_sources,
+ vec![
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ ChildFrameSemanticTurnKind::RealmMaterialization,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle
+ ],
+ "child defer ordering bootstrap should reach interactive before either source completion"
+ );
+ assert_eq!(
+ events_after_second_completion, "before:true|after",
+ "faster second defer source completion must not run before earlier defer"
+ );
+ assert!(matches!(
+ first_completion.action.source(),
+ RendererOwnerResourceActivitySource::ChildClassicScript
+ ));
+ assert_eq!(
+ first_completion.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ first_completion.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+
+ assert_eq!(
+ events_after_first_completion, "before:true|after",
+ "first defer source completion turn should still not inline-run script"
+ );
+ assert_eq!(
+ followup_sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::HostLoad
+ ],
+ "ordered child defer classics should execute through two script-ready turns, DOMContentLoaded, and complete before HostLoad"
+ );
+ assert_eq!(
+ final_events,
+ "before:true|after|first:true|current:first-defer-classic|first-load|second:true|current:second-defer-classic|second-load|load",
+ "defer classics should execute in document order even when the second source finishes first"
+ );
+
+ server
+ .await
+ .expect("child defer classic ordering server should finish");
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn page_vm_realm_materialization_created_ready_work_enters_document_script_ready_directly() {
+ run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm();
+ page_vm.vm_mut().eval_with_child_record_sync(
+ r#"
+(() => {
+ globalThis.__realmMaterializationNestedEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.srcdoc = `
+ <iframe srcdoc="&lt;script&gt;parent.parent.__realmMaterializationNestedEvents.push('nested-script:' + (globalThis === self));&lt;/script&gt;"></iframe>
+ <script>parent.__realmMaterializationNestedEvents.push("outer-script:" + (globalThis === self));<\/script>
+ `;
+ body.appendChild(frame);
+})()
+"#,
+ )?;
+
+ for label in ["outer", "nested"] {
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ &format!("{label} child navigation commit"),
+ )
+ .await;
+ }
+ assert_eq!(
+ page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "outer child parser work should run on the DocumentScriptReady source"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__realmMaterializationNestedEvents.join('|')")?,
+ "outer-script:true",
+ "outer DocumentScriptReady turn should not inline-run nested parser work"
+ );
+ assert_eq!(
+ page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await,
+ Some(ChildFrameSemanticTurnKind::RealmMaterialization),
+ "nested child realm must be materialized in its own visible family turn"
+ );
+ assert_eq!(
+ page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await,
+ Some(ChildFrameSemanticTurnKind::DocumentLifecycle),
+ "outer parser EOF should become interactive before nested document work"
+ );
+ assert_eq!(
+ page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "ready work produced by child realm materialization should enter DocumentScriptReady directly"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__realmMaterializationNestedEvents.join('|')")?,
+ "outer-script:true|nested-script:true",
+ "nested parser work should run on the later DocumentScriptReady turn"
+ );
+ assert_eq!(
+ page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await,
+ Some(ChildFrameSemanticTurnKind::DocumentLifecycle),
+ "outer DOMContentLoaded should remain a later FIFO turn after nested work already admitted by realm materialization"
+ );
+ Ok::<_, anyhow::Error>(())
+ })
+ .await
+ .expect("realm materialization nested ready-work source test should run");
+}
+#[tokio::test]
+async fn child_dynamic_inline_script_runs_synchronously_without_document_script_ready_work() {
+ let (immediate_events, settled_events, next_source) = run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm();
+ page_vm.vm_mut().eval(
+ r#"
+(() => {
+ globalThis.__childDynamicReadySourceEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => __childDynamicReadySourceEvents.push("frame-load");
+ body.appendChild(frame);
+ const script = document.createElement("script");
+ script.textContent = `
+ parent.__childDynamicReadySourceEvents.push(
+ "dynamic:" + document.currentScript.tagName.toLowerCase()
+ );
+ `;
+ frame.contentDocument.body.appendChild(script);
+ __childDynamicReadySourceEvents.push("returned");
+})()
+"#,
+ )?;
+ let immediate_events = page_vm
+ .vm_mut()
+ .eval("__childDynamicReadySourceEvents.join('|')")?;
+ run_expected_child_realm_materialization_for_wait(
+ &mut page_vm,
+ "dynamic child inline-script realm",
+ )
+ .await;
+ let next_source = page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await;
+ let settled_events = page_vm
+ .vm_mut()
+ .eval("__childDynamicReadySourceEvents.join('|')")?;
+ Ok::<_, anyhow::Error>((immediate_events, settled_events, next_source))
+ })
+ .await
+ .expect("child dynamic inline script source test should run");
+
+ assert_eq!(
+ immediate_events, "frame-load|dynamic:script|returned",
+ "both initial about:blank load and dynamic inline execution are synchronous"
+ );
+ assert_eq!(settled_events, immediate_events);
+ assert_eq!(
+ next_source, None,
+ "inline execution must leave no DocumentScriptReady or HostLoad task"
+ );
+}
+#[tokio::test]
+async fn child_dynamic_external_classic_script_uses_child_resource_and_ready_owners() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-dynamic-classic.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childDynamicExternalEvents.push("external:" + (globalThis === self));
+parent.__childDynamicExternalEvents.push("current:" + document.currentScript.id);
+"#
+ .to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (events_before_completion, completion_source, ready_source, final_events) =
+ local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let script_url = format!("{base_url}/child-dynamic-classic.js");
+ page_vm.vm_mut().eval(
+ r#"
+(() => {
+ globalThis.__childDynamicExternalEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.id = "dynamic-external-frame";
+ frame.onload = () => __childDynamicExternalEvents.push("frame-load");
+ frame.srcdoc = "<!doctype html><html><head><title>child</title></head><body></body></html>";
+ body.appendChild(frame);
+})()
+"#,
+ )?;
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "dynamic external child navigation commit",
+ )
+ .await;
+ run_expected_child_realm_materialization_for_wait(
+ &mut page_vm,
+ "dynamic external child realm",
+ )
+ .await;
+ run_child_interactive_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "dynamic external child initial load",
+ )
+ .await;
+
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ const frame = document.getElementById("dynamic-external-frame");
+ const script = frame.contentDocument.createElement("script");
+ script.id = "dynamic-external";
+ script.onload = () => __childDynamicExternalEvents.push("script-load");
+ script.onerror = () => __childDynamicExternalEvents.push("script-error");
+ script.src = "{script_url}";
+ frame.contentDocument.body.appendChild(script);
+}})()
+"#,
+ ))?;
+ let events_before_completion = page_vm
+ .vm_mut()
+ .eval("__childDynamicExternalEvents.join('|')")?;
+ if !page_vm
+ .page_resource_completion_queue()
+ .has_ready_completion()
+ {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child dynamic external completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child dynamic external completion sender should remain open"
+ );
+ }
+ let completion = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let completion_source = completion.action.source();
+ let ready_source =
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "child dynamic external classic execution",
+ )
+ .await;
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childDynamicExternalEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ events_before_completion,
+ completion_source,
+ ready_source,
+ final_events,
+ ))
+ })
+ .await
+ .expect("child dynamic external script test should run");
+
+ assert_eq!(
+ events_before_completion, "frame-load",
+ "external script fetch and execution must not run inline with insertion"
+ );
+ assert_eq!(
+ completion_source,
+ RendererOwnerResourceActivitySource::ChildClassicScript,
+ "the child classic resource owner should publish the network terminal"
+ );
+ assert_eq!(
+ ready_source,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "the loaded external classic script should execute on the child ready source"
+ );
+ assert_eq!(
+ final_events, "frame-load|external:true|current:dynamic-external|script-load",
+ "the current child realm should execute once and dispatch load on its script element"
+ );
+
+ server
+ .await
+ .expect("child dynamic external script server should finish");
+ })
+ .await;
+}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/extracted/main_document_scripts.rs b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/main_document_scripts.rs
new file mode 100644
index 000000000..60bc640e9
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/main_document_scripts.rs
@@ -0,0 +1,1137 @@
+use super::*;
+
+#[tokio::test(flavor = "current_thread")]
+async fn main_parser_async_classic_owns_load_delay_from_discovery_through_settlement() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/main-parser-async.html").expect("document URL"),
+ );
+ let owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("main parser async test requires an owner");
+ let script_url =
+ Url::parse("https://example.com/main-parser-async.js").expect("script URL");
+ let mut script = append_parser_owned_external_classic_defer_for_page_vm_test(
+ &mut page_vm,
+ 9060,
+ "main-parser-async-classic",
+ script_url,
+ ScriptSource::External,
+ ("async", ""),
+ );
+ script.mode = ScriptMode::Async;
+ assert!(
+ page_vm
+ .vm_mut()
+ .document_runtime
+ .dom_host_mut()
+ .set_script_already_started(script.node_id, true)
+ );
+ let shared_load =
+ SharedScriptSourceLoad::ready_ok("globalThis.__mainParserAsyncClassicExecuted = 1;");
+ let mut scheduler = crate::document_script_scheduler::DocumentScriptScheduler::new();
+ let resource_task_runner = page_vm.resource_task_runner();
+
+ assert!(
+ scheduler.accept_parser_discovered_async_candidate(
+ script.clone(),
+ &loader,
+ page_vm
+ .vm()
+ .current_main_document_resource_loader()
+ .unwrap()
+ .fetch_context()
+ .request_origin(),
+ resource_task_runner,
+ Some(shared_load),
+ None,
+ |_| {
+ page_vm
+ .vm_mut()
+ .accept_main_document_script_load_delay_binding(
+ owner,
+ crate::frame_owner_model::MainDocumentScriptLoadDelayKind::Classic,
+ )
+ .expect("parser discovery should bind classic lifecycle ownership")
+ },
+ )
+ );
+ assert_eq!(
+ page_vm
+ .vm()
+ .current_main_document_has_async_script_load_delay(owner),
+ Some(true),
+ "acceptance must delay load before source readiness is observed"
+ );
+ assert!(scheduler.claim_existing_parse_time_async_handoff(script.node_id));
+ let ready = scheduler
+ .parse_time_turn(
+ crate::document_script_scheduler::ParseTimeTurnTrigger::BeforeParserStep {
+ default_chunk_bytes: 4096,
+ },
+ )
+ .ready_task
+ .expect("ready shared source should produce a parser async task");
+ let crate::document_script_scheduler::ParseTimeDocumentScriptTask::ClassicAsyncScript(
+ ready,
+ ) = ready
+ else {
+ panic!("ready shared source should produce classic execution work");
+ };
+ let (script, binding) = ready.into_parts();
+ let binding = binding.expect("parse-time work must retain its discovery binding");
+ assert_eq!(binding.owner(), owner);
+
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ PostParsePageOwnedWork::document_script_work(
+ PageOwnedDocumentScriptWork::parser_async_script(
+ DocumentScriptExecutionLane::ParseTimeAsync,
+ script,
+ Some(binding),
+ ),
+ ),
+ )
+ .await
+ .expect("parser async classic execution turn should run");
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__mainParserAsyncClassicExecuted)")?,
+ "1"
+ );
+ assert_eq!(
+ page_vm
+ .vm()
+ .current_main_document_has_async_script_load_delay(owner),
+ Some(true),
+ "execution must enqueue, not inline-apply, lifecycle settlement"
+ );
+ page_vm
+ .drain_deferred_page_tasks_on_named_owner_local_task()
+ .await?;
+ assert_eq!(
+ page_vm
+ .vm()
+ .current_main_document_has_async_script_load_delay(owner),
+ Some(true),
+ "parser progress may publish follow-ups but must not apply settlement inline"
+ );
+
+ run_main_async_script_load_delay_settlement_for_test(
+ &mut page_vm,
+ &loader,
+ owner,
+ "main parser async classic",
+ )
+ .await;
+ assert_eq!(
+ page_vm
+ .vm()
+ .current_main_document_has_async_script_load_delay(owner),
+ Some(false)
+ );
+ Ok::<(), anyhow::Error>(())
+ })
+ .await
+ .expect("main parser async classic lifecycle test should run");
+}
+#[tokio::test(flavor = "current_thread")]
+async fn main_parser_async_module_owns_load_delay_until_evaluation_start() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/main-parser-async-module.html").expect("document URL"),
+ );
+ let owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("main parser async module test requires an owner");
+ let module_url =
+ Url::parse("https://example.com/main-parser-async-module.mjs").expect("module URL");
+ let mut script =
+ prepared_external_module_for_page_vm_test_with_node(&page_vm, 9061, module_url.clone());
+ script.mode = ScriptMode::Async;
+
+ assert!(
+ page_vm
+ .vm_mut()
+ .accept_main_parser_async_module_script(owner, &script)?
+ );
+ assert_eq!(
+ page_vm
+ .vm()
+ .current_main_document_has_async_script_load_delay(owner),
+ Some(true),
+ "module acceptance must bind lifecycle ownership before graph work"
+ );
+ page_vm.target_stage = PageVmInitStage::DomContentLoaded;
+ assert!(
+ !page_vm.has_pending_module_script_for_target_stage(),
+ "a watched parser-origin async module must not enter the parser-deferred DCL gate"
+ );
+ assert!(
+ page_vm.has_pending_module_fetch_for_target_stage(),
+ "the pending graph should remain visible to resource-completion observation"
+ );
+ enqueue_parser_owned_module_script_fetch_completion_for_test(
+ &mut page_vm,
+ 0,
+ &module_url,
+ "globalThis.__mainParserAsyncModuleExecuted = 1; export const value = 1;",
+ );
+ assert!(
+ run_next_main_module_fetch_terminal_for_test(&mut page_vm)?.is_some(),
+ "async module graph completion should apply"
+ );
+ assert!(
+ page_vm.has_ready_parser_owned_document_script_action(),
+ "watching a completed async graph should queue owner work"
+ );
+ assert!(
+ run_one_parser_owned_main_document_runtime_turn_for_test(&mut page_vm, &loader).await?,
+ "async module graph-ready work should start evaluation"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__mainParserAsyncModuleExecuted)")?,
+ "1"
+ );
+ assert_eq!(
+ page_vm
+ .vm()
+ .current_main_document_has_async_script_load_delay(owner),
+ Some(true),
+ "evaluation start must leave settlement for its own lifecycle turn"
+ );
+
+ run_main_async_script_load_delay_settlement_for_test(
+ &mut page_vm,
+ &loader,
+ owner,
+ "main parser async module",
+ )
+ .await;
+ assert_eq!(
+ page_vm
+ .vm()
+ .current_main_document_has_async_script_load_delay(owner),
+ Some(false)
+ );
+ Ok::<(), anyhow::Error>(())
+ })
+ .await
+ .expect("main parser async module lifecycle test should run");
+}
+#[tokio::test(flavor = "current_thread")]
+async fn main_parser_async_inline_module_is_watched_before_graph_start() {
+ run_page_vm_async_test(async move {
+ let loader_owner =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let loader = loader_owner.handle();
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/main-parser-async-inline-module.html")
+ .expect("document URL"),
+ );
+ let owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("main parser async inline module test requires an owner");
+ let mut script = prepared_inline_module_for_page_vm_test(
+ &page_vm,
+ 9063,
+ "globalThis.__mainParserAsyncInlineModuleExecuted = 1; export const value = 1;",
+ );
+ script.mode = ScriptMode::Async;
+
+ assert!(
+ page_vm
+ .vm_mut()
+ .accept_main_parser_async_module_script(owner, &script)?
+ );
+ assert!(
+ page_vm.has_ready_parser_owned_document_script_action(),
+ "an immediately-ready graph must notify the PendingScript watch installed before graph start"
+ );
+ assert_eq!(
+ page_vm
+ .vm()
+ .current_main_document_has_async_script_load_delay(owner),
+ Some(true)
+ );
+ assert!(
+ run_one_parser_owned_main_document_runtime_turn_for_test(&mut page_vm, &loader)
+ .await?
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__mainParserAsyncInlineModuleExecuted)")?,
+ "1"
+ );
+
+ run_main_async_script_load_delay_settlement_for_test(
+ &mut page_vm,
+ &loader,
+ owner,
+ "main parser async inline module",
+ )
+ .await;
+ assert_eq!(
+ page_vm
+ .vm()
+ .current_main_document_has_async_script_load_delay(owner),
+ Some(false)
+ );
+ Ok::<(), anyhow::Error>(())
+ })
+ .await
+ .expect("main parser async inline module lifecycle test should run");
+}
+#[tokio::test(flavor = "current_thread")]
+async fn main_document_lifecycle_sets_interactive_before_defer_and_loads_later() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/main-lifecycle.html").expect("document URL"),
+ );
+ page_vm
+ .vm_mut()
+ .eval(
+ r#"
+ globalThis.__mainLifecycleEvents = [];
+ document.addEventListener("readystatechange", () => {
+ __mainLifecycleEvents.push("ready:" + document.readyState);
+ });
+ document.addEventListener("DOMContentLoaded", () => {
+ __mainLifecycleEvents.push("dcl:" + document.readyState);
+ });
+ window.addEventListener("load", () => {
+ __mainLifecycleEvents.push("load:" + document.readyState);
+ });
+ "installed";
+ "#,
+ )
+ .expect("main lifecycle listeners should install");
+ let owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("main lifecycle test requires an owner");
+ let defer = append_parser_owned_external_classic_defer_for_page_vm_test(
+ &mut page_vm,
+ 7001,
+ "main-lifecycle-defer",
+ Url::parse("https://example.com/main-lifecycle-defer.js").expect("defer script URL"),
+ ScriptSource::Loaded(
+ "__mainLifecycleEvents.push('defer:' + document.readyState);".to_owned(),
+ ),
+ ("data-lifecycle-test", "defer"),
+ );
+ assert!(
+ page_vm
+ .vm_mut()
+ .claim_main_parser_deferred_script(owner, defer, None, None, Default::default(),)
+ .expect("parser-deferred PendingScript acceptance should succeed")
+ );
+ let defer_marker = page_vm
+ .seal_main_parser_deferred_scripts(owner)
+ .expect("parser-deferred work should install into after-parsing order");
+ let interactive = page_vm
+ .vm_mut()
+ .finish_current_main_document_parsing(owner)
+ .expect("parser EOF should produce one interactive action");
+
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ PostParsePageOwnedWork::main_document_interactive(interactive),
+ )
+ .await
+ .expect("interactive lifecycle turn should run");
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__mainLifecycleEvents.join('|')")
+ .expect("interactive events"),
+ "ready:interactive"
+ );
+
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(&loader, defer_marker)
+ .await
+ .expect("main defer script should run");
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__mainLifecycleEvents.join('|')")
+ .expect("defer events"),
+ "ready:interactive|defer:interactive"
+ );
+
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ PostParsePageOwnedWork::main_document_domcontentloaded(owner),
+ )
+ .await
+ .expect("main DOMContentLoaded turn should run");
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__mainLifecycleEvents.join('|')")
+ .expect("DOMContentLoaded events"),
+ "ready:interactive|defer:interactive|dcl:interactive"
+ );
+
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ PostParsePageOwnedWork::main_document_window_load(owner),
+ )
+ .await
+ .expect("main complete/load turn should run");
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__mainLifecycleEvents.join('|')")
+ .expect("complete/load events"),
+ "ready:interactive|defer:interactive|dcl:interactive|ready:complete|load:complete"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn main_document_replacement_during_interactive_retires_old_lifecycle_actions() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/main-lifecycle-replacement.html")
+ .expect("document URL"),
+ );
+ page_vm
+ .vm_mut()
+ .eval(
+ r#"
+ globalThis.__mainReplacementLifecycleEvents = [];
+ document.addEventListener("readystatechange", () => {
+ __mainReplacementLifecycleEvents.push("ready:" + document.readyState);
+ if (document.readyState === "interactive") {
+ document.open();
+ }
+ });
+ "installed";
+ "#,
+ )
+ .expect("replacement listener should install");
+ let retired_owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("main lifecycle test requires an owner");
+ let interactive = page_vm
+ .vm_mut()
+ .finish_current_main_document_parsing(retired_owner)
+ .expect("parser EOF should produce interactive action");
+
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ PostParsePageOwnedWork::main_document_interactive(interactive),
+ )
+ .await
+ .expect("interactive replacement turn should run");
+ let current_owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("replacement must install a current owner");
+ assert_ne!(retired_owner, current_owner);
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__mainReplacementLifecycleEvents.join('|') + ':' + document.readyState")
+ .expect("replacement state"),
+ "ready:interactive:loading"
+ );
+
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ PostParsePageOwnedWork::main_document_domcontentloaded(retired_owner),
+ )
+ .await
+ .expect("stale DOMContentLoaded work should be consumed");
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ PostParsePageOwnedWork::main_document_window_load(retired_owner),
+ )
+ .await
+ .expect("stale load work should be consumed");
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__mainReplacementLifecycleEvents.join('|') + ':' + document.readyState")
+ .expect("stale lifecycle state"),
+ "ready:interactive:loading",
+ "retired owner work must not mutate or dispatch lifecycle events on the replacement"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn empty_main_parser_deferred_seal_does_not_arm_owner_source() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/empty-parser-deferred.html").expect("document URL"),
+ );
+ let task_owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("empty parser-deferred test requires a document owner");
+
+ assert!(
+ page_vm
+ .seal_main_parser_deferred_scripts(task_owner)
+ .is_none(),
+ "empty EOF seal must not create a parser-deferred marker"
+ );
+ assert!(
+ page_vm
+ .vm()
+ .document_runtime
+ .main_parser_deferred_scripts_owner()
+ .is_none(),
+ "empty EOF seal must not arm a lifecycle source that can block DCL"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn main_parser_classic_defer_dispatches_load_before_releasing_next_pending_script() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/defer-order.html").expect("document URL"),
+ );
+ page_vm
+ .vm_mut()
+ .eval("globalThis.__mainParserDeferEvents = []")
+ .expect("defer event state should initialize");
+ let first = append_parser_owned_external_classic_defer_for_page_vm_test(
+ &mut page_vm,
+ 1,
+ "first-defer",
+ Url::parse("https://example.com/first-defer.js").expect("first script URL"),
+ ScriptSource::Loaded(
+ "globalThis.__mainParserDeferEvents.push('first-exec:' + document.currentScript.id);"
+ .to_owned(),
+ ),
+ (
+ "onload",
+ "globalThis.__mainParserDeferEvents.push('first-load:' + (document.currentScript === null))",
+ ),
+ );
+ let second = append_parser_owned_external_classic_defer_for_page_vm_test(
+ &mut page_vm,
+ 2,
+ "second-defer",
+ Url::parse("https://example.com/second-defer.js").expect("second script URL"),
+ ScriptSource::Loaded(
+ "globalThis.__mainParserDeferEvents.push('second-exec:' + document.currentScript.id);"
+ .to_owned(),
+ ),
+ (
+ "onload",
+ "globalThis.__mainParserDeferEvents.push('second-load:' + (document.currentScript === null))",
+ ),
+ );
+ let task_owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("defer test requires a document owner");
+ for script in [first, second] {
+ assert!(
+ page_vm
+ .vm_mut()
+ .claim_main_parser_deferred_script(
+ task_owner,
+ script,
+ None,
+ None,
+ Default::default(),
+ )
+ .expect("loaded classic defer should be accepted")
+ );
+ }
+ assert!(
+ page_vm.has_pending_parser_owned_module_script(),
+ "accepted classic-defer PendingScripts must own the main lifecycle gate"
+ );
+ page_vm
+ .seal_main_parser_deferred_scripts(task_owner)
+ .expect("defer queue should seal");
+ assert!(
+ !page_vm.has_pending_module_script_for_target_stage(),
+ "classic defer lifecycle ownership must not enter the runtime-owned module lane"
+ );
+
+ run_ready_parser_deferred_body_for_test(&mut page_vm, &loader, "first classic defer")
+ .await;
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__mainParserDeferEvents.join('|')")
+ .expect("first defer events should evaluate"),
+ "first-exec:first-defer|first-load:true",
+ "the first PendingScript must dispatch load with currentScript cleared before the next parser-deferred slot is released"
+ );
+ assert!(
+ page_vm.has_pending_parser_owned_module_script(),
+ "the second PendingScript must retain its own lifecycle token"
+ );
+
+ run_ready_parser_deferred_body_for_test(&mut page_vm, &loader, "second classic defer")
+ .await;
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__mainParserDeferEvents.join('|')")
+ .expect("all defer events should evaluate"),
+ "first-exec:first-defer|first-load:true|second-exec:second-defer|second-load:true"
+ );
+ assert!(
+ !page_vm.has_pending_parser_owned_module_script(),
+ "consuming the final PendingScript must release the lifecycle gate"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn main_parser_classic_defer_settles_script_reactions_before_load() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/defer-checkpoint-order.html")
+ .expect("document URL"),
+ );
+ page_vm
+ .vm_mut()
+ .eval("globalThis.__mainParserDeferCheckpointEvents = []")
+ .expect("defer checkpoint state should initialize");
+ let script = append_parser_owned_external_classic_defer_for_page_vm_test(
+ &mut page_vm,
+ 1,
+ "checkpoint-defer",
+ Url::parse("https://example.com/checkpoint-defer.js").expect("script URL"),
+ ScriptSource::Loaded(
+ r#"
+globalThis.__mainParserDeferCheckpointEvents.push('script');
+queueMicrotask(() => globalThis.__mainParserDeferCheckpointEvents.push('script-microtask'));
+"#
+ .to_owned(),
+ ),
+ (
+ "onload",
+ "globalThis.__mainParserDeferCheckpointEvents.push('load'); queueMicrotask(() => globalThis.__mainParserDeferCheckpointEvents.push('load-microtask'))",
+ ),
+ );
+ let task_owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("defer checkpoint test requires a document owner");
+ assert!(
+ page_vm
+ .vm_mut()
+ .claim_main_parser_deferred_script(
+ task_owner,
+ script,
+ None,
+ None,
+ Default::default(),
+ )
+ .expect("loaded classic defer should be accepted")
+ );
+ page_vm
+ .seal_main_parser_deferred_scripts(task_owner)
+ .expect("defer queue should seal");
+
+ run_and_finish_ready_parser_deferred_task_for_test(
+ &mut page_vm,
+ &loader,
+ "classic defer checkpoint ordering",
+ )
+ .await;
+
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__mainParserDeferCheckpointEvents.join('|')")
+ .expect("defer checkpoint events should evaluate"),
+ "script|script-microtask|load|load-microtask",
+ "classic-defer evaluation reactions must settle before load and the selected parser task must then settle load reactions"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn main_parser_classic_defer_load_replacement_retires_old_pending_queue() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/defer-replacement.html").expect("document URL"),
+ );
+ page_vm
+ .vm_mut()
+ .eval("globalThis.__mainParserDeferReplacementEvents = []")
+ .expect("replacement event state should initialize");
+ let first = append_parser_owned_external_classic_defer_for_page_vm_test(
+ &mut page_vm,
+ 1,
+ "replacement-defer",
+ Url::parse("https://example.com/replacement-defer.js")
+ .expect("replacement script URL"),
+ ScriptSource::Loaded(
+ "globalThis.__mainParserDeferReplacementEvents.push('execute');".to_owned(),
+ ),
+ (
+ "onload",
+ "globalThis.__mainParserDeferReplacementEvents.push('load'); document.open(); document.write(\"<!doctype html><html><body><main id='replacement'>replacement</main></body></html>\"); document.close();",
+ ),
+ );
+ let stale = append_parser_owned_external_classic_defer_for_page_vm_test(
+ &mut page_vm,
+ 2,
+ "stale-defer",
+ Url::parse("https://example.com/stale-defer.js").expect("stale script URL"),
+ ScriptSource::Loaded(
+ "globalThis.__mainParserDeferReplacementEvents.push('stale-execute');".to_owned(),
+ ),
+ (
+ "onload",
+ "globalThis.__mainParserDeferReplacementEvents.push('stale-load')",
+ ),
+ );
+ let task_owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("replacement test requires a document owner");
+ for script in [first, stale] {
+ assert!(
+ page_vm
+ .vm_mut()
+ .claim_main_parser_deferred_script(
+ task_owner,
+ script,
+ None,
+ None,
+ Default::default(),
+ )
+ .expect("classic defer should be accepted")
+ );
+ }
+ page_vm
+ .seal_main_parser_deferred_scripts(task_owner)
+ .expect("replacement defer queue should seal");
+
+ run_ready_parser_deferred_body_for_test(
+ &mut page_vm,
+ &loader,
+ "replacement classic defer",
+ )
+ .await;
+ assert_ne!(
+ page_vm.vm().current_main_document_task_owner(),
+ Some(task_owner),
+ "document.open from the load handler must rotate the document owner"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__mainParserDeferReplacementEvents.join('|')")
+ .expect("replacement events should evaluate"),
+ "execute|load",
+ "old parser-deferred work must stop after its completion event replaces the document"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(document.getElementById('replacement') !== null)")
+ .expect("replacement document should evaluate"),
+ "true"
+ );
+ assert!(
+ page_vm
+ .vm()
+ .document_runtime
+ .main_parser_deferred_scripts_owner()
+ .is_none(),
+ "replacement must disarm the retired parser-deferred owner source"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn main_parser_classic_defer_execution_can_replace_the_document() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/defer-execution-replacement.html")
+ .expect("document URL"),
+ );
+ page_vm
+ .vm_mut()
+ .eval("globalThis.__mainParserDeferExecutionReplacementEvents = []")
+ .expect("replacement event state should initialize");
+ let script = append_parser_owned_external_classic_defer_for_page_vm_test(
+ &mut page_vm,
+ 1,
+ "replacement-defer",
+ Url::parse("https://example.com/replacement-defer.js")
+ .expect("replacement script URL"),
+ ScriptSource::Loaded(
+ "globalThis.__mainParserDeferExecutionReplacementEvents.push('execute'); document.open(); document.write(\"<!doctype html><html><body><main id='replacement'>replacement</main></body></html>\"); document.close(); globalThis.__mainParserDeferExecutionReplacementEvents.push('after-open');"
+ .to_owned(),
+ ),
+ (
+ "onload",
+ "globalThis.__mainParserDeferExecutionReplacementEvents.push('load')",
+ ),
+ );
+ let task_owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("replacement test requires a document owner");
+ assert!(
+ page_vm
+ .vm_mut()
+ .claim_main_parser_deferred_script(
+ task_owner,
+ script,
+ None,
+ None,
+ Default::default(),
+ )
+ .expect("classic defer should be accepted")
+ );
+ page_vm
+ .seal_main_parser_deferred_scripts(task_owner)
+ .expect("replacement defer queue should seal");
+
+ run_ready_parser_deferred_body_for_test(
+ &mut page_vm,
+ &loader,
+ "replacement classic defer execution",
+ )
+ .await;
+ assert_ne!(
+ page_vm.vm().current_main_document_task_owner(),
+ Some(task_owner),
+ "document.open from deferred execution must rotate the document owner"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__mainParserDeferExecutionReplacementEvents.join('|')")
+ .expect("replacement events should evaluate"),
+ "execute|after-open",
+ "replacement must prevent the retired script element load event from dispatching"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(document.getElementById('replacement') !== null)")
+ .expect("replacement document should evaluate"),
+ "true"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn main_parser_classic_defer_source_failure_dispatches_typed_error_without_refetch() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let (mut page_vm, mut page_resource_queue, mut owner_wake_rx) =
+ page_vm_with_bound_task_sources_and_owner_wake(
+ &loader,
+ Url::parse("https://example.com/defer-failure.html").expect("document URL"),
+ );
+ page_vm
+ .vm_mut()
+ .eval("globalThis.__mainParserDeferFailureEvents = []")
+ .expect("failure event state should initialize");
+ let failed = append_parser_owned_external_classic_defer_for_page_vm_test(
+ &mut page_vm,
+ 1,
+ "failed-defer",
+ Url::parse("https://defer-failure.test/missing.js").expect("failed script URL"),
+ ScriptSource::External,
+ (
+ "onerror",
+ "globalThis.__mainParserDeferFailureEvents.push('error:' + (document.currentScript === null))",
+ ),
+ );
+ let failed_node_id = failed.node_id;
+ let task_owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("failure test requires a document owner");
+ assert!(
+ page_vm
+ .vm_mut()
+ .claim_main_parser_deferred_script(
+ task_owner,
+ failed,
+ Some(crate::planning::SharedScriptSourceLoad::ready_err(
+ "prepared source failure",
+ )),
+ None,
+ Default::default(),
+ )
+ .expect("failed classic defer should be accepted before source start")
+ );
+ page_vm
+ .seal_main_parser_deferred_scripts(task_owner)
+ .expect("failed defer queue should seal without waiting");
+ assert!(
+ page_vm.has_pending_parser_owned_module_script(),
+ "source failure must retain lifecycle ownership until its owner turn dispatches error"
+ );
+ loop {
+ let wake = owner_wake_rx
+ .recv()
+ .await
+ .expect("ready source failure must keep the Page owner wake route open");
+ if wake.source_for_test()
+ == crate::page_task_queue::RendererOwnerWakeSource::NetworkingTask
+ {
+ break;
+ }
+ }
+ let source_failure = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_resource_queue)
+ .expect("source terminal should arbitrate")
+ .expect("source terminal should apply");
+ assert_eq!(
+ source_failure.action.source,
+ RendererOwnerResourceActivitySource::MainParserDeferredClassicSource
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__mainParserDeferFailureEvents.join('|')")
+ .expect("pre-turn failure events should evaluate"),
+ "",
+ "resource completion must only update PendingScript state"
+ );
+
+ run_ready_parser_deferred_body_for_test(&mut page_vm, &loader, "failed classic defer")
+ .await;
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__mainParserDeferFailureEvents.join('|')")
+ .expect("failure events should evaluate"),
+ "error:true"
+ );
+ assert!(
+ !page_vm.has_pending_parser_owned_module_script(),
+ "source-failure completion must release its exact lifecycle token"
+ );
+ let run = page_vm
+ .report
+ .runs
+ .iter()
+ .find(|run| run.node_id() == failed_node_id)
+ .expect("source failure owner turn should record one failed run");
+ assert!(matches!(run.outcome(), ScriptRunOutcome::Failed(_)));
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn main_parser_after_parsing_queue_orders_module_before_ready_classic_defer() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/page.html").expect("document URL"),
+ );
+ let module_url = Url::parse("https://example.com/ordered-module.mjs").expect("module URL");
+ let module =
+ prepared_external_module_for_page_vm_test_with_node(&page_vm, 9101, module_url.clone());
+ let (classic_node, classic_handle) = {
+ let runtime = &mut page_vm.vm_mut().document_runtime;
+ let body = runtime
+ .snapshot_document()
+ .document_body_handle()
+ .expect("test document body");
+ let script_node = runtime.dom_host_mut().create_element("script");
+ assert!(runtime.dom_host_mut().append_child(body, script_node));
+ let handle = runtime.bind_document_write_owned_script_handle_for_node(script_node);
+ (script_node, handle)
+ };
+ let mut classic = prepared_loaded_classic_for_page_vm_test(
+ &page_vm,
+ 9102,
+ "globalThis.__orderedClassicDefer = 1;",
+ );
+ classic.node_id = classic_node;
+ classic.host_script_handle = Some(classic_handle);
+ classic.mode = ScriptMode::Defer;
+
+ let task_owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("mixed parser-deferred test requires a current document owner");
+ assert!(
+ page_vm
+ .vm_mut()
+ .claim_main_parser_deferred_script(
+ task_owner,
+ classic.clone(),
+ None,
+ None,
+ Default::default(),
+ )
+ .expect("classic defer PendingScript should be accepted")
+ );
+ assert!(
+ page_vm
+ .vm_mut()
+ .claim_main_parser_deferred_script(
+ task_owner,
+ module.clone(),
+ None,
+ None,
+ Default::default(),
+ )
+ .expect("module defer PendingScript should start its graph after acceptance")
+ );
+ let _marker = page_vm
+ .seal_main_parser_deferred_scripts(task_owner)
+ .expect("mixed parser-deferred batch should install");
+ page_vm
+ .page_task_queue
+ .extend_post_parse_work([PostParsePageOwnedWork::lifecycle_work(
+ PostParseLifecycleWork::test_domcontentloaded(),
+ )]);
+ assert!(
+ poll_post_parse_document_processing_action_for_test(&mut page_vm).is_none(),
+ "pending earlier module must hold DCL without exposing later classic work"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__orderedClassicDefer)")
+ .expect("read later classic side effect while module is pending"),
+ "undefined",
+ "later ready classic defer must stay behind the earlier module PendingScript"
+ );
+ assert!(
+ !page_vm.has_ready_parser_owned_document_script_action(),
+ "mixed after-parsing order must not materialize broad ready work"
+ );
+
+ enqueue_parser_owned_module_script_fetch_completion_for_test(
+ &mut page_vm,
+ 0,
+ &module_url,
+ "globalThis.__orderedModuleDefer = 1; export const value = 1;",
+ );
+ assert!(
+ run_next_main_module_fetch_terminal_for_test(&mut page_vm)
+ .expect("module graph completion should run")
+ .is_some()
+ );
+ run_ready_parser_deferred_body_for_test(&mut page_vm, &loader, "earlier module release")
+ .await;
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__orderedModuleDefer)")
+ .expect("read earlier module side effect"),
+ "1"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__orderedClassicDefer)")
+ .expect("read later classic before its owner turn"),
+ "undefined",
+ "one parser owner turn must release only the current document-order slot"
+ );
+
+ run_ready_parser_deferred_body_for_test(&mut page_vm, &loader, "later classic release")
+ .await;
+ let classic_run = page_vm
+ .report
+ .runs
+ .iter()
+ .find(|run| run.node_id() == classic.node_id)
+ .unwrap_or_else(|| {
+ panic!(
+ "later classic owner turn should report a run: {:?}",
+ page_vm.report.runs
+ )
+ });
+ assert!(
+ matches!(classic_run.outcome(), ScriptRunOutcome::Executed),
+ "later classic owner turn should execute, got {classic_run:?}"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__orderedClassicDefer)")
+ .expect("read later classic side effect"),
+ "1"
+ );
+ assert!(
+ page_vm
+ .vm()
+ .document_runtime
+ .main_parser_deferred_scripts_owner()
+ .is_none(),
+ "consuming the final ordered slot must disarm the document owner source"
+ );
+ assert!(
+ !page_vm.has_pending_parser_owned_module_script(),
+ "mixed classic/module order must release every lifecycle token"
+ );
+ assert!(matches!(
+ poll_post_parse_document_processing_action_for_test(&mut page_vm),
+ Some(crate::document_runtime::DocumentProcessingAction::PostParsePageOwnedWork(work))
+ if work.is_domcontentloaded_task()
+ ));
+ })
+ .await;
+}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/extracted/main_module_graphs.rs b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/main_module_graphs.rs
new file mode 100644
index 000000000..b840317f1
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/main_module_graphs.rs
@@ -0,0 +1,684 @@
+use super::*;
+
+#[test]
+fn runtime_module_graph_wait_does_not_block_domcontentloaded_on_load_target() {
+ let mut page_vm = test_page_vm();
+ page_vm.target_stage = PageVmInitStage::Load;
+ let mut script = prepared_inline_module_for_page_vm_test(
+ &page_vm,
+ 9062,
+ "import { value } from 'late'; globalThis.__lateValue = value;",
+ );
+ script.mode = ScriptMode::Async;
+ page_vm
+ .vm_mut()
+ .document_runtime
+ .runtime_script_work_mut()
+ .dynamic_scripts
+ .requeue_failed_script_front(
+ DynamicScriptOwnerId::from_u64(1),
+ script,
+ "failed to resolve module specifier `late`".to_owned(),
+ DynamicScriptFailureKind::ModuleResolve,
+ Some(ModuleFailurePolicy::GraphFailure),
+ None,
+ None,
+ );
+
+ assert!(
+ page_vm
+ .vm_mut()
+ .has_pending_runtime_owned_module_script_graph(),
+ "the terminal graph failure must remain pending until its error owner turn"
+ );
+ assert!(
+ !page_vm.has_pending_module_script_for_target_stage(),
+ "runtime async module work must not become a DCL wait merely because the final target is Load"
+ );
+
+ page_vm
+ .vm_mut()
+ .document_runtime
+ .note_dom_content_loaded_dispatched();
+ assert!(
+ page_vm.has_pending_module_script_for_target_stage(),
+ "after DCL the same terminal graph work must delay Load until error dispatch settles it"
+ );
+}
+#[tokio::test(flavor = "current_thread")]
+async fn main_parser_async_module_graph_failure_settles_exact_load_delay() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/main-parser-async-module-failure.html")
+ .expect("document URL"),
+ );
+ let owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("main parser async module failure test requires an owner");
+ let module_url =
+ Url::parse("https://example.com/main-parser-async-failure.mjs").expect("module URL");
+ let mut script =
+ prepared_external_module_for_page_vm_test_with_node(&page_vm, 9062, module_url.clone());
+ script.mode = ScriptMode::Async;
+
+ assert!(
+ page_vm
+ .vm_mut()
+ .accept_main_parser_async_module_script(owner, &script)?
+ );
+ enqueue_parser_owned_module_script_fetch_error_for_test(
+ &mut page_vm,
+ 0,
+ &module_url,
+ "async module graph failed",
+ );
+ assert!(run_next_main_module_fetch_terminal_for_test(&mut page_vm)?.is_some());
+ assert!(
+ run_one_parser_owned_main_document_runtime_turn_for_test(&mut page_vm, &loader).await?,
+ "graph failure should run through the watched PendingScript owner"
+ );
+ assert_eq!(
+ page_vm
+ .vm()
+ .current_main_document_has_async_script_load_delay(owner),
+ Some(true),
+ "failure reporting must be ordered before lifecycle settlement"
+ );
+
+ run_main_async_script_load_delay_settlement_for_test(
+ &mut page_vm,
+ &loader,
+ owner,
+ "main parser async module graph failure",
+ )
+ .await;
+ assert_eq!(
+ page_vm
+ .vm()
+ .current_main_document_has_async_script_load_delay(owner),
+ Some(false)
+ );
+ assert!(
+ page_vm.report.runs.iter().any(|run| {
+ run.url() == &module_url && matches!(run.outcome(), ScriptRunOutcome::Failed(_))
+ }),
+ "graph failure should remain an observable failed script run"
+ );
+ Ok::<(), anyhow::Error>(())
+ })
+ .await
+ .expect("main parser async module failure lifecycle test should run");
+}
+#[tokio::test(flavor = "current_thread")]
+async fn main_parser_module_tla_releases_lifecycle_at_evaluation_start() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/main-tla.html").expect("document URL"),
+ );
+ let module_url = Url::parse("https://example.com/main-parser-tla.mjs").expect("module URL");
+ let script =
+ prepared_external_module_for_page_vm_test_with_node(&page_vm, 9050, module_url.clone());
+ let parser_module_work = install_parser_module_defer_work(&mut page_vm, script);
+ assert!(
+ page_vm.has_pending_parser_owned_module_script(),
+ "the accepted module PendingScript must own a lifecycle token before fetch starts"
+ );
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(&loader, parser_module_work)
+ .await
+ .expect("parser module owner should wait for its graph");
+
+ enqueue_parser_owned_module_script_fetch_completion_for_test(
+ &mut page_vm,
+ 0,
+ &module_url,
+ concat!(
+ "globalThis.__mainParserTlaStarted = 1;",
+ "await new Promise(resolve => { globalThis.__resolveMainParserTla = resolve; });",
+ "globalThis.__mainParserTlaFinished = 1; export const value = 1;",
+ ),
+ );
+ assert!(
+ run_next_main_module_fetch_terminal_for_test(&mut page_vm)
+ .expect("TLA module graph completion should apply")
+ .is_some()
+ );
+ run_ready_parser_deferred_body_for_test(
+ &mut page_vm,
+ &loader,
+ "main parser TLA evaluation start",
+ )
+ .await;
+
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__mainParserTlaStarted)")
+ .expect("read TLA start"),
+ "1"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__mainParserTlaFinished)")
+ .expect("read suspended TLA body"),
+ "undefined"
+ );
+ assert!(
+ !page_vm.has_pending_parser_owned_module_script(),
+ "the TLA promise must not retain parser-deferred lifecycle ownership"
+ );
+ assert_eq!(
+ page_vm
+ .report
+ .runs
+ .iter()
+ .filter(|run| run.url() == &module_url)
+ .count(),
+ 1,
+ "starting module evaluation must apply script completion exactly once"
+ );
+
+ page_vm
+ .vm_mut()
+ .eval("globalThis.__resolveMainParserTla(); 'resolved'")
+ .expect("resolve main parser TLA");
+ run_parser_module_completion_turns_for_test(
+ &mut page_vm,
+ &loader,
+ 1,
+ "main parser TLA fulfillment",
+ )
+ .await;
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__mainParserTlaFinished)")
+ .expect("read fulfilled TLA body"),
+ "1"
+ );
+ assert_eq!(
+ page_vm
+ .report
+ .runs
+ .iter()
+ .filter(|run| run.url() == &module_url)
+ .count(),
+ 1,
+ "TLA fulfillment must not redispatch script completion"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn main_parser_module_tla_rejection_reports_without_duplicate_completion() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/main-tla-rejection.html").expect("document URL"),
+ );
+ page_vm
+ .vm_mut()
+ .eval(
+ "globalThis.__mainParserTlaErrors = []; addEventListener('error', event => { __mainParserTlaErrors.push((event.error?.constructor?.name ?? 'none') + ':' + event.message); event.preventDefault(); });",
+ )
+ .expect("install main TLA error observer");
+ let module_url = Url::parse("https://example.com/main-parser-tla-rejection.mjs")
+ .expect("module URL");
+ let script = prepared_external_module_for_page_vm_test_with_node(
+ &page_vm,
+ 9051,
+ module_url.clone(),
+ );
+ let parser_module_work = install_parser_module_defer_work(&mut page_vm, script);
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ parser_module_work,
+ )
+ .await
+ .expect("parser module owner should wait for its graph");
+ enqueue_parser_owned_module_script_fetch_completion_for_test(
+ &mut page_vm,
+ 0,
+ &module_url,
+ concat!(
+ "await new Promise((_, reject) => {",
+ " globalThis.__rejectMainParserTla = reject;",
+ "}); export const value = 1;",
+ ),
+ );
+ assert!(
+ run_next_main_module_fetch_terminal_for_test(&mut page_vm)
+ .expect("TLA rejection graph completion should apply")
+ .is_some()
+ );
+ run_ready_parser_deferred_body_for_test(
+ &mut page_vm,
+ &loader,
+ "main parser TLA rejection evaluation start",
+ )
+ .await;
+ assert!(
+ !page_vm.has_pending_parser_owned_module_script(),
+ "pending rejection must not retain parser lifecycle ownership"
+ );
+
+ page_vm
+ .vm_mut()
+ .eval("globalThis.__rejectMainParserTla(new TypeError('main TLA rejected')); 'rejected'")
+ .expect("reject main parser TLA");
+ run_parser_module_completion_turns_for_test(
+ &mut page_vm,
+ &loader,
+ 1,
+ "main parser TLA rejection",
+ )
+ .await;
+ let error = page_vm
+ .vm_mut()
+ .eval("__mainParserTlaErrors.join('|')")
+ .expect("read TLA rejection event");
+ assert!(
+ error.contains("TypeError:") && error.contains("main TLA rejected"),
+ "TLA rejection must retain typed window-error metadata: {error}"
+ );
+ assert_eq!(
+ page_vm
+ .report
+ .runs
+ .iter()
+ .filter(|run| run.url() == &module_url)
+ .count(),
+ 1,
+ "TLA rejection must not redispatch or rerecord script completion"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn parser_module_graph_failure_leaves_shared_sibling_fetch_for_joined_script_waiter() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/page.html").expect("document URL"),
+ );
+ let first_root_url =
+ Url::parse("https://example.com/first-root.mjs").expect("first root URL");
+ let second_root_url =
+ Url::parse("https://example.com/second-root.mjs").expect("second root URL");
+ let bad_url = Url::parse("https://example.com/bad.mjs").expect("bad module URL");
+ let shared_url = Url::parse("https://example.com/shared.mjs").expect("shared module URL");
+ let shared_key = ModuleMapKey::java_script(shared_url.clone());
+ let first_script =
+ prepared_external_module_for_page_vm_test_with_node(&page_vm, 9201, first_root_url.clone());
+ let second_script = prepared_external_module_for_page_vm_test_with_node(
+ &page_vm,
+ 9202,
+ second_root_url.clone(),
+ );
+
+ let first_parser_module_work =
+ install_parser_module_defer_work(&mut page_vm, first_script);
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ first_parser_module_work,
+ )
+ .await
+ .expect("first module defer page task should watch loading tree");
+
+ enqueue_parser_owned_module_script_fetch_completion_for_test(
+ &mut page_vm,
+ 0,
+ &first_root_url,
+ r#"
+import "./bad.mjs";
+import "./shared.mjs";
+export const first = 1;
+"#,
+ );
+ assert!(
+ run_next_main_module_fetch_terminal_for_test(&mut page_vm)
+ .expect("first root completion should run")
+ .is_some(),
+ "first root completion should be consumed"
+ );
+
+ let second_parser_module_work =
+ install_parser_module_defer_work(&mut page_vm, second_script);
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ second_parser_module_work,
+ )
+ .await
+ .expect("second module defer page task should watch loading tree");
+ enqueue_parser_owned_module_script_fetch_completion_for_test(
+ &mut page_vm,
+ 3,
+ &second_root_url,
+ r#"
+import "./shared.mjs";
+export const second = 2;
+"#,
+ );
+ assert!(
+ run_next_main_module_fetch_terminal_for_test(&mut page_vm)
+ .expect("second root completion should run")
+ .is_some(),
+ "second root completion should be consumed"
+ );
+ assert!(
+ page_vm.has_pending_parser_owned_module_fetch(),
+ "second graph should be waiting on the first graph's shared sibling fetch"
+ );
+ let shared_fetch_target = page_vm
+ .vm()
+ .current_main_parser_module_graph_fetch_target(2)
+ .expect("shared fetch must retain its producer-captured target before owner failure");
+
+ enqueue_parser_owned_module_script_fetch_error_for_test(
+ &mut page_vm,
+ 1,
+ &bad_url,
+ "bad dependency failed",
+ );
+ assert!(
+ run_next_main_module_fetch_terminal_for_test(&mut page_vm)
+ .expect("bad dependency completion should run")
+ .is_some(),
+ "bad dependency failure should be consumed"
+ );
+
+ let shared_entry = page_vm
+ .vm()
+ .document_runtime
+ .native_module_entry_id(&shared_key)
+ .expect("cancelled shared sibling fetch should remain in the module map");
+ assert_eq!(
+ page_vm
+ .vm()
+ .document_runtime
+ .native_module_entry_state(shared_entry),
+ ModuleMapEntryState::Fetching,
+ "owner failure must not globally fail a shared module map entry while its network fetch is still pending"
+ );
+ assert!(
+ page_vm.has_pending_parser_owned_module_fetch(),
+ "joined parser graph should keep waiting for the shared fetch network completion"
+ );
+ assert!(
+ !page_vm.has_ready_parser_owned_document_script_action(),
+ "ordered graph failure must stay in the parser PendingScript instead of the broad ready lane"
+ );
+ run_ready_parser_deferred_body_for_test(
+ &mut page_vm,
+ &loader,
+ "bad dependency failure",
+ )
+ .await;
+ let first_failure = page_vm
+ .report
+ .runs
+ .iter()
+ .find(|run| run.url() == &first_root_url)
+ .and_then(|run| match run.outcome() {
+ ScriptRunOutcome::Failed(message) => Some(message),
+ _ => None,
+ })
+ .expect("first parser module script should fail after bad dependency");
+ assert!(
+ first_failure.contains("bad dependency failed"),
+ "first script should report the real dependency failure: {first_failure}"
+ );
+
+ enqueue_parser_owned_module_script_fetch_completion_for_target_for_test(
+ &mut page_vm,
+ shared_fetch_target,
+ &shared_url,
+ "export const shared = 1;",
+ );
+ assert!(
+ run_next_main_module_fetch_terminal_for_test(&mut page_vm)
+ .expect("shared dependency completion should run")
+ .is_some(),
+ "shared dependency completion should be consumed"
+ );
+ assert!(
+ page_vm.vm_mut().has_ready_native_module_owner_actions(),
+ "shared module-map terminal must publish its joined-client owner event"
+ );
+ run_next_native_module_owner_event_for_test(
+ &mut page_vm,
+ &loader,
+ "shared parser module-map completion",
+ )
+ .await;
+ assert!(
+ !page_vm.has_pending_parser_owned_module_fetch(),
+ "joined parser graph should resume through the native module owner turn"
+ );
+ run_ready_parser_deferred_body_for_test(
+ &mut page_vm,
+ &loader,
+ "joined parser module graph completion",
+ )
+ .await;
+ run_parser_module_completion_turns_for_test(
+ &mut page_vm,
+ &loader,
+ 0,
+ "joined parser module graph completion",
+ )
+ .await;
+ assert!(
+ !page_vm.has_pending_parser_owned_module_script(),
+ "joined parser graph should no longer be pending after its ready script executes"
+ );
+ let second_run = page_vm
+ .report
+ .runs
+ .iter()
+ .find(|run| run.url() == &second_root_url)
+ .expect("second parser module script should run after joined fetch wakeup");
+ assert!(
+ matches!(second_run.outcome(), ScriptRunOutcome::Executed),
+ "second parser module script should execute after joined fetch wakeup: {:?}",
+ second_run.outcome()
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn stale_main_parser_module_terminal_drops_after_pending_script_retirement() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/page.html").expect("document URL"),
+ );
+ let old_task_owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("original main document task owner should exist");
+ let old_owner = MainParserDocumentOwner::new(old_task_owner);
+ let module_url =
+ Url::parse("https://example.com/stale-ready-module.mjs").expect("module URL");
+ let module_script =
+ prepared_external_module_for_page_vm_test(&page_vm, module_url.clone());
+
+ let replacement_script = prepared_loaded_classic_for_page_vm_test(
+ &page_vm,
+ 9200,
+ "document.open(); document.write('<!doctype html><p>replacement</p>'); document.close();",
+ );
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ classic_defer_work(replacement_script),
+ )
+ .await
+ .expect("replacement script task should run");
+ let stale_pending_script_id =
+ crate::document_script_scheduler::ParserPendingScriptId::new(
+ old_owner,
+ &module_script,
+ );
+ let stale_continuation = ModuleScriptContinuation::new_parser(
+ module_script,
+ stale_pending_script_id,
+ )
+ .with_completed_graph(ModuleGraphHandle {
+ root_entry: ModuleEntryId::for_test(1),
+ entries: vec![ModuleEntryId::for_test(1)],
+ });
+ let main_task_owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("main document task owner should exist");
+ let main_owner = MainParserDocumentOwner::new(main_task_owner);
+ assert_ne!(main_task_owner.document_id, old_task_owner.document_id);
+ assert_eq!(
+ main_task_owner.scheduler_lane_id,
+ old_task_owner.scheduler_lane_id,
+ "main document replacement should retain the browsing-context scheduler lane"
+ );
+ assert_eq!(
+ main_task_owner.local_window_id,
+ old_task_owner.local_window_id,
+ "document.open() should retain the main LocalWindow"
+ );
+ assert_ne!(
+ main_owner, old_owner,
+ "document replacement should install a new document-scoped parser owner"
+ );
+ let stale_work = stale_continuation.into_main_document_graph_ready_work();
+ let accepted = page_vm
+ .vm_mut()
+ .document_runtime
+ .parser_module_document_scripts_mut()
+ .notify_module_script_graph_ready_work(stale_work);
+ assert!(
+ !accepted,
+ "terminal must fail closed after its original PendingScript is retired"
+ );
+ assert!(
+ !page_vm
+ .vm()
+ .document_runtime
+ .parser_module_document_scripts()
+ .has_load_blocking_document_script_work(old_owner),
+ "retired owner must not be rematerialized by a stale terminal"
+ );
+ assert!(
+ !page_vm
+ .vm()
+ .document_runtime
+ .parser_module_document_scripts()
+ .has_load_blocking_document_script_work(main_owner),
+ "stale terminal must not enter the replacement document scheduler"
+ );
+ assert!(
+ !page_vm.has_ready_parser_owned_document_script_action(),
+ "stale terminal must not synthesize a ready action without its PendingScript"
+ );
+
+ assert!(
+ !run_one_parser_owned_main_document_runtime_turn_for_test(&mut page_vm, &loader)
+ .await
+ .expect("stale parser module ready lane should remain idle"),
+ "retired PendingScript terminal must not reach owner-specific execution"
+ );
+ assert!(
+ !page_vm.has_ready_parser_owned_document_script_action(),
+ "stale ready action should be removed from the ready lane"
+ );
+ assert!(
+ page_vm.report.runs.iter().all(|run| run.url() != &module_url),
+ "stale main parser module ready action must not produce a script run: {:?}",
+ page_vm.report.runs
+ );
+ })
+ .await;
+}
+#[test]
+fn module_graph_network_result_records_staged_response_started_with_cache_state() {
+ let mut page_vm = test_page_vm_with_document_url(
+ Url::parse("https://example.com/page.html").expect("document URL"),
+ );
+ let request_url = Url::parse("https://example.com/module.js").expect("request URL");
+ let response = crate::types::NavigationResponse::from_head_and_text_body(
+ moli_fetch::ResponseHead {
+ final_url: request_url.clone(),
+ status: 200,
+ headers: vec![("content-type".to_owned(), b"text/javascript".to_vec())],
+ request_cookie_report: None,
+ cookie_set_reports: Vec::new(),
+ redirected: false,
+ redirect_chain: Vec::new(),
+ from_cache: true,
+ negotiated_http_version: None,
+ },
+ "export default 1;".to_owned(),
+ );
+ let completion = ModuleGraphFetchCompletion {
+ load_id: 7,
+ requester: ModuleGraphFetchRequester::DynamicImport,
+ ordering: ModuleGraphFetchOrdering::Runtime,
+ request_url: request_url.clone(),
+ result: Err("source is not used by this test".to_owned()),
+ network_result: None,
+ };
+
+ page_vm
+ .vm_mut()
+ .record_module_graph_subresource_network_result(&completion, &Ok(response));
+
+ let items: Vec<_> = page_vm
+ .vm_mut()
+ .take_network_output()
+ .into_items()
+ .collect();
+ assert_eq!(
+ items.len(),
+ 3,
+ "module fetch should record staged network output"
+ );
+ let ScriptNetworkOutputItem::SubresourceRequestStarted(request) = &items[0] else {
+ panic!("first item should be requestStarted: {items:?}");
+ };
+ assert_eq!(request.url(), &request_url);
+ assert_eq!(request.resource_type(), SubresourceResourceType::Script);
+
+ let ScriptNetworkOutputItem::SubresourceResponseStarted(response) = &items[1] else {
+ panic!("second item should be responseStarted: {items:?}");
+ };
+ assert_eq!(response.final_url(), &request_url);
+ assert!(
+ response.from_cache(),
+ "module responseStarted must preserve fetch cache state"
+ );
+
+ let ScriptNetworkOutputItem::SubresourceBodyFinished(body) = &items[2] else {
+ panic!("third item should be bodyFinished: {items:?}");
+ };
+ assert!(matches!(
+ body.result(),
+ SubresourceBodyFinishedResult::Ready(_)
+ ));
+}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/extracted/modulepreload.rs b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/modulepreload.rs
new file mode 100644
index 000000000..9fa9ca954
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/modulepreload.rs
@@ -0,0 +1,1256 @@
+use super::*;
+
+#[tokio::test(flavor = "current_thread")]
+async fn child_modulepreload_start_rejects_replaced_realm_with_same_document_owner() {
+ run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm();
+ page_vm.vm_mut().eval(
+ "const frame = document.createElement('iframe'); \
+ frame.id = 'modulepreload-start-realm-replacement'; \
+ document.body.appendChild(frame);",
+ )?;
+ let child_handle = page_vm
+ .vm()
+ .element_handle_by_id_for_test("modulepreload-start-realm-replacement")
+ .expect("realm replacement fixture should install a child handle");
+ materialize_child_realm_through_page_turn_for_test(
+ &mut page_vm,
+ "modulepreload-start-realm-replacement",
+ )?;
+ let retired_target = page_vm
+ .vm()
+ .current_child_document_module_fetch_target(child_handle)
+ .expect("first child realm should have an exact module target");
+ let root_document = page_vm.document_lifecycle.identity().document;
+ page_vm
+ .page_task_executor_sources_for_test()
+ .modulepreload_start()
+ .enqueue_local_for_test(
+ root_document,
+ test_child_modulepreload_start_task_for_target(
+ retired_target,
+ "retired-modulepreload-start-realm",
+ ),
+ );
+
+ page_vm
+ .vm_mut()
+ .retire_child_frame_realm_for_test(child_handle);
+ materialize_child_realm_through_page_turn_for_test(
+ &mut page_vm,
+ "modulepreload-start-realm-replacement",
+ )?;
+ let current_target = page_vm
+ .vm()
+ .current_child_document_module_fetch_target(child_handle)
+ .expect("replacement child realm should have an exact module target");
+ assert_eq!(current_target.task_owner(), retired_target.task_owner());
+ assert_ne!(current_target.realm_id(), retired_target.realm_id());
+
+ let outcome = page_vm
+ .run_page_modulepreload_start_body_for_test()
+ .expect("stale-realm start should consume exactly one bounded turn");
+ assert_eq!(
+ outcome.action.owner,
+ RendererPageModulepreloadStartOwner::new(root_document, retired_target)
+ );
+ assert_eq!(
+ outcome.action.document_effect,
+ PageModulepreloadStartDocumentEffect::DiscardedStaleOwner {
+ current_owner: Some(RendererPageModulepreloadStartOwner::new(
+ root_document,
+ current_target,
+ )),
+ }
+ );
+
+ assert!(
+ !page_vm
+ .page_task_executor_sources_for_test()
+ .modulepreload_start()
+ .has_ready_task(),
+ "a stale typed start must consume only its stable source head"
+ );
+ Ok::<_, anyhow::Error>(())
+ })
+ .await
+ .expect("same-Document stale modulepreload start realm test should run");
+}
+#[tokio::test(flavor = "current_thread")]
+async fn child_modulepreload_start_rejects_reused_local_owner_from_retired_root_document() {
+ run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm();
+ page_vm.vm_mut().eval(
+ "const frame = document.createElement('iframe'); \
+ frame.id = 'modulepreload-start-root-replacement'; \
+ document.body.appendChild(frame);",
+ )?;
+ let child_handle = page_vm
+ .vm()
+ .element_handle_by_id_for_test("modulepreload-start-root-replacement")
+ .expect("root replacement fixture should install a child handle");
+ materialize_child_realm_through_page_turn_for_test(
+ &mut page_vm,
+ "modulepreload-start-root-replacement",
+ )?;
+ let reused_local_target = page_vm
+ .vm()
+ .current_child_document_module_fetch_target(child_handle)
+ .expect("current PageVm should expose an exact child target");
+ let current_root = page_vm.document_lifecycle.identity().document;
+ let retired_root = current_root.successor_for_testing();
+ page_vm.page_task_executor_sources_for_test().modulepreload_start()
+ .enqueue_local_for_test(
+ retired_root,
+ test_child_modulepreload_start_task_for_target(
+ reused_local_target,
+ "retired-root-modulepreload-start",
+ ),
+ );
+
+ let outcome = page_vm
+ .run_page_modulepreload_start_body_for_test()
+ .expect("retired-root start should consume one stale turn");
+ assert_eq!(
+ outcome.action.owner,
+ RendererPageModulepreloadStartOwner::new(retired_root, reused_local_target)
+ );
+ assert_eq!(
+ outcome.action.document_effect,
+ PageModulepreloadStartDocumentEffect::DiscardedStaleOwner {
+ current_owner: Some(RendererPageModulepreloadStartOwner::new(
+ current_root,
+ reused_local_target,
+ )),
+ },
+ "PageVm-local owner counters may collide after replacement, so the root token must remain part of authorization"
+ );
+
+ assert!(
+ !page_vm.page_task_executor_sources_for_test().modulepreload_start()
+ .has_ready_task(),
+ "a root-stale typed start must consume only its stable source head"
+ );
+ Ok::<_, anyhow::Error>(())
+ })
+ .await
+ .expect("retired-root modulepreload start test should run");
+}
+#[tokio::test(flavor = "current_thread")]
+async fn modulepreload_start_source_consumes_one_exact_owner_per_turn_in_fifo_order() {
+ run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm();
+ let root_document = page_vm.document_lifecycle.identity().document;
+ let first_target = ChildDocumentModuleFetchTarget::new(
+ crate::dom::native::NativeNodeId::new(701),
+ FrameDocumentTaskOwner::new(
+ crate::frame_owner_model::FrameSchedulerLaneId(703),
+ crate::frame_owner_model::LocalWindowId(709),
+ DocumentId(719),
+ ),
+ FrameRealmId(727),
+ );
+ let second_target = ChildDocumentModuleFetchTarget::new(
+ crate::dom::native::NativeNodeId::new(733),
+ FrameDocumentTaskOwner::new(
+ crate::frame_owner_model::FrameSchedulerLaneId(739),
+ crate::frame_owner_model::LocalWindowId(743),
+ DocumentId(751),
+ ),
+ FrameRealmId(757),
+ );
+ let source = page_vm
+ .page_task_executor_sources_for_test()
+ .modulepreload_start();
+ source.enqueue_local_for_test(
+ root_document,
+ test_child_modulepreload_start_task_for_target(first_target, "first-start-turn"),
+ );
+ source.enqueue_local_for_test(
+ root_document,
+ test_child_modulepreload_start_task_for_target(second_target, "second-start-turn"),
+ );
+
+ let first = page_vm
+ .run_page_modulepreload_start_body_for_test()
+ .expect("first start should consume one turn");
+ assert_eq!(
+ first.action.owner,
+ RendererPageModulepreloadStartOwner::new(root_document, first_target)
+ );
+ assert!(matches!(
+ first.action.document_effect,
+ PageModulepreloadStartDocumentEffect::DiscardedStaleOwner {
+ current_owner: None
+ }
+ ));
+
+ let second = page_vm
+ .run_page_modulepreload_start_body_for_test()
+ .expect("second start should consume a separate turn");
+ assert_eq!(
+ second.action.owner,
+ RendererPageModulepreloadStartOwner::new(root_document, second_target)
+ );
+
+ assert!(!source.has_ready_task());
+ Ok::<_, anyhow::Error>(())
+ })
+ .await
+ .expect("modulepreload start FIFO test should run");
+}
+#[tokio::test]
+async fn page_vm_child_modulepreload_terminal_event_does_not_delay_complete() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let page_vm = test_page_vm();
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ lifecycle_turns,
+ events_before_preload_event,
+ ready_state_before_preload_event,
+ events_after_preload_event,
+ ready_state_after_preload_event,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ page_vm.vm_mut().eval(
+ r#"
+(() => {
+ globalThis.__childModulepreloadTerminalEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childModulepreloadTerminalEvents.push("frame-load");
+ frame.srcdoc = `
+ <script>
+ parent.__childModulepreloadTerminalEvents.push("before");
+ document.addEventListener("DOMContentLoaded", () => {
+ parent.__childModulepreloadTerminalEvents.push("dcl:" + document.readyState);
+ });
+ <\/script>
+ <link rel="modulepreload" href="/invalid-modulepreload.bin" as="image" onerror="parent.__childModulepreloadTerminalEvents.push('preload-error')">
+ <script>parent.__childModulepreloadTerminalEvents.push("after");<\/script>
+ `;
+ body.appendChild(frame);
+})()
+"#,
+ )?;
+
+ let mut lifecycle_turns = Vec::new();
+ while let Some(source) = page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await
+ {
+ lifecycle_turns.push(source);
+ }
+
+ let events_before_preload_event = page_vm
+ .vm_mut()
+ .eval("__childModulepreloadTerminalEvents.join('|')")?;
+ let ready_state_before_preload_event = page_vm.vm_mut().eval(
+ "document.querySelector('iframe').contentDocument?.readyState || 'missing'",
+ )?;
+
+ assert!(
+ page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ChildModulepreloadEventAction,
+ &loader,
+ )
+ .await?,
+ "the deliberately withheld modulepreload error action must remain queued"
+ );
+ let events_after_preload_event = page_vm
+ .vm_mut()
+ .eval("__childModulepreloadTerminalEvents.join('|')")?;
+ let ready_state_after_preload_event = page_vm.vm_mut().eval(
+ "document.querySelector('iframe').contentDocument?.readyState || 'missing'",
+ )?;
+
+ Ok::<_, anyhow::Error>((
+ lifecycle_turns,
+ events_before_preload_event,
+ ready_state_before_preload_event,
+ events_after_preload_event,
+ ready_state_after_preload_event,
+ ))
+ })
+ .await
+ .expect("terminal child modulepreload lifecycle test should run");
+
+ assert!(
+ lifecycle_turns
+ .iter()
+ .filter(|source| **source == ChildFrameSemanticTurnKind::DocumentLifecycle)
+ .count()
+ >= 3,
+ "interactive, DOMContentLoaded, and complete must advance while the terminal link event remains queued: {lifecycle_turns:?}"
+ );
+ assert!(
+ lifecycle_turns.contains(&ChildFrameSemanticTurnKind::HostLoad),
+ "iframe load must remain independently runnable while the terminal link event is withheld: {lifecycle_turns:?}"
+ );
+ assert_eq!(
+ events_before_preload_event,
+ "before|after|dcl:interactive|frame-load",
+ "child complete and iframe load must not wait for the queued modulepreload error"
+ );
+ assert_eq!(
+ ready_state_before_preload_event, "complete",
+ "a terminal modulepreload event must not hold the child Document load gate"
+ );
+ assert_eq!(
+ events_after_preload_event,
+ "before|after|dcl:interactive|frame-load|preload-error",
+ "the independently queued modulepreload event must still dispatch afterward"
+ );
+ assert_eq!(
+ ready_state_after_preload_event, "complete",
+ "post-complete modulepreload dispatch must not regress readyState"
+ );
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_modulepreload_fetch_does_not_delay_iframe_load() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/standalone-preload.js",
+ "HTTP/1.1 200 OK",
+ "export const preloaded = true;".to_owned(),
+ Duration::from_millis(100),
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let (owner_wake_tx, owner_wake_rx) = tokio::sync::mpsc::unbounded_channel();
+ let owner_wake = crate::page_task_queue::RendererOwnerWakeSender::new(
+ owner_wake_tx,
+ crate::runtime::RendererPageToken::new_for_testing(crate::PageId::new_for_testing(2)),
+ );
+ let runtime_hooks =
+ PageVmRuntimeHooks::standalone_with_owner_wake_without_owner_reservation_for_test(
+ owner_wake,
+ );
+ let page_vm = test_page_vm_with_loader_document_url_and_hooks(
+ &loader,
+ Vec::new(),
+ document_url,
+ runtime_hooks,
+ );
+ let page_resource_queue = page_vm.page_resource_completion_queue();
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ typed_modulepreload_start_ran,
+ startup_sources,
+ events_before_completion,
+ ready_state_before_completion,
+ completion,
+ events_after_preload_event,
+ ready_state_after_preload_event,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let mut page_resource_queue = page_resource_queue;
+ let mut owner_wake_rx = owner_wake_rx;
+ let preload_url = format!("{base_url}/standalone-preload.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childStandaloneModulepreloadEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childStandaloneModulepreloadEvents.push("frame-load");
+ frame.srcdoc = `
+ <script>
+ parent.__childStandaloneModulepreloadEvents.push("before");
+ document.addEventListener("DOMContentLoaded", () => {{
+ parent.__childStandaloneModulepreloadEvents.push("dcl:" + document.readyState);
+ }});
+ <\/script>
+ <link rel="modulepreload" href="{preload_url}" onload="parent.__childStandaloneModulepreloadEvents.push('preload-load')" onerror="parent.__childStandaloneModulepreloadEvents.push('preload-error')">
+ <script>parent.__childStandaloneModulepreloadEvents.push("after");<\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let mut typed_modulepreload_start_ran = false;
+ let mut startup_sources = Vec::new();
+ for _ in 0..10 {
+ if page_resource_queue.has_ready_completion() {
+ break;
+ }
+ if page_vm.page_task_executor_sources_for_test().modulepreload_start()
+ .has_ready_task()
+ {
+ assert!(
+ page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ModulepreloadStart,
+ &loader,
+ )
+ .await?,
+ "typed modulepreload start should enter the production selected dispatcher",
+ );
+
+ assert!(
+ !typed_modulepreload_start_ran,
+ "one parser-discovered link must publish one typed start"
+ );
+ typed_modulepreload_start_ran = true;
+ continue;
+ }
+ let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
+ break;
+ };
+ startup_sources.push(source);
+ }
+ if !page_resource_queue.has_ready_completion() {
+ tokio::time::timeout(Duration::from_secs(2), async {
+ while !page_resource_queue.has_ready_completion() {
+ owner_wake_rx
+ .recv()
+ .await
+ .expect("owner-attached modulepreload wake route should remain open");
+ }
+ })
+ .await
+ .expect("typed modulepreload completion should arrive before timeout");
+ }
+ let events_before_completion = page_vm
+ .vm_mut()
+ .eval("__childStandaloneModulepreloadEvents.join('|')")?;
+ let ready_state_before_completion = page_vm.vm_mut().eval(
+ "document.querySelector('iframe').contentDocument.readyState",
+ )?;
+
+ let activity_epoch_before_completion =
+ page_vm.vm().subresource_activity_epoch();
+ let completion = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_resource_queue)?
+ .expect("typed modulepreload completion should consume one Page owner turn");
+ assert_eq!(
+ completion.action.document_effect,
+ PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
+ );
+ assert_eq!(
+ completion.action.output_effect,
+ PageResourceCompletionOutputEffect::CaptureRequired
+ );
+ assert!(
+ page_vm.vm().subresource_activity_epoch()
+ > activity_epoch_before_completion,
+ "current modulepreload Network output must advance current Document activity"
+ );
+ assert!(
+ !page_resource_queue.has_ready_completion(),
+ "one modulepreload producer terminal must be consumed exactly once"
+ );
+ let (network_records, websocket_events, websocket_lifecycle_events) =
+ split_network_output_items(page_vm.vm_mut().take_network_output());
+ assert!(websocket_events.is_empty());
+ assert!(websocket_lifecycle_events.is_empty());
+ assert_eq!(network_records.len(), 1);
+ assert!(network_records[0].frame_id().is_some());
+ assert_eq!(network_records[0].document_url().as_str(), "about:srcdoc");
+ assert_eq!(network_records[0].url().as_str(), preload_url);
+ run_expected_child_modulepreload_event_action_for_test(
+ &mut page_vm,
+ &loader,
+ "owner-scheduled child modulepreload event dispatch",
+ )
+ .await;
+ let events_after_preload_event = page_vm
+ .vm_mut()
+ .eval("__childStandaloneModulepreloadEvents.join('|')")?;
+ let ready_state_after_preload_event = page_vm.vm_mut().eval(
+ "document.querySelector('iframe').contentDocument.readyState",
+ )?;
+
+ assert_eq!(
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ None,
+ "owner-scheduled modulepreload sequence should not leave child frame work"
+ );
+
+ Ok::<_, anyhow::Error>((
+ typed_modulepreload_start_ran,
+ startup_sources,
+ events_before_completion,
+ ready_state_before_completion,
+ completion,
+ events_after_preload_event,
+ ready_state_after_preload_event,
+ ))
+ })
+ .await
+ .expect("owner-scheduled child modulepreload lifecycle test should run");
+
+ assert!(
+ typed_modulepreload_start_ran,
+ "parser-discovered modulepreload should start from its typed source: {startup_sources:?}"
+ );
+ assert!(
+ startup_sources
+ .iter()
+ .filter(|source| **source == ChildFrameSemanticTurnKind::DocumentLifecycle)
+ .count()
+ >= 3,
+ "interactive, DOMContentLoaded and complete should run while modulepreload fetch is pending: {startup_sources:?}"
+ );
+ assert!(startup_sources.contains(&ChildFrameSemanticTurnKind::HostLoad));
+ assert_eq!(
+ events_before_completion,
+ "before|after|dcl:interactive|frame-load"
+ );
+ assert_eq!(
+ ready_state_before_completion, "complete",
+ "fetching modulepreload must not delay document complete or iframe load"
+ );
+ assert!(matches!(
+ completion.action.source(),
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ ));
+ assert_eq!(
+ events_after_preload_event,
+ "before|after|dcl:interactive|frame-load|preload-load",
+ "a slow modulepreload link event may dispatch after iframe load"
+ );
+ assert_eq!(
+ ready_state_after_preload_event, "complete",
+ "post-complete modulepreload event dispatch must not regress readyState"
+ );
+
+ server
+ .await
+ .expect("standalone child modulepreload server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_modulepreload_fetch_runs_before_joined_module_root() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/preloaded-root.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childModulepreloadJoinEvents.push("module:" + (globalThis === self));
+globalThis.__childModulepreloadJoinValue = 551;
+"#
+ .to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ startup_sources,
+ events_before_completion,
+ completion,
+ events_after_preload_event,
+ events_after_module_terminal,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let root_url = format!("{base_url}/preloaded-root.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childModulepreloadJoinEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childModulepreloadJoinEvents.push("frame-load");
+ frame.srcdoc = `
+ <script>parent.__childModulepreloadJoinEvents.push("before:" + (globalThis === self));<\/script>
+ <link id="preload" rel="modulepreload" href="{root_url}" onload="parent.__childModulepreloadJoinEvents.push('preload-load')" onerror="parent.__childModulepreloadJoinEvents.push('preload-error')">
+ <script id="external-module" type="module" src="{root_url}"><\/script>
+ <script>
+ document.getElementById("external-module").addEventListener("load", () => {{
+ parent.__childModulepreloadJoinEvents.push("script-load");
+ }});
+ document.getElementById("external-module").addEventListener("error", () => {{
+ parent.__childModulepreloadJoinEvents.push("script-error");
+ }});
+ parent.__childModulepreloadJoinEvents.push("after:" + String(globalThis.__childModulepreloadJoinValue));
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let startup_sources =
+ drive_child_modulepreload_startup_until_resource_completion_ready(
+ &mut page_vm,
+ &loader,
+ 8,
+ )
+ .await;
+ let events_before_completion = page_vm
+ .vm_mut()
+ .eval("__childModulepreloadJoinEvents.join('|')")?;
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child modulepreload completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child modulepreload completion sender should remain open"
+ );
+ }
+
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+
+ run_expected_child_modulepreload_event_action_for_test(
+ &mut page_vm,
+ &loader,
+ "child modulepreload event dispatch",
+ )
+ .await;
+ let events_after_preload_event = page_vm
+ .vm_mut()
+ .eval("__childModulepreloadJoinEvents.join('|')")?;
+
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "same-URL modulepreload terminal fanout",
+ )
+ .await;
+ let events_after_module_terminal = page_vm
+ .vm_mut()
+ .eval("__childModulepreloadJoinEvents.join('|')")?;
+
+ let script_ready_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "same-URL modulepreload graph-ready execution",
+ )
+ .await;
+ let events_after_script_ready = page_vm
+ .vm_mut()
+ .eval("__childModulepreloadJoinEvents.join('|')")?;
+
+ let host_load_source = run_child_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "same-URL modulepreload iframe load",
+ )
+ .await;
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childModulepreloadJoinEvents.join('|')")?;
+
+ assert_eq!(
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ None,
+ "same-URL modulepreload sequence should not leave extra child frame task work"
+ );
+
+ Ok::<_, anyhow::Error>((
+ startup_sources,
+ events_before_completion,
+ completion,
+ events_after_preload_event,
+ events_after_module_terminal,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child modulepreload joined root test should run");
+
+ assert!(
+ startup_sources.contains(&ChildModulepreloadStartupTurn::ChildSemanticTurn(
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ )),
+ "child modulepreload startup should reach DocumentScriptReady without test drain: {startup_sources:?}"
+ );
+ let modulepreload_fetch_position = startup_sources
+ .iter()
+ .position(|turn| *turn == ChildModulepreloadStartupTurn::TypedModulepreloadStart)
+ .expect("parser-discovered modulepreload should start a fetch before completion");
+ let parser_root_position = startup_sources
+ .iter()
+ .position(|turn| {
+ *turn
+ == ChildModulepreloadStartupTurn::ChildSemanticTurn(
+ ChildFrameSemanticTurnKind::ParserModuleRootStart,
+ )
+ })
+ .expect("same-URL parser module root should still run and join the module map entry");
+ assert!(
+ modulepreload_fetch_position < parser_root_position,
+ "parser-discovered modulepreload should start before same-URL parser module root joins it: {startup_sources:?}"
+ );
+ assert_eq!(
+ events_before_completion, "before:true|after:undefined",
+ "modulepreload fetch start should not execute module or dispatch link/frame events"
+ );
+ assert!(matches!(
+ completion.action.source(),
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ ));
+ assert_eq!(
+ events_after_preload_event, "before:true|after:undefined|preload-load",
+ "modulepreload link load should dispatch before module script execution"
+ );
+ assert_eq!(
+ events_after_module_terminal, "before:true|after:undefined|preload-load",
+ "ModuleScriptTerminal should not execute the joined module inline"
+ );
+ assert_eq!(
+ script_ready_source,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "joined module graph-ready work should execute on DocumentScriptReady"
+ );
+ assert_eq!(
+ events_after_script_ready,
+ "before:true|after:undefined|preload-load|module:true|script-load",
+ "DocumentScriptReady should execute the joined module without iframe load"
+ );
+ assert_eq!(
+ host_load_source,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "iframe load should remain a later HostLoad source"
+ );
+ assert_eq!(
+ final_events,
+ "before:true|after:undefined|preload-load|module:true|script-load|frame-load",
+ "HostLoad should dispatch iframe load after joined modulepreload execution"
+ );
+
+ server
+ .await
+ .expect("child modulepreload joined root server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_modulepreload_failure_wakes_joined_root_before_host_load() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/preloaded-root.js",
+ "HTTP/1.1 404 Not Found",
+ "modulepreload missing".to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ startup_sources,
+ events_before_completion,
+ completion,
+ events_after_preload_event,
+ events_after_module_terminal,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let root_url = format!("{base_url}/preloaded-root.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childModulepreloadFailureEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childModulepreloadFailureEvents.push("frame-load");
+ frame.srcdoc = `
+ <script>parent.__childModulepreloadFailureEvents.push("before:" + (globalThis === self));<\/script>
+ <link id="preload" rel="modulepreload" href="{root_url}" onload="parent.__childModulepreloadFailureEvents.push('preload-load')" onerror="parent.__childModulepreloadFailureEvents.push('preload-error')">
+ <script id="external-module" type="module" src="{root_url}"><\/script>
+ <script>
+ document.getElementById("external-module").addEventListener("load", () => {{
+ parent.__childModulepreloadFailureEvents.push("script-load");
+ }});
+ document.getElementById("external-module").addEventListener("error", () => {{
+ parent.__childModulepreloadFailureEvents.push("script-error");
+ }});
+ parent.__childModulepreloadFailureEvents.push("after:" + String(globalThis.__childModulepreloadFailureValue));
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let startup_sources =
+ drive_child_modulepreload_startup_until_resource_completion_ready(
+ &mut page_vm,
+ &loader,
+ 8,
+ )
+ .await;
+ let events_before_completion = page_vm
+ .vm_mut()
+ .eval("__childModulepreloadFailureEvents.join('|')")?;
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child failed modulepreload completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child failed modulepreload completion sender should remain open"
+ );
+ }
+
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+
+ run_expected_child_modulepreload_event_action_for_test(
+ &mut page_vm,
+ &loader,
+ "child failed modulepreload event dispatch",
+ )
+ .await;
+ let events_after_preload_event = page_vm
+ .vm_mut()
+ .eval("__childModulepreloadFailureEvents.join('|')")?;
+
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "failed same-URL modulepreload terminal fanout",
+ )
+ .await;
+ let events_after_module_terminal = page_vm
+ .vm_mut()
+ .eval("__childModulepreloadFailureEvents.join('|')")?;
+
+ let script_ready_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "failed same-URL modulepreload graph-failed dispatch",
+ )
+ .await;
+ let events_after_script_ready = page_vm
+ .vm_mut()
+ .eval("__childModulepreloadFailureEvents.join('|')")?;
+
+ let host_load_source = run_child_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "failed same-URL modulepreload iframe load",
+ )
+ .await;
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childModulepreloadFailureEvents.join('|')")?;
+
+ assert_eq!(
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ None,
+ "failed same-URL modulepreload sequence should not leave extra child frame task work"
+ );
+
+ Ok::<_, anyhow::Error>((
+ startup_sources,
+ events_before_completion,
+ completion,
+ events_after_preload_event,
+ events_after_module_terminal,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child failed modulepreload joined root test should run");
+
+ assert!(
+ startup_sources.contains(&ChildModulepreloadStartupTurn::ChildSemanticTurn(
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ )),
+ "child failed modulepreload startup should reach DocumentScriptReady without test drain: {startup_sources:?}"
+ );
+ let modulepreload_fetch_position = startup_sources
+ .iter()
+ .position(|turn| *turn == ChildModulepreloadStartupTurn::TypedModulepreloadStart)
+ .expect("parser-discovered modulepreload should start a fetch before failure");
+ let parser_root_position = startup_sources
+ .iter()
+ .position(|turn| {
+ *turn
+ == ChildModulepreloadStartupTurn::ChildSemanticTurn(
+ ChildFrameSemanticTurnKind::ParserModuleRootStart,
+ )
+ })
+ .expect("same-URL parser module root should still run and join the failed module map entry");
+ assert!(
+ modulepreload_fetch_position < parser_root_position,
+ "parser-discovered modulepreload should start before same-URL parser module root joins it: {startup_sources:?}"
+ );
+ assert_eq!(
+ events_before_completion, "before:true|after:undefined",
+ "modulepreload fetch start should not dispatch link/script/frame events before failure"
+ );
+ assert!(matches!(
+ completion.action.source(),
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ ));
+ assert_eq!(
+ events_after_preload_event, "before:true|after:undefined|preload-error",
+ "modulepreload link error should dispatch before joined module script failure"
+ );
+ assert_eq!(
+ events_after_module_terminal, "before:true|after:undefined|preload-error",
+ "ModuleScriptTerminal should not dispatch the joined script error inline"
+ );
+ assert_eq!(
+ script_ready_source,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "joined module graph-failed work should dispatch on DocumentScriptReady"
+ );
+ assert_eq!(
+ events_after_script_ready, "before:true|after:undefined|preload-error|script-error",
+ "DocumentScriptReady should dispatch the joined module script error without iframe load"
+ );
+ assert_eq!(
+ host_load_source,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "iframe load should remain a later HostLoad source after modulepreload failure"
+ );
+ assert_eq!(
+ final_events, "before:true|after:undefined|preload-error|script-error|frame-load",
+ "HostLoad should dispatch iframe load after joined modulepreload failure finalizes"
+ );
+
+ server
+ .await
+ .expect("child failed modulepreload joined root server should finish");
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn modulepreload_fetch_failure_wakes_joined_parser_script_waiter() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse("https://example.com/page.html").expect("document URL");
+ let mut page_vm =
+ test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url.clone());
+
+ let root_url = Url::parse("https://example.com/root.mjs").expect("root URL");
+ let shared_url = Url::parse("https://cdn.example.com/shared.mjs").expect("shared URL");
+ let shared_key = ModuleMapKey::java_script(shared_url.clone());
+ let modulepreload = NativeModuleSingleFetchRequest::new(
+ shared_url.clone(),
+ shared_url.clone(),
+ document_url,
+ shared_key.clone(),
+ ModuleFetchMetadata::default(),
+ );
+ let start = page_vm
+ .vm_mut()
+ .document_runtime
+ .fetch_single_native_module_for_modulepreload(modulepreload)
+ .expect("modulepreload registration should succeed");
+ let crate::module_runtime::NativeModulepreloadFetchStart::Started(modulepreload) = start
+ else {
+ panic!("new modulepreload should start a single-module fetch");
+ };
+ let modulepreload_load_id = page_vm
+ .vm_mut()
+ .document_runtime
+ .suspend_native_modulepreload_fetch(*modulepreload);
+
+ let root_script =
+ prepared_external_module_for_page_vm_test_with_node(&page_vm, 9301, root_url.clone());
+ let parser_module_work = install_parser_module_defer_work(&mut page_vm, root_script);
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(&loader, parser_module_work)
+ .await
+ .expect("module defer page task should watch loading tree");
+
+ enqueue_parser_owned_module_script_fetch_completion_for_test(
+ &mut page_vm,
+ 1,
+ &root_url,
+ r#"
+import "https://cdn.example.com/shared.mjs";
+export const root = 1;
+"#,
+ );
+ assert!(
+ run_next_main_module_fetch_terminal_for_test(&mut page_vm)
+ .expect("root completion should run")
+ .is_some(),
+ "root completion should be consumed"
+ );
+ assert!(
+ page_vm.has_pending_parser_owned_module_fetch(),
+ "parser graph should wait on the in-flight modulepreload entry"
+ );
+
+ enqueue_main_modulepreload_fetch_error_for_test(
+ &mut page_vm,
+ modulepreload_load_id,
+ &shared_url,
+ "modulepreload fetch failed",
+ );
+ assert!(
+ run_next_main_module_fetch_terminal_for_test(&mut page_vm)
+ .expect("modulepreload completion should run")
+ .is_some(),
+ "modulepreload completion should be consumed"
+ );
+ run_next_native_module_owner_event_for_test(
+ &mut page_vm,
+ &loader,
+ "joined modulepreload failure",
+ )
+ .await;
+ let shared_entry = page_vm
+ .vm()
+ .document_runtime
+ .native_module_entry_id(&shared_key)
+ .expect("failed modulepreload should remain in module map");
+ assert_eq!(
+ page_vm
+ .vm()
+ .document_runtime
+ .native_module_entry_state(shared_entry),
+ ModuleMapEntryState::Failed,
+ "failed modulepreload must become terminal"
+ );
+ assert!(
+ !page_vm.has_pending_parser_owned_module_fetch(),
+ "joined parser graph should be woken by the modulepreload failure"
+ );
+ assert!(
+ page_vm.has_pending_parser_owned_module_script(),
+ "joined parser graph failure should wait for the document-owned ready dispatch"
+ );
+ run_ready_parser_deferred_body_for_test(
+ &mut page_vm,
+ &loader,
+ "joined modulepreload graph failure",
+ )
+ .await;
+ assert!(
+ !page_vm.has_pending_parser_owned_module_script(),
+ "joined parser graph failure should leave no pending parser-owned module script"
+ );
+ let root_failure = page_vm
+ .report
+ .runs
+ .iter()
+ .find(|run| run.url() == &root_url)
+ .and_then(|run| match run.outcome() {
+ ScriptRunOutcome::Failed(message) => Some(message),
+ _ => None,
+ })
+ .expect("parser module script should fail after joined modulepreload wakeup");
+ assert!(
+ root_failure.contains("modulepreload fetch failed"),
+ "joined script should observe the terminal modulepreload failure: {root_failure}"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn parser_module_script_observes_prior_modulepreload_failure() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse("https://example.com/page.html").expect("document URL");
+ let mut page_vm =
+ test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url.clone());
+
+ let module_url = Url::parse("https://example.com/module.mjs").expect("module URL");
+ let modulepreload = NativeModuleSingleFetchRequest::new(
+ module_url.clone(),
+ module_url.clone(),
+ document_url,
+ ModuleMapKey::java_script(module_url.clone()),
+ ModuleFetchMetadata::default(),
+ );
+ let start = page_vm
+ .vm_mut()
+ .document_runtime
+ .fetch_single_native_module_for_modulepreload(modulepreload)
+ .expect("modulepreload registration should succeed");
+ let crate::module_runtime::NativeModulepreloadFetchStart::Started(modulepreload) = start
+ else {
+ panic!("new modulepreload should start a single-module fetch");
+ };
+ let modulepreload_load_id = page_vm
+ .vm_mut()
+ .document_runtime
+ .suspend_native_modulepreload_fetch(*modulepreload);
+
+ enqueue_main_modulepreload_fetch_error_for_test(
+ &mut page_vm,
+ modulepreload_load_id,
+ &module_url,
+ "modulepreload integrity failed",
+ );
+ assert!(
+ run_next_main_module_fetch_terminal_for_test(&mut page_vm)
+ .expect("modulepreload completion should run")
+ .is_some(),
+ "modulepreload completion should be consumed"
+ );
+
+ let module_script =
+ prepared_external_module_for_page_vm_test_with_node(&page_vm, 9401, module_url.clone());
+ let parser_module_work = install_parser_module_defer_work(&mut page_vm, module_script);
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(&loader, parser_module_work)
+ .await
+ .expect("module defer page task should watch failed tree");
+ assert!(
+ !page_vm.has_pending_parser_owned_module_script(),
+ "the parser-deferred owner turn should consume the already-terminal failure"
+ );
+ assert!(
+ !page_vm.has_ready_parser_owned_document_script_action(),
+ "sticky failure must not materialize broad ready work"
+ );
+
+ let root_failure = page_vm
+ .report
+ .runs
+ .iter()
+ .find(|run| run.url() == &module_url)
+ .and_then(|run| match run.outcome() {
+ ScriptRunOutcome::Failed(message) => Some(message),
+ _ => None,
+ })
+ .expect("parser module script should fail from sticky modulepreload failure");
+ assert!(
+ root_failure.contains("modulepreload integrity failed"),
+ "module script should report sticky modulepreload failure: {root_failure}"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn parser_module_script_joins_inflight_same_url_modulepreload_failure() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse("https://example.com/page.html").expect("document URL");
+ let mut page_vm =
+ test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url.clone());
+
+ let module_url = Url::parse("https://example.com/module.mjs").expect("module URL");
+ let modulepreload = NativeModuleSingleFetchRequest::new(
+ module_url.clone(),
+ module_url.clone(),
+ document_url,
+ ModuleMapKey::java_script(module_url.clone()),
+ ModuleFetchMetadata::default(),
+ );
+ let start = page_vm
+ .vm_mut()
+ .document_runtime
+ .fetch_single_native_module_for_modulepreload(modulepreload)
+ .expect("modulepreload registration should succeed");
+ let crate::module_runtime::NativeModulepreloadFetchStart::Started(modulepreload) = start
+ else {
+ panic!("new modulepreload should start a single-module fetch");
+ };
+ let modulepreload_load_id = page_vm
+ .vm_mut()
+ .document_runtime
+ .suspend_native_modulepreload_fetch(*modulepreload);
+
+ let module_script =
+ prepared_external_module_for_page_vm_test_with_node(&page_vm, 9501, module_url.clone());
+ let parser_module_work = install_parser_module_defer_work(&mut page_vm, module_script);
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ parser_module_work,
+ )
+ .await
+ .expect("module defer page task should watch joined modulepreload");
+ assert!(
+ page_vm.has_pending_parser_owned_module_fetch(),
+ "parser root graph should wait on the in-flight same-URL modulepreload entry"
+ );
+
+ enqueue_main_modulepreload_fetch_error_for_test(
+ &mut page_vm,
+ modulepreload_load_id,
+ &module_url,
+ "modulepreload integrity failed",
+ );
+ assert!(
+ run_next_main_module_fetch_terminal_for_test(&mut page_vm)
+ .expect("modulepreload completion should run")
+ .is_some(),
+ "modulepreload completion should be consumed"
+ );
+ run_next_native_module_owner_event_for_test(
+ &mut page_vm,
+ &loader,
+ "same-URL joined modulepreload failure",
+ )
+ .await;
+ assert!(
+ !page_vm.has_pending_parser_owned_module_fetch(),
+ "same-URL joined parser graph should be woken by modulepreload failure"
+ );
+ assert!(
+ page_vm.has_pending_parser_owned_module_script(),
+ "same-URL joined parser graph failure should wait for the document-owned ready dispatch"
+ );
+ run_ready_parser_deferred_body_for_test(
+ &mut page_vm,
+ &loader,
+ "same-URL joined modulepreload failure",
+ )
+ .await;
+ assert!(
+ !page_vm.has_pending_parser_owned_module_script(),
+ "same-URL joined parser graph failure should leave no pending parser-owned module script"
+ );
+
+ let root_failure = page_vm
+ .report
+ .runs
+ .iter()
+ .find(|run| run.url() == &module_url)
+ .and_then(|run| match run.outcome() {
+ ScriptRunOutcome::Failed(message) => Some(message),
+ _ => None,
+ })
+ .expect("parser module script should fail from same-URL modulepreload failure");
+ assert!(
+ root_failure.contains("modulepreload integrity failed"),
+ "module script should report joined modulepreload failure: {root_failure}"
+ );
+ })
+ .await;
+}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/extracted/navigation_lifecycle.rs b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/navigation_lifecycle.rs
new file mode 100644
index 000000000..f1e25ecd0
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/navigation_lifecycle.rs
@@ -0,0 +1,900 @@
+use super::*;
+
+#[tokio::test]
+async fn page_vm_child_script_event_created_nested_navigation_precedes_document_script_ready() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-event-module.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childScriptEventNestedEvents.push("module:" + (globalThis === self));
+"#
+ .to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ completion_source,
+ module_followup_sources,
+ events_after_script_event,
+ nested_script_ready_source,
+ events_after_nested_script,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let script_url = format!("{base_url}/child-event-module.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childScriptEventNestedEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.srcdoc = `
+ <script>parent.__childScriptEventNestedEvents.push("before:" + (globalThis === self));<\/script>
+ <script id="event-module" type="module" src="{script_url}"><\/script>
+ <script>
+ document.getElementById("event-module").addEventListener("load", () => {{
+ parent.__childScriptEventNestedEvents.push("script-load");
+ const nested = document.createElement("iframe");
+ nested.srcdoc = "<script>parent.parent.__childScriptEventNestedEvents.push('nested-script:' + (globalThis === self));<\\/script>";
+ document.body.appendChild(nested);
+ }});
+ parent.__childScriptEventNestedEvents.push("after:" + String(globalThis.__childScriptEventNestedValue));
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+ let startup_sources =
+ drive_child_frame_task_sources_until_resource_completion_ready(
+ &mut page_vm,
+ 8,
+ )
+ .await;
+ assert!(
+ startup_sources.contains(&ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "child module startup should reach DocumentScriptReady without test drain: {startup_sources:?}"
+ );
+ assert!(
+ startup_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
+ "child module startup should start the parser module root fetch from its typed source: {startup_sources:?}"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childScriptEventNestedEvents.join('|')")?,
+ "before:true|after:undefined",
+ "parser should continue past the child module while the root fetch is pending"
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child parser module completion should arrive before timeout");
+ assert!(
+ arrived,
+ "child parser module completion sender should remain open"
+ );
+ }
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let completion_source = completion.action.source();
+
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "child script-event module terminal fanout",
+ )
+ .await;
+ let mut module_followup_sources = Vec::new();
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childScriptEventNestedEvents.join('|')")?,
+ "before:true|after:undefined",
+ "ModuleScriptTerminal should queue graph-ready work without running the module or nested iframe"
+ );
+ module_followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "child script-event module execution",
+ )
+ .await,
+ );
+ let events_after_script_event = page_vm
+ .vm_mut()
+ .eval("__childScriptEventNestedEvents.join('|')")?;
+
+ module_followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "nested iframe navigation created during child script event",
+ )
+ .await,
+ );
+ module_followup_sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "child script-event DOMContentLoaded transition",
+ )
+ .await,
+ );
+ let nested_script_ready_source = Some(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "nested iframe ready work created during child script event",
+ )
+ .await,
+ );
+ let events_after_nested_script = page_vm
+ .vm_mut()
+ .eval("__childScriptEventNestedEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ completion_source,
+ module_followup_sources,
+ events_after_script_event,
+ nested_script_ready_source,
+ events_after_nested_script,
+ ))
+ })
+ .await
+ .expect("child script event nested ready-work source test should run");
+
+ assert_eq!(
+ completion_source,
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ );
+ assert_eq!(
+ module_followup_sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ ChildFrameSemanticTurnKind::DocumentLifecycle
+ ],
+ "module execution, nested navigation commit, and DOMContentLoaded should remain separate child-frame turns after the typed terminal fanout"
+ );
+ assert_eq!(
+ events_after_script_event, "before:true|after:undefined|module:true|script-load",
+ "module evaluation should dispatch the script load event before nested parser work"
+ );
+ assert_eq!(
+ nested_script_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "nested parser ready work should enter DocumentScriptReady after its owner transaction commits"
+ );
+ assert_eq!(
+ events_after_nested_script,
+ "before:true|after:undefined|module:true|script-load|nested-script:true"
+ );
+
+ server
+ .await
+ .expect("child script event nested ready-work server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_resync_child_commits_navigation_before_document_script_ready() {
+ let page_vm = test_page_vm();
+ let local_executor = page_vm.local_executor.clone();
+
+ let resync = run_on_page_vm_local_executor(local_executor, async move {
+ let mut page_vm = page_vm;
+ page_vm.vm_mut().eval_with_child_record_sync(
+ r#"
+(() => {
+ globalThis.__resyncReadyEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => __resyncReadyEvents.push("frame-load");
+ frame.srcdoc = `<script>parent.__resyncReadyEvents.push("child-script:" + (globalThis === self));<\/script>`;
+ body.appendChild(frame);
+})()
+"#,
+ )?;
+ let host_load_pending_after_resync = page_vm
+ .has_ready_child_frame_semantic_turn_for_test(ChildFrameSemanticTurnKind::HostLoad);
+
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "resynced child navigation commit",
+ )
+ .await;
+ run_expected_child_realm_materialization_for_wait(&mut page_vm, "resynced child realm")
+ .await;
+ let script_ready_source = page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await;
+ let events_after_script_ready = page_vm.vm_mut().eval("__resyncReadyEvents.join('|')")?;
+ let host_load_source = Some(
+ run_child_interactive_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "resynced child iframe load",
+ )
+ .await,
+ );
+ let events_after_host_load = page_vm.vm_mut().eval("__resyncReadyEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ host_load_pending_after_resync,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ events_after_host_load,
+ ))
+ });
+ let (
+ host_load_pending_after_resync,
+ script_ready_source,
+ events_after_script_ready,
+ host_load_source,
+ events_after_host_load,
+ ) = run_page_vm_async_test(resync)
+ .await
+ .expect("resync ready-work source test should run");
+
+ assert!(
+ !host_load_pending_after_resync,
+ "ScriptVm resync should not wake HostLoad while parser-ready work is pending"
+ );
+ assert_eq!(
+ script_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "ScriptVm resync should expose parser-ready work after the child navigation commits"
+ );
+ assert_eq!(
+ events_after_script_ready, "child-script:true",
+ "DocumentScriptReady should run the child script without dispatching iframe load"
+ );
+ assert_eq!(
+ host_load_source,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "iframe load should remain a later HostLoad source"
+ );
+ assert_eq!(
+ events_after_host_load, "child-script:true|frame-load",
+ "HostLoad should dispatch iframe load after the script-ready turn"
+ );
+}
+#[tokio::test]
+async fn page_vm_nested_frame_finish_releases_parent_document_lifecycle() {
+ run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm();
+ page_vm.vm_mut().eval(
+ r#"
+(() => {
+ globalThis.__nestedLifecycleEvents = [];
+ const outer = document.createElement("iframe");
+ outer.onload = () => __nestedLifecycleEvents.push("outer-load");
+ outer.srcdoc = `<!doctype html><body><script>
+ parent.__nestedLifecycleEvents.push("outer-script");
+ const nested = document.createElement("iframe");
+ nested.onload = () => parent.parent.__nestedLifecycleEvents.push("nested-load");
+ nested.srcdoc = \`<!doctype html><script>parent.parent.__nestedLifecycleEvents.push("nested-script")<\\/script>\`;
+ document.body.appendChild(nested);
+ <\/script></body>`;
+ document.body.appendChild(outer);
+})()
+"#,
+ )?;
+
+ let mut turns = Vec::new();
+ for _ in 0..32 {
+ let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
+ break;
+ };
+ let events = page_vm
+ .vm_mut()
+ .eval("__nestedLifecycleEvents.join('|')")?;
+ let outer_loaded = events.contains("outer-load");
+ turns.push((source, events));
+ if outer_loaded {
+ break;
+ }
+ }
+
+ let nested_load_turn = turns
+ .iter()
+ .position(|(_, events)| events.contains("nested-load"))
+ .expect("nested frame should finish");
+ let outer_load_turn = turns
+ .iter()
+ .position(|(_, events)| events.contains("outer-load"))
+ .expect("parent frame should finish after its descendant");
+ assert_eq!(turns[nested_load_turn].0, ChildFrameSemanticTurnKind::HostLoad);
+ assert_eq!(turns[outer_load_turn].0, ChildFrameSemanticTurnKind::HostLoad);
+ assert!(
+ nested_load_turn < outer_load_turn,
+ "parent load must remain blocked until the exact descendant frame finishes: {turns:?}"
+ );
+ assert!(
+ !turns[nested_load_turn].1.contains("outer-load"),
+ "descendant HostLoad must only enqueue the parent lifecycle wake: {turns:?}"
+ );
+ assert!(
+ turns[nested_load_turn + 1..outer_load_turn]
+ .iter()
+ .any(|(source, _)| *source == ChildFrameSemanticTurnKind::DocumentLifecycle),
+ "parent complete must be a later DocumentLifecycle turn before its HostLoad: {turns:?}"
+ );
+ assert_eq!(
+ turns[outer_load_turn].1,
+ "outer-script|nested-script|nested-load|outer-load"
+ );
+ Ok::<_, anyhow::Error>(())
+ })
+ .await
+ .expect("nested lifecycle source-turn proof should run");
+}
+#[tokio::test]
+async fn page_vm_host_load_commits_nested_navigation_before_document_script_ready() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-load-creates-nested.html",
+ "HTTP/1.1 200 OK",
+ r#"
+<script>
+parent.__hostLoadNestedEvents.push("child-script");
+onload = () => {
+ parent.__hostLoadNestedEvents.push("child-load");
+ const nested = document.createElement("iframe");
+ nested.onload = () => parent.__hostLoadNestedEvents.push("nested-load");
+ nested.srcdoc = `<script>parent.parent.__hostLoadNestedEvents.push("nested-script:" + (globalThis === self));<\/script>`;
+ document.body.appendChild(nested);
+};
+</script>
+"#
+ .to_owned(),
+ Duration::ZERO,
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ bootstrap_source,
+ completion_source,
+ host_load_pending_after_completion,
+ script_ready_source,
+ events_after_script_ready,
+ interactive_source,
+ host_load_source,
+ events_after_host_load,
+ nested_script_ready_source,
+ events_after_nested_script_ready,
+ nested_interactive_source,
+ nested_host_load_source,
+ events_after_nested_host_load,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let child_url = format!("{base_url}/child-load-creates-nested.html");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__hostLoadNestedEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.src = "{child_url}";
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let bootstrap_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child document completion should arrive before timeout");
+ assert!(arrived, "child document completion sender should remain open");
+ }
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let completion_source = completion.action.source();
+ let host_load_pending_after_completion = page_vm
+ .has_ready_child_frame_semantic_turn_for_test(ChildFrameSemanticTurnKind::HostLoad);
+ run_expected_pending_child_realm_materialization_turn(
+ &mut page_vm,
+ "child host-load realm prerequisite",
+ )?;
+
+ let script_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_script_ready = page_vm
+ .vm_mut()
+ .eval("__hostLoadNestedEvents.join('|')")?;
+ let interactive_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let host_load_source = Some(
+ run_child_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "child window load",
+ )
+ .await,
+ );
+ let events_after_host_load = page_vm
+ .vm_mut()
+ .eval("__hostLoadNestedEvents.join('|')")?;
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "nested child navigation created during HostLoad",
+ )
+ .await;
+ run_expected_pending_child_realm_materialization_turn(
+ &mut page_vm,
+ "nested child realm prerequisite",
+ )?;
+ let nested_script_ready_source =
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_nested_script_ready = page_vm
+ .vm_mut()
+ .eval("__hostLoadNestedEvents.join('|')")?;
+ let nested_interactive_source =
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let nested_host_load_source = Some(
+ run_child_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "nested child iframe load",
+ )
+ .await,
+ );
+ let events_after_nested_host_load = page_vm
+ .vm_mut()
+ .eval("__hostLoadNestedEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ bootstrap_source,
+ completion_source,
+ host_load_pending_after_completion,
+ script_ready_source,
+ events_after_script_ready,
+ interactive_source,
+ host_load_source,
+ events_after_host_load,
+ nested_script_ready_source,
+ events_after_nested_script_ready,
+ nested_interactive_source,
+ nested_host_load_source,
+ events_after_nested_host_load,
+ ))
+ })
+ .await
+ .expect("host-load nested ready-work source test should run");
+
+ assert_eq!(
+ bootstrap_source,
+ Some(ChildFrameSemanticTurnKind::NavigationCommit),
+ "bootstrap child frame turn should commit navigation before lifecycle delivery"
+ );
+ assert_eq!(
+ completion_source,
+ RendererOwnerResourceActivitySource::ChildDocument
+ );
+ assert!(
+ !host_load_pending_after_completion,
+ "child document completion should not leave HostLoad pending before document-script ready work runs"
+ );
+ assert_eq!(
+ script_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "child document completion follow-up should run document-script ready work"
+ );
+ assert_eq!(events_after_script_ready, "child-script");
+ assert_eq!(
+ interactive_source,
+ Some(ChildFrameSemanticTurnKind::DocumentLifecycle),
+ "child parser EOF should become interactive before window load"
+ );
+ assert_eq!(
+ host_load_source,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "child window load should dispatch on HostLoad"
+ );
+ assert_eq!(
+ events_after_host_load, "child-script|child-load",
+ "HostLoad should create the nested frame without running its script inline"
+ );
+ assert_eq!(
+ nested_script_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "nested parser work created during HostLoad should follow its navigation commit"
+ );
+ assert_eq!(
+ events_after_nested_script_ready, "child-script|child-load|nested-script:true",
+ "nested script should run on the later DocumentScriptReady turn"
+ );
+ assert_eq!(
+ nested_interactive_source,
+ Some(ChildFrameSemanticTurnKind::DocumentLifecycle),
+ "nested parser EOF should become interactive before nested HostLoad"
+ );
+ assert_eq!(
+ nested_host_load_source,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "nested iframe load should still remain a separate HostLoad turn"
+ );
+ assert_eq!(
+ events_after_nested_host_load,
+ "child-script|child-load|nested-script:true|nested-load"
+ );
+
+ server
+ .await
+ .expect("host-load nested ready-work server should finish");
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn main_runtime_module_tla_releases_lifecycle_at_evaluation_start() {
+ #[derive(Debug)]
+ enum RuntimeModuleTurn {
+ RuntimeScriptAdmission,
+ ParserAsyncModuleAdmission,
+ ModuleReaction,
+ NativeModuleOwner,
+ DynamicModuleJob,
+ RuntimeScriptContinuation,
+ RuntimeOwnedModuleContinuation,
+ ParserOwnedModuleContinuation,
+ PostParseWork,
+ }
+
+ async fn run_one_runtime_module_turn(
+ page_vm: &mut PageVm,
+ loader: &crate::network::ResourceRequestClient,
+ ) -> anyhow::Result<Option<RuntimeModuleTurn>> {
+ if page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ModuleReaction,
+ loader,
+ )
+ .await?
+ {
+ return Ok(Some(RuntimeModuleTurn::ModuleReaction));
+ }
+ if let Some(outcome) = page_vm
+ .run_page_main_document_runtime_body_for_test(loader)
+ .await?
+ {
+ let turn = match outcome.action.kind() {
+ crate::page_task_queue::PageMainDocumentRuntimeActionKind::RuntimeScriptAdmission => {
+ RuntimeModuleTurn::RuntimeScriptAdmission
+ }
+ crate::page_task_queue::PageMainDocumentRuntimeActionKind::ParserAsyncModuleAdmission => {
+ RuntimeModuleTurn::ParserAsyncModuleAdmission
+ }
+ crate::page_task_queue::PageMainDocumentRuntimeActionKind::RuntimeScriptContinuation => {
+ RuntimeModuleTurn::RuntimeScriptContinuation
+ }
+ crate::page_task_queue::PageMainDocumentRuntimeActionKind::DynamicModuleJob => {
+ RuntimeModuleTurn::DynamicModuleJob
+ }
+ crate::page_task_queue::PageMainDocumentRuntimeActionKind::RuntimeOwnedModuleContinuation => {
+ RuntimeModuleTurn::RuntimeOwnedModuleContinuation
+ }
+ crate::page_task_queue::PageMainDocumentRuntimeActionKind::ParserOwnedModuleContinuation => {
+ RuntimeModuleTurn::ParserOwnedModuleContinuation
+ }
+ crate::page_task_queue::PageMainDocumentRuntimeActionKind::NativeModuleOwnerEvent => {
+ RuntimeModuleTurn::NativeModuleOwner
+ }
+ crate::page_task_queue::PageMainDocumentRuntimeActionKind::PostParseWork => {
+ RuntimeModuleTurn::PostParseWork
+ }
+ };
+ return Ok(Some(turn));
+ }
+ Ok(None)
+ }
+
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/runtime-tla.html").expect("document URL"),
+ );
+ page_vm
+ .vm_mut()
+ .document_runtime
+ .note_dom_content_loaded_dispatched();
+ page_vm
+ .vm_mut()
+ .eval(
+ r#"
+(() => {
+ globalThis.__runtimeTlaEvents = [];
+ const script = document.createElement("script");
+ script.type = "module";
+ script.onload = () => __runtimeTlaEvents.push("script-load");
+ script.onerror = () => __runtimeTlaEvents.push("script-error");
+ script.textContent = `
+ globalThis.__runtimeTlaStarted = 1;
+ await new Promise(resolve => { globalThis.__resolveRuntimeTla = resolve; });
+ globalThis.__runtimeTlaFinished = 1;
+ `;
+ document.body.appendChild(script);
+})()
+"#,
+ )
+ .expect("install runtime TLA module");
+ let owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("main document owner");
+
+ let mut reached_evaluation_start = false;
+ let mut progress_actions = Vec::new();
+ for _ in 0..32 {
+ let progressed = run_one_runtime_module_turn(&mut page_vm, &loader).await?;
+ let started = page_vm
+ .vm_mut()
+ .eval("String(globalThis.__runtimeTlaStarted)")?;
+ let load_delay = page_vm
+ .vm()
+ .current_main_document_has_async_script_load_delay(owner);
+ let events = page_vm.vm_mut().eval("__runtimeTlaEvents.join('|')")?;
+ if started == "1" && load_delay == Some(false) {
+ assert_eq!(
+ events, "",
+ "inline module evaluation must not dispatch script load or error"
+ );
+ reached_evaluation_start = true;
+ break;
+ }
+ let Some(progressed) = progressed else {
+ let ready_module_continuation =
+ page_vm.has_ready_runtime_owned_module_script_continuation_work();
+ let ready_dynamic_module_job = page_vm.vm_mut().has_ready_dynamic_module_job();
+ let runnable_runtime_work = page_vm
+ .vm_mut()
+ .has_runnable_runtime_script_work_now();
+ panic!(
+ "runtime module owner loop stalled before evaluation-start completion: started={started} load_delay={load_delay:?} events={events:?} progress_actions={progress_actions:?} ready_module_continuation={ready_module_continuation} ready_dynamic_module_job={ready_dynamic_module_job} runnable_runtime_work={runnable_runtime_work}",
+ );
+ };
+ progress_actions.push(progressed);
+ }
+ assert!(
+ reached_evaluation_start,
+ "runtime TLA evaluation start must complete the script and release its lifecycle binding"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__runtimeTlaFinished)")?,
+ "undefined",
+ "the module body should still be suspended on its TLA promise"
+ );
+ let run_count_at_evaluation_start = page_vm
+ .report
+ .runs
+ .iter()
+ .filter(|run| run.url().as_str().contains("runtime-tla"))
+ .count();
+ assert_eq!(
+ run_count_at_evaluation_start, 1,
+ "evaluation start must apply runtime module script completion exactly once"
+ );
+
+ page_vm
+ .vm_mut()
+ .eval("globalThis.__resolveRuntimeTla(); 'resolved'")?;
+ assert!(
+ page_vm
+ .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::ModuleReaction, &loader)
+ .await?,
+ "runtime TLA fulfillment should enqueue one typed module reaction"
+ );
+ for _ in 0..32 {
+ let progressed = run_one_runtime_module_turn(&mut page_vm, &loader).await?;
+ if page_vm
+ .vm_mut()
+ .eval("String(globalThis.__runtimeTlaFinished)")?
+ == "1"
+ {
+ break;
+ }
+ assert!(
+ progressed.is_some(),
+ "runtime module owner loop stalled after TLA resolve"
+ );
+ }
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__runtimeTlaFinished)")?,
+ "1"
+ );
+ assert_eq!(
+ page_vm
+ .report
+ .runs
+ .iter()
+ .filter(|run| run.url().as_str().contains("runtime-tla"))
+ .count(),
+ run_count_at_evaluation_start,
+ "TLA fulfillment must not redispatch runtime module script completion"
+ );
+ assert_eq!(
+ page_vm.vm_mut().eval("__runtimeTlaEvents.join('|')")?,
+ "",
+ "inline module fulfillment must not dispatch script load or error"
+ );
+ Ok::<_, anyhow::Error>(())
+ })
+ .await
+ .expect("runtime TLA lifecycle test should run");
+}
+#[tokio::test(flavor = "current_thread")]
+async fn dcl_lifecycle_yields_parser_deferred_source_wait_to_page_vm_resource_queue() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/defer-arrival.html").expect("document URL"),
+ );
+ let script = append_parser_owned_external_classic_defer_for_page_vm_test(
+ &mut page_vm,
+ 1,
+ "deferred-arrival",
+ Url::parse("https://example.com/deferred-arrival.js").expect("script URL"),
+ ScriptSource::External,
+ ("onload", "globalThis.__deferredArrivalLoaded = true"),
+ );
+ let (source_ready_tx, source_ready_rx) = tokio::sync::oneshot::channel();
+ let source_load = SharedScriptSourceLoad::spawn_for_test(async move {
+ source_ready_rx
+ .await
+ .expect("test should release the deferred source");
+ Ok("globalThis.__deferredArrivalExecuted = true;".to_owned())
+ });
+ let task_owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("defer test requires a document owner");
+ assert!(
+ page_vm
+ .vm_mut()
+ .claim_main_parser_deferred_script(
+ task_owner,
+ script,
+ Some(source_load),
+ None,
+ Default::default(),
+ )
+ .expect("pending classic defer should be accepted")
+ );
+ page_vm
+ .seal_main_parser_deferred_scripts(task_owner)
+ .expect("defer queue should seal");
+ let lifecycle_driver = page_vm
+ .vm()
+ .resume_post_parse_lifecycle_driver_for_existing_queue(
+ PageVmInitStage::DomContentLoaded,
+ );
+
+ let advance = {
+ let PageVm {
+ vm,
+ page_task_queue,
+ report,
+ ..
+ } = &mut page_vm;
+ vm.as_mut()
+ .expect("page vm must retain a ScriptVm")
+ .advance_post_parse_lifecycle(
+ &loader,
+ page_task_queue,
+ report,
+ lifecycle_driver,
+ None,
+ )
+ .await
+ .expect("DCL driver should report its blocked state")
+ };
+ assert!(
+ matches!(advance, PostParseLifecycleAdvance::AwaitProgress),
+ "the document driver must yield future resource progress to PageVm arbitration"
+ );
+
+ page_vm
+ .vm_mut()
+ .eval(
+ "globalThis.__dclBlockedTimerRan = false; \
+ setTimeout(() => { globalThis.__dclBlockedTimerRan = true; }, 0);",
+ )
+ .expect("ready timer should be registered");
+ assert!(
+ page_vm.vm().has_ready_timeout(),
+ "the regression requires a ready timer competing with the deferred source"
+ );
+ let progress_arrived = {
+ let progress_wait =
+ page_vm.wait_for_lifecycle_blocking_page_work_arrival_without_timeout(false);
+ tokio::pin!(progress_wait);
+ tokio::select! {
+ biased;
+ result = &mut progress_wait => {
+ panic!("a DCL-ineligible timer must not satisfy the lifecycle wait: {result}")
+ }
+ _ = std::future::ready(()) => {}
+ }
+ source_ready_tx
+ .send(())
+ .expect("deferred source receiver should remain alive");
+ progress_wait.await
+ };
+ assert!(
+ progress_arrived,
+ "deferred source terminal must wake the PageVm resource queue"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__dclBlockedTimerRan)")
+ .expect("timer marker should remain readable"),
+ "false",
+ "waiting for DCL progress must not execute a generic timer task"
+ );
+ let deferred_source = run_next_resource_completion_as_typed_page_turn(&mut page_vm)
+ .expect("deferred source terminal should apply");
+ assert_eq!(
+ deferred_source.action.source,
+ RendererOwnerResourceActivitySource::MainParserDeferredClassicSource
+ );
+
+ let advance = {
+ let PageVm {
+ vm,
+ page_task_queue,
+ report,
+ ..
+ } = &mut page_vm;
+ vm.as_mut()
+ .expect("page vm must retain a ScriptVm")
+ .advance_post_parse_lifecycle(
+ &loader,
+ page_task_queue,
+ report,
+ lifecycle_driver,
+ None,
+ )
+ .await
+ .expect("resource completion should resume the DCL driver")
+ };
+ let PostParseLifecycleAdvance::PageOwnedTask(mut task) = advance else {
+ panic!("ready parser-deferred work should become a page-owned task");
+ };
+ assert!(
+ task.take_work_for_execution()
+ .main_parser_deferred_scripts_owner()
+ .is_some(),
+ "the resumed owner turn must execute the exact parser-deferred queue"
+ );
+ })
+ .await;
+}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/extracted/page_task_dispatch.rs b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/page_task_dispatch.rs
new file mode 100644
index 000000000..435ae1812
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/page_task_dispatch.rs
@@ -0,0 +1,293 @@
+use super::*;
+
+#[test]
+fn default_runtime_hooks_reject_direct_no_owner_page_vm_construction() {
+ let _js_runtime = crate::JsRuntime::initialize();
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let local_executor = crate::local_executor::JsLocalExecutor::new();
+ let error = match PageVm::new(
+ PageId::new_for_testing(1),
+ local_executor,
+ &loader,
+ &PageVmEnvConfig {
+ web_storage: crate::RendererWebStorageHandles::ephemeral(),
+ root_frame_id: None,
+ main_document_commit: None,
+ top_level_storage_key: None,
+ document_start_scripts: vec![],
+ runtime_bindings: vec![],
+ runtime_inspector_session_restore_snapshots: vec![],
+ runtime_isolated_worlds: vec![],
+ permission_overrides: vec![],
+ extra_http_headers: Default::default(),
+ navigator_identity: loader.browser_identity().clone(),
+ document_policy_container: Default::default(),
+ document_default_language: None,
+ document_last_modified: None,
+ script_execution_disabled: false,
+ bypass_content_security_policy: false,
+ emulated_media: crate::protocol_types::EmulatedMediaOverrides::default(),
+ idle_override: None,
+ navigator_overrides: Default::default(),
+ viewport_surface: None,
+ document_activity: Default::default(),
+ network_offline: false,
+ blocked_url_patterns: Vec::new(),
+ indexed_db_manager: None,
+ storage_bucket_store: None,
+ fetch_subresource_interception_enabled: false,
+ fetch_subresource_interception_resource_type: None,
+ layout_policy: crate::real_layout_test_policy(),
+ wpt_extensions_enabled: false,
+ navigation_bootstrap_entry: None,
+ reserved_service_worker_client_id: None,
+ },
+ PageVmRuntimeHooks::default(),
+ DomHost::from_dom(HtmlParser::SCRIPTING_ENABLED.parse(
+ Url::parse("https://example.com/").unwrap(),
+ "<!doctype html><html><head></head><body></body></html>".to_owned(),
+ )),
+ Instant::now(),
+ ) {
+ Ok(_) => panic!("default runtime hooks must not create standalone document isolates"),
+ Err(error) => error,
+ };
+ assert!(
+ error
+ .to_string()
+ .contains("PageVmRuntimeHooks::standalone_without_owner_reservation_for_test()"),
+ "unexpected direct no-owner construction error: {error}"
+ );
+}
+#[tokio::test]
+async fn stream_declared_controller_and_writer_surface_ignores_reflection_and_spoofing() {
+ run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm();
+ let local_executor = page_vm.local_executor.clone();
+
+ let result = local_executor
+ .run(async move {
+ page_vm.vm_mut().eval(
+ r#"
+ (() => {
+ const methodShape = (object, name) => {
+ const descriptor = Object.getOwnPropertyDescriptor(
+ Object.getPrototypeOf(object),
+ name
+ );
+ return [
+ !!descriptor,
+ descriptor && descriptor.enumerable,
+ descriptor && descriptor.configurable,
+ descriptor && descriptor.writable,
+ descriptor && typeof descriptor.value,
+ descriptor && descriptor.value.length,
+ descriptor && descriptor.value.name
+ ].join(":");
+ };
+ const accessorShape = (object, name) => {
+ const descriptor = Object.getOwnPropertyDescriptor(
+ Object.getPrototypeOf(object),
+ name
+ );
+ return [
+ !!descriptor,
+ descriptor && descriptor.enumerable,
+ descriptor && descriptor.configurable,
+ descriptor && ("writable" in descriptor),
+ descriptor && typeof descriptor.get,
+ descriptor && descriptor.get.name,
+ descriptor && descriptor.get.length,
+ descriptor && typeof descriptor.set
+ ].join(":");
+ };
+ const internals = [
+ "__moliStreamControllerStream",
+ "__moliWritableStreamWriterStream"
+ ];
+ const reflectedInternals = object => Object.getOwnPropertyNames(object)
+ .filter(name => internals.includes(name))
+ .join(",");
+ const throwsTypeError = callback => {
+ try {
+ callback();
+ return "no-throw";
+ } catch (error) {
+ return `throw:${error.name}`;
+ }
+ };
+
+ let readableController;
+ const readable = new ReadableStream({
+ start(controller) {
+ readableController = controller;
+ }
+ }, { highWaterMark: 2 });
+ if (!readableController) {
+ throw new Error("ReadableStream start controller was not captured");
+ }
+ const readableReflectedBefore = reflectedInternals(readableController);
+ const readableDesiredGetter =
+ Object.getOwnPropertyDescriptor(
+ Object.getPrototypeOf(readableController),
+ "desiredSize"
+ ).get;
+ const readableBefore = readableController.desiredSize;
+ readableController.enqueue("one");
+ const readableAfter = readableController.desiredSize;
+ const readableFake = throwsTypeError(() => readableDesiredGetter.call({
+ __moliStreamControllerStream: readable
+ }));
+ readableController.__moliStreamControllerStream = new ReadableStream(
+ {},
+ { highWaterMark: 99 }
+ );
+ const readableSpoofed = readableController.desiredSize;
+
+ let transformController;
+ const transform = new TransformStream({
+ start(controller) {
+ transformController = controller;
+ }
+ }, undefined, { highWaterMark: 3 });
+ if (!transformController) {
+ throw new Error("TransformStream transform controller was not captured");
+ }
+ transformController.enqueue("chunk");
+ const transformReflectedBefore = reflectedInternals(transformController);
+ const transformBeforeSpoof = transformController.desiredSize;
+ transformController.__moliStreamControllerStream = new ReadableStream(
+ {},
+ { highWaterMark: 99 }
+ );
+ const transformSpoofed = transformController.desiredSize;
+
+ const writable = new WritableStream();
+ const writer = writable.getWriter();
+ const writerReflectedBefore = reflectedInternals(writer);
+ const writerReadyGetter =
+ Object.getOwnPropertyDescriptor(
+ Object.getPrototypeOf(writer),
+ "ready"
+ ).get;
+ const writerDesiredGetter =
+ Object.getOwnPropertyDescriptor(
+ Object.getPrototypeOf(writer),
+ "desiredSize"
+ ).get;
+ const writerDesiredBefore = writer.desiredSize;
+ const writerReadyIsPromise = writer.ready instanceof Promise;
+ const writerClosedIsPromise = writer.closed instanceof Promise;
+ const writerFakeReady = writerReadyGetter.call({
+ __moliWritableStreamWriterStream: writable
+ }) instanceof Promise;
+ const writerFakeDesired = throwsTypeError(() =>
+ writerDesiredGetter.call({
+ __moliWritableStreamWriterStream: writable
+ })
+ );
+ writer.__moliWritableStreamWriterStream = new WritableStream();
+ const writerDesiredSpoofed = writer.desiredSize;
+
+ return [
+ readableReflectedBefore,
+ methodShape(readableController, "enqueue"),
+ methodShape(readableController, "close"),
+ accessorShape(readableController, "desiredSize"),
+ `${readableBefore}:${readableAfter}:${readableFake}:${readableSpoofed}`,
+ transformReflectedBefore,
+ methodShape(transformController, "enqueue"),
+ String(Object.hasOwn(
+ Object.getPrototypeOf(transformController),
+ "close"
+ )),
+ accessorShape(transformController, "desiredSize"),
+ `${transformBeforeSpoof}:${transformSpoofed}`,
+ writerReflectedBefore,
+ accessorShape(writer, "ready"),
+ accessorShape(writer, "closed"),
+ accessorShape(writer, "desiredSize"),
+ `${writerDesiredBefore}:${writerReadyIsPromise}:${writerClosedIsPromise}:${writerFakeReady}:${writerFakeDesired}:${writerDesiredSpoofed}`
+ ].join("\n");
+ })()
+ "#,
+ )
+ })
+ .await
+ .expect("stream declared surface test should run on owner lane");
+
+ assert_eq!(
+ result,
+ [
+ "",
+ "true:true:true:true:function:0:enqueue",
+ "true:true:true:true:function:0:close",
+ "true:true:true:false:function:get desiredSize:0:undefined",
+ "2:1:throw:TypeError:1",
+ "",
+ "true:true:true:true:function:0:enqueue",
+ "false",
+ "true:true:true:false:function:get desiredSize:0:undefined",
+ "2:2",
+ "",
+ "true:true:true:false:function:get ready:0:undefined",
+ "true:true:true:false:function:get closed:0:undefined",
+ "true:true:true:false:function:get desiredSize:0:undefined",
+ "1:true:true:true:throw:TypeError:1",
+ ]
+ .join("\n")
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn direct_page_vm_wait_commands_fail_closed() {
+ run_page_vm_async_test(async move {
+ let loader_owner =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let loader = loader_owner.handle();
+
+ let commands = [
+ (
+ RendererPageCommand::WaitForSelector {
+ selector: "#never".to_owned(),
+ timeout_ms: 1_000,
+ loader: loader.clone(),
+ },
+ "wait-for-selector must be routed through the renderer owner continuation",
+ ),
+ (
+ RendererPageCommand::WaitForScriptTruthy {
+ expression: "false".to_owned(),
+ timeout_ms: 1_000,
+ loader: loader.clone(),
+ },
+ "wait-for-script-truthy must be routed through the renderer owner continuation",
+ ),
+ (
+ RendererPageCommand::WaitForSubresourceResponse {
+ criteria: SubresourceResponseWaitCriteria::default(),
+ timeout_ms: 1_000,
+ loader,
+ },
+ "wait-for-subresource-response must be routed through the renderer owner continuation",
+ ),
+ ];
+
+ for (command, expected_error) in commands {
+ let mut page_vm = test_page_vm();
+ let error = match page_vm
+ .dispatch_renderer_page_command(command)
+ {
+ Ok(_) => panic!("direct wait command should fail closed"),
+ Err(error) => error,
+ };
+ assert!(
+ error.to_string().contains(expected_error),
+ "unexpected error: {error}"
+ );
+ }
+ })
+ .await;
+}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/extracted/parser_module_tasks.rs b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/parser_module_tasks.rs
new file mode 100644
index 000000000..78551c90f
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/parser_module_tasks.rs
@@ -0,0 +1,961 @@
+use super::*;
+
+#[tokio::test]
+async fn page_vm_moved_child_defer_disposes_in_flight_slot_before_later_module() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![
+ (
+ "/moved-child-defer.js",
+ "HTTP/1.1 200 OK",
+ "parent.__movedChildDeferEvents.push('classic-ran');".to_owned(),
+ Duration::from_millis(80),
+ ),
+ (
+ "/later-moved-module.js",
+ "HTTP/1.1 200 OK",
+ "parent.__movedChildDeferEvents.push('module-ran');".to_owned(),
+ Duration::ZERO,
+ ),
+ ])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (events_after_dispose, sources, final_events) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let script_url = format!("{base_url}/moved-child-defer.js");
+ let module_url = format!("{base_url}/later-moved-module.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__movedChildDeferEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.id = "moved-defer-frame";
+ frame.onload = () => globalThis.__movedChildDeferEvents.push("load");
+ frame.srcdoc = `
+ <script>parent.__movedChildDeferEvents.push("before");<\/script>
+ <script id="move-defer" defer src="{script_url}"><\/script>
+ <script id="later-module" type="module" src="{module_url}"><\/script>
+ <script>
+ document.getElementById("move-defer").addEventListener("load", () => {{
+ parent.__movedChildDeferEvents.push("classic-load");
+ }});
+ document.getElementById("later-module").addEventListener("load", () => {{
+ parent.__movedChildDeferEvents.push("module-load");
+ }});
+ document.addEventListener("readystatechange", () => {{
+ parent.__movedChildDeferEvents.push("ready:" + document.readyState);
+ }});
+ document.addEventListener("DOMContentLoaded", () => {{
+ parent.__movedChildDeferEvents.push("dcl");
+ }});
+ parent.__movedChildDeferEvents.push("after");
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ for _ in 0..12 {
+ let Some(_) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
+ break;
+ };
+ }
+ assert_eq!(
+ page_vm.vm_mut().eval("__movedChildDeferEvents.join('|')")?,
+ "before|after|ready:interactive",
+ "later module must remain retained behind the unresolved classic defer"
+ );
+
+ let mut classic_completion = None;
+ for _ in 0..4 {
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("moved child defer completion should arrive");
+ }
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ if matches!(
+ completion.action.source(),
+ RendererOwnerResourceActivitySource::ChildClassicScript
+ ) {
+ classic_completion = Some(completion);
+ break;
+ }
+ assert!(
+ matches!(
+ completion.action.source(),
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ ),
+ "the only completion allowed ahead of the moved classic defer is its later module root"
+ );
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "module terminal retained behind the moved classic defer",
+ )
+ .await;
+ }
+ classic_completion
+ .expect("classic source completion must arrive after retained module terminals");
+ page_vm.vm_mut().eval(
+ r#"
+(() => {
+ const frame = document.getElementById("moved-defer-frame");
+ document.body.appendChild(frame.contentDocument.getElementById("move-defer"));
+ __movedChildDeferEvents.push("moved");
+})()
+"#,
+ )?;
+
+ let mut sources = Vec::new();
+ sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "moved classic defer disposal",
+ )
+ .await,
+ );
+ let events_after_dispose =
+ page_vm.vm_mut().eval("__movedChildDeferEvents.join('|')")?;
+ assert_eq!(
+ events_after_dispose, "before|after|ready:interactive|moved",
+ "disposed classic defer must not execute or dispatch load"
+ );
+ sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "module after moved classic defer",
+ )
+ .await,
+ );
+ assert_eq!(
+ page_vm.vm_mut().eval("__movedChildDeferEvents.join('|')")?,
+ "before|after|ready:interactive|moved|module-ran|module-load",
+ "disposing the exact classic slot must release the later module-defer"
+ );
+ for (source, label) in [
+ (
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "moved defer DOMContentLoaded",
+ ),
+ (
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "moved defer complete transition",
+ ),
+ (ChildFrameSemanticTurnKind::HostLoad, "moved defer iframe load"),
+ ] {
+ sources.push(
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(&mut page_vm, source, label)
+ .await,
+ );
+ }
+ let final_events = page_vm.vm_mut().eval("__movedChildDeferEvents.join('|')")?;
+ assert_eq!(page_vm.run_next_child_frame_task_source_for_semantic_test().await, None);
+ Ok::<_, anyhow::Error>((events_after_dispose, sources, final_events))
+ })
+ .await
+ .expect("moved child defer cancellation test should run");
+
+ assert_eq!(events_after_dispose, "before|after|ready:interactive|moved");
+ assert_eq!(
+ sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::HostLoad,
+ ]
+ );
+ assert_eq!(
+ final_events,
+ "before|after|ready:interactive|moved|module-ran|module-load|dcl|ready:complete|load"
+ );
+ server.await.expect("moved child defer server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_joined_parser_roots_batch_one_module_script_terminal() {
+ run_page_vm_async_test(async move {
+ let (base_url, shutdown_server_tx, server) = spawn_shutdown_path_response_http_server(vec![(
+ "/child-shared-module.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childJoinedParserRootEvents.push("module:" + (globalThis === self));
+globalThis.__childJoinedParserRootValue = 501;
+"#
+ .to_owned(),
+ Duration::from_millis(200),
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ pre_completion_sources,
+ events_before_completion,
+ resource_ready_before_wait,
+ completion_source,
+ events_after_module_owner,
+ first_ready_source,
+ events_after_first_ready,
+ second_ready_source,
+ events_after_second_ready,
+ host_load_source,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let script_url = format!("{base_url}/child-shared-module.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childJoinedParserRootEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childJoinedParserRootEvents.push("frame-load");
+ frame.srcdoc = `
+ <script>parent.__childJoinedParserRootEvents.push("before:" + (globalThis === self));<\/script>
+ <script id="joined-module-a" type="module" src="{script_url}"><\/script>
+ <script id="joined-module-b" type="module" src="{script_url}"><\/script>
+ <script>
+ document.getElementById("joined-module-a").addEventListener("load", () => {{
+ parent.__childJoinedParserRootEvents.push("script-a-load");
+ }});
+ document.getElementById("joined-module-b").addEventListener("load", () => {{
+ parent.__childJoinedParserRootEvents.push("script-b-load");
+ }});
+ parent.__childJoinedParserRootEvents.push(
+ "after:" + String(globalThis.__childJoinedParserRootValue)
+ );
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let mut pre_completion_sources = Vec::new();
+ let mut events_before_completion = String::new();
+ for _ in 0..8 {
+ let source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ events_before_completion = page_vm
+ .vm_mut()
+ .eval("__childJoinedParserRootEvents.join('|')")?;
+ if let Some(source) = source {
+ pre_completion_sources.push(source);
+ }
+ if source.is_none()
+ || page_vm.has_ready_page_websocket_task_for_test()
+ || events_before_completion.contains("frame-load")
+ {
+ break;
+ }
+ }
+ let resource_ready_before_wait = page_vm
+ .page_resource_completion_queue()
+ .has_ready_completion();
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("joined child module completion should arrive before timeout");
+ assert!(
+ arrived,
+ "joined child module completion sender should remain open"
+ );
+ }
+
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let completion_source = completion.action.source();
+
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "joined parser-root terminal fanout",
+ )
+ .await;
+ let events_after_module_owner = page_vm
+ .vm_mut()
+ .eval("__childJoinedParserRootEvents.join('|')")?;
+
+ let first_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_first_ready = page_vm
+ .vm_mut()
+ .eval("__childJoinedParserRootEvents.join('|')")?;
+
+ let second_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_second_ready = page_vm
+ .vm_mut()
+ .eval("__childJoinedParserRootEvents.join('|')")?;
+
+ let host_load_source = Some(
+ run_child_domcontentloaded_then_host_load_for_wait(
+ &mut page_vm,
+ "joined child parser-module iframe load",
+ )
+ .await,
+ );
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childJoinedParserRootEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ pre_completion_sources,
+ events_before_completion,
+ resource_ready_before_wait,
+ completion_source,
+ events_after_module_owner,
+ first_ready_source,
+ events_after_first_ready,
+ second_ready_source,
+ events_after_second_ready,
+ host_load_source,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm joined child parser roots test should run");
+
+ assert_eq!(
+ pre_completion_sources
+ .iter()
+ .filter(|source| **source == ChildFrameSemanticTurnKind::ParserModuleRootStart)
+ .count(),
+ 2,
+ "each parser root should get a reserve/join root-fetch source turn: {pre_completion_sources:?}"
+ );
+ assert!(
+ !resource_ready_before_wait,
+ "delayed shared module response should leave a window to prove joined roots wait for one completion"
+ );
+ assert_eq!(
+ events_before_completion, "before:true|after:undefined",
+ "joined child parser roots should not evaluate before the shared fetch completes"
+ );
+ assert_eq!(
+ completion_source,
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ );
+ assert_eq!(
+ events_after_module_owner, "before:true|after:undefined",
+ "module owner event should only enqueue document-script ready work"
+ );
+ assert_eq!(
+ first_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "first joined parser root should execute on a document-script ready turn"
+ );
+ assert_eq!(
+ events_after_first_ready,
+ "before:true|after:undefined|module:true|script-a-load",
+ "first ready turn should evaluate the shared module and dispatch the first script load"
+ );
+ assert_eq!(
+ second_ready_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
+ "second joined parser root should execute on a later document-script ready turn"
+ );
+ assert_eq!(
+ events_after_second_ready,
+ "before:true|after:undefined|module:true|script-a-load|script-b-load",
+ "second ready turn should dispatch the second script load without re-evaluating the module"
+ );
+ assert_eq!(
+ host_load_source,
+ Some(ChildFrameSemanticTurnKind::HostLoad),
+ "iframe load should remain a later HostLoad source after joined parser roots"
+ );
+ assert_eq!(
+ final_events,
+ "before:true|after:undefined|module:true|script-a-load|script-b-load|frame-load",
+ "HostLoad should dispatch iframe load after both joined parser roots complete"
+ );
+
+ shutdown_server_tx
+ .send(())
+ .expect("joined child parser roots server shutdown should send");
+ let requested_paths = server
+ .await
+ .expect("joined child parser roots server should finish");
+ assert_eq!(
+ requested_paths,
+ vec!["/child-shared-module.js"],
+ "joined parser roots should reserve twice but share one network module fetch"
+ );
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_async_module_allows_dcl_before_source_completion() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_path_response_http_server(vec![(
+ "/child-async-module.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childAsyncModuleEvents.push("module:" + (globalThis === self));
+globalThis.__childAsyncModuleValue = 307;
+"#
+ .to_owned(),
+ Duration::from_millis(200),
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ pre_completion_sources,
+ events_at_dcl,
+ resource_ready_at_dcl,
+ post_dcl_sources_before_completion,
+ completion_source,
+ document_script_source,
+ events_after_module,
+ complete_source,
+ host_load_source,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ let script_url = format!("{base_url}/child-async-module.js");
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childAsyncModuleEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childAsyncModuleEvents.push("frame-load");
+ frame.srcdoc = `
+ <script>
+ parent.__childAsyncModuleEvents.push("before");
+ document.addEventListener("DOMContentLoaded", () => {{
+ parent.__childAsyncModuleEvents.push("dcl");
+ }});
+ <\/script>
+ <script id="async-module" type="module" async src="{script_url}"><\/script>
+ <script>
+ document.getElementById("async-module").addEventListener("load", () => {{
+ parent.__childAsyncModuleEvents.push("script-load");
+ }});
+ parent.__childAsyncModuleEvents.push("after");
+ <\/script>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let mut pre_completion_sources = Vec::new();
+ let mut events_at_dcl = String::new();
+ for _ in 0..12 {
+ let source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ if let Some(source) = source {
+ pre_completion_sources.push(source);
+ }
+ events_at_dcl = page_vm
+ .vm_mut()
+ .eval("__childAsyncModuleEvents.join('|')")?;
+ if events_at_dcl.contains("dcl") || source.is_none() {
+ break;
+ }
+ }
+ let resource_ready_at_dcl =
+ page_vm.has_ready_page_websocket_task_for_test();
+ let mut post_dcl_sources_before_completion = Vec::new();
+ for _ in 0..4 {
+ let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
+ break;
+ };
+ post_dcl_sources_before_completion.push(source);
+ }
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ let arrived = tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child async module completion should arrive before timeout");
+ assert!(arrived, "child async module completion sender should remain open");
+ }
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let completion_source = completion.action.source();
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "child async-module terminal",
+ )
+ .await;
+ let document_script_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let events_after_module = page_vm
+ .vm_mut()
+ .eval("__childAsyncModuleEvents.join('|')")?;
+ let complete_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let host_load_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childAsyncModuleEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ pre_completion_sources,
+ events_at_dcl,
+ resource_ready_at_dcl,
+ post_dcl_sources_before_completion,
+ completion_source,
+ document_script_source,
+ events_after_module,
+ complete_source,
+ host_load_source,
+ final_events,
+ ))
+ })
+ .await
+ .expect("page vm child async module lifecycle test should run");
+
+ assert!(
+ pre_completion_sources.contains(&ChildFrameSemanticTurnKind::DocumentLifecycle),
+ "the child document should reach an explicit lifecycle turn before async module completion: {pre_completion_sources:?}"
+ );
+ assert!(
+ !pre_completion_sources.contains(&ChildFrameSemanticTurnKind::HostLoad),
+ "the async module load-delay token must keep HostLoad unavailable before source completion: {pre_completion_sources:?}"
+ );
+ assert_eq!(events_at_dcl, "before|after|dcl");
+ assert!(
+ !resource_ready_at_dcl,
+ "DCL should run while the delayed async module source is still pending"
+ );
+ assert!(
+ pre_completion_sources
+ .contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
+ "the async root fetch must start when the parser encounters the module, before DCL observes parser completion: {pre_completion_sources:?}"
+ );
+ assert!(
+ !post_dcl_sources_before_completion
+ .contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
+ "one async parser module must publish exactly one root-start task: before={pre_completion_sources:?}, after={post_dcl_sources_before_completion:?}"
+ );
+ assert!(
+ !post_dcl_sources_before_completion
+ .contains(&ChildFrameSemanticTurnKind::DocumentLifecycle)
+ && !post_dcl_sources_before_completion.contains(&ChildFrameSemanticTurnKind::HostLoad),
+ "the async-module token should block complete and HostLoad without blocking DCL: {post_dcl_sources_before_completion:?}"
+ );
+ assert_eq!(
+ completion_source,
+ RendererOwnerResourceActivitySource::ModuleGraphFetch
+ );
+ assert_eq!(
+ document_script_source,
+ Some(ChildFrameSemanticTurnKind::DocumentScriptReady)
+ );
+ assert_eq!(
+ events_after_module,
+ "before|after|dcl|module:true|script-load",
+ "async module execution should release complete without redispatching DCL"
+ );
+ assert_eq!(
+ complete_source,
+ Some(ChildFrameSemanticTurnKind::DocumentLifecycle)
+ );
+ assert_eq!(host_load_source, Some(ChildFrameSemanticTurnKind::HostLoad));
+ assert_eq!(
+ final_events,
+ "before|after|dcl|module:true|script-load|frame-load"
+ );
+
+ server
+ .await
+ .expect("child async module lifecycle server should finish");
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn parser_inline_module_runs_from_parser_after_parsing_order() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(
+ "https://example.com/page.html?case=inline-module#document-fragment",
+ )
+ .expect("document URL");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ document_url.clone(),
+ );
+ let script = prepared_inline_module_for_page_vm_test(
+ &page_vm,
+ 9002,
+ "globalThis.__inlineParserModuleExecuted = (globalThis.__inlineParserModuleExecuted ?? 0) + 1; globalThis.__inlineParserModuleUrl = import.meta.url; export const value = 1;",
+ );
+
+ let parser_module_work = install_parser_module_defer_work(&mut page_vm, script);
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__inlineParserModuleExecuted)")
+ .expect("read module side effect before page task"),
+ "undefined",
+ "prewarmed inline graph must not evaluate before parser after-parsing release"
+ );
+
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ parser_module_work,
+ )
+ .await
+ .expect("parser after-parsing owner should release inline graph");
+ run_parser_module_completion_turns_for_test(
+ &mut page_vm,
+ &loader,
+ 0,
+ "inline parser module after-parsing release",
+ )
+ .await;
+
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__inlineParserModuleExecuted)")
+ .expect("read module side effect after page task"),
+ "1",
+ "parser after-parsing release should evaluate the prewarmed inline graph once"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("globalThis.__inlineParserModuleUrl")
+ .expect("read inline module URL after page task"),
+ document_url.as_str(),
+ "an inline module must expose its document base URL, not its internal module-map key"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn parser_data_url_module_runs_from_parser_after_parsing_order() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/page.html").expect("document URL"),
+ );
+ let module_url = Url::parse(
+ "data:text/javascript,globalThis.__dataParserModuleExecuted%3D1%3Bexport%20const%20value%3D1%3B",
+ )
+ .expect("data module URL");
+ let script = prepared_external_module_for_page_vm_test(&page_vm, module_url);
+
+ let parser_module_work = install_parser_module_defer_work(&mut page_vm, script);
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__dataParserModuleExecuted)")
+ .expect("read data module side effect before page task"),
+ "undefined",
+ "prepared data graph must not evaluate before parser after-parsing release"
+ );
+
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ parser_module_work,
+ )
+ .await
+ .expect("parser after-parsing owner should release the data module graph");
+ run_parser_module_completion_turns_for_test(
+ &mut page_vm,
+ &loader,
+ 0,
+ "data parser module after-parsing release",
+ )
+ .await;
+
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__dataParserModuleExecuted)")
+ .expect("read data module side effect after page task"),
+ "1",
+ "parser after-parsing release should evaluate the prepared data graph once"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn parser_pending_module_tree_fetch_completion_waits_for_after_parsing_release() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/page.html").expect("document URL"),
+ );
+ let module_url = Url::parse("https://example.com/module.mjs").expect("module URL");
+ let script = prepared_external_module_for_page_vm_test(&page_vm, module_url.clone());
+
+ let parser_module_work = install_parser_module_defer_work(&mut page_vm, script);
+
+ enqueue_parser_owned_module_script_fetch_completion_for_test(
+ &mut page_vm,
+ 0,
+ &module_url,
+ "globalThis.__pendingTreeExecuted = (globalThis.__pendingTreeExecuted ?? 0) + 1; export const value = 1;",
+ );
+
+ assert!(
+ run_next_main_module_fetch_terminal_for_test(&mut page_vm)
+ .expect("module graph completion should run")
+ .is_some(),
+ "module graph completion should be consumed"
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__pendingTreeExecuted)")
+ .expect("read module side effect before page task"),
+ "undefined",
+ "completed fetch tree must not evaluate before the parser script task watches it"
+ );
+
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ parser_module_work,
+ )
+ .await
+ .expect("parser after-parsing owner should release the pending tree");
+ run_parser_module_completion_turns_for_test(
+ &mut page_vm,
+ &loader,
+ 0,
+ "completed parser module after-parsing release",
+ )
+ .await;
+
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__pendingTreeExecuted)")
+ .expect("read module side effect after page task"),
+ "1",
+ "parser script task watch should evaluate the completed pending tree once"
+ );
+ assert!(
+ page_vm
+ .report
+ .runs
+ .iter()
+ .any(|run| run.url() == &module_url),
+ "module script run should be reported after watch: {:?}",
+ page_vm.report.runs
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn watched_loading_parser_pending_module_tree_runs_after_fetch_completion() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/page.html").expect("document URL"),
+ );
+ let module_url = Url::parse("https://example.com/late-module.mjs").expect("module URL");
+ let script = prepared_external_module_for_page_vm_test(&page_vm, module_url.clone());
+
+ let parser_module_work = install_parser_module_defer_work(&mut page_vm, script);
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ parser_module_work,
+ )
+ .await
+ .expect("parser after-parsing owner should retain the loading pending tree");
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__pendingTreeLateExecuted)")
+ .expect("read module side effect before fetch completion"),
+ "undefined",
+ "loading watch must wait for the fetch tree completion"
+ );
+
+ enqueue_parser_owned_module_script_fetch_completion_for_test(
+ &mut page_vm,
+ 0,
+ &module_url,
+ "globalThis.__pendingTreeLateExecuted = (globalThis.__pendingTreeLateExecuted ?? 0) + 1; export const value = 1;",
+ );
+ assert!(
+ run_next_main_module_fetch_terminal_for_test(&mut page_vm)
+ .expect("module graph completion should run")
+ .is_some(),
+ "module graph completion should be consumed"
+ );
+ assert!(
+ !page_vm.has_ready_parser_owned_document_script_action(),
+ "after-parsing terminal must stay in its PendingScript instead of the broad ready queue"
+ );
+ run_ready_parser_deferred_body_for_test(
+ &mut page_vm,
+ &loader,
+ "late parser module graph completion",
+ )
+ .await;
+ run_parser_module_completion_turns_for_test(
+ &mut page_vm,
+ &loader,
+ 0,
+ "late parser module graph completion",
+ )
+ .await;
+
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__pendingTreeLateExecuted)")
+ .expect("read module side effect after fetch completion"),
+ "1",
+ "fetch completion after watch should evaluate the pending tree once"
+ );
+ assert!(
+ page_vm
+ .report
+ .runs
+ .iter()
+ .any(|run| run.url() == &module_url),
+ "module script run should be reported after late completion: {:?}",
+ page_vm.report.runs
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn document_replacement_drops_parser_pending_module_tree_owner() {
+ run_page_vm_async_test(async move {
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/page.html").expect("document URL"),
+ );
+ let module_url = Url::parse("https://example.com/replaced-module.mjs")
+ .expect("module URL");
+ let module_script = prepared_external_module_for_page_vm_test(&page_vm, module_url.clone());
+
+ let parser_module_work = install_parser_module_defer_work(&mut page_vm, module_script);
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ parser_module_work,
+ )
+ .await
+ .expect("module defer page task should watch loading pending tree");
+ assert!(
+ page_vm.has_pending_parser_owned_module_fetch(),
+ "module tree should be waiting for its root fetch before replacement"
+ );
+ let stale_target = page_vm
+ .vm()
+ .current_main_parser_module_graph_fetch_target(0)
+ .expect("loading parser root must expose its exact terminal target");
+
+ let replacement_script = prepared_loaded_classic_for_page_vm_test(
+ &page_vm,
+ 9100,
+ "document.open(); document.write('<!doctype html><p>replacement</p>'); document.close();",
+ );
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(
+ &loader,
+ classic_defer_work(replacement_script),
+ )
+ .await
+ .expect("replacement script task should run");
+
+ assert!(
+ !page_vm.has_pending_parser_owned_module_fetch(),
+ "document replacement must drop parser-owned module fetch continuations"
+ );
+ assert!(
+ !page_vm.has_pending_parser_owned_module_script(),
+ "document replacement must drop parser pending module scripts"
+ );
+
+ let replacement_document_url = page_vm.vm().document_runtime.document_url().clone();
+ page_vm
+ .vm()
+ .resource_completion_sender_for_test()
+ .send_main_parser_module_graph_fetch(MainParserModuleGraphFetchCompletion::new(
+ stale_target,
+ Ok(ModuleGraphFetchedSource::new(
+ module_url.clone(),
+ false,
+ ModuleSource::text(
+ "globalThis.__oldModuleAfterReplacement = true; export const value = 1;"
+ .to_owned(),
+ ),
+ )),
+ None,
+ MainModuleFetchNetworkAttribution::new(
+ replacement_document_url,
+ module_url.clone(),
+ ),
+ ))
+ .expect("stale exact parser terminal should still enter the stable Page source");
+ let outcome = run_next_resource_completion_as_typed_page_turn(&mut page_vm)
+ .expect("old module graph completion should consume one typed turn");
+ assert!(
+ matches!(
+ outcome.action.document_effect,
+ PageResourceCompletionDocumentEffect::DiscardedStaleOwner { .. }
+ ),
+ "old exact parser target must be rejected before module-map application: {outcome:?}"
+ );
+
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__oldModuleAfterReplacement)")
+ .expect("read old module side effect"),
+ "undefined",
+ "old parser module tree must not execute after document replacement"
+ );
+ assert!(
+ page_vm
+ .capture_page_state()
+ .expect("page state capture")
+ .report
+ .lifecycle_errors()
+ .is_empty(),
+ "typed stale-owner rejection is an expected terminal outcome, not a lifecycle error"
+ );
+ })
+ .await;
+}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/extracted/resource_completion_tasks.rs b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/resource_completion_tasks.rs
new file mode 100644
index 000000000..7209745c6
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/resource_completion_tasks.rs
@@ -0,0 +1,885 @@
+use super::*;
+
+#[tokio::test(flavor = "current_thread")]
+async fn page_resource_completion_rejects_stale_document_before_application() {
+ run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm();
+ page_vm
+ .vm_mut()
+ .document_runtime
+ .set_document_ready_state(crate::dom::native::DocumentReadyState::Complete);
+ park_current_document_websocket_for_test(
+ &mut page_vm,
+ moli_websocket::Event::TextMessage {
+ socket_id: 72,
+ data: "blocked".to_owned(),
+ },
+ )
+ .await;
+ let current_owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("test page should install a main Document owner");
+ let root_document = page_vm.document_lifecycle.identity().document;
+ let stale_owner = FrameDocumentTaskOwner::new(
+ current_owner.scheduler_lane_id,
+ current_owner.local_window_id,
+ DocumentId(current_owner.document_id.0 + 1),
+ );
+ let later_stale_owner = FrameDocumentTaskOwner::new(
+ current_owner.scheduler_lane_id,
+ current_owner.local_window_id,
+ DocumentId(current_owner.document_id.0 + 2),
+ );
+ let completion_for = |owner, parser_position, node_id, network_error: Option<&str>| {
+ MainParserDeferredClassicSourceLoadCompletion::new(
+ ParserPendingScriptId::from_key(
+ MainParserDocumentOwner::new(owner),
+ ParserPendingScriptKey::from_parts_for_test(
+ parser_position,
+ NodeId::new(node_id),
+ ),
+ ),
+ PreparedScriptSourceLoadOutcome {
+ source_result: Ok("globalThis.__staleDeferRan = true".to_owned()),
+ source_bytes: None,
+ network_result: network_error.map(|error| Arc::new(Err(error.to_owned()))),
+ },
+ )
+ };
+ let network_attribution_for = |parser_position| {
+ MainParserDeferredClassicSourceNetworkAttribution::new(
+ Url::parse("https://stale-defer.test/document").unwrap(),
+ Url::parse(&format!(
+ "https://stale-defer.test/script-{parser_position}.js"
+ ))
+ .unwrap(),
+ )
+ };
+ let mut queue = RendererPageNetworkingSource::new_for_test();
+ queue.enqueue_local_for_test(
+ RendererPageResourceCompletion::main_parser_deferred_classic_source(
+ root_document,
+ completion_for(stale_owner, 1, 9, Some("stale defer request failed")),
+ network_attribution_for(1),
+ ),
+ );
+ queue.enqueue_local_for_test(
+ RendererPageResourceCompletion::main_parser_deferred_classic_source(
+ root_document,
+ completion_for(later_stale_owner, 2, 10, None),
+ network_attribution_for(2),
+ ),
+ );
+ let activity_epoch_before = page_vm.vm().subresource_activity_epoch();
+
+ let outcome = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)
+ .expect("stale completion arbitration should succeed")
+ .expect("typed stale completion must remain runnable beside blocked WebSocket work");
+ assert_eq!(
+ outcome.action,
+ PageResourceCompletionTurnAction {
+ source: RendererOwnerResourceActivitySource::MainParserDeferredClassicSource,
+ owner: RendererPageResourceCompletionOwner::main_document(
+ root_document,
+ stale_owner,
+ ),
+ document_effect: PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
+ current_owner: Some(RendererPageResourceCompletionOwner::main_document(
+ root_document,
+ current_owner,
+ )),
+ },
+ body_activity: PageResourceCompletionBodyActivity::NoPageCodeOrEventDispatch,
+ post_checkpoint_effect: PageResourceCompletionPostCheckpointEffect::None,
+ output_effect: PageResourceCompletionOutputEffect::CaptureRequired,
+ }
+ );
+
+ assert!(queue.has_ready_completion());
+
+ let second = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)
+ .expect("second stale completion arbitration should succeed")
+ .expect("second stale completion should consume its own turn");
+ assert_eq!(
+ second.action,
+ PageResourceCompletionTurnAction {
+ source: RendererOwnerResourceActivitySource::MainParserDeferredClassicSource,
+ owner: RendererPageResourceCompletionOwner::main_document(
+ root_document,
+ later_stale_owner,
+ ),
+ document_effect: PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
+ current_owner: Some(RendererPageResourceCompletionOwner::main_document(
+ root_document,
+ current_owner,
+ )),
+ },
+ body_activity: PageResourceCompletionBodyActivity::NoPageCodeOrEventDispatch,
+ post_checkpoint_effect: PageResourceCompletionPostCheckpointEffect::None,
+ output_effect: PageResourceCompletionOutputEffect::None,
+ }
+ );
+
+ assert!(!queue.has_ready_completion());
+ assert_eq!(
+ page_vm.vm().subresource_activity_epoch(),
+ activity_epoch_before,
+ "stale defer Network output must not become current Document activity"
+ );
+ let (network_records, websocket_events, websocket_lifecycle_events) =
+ split_network_output_items(page_vm.vm_mut().take_network_output());
+ assert!(websocket_events.is_empty());
+ assert!(websocket_lifecycle_events.is_empty());
+ assert_eq!(network_records.len(), 1);
+ assert_eq!(
+ network_records[0].document_url().as_str(),
+ "https://stale-defer.test/document"
+ );
+ assert_eq!(
+ network_records[0].url().as_str(),
+ "https://stale-defer.test/script-1.js"
+ );
+ assert_eq!(
+ network_records[0].outcome(),
+ &SubresourceNetworkOutcome::Failure {
+ error_text: "stale defer request failed".to_owned(),
+ }
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("String(globalThis.__staleDeferRan)")
+ .expect("replacement Document should remain observable"),
+ "undefined",
+ "stale completion must not execute or rediscover the current Document"
+ );
+ })
+ .await;
+}
+#[tokio::test(flavor = "current_thread")]
+async fn stale_child_unusable_stylesheet_preserves_physical_output_without_document_effect() {
+ run_page_vm_async_test(async move {
+ let mut page_vm = test_page_vm();
+ let root_document = page_vm.document_lifecycle.identity().document;
+ let child_handle = crate::dom::native::NativeNodeId::new(404);
+ let stale_owner = FrameDocumentTaskOwner::new(
+ crate::frame_owner_model::FrameSchedulerLaneId(7),
+ crate::frame_owner_model::LocalWindowId(8),
+ DocumentId(9),
+ );
+ let request_url = Url::parse("https://stale-child.test/style.css").unwrap();
+ let physical_response = crate::protocol_types::NavigationResponse::from_text_body(
+ request_url.clone(),
+ 200,
+ vec![("Content-Type".to_owned(), b"text/html".to_vec())],
+ "<html>not a stylesheet</html>".to_owned(),
+ );
+ let mut queue = RendererPageNetworkingSource::new_for_test();
+ queue.enqueue_local_for_test(RendererPageResourceCompletion::child_blocking_stylesheet(
+ root_document,
+ ChildBlockingStylesheetLoadCompletion {
+ child_handle,
+ owner: stale_owner,
+ signature: crate::DocumentBlockingStylesheetSignature::ParserCreatedStyleImport {
+ urls: Vec::new(),
+ },
+ network_results: vec![ChildBlockingStylesheetNetworkResult {
+ frame_id: Some("stale-child-frame".to_owned()),
+ document_url: Url::parse("https://stale-child.test/document").unwrap(),
+ request_url,
+ initiator_type: SubresourceRequestInitiatorType::Parser,
+ terminal:
+ crate::stylesheet_blocking::StylesheetFetchTerminal::unusable_response(
+ physical_response,
+ false,
+ "stylesheet MIME validation failed",
+ ),
+ }],
+ },
+ ));
+ let activity_epoch_before = page_vm.vm().subresource_activity_epoch();
+
+ let outcome = page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)
+ .expect("stale child completion arbitration should succeed")
+ .expect("stale child completion should consume one bounded turn");
+ assert_eq!(
+ outcome.action,
+ PageResourceCompletionTurnAction {
+ source: RendererOwnerResourceActivitySource::ChildBlockingStylesheet,
+ owner: RendererPageResourceCompletionOwner::child_document(
+ root_document,
+ child_handle,
+ stale_owner,
+ ),
+ document_effect: PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
+ current_owner: None,
+ },
+ body_activity: PageResourceCompletionBodyActivity::NoPageCodeOrEventDispatch,
+ post_checkpoint_effect: PageResourceCompletionPostCheckpointEffect::None,
+ output_effect: PageResourceCompletionOutputEffect::CaptureRequired,
+ }
+ );
+
+ assert!(!queue.has_ready_completion());
+ assert_eq!(
+ page_vm.vm().subresource_activity_epoch(),
+ activity_epoch_before,
+ "a retired Document's Network fact must not become activity of the current Document"
+ );
+ let (network_records, websocket_events, websocket_lifecycle_events) =
+ split_network_output_items(page_vm.vm_mut().take_network_output());
+ assert!(websocket_events.is_empty());
+ assert!(websocket_lifecycle_events.is_empty());
+ assert_eq!(
+ network_records.len(),
+ 1,
+ "stale child Document must not suppress or duplicate the completed Network fact"
+ );
+ let network_record = &network_records[0];
+ assert_eq!(network_record.frame_id(), Some("stale-child-frame"));
+ assert_eq!(
+ network_record.document_url().as_str(),
+ "https://stale-child.test/document"
+ );
+ assert_eq!(
+ network_record.url().as_str(),
+ "https://stale-child.test/style.css"
+ );
+ assert_eq!(
+ network_record.resource_type(),
+ SubresourceResourceType::Stylesheet
+ );
+ assert_eq!(
+ network_record.request_initiator_type(),
+ SubresourceRequestInitiatorType::Parser
+ );
+ assert!(matches!(
+ network_record.outcome(),
+ SubresourceNetworkOutcome::Success { status: 200, .. }
+ ));
+ })
+ .await;
+}
+#[test]
+fn parser_eof_releases_preloads_only_for_the_current_document_transition() {
+ fn ready_store(url: Url) -> crate::runtime::DocumentScriptPreloadStore {
+ let request = crate::runtime::BufferedScriptPreloadRequest {
+ url: url.clone(),
+ initiator_url: url,
+ kind_hint: ScriptKind::Classic,
+ mode_hint: ScriptMode::Normal,
+ resource_type_hint: moli_fetch::RequestResourceType::ParserBlockingScript,
+ fetch_metadata: ScriptFetchMetadata::default(),
+ };
+ let mut store = crate::runtime::DocumentScriptPreloadStore::default();
+ store.insert(
+ request.cache_key(),
+ crate::runtime::script_preloads::BufferedScriptPreloadEntry {
+ request,
+ load: SharedScriptSourceLoad::ready_ok("window.ready = true;"),
+ },
+ );
+ store
+ }
+
+ let mut page_vm = test_page_vm();
+ let owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("test page should have a main document owner");
+ let live_store =
+ ready_store(Url::parse("https://example.test/preloaded.js").expect("preload URL"));
+ let live_store_observer = live_store.clone();
+ page_vm
+ .vm_mut()
+ .document_runtime
+ .bind_main_document_script_preload_store(live_store);
+
+ assert!(!live_store_observer.is_empty());
+ assert!(
+ page_vm
+ .vm_mut()
+ .finish_current_main_document_parsing(owner)
+ .is_some()
+ );
+ assert!(live_store_observer.is_empty());
+
+ let stale_store =
+ ready_store(Url::parse("https://example.test/stale.js").expect("preload URL"));
+ let stale_store_observer = stale_store.clone();
+ page_vm
+ .vm_mut()
+ .document_runtime
+ .bind_main_document_script_preload_store(stale_store);
+
+ assert!(
+ page_vm
+ .vm_mut()
+ .finish_current_main_document_parsing(owner)
+ .is_none()
+ );
+ assert!(
+ !stale_store_observer.is_empty(),
+ "a stale parser completion must not clear the current preload store"
+ );
+}
+#[tokio::test]
+async fn page_vm_child_mixed_parser_defer_waits_for_preceding_stylesheet() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_concurrent_path_response_http_server(vec![
+ (
+ "/mixed-defer.css",
+ "HTTP/1.1 200 OK",
+ ":root { --child-defer-style-gate: stylesheet-ready; }".to_owned(),
+ Duration::from_millis(600),
+ ),
+ (
+ "/stylesheet-classic-defer.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childDeferStylesheetEvents.push(
+ "classic:" + getComputedStyle(document.documentElement)
+ .getPropertyValue("--child-defer-style-gate").trim()
+);
+"#
+ .to_owned(),
+ Duration::ZERO,
+ ),
+ (
+ "/stylesheet-module-defer.js",
+ "HTTP/1.1 200 OK",
+ r#"
+parent.__childDeferStylesheetEvents.push(
+ "module:" + getComputedStyle(document.documentElement)
+ .getPropertyValue("--child-defer-style-gate").trim()
+);
+"#
+ .to_owned(),
+ Duration::from_millis(20),
+ ),
+ ])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (
+ mut script_completion_sources,
+ stylesheet_completion,
+ execution_sources,
+ lifecycle_sources,
+ final_events,
+ ) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childDeferStylesheetEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childDeferStylesheetEvents.push("load");
+ frame.srcdoc = `
+ <link rel="stylesheet" href="{base_url}/mixed-defer.css">
+ <script defer src="{base_url}/stylesheet-classic-defer.js"><\/script>
+ <script type="module" src="{base_url}/stylesheet-module-defer.js"><\/script>
+ <body></body>
+ `;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ let mut bootstrap_sources = Vec::new();
+ for _ in 0..8 {
+ let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
+ break;
+ };
+ bootstrap_sources.push(source);
+ if bootstrap_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart)
+ && bootstrap_sources.contains(&ChildFrameSemanticTurnKind::DocumentLifecycle)
+ {
+ break;
+ }
+ }
+ assert!(
+ bootstrap_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart)
+ && bootstrap_sources.contains(&ChildFrameSemanticTurnKind::DocumentLifecycle),
+ "child parser must start the module root fetch and reach interactive while classic defer fetches directly: {bootstrap_sources:?}"
+ );
+
+ let mut script_completion_sources = Vec::new();
+ while script_completion_sources.len() != 2 {
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("child deferred script completion should arrive");
+ }
+ let completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ assert_ne!(
+ completion.action.source(),
+ RendererOwnerResourceActivitySource::ChildBlockingStylesheet,
+ "delayed stylesheet must remain pending while both script sources become terminal"
+ );
+ script_completion_sources.push(completion.action.source());
+ if completion.action.source()
+ == RendererOwnerResourceActivitySource::ModuleGraphFetch
+ {
+ run_expected_child_module_script_terminal_turn(
+ &mut page_vm,
+ "stylesheet-blocked child module terminal",
+ )
+ .await;
+ }
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childDeferStylesheetEvents.join('|')")?,
+ "",
+ "terminal script sources must remain retained behind the stylesheet snapshot"
+ );
+ }
+ assert_eq!(
+ page_vm.run_next_child_frame_task_source_for_semantic_test().await,
+ None,
+ "no script or HostLoad turn should be runnable before stylesheet completion"
+ );
+
+ if !page_vm.page_resource_completion_queue().has_ready_completion() {
+ tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("delayed child stylesheet completion should arrive");
+ }
+ let stylesheet_completion =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childDeferStylesheetEvents.join('|')")?,
+ "",
+ "stylesheet completion must not inline-execute retained deferred scripts"
+ );
+
+ let execution_sources = vec![
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "stylesheet-released child classic defer",
+ )
+ .await,
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentScriptReady,
+ "stylesheet-released child module defer",
+ )
+ .await,
+ ];
+ let lifecycle_sources = vec![
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "stylesheet-released child DOMContentLoaded",
+ )
+ .await,
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "stylesheet-released child complete transition",
+ )
+ .await,
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "stylesheet-released child iframe load",
+ )
+ .await,
+ ];
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childDeferStylesheetEvents.join('|')")?;
+ assert_eq!(page_vm.run_next_child_frame_task_source_for_semantic_test().await, None);
+
+ Ok::<_, anyhow::Error>((
+ script_completion_sources,
+ stylesheet_completion,
+ execution_sources,
+ lifecycle_sources,
+ final_events,
+ ))
+ })
+ .await
+ .expect("mixed child defer stylesheet test should run");
+
+ script_completion_sources.sort_by_key(|source| match source {
+ RendererOwnerResourceActivitySource::ChildClassicScript => 0,
+ RendererOwnerResourceActivitySource::ModuleGraphFetch => 1,
+ _ => 2,
+ });
+ assert_eq!(
+ script_completion_sources,
+ vec![
+ RendererOwnerResourceActivitySource::ChildClassicScript,
+ RendererOwnerResourceActivitySource::ModuleGraphFetch,
+ ]
+ );
+ assert_eq!(
+ stylesheet_completion.action.source(),
+ RendererOwnerResourceActivitySource::ChildBlockingStylesheet
+ );
+ assert_eq!(
+ execution_sources,
+ vec![ChildFrameSemanticTurnKind::DocumentScriptReady; 2]
+ );
+ assert_eq!(
+ lifecycle_sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::HostLoad,
+ ]
+ );
+ assert_eq!(
+ final_events,
+ "classic:stylesheet-ready|module:stylesheet-ready|load",
+ "mixed parser-deferred scripts must preserve document order and observe the installed stylesheet"
+ );
+ server
+ .await
+ .expect("mixed child defer stylesheet server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_failed_child_stylesheet_installs_empty_sheet_before_host_load() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_concurrent_path_response_http_server(vec![(
+ "/load-only.css",
+ "HTTP/1.1 404 Not Found",
+ ".failed-body { color: rgb(11, 12, 13); }".to_owned(),
+ Duration::from_millis(220),
+ )])
+ .await;
+ let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (completion, child_stylesheet_surface, lifecycle_sources, final_events) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childStylesheetHostLoadEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childStylesheetHostLoadEvents.push("load");
+ frame.srcdoc = `<link rel="stylesheet" href="{base_url}/load-only.css"><body class="failed-body"></body>`;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "stylesheet-only child navigation commit",
+ )
+ .await;
+ let lifecycle_sources = vec![
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "stylesheet-only child interactive transition",
+ )
+ .await,
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "stylesheet-only child DOMContentLoaded transition",
+ )
+ .await,
+ ];
+ assert!(
+ !page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ChildHostLoad,
+ &loader,
+ )
+ .await?,
+ "HostLoad must remain blocked after DCL while a child stylesheet is pending"
+ );
+ assert_eq!(
+ page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await,
+ None,
+ "blocked stylesheet lifecycle must not produce HostLoad progress"
+ );
+
+ if !page_vm
+ .page_resource_completion_queue()
+ .has_ready_completion()
+ {
+ tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("failed stylesheet-only completion should arrive");
+ }
+ let completion = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ let child_context_id = page_vm
+ .live_child_default_runtime_realm_inventory()
+ .into_iter()
+ .map(|realm| realm.context_id)
+ .next()
+ .expect("stylesheet child should have one materialized default realm");
+ let child_stylesheet_surface = page_vm.vm_mut().eval_in_child_default_context(
+ child_context_id,
+ r#"
+(() => {
+ const link = document.querySelector("link");
+ return JSON.stringify({
+ sheet: link.sheet !== null,
+ owner: link.sheet && link.sheet.ownerNode === link,
+ count: document.styleSheets.length,
+ color: getComputedStyle(document.body).color,
+ });
+})()
+"#,
+ )?;
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childStylesheetHostLoadEvents.join('|')")?,
+ "",
+ "stylesheet completion must not inline-dispatch iframe load"
+ );
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "stylesheet-terminal child complete transition",
+ )
+ .await;
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "stylesheet-terminal child iframe load",
+ )
+ .await;
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childStylesheetHostLoadEvents.join('|')")?;
+
+ Ok::<_, anyhow::Error>((
+ completion,
+ child_stylesheet_surface,
+ lifecycle_sources,
+ final_events,
+ ))
+ })
+ .await
+ .expect("stylesheet-only child HostLoad test should run");
+
+ assert_eq!(
+ completion.action.source(),
+ RendererOwnerResourceActivitySource::ChildBlockingStylesheet
+ );
+ assert_eq!(
+ child_stylesheet_surface,
+ r#"{"sheet":true,"owner":true,"count":1,"color":"rgb(0, 0, 0)"}"#,
+ "a failed child stylesheet must expose the same empty sheet surface as Chromium and the main document"
+ );
+ assert_eq!(
+ lifecycle_sources,
+ vec![
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ ]
+ );
+ assert_eq!(final_events, "load");
+ server
+ .await
+ .expect("stylesheet-only child HostLoad server should finish");
+ })
+ .await;
+}
+#[tokio::test]
+async fn page_vm_child_stylesheet_fonts_block_complete_until_the_exact_terminal() {
+ run_page_vm_async_test(async move {
+ let (base_url, server) = spawn_concurrent_path_response_http_server(vec![
+ (
+ "/blocking-resources.css",
+ "HTTP/1.1 200 OK",
+ r#"
+body { background-image: url('/css-image.png'); }
+@font-face { font-family: Demo; src: url('/demo.woff2') format('woff2'); }
+"#
+ .to_owned(),
+ Duration::from_millis(80),
+ ),
+ (
+ "/demo.woff2",
+ "HTTP/1.1 200 OK",
+ "font-body".to_owned(),
+ Duration::from_millis(420),
+ ),
+ ])
+ .await;
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ loader.set_optional_resource_fetch_mask(
+ crate::protocol_types::OptionalResourceFetchMask::IMAGE
+ | crate::protocol_types::OptionalResourceFetchMask::FONT,
+ );
+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
+ let local_executor = page_vm.local_executor.clone();
+
+ let (stylesheet_outcome, lifecycle_ready_after_font, final_events) = local_executor
+ .run(async move {
+ let mut page_vm = page_vm;
+ page_vm.vm_mut().eval(&format!(
+ r#"
+(() => {{
+ globalThis.__childCssResourceEvents = [];
+ const root = document.documentElement || document.appendChild(document.createElement("html"));
+ const body = document.body || root.appendChild(document.createElement("body"));
+ const frame = document.createElement("iframe");
+ frame.onload = () => globalThis.__childCssResourceEvents.push("load");
+ frame.srcdoc = `<link rel="stylesheet" href="{base_url}/blocking-resources.css"><body></body>`;
+ body.appendChild(frame);
+}})()
+"#
+ ))?;
+
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::NavigationCommit,
+ "CSS-resource child navigation commit",
+ )
+ .await;
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "CSS-resource child interactive transition",
+ )
+ .await;
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "CSS-resource child DOMContentLoaded transition",
+ )
+ .await;
+
+ if !page_vm
+ .page_resource_completion_queue()
+ .has_ready_completion()
+ {
+ tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("stylesheet completion should arrive");
+ }
+ let stylesheet_outcome =
+ run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ assert!(
+ !page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ChildHostLoad,
+ &loader,
+ )
+ .await?,
+ "HostLoad must remain blocked while stylesheet subresources are pending"
+ );
+
+ if !page_vm
+ .page_resource_completion_queue()
+ .has_ready_completion()
+ {
+ tokio::time::timeout(
+ Duration::from_secs(2),
+ wait_for_typed_page_resource_completion(&mut page_vm),
+ )
+ .await
+ .expect("stylesheet font terminal should arrive");
+ }
+ let outcome = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
+ assert_eq!(
+ outcome.action.source(),
+ RendererOwnerResourceActivitySource::AsyncSubresource,
+ "the stylesheet font terminal must use Networking"
+ );
+ let lifecycle_ready_after_font = page_vm
+ .has_ready_child_frame_semantic_turn_for_test(
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ );
+ assert_eq!(
+ page_vm
+ .vm_mut()
+ .eval("__childCssResourceEvents.join('|')")?,
+ "",
+ "the font terminal must not inline-dispatch iframe load"
+ );
+
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ "CSS-resource child complete transition",
+ )
+ .await;
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ &mut page_vm,
+ ChildFrameSemanticTurnKind::HostLoad,
+ "CSS-resource child iframe load",
+ )
+ .await;
+ let final_events = page_vm
+ .vm_mut()
+ .eval("__childCssResourceEvents.join('|')")?;
+ assert_eq!(
+ page_vm.vm().css_image_resource_observability_for_test(),
+ (0, 0, 0, 0, Vec::<String>::new()),
+ "raw stylesheet text must not eagerly admit CSS image slots before paint layout"
+ );
+ Ok::<_, anyhow::Error>((
+ stylesheet_outcome,
+ lifecycle_ready_after_font,
+ final_events,
+ ))
+ })
+ .await
+ .expect("stylesheet subresource lifecycle test should run");
+
+ assert_eq!(
+ stylesheet_outcome.action.source(),
+ RendererOwnerResourceActivitySource::ChildBlockingStylesheet
+ );
+ assert!(
+ lifecycle_ready_after_font,
+ "the exact stylesheet font token must make complete runnable"
+ );
+ assert_eq!(final_events, "load");
+ server
+ .await
+ .expect("stylesheet subresource server should finish");
+ })
+ .await;
+}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs
index 49cd9fcaa..7d4f8ac18 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs
@@ -55,8 +55,8 @@ use crate::types::{
ModuleGraphFetchRequester, ScriptKind, ScriptMode, ScriptNetworkOutput,
ScriptNetworkOutputItem, ScriptObservableOutput, ScriptObservableOutputItem, ScriptRun,
ScriptRunOutcome, ScriptSkipReason, ScriptSourceKind, SubresourceBodyFinishedResult,
- SubresourceNetworkRecord, SubresourceRequestInitiatorType, SubresourceResponseWaitCriteria,
- WebSocketLifecycleEvent, WebSocketNetworkEvent,
+ SubresourceNetworkRecord, SubresourceRequestInitiatorType, WebSocketLifecycleEvent,
+ WebSocketNetworkEvent,
};
use crate::types::{SubresourceNetworkOutcome, SubresourceResourceType};
use moli_fetch::FetchConfig;
@@ -87,13 +87,12 @@ use super::{
PageVmEnvConfig, PageVmRuntimeHooks, PostParseLifecycleLoopAdvance,
};
use crate::frame_owner_model::{
- ChildDocumentModuleFetchTarget, ChildFrameSemanticTurnKind, DocumentId,
- FrameDocumentModuleClientEntryId, FrameDocumentModuleClientId,
- FrameDocumentModuleClientRegistration, FrameDocumentModuleClientReservation,
- FrameDocumentModuleDependencyFetchTask, FrameDocumentModuleFetchDisposition,
- FrameDocumentModulepreloadFetchTask, FrameDocumentModulepreloadLinkClient,
- FrameDocumentStaticDependencyModuleClient, FrameDocumentTaskOwner, FrameRealmId,
- FrameRequestId,
+ ChildDocumentModuleFetchTarget, ChildFrameSemanticTurnKind, FrameDocumentModuleClientEntryId,
+ FrameDocumentModuleClientId, FrameDocumentModuleClientRegistration,
+ FrameDocumentModuleClientReservation, FrameDocumentModuleDependencyFetchTask,
+ FrameDocumentModuleFetchDisposition, FrameDocumentModulepreloadFetchTask,
+ FrameDocumentModulepreloadLinkClient, FrameDocumentStaticDependencyModuleClient,
+ FrameDocumentTaskOwner, FrameRealmId, FrameRequestId,
};
use crate::native_bridge::PendingWindowMessageEndpoint;
@@ -183,1655 +182,526 @@ fn has_ready_runtime_script_continuation_for_test(page_vm: &PageVm) -> bool {
)
}
-#[tokio::test(flavor = "current_thread")]
-async fn page_resource_completion_rejects_stale_document_before_application() {
- run_page_vm_async_test(async move {
- let mut page_vm = test_page_vm();
+pub(super) fn test_page_vm() -> PageVm {
+ test_page_vm_with_config(FetchConfig::default(), Vec::new())
+}
+
+async fn park_current_document_websocket_for_test(
+ page_vm: &mut PageVm,
+ event: moli_websocket::Event,
+) {
+ assert!(
page_vm
- .vm_mut()
- .document_runtime
- .set_document_ready_state(crate::dom::native::DocumentReadyState::Complete);
- park_current_document_websocket_for_test(
- &mut page_vm,
- moli_websocket::Event::TextMessage {
- socket_id: 72,
- data: "blocked".to_owned(),
- },
- )
- .await;
- let current_owner = page_vm
.vm()
- .current_main_document_task_owner()
- .expect("test page should install a main Document owner");
- let root_document = page_vm.document_lifecycle.identity().document;
- let stale_owner = FrameDocumentTaskOwner::new(
- current_owner.scheduler_lane_id,
- current_owner.local_window_id,
- DocumentId(current_owner.document_id.0 + 1),
- );
- let later_stale_owner = FrameDocumentTaskOwner::new(
- current_owner.scheduler_lane_id,
- current_owner.local_window_id,
- DocumentId(current_owner.document_id.0 + 2),
- );
- let completion_for = |owner, parser_position, node_id, network_error: Option<&str>| {
- MainParserDeferredClassicSourceLoadCompletion::new(
- ParserPendingScriptId::from_key(
- MainParserDocumentOwner::new(owner),
- ParserPendingScriptKey::from_parts_for_test(
- parser_position,
- NodeId::new(node_id),
- ),
- ),
- PreparedScriptSourceLoadOutcome {
- source_result: Ok("globalThis.__staleDeferRan = true".to_owned()),
- source_bytes: None,
- network_result: network_error.map(|error| Arc::new(Err(error.to_owned()))),
- },
- )
- };
- let network_attribution_for = |parser_position| {
- MainParserDeferredClassicSourceNetworkAttribution::new(
- Url::parse("https://stale-defer.test/document").unwrap(),
- Url::parse(&format!(
- "https://stale-defer.test/script-{parser_position}.js"
- ))
- .unwrap(),
+ .websocket_sender_for_test()
+ .event_sender()
+ .send(event)
+ .await,
+ "test WebSocket ingress should retain its typed Page route"
+ );
+ let task = page_vm
+ .page_task_executor_sources_for_test()
+ .take_scheduler_task_for_executor_test(|descriptor| {
+ matches!(
+ descriptor,
+ crate::page_task_queue::RendererPageReadyDescriptor::WebSocket { .. }
)
- };
- let mut queue = RendererPageNetworkingSource::new_for_test();
- queue.enqueue_local_for_test(
- RendererPageResourceCompletion::main_parser_deferred_classic_source(
- root_document,
- completion_for(stale_owner, 1, 9, Some("stale defer request failed")),
- network_attribution_for(1),
- ),
- );
- queue.enqueue_local_for_test(
- RendererPageResourceCompletion::main_parser_deferred_classic_source(
- root_document,
- completion_for(later_stale_owner, 2, 10, None),
- network_attribution_for(2),
- ),
- );
- let activity_epoch_before = page_vm.vm().subresource_activity_epoch();
-
- let outcome = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)
- .expect("stale completion arbitration should succeed")
- .expect("typed stale completion must remain runnable beside blocked WebSocket work");
- assert_eq!(
- outcome.action,
- PageResourceCompletionTurnAction {
- source: RendererOwnerResourceActivitySource::MainParserDeferredClassicSource,
- owner: RendererPageResourceCompletionOwner::main_document(
- root_document,
- stale_owner,
- ),
- document_effect: PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
- current_owner: Some(RendererPageResourceCompletionOwner::main_document(
- root_document,
- current_owner,
- )),
- },
- body_activity: PageResourceCompletionBodyActivity::NoPageCodeOrEventDispatch,
- post_checkpoint_effect: PageResourceCompletionPostCheckpointEffect::None,
- output_effect: PageResourceCompletionOutputEffect::CaptureRequired,
- }
- );
-
- assert!(queue.has_ready_completion());
-
- let second = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)
- .expect("second stale completion arbitration should succeed")
- .expect("second stale completion should consume its own turn");
- assert_eq!(
- second.action,
- PageResourceCompletionTurnAction {
- source: RendererOwnerResourceActivitySource::MainParserDeferredClassicSource,
- owner: RendererPageResourceCompletionOwner::main_document(
- root_document,
- later_stale_owner,
- ),
- document_effect: PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
- current_owner: Some(RendererPageResourceCompletionOwner::main_document(
- root_document,
- current_owner,
- )),
- },
- body_activity: PageResourceCompletionBodyActivity::NoPageCodeOrEventDispatch,
- post_checkpoint_effect: PageResourceCompletionPostCheckpointEffect::None,
- output_effect: PageResourceCompletionOutputEffect::None,
- }
- );
-
- assert!(!queue.has_ready_completion());
- assert_eq!(
- page_vm.vm().subresource_activity_epoch(),
- activity_epoch_before,
- "stale defer Network output must not become current Document activity"
- );
- let (network_records, websocket_events, websocket_lifecycle_events) =
- split_network_output_items(page_vm.vm_mut().take_network_output());
- assert!(websocket_events.is_empty());
- assert!(websocket_lifecycle_events.is_empty());
- assert_eq!(network_records.len(), 1);
- assert_eq!(
- network_records[0].document_url().as_str(),
- "https://stale-defer.test/document"
- );
- assert_eq!(
- network_records[0].url().as_str(),
- "https://stale-defer.test/script-1.js"
- );
- assert_eq!(
- network_records[0].outcome(),
- &SubresourceNetworkOutcome::Failure {
- error_text: "stale defer request failed".to_owned(),
- }
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__staleDeferRan)")
- .expect("replacement Document should remain observable"),
- "undefined",
- "stale completion must not execute or rediscover the current Document"
- );
- })
- .await;
+ })
+ .expect("test WebSocket ingress should publish one typed source head");
+ let crate::page_task_queue::RendererPageSchedulerTask::WebSocket(task) = task else {
+ panic!("WebSocket descriptor dequeued a different task variant")
+ };
+ task.return_backpressured();
+ assert!(
+ !page_vm.has_ready_page_websocket_task_for_test(),
+ "current-Document backpressure must not remain runnable"
+ );
}
-#[tokio::test(flavor = "current_thread")]
-async fn stale_child_classic_completion_preserves_network_without_document_activity() {
- run_page_vm_async_test(async move {
- let mut page_vm = test_page_vm();
- let root_document = page_vm.document_lifecycle.identity().document;
- let child_handle = crate::dom::native::NativeNodeId::new(401);
- let stale_owner = FrameDocumentTaskOwner::new(
- crate::frame_owner_model::FrameSchedulerLaneId(4),
- crate::frame_owner_model::LocalWindowId(5),
- DocumentId(6),
- );
- let mut queue = RendererPageNetworkingSource::new_for_test();
- queue.enqueue_local_for_test(RendererPageResourceCompletion::child_classic_script(
- root_document,
- ChildClassicScriptLoadCompletion {
- owner: stale_owner,
- load_id: 7,
- handle: child_handle,
- script_handle: crate::dom::native::NativeNodeId::new(402),
- result: Ok("globalThis.__staleChildClassicRan = true".to_owned()),
- network_result: Some(Arc::new(Err(
- "stale child classic request failed".to_owned()
- ))),
- network_attribution: ChildClassicScriptNetworkAttribution {
- frame_id: Some("stale-child-classic-frame".to_owned()),
- document_url: Url::parse("https://stale-child.test/classic-document").unwrap(),
- request_url: Url::parse("https://stale-child.test/classic.js").unwrap(),
- },
- },
- ));
- let activity_epoch_before = page_vm.vm().subresource_activity_epoch();
-
- let outcome = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)
- .expect("stale child classic arbitration should succeed")
- .expect("stale child classic completion should consume one bounded turn");
- assert_eq!(
- outcome.action,
- PageResourceCompletionTurnAction {
- source: RendererOwnerResourceActivitySource::ChildClassicScript,
- owner: RendererPageResourceCompletionOwner::child_document(
- root_document,
- child_handle,
- stale_owner,
- ),
- document_effect: PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
- current_owner: None,
- },
- body_activity: PageResourceCompletionBodyActivity::NoPageCodeOrEventDispatch,
- post_checkpoint_effect: PageResourceCompletionPostCheckpointEffect::None,
- output_effect: PageResourceCompletionOutputEffect::CaptureRequired,
- }
- );
-
- assert!(!queue.has_ready_completion());
- assert_eq!(
- page_vm.vm().subresource_activity_epoch(),
- activity_epoch_before,
- "a retired child classic request must not become current Document activity"
- );
- let (network_records, websocket_events, websocket_lifecycle_events) =
- split_network_output_items(page_vm.vm_mut().take_network_output());
- assert!(websocket_events.is_empty());
- assert!(websocket_lifecycle_events.is_empty());
- assert_eq!(network_records.len(), 1);
- let network_record = &network_records[0];
- assert_eq!(network_record.frame_id(), Some("stale-child-classic-frame"));
- assert_eq!(
- network_record.document_url().as_str(),
- "https://stale-child.test/classic-document"
- );
- assert_eq!(
- network_record.url().as_str(),
- "https://stale-child.test/classic.js"
- );
- assert_eq!(
- network_record.resource_type(),
- SubresourceResourceType::Script
- );
- assert_eq!(
- network_record.request_initiator_type(),
- SubresourceRequestInitiatorType::Script
- );
- assert_eq!(
- network_record.outcome(),
- &SubresourceNetworkOutcome::Failure {
- error_text: "stale child classic request failed".to_owned(),
- }
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__staleChildClassicRan)")
- .expect("current main Document should remain observable"),
- "undefined"
- );
- })
- .await;
+fn run_next_resource_completion_as_typed_page_turn(
+ page_vm: &mut PageVm,
+) -> anyhow::Result<PageResourceCompletionTurnOutcome> {
+ let mut page_resource_queue = page_vm.page_resource_completion_queue();
+ page_vm
+ .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_resource_queue)?
+ .ok_or_else(|| anyhow::anyhow!("typed resource completion should consume one owner turn"))
}
-#[tokio::test(flavor = "current_thread")]
-async fn child_classic_completion_queue_runs_exactly_one_terminal_per_owner_turn() {
- run_page_vm_async_test(async move {
- let mut page_vm = test_page_vm();
- let root_document = page_vm.document_lifecycle.identity().document;
- let child_handle = crate::dom::native::NativeNodeId::new(411);
- let stale_owner = FrameDocumentTaskOwner::new(
- crate::frame_owner_model::FrameSchedulerLaneId(12),
- crate::frame_owner_model::LocalWindowId(13),
- DocumentId(14),
- );
- let completion = |load_id, script_handle| ChildClassicScriptLoadCompletion {
- owner: stale_owner,
- load_id,
- handle: child_handle,
- script_handle: crate::dom::native::NativeNodeId::new(script_handle),
- result: Ok(format!("globalThis.__staleChildClassic{load_id} = true")),
- network_result: None,
- network_attribution: ChildClassicScriptNetworkAttribution {
- frame_id: Some("stale-child-classic-turn-frame".to_owned()),
- document_url: Url::parse("https://stale-child-turn.test/document").unwrap(),
- request_url: Url::parse(&format!(
- "https://stale-child-turn.test/script-{load_id}.js"
- ))
- .unwrap(),
- },
- };
- let mut queue = RendererPageNetworkingSource::new_for_test();
- queue.enqueue_local_for_test(RendererPageResourceCompletion::child_classic_script(
- root_document,
- completion(1, 412),
- ));
- queue.enqueue_local_for_test(RendererPageResourceCompletion::child_classic_script(
- root_document,
- completion(2, 413),
- ));
-
- let first = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)
- .expect("first child classic turn should arbitrate")
- .expect("first child classic terminal should be consumed");
- assert_eq!(
- first.action.document_effect,
- PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
- current_owner: None,
- }
- );
- assert_eq!(
- first.action.output_effect,
- PageResourceCompletionOutputEffect::None,
- "a stale terminal without Network output must not synthesize an output wake"
- );
-
- assert!(
- queue.has_ready_completion(),
- "one owner turn must not drain the second typed terminal"
- );
-
- let second = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)
- .expect("second child classic turn should arbitrate")
- .expect("second child classic terminal should be consumed");
- assert_eq!(
- second.action.output_effect,
- PageResourceCompletionOutputEffect::None
- );
-
- assert!(!queue.has_ready_completion());
- assert!(page_vm.vm_mut().take_network_output().is_empty());
- for load_id in [1, 2] {
- assert_eq!(
- page_vm
- .vm_mut()
- .eval(&format!("String(globalThis.__staleChildClassic{load_id})"))
- .expect("current Document should remain observable"),
- "undefined"
- );
- }
- })
- .await;
+async fn wait_for_typed_page_resource_completion(page_vm: &mut PageVm) -> bool {
+ page_vm.wait_for_page_resource_completion_for_test().await
}
-#[tokio::test(flavor = "current_thread")]
-async fn stale_child_module_completions_preserve_network_and_run_one_terminal_per_turn() {
- run_page_vm_async_test(async move {
- let mut page_vm = test_page_vm();
- let root_document = page_vm.document_lifecycle.identity().document;
- page_vm.vm_mut().eval(
- "const staleModuleFrame = document.createElement('iframe'); \
- staleModuleFrame.id = 'stale-module-frame'; \
- document.body.appendChild(staleModuleFrame);",
- )?;
- let child_handle = page_vm
- .vm()
- .element_handle_by_id_for_test("stale-module-frame")
- .expect("same-Page stale module fixture should install a child handle");
- materialize_child_realm_through_page_turn_for_test(&mut page_vm, "stale-module-frame")?;
- let current_child_owner = page_vm
- .vm()
- .current_child_document_task_owner(child_handle)
- .expect("same-Page stale module fixture should install a child owner");
- let current_module_target = page_vm
- .vm()
- .current_child_document_module_fetch_target(child_handle)
- .expect("same-Page stale module fixture should install a child realm");
- assert_eq!(current_module_target.task_owner(), current_child_owner);
- let stale_owner = FrameDocumentTaskOwner::new(
- crate::frame_owner_model::FrameSchedulerLaneId(
- current_child_owner.scheduler_lane_id.0 + 1,
- ),
- current_child_owner.local_window_id,
- current_child_owner.document_id,
- );
- let mut queue = RendererPageNetworkingSource::new_for_test();
- queue.enqueue_local_for_test(
- RendererPageResourceCompletion::child_parser_module_root_fetch(
- root_document,
- test_child_parser_module_root_completion(
- child_handle,
- stale_owner,
- 47,
- "stale-child-module-root",
- Some("stale child module root failed"),
- ),
- ),
- );
- queue.enqueue_local_for_test(
- RendererPageResourceCompletion::child_module_dependency_fetch(
- root_document,
- test_child_module_dependency_completion(
- child_handle,
- stale_owner,
- 53,
- "stale-child-module-dependency",
- Some("stale child module dependency failed"),
- ),
- ),
- );
- queue.enqueue_local_for_test(RendererPageResourceCompletion::child_modulepreload_fetch(
- root_document,
- test_child_modulepreload_completion_for_target(
- ChildDocumentModuleFetchTarget::new(child_handle, stale_owner, FrameRealmId(109)),
- 57,
- "stale-child-modulepreload",
- Some("stale child modulepreload failed"),
- ),
- ));
- queue.enqueue_local_for_test(RendererPageResourceCompletion::child_modulepreload_fetch(
- root_document,
- test_child_modulepreload_completion_for_target(
- ChildDocumentModuleFetchTarget::new(child_handle, stale_owner, FrameRealmId(109)),
- 59,
- "stale-child-module-no-network",
- None,
- ),
- ));
- let activity_epoch_before = page_vm.vm().subresource_activity_epoch();
- let expected_owner = RendererPageResourceCompletionOwner::child_module_fetch(
- root_document,
- ChildDocumentModuleFetchTarget::new(child_handle, stale_owner, FrameRealmId(109)),
- );
- let expected_current_owner = RendererPageResourceCompletionOwner::child_module_fetch(
- root_document,
- current_module_target,
- );
-
- let root = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)?
- .expect("stale root module terminal should consume one owner turn");
- assert_eq!(root.action.owner, expected_owner);
- assert_eq!(
- root.action.document_effect,
- PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
- current_owner: Some(expected_current_owner),
- }
- );
- assert_eq!(
- root.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- assert!(queue.has_ready_completion());
-
- let dependency = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)?
- .expect("stale dependency module terminal should consume its own owner turn");
- assert_eq!(dependency.action.owner, expected_owner);
- assert_eq!(
- dependency.action.document_effect,
- PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
- current_owner: Some(expected_current_owner),
- }
- );
- assert_eq!(
- dependency.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- assert!(queue.has_ready_completion());
+fn test_child_module_network_attribution(label: &str) -> ChildModuleFetchNetworkAttribution {
+ ChildModuleFetchNetworkAttribution::parser(
+ Some(format!("{label}-frame")),
+ Url::parse(&format!("https://{label}.test/document")).unwrap(),
+ Url::parse(&format!("https://{label}.test/module.js")).unwrap(),
+ )
+}
- let modulepreload = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)?
- .expect("stale modulepreload terminal should consume its own owner turn");
- assert_eq!(modulepreload.action.owner, expected_owner);
- assert_eq!(
- modulepreload.action.document_effect,
- PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
- current_owner: Some(expected_current_owner),
- }
- );
- assert_eq!(
- modulepreload.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
+fn test_child_dynamic_import_network_attribution(
+ label: &str,
+) -> ChildModuleFetchNetworkAttribution {
+ ChildModuleFetchNetworkAttribution::dynamic_import(
+ Some(format!("{label}-frame")),
+ Url::parse(&format!("https://{label}.test/document")).unwrap(),
+ Url::parse(&format!("https://{label}.test/module.js")).unwrap(),
+ )
+}
- assert!(queue.has_ready_completion());
+fn test_child_parser_module_root_completion(
+ child_handle: crate::dom::native::NativeNodeId,
+ owner: FrameDocumentTaskOwner,
+ request_id: u64,
+ label: &str,
+ network_error: Option<&str>,
+) -> ChildParserModuleRootFetchCompletion {
+ test_child_parser_module_root_completion_for_target(
+ ChildDocumentModuleFetchTarget::new(child_handle, owner, FrameRealmId(109)),
+ request_id,
+ label,
+ network_error,
+ )
+}
- let no_network = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)?
- .expect("stale no-Network module terminal should consume its own owner turn");
- assert_eq!(no_network.action.owner, expected_owner);
- assert_eq!(
- no_network.action.document_effect,
- PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
- current_owner: Some(expected_current_owner),
- }
- );
- assert_eq!(
- no_network.action.output_effect,
- PageResourceCompletionOutputEffect::None,
- "a stale module terminal without a Network fact must not synthesize output"
- );
+fn test_child_parser_module_root_completion_for_target(
+ target: ChildDocumentModuleFetchTarget,
+ request_id: u64,
+ label: &str,
+ network_error: Option<&str>,
+) -> ChildParserModuleRootFetchCompletion {
+ let network_attribution = test_child_module_network_attribution(label);
+ ChildParserModuleRootFetchCompletion::new(
+ target,
+ FrameRequestId(request_id),
+ ModuleMapKey::java_script(network_attribution.request_url().clone()),
+ Err(format!("{label} root completion")),
+ network_error.map(|error| Arc::new(Err(error.to_owned()))),
+ network_attribution,
+ )
+}
- assert!(!queue.has_ready_completion());
- assert_eq!(
- page_vm.vm().subresource_activity_epoch(),
- activity_epoch_before,
- "retired child module Network facts must not become current Document activity"
- );
+fn test_child_module_dependency_completion(
+ child_handle: crate::dom::native::NativeNodeId,
+ owner: FrameDocumentTaskOwner,
+ request_id: u64,
+ label: &str,
+ network_error: Option<&str>,
+) -> ChildModuleDependencyFetchCompletion {
+ test_child_module_dependency_completion_for_target(
+ ChildDocumentModuleFetchTarget::new(child_handle, owner, FrameRealmId(109)),
+ request_id,
+ label,
+ network_error,
+ )
+}
- let (network_records, websocket_events, websocket_lifecycle_events) =
- split_network_output_items(page_vm.vm_mut().take_network_output());
- assert!(websocket_events.is_empty());
- assert!(websocket_lifecycle_events.is_empty());
- assert_eq!(network_records.len(), 3);
- assert_eq!(
- network_records
- .iter()
- .map(|record| record.frame_id())
- .collect::<Vec<_>>(),
- vec![
- Some("stale-child-module-root-frame"),
- Some("stale-child-module-dependency-frame"),
- Some("stale-child-modulepreload-frame"),
- ]
- );
- assert!(network_records.iter().all(|record| {
- record.resource_type() == SubresourceResourceType::Script
- && record.request_initiator_type() == SubresourceRequestInitiatorType::Parser
- }));
- assert_eq!(
- network_records[0].outcome(),
- &SubresourceNetworkOutcome::Failure {
- error_text: "stale child module root failed".to_owned(),
- }
- );
- assert_eq!(
- network_records[1].outcome(),
- &SubresourceNetworkOutcome::Failure {
- error_text: "stale child module dependency failed".to_owned(),
- }
- );
- assert_eq!(
- network_records[2].outcome(),
- &SubresourceNetworkOutcome::Failure {
- error_text: "stale child modulepreload failed".to_owned(),
- }
- );
- Ok::<_, anyhow::Error>(())
- })
- .await
- .expect("stale child module completion test should run");
+fn test_child_module_dependency_completion_for_target(
+ target: ChildDocumentModuleFetchTarget,
+ request_id: u64,
+ label: &str,
+ network_error: Option<&str>,
+) -> ChildModuleDependencyFetchCompletion {
+ let network_attribution = test_child_module_network_attribution(label);
+ let task = test_child_module_dependency_fetch_task_for_target(target, request_id, label);
+ ChildModuleDependencyFetchCompletion::new(
+ target.child_handle(),
+ FrameRequestId(request_id),
+ task,
+ Err(format!("{label} dependency completion")),
+ network_error.map(|error| Arc::new(Err(error.to_owned()))),
+ network_attribution,
+ )
}
-#[tokio::test(flavor = "current_thread")]
-async fn child_module_completion_rejects_replaced_realm_with_same_document_owner() {
- run_page_vm_async_test(async move {
- let mut page_vm = test_page_vm();
- page_vm.vm_mut().eval(
- "const realmReplacementFrame = document.createElement('iframe'); \
- realmReplacementFrame.id = 'realm-replacement-frame'; \
- document.body.appendChild(realmReplacementFrame);",
- )?;
- let child_handle = page_vm
- .vm()
- .element_handle_by_id_for_test("realm-replacement-frame")
- .expect("realm replacement fixture should install a child handle");
- materialize_child_realm_through_page_turn_for_test(
- &mut page_vm,
- "realm-replacement-frame",
- )?;
- let retired_target = page_vm
- .vm()
- .current_child_document_module_fetch_target(child_handle)
- .expect("first child realm should have an exact module target");
- let root_completion = test_child_parser_module_root_completion_for_target(
- retired_target,
- 61,
- "stale-child-module-root-realm",
- Some("retired child realm root fetch failed"),
- );
- let dependency_completion = test_child_module_dependency_completion_for_target(
- retired_target,
- 67,
- "stale-child-module-dependency-realm",
- Some("retired child realm dependency fetch failed"),
- );
- let modulepreload_completion = test_child_modulepreload_completion_for_target(
- retired_target,
- 71,
- "stale-child-modulepreload-realm",
- Some("retired child realm modulepreload failed"),
- );
-
- page_vm
- .vm_mut()
- .retire_child_frame_realm_for_test(child_handle);
- materialize_child_realm_through_page_turn_for_test(
- &mut page_vm,
- "realm-replacement-frame",
- )?;
- let current_target = page_vm
- .vm()
- .current_child_document_module_fetch_target(child_handle)
- .expect("replacement child realm should have an exact module target");
- assert_eq!(current_target.child_handle(), retired_target.child_handle());
- assert_eq!(current_target.task_owner(), retired_target.task_owner());
- assert_ne!(
- current_target.realm_id(),
- retired_target.realm_id(),
- "realm replacement must preserve the Document owner while changing execution identity"
- );
-
- let root_document = page_vm.document_lifecycle.identity().document;
- let expected_owner = RendererPageResourceCompletionOwner::child_module_fetch(
- root_document,
- retired_target,
- );
- let expected_current_owner = RendererPageResourceCompletionOwner::child_module_fetch(
- root_document,
- current_target,
- );
- let activity_epoch_before = page_vm.vm().subresource_activity_epoch();
- let mut queue = RendererPageNetworkingSource::new_for_test();
- queue.enqueue_local_for_test(
- RendererPageResourceCompletion::child_parser_module_root_fetch(
- root_document,
- root_completion,
- ),
- );
- queue.enqueue_local_for_test(
- RendererPageResourceCompletion::child_module_dependency_fetch(
- root_document,
- dependency_completion,
- ),
- );
- queue.enqueue_local_for_test(
- RendererPageResourceCompletion::child_modulepreload_fetch(
- root_document,
- modulepreload_completion,
- ),
- );
-
- let root_outcome = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)?
- .expect("retired-realm terminal should consume exactly one owner turn");
- assert_eq!(root_outcome.action.owner, expected_owner);
- assert_eq!(
- root_outcome.action.document_effect,
- PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
- current_owner: Some(expected_current_owner),
- }
- );
- assert_eq!(
- root_outcome.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- let dependency_outcome = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)?
- .expect("retired-realm dependency must consume a second owner turn");
- assert_eq!(dependency_outcome.action.owner, expected_owner);
- assert_eq!(
- dependency_outcome.action.document_effect,
- PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
- current_owner: Some(expected_current_owner),
- }
- );
- assert_eq!(
- dependency_outcome.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- let modulepreload_outcome = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)?
- .expect("retired-realm modulepreload must consume a third owner turn");
- assert_eq!(modulepreload_outcome.action.owner, expected_owner);
- assert_eq!(
- modulepreload_outcome.action.document_effect,
- PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
- current_owner: Some(expected_current_owner),
- }
- );
- assert_eq!(
- modulepreload_outcome.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- assert_eq!(
- page_vm.vm().subresource_activity_epoch(),
- activity_epoch_before,
- "historical Network output from a retired realm must not become current Document activity"
- );
+fn test_child_module_dependency_fetch_task_for_target(
+ target: ChildDocumentModuleFetchTarget,
+ request_id: u64,
+ label: &str,
+) -> FrameDocumentModuleDependencyFetchTask {
+ let parent_url = Url::parse(&format!("https://{label}.test/root.js")).unwrap();
+ let dependency_url = Url::parse(&format!("https://{label}.test/module.js")).unwrap();
+ let parent_key = ModuleMapKey::java_script(parent_url.clone());
+ let dependency_key = ModuleMapKey::java_script(dependency_url.clone());
+ let parent_entry_id = ModuleEntryId::from_raw(113);
+ let tree_client = module_tree::SingleModuleClientToken {
+ tree_id: module_tree::ModuleTreeId(127),
+ sequence: request_id,
+ };
+ let client = FrameDocumentStaticDependencyModuleClient::new(
+ parent_entry_id,
+ parent_key.clone(),
+ "./module.js".to_owned(),
+ ModuleImportPhase::Evaluation,
+ tree_client,
+ );
+ let entry_id = FrameDocumentModuleClientEntryId::from_raw(131);
+ let reservation = FrameDocumentModuleClientReservation::new(
+ target.task_owner().document_owner(),
+ dependency_key.clone(),
+ FrameDocumentModuleClientRegistration::new(
+ entry_id,
+ FrameDocumentModuleClientId::from_raw(request_id),
+ FrameDocumentModuleFetchDisposition::StartedFetch(entry_id),
+ ),
+ );
+ FrameDocumentModuleDependencyFetchTask::from_dependency_fetch_parts(
+ target.task_owner(),
+ target.realm_id(),
+ dependency_key.clone(),
+ client,
+ reservation,
+ NativeModuleGraphFetchRequest::new_tree_dependency_for_test(
+ dependency_url,
+ parent_url,
+ ModuleFetchMetadata::default(),
+ ModuleKind::JavaScript,
+ tree_client,
+ dependency_key,
+ parent_key,
+ parent_entry_id,
+ "./module.js".to_owned(),
+ ModuleImportPhase::Evaluation,
+ ),
+ )
+}
- let (network_records, websocket_events, websocket_lifecycle_events) =
- split_network_output_items(page_vm.vm_mut().take_network_output());
- assert!(websocket_events.is_empty());
- assert!(websocket_lifecycle_events.is_empty());
- assert_eq!(network_records.len(), 3);
- assert_eq!(
- network_records[0].frame_id(),
- Some("stale-child-module-root-realm-frame")
- );
- assert_eq!(
- network_records[0].outcome(),
- &SubresourceNetworkOutcome::Failure {
- error_text: "retired child realm root fetch failed".to_owned(),
- }
- );
- assert_eq!(
- network_records[1].frame_id(),
- Some("stale-child-module-dependency-realm-frame")
- );
- assert_eq!(
- network_records[1].outcome(),
- &SubresourceNetworkOutcome::Failure {
- error_text: "retired child realm dependency fetch failed".to_owned(),
- }
- );
- assert_eq!(
- network_records[2].frame_id(),
- Some("stale-child-modulepreload-realm-frame")
- );
- assert_eq!(
- network_records[2].outcome(),
- &SubresourceNetworkOutcome::Failure {
- error_text: "retired child realm modulepreload failed".to_owned(),
- }
- );
- Ok::<_, anyhow::Error>(())
- })
- .await
- .expect("same-Document stale child realm test should run");
+fn test_child_modulepreload_completion_for_target(
+ target: ChildDocumentModuleFetchTarget,
+ load_id: u64,
+ label: &str,
+ network_error: Option<&str>,
+) -> ChildModulepreloadFetchCompletion {
+ ChildModulepreloadFetchCompletion::new(
+ target,
+ load_id,
+ Err(format!("{label} modulepreload completion")),
+ network_error.map(|error| Arc::new(Err(error.to_owned()))),
+ test_child_module_network_attribution(label),
+ )
}
-#[tokio::test(flavor = "current_thread")]
-async fn child_modulepreload_start_rejects_replaced_realm_with_same_document_owner() {
- run_page_vm_async_test(async move {
- let mut page_vm = test_page_vm();
- page_vm.vm_mut().eval(
- "const frame = document.createElement('iframe'); \
- frame.id = 'modulepreload-start-realm-replacement'; \
- document.body.appendChild(frame);",
- )?;
- let child_handle = page_vm
- .vm()
- .element_handle_by_id_for_test("modulepreload-start-realm-replacement")
- .expect("realm replacement fixture should install a child handle");
- materialize_child_realm_through_page_turn_for_test(
- &mut page_vm,
- "modulepreload-start-realm-replacement",
- )?;
- let retired_target = page_vm
- .vm()
- .current_child_document_module_fetch_target(child_handle)
- .expect("first child realm should have an exact module target");
- let root_document = page_vm.document_lifecycle.identity().document;
- page_vm
- .page_task_executor_sources_for_test()
- .modulepreload_start()
- .enqueue_local_for_test(
- root_document,
- test_child_modulepreload_start_task_for_target(
- retired_target,
- "retired-modulepreload-start-realm",
- ),
- );
+fn test_child_dynamic_import_completion_for_target(
+ target: ChildDocumentModuleFetchTarget,
+ load_id: u64,
+ label: &str,
+ network_error: Option<&str>,
+) -> ChildDynamicImportFetchCompletion {
+ ChildDynamicImportFetchCompletion::new(
+ target,
+ load_id,
+ Err(format!("{label} dynamic import completion")),
+ network_error.map(|error| Arc::new(Err(error.to_owned()))),
+ test_child_dynamic_import_network_attribution(label),
+ )
+}
- page_vm
- .vm_mut()
- .retire_child_frame_realm_for_test(child_handle);
- materialize_child_realm_through_page_turn_for_test(
- &mut page_vm,
- "modulepreload-start-realm-replacement",
- )?;
- let current_target = page_vm
- .vm()
- .current_child_document_module_fetch_target(child_handle)
- .expect("replacement child realm should have an exact module target");
- assert_eq!(current_target.task_owner(), retired_target.task_owner());
- assert_ne!(current_target.realm_id(), retired_target.realm_id());
+fn test_child_modulepreload_start_task_for_target(
+ target: ChildDocumentModuleFetchTarget,
+ label: &str,
+) -> FrameDocumentModulepreloadFetchTask {
+ let source_url = Url::parse(&format!("https://{label}.test/modulepreload.js"))
+ .expect("modulepreload start URL");
+ FrameDocumentModulepreloadFetchTask::from_modulepreload_fetch_parts(
+ target.realm_id(),
+ FrameDocumentModulepreloadLinkClient::new(
+ target.child_handle(),
+ target.task_owner(),
+ crate::dom::native::NativeNodeId::new(997),
+ ),
+ NativeModuleSingleFetchRequest::new(
+ source_url.clone(),
+ source_url.clone(),
+ source_url.clone(),
+ ModuleMapKey::java_script(source_url),
+ ModuleFetchMetadata::default(),
+ ),
+ )
+}
- let outcome = page_vm
- .run_page_modulepreload_start_body_for_test()
- .expect("stale-realm start should consume exactly one bounded turn");
- assert_eq!(
- outcome.action.owner,
- RendererPageModulepreloadStartOwner::new(root_document, retired_target)
- );
- assert_eq!(
- outcome.action.document_effect,
- PageModulepreloadStartDocumentEffect::DiscardedStaleOwner {
- current_owner: Some(RendererPageModulepreloadStartOwner::new(
- root_document,
- current_target,
- )),
- }
- );
+fn test_page_vm_with_config(
+ config: FetchConfig,
+ extra_http_headers: Vec<(String, String)>,
+) -> PageVm {
+ let loader_owner = crate::network::ResourceRequestClient::new(&config).expect("loader");
+ let mut page_vm = test_page_vm_with_loader(&loader_owner, extra_http_headers);
+ page_vm.retain_standalone_request_client_owner_for_test(loader_owner);
+ page_vm
+}
- assert!(
- !page_vm
- .page_task_executor_sources_for_test()
- .modulepreload_start()
- .has_ready_task(),
- "a stale typed start must consume only its stable source head"
- );
- Ok::<_, anyhow::Error>(())
- })
- .await
- .expect("same-Document stale modulepreload start realm test should run");
+fn test_page_vm_with_loader(
+ loader: &crate::network::ResourceRequestClient,
+ extra_http_headers: Vec<(String, String)>,
+) -> PageVm {
+ test_page_vm_with_loader_and_document_url(
+ loader,
+ extra_http_headers,
+ Url::parse("https://example.com/").unwrap(),
+ )
}
-#[tokio::test(flavor = "current_thread")]
-async fn child_modulepreload_start_rejects_reused_local_owner_from_retired_root_document() {
- run_page_vm_async_test(async move {
- let mut page_vm = test_page_vm();
- page_vm.vm_mut().eval(
- "const frame = document.createElement('iframe'); \
- frame.id = 'modulepreload-start-root-replacement'; \
- document.body.appendChild(frame);",
- )?;
- let child_handle = page_vm
- .vm()
- .element_handle_by_id_for_test("modulepreload-start-root-replacement")
- .expect("root replacement fixture should install a child handle");
- materialize_child_realm_through_page_turn_for_test(
- &mut page_vm,
- "modulepreload-start-root-replacement",
- )?;
- let reused_local_target = page_vm
- .vm()
- .current_child_document_module_fetch_target(child_handle)
- .expect("current PageVm should expose an exact child target");
- let current_root = page_vm.document_lifecycle.identity().document;
- let retired_root = current_root.successor_for_testing();
- page_vm.page_task_executor_sources_for_test().modulepreload_start()
- .enqueue_local_for_test(
- retired_root,
- test_child_modulepreload_start_task_for_target(
- reused_local_target,
- "retired-root-modulepreload-start",
- ),
- );
+fn test_page_vm_with_document_url(document_url: Url) -> PageVm {
+ let loader_owner =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm =
+ test_page_vm_with_loader_and_document_url(&loader_owner, Vec::new(), document_url);
+ page_vm.retain_standalone_request_client_owner_for_test(loader_owner);
+ page_vm
+}
- let outcome = page_vm
- .run_page_modulepreload_start_body_for_test()
- .expect("retired-root start should consume one stale turn");
- assert_eq!(
- outcome.action.owner,
- RendererPageModulepreloadStartOwner::new(retired_root, reused_local_target)
- );
- assert_eq!(
- outcome.action.document_effect,
- PageModulepreloadStartDocumentEffect::DiscardedStaleOwner {
- current_owner: Some(RendererPageModulepreloadStartOwner::new(
- current_root,
- reused_local_target,
- )),
- },
- "PageVm-local owner counters may collide after replacement, so the root token must remain part of authorization"
- );
+fn test_page_vm_with_root_frame_id(root_frame_id: &str) -> PageVm {
+ let loader_owner =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let dom_host = DomHost::from_dom(HtmlParser::SCRIPTING_ENABLED.parse(
+ Url::parse("https://example.com/").expect("test Document URL"),
+ "<!doctype html><html><head></head><body></body></html>".to_owned(),
+ ));
+ let mut page_vm = test_page_vm_with_loader_dom_host_hooks_and_response_referrer_policy(
+ &loader_owner,
+ Vec::new(),
+ dom_host,
+ PageVmRuntimeHooks::standalone_without_owner_reservation_for_test(),
+ None,
+ Some(root_frame_id.to_owned()),
+ );
+ page_vm.retain_standalone_request_client_owner_for_test(loader_owner);
+ page_vm
+}
- assert!(
- !page_vm.page_task_executor_sources_for_test().modulepreload_start()
- .has_ready_task(),
- "a root-stale typed start must consume only its stable source head"
- );
- Ok::<_, anyhow::Error>(())
- })
- .await
- .expect("retired-root modulepreload start test should run");
+fn test_page_vm_with_response_referrer_policy(
+ document_url: Url,
+ response_referrer_policy: impl Into<String>,
+) -> PageVm {
+ let loader_owner =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_document_url_hooks_and_response_referrer_policy(
+ &loader_owner,
+ Vec::new(),
+ document_url,
+ PageVmRuntimeHooks::standalone_without_owner_reservation_for_test(),
+ Some(response_referrer_policy.into()),
+ );
+ page_vm.retain_standalone_request_client_owner_for_test(loader_owner);
+ page_vm
}
-#[tokio::test(flavor = "current_thread")]
-async fn modulepreload_start_source_consumes_one_exact_owner_per_turn_in_fifo_order() {
- run_page_vm_async_test(async move {
- let mut page_vm = test_page_vm();
- let root_document = page_vm.document_lifecycle.identity().document;
- let first_target = ChildDocumentModuleFetchTarget::new(
- crate::dom::native::NativeNodeId::new(701),
- FrameDocumentTaskOwner::new(
- crate::frame_owner_model::FrameSchedulerLaneId(703),
- crate::frame_owner_model::LocalWindowId(709),
- DocumentId(719),
- ),
- FrameRealmId(727),
- );
- let second_target = ChildDocumentModuleFetchTarget::new(
- crate::dom::native::NativeNodeId::new(733),
- FrameDocumentTaskOwner::new(
- crate::frame_owner_model::FrameSchedulerLaneId(739),
- crate::frame_owner_model::LocalWindowId(743),
- DocumentId(751),
- ),
- FrameRealmId(757),
- );
- let source = page_vm
- .page_task_executor_sources_for_test()
- .modulepreload_start();
- source.enqueue_local_for_test(
- root_document,
- test_child_modulepreload_start_task_for_target(first_target, "first-start-turn"),
- );
- source.enqueue_local_for_test(
- root_document,
- test_child_modulepreload_start_task_for_target(second_target, "second-start-turn"),
- );
+fn dns_failure_fetch_config() -> FetchConfig {
+ let mut config = FetchConfig::default();
+ config.set_http_no_proxy(Some("*".to_owned()));
+ config.set_request_timeout_ms(2_000);
+ config.set_connect_timeout_ms(Some(500));
+ config
+}
- let first = page_vm
- .run_page_modulepreload_start_body_for_test()
- .expect("first start should consume one turn");
- assert_eq!(
- first.action.owner,
- RendererPageModulepreloadStartOwner::new(root_document, first_target)
- );
- assert!(matches!(
- first.action.document_effect,
- PageModulepreloadStartDocumentEffect::DiscardedStaleOwner {
- current_owner: None
- }
- ));
-
- let second = page_vm
- .run_page_modulepreload_start_body_for_test()
- .expect("second start should consume a separate turn");
- assert_eq!(
- second.action.owner,
- RendererPageModulepreloadStartOwner::new(root_document, second_target)
- );
-
- assert!(!source.has_ready_task());
- Ok::<_, anyhow::Error>(())
- })
- .await
- .expect("modulepreload start FIFO test should run");
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn production_child_module_route_reaches_exact_realm_page_turn() {
- run_page_vm_async_test(async move {
- let mut page_vm = test_page_vm();
- page_vm.vm_mut().eval(
- "const productionModuleFrame = document.createElement('iframe'); \
- productionModuleFrame.id = 'production-module-frame'; \
- document.body.appendChild(productionModuleFrame);",
- )?;
- let child_handle = page_vm
- .vm()
- .element_handle_by_id_for_test("production-module-frame")
- .expect("production route fixture should install a child handle");
- materialize_child_realm_through_page_turn_for_test(
- &mut page_vm,
- "production-module-frame",
- )?;
- let target = page_vm
- .vm()
- .current_child_document_module_fetch_target(child_handle)
- .expect("production route fixture should expose an exact module target");
- let root_document = page_vm.document_lifecycle.identity().document;
-
- let (wake_tx, mut wake_rx) = tokio::sync::mpsc::unbounded_channel();
- let token = crate::runtime::RendererPageToken::new_for_testing(root_document.page_id);
- let owner_wake = crate::page_task_queue::RendererOwnerWakeSender::new(wake_tx, token);
- let mut page_queue = RendererPageNetworkingSource::new_owner_attached(
- crate::page_task_queue::PageRuntimeWakeSignal::default(),
- owner_wake.clone(),
- );
- let sender =
- crate::page_task_queue::RendererResourceCompletionSender::for_page_resource_test(
- page_queue.sender(),
- root_document,
- );
- let activity_epoch_before = page_vm.vm().subresource_activity_epoch();
- sender
- .send_child_parser_module_root_fetch(
- test_child_parser_module_root_completion_for_target(
- target,
- 67,
- "production-child-module-route",
- Some("production routed module fetch failed"),
- ),
- )
- .expect("production sender should enqueue the typed child module terminal");
-
- assert_eq!(
- wake_rx
- .try_recv()
- .expect("accepted production terminal should publish one Page wake")
- .page_id(),
- root_document.page_id
- );
- assert!(
- wake_rx.try_recv().is_err(),
- "one accepted terminal must not publish a duplicate wake"
- );
-
- let outcome = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_queue)?
- .expect("production-routed terminal should execute through the typed Page turn");
- assert_eq!(
- outcome.action.owner,
- RendererPageResourceCompletionOwner::child_module_fetch(root_document, target)
- );
- assert_eq!(
- outcome.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- outcome.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- assert!(!page_queue.has_ready_completion());
- assert!(
- page_vm.vm().subresource_activity_epoch() > activity_epoch_before,
- "current-target Network output must be attributed to current Document activity"
- );
-
- let (network_records, websocket_events, websocket_lifecycle_events) =
- split_network_output_items(page_vm.vm_mut().take_network_output());
- assert!(websocket_events.is_empty());
- assert!(websocket_lifecycle_events.is_empty());
- assert_eq!(network_records.len(), 1);
- assert_eq!(
- network_records[0].frame_id(),
- Some("production-child-module-route-frame")
- );
- Ok::<_, anyhow::Error>(())
- })
- .await
- .expect("production child module stable-route test should run");
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn stale_child_unusable_stylesheet_preserves_physical_output_without_document_effect() {
- run_page_vm_async_test(async move {
- let mut page_vm = test_page_vm();
- let root_document = page_vm.document_lifecycle.identity().document;
- let child_handle = crate::dom::native::NativeNodeId::new(404);
- let stale_owner = FrameDocumentTaskOwner::new(
- crate::frame_owner_model::FrameSchedulerLaneId(7),
- crate::frame_owner_model::LocalWindowId(8),
- DocumentId(9),
- );
- let request_url = Url::parse("https://stale-child.test/style.css").unwrap();
- let physical_response = crate::protocol_types::NavigationResponse::from_text_body(
- request_url.clone(),
- 200,
- vec![("Content-Type".to_owned(), b"text/html".to_vec())],
- "<html>not a stylesheet</html>".to_owned(),
- );
- let mut queue = RendererPageNetworkingSource::new_for_test();
- queue.enqueue_local_for_test(RendererPageResourceCompletion::child_blocking_stylesheet(
- root_document,
- ChildBlockingStylesheetLoadCompletion {
- child_handle,
- owner: stale_owner,
- signature: crate::DocumentBlockingStylesheetSignature::ParserCreatedStyleImport {
- urls: Vec::new(),
- },
- network_results: vec![ChildBlockingStylesheetNetworkResult {
- frame_id: Some("stale-child-frame".to_owned()),
- document_url: Url::parse("https://stale-child.test/document").unwrap(),
- request_url,
- initiator_type: SubresourceRequestInitiatorType::Parser,
- terminal:
- crate::stylesheet_blocking::StylesheetFetchTerminal::unusable_response(
- physical_response,
- false,
- "stylesheet MIME validation failed",
- ),
- }],
- },
- ));
- let activity_epoch_before = page_vm.vm().subresource_activity_epoch();
-
- let outcome = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut queue)
- .expect("stale child completion arbitration should succeed")
- .expect("stale child completion should consume one bounded turn");
- assert_eq!(
- outcome.action,
- PageResourceCompletionTurnAction {
- source: RendererOwnerResourceActivitySource::ChildBlockingStylesheet,
- owner: RendererPageResourceCompletionOwner::child_document(
- root_document,
- child_handle,
- stale_owner,
- ),
- document_effect: PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
- current_owner: None,
- },
- body_activity: PageResourceCompletionBodyActivity::NoPageCodeOrEventDispatch,
- post_checkpoint_effect: PageResourceCompletionPostCheckpointEffect::None,
- output_effect: PageResourceCompletionOutputEffect::CaptureRequired,
- }
- );
-
- assert!(!queue.has_ready_completion());
- assert_eq!(
- page_vm.vm().subresource_activity_epoch(),
- activity_epoch_before,
- "a retired Document's Network fact must not become activity of the current Document"
- );
- let (network_records, websocket_events, websocket_lifecycle_events) =
- split_network_output_items(page_vm.vm_mut().take_network_output());
- assert!(websocket_events.is_empty());
- assert!(websocket_lifecycle_events.is_empty());
- assert_eq!(
- network_records.len(),
- 1,
- "stale child Document must not suppress or duplicate the completed Network fact"
- );
- let network_record = &network_records[0];
- assert_eq!(network_record.frame_id(), Some("stale-child-frame"));
- assert_eq!(
- network_record.document_url().as_str(),
- "https://stale-child.test/document"
- );
- assert_eq!(
- network_record.url().as_str(),
- "https://stale-child.test/style.css"
- );
- assert_eq!(
- network_record.resource_type(),
- SubresourceResourceType::Stylesheet
- );
- assert_eq!(
- network_record.request_initiator_type(),
- SubresourceRequestInitiatorType::Parser
- );
- assert!(matches!(
- network_record.outcome(),
- SubresourceNetworkOutcome::Success { status: 200, .. }
- ));
- })
- .await;
+fn test_page_vm_with_loader_and_document_url(
+ loader: &crate::network::ResourceRequestClient,
+ extra_http_headers: Vec<(String, String)>,
+ document_url: Url,
+) -> PageVm {
+ test_page_vm_with_loader_document_url_and_hooks(
+ loader,
+ extra_http_headers,
+ document_url,
+ PageVmRuntimeHooks::standalone_without_owner_reservation_for_test(),
+ )
}
-pub(super) fn test_page_vm() -> PageVm {
- test_page_vm_with_config(FetchConfig::default(), Vec::new())
+fn test_page_vm_with_loader_document_url_and_hooks(
+ loader: &crate::network::ResourceRequestClient,
+ extra_http_headers: Vec<(String, String)>,
+ document_url: Url,
+ runtime_hooks: PageVmRuntimeHooks,
+) -> PageVm {
+ test_page_vm_with_loader_document_url_hooks_and_response_referrer_policy(
+ loader,
+ extra_http_headers,
+ document_url,
+ runtime_hooks,
+ None,
+ )
}
-async fn park_current_document_websocket_for_test(
- page_vm: &mut PageVm,
- event: moli_websocket::Event,
+/// Builds a low-level PageVm executor fixture with the production Page task
+/// sources and wake route bound.
+///
+/// It deliberately has no `RendererOwnerLocalPageSlot` or scheduler
+/// residence. Tests using it may prove producer routing, exact-owner
+/// arbitration, and one-task execution, but not owner admission, fairness, or
+/// autonomous liveness.
+fn page_vm_with_bound_task_sources_and_owner_wake(
+ loader: &crate::network::ResourceRequestClient,
+ document_url: Url,
+) -> (
+ PageVm,
+ crate::page_task_queue::RendererPageResourceCompletionTestSource,
+ tokio::sync::mpsc::UnboundedReceiver<crate::page_task_queue::RendererOwnerWake>,
) {
- assert!(
- page_vm
- .vm()
- .websocket_sender_for_test()
- .event_sender()
- .send(event)
- .await,
- "test WebSocket ingress should retain its typed Page route"
+ let (wake_tx, wake_rx) = tokio::sync::mpsc::unbounded_channel();
+ let owner_wake = crate::page_task_queue::RendererOwnerWakeSender::new(
+ wake_tx,
+ crate::runtime::RendererPageToken::new_for_testing(PageId::new_for_testing(1)),
);
- let task = page_vm
- .page_task_executor_sources_for_test()
- .take_scheduler_task_for_executor_test(|descriptor| {
- matches!(
- descriptor,
- crate::page_task_queue::RendererPageReadyDescriptor::WebSocket { .. }
- )
- })
- .expect("test WebSocket ingress should publish one typed source head");
- let crate::page_task_queue::RendererPageSchedulerTask::WebSocket(task) = task else {
- panic!("WebSocket descriptor dequeued a different task variant")
- };
- task.return_backpressured();
- assert!(
- !page_vm.has_ready_page_websocket_task_for_test(),
- "current-Document backpressure must not remain runnable"
+ let hooks = PageVmRuntimeHooks::standalone_with_owner_wake_without_owner_reservation_for_test(
+ owner_wake,
);
+ let page_vm =
+ test_page_vm_with_loader_document_url_and_hooks(loader, Vec::new(), document_url, hooks);
+ let queue = page_vm.page_resource_completion_queue();
+ (page_vm, queue, wake_rx)
}
-fn run_next_resource_completion_as_typed_page_turn(
+/// Materialize the only child fixture through the production producer,
+/// stable source, exact-owner arbiter, and one-turn executor.
+fn materialize_child_realm_through_page_turn_for_test(
page_vm: &mut PageVm,
-) -> anyhow::Result<PageResourceCompletionTurnOutcome> {
- let mut page_resource_queue = page_vm.page_resource_completion_queue();
- page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_resource_queue)?
- .ok_or_else(|| anyhow::anyhow!("typed resource completion should consume one owner turn"))
+ element_id: &str,
+) -> anyhow::Result<crate::page_task_queue::PageChildRealmMaterializationTurnOutcome> {
+ let child_handle = page_vm
+ .vm()
+ .element_handle_by_id_for_test(element_id)
+ .expect("child realm fixture should retain its iframe handle");
+ page_vm.vm_mut().eval(&format!(
+ "void document.getElementById({element_id:?}).contentWindow.Function; 'queued'"
+ ))?;
+ let outcome = page_vm
+ .run_child_realm_materialization_body_for_test()?
+ .expect("child Window exposure should enqueue one typed realm turn");
+ assert_eq!(
+ outcome.action.owner.target().child_handle(),
+ Some(child_handle)
+ );
+ assert_eq!(
+ outcome.action.target_effect,
+ crate::page_task_queue::PageChildRealmMaterializationTargetEffect::MaterializedCurrentOwnerWithoutDocumentStartScript
+ );
+ Ok(outcome)
}
-async fn wait_for_typed_page_resource_completion(page_vm: &mut PageVm) -> bool {
- page_vm.wait_for_page_resource_completion_for_test().await
+fn run_expected_pending_child_realm_materialization_turn(
+ page_vm: &mut PageVm,
+ label: &str,
+) -> anyhow::Result<crate::page_task_queue::PageChildRealmMaterializationTurnOutcome> {
+ let outcome = page_vm
+ .run_child_realm_materialization_body_for_test()?
+ .unwrap_or_else(|| panic!("{label} should consume one typed child-realm turn"));
+ assert_eq!(
+ outcome.action.target_effect,
+ crate::page_task_queue::PageChildRealmMaterializationTargetEffect::MaterializedCurrentOwnerWithoutDocumentStartScript,
+ "{label} must materialize the exact current child Document"
+ );
+ Ok(outcome)
}
-fn test_child_module_network_attribution(label: &str) -> ChildModuleFetchNetworkAttribution {
- ChildModuleFetchNetworkAttribution::parser(
- Some(format!("{label}-frame")),
- Url::parse(&format!("https://{label}.test/document")).unwrap(),
- Url::parse(&format!("https://{label}.test/module.js")).unwrap(),
- )
+fn materialize_only_child_realm_execution_context_through_page_turn_for_test(
+ page_vm: &mut PageVm,
+ element_id: &str,
+) -> anyhow::Result<i64> {
+ let _ = materialize_child_realm_through_page_turn_for_test(page_vm, element_id)?;
+ let realms = page_vm
+ .vm_mut()
+ .live_child_default_runtime_realm_inventory();
+ assert_eq!(
+ realms.len(),
+ 1,
+ "single-child PageVm fixture should expose exactly one live child realm"
+ );
+ Ok(realms[0].context_id)
}
-fn test_child_dynamic_import_network_attribution(
- label: &str,
-) -> ChildModuleFetchNetworkAttribution {
- ChildModuleFetchNetworkAttribution::dynamic_import(
- Some(format!("{label}-frame")),
- Url::parse(&format!("https://{label}.test/document")).unwrap(),
- Url::parse(&format!("https://{label}.test/module.js")).unwrap(),
+fn test_page_vm_with_loader_document_url_hooks_and_response_referrer_policy(
+ loader: &crate::network::ResourceRequestClient,
+ extra_http_headers: Vec<(String, String)>,
+ document_url: Url,
+ runtime_hooks: PageVmRuntimeHooks,
+ response_referrer_policy: Option<String>,
+) -> PageVm {
+ let dom_host = DomHost::from_dom(HtmlParser::SCRIPTING_ENABLED.parse(
+ document_url,
+ "<!doctype html><html><head></head><body></body></html>".to_owned(),
+ ));
+ test_page_vm_with_loader_dom_host_hooks_and_response_referrer_policy(
+ loader,
+ extra_http_headers,
+ dom_host,
+ runtime_hooks,
+ response_referrer_policy,
+ None,
)
}
-fn test_child_parser_module_root_completion(
- child_handle: crate::dom::native::NativeNodeId,
- owner: FrameDocumentTaskOwner,
- request_id: u64,
- label: &str,
- network_error: Option<&str>,
-) -> ChildParserModuleRootFetchCompletion {
- test_child_parser_module_root_completion_for_target(
- ChildDocumentModuleFetchTarget::new(child_handle, owner, FrameRealmId(109)),
- request_id,
- label,
- network_error,
+fn test_page_vm_with_loader_and_dom_host(
+ loader: &crate::network::ResourceRequestClient,
+ dom_host: DomHost,
+) -> PageVm {
+ test_page_vm_with_loader_dom_host_hooks_and_response_referrer_policy(
+ loader,
+ Vec::new(),
+ dom_host,
+ PageVmRuntimeHooks::standalone_without_owner_reservation_for_test(),
+ None,
+ None,
)
}
-fn test_child_parser_module_root_completion_for_target(
- target: ChildDocumentModuleFetchTarget,
- request_id: u64,
- label: &str,
- network_error: Option<&str>,
-) -> ChildParserModuleRootFetchCompletion {
- let network_attribution = test_child_module_network_attribution(label);
- ChildParserModuleRootFetchCompletion::new(
- target,
- FrameRequestId(request_id),
- ModuleMapKey::java_script(network_attribution.request_url().clone()),
- Err(format!("{label} root completion")),
- network_error.map(|error| Arc::new(Err(error.to_owned()))),
- network_attribution,
- )
-}
-
-fn test_child_module_dependency_completion(
- child_handle: crate::dom::native::NativeNodeId,
- owner: FrameDocumentTaskOwner,
- request_id: u64,
- label: &str,
- network_error: Option<&str>,
-) -> ChildModuleDependencyFetchCompletion {
- test_child_module_dependency_completion_for_target(
- ChildDocumentModuleFetchTarget::new(child_handle, owner, FrameRealmId(109)),
- request_id,
- label,
- network_error,
- )
-}
-
-fn test_child_module_dependency_completion_for_target(
- target: ChildDocumentModuleFetchTarget,
- request_id: u64,
- label: &str,
- network_error: Option<&str>,
-) -> ChildModuleDependencyFetchCompletion {
- let network_attribution = test_child_module_network_attribution(label);
- let task = test_child_module_dependency_fetch_task_for_target(target, request_id, label);
- ChildModuleDependencyFetchCompletion::new(
- target.child_handle(),
- FrameRequestId(request_id),
- task,
- Err(format!("{label} dependency completion")),
- network_error.map(|error| Arc::new(Err(error.to_owned()))),
- network_attribution,
- )
-}
-
-fn test_child_module_dependency_fetch_task_for_target(
- target: ChildDocumentModuleFetchTarget,
- request_id: u64,
- label: &str,
-) -> FrameDocumentModuleDependencyFetchTask {
- let parent_url = Url::parse(&format!("https://{label}.test/root.js")).unwrap();
- let dependency_url = Url::parse(&format!("https://{label}.test/module.js")).unwrap();
- let parent_key = ModuleMapKey::java_script(parent_url.clone());
- let dependency_key = ModuleMapKey::java_script(dependency_url.clone());
- let parent_entry_id = ModuleEntryId::from_raw(113);
- let tree_client = module_tree::SingleModuleClientToken {
- tree_id: module_tree::ModuleTreeId(127),
- sequence: request_id,
- };
- let client = FrameDocumentStaticDependencyModuleClient::new(
- parent_entry_id,
- parent_key.clone(),
- "./module.js".to_owned(),
- ModuleImportPhase::Evaluation,
- tree_client,
- );
- let entry_id = FrameDocumentModuleClientEntryId::from_raw(131);
- let reservation = FrameDocumentModuleClientReservation::new(
- target.task_owner().document_owner(),
- dependency_key.clone(),
- FrameDocumentModuleClientRegistration::new(
- entry_id,
- FrameDocumentModuleClientId::from_raw(request_id),
- FrameDocumentModuleFetchDisposition::StartedFetch(entry_id),
- ),
- );
- FrameDocumentModuleDependencyFetchTask::from_dependency_fetch_parts(
- target.task_owner(),
- target.realm_id(),
- dependency_key.clone(),
- client,
- reservation,
- NativeModuleGraphFetchRequest::new_tree_dependency_for_test(
- dependency_url,
- parent_url,
- ModuleFetchMetadata::default(),
- ModuleKind::JavaScript,
- tree_client,
- dependency_key,
- parent_key,
- parent_entry_id,
- "./module.js".to_owned(),
- ModuleImportPhase::Evaluation,
- ),
- )
-}
-
-fn test_child_modulepreload_completion_for_target(
- target: ChildDocumentModuleFetchTarget,
- load_id: u64,
- label: &str,
- network_error: Option<&str>,
-) -> ChildModulepreloadFetchCompletion {
- ChildModulepreloadFetchCompletion::new(
- target,
- load_id,
- Err(format!("{label} modulepreload completion")),
- network_error.map(|error| Arc::new(Err(error.to_owned()))),
- test_child_module_network_attribution(label),
- )
-}
-
-fn test_child_dynamic_import_completion_for_target(
- target: ChildDocumentModuleFetchTarget,
- load_id: u64,
- label: &str,
- network_error: Option<&str>,
-) -> ChildDynamicImportFetchCompletion {
- ChildDynamicImportFetchCompletion::new(
- target,
- load_id,
- Err(format!("{label} dynamic import completion")),
- network_error.map(|error| Arc::new(Err(error.to_owned()))),
- test_child_dynamic_import_network_attribution(label),
- )
-}
-
-fn test_child_modulepreload_start_task_for_target(
- target: ChildDocumentModuleFetchTarget,
- label: &str,
-) -> FrameDocumentModulepreloadFetchTask {
- let source_url = Url::parse(&format!("https://{label}.test/modulepreload.js"))
- .expect("modulepreload start URL");
- FrameDocumentModulepreloadFetchTask::from_modulepreload_fetch_parts(
- target.realm_id(),
- FrameDocumentModulepreloadLinkClient::new(
- target.child_handle(),
- target.task_owner(),
- crate::dom::native::NativeNodeId::new(997),
- ),
- NativeModuleSingleFetchRequest::new(
- source_url.clone(),
- source_url.clone(),
- source_url.clone(),
- ModuleMapKey::java_script(source_url),
- ModuleFetchMetadata::default(),
- ),
- )
-}
-
-fn test_page_vm_with_config(
- config: FetchConfig,
- extra_http_headers: Vec<(String, String)>,
-) -> PageVm {
- let loader_owner = crate::network::ResourceRequestClient::new(&config).expect("loader");
- let mut page_vm = test_page_vm_with_loader(&loader_owner, extra_http_headers);
- page_vm.retain_standalone_request_client_owner_for_test(loader_owner);
- page_vm
-}
-
-fn test_page_vm_with_loader(
+fn test_page_vm_with_loader_dom_host_hooks_and_response_referrer_policy(
loader: &crate::network::ResourceRequestClient,
extra_http_headers: Vec<(String, String)>,
+ dom_host: DomHost,
+ runtime_hooks: PageVmRuntimeHooks,
+ response_referrer_policy: Option<String>,
+ root_frame_id: Option<String>,
) -> PageVm {
- test_page_vm_with_loader_and_document_url(
+ let _js_runtime = crate::JsRuntime::initialize();
+ let local_executor = crate::local_executor::JsLocalExecutor::new();
+ PageVm::new(
+ PageId::new_for_testing(1),
+ local_executor,
loader,
- extra_http_headers,
- Url::parse("https://example.com/").unwrap(),
+ &PageVmEnvConfig {
+ web_storage: crate::RendererWebStorageHandles::ephemeral(),
+ root_frame_id,
+ main_document_commit: None,
+ top_level_storage_key: None,
+ document_start_scripts: vec![],
+ runtime_bindings: vec![],
+ runtime_inspector_session_restore_snapshots: vec![],
+ runtime_isolated_worlds: vec![],
+ permission_overrides: vec![],
+ extra_http_headers: extra_http_headers.into(),
+ navigator_identity: loader.browser_identity().clone(),
+ document_policy_container: crate::document_runtime::DocumentPolicyContainer {
+ referrer_policy: response_referrer_policy,
+ ..Default::default()
+ },
+ document_default_language: None,
+ document_last_modified: None,
+ script_execution_disabled: false,
+ bypass_content_security_policy: false,
+ emulated_media: crate::protocol_types::EmulatedMediaOverrides::default(),
+ idle_override: None,
+ navigator_overrides: Default::default(),
+ viewport_surface: None,
+ document_activity: Default::default(),
+ network_offline: false,
+ blocked_url_patterns: Vec::new(),
+ indexed_db_manager: None,
+ storage_bucket_store: None,
+ fetch_subresource_interception_enabled: false,
+ fetch_subresource_interception_resource_type: None,
+ layout_policy: crate::real_layout_test_policy(),
+ wpt_extensions_enabled: false,
+ navigation_bootstrap_entry: None,
+ reserved_service_worker_client_id: None,
+ },
+ runtime_hooks,
+ dom_host,
+ Instant::now(),
)
+ .expect("page vm")
}
-fn test_page_vm_with_document_url(document_url: Url) -> PageVm {
- let loader_owner =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm =
- test_page_vm_with_loader_and_document_url(&loader_owner, Vec::new(), document_url);
- page_vm.retain_standalone_request_client_owner_for_test(loader_owner);
- page_vm
-}
-
-fn test_page_vm_with_root_frame_id(root_frame_id: &str) -> PageVm {
- let loader_owner =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let dom_host = DomHost::from_dom(HtmlParser::SCRIPTING_ENABLED.parse(
- Url::parse("https://example.com/").expect("test Document URL"),
- "<!doctype html><html><head></head><body></body></html>".to_owned(),
- ));
- let mut page_vm = test_page_vm_with_loader_dom_host_hooks_and_response_referrer_policy(
- &loader_owner,
- Vec::new(),
- dom_host,
- PageVmRuntimeHooks::standalone_without_owner_reservation_for_test(),
- None,
- Some(root_frame_id.to_owned()),
- );
- page_vm.retain_standalone_request_client_owner_for_test(loader_owner);
- page_vm
-}
-
-fn test_page_vm_with_response_referrer_policy(
- document_url: Url,
- response_referrer_policy: impl Into<String>,
-) -> PageVm {
- let loader_owner =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_document_url_hooks_and_response_referrer_policy(
- &loader_owner,
- Vec::new(),
- document_url,
- PageVmRuntimeHooks::standalone_without_owner_reservation_for_test(),
- Some(response_referrer_policy.into()),
- );
- page_vm.retain_standalone_request_client_owner_for_test(loader_owner);
- page_vm
-}
-
-fn dns_failure_fetch_config() -> FetchConfig {
- let mut config = FetchConfig::default();
- config.set_http_no_proxy(Some("*".to_owned()));
- config.set_request_timeout_ms(2_000);
- config.set_connect_timeout_ms(Some(500));
- config
-}
-
-fn test_page_vm_with_loader_and_document_url(
- loader: &crate::network::ResourceRequestClient,
- extra_http_headers: Vec<(String, String)>,
- document_url: Url,
-) -> PageVm {
- test_page_vm_with_loader_document_url_and_hooks(
- loader,
- extra_http_headers,
- document_url,
- PageVmRuntimeHooks::standalone_without_owner_reservation_for_test(),
- )
-}
-
-fn test_page_vm_with_loader_document_url_and_hooks(
- loader: &crate::network::ResourceRequestClient,
- extra_http_headers: Vec<(String, String)>,
- document_url: Url,
- runtime_hooks: PageVmRuntimeHooks,
-) -> PageVm {
- test_page_vm_with_loader_document_url_hooks_and_response_referrer_policy(
- loader,
- extra_http_headers,
- document_url,
- runtime_hooks,
- None,
- )
-}
-
-/// Builds a low-level PageVm executor fixture with the production Page task
-/// sources and wake route bound.
-///
-/// It deliberately has no `RendererOwnerLocalPageSlot` or scheduler
-/// residence. Tests using it may prove producer routing, exact-owner
-/// arbitration, and one-task execution, but not owner admission, fairness, or
-/// autonomous liveness.
-fn page_vm_with_bound_task_sources_and_owner_wake(
- loader: &crate::network::ResourceRequestClient,
- document_url: Url,
-) -> (
- PageVm,
- crate::page_task_queue::RendererPageResourceCompletionTestSource,
- tokio::sync::mpsc::UnboundedReceiver<crate::page_task_queue::RendererOwnerWake>,
-) {
- let (wake_tx, wake_rx) = tokio::sync::mpsc::unbounded_channel();
- let owner_wake = crate::page_task_queue::RendererOwnerWakeSender::new(
- wake_tx,
- crate::runtime::RendererPageToken::new_for_testing(PageId::new_for_testing(1)),
- );
- let hooks = PageVmRuntimeHooks::standalone_with_owner_wake_without_owner_reservation_for_test(
- owner_wake,
- );
- let page_vm =
- test_page_vm_with_loader_document_url_and_hooks(loader, Vec::new(), document_url, hooks);
- let queue = page_vm.page_resource_completion_queue();
- (page_vm, queue, wake_rx)
-}
-
-/// Materialize the only child fixture through the production producer,
-/// stable source, exact-owner arbiter, and one-turn executor.
-fn materialize_child_realm_through_page_turn_for_test(
- page_vm: &mut PageVm,
- element_id: &str,
-) -> anyhow::Result<crate::page_task_queue::PageChildRealmMaterializationTurnOutcome> {
- let child_handle = page_vm
- .vm()
- .element_handle_by_id_for_test(element_id)
- .expect("child realm fixture should retain its iframe handle");
- page_vm.vm_mut().eval(&format!(
- "void document.getElementById({element_id:?}).contentWindow.Function; 'queued'"
- ))?;
- let outcome = page_vm
- .run_child_realm_materialization_body_for_test()?
- .expect("child Window exposure should enqueue one typed realm turn");
- assert_eq!(
- outcome.action.owner.target().child_handle(),
- Some(child_handle)
- );
- assert_eq!(
- outcome.action.target_effect,
- crate::page_task_queue::PageChildRealmMaterializationTargetEffect::MaterializedCurrentOwnerWithoutDocumentStartScript
- );
- Ok(outcome)
-}
-
-fn run_expected_pending_child_realm_materialization_turn(
- page_vm: &mut PageVm,
- label: &str,
-) -> anyhow::Result<crate::page_task_queue::PageChildRealmMaterializationTurnOutcome> {
- let outcome = page_vm
- .run_child_realm_materialization_body_for_test()?
- .unwrap_or_else(|| panic!("{label} should consume one typed child-realm turn"));
- assert_eq!(
- outcome.action.target_effect,
- crate::page_task_queue::PageChildRealmMaterializationTargetEffect::MaterializedCurrentOwnerWithoutDocumentStartScript,
- "{label} must materialize the exact current child Document"
- );
- Ok(outcome)
-}
-
-fn materialize_only_child_realm_execution_context_through_page_turn_for_test(
- page_vm: &mut PageVm,
- element_id: &str,
-) -> anyhow::Result<i64> {
- let _ = materialize_child_realm_through_page_turn_for_test(page_vm, element_id)?;
- let realms = page_vm
- .vm_mut()
- .live_child_default_runtime_realm_inventory();
- assert_eq!(
- realms.len(),
- 1,
- "single-child PageVm fixture should expose exactly one live child realm"
- );
- Ok(realms[0].context_id)
-}
-
-fn test_page_vm_with_loader_document_url_hooks_and_response_referrer_policy(
- loader: &crate::network::ResourceRequestClient,
- extra_http_headers: Vec<(String, String)>,
- document_url: Url,
- runtime_hooks: PageVmRuntimeHooks,
- response_referrer_policy: Option<String>,
-) -> PageVm {
- let dom_host = DomHost::from_dom(HtmlParser::SCRIPTING_ENABLED.parse(
- document_url,
- "<!doctype html><html><head></head><body></body></html>".to_owned(),
- ));
- test_page_vm_with_loader_dom_host_hooks_and_response_referrer_policy(
- loader,
- extra_http_headers,
- dom_host,
- runtime_hooks,
- response_referrer_policy,
- None,
- )
-}
-
-fn test_page_vm_with_loader_and_dom_host(
- loader: &crate::network::ResourceRequestClient,
- dom_host: DomHost,
-) -> PageVm {
- test_page_vm_with_loader_dom_host_hooks_and_response_referrer_policy(
- loader,
- Vec::new(),
- dom_host,
- PageVmRuntimeHooks::standalone_without_owner_reservation_for_test(),
- None,
- None,
- )
-}
-
-fn test_page_vm_with_loader_dom_host_hooks_and_response_referrer_policy(
- loader: &crate::network::ResourceRequestClient,
- extra_http_headers: Vec<(String, String)>,
- dom_host: DomHost,
- runtime_hooks: PageVmRuntimeHooks,
- response_referrer_policy: Option<String>,
- root_frame_id: Option<String>,
-) -> PageVm {
- let _js_runtime = crate::JsRuntime::initialize();
- let local_executor = crate::local_executor::JsLocalExecutor::new();
- PageVm::new(
- PageId::new_for_testing(1),
- local_executor,
- loader,
- &PageVmEnvConfig {
- web_storage: crate::RendererWebStorageHandles::ephemeral(),
- root_frame_id,
- main_document_commit: None,
- top_level_storage_key: None,
- document_start_scripts: vec![],
- runtime_bindings: vec![],
- runtime_inspector_session_restore_snapshots: vec![],
- runtime_isolated_worlds: vec![],
- permission_overrides: vec![],
- extra_http_headers: extra_http_headers.into(),
- navigator_identity: loader.browser_identity().clone(),
- document_policy_container: crate::document_runtime::DocumentPolicyContainer {
- referrer_policy: response_referrer_policy,
- ..Default::default()
- },
- document_default_language: None,
- document_last_modified: None,
- script_execution_disabled: false,
- bypass_content_security_policy: false,
- emulated_media: crate::protocol_types::EmulatedMediaOverrides::default(),
- idle_override: None,
- navigator_overrides: Default::default(),
- viewport_surface: None,
- document_activity: Default::default(),
- network_offline: false,
- blocked_url_patterns: Vec::new(),
- indexed_db_manager: None,
- storage_bucket_store: None,
- fetch_subresource_interception_enabled: false,
- fetch_subresource_interception_resource_type: None,
- layout_policy: crate::real_layout_test_policy(),
- wpt_extensions_enabled: false,
- navigation_bootstrap_entry: None,
- reserved_service_worker_client_id: None,
- },
- runtime_hooks,
- dom_host,
- Instant::now(),
- )
- .expect("page vm")
-}
-
-fn prepared_external_module_for_page_vm_test(page_vm: &PageVm, url: Url) -> PreparedScript {
- prepared_external_module_for_page_vm_test_with_node(page_vm, 9001, url)
+fn prepared_external_module_for_page_vm_test(page_vm: &PageVm, url: Url) -> PreparedScript {
+ prepared_external_module_for_page_vm_test_with_node(page_vm, 9001, url)
}
fn prepared_external_module_for_page_vm_test_with_node(
@@ -1839,12367 +709,627 @@ fn prepared_external_module_for_page_vm_test_with_node(
node: u32,
url: Url,
) -> PreparedScript {
- PreparedScript {
- position: node as usize,
- node_id: NodeId::new(node as usize),
- kind: ScriptKind::Module,
- mode: ScriptMode::ModuleDefer,
- source_kind: ScriptSourceKind::External,
- fetch_metadata: ScriptFetchMetadata::default(),
- source: ScriptSource::External,
- initiator_url: page_vm.vm().document_runtime.document_url().clone(),
- base_url: url.clone(),
- url,
- host_script_handle: None,
- }
-}
-
-async fn drive_child_frame_task_sources_until_resource_completion_ready(
- page_vm: &mut PageVm,
- max_turns: usize,
-) -> Vec<ChildFrameSemanticTurnKind> {
- let mut sources = Vec::new();
- for _ in 0..max_turns {
- if page_vm.has_ready_page_websocket_task_for_test() {
- break;
- }
- let Some(source) = page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await
- else {
- break;
- };
- sources.push(source);
- }
- sources
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum ChildModulepreloadStartupTurn {
- TypedModulepreloadStart,
- ChildSemanticTurn(ChildFrameSemanticTurnKind),
-}
-
-async fn run_expected_child_modulepreload_event_action_for_test(
- page_vm: &mut PageVm,
- loader: &crate::network::ResourceRequestClient,
- label: &str,
-) {
- assert!(
- page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ChildModulepreloadEventAction,
- loader,
- )
- .await
- .unwrap_or_else(|error| panic!("{label} selected task should succeed: {error:#}")),
- "{label} should consume one typed modulepreload event action through the selected-task dispatcher"
- );
-}
-
-/// Adjacent module-map helper that preserves distinct modulepreload and child
-/// semantic turns. The modulepreload start enters the production selected-task
-/// dispatcher; the returned sequence still must not be used as owner-scheduler
-/// or cross-source fairness evidence.
-async fn drive_child_modulepreload_startup_until_resource_completion_ready(
- page_vm: &mut PageVm,
- loader: &crate::network::ResourceRequestClient,
- max_turns: usize,
-) -> Vec<ChildModulepreloadStartupTurn> {
- let mut turns = Vec::new();
- for _ in 0..max_turns {
- if page_vm.has_ready_page_websocket_task_for_test() {
- break;
- }
- if page_vm
- .page_task_executor_sources_for_test()
- .modulepreload_start()
- .has_ready_task()
- {
- assert!(
- page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ModulepreloadStart,
- loader,
- )
- .await
- .expect("selected child modulepreload start should succeed"),
- "typed child modulepreload start should consume one source head through the production dispatcher",
- );
- turns.push(ChildModulepreloadStartupTurn::TypedModulepreloadStart);
- continue;
- }
- let Some(source) = page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await
- else {
- break;
- };
- turns.push(ChildModulepreloadStartupTurn::ChildSemanticTurn(source));
- }
- turns
-}
-
-/// Settle at most one exact realm-materialization prerequisite before running
-/// the requested child-family turn. The production semantic helper remains a
-/// strict one-turn operation.
-async fn run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- page_vm: &mut PageVm,
- expected: impl Into<ChildFrameSemanticTurnKind>,
- label: &str,
-) -> ChildFrameSemanticTurnKind {
- let expected = expected.into();
- if expected != ChildFrameSemanticTurnKind::RealmMaterialization
- && page_vm.has_ready_child_frame_semantic_turn_for_test(
- ChildFrameSemanticTurnKind::RealmMaterialization,
- )
- {
- assert_eq!(
- page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await,
- Some(ChildFrameSemanticTurnKind::RealmMaterialization),
- "{label} should first materialize the exact child realm"
- );
- }
- let Some(source) = page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await
- else {
- panic!("{label} should produce {expected:?}, but no child frame task work was ready");
- };
- assert_eq!(
- source, expected,
- "{label} should run the expected child frame task source"
- );
- source
-}
-
-async fn run_expected_child_realm_materialization_for_wait(
- page_vm: &mut PageVm,
- label: &str,
-) -> ChildFrameSemanticTurnKind {
- let source = page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await;
- assert_eq!(
- source,
- Some(ChildFrameSemanticTurnKind::RealmMaterialization),
- "{label} should materialize its exact child realm in one explicit turn"
- );
- ChildFrameSemanticTurnKind::RealmMaterialization
-}
-
-async fn run_expected_child_module_script_terminal_turn(page_vm: &mut PageVm, label: &str) {
- let loader = page_vm.request_client.clone();
- let claimed = page_vm
- .claim_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ChildModuleScriptTerminal,
- )
- .unwrap_or_else(|| panic!("{label} should produce one selected module-terminal task"));
- let owner = claimed
- .child_module_script_terminal_owner()
- .expect("exact terminal selector must retain its typed owner");
- assert_eq!(
- owner.root_document(),
- page_vm.document_lifecycle.identity().document,
- "{label} must belong to the current root Document",
- );
- assert_eq!(
- page_vm
- .vm()
- .current_child_module_script_terminal_owner(owner.document_owner(), owner.realm_id(),),
- Some(owner.document_owner()),
- "{label} must belong to the current child Document/realm",
- );
- page_vm
- .run_claimed_selected_page_task_for_test(claimed, &loader)
- .await
- .unwrap_or_else(|error| panic!("{label} selected task failed: {error:#}"));
-}
-
-async fn run_child_domcontentloaded_then_host_load_for_wait(
- page_vm: &mut PageVm,
- label: &str,
-) -> ChildFrameSemanticTurnKind {
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- &format!("{label} DOMContentLoaded transition"),
- )
- .await;
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- &format!("{label} complete transition"),
- )
- .await;
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- page_vm,
- ChildFrameSemanticTurnKind::HostLoad,
- label,
- )
- .await
-}
-
-async fn run_child_interactive_domcontentloaded_then_host_load_for_wait(
- page_vm: &mut PageVm,
- label: &str,
-) -> ChildFrameSemanticTurnKind {
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- &format!("{label} interactive transition"),
- )
- .await;
- run_child_domcontentloaded_then_host_load_for_wait(page_vm, label).await
-}
-
-fn prepared_inline_module_for_page_vm_test(
- page_vm: &PageVm,
- node: u32,
- source: &str,
-) -> PreparedScript {
- PreparedScript {
- position: node as usize,
- node_id: NodeId::new(node as usize),
- kind: ScriptKind::Module,
- mode: ScriptMode::ModuleDefer,
- source_kind: ScriptSourceKind::Inline,
- fetch_metadata: ScriptFetchMetadata::default(),
- source: ScriptSource::Inline(source.to_owned()),
- initiator_url: page_vm.vm().document_runtime.document_url().clone(),
- base_url: page_vm.vm().document_runtime.document_url().clone(),
- url: page_vm.vm().document_runtime.document_url().clone(),
- host_script_handle: None,
- }
-}
-
-fn prepared_loaded_classic_for_page_vm_test(
- page_vm: &PageVm,
- node: u32,
- source: &str,
-) -> PreparedScript {
- PreparedScript {
- position: node as usize,
- node_id: NodeId::new(node as usize),
- kind: ScriptKind::Classic,
- mode: ScriptMode::Normal,
- source_kind: ScriptSourceKind::Inline,
- fetch_metadata: ScriptFetchMetadata::default(),
- source: ScriptSource::Loaded(source.to_owned()),
- initiator_url: page_vm.vm().document_runtime.document_url().clone(),
- base_url: page_vm.vm().document_runtime.document_url().clone(),
- url: page_vm.vm().document_runtime.document_url().clone(),
- host_script_handle: None,
- }
-}
-
-fn append_parser_owned_external_classic_defer_for_page_vm_test(
- page_vm: &mut PageVm,
- position: usize,
- element_id: &str,
- script_url: Url,
- source: ScriptSource,
- completion_attribute: (&str, &str),
-) -> PreparedScript {
- let body = page_vm
- .vm()
- .snapshot_live_document()
- .document_body_handle()
- .expect("test document body");
- let script_node = page_vm
- .vm_mut()
- .document_runtime
- .dom_host_mut()
- .create_parser_element_without_attributes(
- "script".to_owned(),
- "http://www.w3.org/1999/xhtml".to_owned(),
- None,
- );
- {
- let dom_host = page_vm.vm_mut().document_runtime.dom_host_mut();
- assert!(dom_host.set_attribute(script_node, "id", element_id));
- assert!(dom_host.set_attribute(script_node, "src", script_url.as_str()));
- assert!(dom_host.set_attribute(
- script_node,
- completion_attribute.0,
- completion_attribute.1,
- ));
- assert!(dom_host.append_child(body, script_node));
- }
- let host_script_handle = page_vm
- .vm_mut()
- .document_runtime
- .bind_parser_owned_script_handle_for_node(script_node);
- PreparedScript {
- position,
- node_id: NodeId::new(script_node.index()),
- kind: ScriptKind::Classic,
- mode: ScriptMode::Defer,
- source_kind: ScriptSourceKind::External,
- fetch_metadata: ScriptFetchMetadata::default(),
- source,
- initiator_url: page_vm.vm().document_runtime.document_url().clone(),
- base_url: script_url.clone(),
- url: script_url,
- host_script_handle: Some(host_script_handle),
- }
-}
-
-fn enqueue_parser_owned_module_script_fetch_completion_for_test(
- page_vm: &mut PageVm,
- load_id: u64,
- module_url: &Url,
- source: &str,
-) {
- let target = page_vm
- .vm()
- .current_main_parser_module_graph_fetch_target(load_id)
- .unwrap_or_else(|| panic!("parser module fetch {load_id} must retain its exact target"));
- enqueue_parser_owned_module_script_fetch_completion_for_target_for_test(
- page_vm, target, module_url, source,
- );
-}
-
-fn enqueue_parser_owned_module_script_fetch_completion_for_target_for_test(
- page_vm: &mut PageVm,
- target: MainParserModuleGraphFetchTarget,
- module_url: &Url,
- source: &str,
-) {
- let document_url = page_vm.vm().document_runtime.document_url().clone();
- page_vm
- .vm()
- .resource_completion_sender_for_test()
- .send_main_parser_module_graph_fetch(MainParserModuleGraphFetchCompletion::new(
- target,
- Ok(ModuleGraphFetchedSource::new(
- module_url.clone(),
- false,
- ModuleSource::text(source.to_owned()),
- )),
- None,
- MainModuleFetchNetworkAttribution::new(document_url, module_url.clone()),
- ))
- .expect("module graph completion should enqueue");
-}
-
-fn enqueue_parser_owned_module_script_fetch_error_for_test(
- page_vm: &mut PageVm,
- load_id: u64,
- module_url: &Url,
- message: &str,
-) {
- let target = page_vm
- .vm()
- .current_main_parser_module_graph_fetch_target(load_id)
- .unwrap_or_else(|| panic!("parser module fetch {load_id} must retain its exact target"));
- let document_url = page_vm.vm().document_runtime.document_url().clone();
- page_vm
- .vm()
- .resource_completion_sender_for_test()
- .send_main_parser_module_graph_fetch(MainParserModuleGraphFetchCompletion::new(
- target,
- Err(message.to_owned()),
- None,
- MainModuleFetchNetworkAttribution::new(document_url, module_url.clone()),
- ))
- .expect("module graph error completion should enqueue");
-}
-
-fn run_next_main_module_fetch_terminal_for_test(
- page_vm: &mut PageVm,
-) -> anyhow::Result<Option<RendererOwnerResourceActivitySource>> {
- let outcome = run_next_resource_completion_as_typed_page_turn(page_vm)?;
- anyhow::ensure!(
- outcome.action.source == RendererOwnerResourceActivitySource::ModuleGraphFetch,
- "expected a typed main module fetch terminal, got {:?}",
- outcome.action.source
- );
- Ok(Some(outcome.action.source))
-}
-
-async fn run_next_native_module_owner_event_for_test(
- page_vm: &mut PageVm,
- loader: &crate::network::ResourceRequestClient,
- label: &str,
-) {
- let outcome = page_vm
- .run_page_main_document_runtime_body_for_test(loader)
- .await
- .unwrap_or_else(|error| panic!("{label} owner event should run: {error}"))
- .unwrap_or_else(|| panic!("{label} should retain one native module owner-event turn"));
- assert_eq!(
- outcome.action.kind(),
- crate::page_task_queue::PageMainDocumentRuntimeActionKind::NativeModuleOwnerEvent,
- "{label} must resume joined module-map clients through their typed owner source"
- );
-}
-
-fn enqueue_main_modulepreload_fetch_error_for_test(
- page_vm: &mut PageVm,
- load_id: u64,
- module_url: &Url,
- message: &str,
-) {
- let target = page_vm
- .vm()
- .current_main_modulepreload_fetch_target(load_id)
- .unwrap_or_else(|| panic!("modulepreload fetch {load_id} must retain its exact target"));
- let document_url = page_vm.vm().document_runtime.document_url().clone();
- page_vm
- .vm()
- .resource_completion_sender_for_test()
- .send_main_modulepreload_fetch(MainModulepreloadFetchCompletion::new(
- target,
- Err(message.to_owned()),
- None,
- MainModuleFetchNetworkAttribution::new(document_url, module_url.clone()),
- ))
- .expect("modulepreload graph completion should enqueue");
-}
-
-async fn run_parser_module_completion_turns_for_test(
- page_vm: &mut PageVm,
- loader: &crate::network::ResourceRequestClient,
- expected_ready_turns: usize,
- label: &str,
-) {
- page_vm
- .vm_mut()
- .perform_script_task_checkpoint(None)
- .expect("module evaluation reaction checkpoint should run");
- while page_vm
- .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::ModuleReaction, loader)
- .await
- .expect("module reactions should run")
- {}
- for turn in 0..expected_ready_turns {
- assert!(
- run_one_parser_owned_main_document_runtime_turn_for_test(page_vm, loader)
- .await
- .expect("module evaluation completion should run"),
- "{label} should run parser-owned ready turn {} of {expected_ready_turns}",
- turn + 1
- );
- }
- assert!(
- !page_vm.has_ready_parser_owned_document_script_action(),
- "{label} should not leave another concrete parser-owned module action ready"
- );
-}
-
-async fn run_one_parser_owned_main_document_runtime_turn_for_test(
- page_vm: &mut PageVm,
- loader: &crate::network::ResourceRequestClient,
-) -> anyhow::Result<bool> {
- page_vm.admit_ready_parser_owned_document_script_action();
- page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::MainDocumentRuntime(
- crate::page_task_queue::PageMainDocumentRuntimeActionKind::ParserOwnedModuleContinuation,
- ),
- loader,
- )
- .await
-}
-
-fn post_parse_document_script_work(
- lane: DocumentScriptExecutionLane,
- script: PreparedScript,
-) -> PostParsePageOwnedWork {
- PostParsePageOwnedWork::document_script_work(PageOwnedDocumentScriptWork::script(lane, script))
-}
-
-fn install_parser_module_defer_work(
- page_vm: &mut PageVm,
- script: PreparedScript,
-) -> PostParsePageOwnedWork {
- let task_owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("parser module test requires a current document owner");
- assert!(
- page_vm
- .vm_mut()
- .claim_main_parser_deferred_script(task_owner, script, None, None, Default::default(),)
- .expect("parser module PendingScript acceptance should start its graph")
- );
- page_vm
- .seal_main_parser_deferred_scripts(task_owner)
- .expect("parser module PendingScript should install into after-parsing order")
-}
-
-/// Execute only the parser-deferred domain body.
-///
-/// This helper intentionally does not prove selected-task checkpoint or exact
-/// DCL handoff behavior. Tests asserting a complete parser task must use
-/// `run_and_finish_ready_parser_deferred_task_for_test()` instead.
-async fn run_ready_parser_deferred_body_for_test(
- page_vm: &mut PageVm,
- loader: &crate::network::ResourceRequestClient,
- label: &str,
-) {
- let action = poll_post_parse_document_processing_action_for_test(page_vm)
- .unwrap_or_else(|| panic!("{label} should expose a ready parser-deferred owner action"));
- let crate::document_runtime::DocumentProcessingAction::PostParsePageOwnedWork(work) = action
- else {
- panic!("{label} should produce page-owned parser-deferred work");
- };
- assert!(
- work.main_parser_deferred_scripts_owner().is_some(),
- "{label} should produce the armed parser-deferred marker, got {work:?}"
- );
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(loader, *work)
- .await
- .unwrap_or_else(|error| panic!("{label} parser-deferred turn should run: {error}"));
-}
-
-async fn run_and_finish_ready_parser_deferred_task_for_test(
- page_vm: &mut PageVm,
- loader: &crate::network::ResourceRequestClient,
- label: &str,
-) {
- let action = poll_post_parse_document_processing_action_for_test(page_vm)
- .unwrap_or_else(|| panic!("{label} should expose a ready parser-deferred owner action"));
- let crate::document_runtime::DocumentProcessingAction::PostParsePageOwnedWork(work) = action
- else {
- panic!("{label} should produce page-owned parser-deferred work");
- };
- assert!(
- work.main_parser_deferred_scripts_owner().is_some(),
- "{label} should produce the armed parser-deferred marker, got {work:?}"
- );
- let completion = page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(loader, *work)
- .await
- .unwrap_or_else(|error| panic!("{label} parser-deferred body should run: {error}"));
- let super::parser_completion::SelectedPostParsePageOwnedCompletion::MainParser(completion) =
- completion
- else {
- panic!("{label} must retain its main-parser completion authority");
- };
- page_vm
- .finish_parse_time_main_parser_boundary(completion)
- .await
- .unwrap_or_else(|error| panic!("{label} parser task completion should run: {error}"));
-}
-
-fn poll_post_parse_document_processing_action_for_test(
- page_vm: &mut PageVm,
-) -> Option<crate::document_runtime::DocumentProcessingAction> {
- let (vm, task_queue) = (&mut page_vm.vm, &mut page_vm.page_task_queue);
- vm.as_mut()
- .expect("test PageVm should retain ScriptVm")
- .document_runtime
- .poll_document_processing_action(task_queue, Option::<&crate::dom::native::NativeDom>::None)
-}
-
-async fn run_main_async_script_load_delay_settlement_for_test(
- page_vm: &mut PageVm,
- loader: &crate::network::ResourceRequestClient,
- owner: crate::frame_owner_model::FrameDocumentTaskOwner,
- label: &str,
-) {
- for turn in 0..2 {
- if let Some(outcome) = page_vm
- .run_page_main_document_runtime_body_for_test(loader)
- .await
- .unwrap_or_else(|error| panic!("{label} follow-up turn should run: {error}"))
- {
- assert_eq!(
- outcome.action.kind(),
- crate::page_task_queue::PageMainDocumentRuntimeActionKind::PostParseWork
- );
- assert_eq!(outcome.action.owner().document_owner(), owner);
- assert_eq!(
- outcome.action.target_effect(),
- crate::page_task_queue::PageMainDocumentRuntimeTargetEffect::AppliedToCurrentOwner
- );
- } else {
- // Parse-time async classic work can finish before DCL. Its event
- // and settlement therefore remain lifecycle-owned rather than
- // entering the post-DCL MainDocumentRuntime source.
- let action = page_vm
- .vm_mut()
- .document_runtime
- .pop_parser_owned_pre_domcontentloaded_action()
- .or_else(|| poll_post_parse_document_processing_action_for_test(page_vm))
- .unwrap_or_else(|| panic!("{label} should enqueue an explicit follow-up"));
- let crate::document_runtime::DocumentProcessingAction::PostParsePageOwnedWork(work) =
- action
- else {
- panic!("{label} async follow-up must remain page-owned work");
- };
- if let Some(PostParseLifecycleWork::SettleMainDocumentScriptLoadDelay(binding)) =
- work.as_lifecycle_work()
- {
- assert_eq!(binding.owner(), owner);
- }
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(loader, *work)
- .await
- .unwrap_or_else(|error| panic!("{label} lifecycle follow-up should run: {error}"));
- }
- if page_vm
- .vm()
- .current_main_document_has_async_script_load_delay(owner)
- == Some(false)
- {
- return;
- }
- assert_eq!(
- turn, 0,
- "{label} must settle after at most one observable event turn"
- );
- }
- panic!("{label} left its exact main-Document load delay unsettled");
-}
-
-fn classic_defer_work(script: PreparedScript) -> PostParsePageOwnedWork {
- post_parse_document_script_work(DocumentScriptExecutionLane::ClassicDefer, script)
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_parser_async_classic_owns_load_delay_from_discovery_through_settlement() {
- run_page_vm_async_test(async move {
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/main-parser-async.html").expect("document URL"),
- );
- let owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("main parser async test requires an owner");
- let script_url =
- Url::parse("https://example.com/main-parser-async.js").expect("script URL");
- let mut script = append_parser_owned_external_classic_defer_for_page_vm_test(
- &mut page_vm,
- 9060,
- "main-parser-async-classic",
- script_url,
- ScriptSource::External,
- ("async", ""),
- );
- script.mode = ScriptMode::Async;
- assert!(
- page_vm
- .vm_mut()
- .document_runtime
- .dom_host_mut()
- .set_script_already_started(script.node_id, true)
- );
- let shared_load =
- SharedScriptSourceLoad::ready_ok("globalThis.__mainParserAsyncClassicExecuted = 1;");
- let mut scheduler = crate::document_script_scheduler::DocumentScriptScheduler::new();
- let resource_task_runner = page_vm.resource_task_runner();
-
- assert!(
- scheduler.accept_parser_discovered_async_candidate(
- script.clone(),
- &loader,
- page_vm
- .vm()
- .current_main_document_resource_loader()
- .unwrap()
- .fetch_context()
- .request_origin(),
- resource_task_runner,
- Some(shared_load),
- None,
- |_| {
- page_vm
- .vm_mut()
- .accept_main_document_script_load_delay_binding(
- owner,
- crate::frame_owner_model::MainDocumentScriptLoadDelayKind::Classic,
- )
- .expect("parser discovery should bind classic lifecycle ownership")
- },
- )
- );
- assert_eq!(
- page_vm
- .vm()
- .current_main_document_has_async_script_load_delay(owner),
- Some(true),
- "acceptance must delay load before source readiness is observed"
- );
- assert!(scheduler.claim_existing_parse_time_async_handoff(script.node_id));
- let ready = scheduler
- .parse_time_turn(
- crate::document_script_scheduler::ParseTimeTurnTrigger::BeforeParserStep {
- default_chunk_bytes: 4096,
- },
- )
- .ready_task
- .expect("ready shared source should produce a parser async task");
- let crate::document_script_scheduler::ParseTimeDocumentScriptTask::ClassicAsyncScript(
- ready,
- ) = ready
- else {
- panic!("ready shared source should produce classic execution work");
- };
- let (script, binding) = ready.into_parts();
- let binding = binding.expect("parse-time work must retain its discovery binding");
- assert_eq!(binding.owner(), owner);
-
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- PostParsePageOwnedWork::document_script_work(
- PageOwnedDocumentScriptWork::parser_async_script(
- DocumentScriptExecutionLane::ParseTimeAsync,
- script,
- Some(binding),
- ),
- ),
- )
- .await
- .expect("parser async classic execution turn should run");
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__mainParserAsyncClassicExecuted)")?,
- "1"
- );
- assert_eq!(
- page_vm
- .vm()
- .current_main_document_has_async_script_load_delay(owner),
- Some(true),
- "execution must enqueue, not inline-apply, lifecycle settlement"
- );
- page_vm
- .drain_deferred_page_tasks_on_named_owner_local_task()
- .await?;
- assert_eq!(
- page_vm
- .vm()
- .current_main_document_has_async_script_load_delay(owner),
- Some(true),
- "parser progress may publish follow-ups but must not apply settlement inline"
- );
-
- run_main_async_script_load_delay_settlement_for_test(
- &mut page_vm,
- &loader,
- owner,
- "main parser async classic",
- )
- .await;
- assert_eq!(
- page_vm
- .vm()
- .current_main_document_has_async_script_load_delay(owner),
- Some(false)
- );
- Ok::<(), anyhow::Error>(())
- })
- .await
- .expect("main parser async classic lifecycle test should run");
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_parser_async_module_owns_load_delay_until_evaluation_start() {
- run_page_vm_async_test(async move {
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/main-parser-async-module.html").expect("document URL"),
- );
- let owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("main parser async module test requires an owner");
- let module_url =
- Url::parse("https://example.com/main-parser-async-module.mjs").expect("module URL");
- let mut script =
- prepared_external_module_for_page_vm_test_with_node(&page_vm, 9061, module_url.clone());
- script.mode = ScriptMode::Async;
-
- assert!(
- page_vm
- .vm_mut()
- .accept_main_parser_async_module_script(owner, &script)?
- );
- assert_eq!(
- page_vm
- .vm()
- .current_main_document_has_async_script_load_delay(owner),
- Some(true),
- "module acceptance must bind lifecycle ownership before graph work"
- );
- page_vm.target_stage = PageVmInitStage::DomContentLoaded;
- assert!(
- !page_vm.has_pending_module_script_for_target_stage(),
- "a watched parser-origin async module must not enter the parser-deferred DCL gate"
- );
- assert!(
- page_vm.has_pending_module_fetch_for_target_stage(),
- "the pending graph should remain visible to resource-completion observation"
- );
- enqueue_parser_owned_module_script_fetch_completion_for_test(
- &mut page_vm,
- 0,
- &module_url,
- "globalThis.__mainParserAsyncModuleExecuted = 1; export const value = 1;",
- );
- assert!(
- run_next_main_module_fetch_terminal_for_test(&mut page_vm)?.is_some(),
- "async module graph completion should apply"
- );
- assert!(
- page_vm.has_ready_parser_owned_document_script_action(),
- "watching a completed async graph should queue owner work"
- );
- assert!(
- run_one_parser_owned_main_document_runtime_turn_for_test(&mut page_vm, &loader).await?,
- "async module graph-ready work should start evaluation"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__mainParserAsyncModuleExecuted)")?,
- "1"
- );
- assert_eq!(
- page_vm
- .vm()
- .current_main_document_has_async_script_load_delay(owner),
- Some(true),
- "evaluation start must leave settlement for its own lifecycle turn"
- );
-
- run_main_async_script_load_delay_settlement_for_test(
- &mut page_vm,
- &loader,
- owner,
- "main parser async module",
- )
- .await;
- assert_eq!(
- page_vm
- .vm()
- .current_main_document_has_async_script_load_delay(owner),
- Some(false)
- );
- Ok::<(), anyhow::Error>(())
- })
- .await
- .expect("main parser async module lifecycle test should run");
-}
-
-#[test]
-fn runtime_module_graph_wait_does_not_block_domcontentloaded_on_load_target() {
- let mut page_vm = test_page_vm();
- page_vm.target_stage = PageVmInitStage::Load;
- let mut script = prepared_inline_module_for_page_vm_test(
- &page_vm,
- 9062,
- "import { value } from 'late'; globalThis.__lateValue = value;",
- );
- script.mode = ScriptMode::Async;
- page_vm
- .vm_mut()
- .document_runtime
- .runtime_script_work_mut()
- .dynamic_scripts
- .requeue_failed_script_front(
- DynamicScriptOwnerId::from_u64(1),
- script,
- "failed to resolve module specifier `late`".to_owned(),
- DynamicScriptFailureKind::ModuleResolve,
- Some(ModuleFailurePolicy::GraphFailure),
- None,
- None,
- );
-
- assert!(
- page_vm
- .vm_mut()
- .has_pending_runtime_owned_module_script_graph(),
- "the terminal graph failure must remain pending until its error owner turn"
- );
- assert!(
- !page_vm.has_pending_module_script_for_target_stage(),
- "runtime async module work must not become a DCL wait merely because the final target is Load"
- );
-
- page_vm
- .vm_mut()
- .document_runtime
- .note_dom_content_loaded_dispatched();
- assert!(
- page_vm.has_pending_module_script_for_target_stage(),
- "after DCL the same terminal graph work must delay Load until error dispatch settles it"
- );
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_parser_async_inline_module_is_watched_before_graph_start() {
- run_page_vm_async_test(async move {
- let loader_owner =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let loader = loader_owner.handle();
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/main-parser-async-inline-module.html")
- .expect("document URL"),
- );
- let owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("main parser async inline module test requires an owner");
- let mut script = prepared_inline_module_for_page_vm_test(
- &page_vm,
- 9063,
- "globalThis.__mainParserAsyncInlineModuleExecuted = 1; export const value = 1;",
- );
- script.mode = ScriptMode::Async;
-
- assert!(
- page_vm
- .vm_mut()
- .accept_main_parser_async_module_script(owner, &script)?
- );
- assert!(
- page_vm.has_ready_parser_owned_document_script_action(),
- "an immediately-ready graph must notify the PendingScript watch installed before graph start"
- );
- assert_eq!(
- page_vm
- .vm()
- .current_main_document_has_async_script_load_delay(owner),
- Some(true)
- );
- assert!(
- run_one_parser_owned_main_document_runtime_turn_for_test(&mut page_vm, &loader)
- .await?
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__mainParserAsyncInlineModuleExecuted)")?,
- "1"
- );
-
- run_main_async_script_load_delay_settlement_for_test(
- &mut page_vm,
- &loader,
- owner,
- "main parser async inline module",
- )
- .await;
- assert_eq!(
- page_vm
- .vm()
- .current_main_document_has_async_script_load_delay(owner),
- Some(false)
- );
- Ok::<(), anyhow::Error>(())
- })
- .await
- .expect("main parser async inline module lifecycle test should run");
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_parser_async_module_graph_failure_settles_exact_load_delay() {
- run_page_vm_async_test(async move {
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/main-parser-async-module-failure.html")
- .expect("document URL"),
- );
- let owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("main parser async module failure test requires an owner");
- let module_url =
- Url::parse("https://example.com/main-parser-async-failure.mjs").expect("module URL");
- let mut script =
- prepared_external_module_for_page_vm_test_with_node(&page_vm, 9062, module_url.clone());
- script.mode = ScriptMode::Async;
-
- assert!(
- page_vm
- .vm_mut()
- .accept_main_parser_async_module_script(owner, &script)?
- );
- enqueue_parser_owned_module_script_fetch_error_for_test(
- &mut page_vm,
- 0,
- &module_url,
- "async module graph failed",
- );
- assert!(run_next_main_module_fetch_terminal_for_test(&mut page_vm)?.is_some());
- assert!(
- run_one_parser_owned_main_document_runtime_turn_for_test(&mut page_vm, &loader).await?,
- "graph failure should run through the watched PendingScript owner"
- );
- assert_eq!(
- page_vm
- .vm()
- .current_main_document_has_async_script_load_delay(owner),
- Some(true),
- "failure reporting must be ordered before lifecycle settlement"
- );
-
- run_main_async_script_load_delay_settlement_for_test(
- &mut page_vm,
- &loader,
- owner,
- "main parser async module graph failure",
- )
- .await;
- assert_eq!(
- page_vm
- .vm()
- .current_main_document_has_async_script_load_delay(owner),
- Some(false)
- );
- assert!(
- page_vm.report.runs.iter().any(|run| {
- run.url() == &module_url && matches!(run.outcome(), ScriptRunOutcome::Failed(_))
- }),
- "graph failure should remain an observable failed script run"
- );
- Ok::<(), anyhow::Error>(())
- })
- .await
- .expect("main parser async module failure lifecycle test should run");
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_document_lifecycle_sets_interactive_before_defer_and_loads_later() {
- run_page_vm_async_test(async move {
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/main-lifecycle.html").expect("document URL"),
- );
- page_vm
- .vm_mut()
- .eval(
- r#"
- globalThis.__mainLifecycleEvents = [];
- document.addEventListener("readystatechange", () => {
- __mainLifecycleEvents.push("ready:" + document.readyState);
- });
- document.addEventListener("DOMContentLoaded", () => {
- __mainLifecycleEvents.push("dcl:" + document.readyState);
- });
- window.addEventListener("load", () => {
- __mainLifecycleEvents.push("load:" + document.readyState);
- });
- "installed";
- "#,
- )
- .expect("main lifecycle listeners should install");
- let owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("main lifecycle test requires an owner");
- let defer = append_parser_owned_external_classic_defer_for_page_vm_test(
- &mut page_vm,
- 7001,
- "main-lifecycle-defer",
- Url::parse("https://example.com/main-lifecycle-defer.js").expect("defer script URL"),
- ScriptSource::Loaded(
- "__mainLifecycleEvents.push('defer:' + document.readyState);".to_owned(),
- ),
- ("data-lifecycle-test", "defer"),
- );
- assert!(
- page_vm
- .vm_mut()
- .claim_main_parser_deferred_script(owner, defer, None, None, Default::default(),)
- .expect("parser-deferred PendingScript acceptance should succeed")
- );
- let defer_marker = page_vm
- .seal_main_parser_deferred_scripts(owner)
- .expect("parser-deferred work should install into after-parsing order");
- let interactive = page_vm
- .vm_mut()
- .finish_current_main_document_parsing(owner)
- .expect("parser EOF should produce one interactive action");
-
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- PostParsePageOwnedWork::main_document_interactive(interactive),
- )
- .await
- .expect("interactive lifecycle turn should run");
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__mainLifecycleEvents.join('|')")
- .expect("interactive events"),
- "ready:interactive"
- );
-
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(&loader, defer_marker)
- .await
- .expect("main defer script should run");
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__mainLifecycleEvents.join('|')")
- .expect("defer events"),
- "ready:interactive|defer:interactive"
- );
-
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- PostParsePageOwnedWork::main_document_domcontentloaded(owner),
- )
- .await
- .expect("main DOMContentLoaded turn should run");
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__mainLifecycleEvents.join('|')")
- .expect("DOMContentLoaded events"),
- "ready:interactive|defer:interactive|dcl:interactive"
- );
-
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- PostParsePageOwnedWork::main_document_window_load(owner),
- )
- .await
- .expect("main complete/load turn should run");
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__mainLifecycleEvents.join('|')")
- .expect("complete/load events"),
- "ready:interactive|defer:interactive|dcl:interactive|ready:complete|load:complete"
- );
- })
- .await;
-}
-
-#[test]
-fn parser_eof_releases_preloads_only_for_the_current_document_transition() {
- fn ready_store(url: Url) -> crate::runtime::DocumentScriptPreloadStore {
- let request = crate::runtime::BufferedScriptPreloadRequest {
- url: url.clone(),
- initiator_url: url,
- kind_hint: ScriptKind::Classic,
- mode_hint: ScriptMode::Normal,
- resource_type_hint: moli_fetch::RequestResourceType::ParserBlockingScript,
- fetch_metadata: ScriptFetchMetadata::default(),
- };
- let mut store = crate::runtime::DocumentScriptPreloadStore::default();
- store.insert(
- request.cache_key(),
- crate::runtime::script_preloads::BufferedScriptPreloadEntry {
- request,
- load: SharedScriptSourceLoad::ready_ok("window.ready = true;"),
- },
- );
- store
- }
-
- let mut page_vm = test_page_vm();
- let owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("test page should have a main document owner");
- let live_store =
- ready_store(Url::parse("https://example.test/preloaded.js").expect("preload URL"));
- let live_store_observer = live_store.clone();
- page_vm
- .vm_mut()
- .document_runtime
- .bind_main_document_script_preload_store(live_store);
-
- assert!(!live_store_observer.is_empty());
- assert!(
- page_vm
- .vm_mut()
- .finish_current_main_document_parsing(owner)
- .is_some()
- );
- assert!(live_store_observer.is_empty());
-
- let stale_store =
- ready_store(Url::parse("https://example.test/stale.js").expect("preload URL"));
- let stale_store_observer = stale_store.clone();
- page_vm
- .vm_mut()
- .document_runtime
- .bind_main_document_script_preload_store(stale_store);
-
- assert!(
- page_vm
- .vm_mut()
- .finish_current_main_document_parsing(owner)
- .is_none()
- );
- assert!(
- !stale_store_observer.is_empty(),
- "a stale parser completion must not clear the current preload store"
- );
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_document_replacement_during_interactive_retires_old_lifecycle_actions() {
- run_page_vm_async_test(async move {
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/main-lifecycle-replacement.html")
- .expect("document URL"),
- );
- page_vm
- .vm_mut()
- .eval(
- r#"
- globalThis.__mainReplacementLifecycleEvents = [];
- document.addEventListener("readystatechange", () => {
- __mainReplacementLifecycleEvents.push("ready:" + document.readyState);
- if (document.readyState === "interactive") {
- document.open();
- }
- });
- "installed";
- "#,
- )
- .expect("replacement listener should install");
- let retired_owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("main lifecycle test requires an owner");
- let interactive = page_vm
- .vm_mut()
- .finish_current_main_document_parsing(retired_owner)
- .expect("parser EOF should produce interactive action");
-
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- PostParsePageOwnedWork::main_document_interactive(interactive),
- )
- .await
- .expect("interactive replacement turn should run");
- let current_owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("replacement must install a current owner");
- assert_ne!(retired_owner, current_owner);
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__mainReplacementLifecycleEvents.join('|') + ':' + document.readyState")
- .expect("replacement state"),
- "ready:interactive:loading"
- );
-
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- PostParsePageOwnedWork::main_document_domcontentloaded(retired_owner),
- )
- .await
- .expect("stale DOMContentLoaded work should be consumed");
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- PostParsePageOwnedWork::main_document_window_load(retired_owner),
- )
- .await
- .expect("stale load work should be consumed");
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__mainReplacementLifecycleEvents.join('|') + ':' + document.readyState")
- .expect("stale lifecycle state"),
- "ready:interactive:loading",
- "retired owner work must not mutate or dispatch lifecycle events on the replacement"
- );
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn empty_main_parser_deferred_seal_does_not_arm_owner_source() {
- run_page_vm_async_test(async move {
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/empty-parser-deferred.html").expect("document URL"),
- );
- let task_owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("empty parser-deferred test requires a document owner");
-
- assert!(
- page_vm
- .seal_main_parser_deferred_scripts(task_owner)
- .is_none(),
- "empty EOF seal must not create a parser-deferred marker"
- );
- assert!(
- page_vm
- .vm()
- .document_runtime
- .main_parser_deferred_scripts_owner()
- .is_none(),
- "empty EOF seal must not arm a lifecycle source that can block DCL"
- );
- })
- .await;
-}
-
-#[test]
-fn default_runtime_hooks_reject_direct_no_owner_page_vm_construction() {
- let _js_runtime = crate::JsRuntime::initialize();
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let local_executor = crate::local_executor::JsLocalExecutor::new();
- let error = match PageVm::new(
- PageId::new_for_testing(1),
- local_executor,
- &loader,
- &PageVmEnvConfig {
- web_storage: crate::RendererWebStorageHandles::ephemeral(),
- root_frame_id: None,
- main_document_commit: None,
- top_level_storage_key: None,
- document_start_scripts: vec![],
- runtime_bindings: vec![],
- runtime_inspector_session_restore_snapshots: vec![],
- runtime_isolated_worlds: vec![],
- permission_overrides: vec![],
- extra_http_headers: Default::default(),
- navigator_identity: loader.browser_identity().clone(),
- document_policy_container: Default::default(),
- document_default_language: None,
- document_last_modified: None,
- script_execution_disabled: false,
- bypass_content_security_policy: false,
- emulated_media: crate::protocol_types::EmulatedMediaOverrides::default(),
- idle_override: None,
- navigator_overrides: Default::default(),
- viewport_surface: None,
- document_activity: Default::default(),
- network_offline: false,
- blocked_url_patterns: Vec::new(),
- indexed_db_manager: None,
- storage_bucket_store: None,
- fetch_subresource_interception_enabled: false,
- fetch_subresource_interception_resource_type: None,
- layout_policy: crate::real_layout_test_policy(),
- wpt_extensions_enabled: false,
- navigation_bootstrap_entry: None,
- reserved_service_worker_client_id: None,
- },
- PageVmRuntimeHooks::default(),
- DomHost::from_dom(HtmlParser::SCRIPTING_ENABLED.parse(
- Url::parse("https://example.com/").unwrap(),
- "<!doctype html><html><head></head><body></body></html>".to_owned(),
- )),
- Instant::now(),
- ) {
- Ok(_) => panic!("default runtime hooks must not create standalone document isolates"),
- Err(error) => error,
- };
- assert!(
- error
- .to_string()
- .contains("PageVmRuntimeHooks::standalone_without_owner_reservation_for_test()"),
- "unexpected direct no-owner construction error: {error}"
- );
-}
-
-#[tokio::test]
-async fn page_vm_child_classic_resource_completion_queues_child_frame_work() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-classic.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childClassicWaitEvents.push("external:" + (globalThis === self));
-parent.__childClassicWaitEvents.push("current:" + document.currentScript.id);
-globalThis.__childClassicWaitValue = 91;
-"#
- .to_owned(),
- Duration::from_millis(200),
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm =
- test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- first,
- first_events,
- bootstrap_source,
- blocked_host_load_before_completion,
- blocked_host_load_pump_before_completion,
- events_after_blocked_host_load_before_completion,
- followup_sources,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let script_url = format!("{base_url}/child-classic.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childClassicWaitEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childClassicWaitEvents.push("load");
- frame.srcdoc = `
- <script id="external-classic" src="{script_url}"><\/script>
- <script id="after-external-classic">
- parent.__childClassicWaitEvents.push(
- "inline:" + globalThis.__childClassicWaitValue
- );
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "child classic srcdoc navigation commit",
- )
- .await;
- let bootstrap_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- run_expected_child_realm_materialization_for_wait(
- &mut page_vm,
- "child classic exact realm",
- )
- .await;
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childClassicWaitEvents.join('|')")?,
- "",
- "pending child external classic script should block inline script and load"
- );
- let blocked_host_load_before_completion = page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ChildHostLoad,
- &loader,
- )
- .await?;
- let blocked_host_load_pump_before_completion =
- page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_blocked_host_load_before_completion = page_vm
- .vm_mut()
- .eval("__childClassicWaitEvents.join('|')")?;
-
- let page_resource_queue = page_vm.page_resource_completion_queue();
- if !page_resource_queue.has_ready_completion() {
- tokio::time::timeout(
- Duration::from_secs(2),
- page_vm.page_task_queue.wait_for_page_runtime_wake(),
- )
- .await
- .expect("child classic completion should arrive before timeout");
- }
- let (_, queued_completion) = page_resource_queue
- .pop_front()
- .expect("child classic completion should remain queued");
- let completion_owner = queued_completion.owner();
- let completion = match queued_completion.into_terminal() {
- RendererPageResourceTerminal::ChildClassicScript { completion } => completion,
- other => panic!("expected child classic completion, got {other:?}"),
- };
- let root_document = page_vm.document_lifecycle.identity().document;
- assert!(
- completion.network_result.is_some(),
- "loader-backed child classic completion must retain its Network fact"
- );
- let expected_network_frame_id = completion.network_attribution.frame_id.clone();
- let expected_network_document_url =
- completion.network_attribution.document_url.clone();
- let expected_network_request_url =
- completion.network_attribution.request_url.clone();
- let _ = page_vm.vm_mut().take_network_output();
- let activity_epoch_before_completion =
- page_vm.vm().subresource_activity_epoch();
- let first = page_vm
- .apply_selected_page_resource_completion_turn(
- RendererPageResourceCompletion::child_classic_script(
- root_document,
- completion,
- ),
- )?;
- assert_eq!(first.action.owner, completion_owner);
- assert_eq!(
- first.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- first.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- assert!(
- page_vm.vm().subresource_activity_epoch()
- > activity_epoch_before_completion,
- "a current child classic Network terminal must advance current Document activity"
- );
- let (network_records, websocket_events, websocket_lifecycle_events) =
- split_network_output_items(page_vm.vm_mut().take_network_output());
- assert!(websocket_events.is_empty());
- assert!(websocket_lifecycle_events.is_empty());
- assert_eq!(network_records.len(), 1);
- let network_record = &network_records[0];
- assert_eq!(
- network_record.frame_id(),
- expected_network_frame_id.as_deref(),
- "consumer must use producer-captured child frame attribution"
- );
- assert_eq!(
- network_record.document_url(),
- &expected_network_document_url
- );
- assert_eq!(network_record.url(), &expected_network_request_url);
- assert_eq!(network_record.resource_type(), SubresourceResourceType::Script);
- assert_eq!(
- network_record.request_initiator_type(),
- SubresourceRequestInitiatorType::Script
- );
- assert!(matches!(
- network_record.outcome(),
- SubresourceNetworkOutcome::Success { .. }
- ));
- let first_events = page_vm
- .vm_mut()
- .eval("__childClassicWaitEvents.join('|')")?;
- let mut followup_sources = Vec::new();
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "child classic external execution",
- )
- .await,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childClassicWaitEvents.join('|')")?,
- "external:true|current:external-classic",
- "first DocumentScriptReady should execute the external classic script without parser continuation or iframe load"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "child classic parser continuation",
- )
- .await,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childClassicWaitEvents.join('|')")?,
- "external:true|current:external-classic|inline:91",
- "second DocumentScriptReady should run parser continuation without iframe load"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "child classic parser EOF interactive transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "child classic DOMContentLoaded transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "child classic complete transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::HostLoad,
- "child classic iframe load",
- )
- .await,
- );
- let final_events = page_vm
- .vm_mut()
- .eval("__childClassicWaitEvents.join('|')")?;
- assert_eq!(
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- None,
- "child classic follow-up sequence should not leave extra child frame task work"
- );
-
- Ok::<_, anyhow::Error>((
- first,
- first_events,
- bootstrap_source,
- blocked_host_load_before_completion,
- blocked_host_load_pump_before_completion,
- events_after_blocked_host_load_before_completion,
- followup_sources,
- final_events,
- ))
- })
- .await
- .expect("page vm child classic deferred completion test should run");
-
- assert!(matches!(
- first.action.source(),
- RendererOwnerResourceActivitySource::ChildClassicScript
- ));
- assert_eq!(
- first.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- first.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- assert_eq!(
- first_events, "",
- "resource completion turn should not inline-run child classic script"
- );
- assert_eq!(
- bootstrap_source,
- Some(ChildFrameSemanticTurnKind::ClassicScriptSourceLoad),
- "child classic bootstrap should start the external source load with one explicit source turn"
- );
- assert!(
- !blocked_host_load_before_completion,
- "HostLoad source should report no progress while parser-blocking classic source is pending"
- );
- assert_eq!(
- blocked_host_load_pump_before_completion, None,
- "blocked lifecycle must not produce a HostLoad task in the stable child-frame family"
- );
- assert_eq!(
- events_after_blocked_host_load_before_completion, "",
- "no HostLoad delivery may exist before classic source completion"
- );
- assert_eq!(
- followup_sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::HostLoad
- ],
- "child classic completion should progress through script, parser continuation, interactive, DOMContentLoaded, complete, and HostLoad turns"
- );
- assert_eq!(
- final_events,
- "external:true|current:external-classic|inline:91|load",
- "explicit later wait turns should run queued child classic work"
- );
-
- server
- .await
- .expect("child classic wait-path server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_parser_blocking_classic_waits_for_preceding_stylesheet() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_concurrent_path_response_http_server(vec![(
- "/parser-blocking.css",
- "HTTP/1.1 200 OK",
- ":root { --child-parser-style-gate: stylesheet-ready; }".to_owned(),
- Duration::from_millis(180),
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- navigation_source,
- completion,
- events_after_completion,
- followup_sources,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childParserStylesheetEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childParserStylesheetEvents.push("load");
- frame.srcdoc = `
- <link rel="stylesheet" href="{base_url}/parser-blocking.css">
- <script>
- parent.__childParserStylesheetEvents.push(
- "script:" + getComputedStyle(document.documentElement)
- .getPropertyValue("--child-parser-style-gate").trim() + ":" + document.readyState
- );
- <\/script>
- <body></body>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let navigation_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "stylesheet-gated child srcdoc navigation commit",
- )
- .await;
- let materialization = page_vm
- .run_child_realm_materialization_body_for_test()?
- .expect("child parser stylesheet fixture should queue one typed realm turn");
- assert_eq!(
- materialization.action.target_effect,
- crate::page_task_queue::PageChildRealmMaterializationTargetEffect::MaterializedCurrentOwnerWithoutDocumentStartScript
- );
-
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childParserStylesheetEvents.join('|')")?,
- "",
- "parser-blocking classic must remain pending while its preparation-time stylesheet snapshot is unresolved"
- );
- assert!(
- !page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ChildHostLoad,
- &loader,
- )
- .await?,
- "HostLoad must not bypass a stylesheet-blocked parser"
- );
-
- let page_resource_queue = page_vm.page_resource_completion_queue();
- if !page_resource_queue.has_ready_completion() {
- tokio::time::timeout(
- Duration::from_secs(2),
- page_vm.page_task_queue.wait_for_page_runtime_wake(),
- )
- .await
- .expect("child stylesheet completion should arrive");
- }
- let (_, queued_completion) = page_resource_queue
- .pop_front()
- .expect("child stylesheet completion should remain queued");
- let completion_owner = queued_completion.owner();
- let completion = match queued_completion.into_terminal() {
- RendererPageResourceTerminal::ChildBlockingStylesheet { completion } => {
- completion
- }
- other => panic!("expected child stylesheet completion, got {other:?}"),
- };
- let root_document = page_vm.document_lifecycle.identity().document;
- let completion = page_vm
- .apply_selected_page_resource_completion_turn(
- RendererPageResourceCompletion::child_blocking_stylesheet(
- root_document,
- completion,
- ),
- )?;
- assert_eq!(completion.action.owner, completion_owner);
- let events_after_completion = page_vm
- .vm_mut()
- .eval("__childParserStylesheetEvents.join('|')")?;
-
- let mut followup_sources = Vec::new();
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "stylesheet-released child parser-blocking classic",
- )
- .await,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childParserStylesheetEvents.join('|')")?,
- "script:stylesheet-ready:complete",
- "stylesheet source must be installed before the parser-blocking script executes"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "stylesheet-gated child interactive transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "stylesheet-gated child DOMContentLoaded transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "stylesheet-gated child complete transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::HostLoad,
- "stylesheet-gated child iframe load",
- )
- .await,
- );
- let final_events = page_vm
- .vm_mut()
- .eval("__childParserStylesheetEvents.join('|')")?;
- assert_eq!(page_vm.run_next_child_frame_task_source_for_semantic_test().await, None);
-
- Ok::<_, anyhow::Error>((
- navigation_source,
- completion,
- events_after_completion,
- followup_sources,
- final_events,
- ))
- })
- .await
- .expect("child parser stylesheet test should run");
-
- assert_eq!(navigation_source, ChildFrameSemanticTurnKind::NavigationCommit);
- assert_eq!(
- completion.action.source(),
- RendererOwnerResourceActivitySource::ChildBlockingStylesheet
- );
- assert_eq!(
- completion.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- completion.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
- assert_eq!(
- events_after_completion, "",
- "stylesheet resource completion must not inline-run child script"
- );
- assert_eq!(
- followup_sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::HostLoad,
- ]
- );
- assert_eq!(final_events, "script:stylesheet-ready:complete|load");
- server.await.expect("child parser stylesheet server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_mixed_parser_defer_waits_for_preceding_stylesheet() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_concurrent_path_response_http_server(vec![
- (
- "/mixed-defer.css",
- "HTTP/1.1 200 OK",
- ":root { --child-defer-style-gate: stylesheet-ready; }".to_owned(),
- Duration::from_millis(600),
- ),
- (
- "/stylesheet-classic-defer.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childDeferStylesheetEvents.push(
- "classic:" + getComputedStyle(document.documentElement)
- .getPropertyValue("--child-defer-style-gate").trim()
-);
-"#
- .to_owned(),
- Duration::ZERO,
- ),
- (
- "/stylesheet-module-defer.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childDeferStylesheetEvents.push(
- "module:" + getComputedStyle(document.documentElement)
- .getPropertyValue("--child-defer-style-gate").trim()
-);
-"#
- .to_owned(),
- Duration::from_millis(20),
- ),
- ])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- mut script_completion_sources,
- stylesheet_completion,
- execution_sources,
- lifecycle_sources,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childDeferStylesheetEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childDeferStylesheetEvents.push("load");
- frame.srcdoc = `
- <link rel="stylesheet" href="{base_url}/mixed-defer.css">
- <script defer src="{base_url}/stylesheet-classic-defer.js"><\/script>
- <script type="module" src="{base_url}/stylesheet-module-defer.js"><\/script>
- <body></body>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let mut bootstrap_sources = Vec::new();
- for _ in 0..8 {
- let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
- break;
- };
- bootstrap_sources.push(source);
- if bootstrap_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart)
- && bootstrap_sources.contains(&ChildFrameSemanticTurnKind::DocumentLifecycle)
- {
- break;
- }
- }
- assert!(
- bootstrap_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart)
- && bootstrap_sources.contains(&ChildFrameSemanticTurnKind::DocumentLifecycle),
- "child parser must start the module root fetch and reach interactive while classic defer fetches directly: {bootstrap_sources:?}"
- );
-
- let mut script_completion_sources = Vec::new();
- while script_completion_sources.len() != 2 {
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child deferred script completion should arrive");
- }
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- assert_ne!(
- completion.action.source(),
- RendererOwnerResourceActivitySource::ChildBlockingStylesheet,
- "delayed stylesheet must remain pending while both script sources become terminal"
- );
- script_completion_sources.push(completion.action.source());
- if completion.action.source()
- == RendererOwnerResourceActivitySource::ModuleGraphFetch
- {
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "stylesheet-blocked child module terminal",
- )
- .await;
- }
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childDeferStylesheetEvents.join('|')")?,
- "",
- "terminal script sources must remain retained behind the stylesheet snapshot"
- );
- }
- assert_eq!(
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- None,
- "no script or HostLoad turn should be runnable before stylesheet completion"
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("delayed child stylesheet completion should arrive");
- }
- let stylesheet_completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childDeferStylesheetEvents.join('|')")?,
- "",
- "stylesheet completion must not inline-execute retained deferred scripts"
- );
-
- let execution_sources = vec![
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "stylesheet-released child classic defer",
- )
- .await,
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "stylesheet-released child module defer",
- )
- .await,
- ];
- let lifecycle_sources = vec![
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "stylesheet-released child DOMContentLoaded",
- )
- .await,
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "stylesheet-released child complete transition",
- )
- .await,
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::HostLoad,
- "stylesheet-released child iframe load",
- )
- .await,
- ];
- let final_events = page_vm
- .vm_mut()
- .eval("__childDeferStylesheetEvents.join('|')")?;
- assert_eq!(page_vm.run_next_child_frame_task_source_for_semantic_test().await, None);
-
- Ok::<_, anyhow::Error>((
- script_completion_sources,
- stylesheet_completion,
- execution_sources,
- lifecycle_sources,
- final_events,
- ))
- })
- .await
- .expect("mixed child defer stylesheet test should run");
-
- script_completion_sources.sort_by_key(|source| match source {
- RendererOwnerResourceActivitySource::ChildClassicScript => 0,
- RendererOwnerResourceActivitySource::ModuleGraphFetch => 1,
- _ => 2,
- });
- assert_eq!(
- script_completion_sources,
- vec![
- RendererOwnerResourceActivitySource::ChildClassicScript,
- RendererOwnerResourceActivitySource::ModuleGraphFetch,
- ]
- );
- assert_eq!(
- stylesheet_completion.action.source(),
- RendererOwnerResourceActivitySource::ChildBlockingStylesheet
- );
- assert_eq!(
- execution_sources,
- vec![ChildFrameSemanticTurnKind::DocumentScriptReady; 2]
- );
- assert_eq!(
- lifecycle_sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::HostLoad,
- ]
- );
- assert_eq!(
- final_events,
- "classic:stylesheet-ready|module:stylesheet-ready|load",
- "mixed parser-deferred scripts must preserve document order and observe the installed stylesheet"
- );
- server
- .await
- .expect("mixed child defer stylesheet server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_failed_child_stylesheet_installs_empty_sheet_before_host_load() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_concurrent_path_response_http_server(vec![(
- "/load-only.css",
- "HTTP/1.1 404 Not Found",
- ".failed-body { color: rgb(11, 12, 13); }".to_owned(),
- Duration::from_millis(220),
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (completion, child_stylesheet_surface, lifecycle_sources, final_events) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childStylesheetHostLoadEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childStylesheetHostLoadEvents.push("load");
- frame.srcdoc = `<link rel="stylesheet" href="{base_url}/load-only.css"><body class="failed-body"></body>`;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "stylesheet-only child navigation commit",
- )
- .await;
- let lifecycle_sources = vec![
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "stylesheet-only child interactive transition",
- )
- .await,
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "stylesheet-only child DOMContentLoaded transition",
- )
- .await,
- ];
- assert!(
- !page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ChildHostLoad,
- &loader,
- )
- .await?,
- "HostLoad must remain blocked after DCL while a child stylesheet is pending"
- );
- assert_eq!(
- page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await,
- None,
- "blocked stylesheet lifecycle must not produce HostLoad progress"
- );
-
- if !page_vm
- .page_resource_completion_queue()
- .has_ready_completion()
- {
- tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("failed stylesheet-only completion should arrive");
- }
- let completion = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let child_context_id = page_vm
- .live_child_default_runtime_realm_inventory()
- .into_iter()
- .map(|realm| realm.context_id)
- .next()
- .expect("stylesheet child should have one materialized default realm");
- let child_stylesheet_surface = page_vm.vm_mut().eval_in_child_default_context(
- child_context_id,
- r#"
-(() => {
- const link = document.querySelector("link");
- return JSON.stringify({
- sheet: link.sheet !== null,
- owner: link.sheet && link.sheet.ownerNode === link,
- count: document.styleSheets.length,
- color: getComputedStyle(document.body).color,
- });
-})()
-"#,
- )?;
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childStylesheetHostLoadEvents.join('|')")?,
- "",
- "stylesheet completion must not inline-dispatch iframe load"
- );
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "stylesheet-terminal child complete transition",
- )
- .await;
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::HostLoad,
- "stylesheet-terminal child iframe load",
- )
- .await;
- let final_events = page_vm
- .vm_mut()
- .eval("__childStylesheetHostLoadEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- completion,
- child_stylesheet_surface,
- lifecycle_sources,
- final_events,
- ))
- })
- .await
- .expect("stylesheet-only child HostLoad test should run");
-
- assert_eq!(
- completion.action.source(),
- RendererOwnerResourceActivitySource::ChildBlockingStylesheet
- );
- assert_eq!(
- child_stylesheet_surface,
- r#"{"sheet":true,"owner":true,"count":1,"color":"rgb(0, 0, 0)"}"#,
- "a failed child stylesheet must expose the same empty sheet surface as Chromium and the main document"
- );
- assert_eq!(
- lifecycle_sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ]
- );
- assert_eq!(final_events, "load");
- server
- .await
- .expect("stylesheet-only child HostLoad server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_stylesheet_fonts_block_complete_until_the_exact_terminal() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_concurrent_path_response_http_server(vec![
- (
- "/blocking-resources.css",
- "HTTP/1.1 200 OK",
- r#"
-body { background-image: url('/css-image.png'); }
-@font-face { font-family: Demo; src: url('/demo.woff2') format('woff2'); }
-"#
- .to_owned(),
- Duration::from_millis(80),
- ),
- (
- "/demo.woff2",
- "HTTP/1.1 200 OK",
- "font-body".to_owned(),
- Duration::from_millis(420),
- ),
- ])
- .await;
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- loader.set_optional_resource_fetch_mask(
- crate::protocol_types::OptionalResourceFetchMask::IMAGE
- | crate::protocol_types::OptionalResourceFetchMask::FONT,
- );
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (stylesheet_outcome, lifecycle_ready_after_font, final_events) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childCssResourceEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childCssResourceEvents.push("load");
- frame.srcdoc = `<link rel="stylesheet" href="{base_url}/blocking-resources.css"><body></body>`;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "CSS-resource child navigation commit",
- )
- .await;
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "CSS-resource child interactive transition",
- )
- .await;
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "CSS-resource child DOMContentLoaded transition",
- )
- .await;
-
- if !page_vm
- .page_resource_completion_queue()
- .has_ready_completion()
- {
- tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("stylesheet completion should arrive");
- }
- let stylesheet_outcome =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- assert!(
- !page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ChildHostLoad,
- &loader,
- )
- .await?,
- "HostLoad must remain blocked while stylesheet subresources are pending"
- );
-
- if !page_vm
- .page_resource_completion_queue()
- .has_ready_completion()
- {
- tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("stylesheet font terminal should arrive");
- }
- let outcome = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- assert_eq!(
- outcome.action.source(),
- RendererOwnerResourceActivitySource::AsyncSubresource,
- "the stylesheet font terminal must use Networking"
- );
- let lifecycle_ready_after_font = page_vm
- .has_ready_child_frame_semantic_turn_for_test(
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childCssResourceEvents.join('|')")?,
- "",
- "the font terminal must not inline-dispatch iframe load"
- );
-
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "CSS-resource child complete transition",
- )
- .await;
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::HostLoad,
- "CSS-resource child iframe load",
- )
- .await;
- let final_events = page_vm
- .vm_mut()
- .eval("__childCssResourceEvents.join('|')")?;
- assert_eq!(
- page_vm.vm().css_image_resource_observability_for_test(),
- (0, 0, 0, 0, Vec::<String>::new()),
- "raw stylesheet text must not eagerly admit CSS image slots before paint layout"
- );
- Ok::<_, anyhow::Error>((
- stylesheet_outcome,
- lifecycle_ready_after_font,
- final_events,
- ))
- })
- .await
- .expect("stylesheet subresource lifecycle test should run");
-
- assert_eq!(
- stylesheet_outcome.action.source(),
- RendererOwnerResourceActivitySource::ChildBlockingStylesheet
- );
- assert!(
- lifecycle_ready_after_font,
- "the exact stylesheet font token must make complete runnable"
- );
- assert_eq!(final_events, "load");
- server
- .await
- .expect("stylesheet subresource server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_defer_classic_runs_between_interactive_and_domcontentloaded() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-defer-classic.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childClassicDeferWaitEvents.push("defer:" + (globalThis === self));
-parent.__childClassicDeferWaitEvents.push("defer-ready:" + document.readyState);
-parent.__childClassicDeferWaitEvents.push("current:" + document.currentScript.id);
-globalThis.__childClassicDeferWaitValue = 73;
-"#
- .to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- first,
- first_events,
- bootstrap_sources,
- followup_sources,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let script_url = format!("{base_url}/child-defer-classic.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childClassicDeferWaitEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childClassicDeferWaitEvents.push("load");
- frame.srcdoc = `
- <script>parent.__childClassicDeferWaitEvents.push("before:" + (globalThis === self));<\/script>
- <script id="external-defer-classic" defer src="{script_url}"><\/script>
- <script>
- document.getElementById("external-defer-classic").addEventListener("load", () => {{
- parent.__childClassicDeferWaitEvents.push("script-load");
- }});
- document.addEventListener("readystatechange", () => {{
- parent.__childClassicDeferWaitEvents.push("ready:" + document.readyState);
- }});
- document.addEventListener("DOMContentLoaded", () => {{
- parent.__childClassicDeferWaitEvents.push("dcl:" + document.readyState);
- }});
- parent.__childClassicDeferWaitEvents.push(
- "after:" + String(globalThis.__childClassicDeferWaitValue)
- );
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
- let mut bootstrap_sources = Vec::new();
- let mut bootstrap_events = String::new();
- for _ in 0..8 {
- let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
- break;
- };
- bootstrap_sources.push(source);
- bootstrap_events = page_vm
- .vm_mut()
- .eval("__childClassicDeferWaitEvents.join('|')")?;
- if bootstrap_events == "before:true|after:undefined|ready:interactive" {
- break;
- }
- }
- assert_eq!(
- bootstrap_events,
- "before:true|after:undefined|ready:interactive",
- "parser EOF should dispatch interactive before the deferred script or load"
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child defer classic completion should arrive before timeout");
- assert!(
- arrived,
- "child defer classic completion sender should remain open"
- );
- }
-
- let first =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let first_events = page_vm
- .vm_mut()
- .eval("__childClassicDeferWaitEvents.join('|')")?;
- let mut followup_sources = Vec::new();
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "child defer classic execution",
- )
- .await,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childClassicDeferWaitEvents.join('|')")?,
- "before:true|after:undefined|ready:interactive|defer:true|defer-ready:interactive|current:external-defer-classic|script-load",
- "DocumentScriptReady should run defer after interactive and before DOMContentLoaded or iframe load"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "child defer classic DOMContentLoaded transition",
- )
- .await,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childClassicDeferWaitEvents.join('|')")?,
- "before:true|after:undefined|ready:interactive|defer:true|defer-ready:interactive|current:external-defer-classic|script-load|dcl:interactive",
- "DOMContentLoaded should run on its own lifecycle turn after defer and before complete/load"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "child defer classic complete transition",
- )
- .await,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childClassicDeferWaitEvents.join('|')")?,
- "before:true|after:undefined|ready:interactive|defer:true|defer-ready:interactive|current:external-defer-classic|script-load|dcl:interactive|ready:complete",
- "document complete must be a lifecycle turn after defer and DOMContentLoaded"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::HostLoad,
- "child defer classic iframe load",
- )
- .await,
- );
- let final_events = page_vm
- .vm_mut()
- .eval("__childClassicDeferWaitEvents.join('|')")?;
- assert_eq!(
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- None,
- "child defer classic follow-up sequence should not leave extra child frame task work"
- );
-
- Ok::<_, anyhow::Error>((
- first,
- first_events,
- bootstrap_sources,
- followup_sources,
- final_events,
- ))
- })
- .await
- .expect("page vm child defer classic deferred completion test should run");
-
- assert!(matches!(
- first.action.source(),
- RendererOwnerResourceActivitySource::ChildClassicScript
- ));
- assert_eq!(
- first.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- first.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- assert_eq!(
- first_events, "before:true|after:undefined|ready:interactive",
- "source completion turn should not inline-run child defer classic script"
- );
- assert_eq!(
- bootstrap_sources,
- vec![
- ChildFrameSemanticTurnKind::NavigationCommit,
- ChildFrameSemanticTurnKind::RealmMaterialization,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle
- ],
- "child defer classic bootstrap should end with the document-owned interactive turn"
- );
- assert_eq!(
- followup_sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::HostLoad
- ],
- "child defer classic should progress through script, DCL, complete, and later HostLoad turns"
- );
- assert_eq!(
- final_events,
- "before:true|after:undefined|ready:interactive|defer:true|defer-ready:interactive|current:external-defer-classic|script-load|dcl:interactive|ready:complete|load",
- "defer must run after interactive and before the later HostLoad DCL/complete/load delivery"
- );
-
- server
- .await
- .expect("child defer classic wait-path server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_defer_classic_source_failure_releases_parser_order_slot() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/missing-child-defer.js",
- "HTTP/1.1 404 Not Found",
- "missing".to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (completion, events_after_completion, followup_sources, final_events) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let script_url = format!("{base_url}/missing-child-defer.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childClassicDeferFailureEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childClassicDeferFailureEvents.push("load");
- frame.srcdoc = `
- <script>parent.__childClassicDeferFailureEvents.push("before");<\/script>
- <script id="failed-defer" defer src="{script_url}"><\/script>
- <script>
- document.getElementById("failed-defer").addEventListener("error", () => {{
- parent.__childClassicDeferFailureEvents.push("script-error");
- }});
- document.addEventListener("readystatechange", () => {{
- parent.__childClassicDeferFailureEvents.push("ready:" + document.readyState);
- }});
- document.addEventListener("DOMContentLoaded", () => {{
- parent.__childClassicDeferFailureEvents.push("dcl");
- }});
- parent.__childClassicDeferFailureEvents.push("after");
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- for _ in 0..8 {
- let Some(_) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
- break;
- };
- if page_vm
- .vm_mut()
- .eval("__childClassicDeferFailureEvents.join('|')")?
- == "before|after|ready:interactive"
- {
- break;
- }
- }
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childClassicDeferFailureEvents.join('|')")?,
- "before|after|ready:interactive",
- "failed defer must keep DCL gated while its source completion is pending"
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("failed child defer completion should arrive");
- }
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let events_after_completion = page_vm
- .vm_mut()
- .eval("__childClassicDeferFailureEvents.join('|')")?;
-
- let mut followup_sources = Vec::new();
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "failed child defer source terminal",
- )
- .await,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childClassicDeferFailureEvents.join('|')")?,
- "before|after|ready:interactive|script-error",
- "source failure must dispatch error and release defer ordering without resuming the parser"
- );
- for (source, label) in [
- (
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "failed child defer DOMContentLoaded",
- ),
- (
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "failed child defer complete transition",
- ),
- (
- ChildFrameSemanticTurnKind::HostLoad,
- "failed child defer iframe load",
- ),
- ] {
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(&mut page_vm, source, label)
- .await,
- );
- }
- let final_events = page_vm
- .vm_mut()
- .eval("__childClassicDeferFailureEvents.join('|')")?;
- assert_eq!(page_vm.run_next_child_frame_task_source_for_semantic_test().await, None);
-
- Ok::<_, anyhow::Error>((
- completion,
- events_after_completion,
- followup_sources,
- final_events,
- ))
- })
- .await
- .expect("child defer source-failure order test should run");
-
- assert!(matches!(
- completion.action.source(),
- RendererOwnerResourceActivitySource::ChildClassicScript
- ));
- assert_eq!(
- completion.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- completion.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- assert_eq!(
- events_after_completion, "before|after|ready:interactive",
- "resource completion must not report or finalize the failed script inline"
- );
- assert_eq!(
- followup_sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::HostLoad,
- ]
- );
- assert_eq!(
- final_events,
- "before|after|ready:interactive|script-error|dcl|ready:complete|load"
- );
- server
- .await
- .expect("failed child defer source server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_moved_child_defer_disposes_in_flight_slot_before_later_module() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![
- (
- "/moved-child-defer.js",
- "HTTP/1.1 200 OK",
- "parent.__movedChildDeferEvents.push('classic-ran');".to_owned(),
- Duration::from_millis(80),
- ),
- (
- "/later-moved-module.js",
- "HTTP/1.1 200 OK",
- "parent.__movedChildDeferEvents.push('module-ran');".to_owned(),
- Duration::ZERO,
- ),
- ])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (events_after_dispose, sources, final_events) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let script_url = format!("{base_url}/moved-child-defer.js");
- let module_url = format!("{base_url}/later-moved-module.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__movedChildDeferEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.id = "moved-defer-frame";
- frame.onload = () => globalThis.__movedChildDeferEvents.push("load");
- frame.srcdoc = `
- <script>parent.__movedChildDeferEvents.push("before");<\/script>
- <script id="move-defer" defer src="{script_url}"><\/script>
- <script id="later-module" type="module" src="{module_url}"><\/script>
- <script>
- document.getElementById("move-defer").addEventListener("load", () => {{
- parent.__movedChildDeferEvents.push("classic-load");
- }});
- document.getElementById("later-module").addEventListener("load", () => {{
- parent.__movedChildDeferEvents.push("module-load");
- }});
- document.addEventListener("readystatechange", () => {{
- parent.__movedChildDeferEvents.push("ready:" + document.readyState);
- }});
- document.addEventListener("DOMContentLoaded", () => {{
- parent.__movedChildDeferEvents.push("dcl");
- }});
- parent.__movedChildDeferEvents.push("after");
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- for _ in 0..12 {
- let Some(_) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
- break;
- };
- }
- assert_eq!(
- page_vm.vm_mut().eval("__movedChildDeferEvents.join('|')")?,
- "before|after|ready:interactive",
- "later module must remain retained behind the unresolved classic defer"
- );
-
- let mut classic_completion = None;
- for _ in 0..4 {
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("moved child defer completion should arrive");
- }
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- if matches!(
- completion.action.source(),
- RendererOwnerResourceActivitySource::ChildClassicScript
- ) {
- classic_completion = Some(completion);
- break;
- }
- assert!(
- matches!(
- completion.action.source(),
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- ),
- "the only completion allowed ahead of the moved classic defer is its later module root"
- );
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "module terminal retained behind the moved classic defer",
- )
- .await;
- }
- classic_completion
- .expect("classic source completion must arrive after retained module terminals");
- page_vm.vm_mut().eval(
- r#"
-(() => {
- const frame = document.getElementById("moved-defer-frame");
- document.body.appendChild(frame.contentDocument.getElementById("move-defer"));
- __movedChildDeferEvents.push("moved");
-})()
-"#,
- )?;
-
- let mut sources = Vec::new();
- sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "moved classic defer disposal",
- )
- .await,
- );
- let events_after_dispose =
- page_vm.vm_mut().eval("__movedChildDeferEvents.join('|')")?;
- assert_eq!(
- events_after_dispose, "before|after|ready:interactive|moved",
- "disposed classic defer must not execute or dispatch load"
- );
- sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "module after moved classic defer",
- )
- .await,
- );
- assert_eq!(
- page_vm.vm_mut().eval("__movedChildDeferEvents.join('|')")?,
- "before|after|ready:interactive|moved|module-ran|module-load",
- "disposing the exact classic slot must release the later module-defer"
- );
- for (source, label) in [
- (
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "moved defer DOMContentLoaded",
- ),
- (
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "moved defer complete transition",
- ),
- (ChildFrameSemanticTurnKind::HostLoad, "moved defer iframe load"),
- ] {
- sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(&mut page_vm, source, label)
- .await,
- );
- }
- let final_events = page_vm.vm_mut().eval("__movedChildDeferEvents.join('|')")?;
- assert_eq!(page_vm.run_next_child_frame_task_source_for_semantic_test().await, None);
- Ok::<_, anyhow::Error>((events_after_dispose, sources, final_events))
- })
- .await
- .expect("moved child defer cancellation test should run");
-
- assert_eq!(events_after_dispose, "before|after|ready:interactive|moved");
- assert_eq!(
- sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::HostLoad,
- ]
- );
- assert_eq!(
- final_events,
- "before|after|ready:interactive|moved|module-ran|module-load|dcl|ready:complete|load"
- );
- server.await.expect("moved child defer server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_async_classic_handoff_queues_document_script_ready_work() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-async-classic.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childClassicAsyncWaitEvents.push("async:" + (globalThis === self));
-parent.__childClassicAsyncWaitEvents.push("current:" + document.currentScript.id);
-globalThis.__childClassicAsyncWaitValue = 41;
-"#
- .to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- first,
- first_events,
- bootstrap_sources,
- followup_sources,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let script_url = format!("{base_url}/child-async-classic.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childClassicAsyncWaitEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childClassicAsyncWaitEvents.push("load");
- frame.srcdoc = `
- <script>parent.__childClassicAsyncWaitEvents.push("before:" + (globalThis === self));<\/script>
- <script id="external-async-classic" async src="{script_url}"><\/script>
- <script>
- document.getElementById("external-async-classic").addEventListener("load", () => {{
- parent.__childClassicAsyncWaitEvents.push("script-load");
- }});
- document.addEventListener("DOMContentLoaded", () => {{
- parent.__childClassicAsyncWaitEvents.push("dcl:" + document.readyState);
- }});
- parent.__childClassicAsyncWaitEvents.push(
- "after:" + String(globalThis.__childClassicAsyncWaitValue)
- );
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
- let mut bootstrap_sources = Vec::new();
- let mut bootstrap_events = String::new();
- for _ in 0..8 {
- let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
- break;
- };
- bootstrap_sources.push(source);
- bootstrap_events = page_vm
- .vm_mut()
- .eval("__childClassicAsyncWaitEvents.join('|')")?;
- if bootstrap_events == "before:true|after:undefined|dcl:interactive" {
- break;
- }
- }
- assert_eq!(
- bootstrap_events,
- "before:true|after:undefined|dcl:interactive",
- "async classic must not block the document-owned DOMContentLoaded transition"
- );
- assert_eq!(
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- None,
- "the document-owned async classic delay must keep HostLoad blocked until source completion is applied"
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child async classic completion should arrive before timeout");
- assert!(
- arrived,
- "child async classic completion sender should remain open"
- );
- }
-
- let first =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let first_events = page_vm
- .vm_mut()
- .eval("__childClassicAsyncWaitEvents.join('|')")?;
- let mut followup_sources = Vec::new();
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "child async classic execution",
- )
- .await,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childClassicAsyncWaitEvents.join('|')")?,
- "before:true|after:undefined|dcl:interactive|async:true|current:external-async-classic|script-load",
- "DocumentScriptReady should execute child async classic and dispatch its script load without iframe load"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "child async classic complete transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::HostLoad,
- "child async classic iframe load",
- )
- .await,
- );
- let final_events = page_vm
- .vm_mut()
- .eval("__childClassicAsyncWaitEvents.join('|')")?;
- assert_eq!(
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- None,
- "child async classic follow-up sequence should not leave extra child frame task work"
- );
-
- Ok::<_, anyhow::Error>((
- first,
- first_events,
- bootstrap_sources,
- followup_sources,
- final_events,
- ))
- })
- .await
- .expect("page vm child async classic deferred completion test should run");
-
- assert!(matches!(
- first.action.source(),
- RendererOwnerResourceActivitySource::ChildClassicScript
- ));
- assert_eq!(
- first.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- first.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- assert_eq!(
- first_events, "before:true|after:undefined|dcl:interactive",
- "source completion turn should not inline-run child async classic script"
- );
- assert_eq!(
- bootstrap_sources,
- vec![
- ChildFrameSemanticTurnKind::NavigationCommit,
- ChildFrameSemanticTurnKind::RealmMaterialization,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle
- ],
- "child async bootstrap should dispatch interactive and DCL before the later async completion"
- );
- assert_eq!(
- followup_sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::HostLoad
- ],
- "child async classic source completion should progress through script execution, complete, and later HostLoad turns"
- );
- assert_eq!(
- final_events,
- "before:true|after:undefined|dcl:interactive|async:true|current:external-async-classic|script-load|load",
- "explicit later wait turns should run queued child async classic work"
- );
-
- server
- .await
- .expect("child async classic wait-path server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_defer_classic_preserves_document_order_when_second_source_finishes_first() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_concurrent_path_response_http_server(vec![
- (
- "/first-defer-classic.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childClassicDeferOrderEvents.push("first:" + (globalThis === self));
-parent.__childClassicDeferOrderEvents.push("current:" + document.currentScript.id);
-"#
- .to_owned(),
- Duration::from_millis(150),
- ),
- (
- "/second-defer-classic.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childClassicDeferOrderEvents.push("second:" + (globalThis === self));
-parent.__childClassicDeferOrderEvents.push("current:" + document.currentScript.id);
-"#
- .to_owned(),
- Duration::ZERO,
- ),
- ])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- second_completion,
- events_after_second_completion,
- first_completion,
- events_after_first_completion,
- bootstrap_sources,
- followup_sources,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let first_script_url = format!("{base_url}/first-defer-classic.js");
- let second_script_url = format!("{base_url}/second-defer-classic.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childClassicDeferOrderEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childClassicDeferOrderEvents.push("load");
- frame.srcdoc = `
- <script>parent.__childClassicDeferOrderEvents.push("before:" + (globalThis === self));<\/script>
- <script id="first-defer-classic" defer src="{first_script_url}"><\/script>
- <script id="second-defer-classic" defer src="{second_script_url}"><\/script>
- <script>
- document.getElementById("first-defer-classic").addEventListener("load", () => {{
- parent.__childClassicDeferOrderEvents.push("first-load");
- }});
- document.getElementById("second-defer-classic").addEventListener("load", () => {{
- parent.__childClassicDeferOrderEvents.push("second-load");
- }});
- parent.__childClassicDeferOrderEvents.push("after");
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
- let mut bootstrap_sources = Vec::new();
- let mut bootstrap_events = String::new();
- for _ in 0..8 {
- let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
- break;
- };
- bootstrap_sources.push(source);
- bootstrap_events = page_vm
- .vm_mut()
- .eval("__childClassicDeferOrderEvents.join('|')")?;
- if source == ChildFrameSemanticTurnKind::DocumentLifecycle {
- break;
- }
- }
- assert_eq!(
- bootstrap_events,
- "before:true|after",
- "child parser should continue past both defer classics without firing load"
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("second child defer classic completion should arrive before timeout");
- assert!(
- arrived,
- "child defer classic completion sender should remain open"
- );
- }
- let second_completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let events_after_second_completion = page_vm
- .vm_mut()
- .eval("__childClassicDeferOrderEvents.join('|')")?;
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("first child defer classic completion should arrive before timeout");
- assert!(
- arrived,
- "child defer classic completion sender should remain open"
- );
- }
- let first_completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let events_after_first_completion = page_vm
- .vm_mut()
- .eval("__childClassicDeferOrderEvents.join('|')")?;
- let mut followup_sources = Vec::new();
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "first child defer classic execution",
- )
- .await,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childClassicDeferOrderEvents.join('|')")?,
- "before:true|after|first:true|current:first-defer-classic|first-load",
- "first ordered DocumentScriptReady should execute the earlier defer classic without second defer or iframe load"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "second child defer classic execution",
- )
- .await,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childClassicDeferOrderEvents.join('|')")?,
- "before:true|after|first:true|current:first-defer-classic|first-load|second:true|current:second-defer-classic|second-load",
- "second ordered DocumentScriptReady should run only after the earlier defer classic completes"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "ordered child defer classic DOMContentLoaded transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "ordered child defer classic complete transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::HostLoad,
- "ordered child defer classic iframe load",
- )
- .await,
- );
- let final_events = page_vm
- .vm_mut()
- .eval("__childClassicDeferOrderEvents.join('|')")?;
- assert_eq!(
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- None,
- "child defer ordering sequence should not leave extra child frame task work"
- );
-
- Ok::<_, anyhow::Error>((
- second_completion,
- events_after_second_completion,
- first_completion,
- events_after_first_completion,
- bootstrap_sources,
- followup_sources,
- final_events,
- ))
- })
- .await
- .expect("page vm child defer classic ordering test should run");
-
- assert!(matches!(
- second_completion.action.source(),
- RendererOwnerResourceActivitySource::ChildClassicScript
- ));
- assert_eq!(
- second_completion.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- second_completion.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- assert_eq!(
- bootstrap_sources,
- vec![
- ChildFrameSemanticTurnKind::NavigationCommit,
- ChildFrameSemanticTurnKind::RealmMaterialization,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle
- ],
- "child defer ordering bootstrap should reach interactive before either source completion"
- );
- assert_eq!(
- events_after_second_completion, "before:true|after",
- "faster second defer source completion must not run before earlier defer"
- );
- assert!(matches!(
- first_completion.action.source(),
- RendererOwnerResourceActivitySource::ChildClassicScript
- ));
- assert_eq!(
- first_completion.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- first_completion.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- assert_eq!(
- events_after_first_completion, "before:true|after",
- "first defer source completion turn should still not inline-run script"
- );
- assert_eq!(
- followup_sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::HostLoad
- ],
- "ordered child defer classics should execute through two script-ready turns, DOMContentLoaded, and complete before HostLoad"
- );
- assert_eq!(
- final_events,
- "before:true|after|first:true|current:first-defer-classic|first-load|second:true|current:second-defer-classic|second-load|load",
- "defer classics should execute in document order even when the second source finishes first"
- );
-
- server
- .await
- .expect("child defer classic ordering server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_module_defer_preserves_document_order_when_second_graph_finishes_first() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_concurrent_path_response_http_server(vec![
- (
- "/first-module-defer.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childModuleDeferOrderEvents.push("first-module:" + (globalThis === self));
-globalThis.__childModuleDeferOrderFirst = 1;
-"#
- .to_owned(),
- Duration::from_millis(350),
- ),
- (
- "/second-module-defer.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childModuleDeferOrderEvents.push("second-module:" + (globalThis === self));
-globalThis.__childModuleDeferOrderSecond = 2;
-"#
- .to_owned(),
- Duration::ZERO,
- ),
- ])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- second_completion,
- events_after_second_completion,
- events_after_second_module_owner,
- first_completion,
- events_after_first_completion,
- bootstrap_sources,
- events_after_first_module_owner,
- followup_sources,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let first_script_url = format!("{base_url}/first-module-defer.js");
- let second_script_url = format!("{base_url}/second-module-defer.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childModuleDeferOrderEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childModuleDeferOrderEvents.push("load");
- frame.srcdoc = `
- <script>parent.__childModuleDeferOrderEvents.push("before:" + (globalThis === self));<\/script>
- <script id="first-module-defer" type="module" src="{first_script_url}"><\/script>
- <script id="second-module-defer" type="module" src="{second_script_url}"><\/script>
- <script>
- document.getElementById("first-module-defer").addEventListener("load", () => {{
- parent.__childModuleDeferOrderEvents.push("first-load");
- }});
- document.getElementById("second-module-defer").addEventListener("load", () => {{
- parent.__childModuleDeferOrderEvents.push("second-load");
- }});
- parent.__childModuleDeferOrderEvents.push(
- "after:" + String(globalThis.__childModuleDeferOrderFirst) + ":" +
- String(globalThis.__childModuleDeferOrderSecond)
- );
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let mut bootstrap_sources = Vec::new();
- let mut bootstrap_events = String::new();
- for _ in 0..10 {
- let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
- break;
- };
- bootstrap_sources.push(source);
- bootstrap_events = page_vm
- .vm_mut()
- .eval("__childModuleDeferOrderEvents.join('|')")?;
- if bootstrap_sources
- .iter()
- .filter(|source| **source == ChildFrameSemanticTurnKind::ParserModuleRootStart)
- .count()
- == 2
- && bootstrap_sources
- .contains(&ChildFrameSemanticTurnKind::DocumentLifecycle)
- && bootstrap_events == "before:true|after:undefined:undefined"
- {
- break;
- }
- }
- assert_eq!(
- bootstrap_events,
- "before:true|after:undefined:undefined",
- "child parser should continue past both parser module-defer scripts without evaluating them"
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("second child module-defer completion should arrive before timeout");
- assert!(
- arrived,
- "child module-defer completion sender should remain open"
- );
- }
- let second_completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let events_after_second_completion = page_vm
- .vm_mut()
- .eval("__childModuleDeferOrderEvents.join('|')")?;
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "later child module-defer terminal",
- )
- .await;
- let events_after_second_module_owner = page_vm
- .vm_mut()
- .eval("__childModuleDeferOrderEvents.join('|')")?;
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("first child module-defer completion should arrive before timeout");
- assert!(
- arrived,
- "child module-defer completion sender should remain open"
- );
- }
- let first_completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let events_after_first_completion = page_vm
- .vm_mut()
- .eval("__childModuleDeferOrderEvents.join('|')")?;
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "earlier child module-defer terminal",
- )
- .await;
- let events_after_first_module_owner = page_vm
- .vm_mut()
- .eval("__childModuleDeferOrderEvents.join('|')")?;
-
- let mut followup_sources = Vec::new();
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "first child module-defer execution",
- )
- .await,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childModuleDeferOrderEvents.join('|')")?,
- "before:true|after:undefined:undefined|first-module:true|first-load",
- "first ordered DocumentScriptReady should execute the earlier module-defer without second module or iframe load"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "second child module-defer execution",
- )
- .await,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childModuleDeferOrderEvents.join('|')")?,
- "before:true|after:undefined:undefined|first-module:true|first-load|second-module:true|second-load",
- "second ordered DocumentScriptReady should run only after the earlier module-defer completes"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "ordered child module-defer DOMContentLoaded transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "ordered child module-defer complete transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::HostLoad,
- "ordered child module-defer iframe load",
- )
- .await,
- );
- let final_events = page_vm
- .vm_mut()
- .eval("__childModuleDeferOrderEvents.join('|')")?;
- assert_eq!(
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- None,
- "child module-defer ordering sequence should not leave extra child frame task work"
- );
-
- Ok::<_, anyhow::Error>((
- second_completion,
- events_after_second_completion,
- events_after_second_module_owner,
- first_completion,
- events_after_first_completion,
- bootstrap_sources,
- events_after_first_module_owner,
- followup_sources,
- final_events,
- ))
- })
- .await
- .expect("page vm child module-defer ordering test should run");
-
- assert!(matches!(
- second_completion.action.source(),
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- ));
- assert_eq!(
- bootstrap_sources
- .iter()
- .filter(|source| **source == ChildFrameSemanticTurnKind::ParserModuleRootStart)
- .count(),
- 2,
- "child module-defer ordering bootstrap should start both parser-module roots explicitly: {bootstrap_sources:?}"
- );
- assert_eq!(
- events_after_second_completion, "before:true|after:undefined:undefined",
- "faster second module graph completion must not evaluate before earlier parser module"
- );
- assert_eq!(
- events_after_second_module_owner, "before:true|after:undefined:undefined",
- "later terminal source must only retain the terminal behind the earlier parser module"
- );
- assert!(matches!(
- first_completion.action.source(),
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- ));
- assert_eq!(
- events_after_first_completion, "before:true|after:undefined:undefined",
- "first module graph completion turn should still not inline-run script"
- );
- assert_eq!(
- events_after_first_module_owner, "before:true|after:undefined:undefined",
- "ModuleScriptTerminal should only enqueue ordered document-script work"
- );
- assert_eq!(
- followup_sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::HostLoad
- ],
- "ordered child module-defer scripts should execute through two script-ready turns, DOMContentLoaded, and complete before HostLoad"
- );
- assert_eq!(
- final_events,
- "before:true|after:undefined:undefined|first-module:true|first-load|second-module:true|second-load|load",
- "module-defer scripts should execute in document order even when the second graph finishes first"
- );
-
- server
- .await
- .expect("child module-defer ordering server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_parser_defer_preserves_cross_kind_document_order() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_concurrent_path_response_http_server(vec![
- (
- "/first-module.js",
- "HTTP/1.1 200 OK",
- r#"parent.__childMixedDeferEvents.push("first-module");"#.to_owned(),
- Duration::from_millis(220),
- ),
- (
- "/second-classic.js",
- "HTTP/1.1 200 OK",
- r#"parent.__childMixedDeferEvents.push("second-classic");"#.to_owned(),
- Duration::ZERO,
- ),
- (
- "/third-classic.js",
- "HTTP/1.1 200 OK",
- r#"parent.__childMixedDeferEvents.push("third-classic");"#.to_owned(),
- Duration::from_millis(420),
- ),
- (
- "/fourth-module.js",
- "HTTP/1.1 200 OK",
- r#"parent.__childMixedDeferEvents.push("fourth-module");"#.to_owned(),
- Duration::from_millis(20),
- ),
- ])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- completion_sources,
- execution_sources,
- lifecycle_sources,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childMixedDeferEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childMixedDeferEvents.push("load");
- frame.srcdoc = `
- <script>parent.__childMixedDeferEvents.push("before");<\/script>
- <script id="first-module" type="module" src="{base_url}/first-module.js"><\/script>
- <script id="second-classic" defer src="{base_url}/second-classic.js"><\/script>
- <script id="third-classic" defer src="{base_url}/third-classic.js"><\/script>
- <script id="fourth-module" type="module" src="{base_url}/fourth-module.js"><\/script>
- <script>
- for (const id of ["first-module", "second-classic", "third-classic", "fourth-module"]) {{
- document.getElementById(id).addEventListener("load", () => {{
- parent.__childMixedDeferEvents.push(id + "-load");
- }});
- }}
- parent.__childMixedDeferEvents.push("after");
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let mut bootstrap_sources = Vec::new();
- for _ in 0..12 {
- let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
- break;
- };
- bootstrap_sources.push(source);
- if source == ChildFrameSemanticTurnKind::DocumentLifecycle
- && bootstrap_sources
- .iter()
- .filter(|source| {
- **source == ChildFrameSemanticTurnKind::ParserModuleRootStart
- })
- .count()
- == 2
- {
- break;
- }
- }
- assert_eq!(
- page_vm.vm_mut().eval("__childMixedDeferEvents.join('|')")?,
- "before|after",
- "parser EOF must not execute any mixed parser-deferred script"
- );
- assert!(
- bootstrap_sources.contains(&ChildFrameSemanticTurnKind::DocumentLifecycle),
- "mixed parser-deferred document should reach interactive"
- );
- assert_eq!(
- bootstrap_sources
- .iter()
- .filter(|source| **source == ChildFrameSemanticTurnKind::ParserModuleRootStart)
- .count(),
- 2,
- "both module roots should start before terminal ordering is tested"
- );
-
- let mut completion_sources = Vec::new();
- let mut terminal_turn_count = 0;
- for completion_index in 0..3 {
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .unwrap_or_else(|_| {
- panic!(
- "mixed parser-deferred completion {completion_index} should arrive"
- )
- });
- }
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- completion_sources.push(completion.action.source());
- if completion.action.source()
- == RendererOwnerResourceActivitySource::ModuleGraphFetch
- {
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "mixed child module terminal",
- )
- .await;
- terminal_turn_count += 1;
- }
- assert_eq!(
- page_vm.vm_mut().eval("__childMixedDeferEvents.join('|')")?,
- "before|after",
- "out-of-order completions and retained terminals must not execute a later parser-deferred script"
- );
- }
-
- assert_eq!(
- completion_sources,
- vec![
- RendererOwnerResourceActivitySource::ChildClassicScript,
- RendererOwnerResourceActivitySource::ModuleGraphFetch,
- RendererOwnerResourceActivitySource::ModuleGraphFetch,
- ],
- "network timing should make later classic and module work terminal before the first module"
- );
- assert_eq!(terminal_turn_count, 2);
-
- let mut execution_sources = Vec::new();
- execution_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "first mixed parser-deferred module",
- )
- .await,
- );
- assert_eq!(
- page_vm.vm_mut().eval("__childMixedDeferEvents.join('|')")?,
- "before|after|first-module|first-module-load",
- "earlier module must execute before the already-ready later classic"
- );
- execution_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "second mixed parser-deferred classic",
- )
- .await,
- );
- assert_eq!(
- page_vm.vm_mut().eval("__childMixedDeferEvents.join('|')")?,
- "before|after|first-module|first-module-load|second-classic|second-classic-load",
- "second classic should execute only after the first module finishes"
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("third classic completion should arrive");
- }
- let third_completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- completion_sources.push(third_completion.action.source());
-
- execution_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "third mixed parser-deferred classic",
- )
- .await,
- );
- assert_eq!(
- page_vm.vm_mut().eval("__childMixedDeferEvents.join('|')")?,
- "before|after|first-module|first-module-load|second-classic|second-classic-load|third-classic|third-classic-load",
- "third classic must execute before the already-terminal fourth module"
- );
- execution_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "fourth mixed parser-deferred module",
- )
- .await,
- );
-
- let lifecycle_sources = vec![
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "mixed parser-deferred DOMContentLoaded",
- )
- .await,
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "mixed parser-deferred complete transition",
- )
- .await,
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::HostLoad,
- "mixed parser-deferred iframe load",
- )
- .await,
- ];
- let final_events = page_vm.vm_mut().eval("__childMixedDeferEvents.join('|')")?;
- assert_eq!(page_vm.run_next_child_frame_task_source_for_semantic_test().await, None);
-
- Ok::<_, anyhow::Error>((
- completion_sources,
- execution_sources,
- lifecycle_sources,
- final_events,
- ))
- })
- .await
- .expect("mixed child parser-deferred ordering test should run");
-
- assert_eq!(
- completion_sources.last(),
- Some(&RendererOwnerResourceActivitySource::ChildClassicScript)
- );
- assert_eq!(
- execution_sources,
- vec![ChildFrameSemanticTurnKind::DocumentScriptReady; 4]
- );
- assert_eq!(
- lifecycle_sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::HostLoad,
- ],
- "DCL, complete, and iframe load must remain later lifecycle turns"
- );
- assert_eq!(
- final_events,
- "before|after|first-module|first-module-load|second-classic|second-classic-load|third-classic|third-classic-load|fourth-module|fourth-module-load|load",
- "mixed parser-deferred scripts must execute in one cross-kind document order"
- );
-
- server
- .await
- .expect("mixed child parser-deferred ordering server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_module_defer_retains_later_graph_failure_behind_earlier_graph() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_concurrent_path_response_http_server(vec![
- (
- "/first-module-defer-success.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childModuleDeferFailureOrderEvents.push("first-module:" + (globalThis === self));
-globalThis.__childModuleDeferFailureOrderFirst = 1;
-"#
- .to_owned(),
- Duration::from_millis(350),
- ),
- (
- "/second-module-defer-failure.js",
- "HTTP/1.1 200 OK",
- "import {".to_owned(),
- Duration::ZERO,
- ),
- ])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- second_completion,
- events_after_second_completion,
- events_after_second_module_owner,
- source_after_second_module_owner,
- events_after_blocked_second_terminal,
- first_completion,
- events_after_first_completion,
- bootstrap_sources,
- events_after_first_module_owner,
- followup_sources,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let first_script_url = format!("{base_url}/first-module-defer-success.js");
- let second_script_url = format!("{base_url}/second-module-defer-failure.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childModuleDeferFailureOrderEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childModuleDeferFailureOrderEvents.push("load");
- frame.srcdoc = `
- <script>parent.__childModuleDeferFailureOrderEvents.push("before:" + (globalThis === self));<\/script>
- <script id="first-module-defer-success" type="module" src="{first_script_url}"><\/script>
- <script id="second-module-defer-failure" type="module" src="{second_script_url}"><\/script>
- <script>
- document.getElementById("first-module-defer-success").addEventListener("load", () => {{
- parent.__childModuleDeferFailureOrderEvents.push("first-load");
- }});
- document.getElementById("first-module-defer-success").addEventListener("error", () => {{
- parent.__childModuleDeferFailureOrderEvents.push("first-error");
- }});
- document.getElementById("second-module-defer-failure").addEventListener("load", () => {{
- parent.__childModuleDeferFailureOrderEvents.push("second-load");
- }});
- document.getElementById("second-module-defer-failure").addEventListener("error", () => {{
- parent.__childModuleDeferFailureOrderEvents.push("second-error");
- }});
- parent.__childModuleDeferFailureOrderEvents.push(
- "after:" + String(globalThis.__childModuleDeferFailureOrderFirst)
- );
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let mut bootstrap_sources = Vec::new();
- let mut bootstrap_events = String::new();
- for _ in 0..10 {
- let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
- break;
- };
- bootstrap_sources.push(source);
- bootstrap_events = page_vm
- .vm_mut()
- .eval("__childModuleDeferFailureOrderEvents.join('|')")?;
- if bootstrap_sources
- .iter()
- .filter(|source| **source == ChildFrameSemanticTurnKind::ParserModuleRootStart)
- .count()
- == 2
- && bootstrap_sources
- .contains(&ChildFrameSemanticTurnKind::DocumentLifecycle)
- && bootstrap_events == "before:true|after:undefined"
- {
- break;
- }
- }
- assert_eq!(
- bootstrap_events, "before:true|after:undefined",
- "child parser should continue past success/failure module-defer siblings without evaluating them"
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("second child module-defer failure should arrive before timeout");
- assert!(
- arrived,
- "child module-defer completion sender should remain open"
- );
- }
- let second_completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let events_after_second_completion = page_vm
- .vm_mut()
- .eval("__childModuleDeferFailureOrderEvents.join('|')")?;
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "later failing child module-defer terminal",
- )
- .await;
- let events_after_second_module_owner = page_vm
- .vm_mut()
- .eval("__childModuleDeferFailureOrderEvents.join('|')")?;
- let source_after_second_module_owner =
- page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_blocked_second_terminal = page_vm
- .vm_mut()
- .eval("__childModuleDeferFailureOrderEvents.join('|')")?;
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("first child module-defer success should arrive before timeout");
- assert!(
- arrived,
- "child module-defer completion sender should remain open"
- );
- }
- let first_completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let events_after_first_completion = page_vm
- .vm_mut()
- .eval("__childModuleDeferFailureOrderEvents.join('|')")?;
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "earlier successful child module-defer terminal",
- )
- .await;
- let events_after_first_module_owner = page_vm
- .vm_mut()
- .eval("__childModuleDeferFailureOrderEvents.join('|')")?;
-
- let mut followup_sources = Vec::new();
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "first successful child module-defer execution",
- )
- .await,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childModuleDeferFailureOrderEvents.join('|')")?,
- "before:true|after:undefined|first-module:true|first-load",
- "first ordered DocumentScriptReady should execute the earlier successful module before later error dispatch"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "second failing child module-defer dispatch",
- )
- .await,
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childModuleDeferFailureOrderEvents.join('|')")?,
- "before:true|after:undefined|first-module:true|first-load|second-error",
- "later graph failure should dispatch only after the earlier module-defer completes"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "ordered child module-defer graph-failure DOMContentLoaded transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "ordered child module-defer graph-failure complete transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::HostLoad,
- "ordered child module-defer graph-failure iframe load",
- )
- .await,
- );
- let final_events = page_vm
- .vm_mut()
- .eval("__childModuleDeferFailureOrderEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- second_completion,
- events_after_second_completion,
- events_after_second_module_owner,
- source_after_second_module_owner,
- events_after_blocked_second_terminal,
- first_completion,
- events_after_first_completion,
- bootstrap_sources,
- events_after_first_module_owner,
- followup_sources,
- final_events,
- ))
- })
- .await
- .expect("page vm child module-defer graph-failure ordering test should run");
-
- assert!(matches!(
- second_completion.action.source(),
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- ));
- assert_eq!(
- bootstrap_sources
- .iter()
- .filter(|source| **source == ChildFrameSemanticTurnKind::ParserModuleRootStart)
- .count(),
- 2,
- "child module-defer failure ordering bootstrap should start both roots explicitly: {bootstrap_sources:?}"
- );
- assert_eq!(
- events_after_second_completion, "before:true|after:undefined",
- "faster second graph failure completion must not dispatch script error before earlier parser module"
- );
- assert_eq!(
- events_after_second_module_owner, "before:true|after:undefined",
- "later graph failure terminal must be retained behind the earlier parser module"
- );
- assert_eq!(
- source_after_second_module_owner, None,
- "retained later graph failure should not wake DocumentScriptReady before the earlier graph finishes"
- );
- assert_eq!(
- events_after_blocked_second_terminal, "before:true|after:undefined",
- "blocked later graph failure should not dispatch script error or iframe load"
- );
- assert!(matches!(
- first_completion.action.source(),
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- ));
- assert_eq!(
- events_after_first_completion, "before:true|after:undefined",
- "first graph completion turn should not inline-run script"
- );
- assert_eq!(
- events_after_first_module_owner, "before:true|after:undefined",
- "ModuleScriptTerminal should only enqueue ordered document-script work"
- );
- assert_eq!(
- followup_sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::HostLoad
- ],
- "ordered child module-defer success/failure should finish through ready turns, DOMContentLoaded, and complete before HostLoad"
- );
- assert_eq!(
- final_events,
- "before:true|after:undefined|first-module:true|first-load|second-error|load",
- "later graph failure should preserve parser module document order and keep iframe load on HostLoad"
- );
-
- server
- .await
- .expect("child module-defer graph-failure ordering server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_parser_module_root_completion_queues_module_script_terminal_work() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-parser-module.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childParserModuleWaitEvents.push("module:" + (globalThis === self));
-globalThis.__childParserModuleWaitValue = 188;
-"#
- .to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let (owner_wake_tx, owner_wake_rx) = tokio::sync::mpsc::unbounded_channel();
- let owner_wake = crate::page_task_queue::RendererOwnerWakeSender::new(
- owner_wake_tx,
- crate::runtime::RendererPageToken::new_for_testing(crate::PageId::new_for_testing(1)),
- );
- let runtime_hooks =
- PageVmRuntimeHooks::standalone_with_owner_wake_without_owner_reservation_for_test(
- owner_wake,
- );
- let page_vm = test_page_vm_with_loader_document_url_and_hooks(
- &loader,
- Vec::new(),
- document_url,
- runtime_hooks,
- );
- let page_resource_queue = page_vm.page_resource_completion_queue();
- let local_executor = page_vm.local_executor.clone();
-
- let (
- first,
- first_events,
- bootstrap_sources,
- events_after_module_owner,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let mut page_resource_queue = page_resource_queue;
- let mut owner_wake_rx = owner_wake_rx;
- let script_url = format!("{base_url}/child-parser-module.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childParserModuleWaitEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childParserModuleWaitEvents.push("frame-load");
- frame.srcdoc = `
- <script>
- parent.__childParserModuleWaitEvents.push(
- "before:" + (globalThis === self) + ":" + document.currentScript.isConnected
- );
- <\/script>
- <script id="external-module" type="module" src="{script_url}"><\/script>
- <script>
- document.getElementById("external-module").addEventListener("load", () => {{
- parent.__childParserModuleWaitEvents.push("script-load");
- }});
- parent.__childParserModuleWaitEvents.push(
- "after:" + String(globalThis.__childParserModuleWaitValue)
- );
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
- let mut bootstrap_sources = Vec::new();
- let mut bootstrap_events = String::new();
- for _ in 0..8 {
- let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
- break;
- };
- bootstrap_sources.push(source);
- bootstrap_events = page_vm
- .vm_mut()
- .eval("__childParserModuleWaitEvents.join('|')")?;
- if bootstrap_sources
- .contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart)
- && bootstrap_sources
- .iter()
- .filter(|source| {
- **source == ChildFrameSemanticTurnKind::DocumentScriptReady
- })
- .count()
- == 2
- && bootstrap_sources
- .contains(&ChildFrameSemanticTurnKind::DocumentLifecycle)
- && bootstrap_events == "before:true:true|after:undefined"
- {
- break;
- }
- }
- assert_eq!(
- bootstrap_events,
- "before:true:true|after:undefined",
- "parser should continue past child module-defer script while root fetch is pending; sources={bootstrap_sources:?}"
- );
-
- if !page_resource_queue.has_ready_completion() {
- tokio::time::timeout(Duration::from_secs(2), async {
- while !page_resource_queue.has_ready_completion() {
- owner_wake_rx
- .recv()
- .await
- .expect("owner wake route should remain open");
- }
- })
- .await
- .expect("child parser module completion should arrive before timeout");
- }
-
- let _ = page_vm.vm_mut().take_network_output();
- let activity_epoch_before_completion =
- page_vm.vm().subresource_activity_epoch();
- let first = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_resource_queue)?
- .expect("production child module completion should consume one typed turn");
- assert!(
- !page_resource_queue.has_ready_completion(),
- "the production root terminal must be consumed exactly once"
- );
- assert_eq!(
- first.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- first.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- assert!(
- page_vm.vm().subresource_activity_epoch()
- > activity_epoch_before_completion,
- "a current child module Network terminal must advance current Document activity"
- );
- let (network_records, websocket_events, websocket_lifecycle_events) =
- split_network_output_items(page_vm.vm_mut().take_network_output());
- assert!(websocket_events.is_empty());
- assert!(websocket_lifecycle_events.is_empty());
- assert_eq!(network_records.len(), 1);
- let network_record = &network_records[0];
- assert!(
- network_record.frame_id().is_some(),
- "producer must retain the child frame attribution"
- );
- assert_eq!(network_record.document_url().as_str(), "about:srcdoc");
- assert_eq!(network_record.url().as_str(), script_url);
- assert_eq!(
- network_record.request_initiator_type(),
- SubresourceRequestInitiatorType::Parser
- );
- let first_events = page_vm
- .vm_mut()
- .eval("__childParserModuleWaitEvents.join('|')")?;
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "child parser-module root terminal",
- )
- .await;
- let events_after_module_owner = page_vm
- .vm_mut()
- .eval("__childParserModuleWaitEvents.join('|')")?;
- let script_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_script_ready = page_vm
- .vm_mut()
- .eval("__childParserModuleWaitEvents.join('|')")?;
- let host_load_source = Some(
- run_child_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "child parser-module iframe load",
- )
- .await,
- );
- let final_events = page_vm
- .vm_mut()
- .eval("__childParserModuleWaitEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- first,
- first_events,
- bootstrap_sources,
- events_after_module_owner,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- final_events,
- ))
- })
- .await
- .expect("page vm child parser module deferred completion test should run");
-
- assert!(matches!(
- first.action.source(),
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- ));
- assert_eq!(
- first_events, "before:true:true|after:undefined",
- "resource completion turn should not inline-run child parser module graph"
- );
- assert_eq!(
- bootstrap_sources,
- vec![
- ChildFrameSemanticTurnKind::NavigationCommit,
- ChildFrameSemanticTurnKind::RealmMaterialization,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::ParserModuleRootStart,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle
- ],
- "the typed root fetch-start must preserve parser discovery FIFO, then the parser should run the following inline script and reach interactive"
- );
- assert_eq!(
- events_after_module_owner, "before:true:true|after:undefined",
- "ModuleScriptTerminal should not execute the module-defer script inline"
- );
- assert_eq!(
- script_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "module-defer graph-ready work should execute through DocumentScriptReady"
- );
- assert_eq!(
- events_after_script_ready,
- "before:true:true|after:undefined|module:true|script-load",
- "DocumentScriptReady should run the module-defer script and dispatch its script load without iframe load"
- );
- assert_eq!(
- host_load_source,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "iframe load should remain a later HostLoad source after module-defer execution"
- );
- assert_eq!(
- final_events,
- "before:true:true|after:undefined|module:true|script-load|frame-load",
- "HostLoad should dispatch iframe load only after module-defer execution completes"
- );
-
- server
- .await
- .expect("child parser module wait-path server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_joined_parser_roots_batch_one_module_script_terminal() {
- run_page_vm_async_test(async move {
- let (base_url, shutdown_server_tx, server) = spawn_shutdown_path_response_http_server(vec![(
- "/child-shared-module.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childJoinedParserRootEvents.push("module:" + (globalThis === self));
-globalThis.__childJoinedParserRootValue = 501;
-"#
- .to_owned(),
- Duration::from_millis(200),
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- pre_completion_sources,
- events_before_completion,
- resource_ready_before_wait,
- completion_source,
- events_after_module_owner,
- first_ready_source,
- events_after_first_ready,
- second_ready_source,
- events_after_second_ready,
- host_load_source,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let script_url = format!("{base_url}/child-shared-module.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childJoinedParserRootEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childJoinedParserRootEvents.push("frame-load");
- frame.srcdoc = `
- <script>parent.__childJoinedParserRootEvents.push("before:" + (globalThis === self));<\/script>
- <script id="joined-module-a" type="module" src="{script_url}"><\/script>
- <script id="joined-module-b" type="module" src="{script_url}"><\/script>
- <script>
- document.getElementById("joined-module-a").addEventListener("load", () => {{
- parent.__childJoinedParserRootEvents.push("script-a-load");
- }});
- document.getElementById("joined-module-b").addEventListener("load", () => {{
- parent.__childJoinedParserRootEvents.push("script-b-load");
- }});
- parent.__childJoinedParserRootEvents.push(
- "after:" + String(globalThis.__childJoinedParserRootValue)
- );
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let mut pre_completion_sources = Vec::new();
- let mut events_before_completion = String::new();
- for _ in 0..8 {
- let source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- events_before_completion = page_vm
- .vm_mut()
- .eval("__childJoinedParserRootEvents.join('|')")?;
- if let Some(source) = source {
- pre_completion_sources.push(source);
- }
- if source.is_none()
- || page_vm.has_ready_page_websocket_task_for_test()
- || events_before_completion.contains("frame-load")
- {
- break;
- }
- }
- let resource_ready_before_wait = page_vm
- .page_resource_completion_queue()
- .has_ready_completion();
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("joined child module completion should arrive before timeout");
- assert!(
- arrived,
- "joined child module completion sender should remain open"
- );
- }
-
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let completion_source = completion.action.source();
-
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "joined parser-root terminal fanout",
- )
- .await;
- let events_after_module_owner = page_vm
- .vm_mut()
- .eval("__childJoinedParserRootEvents.join('|')")?;
-
- let first_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_first_ready = page_vm
- .vm_mut()
- .eval("__childJoinedParserRootEvents.join('|')")?;
-
- let second_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_second_ready = page_vm
- .vm_mut()
- .eval("__childJoinedParserRootEvents.join('|')")?;
-
- let host_load_source = Some(
- run_child_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "joined child parser-module iframe load",
- )
- .await,
- );
- let final_events = page_vm
- .vm_mut()
- .eval("__childJoinedParserRootEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- pre_completion_sources,
- events_before_completion,
- resource_ready_before_wait,
- completion_source,
- events_after_module_owner,
- first_ready_source,
- events_after_first_ready,
- second_ready_source,
- events_after_second_ready,
- host_load_source,
- final_events,
- ))
- })
- .await
- .expect("page vm joined child parser roots test should run");
-
- assert_eq!(
- pre_completion_sources
- .iter()
- .filter(|source| **source == ChildFrameSemanticTurnKind::ParserModuleRootStart)
- .count(),
- 2,
- "each parser root should get a reserve/join root-fetch source turn: {pre_completion_sources:?}"
- );
- assert!(
- !resource_ready_before_wait,
- "delayed shared module response should leave a window to prove joined roots wait for one completion"
- );
- assert_eq!(
- events_before_completion, "before:true|after:undefined",
- "joined child parser roots should not evaluate before the shared fetch completes"
- );
- assert_eq!(
- completion_source,
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- );
- assert_eq!(
- events_after_module_owner, "before:true|after:undefined",
- "module owner event should only enqueue document-script ready work"
- );
- assert_eq!(
- first_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "first joined parser root should execute on a document-script ready turn"
- );
- assert_eq!(
- events_after_first_ready,
- "before:true|after:undefined|module:true|script-a-load",
- "first ready turn should evaluate the shared module and dispatch the first script load"
- );
- assert_eq!(
- second_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "second joined parser root should execute on a later document-script ready turn"
- );
- assert_eq!(
- events_after_second_ready,
- "before:true|after:undefined|module:true|script-a-load|script-b-load",
- "second ready turn should dispatch the second script load without re-evaluating the module"
- );
- assert_eq!(
- host_load_source,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "iframe load should remain a later HostLoad source after joined parser roots"
- );
- assert_eq!(
- final_events,
- "before:true|after:undefined|module:true|script-a-load|script-b-load|frame-load",
- "HostLoad should dispatch iframe load after both joined parser roots complete"
- );
-
- shutdown_server_tx
- .send(())
- .expect("joined child parser roots server shutdown should send");
- let requested_paths = server
- .await
- .expect("joined child parser roots server should finish");
- assert_eq!(
- requested_paths,
- vec!["/child-shared-module.js"],
- "joined parser roots should reserve twice but share one network module fetch"
- );
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_module_script_blocks_host_load_until_evaluation_finishes() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-load-module.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childModuleHostLoadEvents.push("module:" + (globalThis === self));
-globalThis.__childModuleHostLoadValue = 203;
-"#
- .to_owned(),
- Duration::from_millis(200),
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- initial_host_load_before_root_fetch,
- navigation_commit_source,
- first_document_script_ready_before_root_fetch,
- host_load_attempt_before_root_fetch,
- events_after_pre_root_host_load_attempt,
- pre_completion_sources,
- events_before_completion,
- resource_ready_before_wait,
- completion_source,
- events_after_module_owner,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let script_url = format!("{base_url}/child-load-module.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childModuleHostLoadEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childModuleHostLoadEvents.push("frame-load");
- frame.srcdoc = `
- <script>parent.__childModuleHostLoadEvents.push("before:" + (globalThis === self));<\/script>
- <script id="load-module" type="module" src="{script_url}"><\/script>
- <script>
- document.getElementById("load-module").addEventListener("load", () => {{
- parent.__childModuleHostLoadEvents.push("script-load");
- }});
- parent.__childModuleHostLoadEvents.push(
- "after:" + String(globalThis.__childModuleHostLoadValue)
- );
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let initial_host_load_before_root_fetch = page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ChildHostLoad,
- &loader,
- )
- .await?;
- let navigation_commit_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- run_expected_child_realm_materialization_for_wait(
- &mut page_vm,
- "child parser-module exact realm",
- )
- .await;
- let first_document_script_ready_before_root_fetch =
- page_vm.run_next_child_frame_task_source_for_semantic_test().await
- == Some(ChildFrameSemanticTurnKind::DocumentScriptReady);
- let host_load_attempt_before_root_fetch = page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ChildHostLoad,
- &loader,
- )
- .await?;
- let events_after_pre_root_host_load_attempt = page_vm
- .vm_mut()
- .eval("__childModuleHostLoadEvents.join('|')")?;
-
- let mut pre_completion_sources = Vec::new();
- let mut events_before_completion = String::new();
- for _ in 0..8 {
- let source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- events_before_completion = page_vm
- .vm_mut()
- .eval("__childModuleHostLoadEvents.join('|')")?;
- if let Some(source) = source {
- pre_completion_sources.push(source);
- }
- if source.is_none()
- || page_vm.has_ready_page_websocket_task_for_test()
- || events_before_completion.contains("frame-load")
- {
- break;
- }
- }
- let resource_ready_before_wait = page_vm
- .page_resource_completion_queue()
- .has_ready_completion();
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child module completion should arrive before timeout");
- assert!(arrived, "child module completion sender should remain open");
- }
-
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let completion_source = completion.action.source();
-
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "child module HostLoad-gate terminal",
- )
- .await;
- let events_after_module_owner = page_vm
- .vm_mut()
- .eval("__childModuleHostLoadEvents.join('|')")?;
- let script_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_script_ready = page_vm
- .vm_mut()
- .eval("__childModuleHostLoadEvents.join('|')")?;
-
- let host_load_source = Some(
- run_child_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "child module iframe load",
- )
- .await,
- );
- let final_events = page_vm
- .vm_mut()
- .eval("__childModuleHostLoadEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- initial_host_load_before_root_fetch,
- navigation_commit_source,
- first_document_script_ready_before_root_fetch,
- host_load_attempt_before_root_fetch,
- events_after_pre_root_host_load_attempt,
- pre_completion_sources,
- events_before_completion,
- resource_ready_before_wait,
- completion_source,
- events_after_module_owner,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- final_events,
- ))
- })
- .await
- .expect("page vm child module HostLoad gate test should run");
-
- assert!(
- !initial_host_load_before_root_fetch,
- "HostLoad source should not progress while initial document-script ready work is pending"
- );
- assert_eq!(
- navigation_commit_source,
- Some(ChildFrameSemanticTurnKind::NavigationCommit),
- "child navigation must install the active Document before its parser-script turns"
- );
- assert!(
- first_document_script_ready_before_root_fetch,
- "the initial child DocumentScriptReady turn should enqueue parser-module root fetch work"
- );
- assert!(
- !host_load_attempt_before_root_fetch,
- "HostLoad source should make no progress while parser-module root fetch work is still queued"
- );
- assert!(
- !events_after_pre_root_host_load_attempt.contains("frame-load"),
- "queued parser-module root fetch work must block iframe load before source priority runs it"
- );
- assert!(
- pre_completion_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
- "pre-completion turns should start the module root fetch from its typed source: {pre_completion_sources:?}"
- );
- assert!(
- !pre_completion_sources.contains(&ChildFrameSemanticTurnKind::HostLoad),
- "blocked bootstrap HostLoad should not re-ready itself before module source completion: {pre_completion_sources:?}"
- );
- assert!(
- !resource_ready_before_wait,
- "delayed module response should leave a window to prove HostLoad is gated before completion"
- );
- assert_eq!(
- events_before_completion, "before:true|after:undefined",
- "pending module script must block iframe load before resource completion"
- );
- assert_eq!(
- completion_source,
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- );
- assert_eq!(
- events_after_module_owner, "before:true|after:undefined",
- "ModuleScriptTerminal should not execute the module or dispatch iframe load inline"
- );
- assert_eq!(
- script_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "module graph-ready work should execute through DocumentScriptReady"
- );
- assert_eq!(
- events_after_script_ready,
- "before:true|after:undefined|module:true|script-load",
- "module evaluation should dispatch script load but not iframe load inline"
- );
- assert_eq!(
- host_load_source,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "iframe load should remain a later HostLoad source"
- );
- assert_eq!(
- final_events,
- "before:true|after:undefined|module:true|script-load|frame-load",
- "HostLoad should dispatch iframe load only after module evaluation finishes"
- );
-
- server
- .await
- .expect("child module HostLoad gate server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_async_module_allows_dcl_before_source_completion() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-async-module.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childAsyncModuleEvents.push("module:" + (globalThis === self));
-globalThis.__childAsyncModuleValue = 307;
-"#
- .to_owned(),
- Duration::from_millis(200),
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- pre_completion_sources,
- events_at_dcl,
- resource_ready_at_dcl,
- post_dcl_sources_before_completion,
- completion_source,
- document_script_source,
- events_after_module,
- complete_source,
- host_load_source,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let script_url = format!("{base_url}/child-async-module.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childAsyncModuleEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childAsyncModuleEvents.push("frame-load");
- frame.srcdoc = `
- <script>
- parent.__childAsyncModuleEvents.push("before");
- document.addEventListener("DOMContentLoaded", () => {{
- parent.__childAsyncModuleEvents.push("dcl");
- }});
- <\/script>
- <script id="async-module" type="module" async src="{script_url}"><\/script>
- <script>
- document.getElementById("async-module").addEventListener("load", () => {{
- parent.__childAsyncModuleEvents.push("script-load");
- }});
- parent.__childAsyncModuleEvents.push("after");
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let mut pre_completion_sources = Vec::new();
- let mut events_at_dcl = String::new();
- for _ in 0..12 {
- let source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- if let Some(source) = source {
- pre_completion_sources.push(source);
- }
- events_at_dcl = page_vm
- .vm_mut()
- .eval("__childAsyncModuleEvents.join('|')")?;
- if events_at_dcl.contains("dcl") || source.is_none() {
- break;
- }
- }
- let resource_ready_at_dcl =
- page_vm.has_ready_page_websocket_task_for_test();
- let mut post_dcl_sources_before_completion = Vec::new();
- for _ in 0..4 {
- let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
- break;
- };
- post_dcl_sources_before_completion.push(source);
- }
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child async module completion should arrive before timeout");
- assert!(arrived, "child async module completion sender should remain open");
- }
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let completion_source = completion.action.source();
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "child async-module terminal",
- )
- .await;
- let document_script_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_module = page_vm
- .vm_mut()
- .eval("__childAsyncModuleEvents.join('|')")?;
- let complete_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let host_load_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let final_events = page_vm
- .vm_mut()
- .eval("__childAsyncModuleEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- pre_completion_sources,
- events_at_dcl,
- resource_ready_at_dcl,
- post_dcl_sources_before_completion,
- completion_source,
- document_script_source,
- events_after_module,
- complete_source,
- host_load_source,
- final_events,
- ))
- })
- .await
- .expect("page vm child async module lifecycle test should run");
-
- assert!(
- pre_completion_sources.contains(&ChildFrameSemanticTurnKind::DocumentLifecycle),
- "the child document should reach an explicit lifecycle turn before async module completion: {pre_completion_sources:?}"
- );
- assert!(
- !pre_completion_sources.contains(&ChildFrameSemanticTurnKind::HostLoad),
- "the async module load-delay token must keep HostLoad unavailable before source completion: {pre_completion_sources:?}"
- );
- assert_eq!(events_at_dcl, "before|after|dcl");
- assert!(
- !resource_ready_at_dcl,
- "DCL should run while the delayed async module source is still pending"
- );
- assert!(
- pre_completion_sources
- .contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
- "the async root fetch must start when the parser encounters the module, before DCL observes parser completion: {pre_completion_sources:?}"
- );
- assert!(
- !post_dcl_sources_before_completion
- .contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
- "one async parser module must publish exactly one root-start task: before={pre_completion_sources:?}, after={post_dcl_sources_before_completion:?}"
- );
- assert!(
- !post_dcl_sources_before_completion
- .contains(&ChildFrameSemanticTurnKind::DocumentLifecycle)
- && !post_dcl_sources_before_completion.contains(&ChildFrameSemanticTurnKind::HostLoad),
- "the async-module token should block complete and HostLoad without blocking DCL: {post_dcl_sources_before_completion:?}"
- );
- assert_eq!(
- completion_source,
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- );
- assert_eq!(
- document_script_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady)
- );
- assert_eq!(
- events_after_module,
- "before|after|dcl|module:true|script-load",
- "async module execution should release complete without redispatching DCL"
- );
- assert_eq!(
- complete_source,
- Some(ChildFrameSemanticTurnKind::DocumentLifecycle)
- );
- assert_eq!(host_load_source, Some(ChildFrameSemanticTurnKind::HostLoad));
- assert_eq!(
- final_events,
- "before|after|dcl|module:true|script-load|frame-load"
- );
-
- server
- .await
- .expect("child async module lifecycle server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_module_tla_releases_lifecycle_after_evaluation_starts() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-tla-module.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childModuleTlaHostLoadEvents.push("module-start:" + (globalThis === self));
-await new Promise(resolve => {
- parent.__resolveChildModuleTlaHostLoad = resolve;
- parent.__childModuleTlaHostLoadEvents.push("module-pending");
-});
-globalThis.__childModuleTlaHostLoadValue = 409;
-parent.__childModuleTlaHostLoadEvents.push("module-after");
-"#
- .to_owned(),
- Duration::from_millis(200),
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- pre_completion_sources,
- events_before_completion,
- resource_ready_before_wait,
- completion_source,
- events_after_module_owner,
- graph_ready_source,
- events_after_pending_evaluation,
- host_load_source_while_tla_pending,
- events_after_host_load,
- parent_completion_recheck_source,
- events_after_module_reaction,
- evaluation_completion_source,
- final_events,
- ) = local_executor
- // Keep this large, stateful scenario off nextest's comparatively
- // small test-thread stack; pinning does not add a scheduler turn.
- .run(Box::pin(async move {
- let mut page_vm = page_vm;
- let script_url = format!("{base_url}/child-tla-module.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childModuleTlaHostLoadEvents = [];
- delete globalThis.__resolveChildModuleTlaHostLoad;
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childModuleTlaHostLoadEvents.push("frame-load");
- frame.srcdoc = `
- <script>parent.__childModuleTlaHostLoadEvents.push("before:" + (globalThis === self));<\/script>
- <script id="tla-module" type="module" src="{script_url}"><\/script>
- <script>
- document.getElementById("tla-module").addEventListener("load", () => {{
- parent.__childModuleTlaHostLoadEvents.push("script-load");
- }});
- document.getElementById("tla-module").addEventListener("error", () => {{
- parent.__childModuleTlaHostLoadEvents.push("script-error");
- }});
- parent.__childModuleTlaHostLoadEvents.push(
- "after:" + String(globalThis.__childModuleTlaHostLoadValue)
- );
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let mut pre_completion_sources = Vec::new();
- let mut events_before_completion = String::new();
- for _ in 0..8 {
- let source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- events_before_completion = page_vm
- .vm_mut()
- .eval("__childModuleTlaHostLoadEvents.join('|')")?;
- if let Some(source) = source {
- pre_completion_sources.push(source);
- }
- if source.is_none()
- || page_vm.has_ready_page_websocket_task_for_test()
- || events_before_completion.contains("frame-load")
- {
- break;
- }
- }
- let resource_ready_before_wait = page_vm
- .page_resource_completion_queue()
- .has_ready_completion();
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child TLA module completion should arrive before timeout");
- assert!(arrived, "child TLA module completion sender should remain open");
- }
-
- let loader = page_vm.main_document_resource_loader();
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let completion_source = completion.action.source();
-
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "child TLA module terminal",
- )
- .await;
- let events_after_module_owner = page_vm
- .vm_mut()
- .eval("__childModuleTlaHostLoadEvents.join('|')")?;
- let graph_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_pending_evaluation = page_vm
- .vm_mut()
- .eval("__childModuleTlaHostLoadEvents.join('|')")?;
-
- let host_load_source_while_tla_pending = Some(
- run_child_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "child module TLA iframe load",
- )
- .await,
- );
- let events_after_host_load = page_vm
- .vm_mut()
- .eval("__childModuleTlaHostLoadEvents.join('|')")?;
- let parent_completion_recheck = page_vm
- .run_page_main_document_runtime_body_for_test(loader.request_client())
- .await?
- .expect("child HostLoad must publish one typed parent completion recheck");
-
- page_vm
- .vm_mut()
- .eval("__resolveChildModuleTlaHostLoad(); 'ok'")?;
- assert!(
- page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ModuleReaction,
- loader.request_client(),
- )
- .await?,
- "resolved child TLA should enqueue one typed module reaction"
- );
- let events_after_module_reaction = page_vm
- .vm_mut()
- .eval("__childModuleTlaHostLoadEvents.join('|')")?;
-
- let evaluation_completion_source =
- page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let final_events = page_vm
- .vm_mut()
- .eval("__childModuleTlaHostLoadEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- pre_completion_sources,
- events_before_completion,
- resource_ready_before_wait,
- completion_source,
- events_after_module_owner,
- graph_ready_source,
- events_after_pending_evaluation,
- host_load_source_while_tla_pending,
- events_after_host_load,
- parent_completion_recheck.action,
- events_after_module_reaction,
- evaluation_completion_source,
- final_events,
- ))
- }))
- .await
- .expect("page vm child TLA module HostLoad gate test should run");
-
- assert!(
- pre_completion_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
- "pre-completion turns should start the module root fetch from its typed source: {pre_completion_sources:?}"
- );
- assert!(
- !resource_ready_before_wait,
- "delayed TLA module response should leave a window to prove HostLoad is gated before completion"
- );
- assert_eq!(
- events_before_completion, "before:true|after:undefined",
- "pending TLA module script must block iframe load before resource completion"
- );
- assert_eq!(
- completion_source,
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- );
- assert_eq!(
- events_after_module_owner, "before:true|after:undefined",
- "ModuleScriptTerminal should not start TLA evaluation or dispatch iframe load inline"
- );
- assert_eq!(
- graph_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "module graph-ready work should start TLA evaluation through DocumentScriptReady"
- );
- assert_eq!(
- events_after_pending_evaluation,
- "before:true|after:undefined|module-start:true|module-pending|script-load",
- "starting TLA should complete the static module script and dispatch its load event"
- );
- assert_eq!(
- host_load_source_while_tla_pending,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "the evaluation promise must not keep the child lifecycle blocked"
- );
- assert_eq!(
- events_after_host_load,
- "before:true|after:undefined|module-start:true|module-pending|script-load|frame-load",
- "iframe load should run after the static module execution turn while TLA remains pending"
- );
- assert_eq!(
- parent_completion_recheck_source.kind(),
- crate::page_task_queue::PageMainDocumentRuntimeActionKind::PostParseWork,
- "child HostLoad completion should publish one concrete parent completion recheck task"
- );
- assert_eq!(
- parent_completion_recheck_source.target_effect(),
- crate::page_task_queue::PageMainDocumentRuntimeTargetEffect::AppliedToCurrentOwner,
- "the exact parent completion recheck must apply through the main-Document arbiter"
- );
- assert_eq!(
- events_after_module_reaction,
- "before:true|after:undefined|module-start:true|module-pending|script-load|frame-load|module-after",
- "module reaction should finish evaluation after document load without redispatching lifecycle events"
- );
- assert_eq!(
- evaluation_completion_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "fulfilled TLA continuation should re-enter DocumentScriptReady"
- );
- assert_eq!(
- final_events,
- "before:true|after:undefined|module-start:true|module-pending|script-load|frame-load|module-after",
- "TLA completion must not dispatch duplicate script or iframe load events"
- );
-
- server
- .await
- .expect("child TLA module HostLoad gate server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_dynamic_import_does_not_block_host_load() {
- run_page_vm_async_test(async move {
- #[derive(Debug, Clone, Copy, PartialEq, Eq)]
- enum PostLoadProgressSource {
- TypedMainDocumentRuntime {
- kind: crate::page_task_queue::PageMainDocumentRuntimeActionKind,
- effect: crate::page_task_queue::PageMainDocumentRuntimeTargetEffect,
- },
- TypedDynamicImportOwnerAction,
- }
-
- let (base_url, server) = spawn_path_response_http_server(vec![
- (
- "/child-dynamic-root.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childDynamicImportHostLoadEvents.push("module-start:" + (globalThis === self));
-import("./child-dynamic-leaf.js").then(
- () => parent.__childDynamicImportHostLoadEvents.push(
- "dynamic-fulfilled:" + String(globalThis.__childDynamicImportLeafValue)
- ),
- () => parent.__childDynamicImportHostLoadEvents.push("dynamic-rejected")
-);
-parent.__childDynamicImportHostLoadEvents.push("module-after");
-"#
- .to_owned(),
- Duration::ZERO,
- ),
- (
- "/child-dynamic-leaf.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childDynamicImportHostLoadEvents.push("dynamic-module:" + (globalThis === self));
-globalThis.__childDynamicImportLeafValue = 701;
-"#
- .to_owned(),
- Duration::from_millis(500),
- ),
- ])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let (owner_wake_tx, owner_wake_rx) = tokio::sync::mpsc::unbounded_channel();
- let owner_wake = crate::page_task_queue::RendererOwnerWakeSender::new(
- owner_wake_tx,
- crate::runtime::RendererPageToken::new_for_testing(crate::PageId::new_for_testing(2)),
- );
- let runtime_hooks =
- PageVmRuntimeHooks::standalone_with_owner_wake_without_owner_reservation_for_test(
- owner_wake,
- );
- let page_vm = test_page_vm_with_loader_document_url_and_hooks(
- &loader,
- Vec::new(),
- document_url,
- runtime_hooks,
- );
- let page_resource_queue = page_vm.page_resource_completion_queue();
- let local_executor = page_vm.local_executor.clone();
-
- let (
- startup_sources,
- events_before_completion,
- completion_source,
- events_after_module_terminal,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- events_after_host_load,
- post_load_progress_sources,
- events_after_dynamic_fetch_scheduled,
- dynamic_fetch_completion_source,
- host_load_pending_after_dynamic_fetch_completion,
- dynamic_owner_action_applied,
- events_after_dynamic_owner_action_body,
- events_after_dynamic_owner_action,
- host_load_pending_after_dynamic_owner_action,
- ) = local_executor
- // Keep this large, stateful scenario off nextest's comparatively
- // small test-thread stack; pinning does not add a scheduler turn.
- .run(Box::pin(async move {
- let mut page_vm = page_vm;
- let mut page_resource_queue = page_resource_queue;
- let mut owner_wake_rx = owner_wake_rx;
- let root_url = format!("{base_url}/child-dynamic-root.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childDynamicImportHostLoadEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childDynamicImportHostLoadEvents.push("frame-load");
- frame.srcdoc = `
- <base href="{base_url}/">
- <script>parent.__childDynamicImportHostLoadEvents.push("before:" + (globalThis === self));<\/script>
- <script id="dynamic-root" type="module" src="{root_url}"><\/script>
- <script>
- document.getElementById("dynamic-root").addEventListener("load", () => {{
- parent.__childDynamicImportHostLoadEvents.push("script-load");
- }});
- document.getElementById("dynamic-root").addEventListener("error", () => {{
- parent.__childDynamicImportHostLoadEvents.push("script-error");
- }});
- parent.__childDynamicImportHostLoadEvents.push(
- "after:" + String(globalThis.__childDynamicImportLeafValue)
- );
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let mut startup_sources = Vec::new();
- for _ in 0..8 {
- if page_resource_queue.has_ready_completion() {
- break;
- }
- let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
- break;
- };
- startup_sources.push(source);
- }
- let events_before_completion = page_vm
- .vm_mut()
- .eval("__childDynamicImportHostLoadEvents.join('|')")?;
-
- if !page_resource_queue.has_ready_completion() {
- tokio::time::timeout(Duration::from_secs(2), async {
- while !page_resource_queue.has_ready_completion() {
- owner_wake_rx
- .recv()
- .await
- .expect("owner-attached dynamic-import route should remain open");
- }
- })
- .await
- .expect("child dynamic root completion should arrive before timeout");
- }
-
- let completion = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_resource_queue)?
- .expect("typed child root completion should consume one Page turn");
- let completion_source = completion.action.source();
- let (root_network_records, root_websocket_events, root_websocket_lifecycle) =
- split_network_output_items(page_vm.vm_mut().take_network_output());
- assert!(root_websocket_events.is_empty());
- assert!(root_websocket_lifecycle.is_empty());
- assert_eq!(root_network_records.len(), 1);
- assert_eq!(
- root_network_records[0].request_initiator_type(),
- SubresourceRequestInitiatorType::Parser
- );
-
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "child dynamic import root terminal fanout",
- )
- .await;
- let events_after_module_terminal = page_vm
- .vm_mut()
- .eval("__childDynamicImportHostLoadEvents.join('|')")?;
-
- let script_ready_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "child dynamic import root module execution",
- )
- .await;
- let events_after_script_ready = page_vm
- .vm_mut()
- .eval("__childDynamicImportHostLoadEvents.join('|')")?;
-
- let host_load_source = run_child_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "child dynamic import iframe load before dynamic fetch",
- )
- .await;
- let events_after_host_load = page_vm
- .vm_mut()
- .eval("__childDynamicImportHostLoadEvents.join('|')")?;
-
- let mut post_load_progress_sources = Vec::new();
- let mut events_after_dynamic_fetch_scheduled = String::new();
- for _ in 0..8 {
- if page_resource_queue.has_ready_completion() {
- break;
- }
- if let Some(outcome) = page_vm
- .run_page_main_document_runtime_body_for_test(&loader)
- .await?
- {
- post_load_progress_sources.push(
- PostLoadProgressSource::TypedMainDocumentRuntime {
- kind: outcome.action.kind(),
- effect: outcome.action.target_effect(),
- },
- );
- events_after_dynamic_fetch_scheduled = page_vm
- .vm_mut()
- .eval("__childDynamicImportHostLoadEvents.join('|')")?;
- continue;
- }
- if page_vm.page_task_executor_sources_for_test().dynamic_import_owner_action()
- .has_ready_task()
- {
- let action = page_vm
- .run_page_dynamic_import_owner_action_body_for_test()
- .expect("typed dynamic-import owner action should win its Page turn");
- let crate::page_task_queue::PageDynamicImportOwnerActionDocumentEffect::AppliedToCurrentOwner {
- outcome,
- } = action.action.document_effect
- else {
- panic!("current dynamic-import owner action must not be stale: {action:?}");
- };
- assert!(
- outcome.waiting_fetch_was_scheduled(),
- "the first typed owner action should schedule the dynamic fetch"
- );
- page_vm
- .finish_selected_page_task_completion(
- action.action.into_page_task_completion(),
- &loader,
- )
- .await?;
- post_load_progress_sources
- .push(PostLoadProgressSource::TypedDynamicImportOwnerAction);
- events_after_dynamic_fetch_scheduled = page_vm
- .vm_mut()
- .eval("__childDynamicImportHostLoadEvents.join('|')")?;
- continue;
- }
- break;
- }
-
- if !page_resource_queue.has_ready_completion() {
- tokio::time::timeout(Duration::from_secs(2), async {
- while !page_resource_queue.has_ready_completion() {
- owner_wake_rx.recv().await.expect(
- "owner-attached dynamic-import completion route should remain open",
- );
- }
- })
- .await
- .unwrap_or_else(|_| {
- panic!(
- "child dynamic import completion should arrive before timeout: progress={post_load_progress_sources:?} events={events_after_dynamic_fetch_scheduled}"
- )
- });
- }
- let activity_epoch_before_dynamic_completion =
- page_vm.vm().subresource_activity_epoch();
- let dynamic_fetch_completion = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_resource_queue)?
- .expect("child dynamic import fetch completion should be ready");
- assert_eq!(
- dynamic_fetch_completion.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- dynamic_fetch_completion.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
- assert!(
- page_vm.vm().subresource_activity_epoch()
- > activity_epoch_before_dynamic_completion,
- "a current dynamic-import Network fact must advance current Document activity"
- );
- assert!(
- !page_resource_queue.has_ready_completion(),
- "one producer terminal must be consumed exactly once"
- );
- let (dynamic_network_records, dynamic_websocket_events, dynamic_websocket_lifecycle) =
- split_network_output_items(page_vm.vm_mut().take_network_output());
- assert!(dynamic_websocket_events.is_empty());
- assert!(dynamic_websocket_lifecycle.is_empty());
- assert_eq!(dynamic_network_records.len(), 1);
- assert_eq!(
- dynamic_network_records[0].url().as_str(),
- format!("{base_url}/child-dynamic-leaf.js")
- );
- assert_eq!(
- dynamic_network_records[0].request_initiator_type(),
- SubresourceRequestInitiatorType::Script
- );
- let dynamic_fetch_completion_source = dynamic_fetch_completion.action.source();
- let host_load_pending_after_dynamic_fetch_completion = page_vm
- .has_ready_child_frame_semantic_turn_for_test(ChildFrameSemanticTurnKind::HostLoad);
-
- let dynamic_owner_action = page_vm
- .run_page_dynamic_import_owner_action_body_for_test()
- .expect("dynamic-import ready action should consume one typed Page turn");
- let crate::page_task_queue::PageDynamicImportOwnerActionDocumentEffect::AppliedToCurrentOwner {
- outcome: dynamic_owner_action_outcome,
- } = dynamic_owner_action.action.document_effect
- else {
- panic!("current dynamic-import ready action must not be stale: {dynamic_owner_action:?}");
- };
- let dynamic_owner_action_applied =
- dynamic_owner_action_outcome.evaluation_import_was_resolved();
- let events_after_dynamic_owner_action_body = page_vm
- .vm_mut()
- .eval_without_microtask_checkpoint_for_test(
- "__childDynamicImportHostLoadEvents.join('|')",
- )?;
- page_vm
- .finish_selected_page_task_completion(
- dynamic_owner_action.action.into_page_task_completion(),
- &loader,
- )
- .await?;
- let events_after_dynamic_owner_action = page_vm
- .vm_mut()
- .eval_without_microtask_checkpoint_for_test(
- "__childDynamicImportHostLoadEvents.join('|')",
- )?;
- let host_load_pending_after_dynamic_owner_action = page_vm
- .has_ready_child_frame_semantic_turn_for_test(ChildFrameSemanticTurnKind::HostLoad);
-
- Ok::<_, anyhow::Error>((
- startup_sources,
- events_before_completion,
- completion_source,
- events_after_module_terminal,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- events_after_host_load,
- post_load_progress_sources,
- events_after_dynamic_fetch_scheduled,
- dynamic_fetch_completion_source,
- host_load_pending_after_dynamic_fetch_completion,
- dynamic_owner_action_applied,
- events_after_dynamic_owner_action_body,
- events_after_dynamic_owner_action,
- host_load_pending_after_dynamic_owner_action,
- ))
- }))
- .await
- .expect("page vm child dynamic import HostLoad proof should run");
-
- assert!(
- startup_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
- "child dynamic import startup should start the root module fetch from a typed source: {startup_sources:?}"
- );
- assert_eq!(
- events_before_completion, "before:true|after:undefined",
- "pending root module should not run dynamic import or dispatch iframe load before completion"
- );
- assert_eq!(
- completion_source,
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- );
- assert_eq!(
- events_after_module_terminal, "before:true|after:undefined",
- "ModuleScriptTerminal should not execute the root module inline"
- );
- assert_eq!(
- script_ready_source,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "root module graph-ready work should execute through DocumentScriptReady"
- );
- assert_eq!(
- events_after_script_ready,
- "before:true|after:undefined|module-start:true|module-after|script-load",
- "DocumentScriptReady should execute the root module and dispatch script load without iframe load or dynamic import completion"
- );
- assert_eq!(
- host_load_source,
- ChildFrameSemanticTurnKind::HostLoad,
- "iframe load should remain a HostLoad turn after the root module script queues dynamic import"
- );
- assert_eq!(
- events_after_host_load,
- "before:true|after:undefined|module-start:true|module-after|script-load|frame-load",
- "HostLoad should dispatch iframe load before dynamic import fetch scheduling or completion"
- );
- assert!(
- post_load_progress_sources.contains(
- &PostLoadProgressSource::TypedMainDocumentRuntime {
- kind: crate::page_task_queue::PageMainDocumentRuntimeActionKind::DynamicModuleJob,
- effect: crate::page_task_queue::PageMainDocumentRuntimeTargetEffect::AppliedToCurrentOwner,
- },
- ),
- "dynamic import should advance through its concrete exact-main-Document task: {post_load_progress_sources:?}"
- );
- let dynamic_module_job = PostLoadProgressSource::TypedMainDocumentRuntime {
- kind: crate::page_task_queue::PageMainDocumentRuntimeActionKind::DynamicModuleJob,
- effect: crate::page_task_queue::PageMainDocumentRuntimeTargetEffect::AppliedToCurrentOwner,
- };
- let materialize_position = post_load_progress_sources
- .iter()
- .position(|source| *source == dynamic_module_job)
- .expect("dynamic import should expose its concrete graph-advance turn");
- let owner_action_position = post_load_progress_sources
- .iter()
- .position(|source| *source == PostLoadProgressSource::TypedDynamicImportOwnerAction)
- .expect("dynamic import graph advance should publish an exact child owner action");
- assert!(
- owner_action_position > materialize_position,
- "the exact child owner action must follow its graph advance without imposing a cross-source adjacency rule: {post_load_progress_sources:?}"
- );
- assert_eq!(
- events_after_dynamic_fetch_scheduled,
- "before:true|after:undefined|module-start:true|module-after|script-load|frame-load",
- "dynamic import runtime work should schedule fetch without executing the dynamic module after iframe load"
- );
- assert_eq!(
- dynamic_fetch_completion_source,
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- );
- assert!(
- !host_load_pending_after_dynamic_fetch_completion,
- "dynamic import fetch completion should not queue HostLoad after the iframe has already loaded"
- );
- assert!(
- dynamic_owner_action_applied,
- "dynamic import ready action should resolve from the typed Page source"
- );
- assert_eq!(
- events_after_dynamic_owner_action_body,
- "before:true|after:undefined|module-start:true|module-after|script-load|frame-load|dynamic-module:true",
- "DynamicImportOwnerAction body must leave the user import reaction for selected-task completion"
- );
- assert_eq!(
- events_after_dynamic_owner_action,
- "before:true|after:undefined|module-start:true|module-after|script-load|frame-load|dynamic-module:true|dynamic-fulfilled:701",
- "selected-task completion should fulfill the child dynamic import after the body returns"
- );
- assert!(
- !host_load_pending_after_dynamic_owner_action,
- "dynamic import ready action should not requeue HostLoad"
- );
-
- server
- .await
- .expect("child dynamic import HostLoad proof server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_module_graph_failure_blocks_host_load_until_error_dispatches() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-bad-module.js",
- "HTTP/1.1 200 OK",
- "import {".to_owned(),
- Duration::from_millis(200),
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- pre_completion_sources,
- events_before_completion,
- resource_ready_before_wait,
- completion_source,
- events_after_module_owner,
- graph_failure_source,
- events_after_graph_failure,
- host_load_source,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let script_url = format!("{base_url}/child-bad-module.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childModuleFailureHostLoadEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childModuleFailureHostLoadEvents.push("frame-load");
- frame.srcdoc = `
- <script>parent.__childModuleFailureHostLoadEvents.push("before:" + (globalThis === self));<\/script>
- <script id="bad-module" type="module" src="{script_url}"><\/script>
- <script>
- document.getElementById("bad-module").addEventListener("load", () => {{
- parent.__childModuleFailureHostLoadEvents.push("script-load");
- }});
- document.getElementById("bad-module").addEventListener("error", () => {{
- parent.__childModuleFailureHostLoadEvents.push("script-error");
- }});
- parent.__childModuleFailureHostLoadEvents.push("after");
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let mut pre_completion_sources = Vec::new();
- let mut events_before_completion = String::new();
- for _ in 0..8 {
- let source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- events_before_completion = page_vm
- .vm_mut()
- .eval("__childModuleFailureHostLoadEvents.join('|')")?;
- if let Some(source) = source {
- pre_completion_sources.push(source);
- }
- if source.is_none()
- || page_vm.has_ready_page_websocket_task_for_test()
- || events_before_completion.contains("frame-load")
- {
- break;
- }
- }
- let resource_ready_before_wait = page_vm
- .page_resource_completion_queue()
- .has_ready_completion();
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child bad module completion should arrive before timeout");
- assert!(arrived, "child bad module completion sender should remain open");
- }
-
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let completion_source = completion.action.source();
-
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "child graph-failure module terminal",
- )
- .await;
- let events_after_module_owner = page_vm
- .vm_mut()
- .eval("__childModuleFailureHostLoadEvents.join('|')")?;
-
- let graph_failure_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_graph_failure = page_vm
- .vm_mut()
- .eval("__childModuleFailureHostLoadEvents.join('|')")?;
-
- let host_load_source = Some(
- run_child_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "child module graph-failure iframe load",
- )
- .await,
- );
- let final_events = page_vm
- .vm_mut()
- .eval("__childModuleFailureHostLoadEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- pre_completion_sources,
- events_before_completion,
- resource_ready_before_wait,
- completion_source,
- events_after_module_owner,
- graph_failure_source,
- events_after_graph_failure,
- host_load_source,
- final_events,
- ))
- })
- .await
- .expect("page vm child bad module HostLoad gate test should run");
-
- assert!(
- pre_completion_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
- "pre-completion turns should start the module root fetch from its typed source: {pre_completion_sources:?}"
- );
- assert!(
- !resource_ready_before_wait,
- "delayed bad module response should leave a window to prove HostLoad is gated before completion"
- );
- assert_eq!(
- events_before_completion, "before:true|after",
- "pending bad module script must block iframe load before resource completion"
- );
- assert_eq!(
- completion_source,
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- );
- assert_eq!(
- events_after_module_owner, "before:true|after",
- "module owner event should not dispatch script error or iframe load inline"
- );
- assert_eq!(
- graph_failure_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "graph failure should dispatch through DocumentScriptReady"
- );
- assert_eq!(
- events_after_graph_failure, "before:true|after|script-error",
- "graph failure should dispatch script error without iframe load"
- );
- assert_eq!(
- host_load_source,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "iframe load should remain a later HostLoad source after graph failure"
- );
- assert_eq!(
- final_events, "before:true|after|script-error|frame-load",
- "HostLoad should dispatch iframe load only after graph failure finalizes"
- );
-
- server
- .await
- .expect("child bad module HostLoad gate server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_script_event_created_nested_navigation_precedes_document_script_ready() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-event-module.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childScriptEventNestedEvents.push("module:" + (globalThis === self));
-"#
- .to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- completion_source,
- module_followup_sources,
- events_after_script_event,
- nested_script_ready_source,
- events_after_nested_script,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let script_url = format!("{base_url}/child-event-module.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childScriptEventNestedEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.srcdoc = `
- <script>parent.__childScriptEventNestedEvents.push("before:" + (globalThis === self));<\/script>
- <script id="event-module" type="module" src="{script_url}"><\/script>
- <script>
- document.getElementById("event-module").addEventListener("load", () => {{
- parent.__childScriptEventNestedEvents.push("script-load");
- const nested = document.createElement("iframe");
- nested.srcdoc = "<script>parent.parent.__childScriptEventNestedEvents.push('nested-script:' + (globalThis === self));<\\/script>";
- document.body.appendChild(nested);
- }});
- parent.__childScriptEventNestedEvents.push("after:" + String(globalThis.__childScriptEventNestedValue));
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
- let startup_sources =
- drive_child_frame_task_sources_until_resource_completion_ready(
- &mut page_vm,
- 8,
- )
- .await;
- assert!(
- startup_sources.contains(&ChildFrameSemanticTurnKind::DocumentScriptReady),
- "child module startup should reach DocumentScriptReady without test drain: {startup_sources:?}"
- );
- assert!(
- startup_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
- "child module startup should start the parser module root fetch from its typed source: {startup_sources:?}"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childScriptEventNestedEvents.join('|')")?,
- "before:true|after:undefined",
- "parser should continue past the child module while the root fetch is pending"
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child parser module completion should arrive before timeout");
- assert!(
- arrived,
- "child parser module completion sender should remain open"
- );
- }
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let completion_source = completion.action.source();
-
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "child script-event module terminal fanout",
- )
- .await;
- let mut module_followup_sources = Vec::new();
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childScriptEventNestedEvents.join('|')")?,
- "before:true|after:undefined",
- "ModuleScriptTerminal should queue graph-ready work without running the module or nested iframe"
- );
- module_followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "child script-event module execution",
- )
- .await,
- );
- let events_after_script_event = page_vm
- .vm_mut()
- .eval("__childScriptEventNestedEvents.join('|')")?;
-
- module_followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "nested iframe navigation created during child script event",
- )
- .await,
- );
- module_followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "child script-event DOMContentLoaded transition",
- )
- .await,
- );
- let nested_script_ready_source = Some(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "nested iframe ready work created during child script event",
- )
- .await,
- );
- let events_after_nested_script = page_vm
- .vm_mut()
- .eval("__childScriptEventNestedEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- completion_source,
- module_followup_sources,
- events_after_script_event,
- nested_script_ready_source,
- events_after_nested_script,
- ))
- })
- .await
- .expect("child script event nested ready-work source test should run");
-
- assert_eq!(
- completion_source,
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- );
- assert_eq!(
- module_followup_sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::NavigationCommit,
- ChildFrameSemanticTurnKind::DocumentLifecycle
- ],
- "module execution, nested navigation commit, and DOMContentLoaded should remain separate child-frame turns after the typed terminal fanout"
- );
- assert_eq!(
- events_after_script_event, "before:true|after:undefined|module:true|script-load",
- "module evaluation should dispatch the script load event before nested parser work"
- );
- assert_eq!(
- nested_script_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "nested parser ready work should enter DocumentScriptReady after its owner transaction commits"
- );
- assert_eq!(
- events_after_nested_script,
- "before:true|after:undefined|module:true|script-load|nested-script:true"
- );
-
- server
- .await
- .expect("child script event nested ready-work server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_module_dependency_completion_queues_module_script_terminal_work() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![
- (
- "/child-root-module.js",
- "HTTP/1.1 200 OK",
- r#"
-import { depValue } from "./child-dependency.js";
-parent.__childModuleDependencyWaitEvents.push("root:" + depValue);
-globalThis.__childModuleDependencyWaitValue = depValue;
-"#
- .to_owned(),
- Duration::ZERO,
- ),
- (
- "/child-dependency.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childModuleDependencyWaitEvents.push("dep:" + (globalThis === self));
-export const depValue = "dep-value";
-"#
- .to_owned(),
- Duration::ZERO,
- ),
- ])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- dependency,
- events_after_dependency_completion,
- followup_sources,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let root_url = format!("{base_url}/child-root-module.js");
- let dependency_url = format!("{base_url}/child-dependency.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childModuleDependencyWaitEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childModuleDependencyWaitEvents.push("frame-load");
- frame.srcdoc = `
- <script>parent.__childModuleDependencyWaitEvents.push("before:" + (globalThis === self));<\/script>
- <script id="external-module" type="module" src="{root_url}"><\/script>
- <script>
- document.getElementById("external-module").addEventListener("load", () => {{
- parent.__childModuleDependencyWaitEvents.push("script-load");
- }});
- parent.__childModuleDependencyWaitEvents.push(
- "after:" + String(globalThis.__childModuleDependencyWaitValue)
- );
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
- let startup_sources =
- drive_child_frame_task_sources_until_resource_completion_ready(
- &mut page_vm,
- 8,
- )
- .await;
- assert!(
- startup_sources.contains(&ChildFrameSemanticTurnKind::DocumentScriptReady),
- "child module dependency startup should reach DocumentScriptReady without test drain: {startup_sources:?}"
- );
- assert!(
- startup_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
- "child module dependency startup should start the root fetch from its typed source: {startup_sources:?}"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childModuleDependencyWaitEvents.join('|')")?,
- "before:true|after:undefined",
- "parser should continue past child module script while dependency fetches are pending"
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child parser module root completion should arrive before timeout");
- assert!(
- arrived,
- "child parser module root completion sender should remain open"
- );
- }
-
- let root = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- assert_eq!(
- root.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- root.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- root.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "child dependency root terminal",
- )
- .await;
- let (root_network_records, _, _) =
- split_network_output_items(page_vm.vm_mut().take_network_output());
- assert_eq!(root_network_records.len(), 1);
- assert_eq!(root_network_records[0].url().as_str(), root_url);
- assert!(
- page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ChildModuleDependencyFetchStart,
- &loader,
- )
- .await?,
- "module terminal should queue one selected dependency-start task",
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child module dependency completion should arrive before timeout");
- assert!(
- arrived,
- "child module dependency completion sender should remain open"
- );
- }
-
- let activity_epoch_before_dependency =
- page_vm.vm().subresource_activity_epoch();
- let dependency =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- assert_eq!(
- dependency.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- dependency.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- assert!(
- page_vm.vm().subresource_activity_epoch()
- > activity_epoch_before_dependency,
- "a current child dependency Network terminal must advance current Document activity"
- );
- let (dependency_network_records, _, _) =
- split_network_output_items(page_vm.vm_mut().take_network_output());
- assert_eq!(dependency_network_records.len(), 1);
- let dependency_network_record = &dependency_network_records[0];
- assert_eq!(dependency_network_record.url().as_str(), dependency_url);
- assert!(dependency_network_record.frame_id().is_some());
- assert_eq!(
- dependency_network_record.request_initiator_type(),
- SubresourceRequestInitiatorType::Parser
- );
- let events_after_dependency_completion = page_vm
- .vm_mut()
- .eval("__childModuleDependencyWaitEvents.join('|')")?;
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "child module dependency terminal fanout",
- )
- .await;
- let mut followup_sources = Vec::new();
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childModuleDependencyWaitEvents.join('|')")?,
- "before:true|after:undefined",
- "dependency terminal fanout should not execute the module graph inline"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "child module dependency graph-ready execution",
- )
- .await,
- );
- let events_after_graph_ready = page_vm
- .vm_mut()
- .eval("__childModuleDependencyWaitEvents.join('|')")?;
- assert_eq!(
- events_after_graph_ready,
- "before:true|after:undefined|dep:true|root:dep-value|script-load",
- "dependency graph-ready execution should dispatch script load without iframe load"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "child module dependency DOMContentLoaded transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "child module dependency complete transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::HostLoad,
- "child module dependency iframe load",
- )
- .await,
- );
- let final_events = page_vm
- .vm_mut()
- .eval("__childModuleDependencyWaitEvents.join('|')")?;
- assert_eq!(
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- None,
- "child module dependency follow-up sequence should not leave extra child frame task work"
- );
-
- Ok::<_, anyhow::Error>((
- dependency,
- events_after_dependency_completion,
- followup_sources,
- final_events,
- ))
- })
- .await
- .expect("page vm child module dependency deferred completion test should run");
-
- assert!(matches!(
- dependency.action.source(),
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- ));
- assert_eq!(
- events_after_dependency_completion, "before:true|after:undefined",
- "dependency completion turn should not inline-run child module graph"
- );
- assert_eq!(
- followup_sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::HostLoad
- ],
- "graph-ready, DOMContentLoaded, complete, and HostLoad must remain separate child turns after typed terminal fanout"
- );
- assert_eq!(
- final_events,
- "before:true|after:undefined|dep:true|root:dep-value|script-load|frame-load",
- "explicit later turns should run queued child module graph work before iframe load"
- );
-
- server
- .await
- .expect("child module dependency wait-path server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_module_dependency_failure_queues_graph_failed_before_host_load() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![
- (
- "/child-root-module.js",
- "HTTP/1.1 200 OK",
- r#"
-import { depValue } from "./missing-child-dependency.js";
-parent.__childModuleDependencyFailureEvents.push("root:" + depValue);
-"#
- .to_owned(),
- Duration::ZERO,
- ),
- (
- "/missing-child-dependency.js",
- "HTTP/1.1 404 Not Found",
- "missing dependency".to_owned(),
- Duration::ZERO,
- ),
- ])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- dependency,
- events_after_dependency_completion,
- followup_sources,
- events_after_graph_failure,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let root_url = format!("{base_url}/child-root-module.js");
- let dependency_url = format!("{base_url}/missing-child-dependency.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childModuleDependencyFailureEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childModuleDependencyFailureEvents.push("frame-load");
- frame.srcdoc = `
- <script>parent.__childModuleDependencyFailureEvents.push("before:" + (globalThis === self));<\/script>
- <script id="external-module" type="module" src="{root_url}"><\/script>
- <script>
- document.getElementById("external-module").addEventListener("load", () => {{
- parent.__childModuleDependencyFailureEvents.push("script-load");
- }});
- document.getElementById("external-module").addEventListener("error", () => {{
- parent.__childModuleDependencyFailureEvents.push("script-error");
- }});
- parent.__childModuleDependencyFailureEvents.push("after:" + String(globalThis.__childModuleDependencyFailureValue));
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
- let startup_sources =
- drive_child_frame_task_sources_until_resource_completion_ready(
- &mut page_vm,
- 8,
- )
- .await;
- assert!(
- startup_sources.contains(&ChildFrameSemanticTurnKind::DocumentScriptReady),
- "child module dependency failure startup should reach DocumentScriptReady without test drain: {startup_sources:?}"
- );
- assert!(
- startup_sources.contains(&ChildFrameSemanticTurnKind::ParserModuleRootStart),
- "child module dependency failure startup should start the root fetch from its typed source: {startup_sources:?}"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childModuleDependencyFailureEvents.join('|')")?,
- "before:true|after:undefined",
- "parser should continue past child module script while dependency fetch is pending"
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child parser module root completion should arrive before timeout");
- assert!(
- arrived,
- "child parser module root completion sender should remain open"
- );
- }
-
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "child dependency-failure root terminal",
- )
- .await;
- let _ = page_vm.vm_mut().take_network_output();
- assert!(
- page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ChildModuleDependencyFetchStart,
- &loader,
- )
- .await?,
- "module terminal should queue one selected dependency-start task",
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect(
- "child module dependency failure completion should arrive before timeout",
- );
- assert!(
- arrived,
- "child module dependency failure completion sender should remain open"
- );
- }
-
- let dependency =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- assert_eq!(
- dependency.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- dependency.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
-
- let (dependency_network_records, _, _) =
- split_network_output_items(page_vm.vm_mut().take_network_output());
- assert_eq!(dependency_network_records.len(), 1);
- assert_eq!(
- dependency_network_records[0].url().as_str(),
- dependency_url
- );
- assert!(matches!(
- dependency_network_records[0].outcome(),
- SubresourceNetworkOutcome::Success { status: 404, .. }
- ));
- let events_after_dependency_completion = page_vm
- .vm_mut()
- .eval("__childModuleDependencyFailureEvents.join('|')")?;
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "child module dependency failure terminal fanout",
- )
- .await;
- let mut followup_sources = Vec::new();
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childModuleDependencyFailureEvents.join('|')")?,
- "before:true|after:undefined",
- "dependency failure terminal fanout should not dispatch script error or iframe load inline"
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "child module dependency graph-failed dispatch",
- )
- .await,
- );
- let events_after_graph_failure = page_vm
- .vm_mut()
- .eval("__childModuleDependencyFailureEvents.join('|')")?;
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "child module dependency failure DOMContentLoaded transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "child module dependency failure complete transition",
- )
- .await,
- );
- followup_sources.push(
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::HostLoad,
- "child module dependency failure iframe load",
- )
- .await,
- );
- let final_events = page_vm
- .vm_mut()
- .eval("__childModuleDependencyFailureEvents.join('|')")?;
- assert_eq!(
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- None,
- "child module dependency failure sequence should not leave extra child frame task work"
- );
-
- Ok::<_, anyhow::Error>((
- dependency,
- events_after_dependency_completion,
- followup_sources,
- events_after_graph_failure,
- final_events,
- ))
- })
- .await
- .expect("page vm child module dependency failure test should run");
-
- assert!(matches!(
- dependency.action.source(),
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- ));
- assert_eq!(
- events_after_dependency_completion, "before:true|after:undefined",
- "dependency failure completion turn should not inline-dispatch script error"
- );
- assert_eq!(
- followup_sources,
- vec![
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- ChildFrameSemanticTurnKind::HostLoad
- ],
- "graph-failed dispatch, DOMContentLoaded, complete, and HostLoad must remain separate child turns after typed terminal fanout"
- );
- assert_eq!(
- events_after_graph_failure, "before:true|after:undefined|script-error",
- "graph-failed work should dispatch script error without iframe load"
- );
- assert_eq!(
- final_events, "before:true|after:undefined|script-error|frame-load",
- "HostLoad should dispatch iframe load only after dependency failure finalizes"
- );
-
- server
- .await
- .expect("child module dependency failure server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_modulepreload_terminal_event_does_not_delay_complete() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let page_vm = test_page_vm();
- let local_executor = page_vm.local_executor.clone();
-
- let (
- lifecycle_turns,
- events_before_preload_event,
- ready_state_before_preload_event,
- events_after_preload_event,
- ready_state_after_preload_event,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- page_vm.vm_mut().eval(
- r#"
-(() => {
- globalThis.__childModulepreloadTerminalEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childModulepreloadTerminalEvents.push("frame-load");
- frame.srcdoc = `
- <script>
- parent.__childModulepreloadTerminalEvents.push("before");
- document.addEventListener("DOMContentLoaded", () => {
- parent.__childModulepreloadTerminalEvents.push("dcl:" + document.readyState);
- });
- <\/script>
- <link rel="modulepreload" href="/invalid-modulepreload.bin" as="image" onerror="parent.__childModulepreloadTerminalEvents.push('preload-error')">
- <script>parent.__childModulepreloadTerminalEvents.push("after");<\/script>
- `;
- body.appendChild(frame);
-})()
-"#,
- )?;
-
- let mut lifecycle_turns = Vec::new();
- while let Some(source) = page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await
- {
- lifecycle_turns.push(source);
- }
-
- let events_before_preload_event = page_vm
- .vm_mut()
- .eval("__childModulepreloadTerminalEvents.join('|')")?;
- let ready_state_before_preload_event = page_vm.vm_mut().eval(
- "document.querySelector('iframe').contentDocument?.readyState || 'missing'",
- )?;
-
- assert!(
- page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ChildModulepreloadEventAction,
- &loader,
- )
- .await?,
- "the deliberately withheld modulepreload error action must remain queued"
- );
- let events_after_preload_event = page_vm
- .vm_mut()
- .eval("__childModulepreloadTerminalEvents.join('|')")?;
- let ready_state_after_preload_event = page_vm.vm_mut().eval(
- "document.querySelector('iframe').contentDocument?.readyState || 'missing'",
- )?;
-
- Ok::<_, anyhow::Error>((
- lifecycle_turns,
- events_before_preload_event,
- ready_state_before_preload_event,
- events_after_preload_event,
- ready_state_after_preload_event,
- ))
- })
- .await
- .expect("terminal child modulepreload lifecycle test should run");
-
- assert!(
- lifecycle_turns
- .iter()
- .filter(|source| **source == ChildFrameSemanticTurnKind::DocumentLifecycle)
- .count()
- >= 3,
- "interactive, DOMContentLoaded, and complete must advance while the terminal link event remains queued: {lifecycle_turns:?}"
- );
- assert!(
- lifecycle_turns.contains(&ChildFrameSemanticTurnKind::HostLoad),
- "iframe load must remain independently runnable while the terminal link event is withheld: {lifecycle_turns:?}"
- );
- assert_eq!(
- events_before_preload_event,
- "before|after|dcl:interactive|frame-load",
- "child complete and iframe load must not wait for the queued modulepreload error"
- );
- assert_eq!(
- ready_state_before_preload_event, "complete",
- "a terminal modulepreload event must not hold the child Document load gate"
- );
- assert_eq!(
- events_after_preload_event,
- "before|after|dcl:interactive|frame-load|preload-error",
- "the independently queued modulepreload event must still dispatch afterward"
- );
- assert_eq!(
- ready_state_after_preload_event, "complete",
- "post-complete modulepreload dispatch must not regress readyState"
- );
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_modulepreload_fetch_does_not_delay_iframe_load() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/standalone-preload.js",
- "HTTP/1.1 200 OK",
- "export const preloaded = true;".to_owned(),
- Duration::from_millis(100),
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let (owner_wake_tx, owner_wake_rx) = tokio::sync::mpsc::unbounded_channel();
- let owner_wake = crate::page_task_queue::RendererOwnerWakeSender::new(
- owner_wake_tx,
- crate::runtime::RendererPageToken::new_for_testing(crate::PageId::new_for_testing(2)),
- );
- let runtime_hooks =
- PageVmRuntimeHooks::standalone_with_owner_wake_without_owner_reservation_for_test(
- owner_wake,
- );
- let page_vm = test_page_vm_with_loader_document_url_and_hooks(
- &loader,
- Vec::new(),
- document_url,
- runtime_hooks,
- );
- let page_resource_queue = page_vm.page_resource_completion_queue();
- let local_executor = page_vm.local_executor.clone();
-
- let (
- typed_modulepreload_start_ran,
- startup_sources,
- events_before_completion,
- ready_state_before_completion,
- completion,
- events_after_preload_event,
- ready_state_after_preload_event,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let mut page_resource_queue = page_resource_queue;
- let mut owner_wake_rx = owner_wake_rx;
- let preload_url = format!("{base_url}/standalone-preload.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childStandaloneModulepreloadEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childStandaloneModulepreloadEvents.push("frame-load");
- frame.srcdoc = `
- <script>
- parent.__childStandaloneModulepreloadEvents.push("before");
- document.addEventListener("DOMContentLoaded", () => {{
- parent.__childStandaloneModulepreloadEvents.push("dcl:" + document.readyState);
- }});
- <\/script>
- <link rel="modulepreload" href="{preload_url}" onload="parent.__childStandaloneModulepreloadEvents.push('preload-load')" onerror="parent.__childStandaloneModulepreloadEvents.push('preload-error')">
- <script>parent.__childStandaloneModulepreloadEvents.push("after");<\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let mut typed_modulepreload_start_ran = false;
- let mut startup_sources = Vec::new();
- for _ in 0..10 {
- if page_resource_queue.has_ready_completion() {
- break;
- }
- if page_vm.page_task_executor_sources_for_test().modulepreload_start()
- .has_ready_task()
- {
- assert!(
- page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ModulepreloadStart,
- &loader,
- )
- .await?,
- "typed modulepreload start should enter the production selected dispatcher",
- );
-
- assert!(
- !typed_modulepreload_start_ran,
- "one parser-discovered link must publish one typed start"
- );
- typed_modulepreload_start_ran = true;
- continue;
- }
- let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
- break;
- };
- startup_sources.push(source);
- }
- if !page_resource_queue.has_ready_completion() {
- tokio::time::timeout(Duration::from_secs(2), async {
- while !page_resource_queue.has_ready_completion() {
- owner_wake_rx
- .recv()
- .await
- .expect("owner-attached modulepreload wake route should remain open");
- }
- })
- .await
- .expect("typed modulepreload completion should arrive before timeout");
- }
- let events_before_completion = page_vm
- .vm_mut()
- .eval("__childStandaloneModulepreloadEvents.join('|')")?;
- let ready_state_before_completion = page_vm.vm_mut().eval(
- "document.querySelector('iframe').contentDocument.readyState",
- )?;
-
- let activity_epoch_before_completion =
- page_vm.vm().subresource_activity_epoch();
- let completion = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_resource_queue)?
- .expect("typed modulepreload completion should consume one Page owner turn");
- assert_eq!(
- completion.action.document_effect,
- PageResourceCompletionDocumentEffect::AppliedToCurrentOwner
- );
- assert_eq!(
- completion.action.output_effect,
- PageResourceCompletionOutputEffect::CaptureRequired
- );
- assert!(
- page_vm.vm().subresource_activity_epoch()
- > activity_epoch_before_completion,
- "current modulepreload Network output must advance current Document activity"
- );
- assert!(
- !page_resource_queue.has_ready_completion(),
- "one modulepreload producer terminal must be consumed exactly once"
- );
- let (network_records, websocket_events, websocket_lifecycle_events) =
- split_network_output_items(page_vm.vm_mut().take_network_output());
- assert!(websocket_events.is_empty());
- assert!(websocket_lifecycle_events.is_empty());
- assert_eq!(network_records.len(), 1);
- assert!(network_records[0].frame_id().is_some());
- assert_eq!(network_records[0].document_url().as_str(), "about:srcdoc");
- assert_eq!(network_records[0].url().as_str(), preload_url);
- run_expected_child_modulepreload_event_action_for_test(
- &mut page_vm,
- &loader,
- "owner-scheduled child modulepreload event dispatch",
- )
- .await;
- let events_after_preload_event = page_vm
- .vm_mut()
- .eval("__childStandaloneModulepreloadEvents.join('|')")?;
- let ready_state_after_preload_event = page_vm.vm_mut().eval(
- "document.querySelector('iframe').contentDocument.readyState",
- )?;
-
- assert_eq!(
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- None,
- "owner-scheduled modulepreload sequence should not leave child frame work"
- );
-
- Ok::<_, anyhow::Error>((
- typed_modulepreload_start_ran,
- startup_sources,
- events_before_completion,
- ready_state_before_completion,
- completion,
- events_after_preload_event,
- ready_state_after_preload_event,
- ))
- })
- .await
- .expect("owner-scheduled child modulepreload lifecycle test should run");
-
- assert!(
- typed_modulepreload_start_ran,
- "parser-discovered modulepreload should start from its typed source: {startup_sources:?}"
- );
- assert!(
- startup_sources
- .iter()
- .filter(|source| **source == ChildFrameSemanticTurnKind::DocumentLifecycle)
- .count()
- >= 3,
- "interactive, DOMContentLoaded and complete should run while modulepreload fetch is pending: {startup_sources:?}"
- );
- assert!(startup_sources.contains(&ChildFrameSemanticTurnKind::HostLoad));
- assert_eq!(
- events_before_completion,
- "before|after|dcl:interactive|frame-load"
- );
- assert_eq!(
- ready_state_before_completion, "complete",
- "fetching modulepreload must not delay document complete or iframe load"
- );
- assert!(matches!(
- completion.action.source(),
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- ));
- assert_eq!(
- events_after_preload_event,
- "before|after|dcl:interactive|frame-load|preload-load",
- "a slow modulepreload link event may dispatch after iframe load"
- );
- assert_eq!(
- ready_state_after_preload_event, "complete",
- "post-complete modulepreload event dispatch must not regress readyState"
- );
-
- server
- .await
- .expect("standalone child modulepreload server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_modulepreload_fetch_runs_before_joined_module_root() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/preloaded-root.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childModulepreloadJoinEvents.push("module:" + (globalThis === self));
-globalThis.__childModulepreloadJoinValue = 551;
-"#
- .to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- startup_sources,
- events_before_completion,
- completion,
- events_after_preload_event,
- events_after_module_terminal,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let root_url = format!("{base_url}/preloaded-root.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childModulepreloadJoinEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childModulepreloadJoinEvents.push("frame-load");
- frame.srcdoc = `
- <script>parent.__childModulepreloadJoinEvents.push("before:" + (globalThis === self));<\/script>
- <link id="preload" rel="modulepreload" href="{root_url}" onload="parent.__childModulepreloadJoinEvents.push('preload-load')" onerror="parent.__childModulepreloadJoinEvents.push('preload-error')">
- <script id="external-module" type="module" src="{root_url}"><\/script>
- <script>
- document.getElementById("external-module").addEventListener("load", () => {{
- parent.__childModulepreloadJoinEvents.push("script-load");
- }});
- document.getElementById("external-module").addEventListener("error", () => {{
- parent.__childModulepreloadJoinEvents.push("script-error");
- }});
- parent.__childModulepreloadJoinEvents.push("after:" + String(globalThis.__childModulepreloadJoinValue));
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let startup_sources =
- drive_child_modulepreload_startup_until_resource_completion_ready(
- &mut page_vm,
- &loader,
- 8,
- )
- .await;
- let events_before_completion = page_vm
- .vm_mut()
- .eval("__childModulepreloadJoinEvents.join('|')")?;
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child modulepreload completion should arrive before timeout");
- assert!(
- arrived,
- "child modulepreload completion sender should remain open"
- );
- }
-
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
-
- run_expected_child_modulepreload_event_action_for_test(
- &mut page_vm,
- &loader,
- "child modulepreload event dispatch",
- )
- .await;
- let events_after_preload_event = page_vm
- .vm_mut()
- .eval("__childModulepreloadJoinEvents.join('|')")?;
-
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "same-URL modulepreload terminal fanout",
- )
- .await;
- let events_after_module_terminal = page_vm
- .vm_mut()
- .eval("__childModulepreloadJoinEvents.join('|')")?;
-
- let script_ready_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "same-URL modulepreload graph-ready execution",
- )
- .await;
- let events_after_script_ready = page_vm
- .vm_mut()
- .eval("__childModulepreloadJoinEvents.join('|')")?;
-
- let host_load_source = run_child_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "same-URL modulepreload iframe load",
- )
- .await;
- let final_events = page_vm
- .vm_mut()
- .eval("__childModulepreloadJoinEvents.join('|')")?;
-
- assert_eq!(
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- None,
- "same-URL modulepreload sequence should not leave extra child frame task work"
- );
-
- Ok::<_, anyhow::Error>((
- startup_sources,
- events_before_completion,
- completion,
- events_after_preload_event,
- events_after_module_terminal,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- final_events,
- ))
- })
- .await
- .expect("page vm child modulepreload joined root test should run");
-
- assert!(
- startup_sources.contains(&ChildModulepreloadStartupTurn::ChildSemanticTurn(
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- )),
- "child modulepreload startup should reach DocumentScriptReady without test drain: {startup_sources:?}"
- );
- let modulepreload_fetch_position = startup_sources
- .iter()
- .position(|turn| *turn == ChildModulepreloadStartupTurn::TypedModulepreloadStart)
- .expect("parser-discovered modulepreload should start a fetch before completion");
- let parser_root_position = startup_sources
- .iter()
- .position(|turn| {
- *turn
- == ChildModulepreloadStartupTurn::ChildSemanticTurn(
- ChildFrameSemanticTurnKind::ParserModuleRootStart,
- )
- })
- .expect("same-URL parser module root should still run and join the module map entry");
- assert!(
- modulepreload_fetch_position < parser_root_position,
- "parser-discovered modulepreload should start before same-URL parser module root joins it: {startup_sources:?}"
- );
- assert_eq!(
- events_before_completion, "before:true|after:undefined",
- "modulepreload fetch start should not execute module or dispatch link/frame events"
- );
- assert!(matches!(
- completion.action.source(),
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- ));
- assert_eq!(
- events_after_preload_event, "before:true|after:undefined|preload-load",
- "modulepreload link load should dispatch before module script execution"
- );
- assert_eq!(
- events_after_module_terminal, "before:true|after:undefined|preload-load",
- "ModuleScriptTerminal should not execute the joined module inline"
- );
- assert_eq!(
- script_ready_source,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "joined module graph-ready work should execute on DocumentScriptReady"
- );
- assert_eq!(
- events_after_script_ready,
- "before:true|after:undefined|preload-load|module:true|script-load",
- "DocumentScriptReady should execute the joined module without iframe load"
- );
- assert_eq!(
- host_load_source,
- ChildFrameSemanticTurnKind::HostLoad,
- "iframe load should remain a later HostLoad source"
- );
- assert_eq!(
- final_events,
- "before:true|after:undefined|preload-load|module:true|script-load|frame-load",
- "HostLoad should dispatch iframe load after joined modulepreload execution"
- );
-
- server
- .await
- .expect("child modulepreload joined root server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_modulepreload_failure_wakes_joined_root_before_host_load() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/preloaded-root.js",
- "HTTP/1.1 404 Not Found",
- "modulepreload missing".to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- startup_sources,
- events_before_completion,
- completion,
- events_after_preload_event,
- events_after_module_terminal,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let root_url = format!("{base_url}/preloaded-root.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childModulepreloadFailureEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childModulepreloadFailureEvents.push("frame-load");
- frame.srcdoc = `
- <script>parent.__childModulepreloadFailureEvents.push("before:" + (globalThis === self));<\/script>
- <link id="preload" rel="modulepreload" href="{root_url}" onload="parent.__childModulepreloadFailureEvents.push('preload-load')" onerror="parent.__childModulepreloadFailureEvents.push('preload-error')">
- <script id="external-module" type="module" src="{root_url}"><\/script>
- <script>
- document.getElementById("external-module").addEventListener("load", () => {{
- parent.__childModulepreloadFailureEvents.push("script-load");
- }});
- document.getElementById("external-module").addEventListener("error", () => {{
- parent.__childModulepreloadFailureEvents.push("script-error");
- }});
- parent.__childModulepreloadFailureEvents.push("after:" + String(globalThis.__childModulepreloadFailureValue));
- <\/script>
- `;
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let startup_sources =
- drive_child_modulepreload_startup_until_resource_completion_ready(
- &mut page_vm,
- &loader,
- 8,
- )
- .await;
- let events_before_completion = page_vm
- .vm_mut()
- .eval("__childModulepreloadFailureEvents.join('|')")?;
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child failed modulepreload completion should arrive before timeout");
- assert!(
- arrived,
- "child failed modulepreload completion sender should remain open"
- );
- }
-
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
-
- run_expected_child_modulepreload_event_action_for_test(
- &mut page_vm,
- &loader,
- "child failed modulepreload event dispatch",
- )
- .await;
- let events_after_preload_event = page_vm
- .vm_mut()
- .eval("__childModulepreloadFailureEvents.join('|')")?;
-
- run_expected_child_module_script_terminal_turn(
- &mut page_vm,
- "failed same-URL modulepreload terminal fanout",
- )
- .await;
- let events_after_module_terminal = page_vm
- .vm_mut()
- .eval("__childModulepreloadFailureEvents.join('|')")?;
-
- let script_ready_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "failed same-URL modulepreload graph-failed dispatch",
- )
- .await;
- let events_after_script_ready = page_vm
- .vm_mut()
- .eval("__childModulepreloadFailureEvents.join('|')")?;
-
- let host_load_source = run_child_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "failed same-URL modulepreload iframe load",
- )
- .await;
- let final_events = page_vm
- .vm_mut()
- .eval("__childModulepreloadFailureEvents.join('|')")?;
-
- assert_eq!(
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- None,
- "failed same-URL modulepreload sequence should not leave extra child frame task work"
- );
-
- Ok::<_, anyhow::Error>((
- startup_sources,
- events_before_completion,
- completion,
- events_after_preload_event,
- events_after_module_terminal,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- final_events,
- ))
- })
- .await
- .expect("page vm child failed modulepreload joined root test should run");
-
- assert!(
- startup_sources.contains(&ChildModulepreloadStartupTurn::ChildSemanticTurn(
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- )),
- "child failed modulepreload startup should reach DocumentScriptReady without test drain: {startup_sources:?}"
- );
- let modulepreload_fetch_position = startup_sources
- .iter()
- .position(|turn| *turn == ChildModulepreloadStartupTurn::TypedModulepreloadStart)
- .expect("parser-discovered modulepreload should start a fetch before failure");
- let parser_root_position = startup_sources
- .iter()
- .position(|turn| {
- *turn
- == ChildModulepreloadStartupTurn::ChildSemanticTurn(
- ChildFrameSemanticTurnKind::ParserModuleRootStart,
- )
- })
- .expect("same-URL parser module root should still run and join the failed module map entry");
- assert!(
- modulepreload_fetch_position < parser_root_position,
- "parser-discovered modulepreload should start before same-URL parser module root joins it: {startup_sources:?}"
- );
- assert_eq!(
- events_before_completion, "before:true|after:undefined",
- "modulepreload fetch start should not dispatch link/script/frame events before failure"
- );
- assert!(matches!(
- completion.action.source(),
- RendererOwnerResourceActivitySource::ModuleGraphFetch
- ));
- assert_eq!(
- events_after_preload_event, "before:true|after:undefined|preload-error",
- "modulepreload link error should dispatch before joined module script failure"
- );
- assert_eq!(
- events_after_module_terminal, "before:true|after:undefined|preload-error",
- "ModuleScriptTerminal should not dispatch the joined script error inline"
- );
- assert_eq!(
- script_ready_source,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "joined module graph-failed work should dispatch on DocumentScriptReady"
- );
- assert_eq!(
- events_after_script_ready, "before:true|after:undefined|preload-error|script-error",
- "DocumentScriptReady should dispatch the joined module script error without iframe load"
- );
- assert_eq!(
- host_load_source,
- ChildFrameSemanticTurnKind::HostLoad,
- "iframe load should remain a later HostLoad source after modulepreload failure"
- );
- assert_eq!(
- final_events, "before:true|after:undefined|preload-error|script-error|frame-load",
- "HostLoad should dispatch iframe load after joined modulepreload failure finalizes"
- );
-
- server
- .await
- .expect("child failed modulepreload joined root server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_document_completion_queues_document_script_ready_work() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-document.html",
- "HTTP/1.1 200 OK",
- r#"
-<!doctype html>
-<script>
-parent.__childDocumentLoadWaitEvents.push("child-script:" + (globalThis === self));
-globalThis.__childDocumentLoadWaitValue = 42;
-</script>
-"#
- .to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- first,
- first_events,
- realm_pending_after_first,
- host_load_pending_after_completion,
- first_followup_source,
- events_after_first_followup,
- lifecycle_ready_after_first_followup,
- interactive_source,
- host_load_source,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let child_url = format!("{base_url}/child-document.html");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childDocumentLoadWaitEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childDocumentLoadWaitEvents.push("frameload");
- frame.src = "{child_url}";
- body.appendChild(frame);
-}})()
-"#
- ))?;
- let startup_sources =
- drive_child_frame_task_sources_until_resource_completion_ready(
- &mut page_vm,
- 8,
- )
- .await;
- assert!(
- startup_sources.contains(&ChildFrameSemanticTurnKind::NavigationCommit),
- "external child document startup should begin from an explicit NavigationCommit source: {startup_sources:?}"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childDocumentLoadWaitEvents.join('|')")?,
- "",
- "child document script and frame load should wait for document completion"
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child document completion should arrive before timeout");
- assert!(
- arrived,
- "child document completion sender should remain open"
- );
- }
-
- let first = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let first_events = page_vm
- .vm_mut()
- .eval("__childDocumentLoadWaitEvents.join('|')")?;
- let realm_pending_after_first = page_vm
- .vm()
- .has_pending_child_frame_realm_materialization();
- run_expected_pending_child_realm_materialization_turn(
- &mut page_vm,
- "child document parser realm prerequisite",
- )?;
- let host_load_pending_after_completion = page_vm
- .has_ready_child_frame_semantic_turn_for_test(ChildFrameSemanticTurnKind::HostLoad);
-
- let first_followup_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "child document parser script execution",
- )
- .await;
- let events_after_first_followup = page_vm
- .vm_mut()
- .eval("__childDocumentLoadWaitEvents.join('|')")?;
- let lifecycle_ready_after_first_followup = page_vm
- .has_ready_child_frame_semantic_turn_for_test(
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- );
-
- let interactive_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "child document parser EOF interactive transition",
- )
- .await;
- let host_load_source = run_child_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "child document iframe load",
- )
- .await;
- let final_events = page_vm
- .vm_mut()
- .eval("__childDocumentLoadWaitEvents.join('|')")?;
- assert_eq!(
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- None,
- "child document completion sequence should not leave extra child frame task work"
- );
-
- Ok::<_, anyhow::Error>((
- first,
- first_events,
- realm_pending_after_first,
- host_load_pending_after_completion,
- first_followup_source,
- events_after_first_followup,
- lifecycle_ready_after_first_followup,
- interactive_source,
- host_load_source,
- final_events,
- ))
- })
- .await
- .expect("page vm child document deferred completion test should run");
-
- assert!(matches!(
- first.action.source(),
- RendererOwnerResourceActivitySource::ChildDocument
- ));
- assert_eq!(
- first_events, "",
- "child document completion turn should not inline-run child document script or frame load"
- );
- assert!(
- realm_pending_after_first,
- "child document completion must leave a typed realm prerequisite queued"
- );
- assert!(
- !host_load_pending_after_completion,
- "child document completion should not wake HostLoad while initial parser work is pending"
- );
- assert_eq!(
- first_followup_source,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "first child frame task turn should run document-script ready work"
- );
- assert_eq!(
- events_after_first_followup, "child-script:true",
- "first child frame task turn should run document-script ready work, not iframe load"
- );
- assert!(
- lifecycle_ready_after_first_followup,
- "document-script ready should make the later lifecycle turn runnable"
- );
- assert_eq!(
- interactive_source,
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- "parser EOF should become interactive before HostLoad"
- );
- assert_eq!(
- host_load_source,
- ChildFrameSemanticTurnKind::HostLoad,
- "iframe load should remain a later HostLoad source"
- );
- assert_eq!(
- final_events,
- "child-script:true|frameload",
- "explicit later HostLoad turn should dispatch iframe load"
- );
-
- server
- .await
- .expect("child document wait-path server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_document_ready_work_runs_one_item_per_turn() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![
- (
- "/child-a.html",
- "HTTP/1.1 200 OK",
- r#"
-<script>
-parent.__multiChildDocumentEvents.push("child-a-script:" + (globalThis === self));
-</script>
-"#
- .to_owned(),
- Duration::ZERO,
- ),
- (
- "/child-b.html",
- "HTTP/1.1 200 OK",
- r#"
-<script>
-parent.__multiChildDocumentEvents.push("child-b-script:" + (globalThis === self));
-</script>
-"#
- .to_owned(),
- Duration::ZERO,
- ),
- ])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let (owner_wake_tx, mut owner_wake_rx) = tokio::sync::mpsc::unbounded_channel();
- let owner_wake = crate::page_task_queue::RendererOwnerWakeSender::new(
- owner_wake_tx,
- crate::runtime::RendererPageToken::new_for_testing(PageId::new_for_testing(1)),
- );
- let runtime_hooks =
- PageVmRuntimeHooks::standalone_with_owner_wake_without_owner_reservation_for_test(
- owner_wake,
- );
- let page_vm = test_page_vm_with_loader_document_url_and_hooks(
- &loader,
- Vec::new(),
- document_url,
- runtime_hooks,
- );
- let mut page_resource_queue = page_vm.page_resource_completion_queue();
- let local_executor = page_vm.local_executor.clone();
-
- let (
- completion_sources,
- events_after_completions,
- first_script_ready_source,
- events_after_first_script_ready,
- second_script_ready_source,
- events_after_second_script_ready,
- lifecycle_ready_after_second_script,
- lifecycle_sources,
- first_host_load_source,
- events_after_first_host_load,
- second_host_load_source,
- final_events,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let child_a_url = format!("{base_url}/child-a.html");
- let child_b_url = format!("{base_url}/child-b.html");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__multiChildDocumentEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- for (const [name, url] of [["a", "{child_a_url}"], ["b", "{child_b_url}"]]) {{
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__multiChildDocumentEvents.push("frame-" + name + "-load");
- frame.src = url;
- body.appendChild(frame);
- }}
-}})()
-"#
- ))?;
- let startup_sources = vec![
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "first external child navigation start",
- )
- .await,
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "second external child navigation start",
- )
- .await,
- ];
- assert_eq!(
- startup_sources
- .iter()
- .filter(|source| **source == ChildFrameSemanticTurnKind::NavigationCommit)
- .count(),
- 2,
- "each child document startup should consume one NavigationCommit source: {startup_sources:?}"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__multiChildDocumentEvents.join('|')")?,
- "",
- "child documents should wait for external document completions"
- );
-
- let mut completion_sources = Vec::new();
- for label in ["first child document", "second child document"] {
- child_document_completion::wait_for_page_resource_completion(
- &mut page_resource_queue,
- &mut owner_wake_rx,
- label,
- )
- .await;
- let completion = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_resource_queue)?
- .expect("child document completion should consume one typed Page turn");
- completion_sources.push(completion.action.source);
- }
- for label in ["first child realm", "second child realm"] {
- run_expected_pending_child_realm_materialization_turn(
- &mut page_vm,
- label,
- )?;
- }
- let events_after_completions = page_vm
- .vm_mut()
- .eval("__multiChildDocumentEvents.join('|')")?;
-
- let first_script_ready_source =
- page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_first_script_ready = page_vm
- .vm_mut()
- .eval("__multiChildDocumentEvents.join('|')")?;
- let second_script_ready_source =
- page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_second_script_ready = page_vm
- .vm_mut()
- .eval("__multiChildDocumentEvents.join('|')")?;
- let lifecycle_ready_after_second_script = page_vm
- .has_ready_child_frame_semantic_turn_for_test(
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- );
- let lifecycle_sources = vec![
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- ];
- let first_host_load_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_first_host_load = page_vm
- .vm_mut()
- .eval("__multiChildDocumentEvents.join('|')")?;
-
- let second_host_load_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let final_events = page_vm
- .vm_mut()
- .eval("__multiChildDocumentEvents.join('|')")?;
- assert_eq!(
- page_vm.run_next_child_frame_task_source_for_semantic_test().await,
- None,
- "multi-child document completion sequence should not leave extra child frame task work"
- );
-
- Ok::<_, anyhow::Error>((
- completion_sources,
- events_after_completions,
- first_script_ready_source,
- events_after_first_script_ready,
- second_script_ready_source,
- events_after_second_script_ready,
- lifecycle_ready_after_second_script,
- lifecycle_sources,
- first_host_load_source,
- events_after_first_host_load,
- second_host_load_source,
- final_events,
- ))
- })
- .await
- .expect("page vm multi child document ready-work test should run");
-
- assert_eq!(
- completion_sources,
- vec![
- RendererOwnerResourceActivitySource::ChildDocument,
- RendererOwnerResourceActivitySource::ChildDocument,
- ]
- );
- assert_eq!(
- events_after_completions, "",
- "document completion turns should not inline-run either child document"
- );
- assert_eq!(
- first_script_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "first child frame task turn should run only one document-script ready item"
- );
- let first_turn_ran_a = events_after_first_script_ready.contains("child-a-script:true");
- let first_turn_ran_b = events_after_first_script_ready.contains("child-b-script:true");
- assert_ne!(
- first_turn_ran_a, first_turn_ran_b,
- "first document-script ready turn should run exactly one child script; events: {events_after_first_script_ready}"
- );
- assert_eq!(
- second_script_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "the stable child-frame family must preserve the already-enqueued second script ahead of lifecycle work produced by the first"
- );
- for expected in ["child-a-script:true", "child-b-script:true"] {
- assert!(
- events_after_second_script_ready.contains(expected),
- "second document-script ready turn should run both child scripts across two turns; events: {events_after_second_script_ready}"
- );
- }
- for unexpected in ["frame-a-load", "frame-b-load"] {
- assert!(
- !events_after_second_script_ready.contains(unexpected),
- "second document-script ready turn should still not dispatch iframe load inline; events: {events_after_second_script_ready}"
- );
- }
- assert!(
- lifecycle_ready_after_second_script,
- "both scripts should leave the oldest exact-Document lifecycle action at the family head"
- );
- assert_eq!(
- lifecycle_sources,
- vec![Some(ChildFrameSemanticTurnKind::DocumentLifecycle); 6],
- "interactive, DOMContentLoaded and complete must each consume one lifecycle turn per child"
- );
- assert_eq!(
- first_host_load_source,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "first iframe load should remain a later HostLoad source"
- );
- let first_host_load_dispatched_a =
- events_after_first_host_load.contains("frame-a-load");
- let first_host_load_dispatched_b =
- events_after_first_host_load.contains("frame-b-load");
- assert_ne!(
- first_host_load_dispatched_a,
- first_host_load_dispatched_b,
- "first HostLoad turn should dispatch exactly one iframe load; events: {events_after_first_host_load}"
- );
- assert_eq!(
- second_host_load_source,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "second iframe load should remain a separate HostLoad source"
- );
- for expected in [
- "child-a-script:true",
- "child-b-script:true",
- "frame-a-load",
- "frame-b-load",
- ] {
- assert!(
- final_events.contains(expected),
- "explicit script-ready and HostLoad turns should finish both child documents; final events: {final_events}"
- );
- }
-
- server
- .await
- .expect("multi child document wait-path server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_document_script_ready_leaves_complete_and_load_for_later_sources() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child.html",
- "HTTP/1.1 200 OK",
- r#"
-<script>
-parent.__childReadyHostLoadEvents.push("child-script:" + (globalThis === self));
-</script>
-"#
- .to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- bootstrap_source,
- completion_source,
- host_load_pending_after_completion,
- script_ready_source,
- events_after_script_ready,
- lifecycle_ready_after_script,
- interactive_source,
- host_load_source,
- events_after_host_load,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let child_url = format!("{base_url}/child.html");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childReadyHostLoadEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => globalThis.__childReadyHostLoadEvents.push("frame-load");
- frame.src = "{child_url}";
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let bootstrap_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__childReadyHostLoadEvents.join('|')")?,
- "",
- "NavigationCommit should start the child document load without dispatching load"
- );
-
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child document completion should arrive before timeout");
- assert!(arrived, "child document completion sender should remain open");
- }
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let completion_source = completion.action.source();
- let host_load_pending_after_completion = page_vm
- .has_ready_child_frame_semantic_turn_for_test(ChildFrameSemanticTurnKind::HostLoad);
- run_expected_pending_child_realm_materialization_turn(
- &mut page_vm,
- "child script-ready realm prerequisite",
- )?;
-
- let script_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_script_ready = page_vm
- .vm_mut()
- .eval("__childReadyHostLoadEvents.join('|')")?;
- let lifecycle_ready_after_script = page_vm
- .has_ready_child_frame_semantic_turn_for_test(
- ChildFrameSemanticTurnKind::DocumentLifecycle,
- );
-
- let interactive_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let host_load_source = Some(
- run_child_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "child document iframe load",
- )
- .await,
- );
- let events_after_host_load = page_vm
- .vm_mut()
- .eval("__childReadyHostLoadEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- bootstrap_source,
- completion_source,
- host_load_pending_after_completion,
- script_ready_source,
- events_after_script_ready,
- lifecycle_ready_after_script,
- interactive_source,
- host_load_source,
- events_after_host_load,
- ))
- })
- .await
- .expect("page vm child script-ready host-load boundary test should run");
-
- assert_eq!(
- bootstrap_source,
- Some(ChildFrameSemanticTurnKind::NavigationCommit),
- "bootstrap child frame turn should commit navigation before lifecycle delivery"
- );
- assert_eq!(
- completion_source,
- RendererOwnerResourceActivitySource::ChildDocument
- );
- assert!(
- !host_load_pending_after_completion,
- "child document completion should not leave HostLoad pending before document-script ready work runs"
- );
- assert_eq!(
- script_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "child document completion follow-up should run document-script ready work"
- );
- assert_eq!(
- events_after_script_ready, "child-script:true",
- "DocumentScriptReady should run the child script but not dispatch iframe load inline"
- );
- assert!(
- lifecycle_ready_after_script,
- "DocumentScriptReady should make the later lifecycle turn runnable"
- );
- assert_eq!(
- interactive_source,
- Some(ChildFrameSemanticTurnKind::DocumentLifecycle),
- "parser EOF should dispatch interactive before HostLoad"
- );
- assert_eq!(
- host_load_source,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "HostLoad should be the source that dispatches iframe load"
- );
- assert_eq!(
- events_after_host_load, "child-script:true|frame-load",
- "iframe load should dispatch only on the HostLoad turn"
- );
-
- server
- .await
- .expect("child document host-load boundary server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_resync_child_commits_navigation_before_document_script_ready() {
- let page_vm = test_page_vm();
- let local_executor = page_vm.local_executor.clone();
-
- let resync = run_on_page_vm_local_executor(local_executor, async move {
- let mut page_vm = page_vm;
- page_vm.vm_mut().eval_with_child_record_sync(
- r#"
-(() => {
- globalThis.__resyncReadyEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => __resyncReadyEvents.push("frame-load");
- frame.srcdoc = `<script>parent.__resyncReadyEvents.push("child-script:" + (globalThis === self));<\/script>`;
- body.appendChild(frame);
-})()
-"#,
- )?;
- let host_load_pending_after_resync = page_vm
- .has_ready_child_frame_semantic_turn_for_test(ChildFrameSemanticTurnKind::HostLoad);
-
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "resynced child navigation commit",
- )
- .await;
- run_expected_child_realm_materialization_for_wait(&mut page_vm, "resynced child realm")
- .await;
- let script_ready_source = page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await;
- let events_after_script_ready = page_vm.vm_mut().eval("__resyncReadyEvents.join('|')")?;
- let host_load_source = Some(
- run_child_interactive_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "resynced child iframe load",
- )
- .await,
- );
- let events_after_host_load = page_vm.vm_mut().eval("__resyncReadyEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- host_load_pending_after_resync,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- events_after_host_load,
- ))
- });
- let (
- host_load_pending_after_resync,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- events_after_host_load,
- ) = run_page_vm_async_test(resync)
- .await
- .expect("resync ready-work source test should run");
-
- assert!(
- !host_load_pending_after_resync,
- "ScriptVm resync should not wake HostLoad while parser-ready work is pending"
- );
- assert_eq!(
- script_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "ScriptVm resync should expose parser-ready work after the child navigation commits"
- );
- assert_eq!(
- events_after_script_ready, "child-script:true",
- "DocumentScriptReady should run the child script without dispatching iframe load"
- );
- assert_eq!(
- host_load_source,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "iframe load should remain a later HostLoad source"
- );
- assert_eq!(
- events_after_host_load, "child-script:true|frame-load",
- "HostLoad should dispatch iframe load after the script-ready turn"
- );
-}
-
-#[tokio::test]
-async fn page_vm_input_event_commits_child_navigation_before_document_script_ready() {
- let page_vm = test_page_vm();
- let local_executor = page_vm.local_executor.clone();
-
- let input = run_on_page_vm_local_executor(local_executor, async move {
- let mut page_vm = page_vm;
- page_vm.vm_mut().eval(
- r#"
-(() => {
- globalThis.__inputReadyEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const button = document.createElement("button");
- button.textContent = "create child";
- button.style.cssText = "display:block;width:100px;height:20px";
- button.addEventListener("click", () => {
- __inputReadyEvents.push("click");
- const frame = document.createElement("iframe");
- frame.onload = () => __inputReadyEvents.push("frame-load");
- frame.srcdoc = `<script>parent.__inputReadyEvents.push("child-script:" + (globalThis === self));<\/script>`;
- body.appendChild(frame);
- });
- body.appendChild(button);
-})()
-"#,
- )?;
-
- page_vm.vm_mut().publish_layout_for_test()?;
-
- let mouse_down_handled = page_vm
- .vm_mut()
- .dispatch_mouse_event_at_point(10.0, 10.0, "mousedown", 0, None, 0.0, 0.0)?
- .handled;
- let mouse_up_handled = page_vm
- .vm_mut()
- .dispatch_mouse_event_at_point(10.0, 10.0, "mouseup", 0, Some(0), 0.0, 0.0)?
- .handled;
- let events_after_click = page_vm.vm_mut().eval("__inputReadyEvents.join('|')")?;
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "input-created child navigation commit",
- )
- .await;
- run_expected_child_realm_materialization_for_wait(
- &mut page_vm,
- "input-created child realm",
- )
- .await;
- let script_ready_source = page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await;
- let events_after_script_ready = page_vm.vm_mut().eval("__inputReadyEvents.join('|')")?;
- let host_load_source = Some(
- run_child_interactive_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "input-created child iframe load",
- )
- .await,
- );
- let events_after_host_load = page_vm.vm_mut().eval("__inputReadyEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- mouse_down_handled,
- mouse_up_handled,
- events_after_click,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- events_after_host_load,
- ))
- });
- let (
- mouse_down_handled,
- mouse_up_handled,
- events_after_click,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- events_after_host_load,
- ) = run_page_vm_async_test(input)
- .await
- .expect("input ready-work source test should run");
-
- assert!(mouse_down_handled, "mousedown should hit the button");
- assert!(
- mouse_up_handled,
- "mouseup should hit the button and dispatch click"
- );
- assert_eq!(
- events_after_click, "click",
- "input click should create the child frame without running its parser script inline"
- );
- assert_eq!(
- script_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "input-created child parser work should follow its navigation commit"
- );
- assert_eq!(
- events_after_script_ready, "click|child-script:true",
- "child parser work should run on the later DocumentScriptReady turn"
- );
- assert_eq!(
- host_load_source,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "iframe load should remain a separate HostLoad turn after input dispatch"
- );
- assert_eq!(
- events_after_host_load, "click|child-script:true|frame-load",
- "iframe load should dispatch only on the HostLoad turn"
- );
-}
-
-#[tokio::test]
-async fn page_vm_message_port_event_commits_child_navigation_before_document_script_ready() {
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse("https://example.com/message-port-child-navigation").unwrap();
- let (page_vm, _resource_source, mut owner_wake_rx) =
- page_vm_with_bound_task_sources_and_owner_wake(&loader, document_url);
- let local_executor = page_vm.local_executor.clone();
- let selected_task_local_set = tokio::task::LocalSet::new();
-
- let (
- completion_sources,
- message_port_turns,
- events_after_message,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- events_after_host_load,
- ) = selected_task_local_set
- .run_until(local_executor.run(async move {
- let mut page_vm = page_vm;
- page_vm.vm_mut().eval(
- r#"
-(() => {
- globalThis.__messagePortReadyEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const workerSource = `
- onmessage = (event) => {
- if (event.data !== "connect") {
- return;
- }
- const port = event.ports[0];
- port.postMessage("go");
- };
- `;
- globalThis.__messagePortReadyWorker = new Worker(
- "data:text/javascript," + encodeURIComponent(workerSource)
- );
- globalThis.__messagePortReadyChannel = new MessageChannel();
- const channel = globalThis.__messagePortReadyChannel;
- channel.port1.onmessage = (event) => {
- __messagePortReadyEvents.push("message:" + event.data);
- const frame = document.createElement("iframe");
- frame.onload = () => __messagePortReadyEvents.push("frame-load");
- frame.srcdoc = `<script>parent.__messagePortReadyEvents.push("child-script:" + (globalThis === self));<\/script>`;
- body.appendChild(frame);
- };
- globalThis.__messagePortReadyWorker.postMessage("connect", [channel.port2]);
-})()
-"#,
- )?;
-
- let mut completion_sources = Vec::new();
- let mut message_port_turns = 0;
- let events_after_message = loop {
- if page_vm
- .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::DedicatedWorkerClientEvent,
- &loader,
- )
- .await?
- {
- completion_sources.push(RendererOwnerResourceActivitySource::Worker);
- } else if page_vm
- .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::MessagePortDelivery, &loader)
- .await?
- {
- message_port_turns += 1;
- } else if page_vm.has_ready_page_websocket_task_for_test() {
- let completion_source = page_vm
- .run_exact_page_websocket_selected_task_for_test().await?
- .expect("ready Worker completion should remain available");
- completion_sources.push(completion_source);
- } else {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- async {
- tokio::select! {
- wake = owner_wake_rx.recv() => wake.is_some(),
- arrived = page_vm.wait_for_page_websocket_task_for_test() => arrived,
- }
- },
- )
- .await
- .expect("MessagePort/worker completion should arrive before timeout");
- assert!(
- arrived,
- "Worker completion sender should remain open"
- );
- }
- let events = page_vm
- .vm_mut()
- .eval("__messagePortReadyEvents.join('|')")?;
- if events == "message:go" {
- break events;
- }
- assert!(
- completion_sources.len() + message_port_turns < 16,
- "MessagePort handler should run after bounded turns; sources: {completion_sources:?}, message_port_turns={message_port_turns}, events: {events}"
- );
- };
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "MessagePort-created child navigation commit",
- )
- .await;
- run_expected_child_realm_materialization_for_wait(
- &mut page_vm,
- "MessagePort-created child realm",
- )
- .await;
- let script_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_script_ready = page_vm
- .vm_mut()
- .eval("__messagePortReadyEvents.join('|')")?;
- let host_load_source = Some(
- run_child_interactive_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "MessagePort-created child iframe load",
- )
- .await,
- );
- let events_after_host_load = page_vm
- .vm_mut()
- .eval("__messagePortReadyEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- completion_sources,
- message_port_turns,
- events_after_message,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- events_after_host_load,
- ))
- }))
- .await
- .expect("MessagePort ready-work source test should run");
-
- assert_eq!(
- message_port_turns, 1,
- "one Worker reply should be consumed by one typed MessagePort turn; completion sources: {completion_sources:?}"
- );
- assert_eq!(
- events_after_message, "message:go",
- "MessagePort handler should create the child frame without running its parser script inline"
- );
- assert_eq!(
- script_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "MessagePort-created child parser work should follow its navigation commit"
- );
- assert_eq!(
- events_after_script_ready, "message:go|child-script:true",
- "child parser work should run on the later DocumentScriptReady turn"
- );
- assert_eq!(
- host_load_source,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "iframe load should remain a separate HostLoad turn after MessagePort dispatch"
- );
- assert_eq!(
- events_after_host_load, "message:go|child-script:true|frame-load",
- "iframe load should dispatch only on the HostLoad turn"
- );
-}
-
-#[tokio::test]
-async fn page_vm_broadcast_channel_commits_child_navigation_before_document_script_ready() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/broadcast-ready-worker.js",
- "HTTP/1.1 200 OK",
- r#"
-const sender = new BroadcastChannel("broadcast-ready-work");
-sender.postMessage("go");
-"#
- .to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let (page_vm, _typed_resource_source, mut owner_wake_rx) =
- page_vm_with_bound_task_sources_and_owner_wake(&loader, document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- completion_sources,
- events_after_broadcast,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- events_after_host_load,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let worker_url = format!("{base_url}/broadcast-ready-worker.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__broadcastReadyEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- globalThis.__broadcastReadyReceiver = new BroadcastChannel("broadcast-ready-work");
- __broadcastReadyReceiver.onmessage = (event) => {{
- __broadcastReadyEvents.push("message:" + event.data);
- const frame = document.createElement("iframe");
- frame.onload = () => __broadcastReadyEvents.push("frame-load");
- frame.srcdoc = `<script>parent.__broadcastReadyEvents.push("child-script:" + (globalThis === self));<\/script>`;
- body.appendChild(frame);
- }};
- globalThis.__broadcastReadyWorker = new Worker("{worker_url}");
-}})()
-"#
- ))?;
-
- let mut completion_sources = Vec::new();
- let events_after_broadcast = loop {
- if page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::DomManipulation(PageDomManipulationTestFamily::BroadcastChannel),
- &loader,
- )
- .await?
- {
- completion_sources
- .push(RendererOwnerResourceActivitySource::BroadcastChannel);
- let events = page_vm.vm_mut().eval("__broadcastReadyEvents.join('|')")?;
- if events == "message:go" {
- break events;
- }
- continue;
- }
- if page_vm
- .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::DedicatedWorkerClientEvent,
- &loader,
- )
- .await?
- {
- completion_sources.push(RendererOwnerResourceActivitySource::Worker);
- continue;
- }
- if !page_vm.has_ready_page_websocket_task_for_test() {
- let websocket_arrival = page_vm.wait_for_page_websocket_task_for_test();
- tokio::pin!(websocket_arrival);
- tokio::time::timeout(Duration::from_secs(2), async {
- tokio::select! {
- arrived = &mut websocket_arrival => {
- assert!(
- arrived,
- "BroadcastChannel/worker completion sender should remain open"
- );
- }
- wake = owner_wake_rx.recv() => {
- assert!(
- wake.is_some(),
- "typed BroadcastChannel owner wake sender should remain open"
- );
- }
- }
- })
- .await
- .expect("BroadcastChannel/worker work should arrive before timeout");
- continue;
- }
- let completion_source = page_vm
- .run_exact_page_websocket_selected_task_for_test().await?
- .expect("BroadcastChannel/worker completion should be ready");
- completion_sources.push(completion_source);
- let events = page_vm.vm_mut().eval("__broadcastReadyEvents.join('|')")?;
- if events == "message:go" {
- break events;
- }
- assert!(
- completion_sources.len() < 16,
- "BroadcastChannel handler should run after bounded completions; sources: {completion_sources:?}, events: {events}"
- );
- };
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "BroadcastChannel-created child navigation commit",
- )
- .await;
- run_expected_child_realm_materialization_for_wait(
- &mut page_vm,
- "BroadcastChannel-created child realm",
- )
- .await;
- let script_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_script_ready =
- page_vm.vm_mut().eval("__broadcastReadyEvents.join('|')")?;
- let host_load_source = Some(
- run_child_interactive_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "BroadcastChannel-created child iframe load",
- )
- .await,
- );
- let events_after_host_load =
- page_vm.vm_mut().eval("__broadcastReadyEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- completion_sources,
- events_after_broadcast,
- script_ready_source,
- events_after_script_ready,
- host_load_source,
- events_after_host_load,
- ))
- })
- .await
- .expect("BroadcastChannel ready-work source test should run");
-
- assert!(
- completion_sources.contains(&RendererOwnerResourceActivitySource::BroadcastChannel),
- "BroadcastChannel handler should be driven by a BroadcastChannel completion: {completion_sources:?}"
- );
- assert_eq!(
- events_after_broadcast, "message:go",
- "BroadcastChannel handler should create the child frame without running its parser script inline"
- );
- assert_eq!(
- script_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "BroadcastChannel-created child parser work should follow its navigation commit"
- );
- assert_eq!(
- events_after_script_ready, "message:go|child-script:true",
- "child parser work should run on the later DocumentScriptReady turn"
- );
- assert_eq!(
- host_load_source,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "iframe load should remain a separate HostLoad turn after BroadcastChannel dispatch"
- );
- assert_eq!(
- events_after_host_load, "message:go|child-script:true|frame-load",
- "iframe load should dispatch only on the HostLoad turn"
- );
-
- server
- .await
- .expect("BroadcastChannel ready-work worker server should finish");
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn page_vm_realm_materialization_created_ready_work_enters_document_script_ready_directly() {
- run_page_vm_async_test(async move {
- let mut page_vm = test_page_vm();
- page_vm.vm_mut().eval_with_child_record_sync(
- r#"
-(() => {
- globalThis.__realmMaterializationNestedEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.srcdoc = `
- <iframe srcdoc="&lt;script&gt;parent.parent.__realmMaterializationNestedEvents.push('nested-script:' + (globalThis === self));&lt;/script&gt;"></iframe>
- <script>parent.__realmMaterializationNestedEvents.push("outer-script:" + (globalThis === self));<\/script>
- `;
- body.appendChild(frame);
-})()
-"#,
- )?;
-
- for label in ["outer", "nested"] {
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- &format!("{label} child navigation commit"),
- )
- .await;
- }
- assert_eq!(
- page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "outer child parser work should run on the DocumentScriptReady source"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__realmMaterializationNestedEvents.join('|')")?,
- "outer-script:true",
- "outer DocumentScriptReady turn should not inline-run nested parser work"
- );
- assert_eq!(
- page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await,
- Some(ChildFrameSemanticTurnKind::RealmMaterialization),
- "nested child realm must be materialized in its own visible family turn"
- );
- assert_eq!(
- page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await,
- Some(ChildFrameSemanticTurnKind::DocumentLifecycle),
- "outer parser EOF should become interactive before nested document work"
- );
- assert_eq!(
- page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "ready work produced by child realm materialization should enter DocumentScriptReady directly"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__realmMaterializationNestedEvents.join('|')")?,
- "outer-script:true|nested-script:true",
- "nested parser work should run on the later DocumentScriptReady turn"
- );
- assert_eq!(
- page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await,
- Some(ChildFrameSemanticTurnKind::DocumentLifecycle),
- "outer DOMContentLoaded should remain a later FIFO turn after nested work already admitted by realm materialization"
- );
- Ok::<_, anyhow::Error>(())
- })
- .await
- .expect("realm materialization nested ready-work source test should run");
-}
-
-#[tokio::test]
-async fn child_dynamic_inline_script_runs_synchronously_without_document_script_ready_work() {
- let (immediate_events, settled_events, next_source) = run_page_vm_async_test(async move {
- let mut page_vm = test_page_vm();
- page_vm.vm_mut().eval(
- r#"
-(() => {
- globalThis.__childDynamicReadySourceEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => __childDynamicReadySourceEvents.push("frame-load");
- body.appendChild(frame);
- const script = document.createElement("script");
- script.textContent = `
- parent.__childDynamicReadySourceEvents.push(
- "dynamic:" + document.currentScript.tagName.toLowerCase()
- );
- `;
- frame.contentDocument.body.appendChild(script);
- __childDynamicReadySourceEvents.push("returned");
-})()
-"#,
- )?;
- let immediate_events = page_vm
- .vm_mut()
- .eval("__childDynamicReadySourceEvents.join('|')")?;
- run_expected_child_realm_materialization_for_wait(
- &mut page_vm,
- "dynamic child inline-script realm",
- )
- .await;
- let next_source = page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await;
- let settled_events = page_vm
- .vm_mut()
- .eval("__childDynamicReadySourceEvents.join('|')")?;
- Ok::<_, anyhow::Error>((immediate_events, settled_events, next_source))
- })
- .await
- .expect("child dynamic inline script source test should run");
-
- assert_eq!(
- immediate_events, "frame-load|dynamic:script|returned",
- "both initial about:blank load and dynamic inline execution are synchronous"
- );
- assert_eq!(settled_events, immediate_events);
- assert_eq!(
- next_source, None,
- "inline execution must leave no DocumentScriptReady or HostLoad task"
- );
-}
-
-#[tokio::test]
-async fn child_dynamic_external_classic_script_uses_child_resource_and_ready_owners() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-dynamic-classic.js",
- "HTTP/1.1 200 OK",
- r#"
-parent.__childDynamicExternalEvents.push("external:" + (globalThis === self));
-parent.__childDynamicExternalEvents.push("current:" + document.currentScript.id);
-"#
- .to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (events_before_completion, completion_source, ready_source, final_events) =
- local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let script_url = format!("{base_url}/child-dynamic-classic.js");
- page_vm.vm_mut().eval(
- r#"
-(() => {
- globalThis.__childDynamicExternalEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.id = "dynamic-external-frame";
- frame.onload = () => __childDynamicExternalEvents.push("frame-load");
- frame.srcdoc = "<!doctype html><html><head><title>child</title></head><body></body></html>";
- body.appendChild(frame);
-})()
-"#,
- )?;
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "dynamic external child navigation commit",
- )
- .await;
- run_expected_child_realm_materialization_for_wait(
- &mut page_vm,
- "dynamic external child realm",
- )
- .await;
- run_child_interactive_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "dynamic external child initial load",
- )
- .await;
-
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- const frame = document.getElementById("dynamic-external-frame");
- const script = frame.contentDocument.createElement("script");
- script.id = "dynamic-external";
- script.onload = () => __childDynamicExternalEvents.push("script-load");
- script.onerror = () => __childDynamicExternalEvents.push("script-error");
- script.src = "{script_url}";
- frame.contentDocument.body.appendChild(script);
-}})()
-"#,
- ))?;
- let events_before_completion = page_vm
- .vm_mut()
- .eval("__childDynamicExternalEvents.join('|')")?;
- if !page_vm
- .page_resource_completion_queue()
- .has_ready_completion()
- {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child dynamic external completion should arrive before timeout");
- assert!(
- arrived,
- "child dynamic external completion sender should remain open"
- );
- }
- let completion = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let completion_source = completion.action.source();
- let ready_source =
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "child dynamic external classic execution",
- )
- .await;
- let final_events = page_vm
- .vm_mut()
- .eval("__childDynamicExternalEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- events_before_completion,
- completion_source,
- ready_source,
- final_events,
- ))
- })
- .await
- .expect("child dynamic external script test should run");
-
- assert_eq!(
- events_before_completion, "frame-load",
- "external script fetch and execution must not run inline with insertion"
- );
- assert_eq!(
- completion_source,
- RendererOwnerResourceActivitySource::ChildClassicScript,
- "the child classic resource owner should publish the network terminal"
- );
- assert_eq!(
- ready_source,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "the loaded external classic script should execute on the child ready source"
- );
- assert_eq!(
- final_events, "frame-load|external:true|current:dynamic-external|script-load",
- "the current child realm should execute once and dispatch load on its script element"
- );
-
- server
- .await
- .expect("child dynamic external script server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn child_document_write_nested_external_classic_blocks_domcontentloaded() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-written-classic.js",
- "HTTP/1.1 200 OK",
- "parent.__childWrittenEvents.push('external');".to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (events_after_outer, source_load_source, events_after_external, final_events) =
- local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let script_url = format!("{base_url}/child-written-classic.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childWrittenEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.onload = () => __childWrittenEvents.push("load");
- frame.srcdoc = `<script>
- parent.__childWrittenEvents.push("outer");
- document.write("<script>parent.__childWrittenEvents.push('nested');<\\/script>");
- document.write("<script src='{script_url}'><\\/script>");
- document.addEventListener("DOMContentLoaded", () => parent.__childWrittenEvents.push("dcl"));
- <\/script>`;
- body.appendChild(frame);
-}})()
-"#,
- ))?;
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "nested document.write child navigation commit",
- )
- .await;
- run_expected_child_realm_materialization_for_wait(
- &mut page_vm,
- "nested document.write child realm",
- )
- .await;
- assert_eq!(
- page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "outer parser script should run before its written external source starts"
- );
- let events_after_outer =
- page_vm.vm_mut().eval("__childWrittenEvents.join('|')")?;
- let source_load_source = page_vm
- .run_next_child_frame_task_source_for_semantic_test()
- .await;
- if !page_vm
- .page_resource_completion_queue()
- .has_ready_completion()
- {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("written external completion should arrive before timeout");
- assert!(
- arrived,
- "written external completion sender should remain open"
- );
- }
- let _ = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "written external classic execution",
- )
- .await;
- let events_after_external =
- page_vm.vm_mut().eval("__childWrittenEvents.join('|')")?;
- run_child_interactive_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "nested document.write child load",
- )
- .await;
- let final_events = page_vm.vm_mut().eval("__childWrittenEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- events_after_outer,
- source_load_source,
- events_after_external,
- final_events,
- ))
- })
- .await
- .expect("nested child document.write test should run");
-
- assert_eq!(events_after_outer, "outer|nested");
- assert_eq!(
- source_load_source,
- Some(ChildFrameSemanticTurnKind::ClassicScriptSourceLoad),
- "the written external script should start before the parser resumes"
- );
- assert_eq!(events_after_external, "outer|nested|external");
- assert_eq!(final_events, "outer|nested|external|dcl|load");
-
- server
- .await
- .expect("nested child document.write server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn child_document_close_defers_while_written_external_classic_blocks_parser() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-close-blocker.js",
- "HTTP/1.1 200 OK",
- "parent.__childCloseEvents.push('external:' + Boolean(document.getElementById('after-blocker')));"
- .to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- events_after_close,
- source_load_source,
- events_after_external,
- final_events,
- tail_exists,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- page_vm.vm_mut().eval(
- r#"
-(() => {
- globalThis.__childCloseEvents = [];
- const frame = document.createElement("iframe");
- frame.id = "child-close-frame";
- document.body.appendChild(frame);
-})()
-"#,
- )?;
- materialize_child_realm_through_page_turn_for_test(
- &mut page_vm,
- "child-close-frame",
- )?;
-
- let script_url = format!("{base_url}/child-close-blocker.js");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- const frame = document.getElementById("child-close-frame");
- frame.onload = () => __childCloseEvents.push("load");
- const childDocument = frame.contentDocument;
- childDocument.open();
- childDocument.addEventListener("DOMContentLoaded", () => __childCloseEvents.push("dcl"));
- childDocument.write(`<script src="{script_url}"><\/script><main id="after-blocker">tail</main>`);
- childDocument.close();
- __childCloseEvents.push("after-close");
-}})()
-"#,
- ))?;
- let events_after_close = page_vm.vm_mut().eval("__childCloseEvents.join('|')")?;
- let source_load_source =
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::ClassicScriptSourceLoad,
- "document.close delayed external classic source load",
- )
- .await;
- if !page_vm
- .page_resource_completion_queue()
- .has_ready_completion()
- {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child close blocker completion should arrive before timeout");
- assert!(
- arrived,
- "child close blocker completion sender should remain open"
- );
- }
- let _ = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "document.close delayed external classic execution",
- )
- .await;
- let events_after_external =
- page_vm.vm_mut().eval("__childCloseEvents.join('|')")?;
- run_child_interactive_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "document.close delayed child load",
- )
- .await;
- let final_events = page_vm.vm_mut().eval("__childCloseEvents.join('|')")?;
- let tail_exists = page_vm.vm_mut().eval(
- "String(Boolean(document.getElementById('child-close-frame').contentDocument.getElementById('after-blocker')))",
- )?;
-
- Ok::<_, anyhow::Error>((
- events_after_close,
- source_load_source,
- events_after_external,
- final_events,
- tail_exists,
- ))
- })
- .await
- .expect("child document.close delayed EOF test should run");
-
- assert_eq!(
- events_after_close, "after-close",
- "document.close() should return without executing or bypassing the blocker"
- );
- assert_eq!(
- source_load_source,
- ChildFrameSemanticTurnKind::ClassicScriptSourceLoad
- );
- assert_eq!(
- events_after_external, "after-close|external:false",
- "the external parser-blocking script must run before future markup is parsed"
- );
- assert_eq!(final_events, "after-close|external:false|dcl|load");
- assert_eq!(tail_exists, "true");
-
- server
- .await
- .expect("child close blocker server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_nested_frame_finish_releases_parent_document_lifecycle() {
- run_page_vm_async_test(async move {
- let mut page_vm = test_page_vm();
- page_vm.vm_mut().eval(
- r#"
-(() => {
- globalThis.__nestedLifecycleEvents = [];
- const outer = document.createElement("iframe");
- outer.onload = () => __nestedLifecycleEvents.push("outer-load");
- outer.srcdoc = `<!doctype html><body><script>
- parent.__nestedLifecycleEvents.push("outer-script");
- const nested = document.createElement("iframe");
- nested.onload = () => parent.parent.__nestedLifecycleEvents.push("nested-load");
- nested.srcdoc = \`<!doctype html><script>parent.parent.__nestedLifecycleEvents.push("nested-script")<\\/script>\`;
- document.body.appendChild(nested);
- <\/script></body>`;
- document.body.appendChild(outer);
-})()
-"#,
- )?;
-
- let mut turns = Vec::new();
- for _ in 0..32 {
- let Some(source) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
- break;
- };
- let events = page_vm
- .vm_mut()
- .eval("__nestedLifecycleEvents.join('|')")?;
- let outer_loaded = events.contains("outer-load");
- turns.push((source, events));
- if outer_loaded {
- break;
- }
- }
-
- let nested_load_turn = turns
- .iter()
- .position(|(_, events)| events.contains("nested-load"))
- .expect("nested frame should finish");
- let outer_load_turn = turns
- .iter()
- .position(|(_, events)| events.contains("outer-load"))
- .expect("parent frame should finish after its descendant");
- assert_eq!(turns[nested_load_turn].0, ChildFrameSemanticTurnKind::HostLoad);
- assert_eq!(turns[outer_load_turn].0, ChildFrameSemanticTurnKind::HostLoad);
- assert!(
- nested_load_turn < outer_load_turn,
- "parent load must remain blocked until the exact descendant frame finishes: {turns:?}"
- );
- assert!(
- !turns[nested_load_turn].1.contains("outer-load"),
- "descendant HostLoad must only enqueue the parent lifecycle wake: {turns:?}"
- );
- assert!(
- turns[nested_load_turn + 1..outer_load_turn]
- .iter()
- .any(|(source, _)| *source == ChildFrameSemanticTurnKind::DocumentLifecycle),
- "parent complete must be a later DocumentLifecycle turn before its HostLoad: {turns:?}"
- );
- assert_eq!(
- turns[outer_load_turn].1,
- "outer-script|nested-script|nested-load|outer-load"
- );
- Ok::<_, anyhow::Error>(())
- })
- .await
- .expect("nested lifecycle source-turn proof should run");
-}
-
-#[tokio::test]
-async fn page_vm_host_load_commits_nested_navigation_before_document_script_ready() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-load-creates-nested.html",
- "HTTP/1.1 200 OK",
- r#"
-<script>
-parent.__hostLoadNestedEvents.push("child-script");
-onload = () => {
- parent.__hostLoadNestedEvents.push("child-load");
- const nested = document.createElement("iframe");
- nested.onload = () => parent.__hostLoadNestedEvents.push("nested-load");
- nested.srcdoc = `<script>parent.parent.__hostLoadNestedEvents.push("nested-script:" + (globalThis === self));<\/script>`;
- document.body.appendChild(nested);
-};
-</script>
-"#
- .to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let local_executor = page_vm.local_executor.clone();
-
- let (
- bootstrap_source,
- completion_source,
- host_load_pending_after_completion,
- script_ready_source,
- events_after_script_ready,
- interactive_source,
- host_load_source,
- events_after_host_load,
- nested_script_ready_source,
- events_after_nested_script_ready,
- nested_interactive_source,
- nested_host_load_source,
- events_after_nested_host_load,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let child_url = format!("{base_url}/child-load-creates-nested.html");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__hostLoadNestedEvents = [];
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.src = "{child_url}";
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let bootstrap_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child document completion should arrive before timeout");
- assert!(arrived, "child document completion sender should remain open");
- }
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let completion_source = completion.action.source();
- let host_load_pending_after_completion = page_vm
- .has_ready_child_frame_semantic_turn_for_test(ChildFrameSemanticTurnKind::HostLoad);
- run_expected_pending_child_realm_materialization_turn(
- &mut page_vm,
- "child host-load realm prerequisite",
- )?;
-
- let script_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_script_ready = page_vm
- .vm_mut()
- .eval("__hostLoadNestedEvents.join('|')")?;
- let interactive_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let host_load_source = Some(
- run_child_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "child window load",
- )
- .await,
- );
- let events_after_host_load = page_vm
- .vm_mut()
- .eval("__hostLoadNestedEvents.join('|')")?;
- run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "nested child navigation created during HostLoad",
- )
- .await;
- run_expected_pending_child_realm_materialization_turn(
- &mut page_vm,
- "nested child realm prerequisite",
- )?;
- let nested_script_ready_source =
- page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_nested_script_ready = page_vm
- .vm_mut()
- .eval("__hostLoadNestedEvents.join('|')")?;
- let nested_interactive_source =
- page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let nested_host_load_source = Some(
- run_child_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "nested child iframe load",
- )
- .await,
- );
- let events_after_nested_host_load = page_vm
- .vm_mut()
- .eval("__hostLoadNestedEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- bootstrap_source,
- completion_source,
- host_load_pending_after_completion,
- script_ready_source,
- events_after_script_ready,
- interactive_source,
- host_load_source,
- events_after_host_load,
- nested_script_ready_source,
- events_after_nested_script_ready,
- nested_interactive_source,
- nested_host_load_source,
- events_after_nested_host_load,
- ))
- })
- .await
- .expect("host-load nested ready-work source test should run");
-
- assert_eq!(
- bootstrap_source,
- Some(ChildFrameSemanticTurnKind::NavigationCommit),
- "bootstrap child frame turn should commit navigation before lifecycle delivery"
- );
- assert_eq!(
- completion_source,
- RendererOwnerResourceActivitySource::ChildDocument
- );
- assert!(
- !host_load_pending_after_completion,
- "child document completion should not leave HostLoad pending before document-script ready work runs"
- );
- assert_eq!(
- script_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "child document completion follow-up should run document-script ready work"
- );
- assert_eq!(events_after_script_ready, "child-script");
- assert_eq!(
- interactive_source,
- Some(ChildFrameSemanticTurnKind::DocumentLifecycle),
- "child parser EOF should become interactive before window load"
- );
- assert_eq!(
- host_load_source,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "child window load should dispatch on HostLoad"
- );
- assert_eq!(
- events_after_host_load, "child-script|child-load",
- "HostLoad should create the nested frame without running its script inline"
- );
- assert_eq!(
- nested_script_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady),
- "nested parser work created during HostLoad should follow its navigation commit"
- );
- assert_eq!(
- events_after_nested_script_ready, "child-script|child-load|nested-script:true",
- "nested script should run on the later DocumentScriptReady turn"
- );
- assert_eq!(
- nested_interactive_source,
- Some(ChildFrameSemanticTurnKind::DocumentLifecycle),
- "nested parser EOF should become interactive before nested HostLoad"
- );
- assert_eq!(
- nested_host_load_source,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "nested iframe load should still remain a separate HostLoad turn"
- );
- assert_eq!(
- events_after_nested_host_load,
- "child-script|child-load|nested-script:true|nested-load"
- );
-
- server
- .await
- .expect("host-load nested ready-work server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn page_vm_child_window_load_navigation_uses_navigation_commit_followup() {
- run_page_vm_async_test(async move {
- let (base_url, server) = spawn_path_response_http_server(vec![(
- "/child-load-navigate.html",
- "HTTP/1.1 200 OK",
- r#"
-<script>
-parent.__childLoadNavigationEvents.push("child-script");
-const clickOrder = [];
-addEventListener("click", event => {
- clickOrder.push("before");
- onclick = () => {
- clickOrder.push("property");
- return false;
- };
- event.stopPropagation();
-});
-onclick = () => clickOrder.push("stale");
-addEventListener("click", () => clickOrder.push("after"));
-const clickDispatchResult = document.dispatchEvent(new Event("click", {
- bubbles: true,
- cancelable: true
-}));
-parent.__childLoadNavigationEvents.push("click:" + clickOrder.join(",") + ":" + clickDispatchResult);
-onerror = function(message, source, line, column, error, extra) {
- parent.__childLoadNavigationEvents.push([
- "child-error",
- arguments.length,
- message,
- source.endsWith("child-load-navigate.html"),
- line > 0,
- column > 0,
- error && error.message,
- extra === undefined
- ].join(":"));
- return true;
-};
-const marker = new Error("child-error-marker");
-const errorDispatchResult = dispatchEvent(new ErrorEvent("error", {
- cancelable: true,
- message: marker.message,
- filename: location.href,
- lineno: 7,
- colno: 9,
- error: marker
-}));
-parent.__childLoadNavigationEvents.push("error-dispatch:" + errorDispatchResult);
-addEventListener("load", () => parent.__childLoadNavigationEvents.push("load-listener-before"));
-onload = () => {
- parent.__childLoadNavigationEvents.push("child-load");
- location.href = "data:text/html,<!doctype html><script>parent.postMessage('can navigate', '*')<\/script>";
-};
-addEventListener("load", () => parent.__childLoadNavigationEvents.push("load-listener-after"));
-</script>
-"#
- .to_owned(),
- Duration::ZERO,
- )])
- .await;
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
- let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
- let loader_for_task = loader.clone();
- let local_executor = page_vm.local_executor.clone();
-
- let (
- bootstrap_source,
- completion_source,
- script_ready_source,
- events_after_script_ready,
- interactive_source,
- host_load_source,
- events_after_host_load,
- pending_after_host_load,
- navigation_commit_source,
- events_after_navigation_commit,
- navigation_script_ready_source,
- events_after_navigation_script_ready,
- message_ready_after_navigation_script,
- message_endpoints_after_navigation_script,
- events_after_window_message,
- ) = local_executor
- .run(async move {
- let mut page_vm = page_vm;
- let child_url = format!("{base_url}/child-load-navigate.html");
- page_vm.vm_mut().eval(&format!(
- r#"
-(() => {{
- globalThis.__childLoadNavigationEvents = [];
- addEventListener("message", event => __childLoadNavigationEvents.push(event.data));
- const root = document.documentElement || document.appendChild(document.createElement("html"));
- const body = document.body || root.appendChild(document.createElement("body"));
- const frame = document.createElement("iframe");
- frame.src = "{child_url}";
- body.appendChild(frame);
-}})()
-"#
- ))?;
-
- let bootstrap_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- if !page_vm.page_resource_completion_queue().has_ready_completion() {
- let arrived = tokio::time::timeout(
- Duration::from_secs(2),
- wait_for_typed_page_resource_completion(&mut page_vm),
- )
- .await
- .expect("child document completion should arrive before timeout");
- assert!(arrived, "child document completion sender should remain open");
- }
- let completion =
- run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
- let completion_source = completion.action.source();
- run_expected_pending_child_realm_materialization_turn(
- &mut page_vm,
- "child window-load realm prerequisite",
- )?;
-
- let script_ready_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let events_after_script_ready = page_vm
- .vm_mut()
- .eval("__childLoadNavigationEvents.join('|')")?;
-
- let interactive_source = page_vm.run_next_child_frame_task_source_for_semantic_test().await;
- let host_load_source = Some(
- run_child_domcontentloaded_then_host_load_for_wait(
- &mut page_vm,
- "child window-load navigation initial load",
- )
- .await,
- );
- let events_after_host_load = page_vm
- .vm_mut()
- .eval("__childLoadNavigationEvents.join('|')")?;
- let pending_after_host_load = page_vm
- .vm()
- .has_pending_child_navigation_commit_for_test();
- let navigation_commit_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "child window load navigation commit",
- )
- .await;
- let events_after_navigation_commit = page_vm
- .vm_mut()
- .eval("__childLoadNavigationEvents.join('|')")?;
- run_expected_pending_child_realm_materialization_turn(
- &mut page_vm,
- "child window-load navigation realm prerequisite",
- )?;
- let navigation_script_ready_source = run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
- &mut page_vm,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "child window load navigation script",
- )
- .await;
- let events_after_navigation_script_ready = page_vm
- .vm_mut()
- .eval("__childLoadNavigationEvents.join('|')")?;
- let message_endpoints_after_navigation_script =
- page_vm.vm().pending_window_message_endpoints_for_test();
- let message_ready_after_navigation_script = page_vm
- .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::WindowMessage, &loader_for_task)
- .await?;
- let events_after_window_message = page_vm
- .vm_mut()
- .eval("__childLoadNavigationEvents.join('|')")?;
-
- Ok::<_, anyhow::Error>((
- bootstrap_source,
- completion_source,
- script_ready_source,
- events_after_script_ready,
- interactive_source,
- host_load_source,
- events_after_host_load,
- pending_after_host_load,
- navigation_commit_source,
- events_after_navigation_commit,
- navigation_script_ready_source,
- events_after_navigation_script_ready,
- message_ready_after_navigation_script,
- message_endpoints_after_navigation_script,
- events_after_window_message,
- ))
- })
- .await
- .expect("child load navigation host-load follow-up test should run");
-
- assert_eq!(
- bootstrap_source,
- Some(ChildFrameSemanticTurnKind::NavigationCommit),
- "bootstrap child frame turn should commit navigation before lifecycle delivery"
- );
- assert_eq!(
- completion_source,
- RendererOwnerResourceActivitySource::ChildDocument
- );
- assert_eq!(
- script_ready_source,
- Some(ChildFrameSemanticTurnKind::DocumentScriptReady)
- );
- assert_eq!(
- events_after_script_ready,
- "child-script|click:before,property,after:false|child-error:5:child-error-marker:true:true:true:child-error-marker:true|error-dispatch:false",
- "DocumentScriptReady should not dispatch child window load inline"
- );
- assert_eq!(
- interactive_source,
- Some(ChildFrameSemanticTurnKind::DocumentLifecycle),
- "child document should become interactive before its window load"
- );
- assert_eq!(
- host_load_source,
- Some(ChildFrameSemanticTurnKind::HostLoad),
- "child window load should dispatch on a HostLoad turn"
- );
- assert_eq!(
- events_after_host_load,
- "child-script|click:before,property,after:false|child-error:5:child-error-marker:true:true:true:child-error-marker:true|error-dispatch:false|load-listener-before|child-load|load-listener-after",
- "HostLoad should invoke one registration-ordered child window load dispatch without finishing navigation inline"
- );
- assert!(
- pending_after_host_load,
- "child window load navigation should leave follow-up child frame work"
- );
- assert_eq!(
- navigation_commit_source,
- ChildFrameSemanticTurnKind::NavigationCommit,
- "navigation queued by child window load should commit through NavigationCommit"
- );
- assert_eq!(
- events_after_navigation_commit,
- "child-script|click:before,property,after:false|child-error:5:child-error-marker:true:true:true:child-error-marker:true|error-dispatch:false|load-listener-before|child-load|load-listener-after",
- "NavigationCommit should not deliver the child postMessage inline"
- );
- assert_eq!(
- navigation_script_ready_source,
- ChildFrameSemanticTurnKind::DocumentScriptReady,
- "data-url navigation script should run from DocumentScriptReady"
- );
- assert_eq!(
- events_after_navigation_script_ready,
- "child-script|click:before,property,after:false|child-error:5:child-error-marker:true:true:true:child-error-marker:true|error-dispatch:false|load-listener-before|child-load|load-listener-after",
- "navigation script should queue a parent window-message task without delivering it inline"
- );
- assert!(
- message_ready_after_navigation_script,
- "child navigation script should queue a ready parent window-message task"
- );
- assert_eq!(
- message_endpoints_after_navigation_script.len(),
- 1,
- "child navigation script should queue exactly one window-message task: {message_endpoints_after_navigation_script:?}"
- );
- assert!(
- matches!(
- message_endpoints_after_navigation_script.as_slice(),
- [(
- PendingWindowMessageEndpoint::TopWindow,
- PendingWindowMessageEndpoint::ChildWindow(_)
- )]
- ),
- "child navigation script should target the top window from the child: {message_endpoints_after_navigation_script:?}"
- );
- assert_eq!(
- events_after_window_message,
- "child-script|click:before,property,after:false|child-error:5:child-error-marker:true:true:true:child-error-marker:true|error-dispatch:false|load-listener-before|child-load|load-listener-after|can navigate",
- "advancing the ready window-message task should deliver the child navigation postMessage"
- );
-
- server
- .await
- .expect("child load navigation host-load follow-up server should finish");
- })
- .await;
-}
-
-#[tokio::test]
-async fn stream_declared_controller_and_writer_surface_ignores_reflection_and_spoofing() {
- run_page_vm_async_test(async move {
- let mut page_vm = test_page_vm();
- let local_executor = page_vm.local_executor.clone();
-
- let result = local_executor
- .run(async move {
- page_vm.vm_mut().eval(
- r#"
- (() => {
- const methodShape = (object, name) => {
- const descriptor = Object.getOwnPropertyDescriptor(
- Object.getPrototypeOf(object),
- name
- );
- return [
- !!descriptor,
- descriptor && descriptor.enumerable,
- descriptor && descriptor.configurable,
- descriptor && descriptor.writable,
- descriptor && typeof descriptor.value,
- descriptor && descriptor.value.length,
- descriptor && descriptor.value.name
- ].join(":");
- };
- const accessorShape = (object, name) => {
- const descriptor = Object.getOwnPropertyDescriptor(
- Object.getPrototypeOf(object),
- name
- );
- return [
- !!descriptor,
- descriptor && descriptor.enumerable,
- descriptor && descriptor.configurable,
- descriptor && ("writable" in descriptor),
- descriptor && typeof descriptor.get,
- descriptor && descriptor.get.name,
- descriptor && descriptor.get.length,
- descriptor && typeof descriptor.set
- ].join(":");
- };
- const internals = [
- "__moliStreamControllerStream",
- "__moliWritableStreamWriterStream"
- ];
- const reflectedInternals = object => Object.getOwnPropertyNames(object)
- .filter(name => internals.includes(name))
- .join(",");
- const throwsTypeError = callback => {
- try {
- callback();
- return "no-throw";
- } catch (error) {
- return `throw:${error.name}`;
- }
- };
-
- let readableController;
- const readable = new ReadableStream({
- start(controller) {
- readableController = controller;
- }
- }, { highWaterMark: 2 });
- if (!readableController) {
- throw new Error("ReadableStream start controller was not captured");
- }
- const readableReflectedBefore = reflectedInternals(readableController);
- const readableDesiredGetter =
- Object.getOwnPropertyDescriptor(
- Object.getPrototypeOf(readableController),
- "desiredSize"
- ).get;
- const readableBefore = readableController.desiredSize;
- readableController.enqueue("one");
- const readableAfter = readableController.desiredSize;
- const readableFake = throwsTypeError(() => readableDesiredGetter.call({
- __moliStreamControllerStream: readable
- }));
- readableController.__moliStreamControllerStream = new ReadableStream(
- {},
- { highWaterMark: 99 }
- );
- const readableSpoofed = readableController.desiredSize;
-
- let transformController;
- const transform = new TransformStream({
- start(controller) {
- transformController = controller;
- }
- }, undefined, { highWaterMark: 3 });
- if (!transformController) {
- throw new Error("TransformStream transform controller was not captured");
- }
- transformController.enqueue("chunk");
- const transformReflectedBefore = reflectedInternals(transformController);
- const transformBeforeSpoof = transformController.desiredSize;
- transformController.__moliStreamControllerStream = new ReadableStream(
- {},
- { highWaterMark: 99 }
- );
- const transformSpoofed = transformController.desiredSize;
-
- const writable = new WritableStream();
- const writer = writable.getWriter();
- const writerReflectedBefore = reflectedInternals(writer);
- const writerReadyGetter =
- Object.getOwnPropertyDescriptor(
- Object.getPrototypeOf(writer),
- "ready"
- ).get;
- const writerDesiredGetter =
- Object.getOwnPropertyDescriptor(
- Object.getPrototypeOf(writer),
- "desiredSize"
- ).get;
- const writerDesiredBefore = writer.desiredSize;
- const writerReadyIsPromise = writer.ready instanceof Promise;
- const writerClosedIsPromise = writer.closed instanceof Promise;
- const writerFakeReady = writerReadyGetter.call({
- __moliWritableStreamWriterStream: writable
- }) instanceof Promise;
- const writerFakeDesired = throwsTypeError(() =>
- writerDesiredGetter.call({
- __moliWritableStreamWriterStream: writable
- })
- );
- writer.__moliWritableStreamWriterStream = new WritableStream();
- const writerDesiredSpoofed = writer.desiredSize;
-
- return [
- readableReflectedBefore,
- methodShape(readableController, "enqueue"),
- methodShape(readableController, "close"),
- accessorShape(readableController, "desiredSize"),
- `${readableBefore}:${readableAfter}:${readableFake}:${readableSpoofed}`,
- transformReflectedBefore,
- methodShape(transformController, "enqueue"),
- String(Object.hasOwn(
- Object.getPrototypeOf(transformController),
- "close"
- )),
- accessorShape(transformController, "desiredSize"),
- `${transformBeforeSpoof}:${transformSpoofed}`,
- writerReflectedBefore,
- accessorShape(writer, "ready"),
- accessorShape(writer, "closed"),
- accessorShape(writer, "desiredSize"),
- `${writerDesiredBefore}:${writerReadyIsPromise}:${writerClosedIsPromise}:${writerFakeReady}:${writerFakeDesired}:${writerDesiredSpoofed}`
- ].join("\n");
- })()
- "#,
- )
- })
- .await
- .expect("stream declared surface test should run on owner lane");
-
- assert_eq!(
- result,
- [
- "",
- "true:true:true:true:function:0:enqueue",
- "true:true:true:true:function:0:close",
- "true:true:true:false:function:get desiredSize:0:undefined",
- "2:1:throw:TypeError:1",
- "",
- "true:true:true:true:function:0:enqueue",
- "false",
- "true:true:true:false:function:get desiredSize:0:undefined",
- "2:2",
- "",
- "true:true:true:false:function:get ready:0:undefined",
- "true:true:true:false:function:get closed:0:undefined",
- "true:true:true:false:function:get desiredSize:0:undefined",
- "1:true:true:true:throw:TypeError:1",
- ]
- .join("\n")
- );
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn parser_inline_module_runs_from_parser_after_parsing_order() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse(
- "https://example.com/page.html?case=inline-module#document-fragment",
- )
- .expect("document URL");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- document_url.clone(),
- );
- let script = prepared_inline_module_for_page_vm_test(
- &page_vm,
- 9002,
- "globalThis.__inlineParserModuleExecuted = (globalThis.__inlineParserModuleExecuted ?? 0) + 1; globalThis.__inlineParserModuleUrl = import.meta.url; export const value = 1;",
- );
-
- let parser_module_work = install_parser_module_defer_work(&mut page_vm, script);
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__inlineParserModuleExecuted)")
- .expect("read module side effect before page task"),
- "undefined",
- "prewarmed inline graph must not evaluate before parser after-parsing release"
- );
-
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- parser_module_work,
- )
- .await
- .expect("parser after-parsing owner should release inline graph");
- run_parser_module_completion_turns_for_test(
- &mut page_vm,
- &loader,
- 0,
- "inline parser module after-parsing release",
- )
- .await;
-
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__inlineParserModuleExecuted)")
- .expect("read module side effect after page task"),
- "1",
- "parser after-parsing release should evaluate the prewarmed inline graph once"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("globalThis.__inlineParserModuleUrl")
- .expect("read inline module URL after page task"),
- document_url.as_str(),
- "an inline module must expose its document base URL, not its internal module-map key"
- );
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn parser_data_url_module_runs_from_parser_after_parsing_order() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/page.html").expect("document URL"),
- );
- let module_url = Url::parse(
- "data:text/javascript,globalThis.__dataParserModuleExecuted%3D1%3Bexport%20const%20value%3D1%3B",
- )
- .expect("data module URL");
- let script = prepared_external_module_for_page_vm_test(&page_vm, module_url);
-
- let parser_module_work = install_parser_module_defer_work(&mut page_vm, script);
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__dataParserModuleExecuted)")
- .expect("read data module side effect before page task"),
- "undefined",
- "prepared data graph must not evaluate before parser after-parsing release"
- );
-
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- parser_module_work,
- )
- .await
- .expect("parser after-parsing owner should release the data module graph");
- run_parser_module_completion_turns_for_test(
- &mut page_vm,
- &loader,
- 0,
- "data parser module after-parsing release",
- )
- .await;
-
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__dataParserModuleExecuted)")
- .expect("read data module side effect after page task"),
- "1",
- "parser after-parsing release should evaluate the prepared data graph once"
- );
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn parser_pending_module_tree_fetch_completion_waits_for_after_parsing_release() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/page.html").expect("document URL"),
- );
- let module_url = Url::parse("https://example.com/module.mjs").expect("module URL");
- let script = prepared_external_module_for_page_vm_test(&page_vm, module_url.clone());
-
- let parser_module_work = install_parser_module_defer_work(&mut page_vm, script);
-
- enqueue_parser_owned_module_script_fetch_completion_for_test(
- &mut page_vm,
- 0,
- &module_url,
- "globalThis.__pendingTreeExecuted = (globalThis.__pendingTreeExecuted ?? 0) + 1; export const value = 1;",
- );
-
- assert!(
- run_next_main_module_fetch_terminal_for_test(&mut page_vm)
- .expect("module graph completion should run")
- .is_some(),
- "module graph completion should be consumed"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__pendingTreeExecuted)")
- .expect("read module side effect before page task"),
- "undefined",
- "completed fetch tree must not evaluate before the parser script task watches it"
- );
-
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- parser_module_work,
- )
- .await
- .expect("parser after-parsing owner should release the pending tree");
- run_parser_module_completion_turns_for_test(
- &mut page_vm,
- &loader,
- 0,
- "completed parser module after-parsing release",
- )
- .await;
-
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__pendingTreeExecuted)")
- .expect("read module side effect after page task"),
- "1",
- "parser script task watch should evaluate the completed pending tree once"
- );
- assert!(
- page_vm
- .report
- .runs
- .iter()
- .any(|run| run.url() == &module_url),
- "module script run should be reported after watch: {:?}",
- page_vm.report.runs
- );
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn watched_loading_parser_pending_module_tree_runs_after_fetch_completion() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/page.html").expect("document URL"),
- );
- let module_url = Url::parse("https://example.com/late-module.mjs").expect("module URL");
- let script = prepared_external_module_for_page_vm_test(&page_vm, module_url.clone());
-
- let parser_module_work = install_parser_module_defer_work(&mut page_vm, script);
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- parser_module_work,
- )
- .await
- .expect("parser after-parsing owner should retain the loading pending tree");
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__pendingTreeLateExecuted)")
- .expect("read module side effect before fetch completion"),
- "undefined",
- "loading watch must wait for the fetch tree completion"
- );
-
- enqueue_parser_owned_module_script_fetch_completion_for_test(
- &mut page_vm,
- 0,
- &module_url,
- "globalThis.__pendingTreeLateExecuted = (globalThis.__pendingTreeLateExecuted ?? 0) + 1; export const value = 1;",
- );
- assert!(
- run_next_main_module_fetch_terminal_for_test(&mut page_vm)
- .expect("module graph completion should run")
- .is_some(),
- "module graph completion should be consumed"
- );
- assert!(
- !page_vm.has_ready_parser_owned_document_script_action(),
- "after-parsing terminal must stay in its PendingScript instead of the broad ready queue"
- );
- run_ready_parser_deferred_body_for_test(
- &mut page_vm,
- &loader,
- "late parser module graph completion",
- )
- .await;
- run_parser_module_completion_turns_for_test(
- &mut page_vm,
- &loader,
- 0,
- "late parser module graph completion",
- )
- .await;
-
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__pendingTreeLateExecuted)")
- .expect("read module side effect after fetch completion"),
- "1",
- "fetch completion after watch should evaluate the pending tree once"
- );
- assert!(
- page_vm
- .report
- .runs
- .iter()
- .any(|run| run.url() == &module_url),
- "module script run should be reported after late completion: {:?}",
- page_vm.report.runs
- );
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_parser_module_tla_releases_lifecycle_at_evaluation_start() {
- run_page_vm_async_test(async move {
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/main-tla.html").expect("document URL"),
- );
- let module_url = Url::parse("https://example.com/main-parser-tla.mjs").expect("module URL");
- let script =
- prepared_external_module_for_page_vm_test_with_node(&page_vm, 9050, module_url.clone());
- let parser_module_work = install_parser_module_defer_work(&mut page_vm, script);
- assert!(
- page_vm.has_pending_parser_owned_module_script(),
- "the accepted module PendingScript must own a lifecycle token before fetch starts"
- );
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(&loader, parser_module_work)
- .await
- .expect("parser module owner should wait for its graph");
-
- enqueue_parser_owned_module_script_fetch_completion_for_test(
- &mut page_vm,
- 0,
- &module_url,
- concat!(
- "globalThis.__mainParserTlaStarted = 1;",
- "await new Promise(resolve => { globalThis.__resolveMainParserTla = resolve; });",
- "globalThis.__mainParserTlaFinished = 1; export const value = 1;",
- ),
- );
- assert!(
- run_next_main_module_fetch_terminal_for_test(&mut page_vm)
- .expect("TLA module graph completion should apply")
- .is_some()
- );
- run_ready_parser_deferred_body_for_test(
- &mut page_vm,
- &loader,
- "main parser TLA evaluation start",
- )
- .await;
-
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__mainParserTlaStarted)")
- .expect("read TLA start"),
- "1"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__mainParserTlaFinished)")
- .expect("read suspended TLA body"),
- "undefined"
- );
- assert!(
- !page_vm.has_pending_parser_owned_module_script(),
- "the TLA promise must not retain parser-deferred lifecycle ownership"
- );
- assert_eq!(
- page_vm
- .report
- .runs
- .iter()
- .filter(|run| run.url() == &module_url)
- .count(),
- 1,
- "starting module evaluation must apply script completion exactly once"
- );
-
- page_vm
- .vm_mut()
- .eval("globalThis.__resolveMainParserTla(); 'resolved'")
- .expect("resolve main parser TLA");
- run_parser_module_completion_turns_for_test(
- &mut page_vm,
- &loader,
- 1,
- "main parser TLA fulfillment",
- )
- .await;
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__mainParserTlaFinished)")
- .expect("read fulfilled TLA body"),
- "1"
- );
- assert_eq!(
- page_vm
- .report
- .runs
- .iter()
- .filter(|run| run.url() == &module_url)
- .count(),
- 1,
- "TLA fulfillment must not redispatch script completion"
- );
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_parser_module_tla_rejection_reports_without_duplicate_completion() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/main-tla-rejection.html").expect("document URL"),
- );
- page_vm
- .vm_mut()
- .eval(
- "globalThis.__mainParserTlaErrors = []; addEventListener('error', event => { __mainParserTlaErrors.push((event.error?.constructor?.name ?? 'none') + ':' + event.message); event.preventDefault(); });",
- )
- .expect("install main TLA error observer");
- let module_url = Url::parse("https://example.com/main-parser-tla-rejection.mjs")
- .expect("module URL");
- let script = prepared_external_module_for_page_vm_test_with_node(
- &page_vm,
- 9051,
- module_url.clone(),
- );
- let parser_module_work = install_parser_module_defer_work(&mut page_vm, script);
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- parser_module_work,
- )
- .await
- .expect("parser module owner should wait for its graph");
- enqueue_parser_owned_module_script_fetch_completion_for_test(
- &mut page_vm,
- 0,
- &module_url,
- concat!(
- "await new Promise((_, reject) => {",
- " globalThis.__rejectMainParserTla = reject;",
- "}); export const value = 1;",
- ),
- );
- assert!(
- run_next_main_module_fetch_terminal_for_test(&mut page_vm)
- .expect("TLA rejection graph completion should apply")
- .is_some()
- );
- run_ready_parser_deferred_body_for_test(
- &mut page_vm,
- &loader,
- "main parser TLA rejection evaluation start",
- )
- .await;
- assert!(
- !page_vm.has_pending_parser_owned_module_script(),
- "pending rejection must not retain parser lifecycle ownership"
- );
-
- page_vm
- .vm_mut()
- .eval("globalThis.__rejectMainParserTla(new TypeError('main TLA rejected')); 'rejected'")
- .expect("reject main parser TLA");
- run_parser_module_completion_turns_for_test(
- &mut page_vm,
- &loader,
- 1,
- "main parser TLA rejection",
- )
- .await;
- let error = page_vm
- .vm_mut()
- .eval("__mainParserTlaErrors.join('|')")
- .expect("read TLA rejection event");
- assert!(
- error.contains("TypeError:") && error.contains("main TLA rejected"),
- "TLA rejection must retain typed window-error metadata: {error}"
- );
- assert_eq!(
- page_vm
- .report
- .runs
- .iter()
- .filter(|run| run.url() == &module_url)
- .count(),
- 1,
- "TLA rejection must not redispatch or rerecord script completion"
- );
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_runtime_module_tla_releases_lifecycle_at_evaluation_start() {
- #[derive(Debug)]
- enum RuntimeModuleTurn {
- RuntimeScriptAdmission,
- ParserAsyncModuleAdmission,
- ModuleReaction,
- NativeModuleOwner,
- DynamicModuleJob,
- RuntimeScriptContinuation,
- RuntimeOwnedModuleContinuation,
- ParserOwnedModuleContinuation,
- PostParseWork,
- }
-
- async fn run_one_runtime_module_turn(
- page_vm: &mut PageVm,
- loader: &crate::network::ResourceRequestClient,
- ) -> anyhow::Result<Option<RuntimeModuleTurn>> {
- if page_vm
- .run_exact_selected_page_task_for_test(
- PageSelectedTaskTestSelector::ModuleReaction,
- loader,
- )
- .await?
- {
- return Ok(Some(RuntimeModuleTurn::ModuleReaction));
- }
- if let Some(outcome) = page_vm
- .run_page_main_document_runtime_body_for_test(loader)
- .await?
- {
- let turn = match outcome.action.kind() {
- crate::page_task_queue::PageMainDocumentRuntimeActionKind::RuntimeScriptAdmission => {
- RuntimeModuleTurn::RuntimeScriptAdmission
- }
- crate::page_task_queue::PageMainDocumentRuntimeActionKind::ParserAsyncModuleAdmission => {
- RuntimeModuleTurn::ParserAsyncModuleAdmission
- }
- crate::page_task_queue::PageMainDocumentRuntimeActionKind::RuntimeScriptContinuation => {
- RuntimeModuleTurn::RuntimeScriptContinuation
- }
- crate::page_task_queue::PageMainDocumentRuntimeActionKind::DynamicModuleJob => {
- RuntimeModuleTurn::DynamicModuleJob
- }
- crate::page_task_queue::PageMainDocumentRuntimeActionKind::RuntimeOwnedModuleContinuation => {
- RuntimeModuleTurn::RuntimeOwnedModuleContinuation
- }
- crate::page_task_queue::PageMainDocumentRuntimeActionKind::ParserOwnedModuleContinuation => {
- RuntimeModuleTurn::ParserOwnedModuleContinuation
- }
- crate::page_task_queue::PageMainDocumentRuntimeActionKind::NativeModuleOwnerEvent => {
- RuntimeModuleTurn::NativeModuleOwner
- }
- crate::page_task_queue::PageMainDocumentRuntimeActionKind::PostParseWork => {
- RuntimeModuleTurn::PostParseWork
- }
- };
- return Ok(Some(turn));
- }
- Ok(None)
- }
-
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/runtime-tla.html").expect("document URL"),
- );
- page_vm
- .vm_mut()
- .document_runtime
- .note_dom_content_loaded_dispatched();
- page_vm
- .vm_mut()
- .eval(
- r#"
-(() => {
- globalThis.__runtimeTlaEvents = [];
- const script = document.createElement("script");
- script.type = "module";
- script.onload = () => __runtimeTlaEvents.push("script-load");
- script.onerror = () => __runtimeTlaEvents.push("script-error");
- script.textContent = `
- globalThis.__runtimeTlaStarted = 1;
- await new Promise(resolve => { globalThis.__resolveRuntimeTla = resolve; });
- globalThis.__runtimeTlaFinished = 1;
- `;
- document.body.appendChild(script);
-})()
-"#,
- )
- .expect("install runtime TLA module");
- let owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("main document owner");
-
- let mut reached_evaluation_start = false;
- let mut progress_actions = Vec::new();
- for _ in 0..32 {
- let progressed = run_one_runtime_module_turn(&mut page_vm, &loader).await?;
- let started = page_vm
- .vm_mut()
- .eval("String(globalThis.__runtimeTlaStarted)")?;
- let load_delay = page_vm
- .vm()
- .current_main_document_has_async_script_load_delay(owner);
- let events = page_vm.vm_mut().eval("__runtimeTlaEvents.join('|')")?;
- if started == "1" && load_delay == Some(false) {
- assert_eq!(
- events, "",
- "inline module evaluation must not dispatch script load or error"
- );
- reached_evaluation_start = true;
- break;
- }
- let Some(progressed) = progressed else {
- let ready_module_continuation =
- page_vm.has_ready_runtime_owned_module_script_continuation_work();
- let ready_dynamic_module_job = page_vm.vm_mut().has_ready_dynamic_module_job();
- let runnable_runtime_work = page_vm
- .vm_mut()
- .has_runnable_runtime_script_work_now();
- panic!(
- "runtime module owner loop stalled before evaluation-start completion: started={started} load_delay={load_delay:?} events={events:?} progress_actions={progress_actions:?} ready_module_continuation={ready_module_continuation} ready_dynamic_module_job={ready_dynamic_module_job} runnable_runtime_work={runnable_runtime_work}",
- );
- };
- progress_actions.push(progressed);
- }
- assert!(
- reached_evaluation_start,
- "runtime TLA evaluation start must complete the script and release its lifecycle binding"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__runtimeTlaFinished)")?,
- "undefined",
- "the module body should still be suspended on its TLA promise"
- );
- let run_count_at_evaluation_start = page_vm
- .report
- .runs
- .iter()
- .filter(|run| run.url().as_str().contains("runtime-tla"))
- .count();
- assert_eq!(
- run_count_at_evaluation_start, 1,
- "evaluation start must apply runtime module script completion exactly once"
- );
-
- page_vm
- .vm_mut()
- .eval("globalThis.__resolveRuntimeTla(); 'resolved'")?;
- assert!(
- page_vm
- .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::ModuleReaction, &loader)
- .await?,
- "runtime TLA fulfillment should enqueue one typed module reaction"
- );
- for _ in 0..32 {
- let progressed = run_one_runtime_module_turn(&mut page_vm, &loader).await?;
- if page_vm
- .vm_mut()
- .eval("String(globalThis.__runtimeTlaFinished)")?
- == "1"
- {
- break;
- }
- assert!(
- progressed.is_some(),
- "runtime module owner loop stalled after TLA resolve"
- );
- }
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__runtimeTlaFinished)")?,
- "1"
- );
- assert_eq!(
- page_vm
- .report
- .runs
- .iter()
- .filter(|run| run.url().as_str().contains("runtime-tla"))
- .count(),
- run_count_at_evaluation_start,
- "TLA fulfillment must not redispatch runtime module script completion"
- );
- assert_eq!(
- page_vm.vm_mut().eval("__runtimeTlaEvents.join('|')")?,
- "",
- "inline module fulfillment must not dispatch script load or error"
- );
- Ok::<_, anyhow::Error>(())
- })
- .await
- .expect("runtime TLA lifecycle test should run");
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_parser_classic_defer_dispatches_load_before_releasing_next_pending_script() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/defer-order.html").expect("document URL"),
- );
- page_vm
- .vm_mut()
- .eval("globalThis.__mainParserDeferEvents = []")
- .expect("defer event state should initialize");
- let first = append_parser_owned_external_classic_defer_for_page_vm_test(
- &mut page_vm,
- 1,
- "first-defer",
- Url::parse("https://example.com/first-defer.js").expect("first script URL"),
- ScriptSource::Loaded(
- "globalThis.__mainParserDeferEvents.push('first-exec:' + document.currentScript.id);"
- .to_owned(),
- ),
- (
- "onload",
- "globalThis.__mainParserDeferEvents.push('first-load:' + (document.currentScript === null))",
- ),
- );
- let second = append_parser_owned_external_classic_defer_for_page_vm_test(
- &mut page_vm,
- 2,
- "second-defer",
- Url::parse("https://example.com/second-defer.js").expect("second script URL"),
- ScriptSource::Loaded(
- "globalThis.__mainParserDeferEvents.push('second-exec:' + document.currentScript.id);"
- .to_owned(),
- ),
- (
- "onload",
- "globalThis.__mainParserDeferEvents.push('second-load:' + (document.currentScript === null))",
- ),
- );
- let task_owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("defer test requires a document owner");
- for script in [first, second] {
- assert!(
- page_vm
- .vm_mut()
- .claim_main_parser_deferred_script(
- task_owner,
- script,
- None,
- None,
- Default::default(),
- )
- .expect("loaded classic defer should be accepted")
- );
- }
- assert!(
- page_vm.has_pending_parser_owned_module_script(),
- "accepted classic-defer PendingScripts must own the main lifecycle gate"
- );
- page_vm
- .seal_main_parser_deferred_scripts(task_owner)
- .expect("defer queue should seal");
- assert!(
- !page_vm.has_pending_module_script_for_target_stage(),
- "classic defer lifecycle ownership must not enter the runtime-owned module lane"
- );
-
- run_ready_parser_deferred_body_for_test(&mut page_vm, &loader, "first classic defer")
- .await;
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__mainParserDeferEvents.join('|')")
- .expect("first defer events should evaluate"),
- "first-exec:first-defer|first-load:true",
- "the first PendingScript must dispatch load with currentScript cleared before the next parser-deferred slot is released"
- );
- assert!(
- page_vm.has_pending_parser_owned_module_script(),
- "the second PendingScript must retain its own lifecycle token"
- );
-
- run_ready_parser_deferred_body_for_test(&mut page_vm, &loader, "second classic defer")
- .await;
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__mainParserDeferEvents.join('|')")
- .expect("all defer events should evaluate"),
- "first-exec:first-defer|first-load:true|second-exec:second-defer|second-load:true"
- );
- assert!(
- !page_vm.has_pending_parser_owned_module_script(),
- "consuming the final PendingScript must release the lifecycle gate"
- );
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_parser_classic_defer_settles_script_reactions_before_load() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/defer-checkpoint-order.html")
- .expect("document URL"),
- );
- page_vm
- .vm_mut()
- .eval("globalThis.__mainParserDeferCheckpointEvents = []")
- .expect("defer checkpoint state should initialize");
- let script = append_parser_owned_external_classic_defer_for_page_vm_test(
- &mut page_vm,
- 1,
- "checkpoint-defer",
- Url::parse("https://example.com/checkpoint-defer.js").expect("script URL"),
- ScriptSource::Loaded(
- r#"
-globalThis.__mainParserDeferCheckpointEvents.push('script');
-queueMicrotask(() => globalThis.__mainParserDeferCheckpointEvents.push('script-microtask'));
-"#
- .to_owned(),
- ),
- (
- "onload",
- "globalThis.__mainParserDeferCheckpointEvents.push('load'); queueMicrotask(() => globalThis.__mainParserDeferCheckpointEvents.push('load-microtask'))",
- ),
- );
- let task_owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("defer checkpoint test requires a document owner");
- assert!(
- page_vm
- .vm_mut()
- .claim_main_parser_deferred_script(
- task_owner,
- script,
- None,
- None,
- Default::default(),
- )
- .expect("loaded classic defer should be accepted")
- );
- page_vm
- .seal_main_parser_deferred_scripts(task_owner)
- .expect("defer queue should seal");
-
- run_and_finish_ready_parser_deferred_task_for_test(
- &mut page_vm,
- &loader,
- "classic defer checkpoint ordering",
- )
- .await;
-
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__mainParserDeferCheckpointEvents.join('|')")
- .expect("defer checkpoint events should evaluate"),
- "script|script-microtask|load|load-microtask",
- "classic-defer evaluation reactions must settle before load and the selected parser task must then settle load reactions"
- );
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn dcl_lifecycle_yields_parser_deferred_source_wait_to_page_vm_resource_queue() {
- run_page_vm_async_test(async move {
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/defer-arrival.html").expect("document URL"),
- );
- let script = append_parser_owned_external_classic_defer_for_page_vm_test(
- &mut page_vm,
- 1,
- "deferred-arrival",
- Url::parse("https://example.com/deferred-arrival.js").expect("script URL"),
- ScriptSource::External,
- ("onload", "globalThis.__deferredArrivalLoaded = true"),
- );
- let (source_ready_tx, source_ready_rx) = tokio::sync::oneshot::channel();
- let source_load = SharedScriptSourceLoad::spawn_for_test(async move {
- source_ready_rx
- .await
- .expect("test should release the deferred source");
- Ok("globalThis.__deferredArrivalExecuted = true;".to_owned())
- });
- let task_owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("defer test requires a document owner");
- assert!(
- page_vm
- .vm_mut()
- .claim_main_parser_deferred_script(
- task_owner,
- script,
- Some(source_load),
- None,
- Default::default(),
- )
- .expect("pending classic defer should be accepted")
- );
- page_vm
- .seal_main_parser_deferred_scripts(task_owner)
- .expect("defer queue should seal");
- let lifecycle_driver = page_vm
- .vm()
- .resume_post_parse_lifecycle_driver_for_existing_queue(
- PageVmInitStage::DomContentLoaded,
- );
-
- let advance = {
- let PageVm {
- vm,
- page_task_queue,
- report,
- ..
- } = &mut page_vm;
- vm.as_mut()
- .expect("page vm must retain a ScriptVm")
- .advance_post_parse_lifecycle(
- &loader,
- page_task_queue,
- report,
- lifecycle_driver,
- None,
- )
- .await
- .expect("DCL driver should report its blocked state")
- };
- assert!(
- matches!(advance, PostParseLifecycleAdvance::AwaitProgress),
- "the document driver must yield future resource progress to PageVm arbitration"
- );
-
- page_vm
- .vm_mut()
- .eval(
- "globalThis.__dclBlockedTimerRan = false; \
- setTimeout(() => { globalThis.__dclBlockedTimerRan = true; }, 0);",
- )
- .expect("ready timer should be registered");
- assert!(
- page_vm.vm().has_ready_timeout(),
- "the regression requires a ready timer competing with the deferred source"
- );
- let progress_arrived = {
- let progress_wait =
- page_vm.wait_for_lifecycle_blocking_page_work_arrival_without_timeout(false);
- tokio::pin!(progress_wait);
- tokio::select! {
- biased;
- result = &mut progress_wait => {
- panic!("a DCL-ineligible timer must not satisfy the lifecycle wait: {result}")
- }
- _ = std::future::ready(()) => {}
- }
- source_ready_tx
- .send(())
- .expect("deferred source receiver should remain alive");
- progress_wait.await
- };
- assert!(
- progress_arrived,
- "deferred source terminal must wake the PageVm resource queue"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__dclBlockedTimerRan)")
- .expect("timer marker should remain readable"),
- "false",
- "waiting for DCL progress must not execute a generic timer task"
- );
- let deferred_source = run_next_resource_completion_as_typed_page_turn(&mut page_vm)
- .expect("deferred source terminal should apply");
- assert_eq!(
- deferred_source.action.source,
- RendererOwnerResourceActivitySource::MainParserDeferredClassicSource
- );
-
- let advance = {
- let PageVm {
- vm,
- page_task_queue,
- report,
- ..
- } = &mut page_vm;
- vm.as_mut()
- .expect("page vm must retain a ScriptVm")
- .advance_post_parse_lifecycle(
- &loader,
- page_task_queue,
- report,
- lifecycle_driver,
- None,
- )
- .await
- .expect("resource completion should resume the DCL driver")
- };
- let PostParseLifecycleAdvance::PageOwnedTask(mut task) = advance else {
- panic!("ready parser-deferred work should become a page-owned task");
- };
- assert!(
- task.take_work_for_execution()
- .main_parser_deferred_scripts_owner()
- .is_some(),
- "the resumed owner turn must execute the exact parser-deferred queue"
- );
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_parser_classic_defer_load_replacement_retires_old_pending_queue() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/defer-replacement.html").expect("document URL"),
- );
- page_vm
- .vm_mut()
- .eval("globalThis.__mainParserDeferReplacementEvents = []")
- .expect("replacement event state should initialize");
- let first = append_parser_owned_external_classic_defer_for_page_vm_test(
- &mut page_vm,
- 1,
- "replacement-defer",
- Url::parse("https://example.com/replacement-defer.js")
- .expect("replacement script URL"),
- ScriptSource::Loaded(
- "globalThis.__mainParserDeferReplacementEvents.push('execute');".to_owned(),
- ),
- (
- "onload",
- "globalThis.__mainParserDeferReplacementEvents.push('load'); document.open(); document.write(\"<!doctype html><html><body><main id='replacement'>replacement</main></body></html>\"); document.close();",
- ),
- );
- let stale = append_parser_owned_external_classic_defer_for_page_vm_test(
- &mut page_vm,
- 2,
- "stale-defer",
- Url::parse("https://example.com/stale-defer.js").expect("stale script URL"),
- ScriptSource::Loaded(
- "globalThis.__mainParserDeferReplacementEvents.push('stale-execute');".to_owned(),
- ),
- (
- "onload",
- "globalThis.__mainParserDeferReplacementEvents.push('stale-load')",
- ),
- );
- let task_owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("replacement test requires a document owner");
- for script in [first, stale] {
- assert!(
- page_vm
- .vm_mut()
- .claim_main_parser_deferred_script(
- task_owner,
- script,
- None,
- None,
- Default::default(),
- )
- .expect("classic defer should be accepted")
- );
- }
- page_vm
- .seal_main_parser_deferred_scripts(task_owner)
- .expect("replacement defer queue should seal");
-
- run_ready_parser_deferred_body_for_test(
- &mut page_vm,
- &loader,
- "replacement classic defer",
- )
- .await;
- assert_ne!(
- page_vm.vm().current_main_document_task_owner(),
- Some(task_owner),
- "document.open from the load handler must rotate the document owner"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__mainParserDeferReplacementEvents.join('|')")
- .expect("replacement events should evaluate"),
- "execute|load",
- "old parser-deferred work must stop after its completion event replaces the document"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(document.getElementById('replacement') !== null)")
- .expect("replacement document should evaluate"),
- "true"
- );
- assert!(
- page_vm
- .vm()
- .document_runtime
- .main_parser_deferred_scripts_owner()
- .is_none(),
- "replacement must disarm the retired parser-deferred owner source"
- );
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_parser_classic_defer_execution_can_replace_the_document() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/defer-execution-replacement.html")
- .expect("document URL"),
- );
- page_vm
- .vm_mut()
- .eval("globalThis.__mainParserDeferExecutionReplacementEvents = []")
- .expect("replacement event state should initialize");
- let script = append_parser_owned_external_classic_defer_for_page_vm_test(
- &mut page_vm,
- 1,
- "replacement-defer",
- Url::parse("https://example.com/replacement-defer.js")
- .expect("replacement script URL"),
- ScriptSource::Loaded(
- "globalThis.__mainParserDeferExecutionReplacementEvents.push('execute'); document.open(); document.write(\"<!doctype html><html><body><main id='replacement'>replacement</main></body></html>\"); document.close(); globalThis.__mainParserDeferExecutionReplacementEvents.push('after-open');"
- .to_owned(),
- ),
- (
- "onload",
- "globalThis.__mainParserDeferExecutionReplacementEvents.push('load')",
- ),
- );
- let task_owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("replacement test requires a document owner");
- assert!(
- page_vm
- .vm_mut()
- .claim_main_parser_deferred_script(
- task_owner,
- script,
- None,
- None,
- Default::default(),
- )
- .expect("classic defer should be accepted")
- );
- page_vm
- .seal_main_parser_deferred_scripts(task_owner)
- .expect("replacement defer queue should seal");
-
- run_ready_parser_deferred_body_for_test(
- &mut page_vm,
- &loader,
- "replacement classic defer execution",
- )
- .await;
- assert_ne!(
- page_vm.vm().current_main_document_task_owner(),
- Some(task_owner),
- "document.open from deferred execution must rotate the document owner"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__mainParserDeferExecutionReplacementEvents.join('|')")
- .expect("replacement events should evaluate"),
- "execute|after-open",
- "replacement must prevent the retired script element load event from dispatching"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(document.getElementById('replacement') !== null)")
- .expect("replacement document should evaluate"),
- "true"
- );
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_parser_classic_defer_source_failure_dispatches_typed_error_without_refetch() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let (mut page_vm, mut page_resource_queue, mut owner_wake_rx) =
- page_vm_with_bound_task_sources_and_owner_wake(
- &loader,
- Url::parse("https://example.com/defer-failure.html").expect("document URL"),
- );
- page_vm
- .vm_mut()
- .eval("globalThis.__mainParserDeferFailureEvents = []")
- .expect("failure event state should initialize");
- let failed = append_parser_owned_external_classic_defer_for_page_vm_test(
- &mut page_vm,
- 1,
- "failed-defer",
- Url::parse("https://defer-failure.test/missing.js").expect("failed script URL"),
- ScriptSource::External,
- (
- "onerror",
- "globalThis.__mainParserDeferFailureEvents.push('error:' + (document.currentScript === null))",
- ),
- );
- let failed_node_id = failed.node_id;
- let task_owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("failure test requires a document owner");
- assert!(
- page_vm
- .vm_mut()
- .claim_main_parser_deferred_script(
- task_owner,
- failed,
- Some(crate::planning::SharedScriptSourceLoad::ready_err(
- "prepared source failure",
- )),
- None,
- Default::default(),
- )
- .expect("failed classic defer should be accepted before source start")
- );
- page_vm
- .seal_main_parser_deferred_scripts(task_owner)
- .expect("failed defer queue should seal without waiting");
- assert!(
- page_vm.has_pending_parser_owned_module_script(),
- "source failure must retain lifecycle ownership until its owner turn dispatches error"
- );
- loop {
- let wake = owner_wake_rx
- .recv()
- .await
- .expect("ready source failure must keep the Page owner wake route open");
- if wake.source_for_test()
- == crate::page_task_queue::RendererOwnerWakeSource::NetworkingTask
- {
- break;
- }
- }
- let source_failure = page_vm
- .apply_one_page_resource_terminal_owner_admission_for_test(&mut page_resource_queue)
- .expect("source terminal should arbitrate")
- .expect("source terminal should apply");
- assert_eq!(
- source_failure.action.source,
- RendererOwnerResourceActivitySource::MainParserDeferredClassicSource
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__mainParserDeferFailureEvents.join('|')")
- .expect("pre-turn failure events should evaluate"),
- "",
- "resource completion must only update PendingScript state"
- );
-
- run_ready_parser_deferred_body_for_test(&mut page_vm, &loader, "failed classic defer")
- .await;
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("__mainParserDeferFailureEvents.join('|')")
- .expect("failure events should evaluate"),
- "error:true"
- );
- assert!(
- !page_vm.has_pending_parser_owned_module_script(),
- "source-failure completion must release its exact lifecycle token"
- );
- let run = page_vm
- .report
- .runs
- .iter()
- .find(|run| run.node_id() == failed_node_id)
- .expect("source failure owner turn should record one failed run");
- assert!(matches!(run.outcome(), ScriptRunOutcome::Failed(_)));
- })
- .await;
-}
-
-#[tokio::test(flavor = "current_thread")]
-async fn main_parser_after_parsing_queue_orders_module_before_ready_classic_defer() {
- run_page_vm_async_test(async move {
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/page.html").expect("document URL"),
- );
- let module_url = Url::parse("https://example.com/ordered-module.mjs").expect("module URL");
- let module =
- prepared_external_module_for_page_vm_test_with_node(&page_vm, 9101, module_url.clone());
- let (classic_node, classic_handle) = {
- let runtime = &mut page_vm.vm_mut().document_runtime;
- let body = runtime
- .snapshot_document()
- .document_body_handle()
- .expect("test document body");
- let script_node = runtime.dom_host_mut().create_element("script");
- assert!(runtime.dom_host_mut().append_child(body, script_node));
- let handle = runtime.bind_document_write_owned_script_handle_for_node(script_node);
- (script_node, handle)
- };
- let mut classic = prepared_loaded_classic_for_page_vm_test(
- &page_vm,
- 9102,
- "globalThis.__orderedClassicDefer = 1;",
- );
- classic.node_id = classic_node;
- classic.host_script_handle = Some(classic_handle);
- classic.mode = ScriptMode::Defer;
-
- let task_owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("mixed parser-deferred test requires a current document owner");
- assert!(
- page_vm
- .vm_mut()
- .claim_main_parser_deferred_script(
- task_owner,
- classic.clone(),
- None,
- None,
- Default::default(),
- )
- .expect("classic defer PendingScript should be accepted")
- );
- assert!(
- page_vm
- .vm_mut()
- .claim_main_parser_deferred_script(
- task_owner,
- module.clone(),
- None,
- None,
- Default::default(),
- )
- .expect("module defer PendingScript should start its graph after acceptance")
- );
- let _marker = page_vm
- .seal_main_parser_deferred_scripts(task_owner)
- .expect("mixed parser-deferred batch should install");
- page_vm
- .page_task_queue
- .extend_post_parse_work([PostParsePageOwnedWork::lifecycle_work(
- PostParseLifecycleWork::test_domcontentloaded(),
- )]);
- assert!(
- poll_post_parse_document_processing_action_for_test(&mut page_vm).is_none(),
- "pending earlier module must hold DCL without exposing later classic work"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__orderedClassicDefer)")
- .expect("read later classic side effect while module is pending"),
- "undefined",
- "later ready classic defer must stay behind the earlier module PendingScript"
- );
- assert!(
- !page_vm.has_ready_parser_owned_document_script_action(),
- "mixed after-parsing order must not materialize broad ready work"
- );
-
- enqueue_parser_owned_module_script_fetch_completion_for_test(
- &mut page_vm,
- 0,
- &module_url,
- "globalThis.__orderedModuleDefer = 1; export const value = 1;",
- );
- assert!(
- run_next_main_module_fetch_terminal_for_test(&mut page_vm)
- .expect("module graph completion should run")
- .is_some()
- );
- run_ready_parser_deferred_body_for_test(&mut page_vm, &loader, "earlier module release")
- .await;
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__orderedModuleDefer)")
- .expect("read earlier module side effect"),
- "1"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__orderedClassicDefer)")
- .expect("read later classic before its owner turn"),
- "undefined",
- "one parser owner turn must release only the current document-order slot"
- );
-
- run_ready_parser_deferred_body_for_test(&mut page_vm, &loader, "later classic release")
- .await;
- let classic_run = page_vm
- .report
- .runs
- .iter()
- .find(|run| run.node_id() == classic.node_id)
- .unwrap_or_else(|| {
- panic!(
- "later classic owner turn should report a run: {:?}",
- page_vm.report.runs
- )
- });
- assert!(
- matches!(classic_run.outcome(), ScriptRunOutcome::Executed),
- "later classic owner turn should execute, got {classic_run:?}"
- );
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__orderedClassicDefer)")
- .expect("read later classic side effect"),
- "1"
- );
- assert!(
- page_vm
- .vm()
- .document_runtime
- .main_parser_deferred_scripts_owner()
- .is_none(),
- "consuming the final ordered slot must disarm the document owner source"
- );
- assert!(
- !page_vm.has_pending_parser_owned_module_script(),
- "mixed classic/module order must release every lifecycle token"
- );
- assert!(matches!(
- poll_post_parse_document_processing_action_for_test(&mut page_vm),
- Some(crate::document_runtime::DocumentProcessingAction::PostParsePageOwnedWork(work))
- if work.is_domcontentloaded_task()
- ));
- })
- .await;
+ PreparedScript {
+ position: node as usize,
+ node_id: NodeId::new(node as usize),
+ kind: ScriptKind::Module,
+ mode: ScriptMode::ModuleDefer,
+ source_kind: ScriptSourceKind::External,
+ fetch_metadata: ScriptFetchMetadata::default(),
+ source: ScriptSource::External,
+ initiator_url: page_vm.vm().document_runtime.document_url().clone(),
+ base_url: url.clone(),
+ url,
+ host_script_handle: None,
+ }
}
-#[tokio::test(flavor = "current_thread")]
-async fn parser_module_graph_failure_leaves_shared_sibling_fetch_for_joined_script_waiter() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/page.html").expect("document URL"),
- );
- let first_root_url =
- Url::parse("https://example.com/first-root.mjs").expect("first root URL");
- let second_root_url =
- Url::parse("https://example.com/second-root.mjs").expect("second root URL");
- let bad_url = Url::parse("https://example.com/bad.mjs").expect("bad module URL");
- let shared_url = Url::parse("https://example.com/shared.mjs").expect("shared module URL");
- let shared_key = ModuleMapKey::java_script(shared_url.clone());
- let first_script =
- prepared_external_module_for_page_vm_test_with_node(&page_vm, 9201, first_root_url.clone());
- let second_script = prepared_external_module_for_page_vm_test_with_node(
- &page_vm,
- 9202,
- second_root_url.clone(),
- );
-
- let first_parser_module_work =
- install_parser_module_defer_work(&mut page_vm, first_script);
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- first_parser_module_work,
- )
+async fn drive_child_frame_task_sources_until_resource_completion_ready(
+ page_vm: &mut PageVm,
+ max_turns: usize,
+) -> Vec<ChildFrameSemanticTurnKind> {
+ let mut sources = Vec::new();
+ for _ in 0..max_turns {
+ if page_vm.has_ready_page_websocket_task_for_test() {
+ break;
+ }
+ let Some(source) = page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
.await
- .expect("first module defer page task should watch loading tree");
+ else {
+ break;
+ };
+ sources.push(source);
+ }
+ sources
+}
- enqueue_parser_owned_module_script_fetch_completion_for_test(
- &mut page_vm,
- 0,
- &first_root_url,
- r#"
-import "./bad.mjs";
-import "./shared.mjs";
-export const first = 1;
-"#,
- );
- assert!(
- run_next_main_module_fetch_terminal_for_test(&mut page_vm)
- .expect("first root completion should run")
- .is_some(),
- "first root completion should be consumed"
- );
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum ChildModulepreloadStartupTurn {
+ TypedModulepreloadStart,
+ ChildSemanticTurn(ChildFrameSemanticTurnKind),
+}
- let second_parser_module_work =
- install_parser_module_defer_work(&mut page_vm, second_script);
+async fn run_expected_child_modulepreload_event_action_for_test(
+ page_vm: &mut PageVm,
+ loader: &crate::network::ResourceRequestClient,
+ label: &str,
+) {
+ assert!(
page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- second_parser_module_work,
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ChildModulepreloadEventAction,
+ loader,
)
.await
- .expect("second module defer page task should watch loading tree");
- enqueue_parser_owned_module_script_fetch_completion_for_test(
- &mut page_vm,
- 3,
- &second_root_url,
- r#"
-import "./shared.mjs";
-export const second = 2;
-"#,
- );
- assert!(
- run_next_main_module_fetch_terminal_for_test(&mut page_vm)
- .expect("second root completion should run")
- .is_some(),
- "second root completion should be consumed"
- );
- assert!(
- page_vm.has_pending_parser_owned_module_fetch(),
- "second graph should be waiting on the first graph's shared sibling fetch"
- );
- let shared_fetch_target = page_vm
- .vm()
- .current_main_parser_module_graph_fetch_target(2)
- .expect("shared fetch must retain its producer-captured target before owner failure");
+ .unwrap_or_else(|error| panic!("{label} selected task should succeed: {error:#}")),
+ "{label} should consume one typed modulepreload event action through the selected-task dispatcher"
+ );
+}
- enqueue_parser_owned_module_script_fetch_error_for_test(
- &mut page_vm,
- 1,
- &bad_url,
- "bad dependency failed",
- );
- assert!(
- run_next_main_module_fetch_terminal_for_test(&mut page_vm)
- .expect("bad dependency completion should run")
- .is_some(),
- "bad dependency failure should be consumed"
- );
+/// Adjacent module-map helper that preserves distinct modulepreload and child
+/// semantic turns. The modulepreload start enters the production selected-task
+/// dispatcher; the returned sequence still must not be used as owner-scheduler
+/// or cross-source fairness evidence.
+async fn drive_child_modulepreload_startup_until_resource_completion_ready(
+ page_vm: &mut PageVm,
+ loader: &crate::network::ResourceRequestClient,
+ max_turns: usize,
+) -> Vec<ChildModulepreloadStartupTurn> {
+ let mut turns = Vec::new();
+ for _ in 0..max_turns {
+ if page_vm.has_ready_page_websocket_task_for_test() {
+ break;
+ }
+ if page_vm
+ .page_task_executor_sources_for_test()
+ .modulepreload_start()
+ .has_ready_task()
+ {
+ assert!(
+ page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ModulepreloadStart,
+ loader,
+ )
+ .await
+ .expect("selected child modulepreload start should succeed"),
+ "typed child modulepreload start should consume one source head through the production dispatcher",
+ );
+ turns.push(ChildModulepreloadStartupTurn::TypedModulepreloadStart);
+ continue;
+ }
+ let Some(source) = page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await
+ else {
+ break;
+ };
+ turns.push(ChildModulepreloadStartupTurn::ChildSemanticTurn(source));
+ }
+ turns
+}
- let shared_entry = page_vm
- .vm()
- .document_runtime
- .native_module_entry_id(&shared_key)
- .expect("cancelled shared sibling fetch should remain in the module map");
+/// Settle at most one exact realm-materialization prerequisite before running
+/// the requested child-family turn. The production semantic helper remains a
+/// strict one-turn operation.
+async fn run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ page_vm: &mut PageVm,
+ expected: impl Into<ChildFrameSemanticTurnKind>,
+ label: &str,
+) -> ChildFrameSemanticTurnKind {
+ let expected = expected.into();
+ if expected != ChildFrameSemanticTurnKind::RealmMaterialization
+ && page_vm.has_ready_child_frame_semantic_turn_for_test(
+ ChildFrameSemanticTurnKind::RealmMaterialization,
+ )
+ {
assert_eq!(
page_vm
- .vm()
- .document_runtime
- .native_module_entry_state(shared_entry),
- ModuleMapEntryState::Fetching,
- "owner failure must not globally fail a shared module map entry while its network fetch is still pending"
- );
- assert!(
- page_vm.has_pending_parser_owned_module_fetch(),
- "joined parser graph should keep waiting for the shared fetch network completion"
- );
- assert!(
- !page_vm.has_ready_parser_owned_document_script_action(),
- "ordered graph failure must stay in the parser PendingScript instead of the broad ready lane"
- );
- run_ready_parser_deferred_body_for_test(
- &mut page_vm,
- &loader,
- "bad dependency failure",
- )
- .await;
- let first_failure = page_vm
- .report
- .runs
- .iter()
- .find(|run| run.url() == &first_root_url)
- .and_then(|run| match run.outcome() {
- ScriptRunOutcome::Failed(message) => Some(message),
- _ => None,
- })
- .expect("first parser module script should fail after bad dependency");
- assert!(
- first_failure.contains("bad dependency failed"),
- "first script should report the real dependency failure: {first_failure}"
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await,
+ Some(ChildFrameSemanticTurnKind::RealmMaterialization),
+ "{label} should first materialize the exact child realm"
);
+ }
+ let Some(source) = page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await
+ else {
+ panic!("{label} should produce {expected:?}, but no child frame task work was ready");
+ };
+ assert_eq!(
+ source, expected,
+ "{label} should run the expected child frame task source"
+ );
+ source
+}
- enqueue_parser_owned_module_script_fetch_completion_for_target_for_test(
- &mut page_vm,
- shared_fetch_target,
- &shared_url,
- "export const shared = 1;",
- );
- assert!(
- run_next_main_module_fetch_terminal_for_test(&mut page_vm)
- .expect("shared dependency completion should run")
- .is_some(),
- "shared dependency completion should be consumed"
- );
- assert!(
- page_vm.vm_mut().has_ready_native_module_owner_actions(),
- "shared module-map terminal must publish its joined-client owner event"
- );
- run_next_native_module_owner_event_for_test(
- &mut page_vm,
- &loader,
- "shared parser module-map completion",
- )
- .await;
- assert!(
- !page_vm.has_pending_parser_owned_module_fetch(),
- "joined parser graph should resume through the native module owner turn"
- );
- run_ready_parser_deferred_body_for_test(
- &mut page_vm,
- &loader,
- "joined parser module graph completion",
- )
- .await;
- run_parser_module_completion_turns_for_test(
- &mut page_vm,
- &loader,
- 0,
- "joined parser module graph completion",
- )
+async fn run_expected_child_realm_materialization_for_wait(
+ page_vm: &mut PageVm,
+ label: &str,
+) -> ChildFrameSemanticTurnKind {
+ let source = page_vm
+ .run_next_child_frame_task_source_for_semantic_test()
.await;
- assert!(
- !page_vm.has_pending_parser_owned_module_script(),
- "joined parser graph should no longer be pending after its ready script executes"
- );
- let second_run = page_vm
- .report
- .runs
- .iter()
- .find(|run| run.url() == &second_root_url)
- .expect("second parser module script should run after joined fetch wakeup");
- assert!(
- matches!(second_run.outcome(), ScriptRunOutcome::Executed),
- "second parser module script should execute after joined fetch wakeup: {:?}",
- second_run.outcome()
- );
- })
- .await;
+ assert_eq!(
+ source,
+ Some(ChildFrameSemanticTurnKind::RealmMaterialization),
+ "{label} should materialize its exact child realm in one explicit turn"
+ );
+ ChildFrameSemanticTurnKind::RealmMaterialization
}
-#[tokio::test(flavor = "current_thread")]
-async fn modulepreload_fetch_failure_wakes_joined_parser_script_waiter() {
- run_page_vm_async_test(async move {
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse("https://example.com/page.html").expect("document URL");
- let mut page_vm =
- test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url.clone());
-
- let root_url = Url::parse("https://example.com/root.mjs").expect("root URL");
- let shared_url = Url::parse("https://cdn.example.com/shared.mjs").expect("shared URL");
- let shared_key = ModuleMapKey::java_script(shared_url.clone());
- let modulepreload = NativeModuleSingleFetchRequest::new(
- shared_url.clone(),
- shared_url.clone(),
- document_url,
- shared_key.clone(),
- ModuleFetchMetadata::default(),
- );
- let start = page_vm
- .vm_mut()
- .document_runtime
- .fetch_single_native_module_for_modulepreload(modulepreload)
- .expect("modulepreload registration should succeed");
- let crate::module_runtime::NativeModulepreloadFetchStart::Started(modulepreload) = start
- else {
- panic!("new modulepreload should start a single-module fetch");
- };
- let modulepreload_load_id = page_vm
- .vm_mut()
- .document_runtime
- .suspend_native_modulepreload_fetch(*modulepreload);
-
- let root_script =
- prepared_external_module_for_page_vm_test_with_node(&page_vm, 9301, root_url.clone());
- let parser_module_work = install_parser_module_defer_work(&mut page_vm, root_script);
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(&loader, parser_module_work)
- .await
- .expect("module defer page task should watch loading tree");
-
- enqueue_parser_owned_module_script_fetch_completion_for_test(
- &mut page_vm,
- 1,
- &root_url,
- r#"
-import "https://cdn.example.com/shared.mjs";
-export const root = 1;
-"#,
- );
- assert!(
- run_next_main_module_fetch_terminal_for_test(&mut page_vm)
- .expect("root completion should run")
- .is_some(),
- "root completion should be consumed"
- );
- assert!(
- page_vm.has_pending_parser_owned_module_fetch(),
- "parser graph should wait on the in-flight modulepreload entry"
- );
-
- enqueue_main_modulepreload_fetch_error_for_test(
- &mut page_vm,
- modulepreload_load_id,
- &shared_url,
- "modulepreload fetch failed",
- );
- assert!(
- run_next_main_module_fetch_terminal_for_test(&mut page_vm)
- .expect("modulepreload completion should run")
- .is_some(),
- "modulepreload completion should be consumed"
- );
- run_next_native_module_owner_event_for_test(
- &mut page_vm,
- &loader,
- "joined modulepreload failure",
+async fn run_expected_child_module_script_terminal_turn(page_vm: &mut PageVm, label: &str) {
+ let loader = page_vm.request_client.clone();
+ let claimed = page_vm
+ .claim_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::ChildModuleScriptTerminal,
)
- .await;
- let shared_entry = page_vm
+ .unwrap_or_else(|| panic!("{label} should produce one selected module-terminal task"));
+ let owner = claimed
+ .child_module_script_terminal_owner()
+ .expect("exact terminal selector must retain its typed owner");
+ assert_eq!(
+ owner.root_document(),
+ page_vm.document_lifecycle.identity().document,
+ "{label} must belong to the current root Document",
+ );
+ assert_eq!(
+ page_vm
.vm()
- .document_runtime
- .native_module_entry_id(&shared_key)
- .expect("failed modulepreload should remain in module map");
- assert_eq!(
- page_vm
- .vm()
- .document_runtime
- .native_module_entry_state(shared_entry),
- ModuleMapEntryState::Failed,
- "failed modulepreload must become terminal"
- );
- assert!(
- !page_vm.has_pending_parser_owned_module_fetch(),
- "joined parser graph should be woken by the modulepreload failure"
- );
- assert!(
- page_vm.has_pending_parser_owned_module_script(),
- "joined parser graph failure should wait for the document-owned ready dispatch"
- );
- run_ready_parser_deferred_body_for_test(
- &mut page_vm,
- &loader,
- "joined modulepreload graph failure",
- )
- .await;
- assert!(
- !page_vm.has_pending_parser_owned_module_script(),
- "joined parser graph failure should leave no pending parser-owned module script"
- );
- let root_failure = page_vm
- .report
- .runs
- .iter()
- .find(|run| run.url() == &root_url)
- .and_then(|run| match run.outcome() {
- ScriptRunOutcome::Failed(message) => Some(message),
- _ => None,
- })
- .expect("parser module script should fail after joined modulepreload wakeup");
- assert!(
- root_failure.contains("modulepreload fetch failed"),
- "joined script should observe the terminal modulepreload failure: {root_failure}"
- );
- })
+ .current_child_module_script_terminal_owner(owner.document_owner(), owner.realm_id(),),
+ Some(owner.document_owner()),
+ "{label} must belong to the current child Document/realm",
+ );
+ page_vm
+ .run_claimed_selected_page_task_for_test(claimed, &loader)
+ .await
+ .unwrap_or_else(|error| panic!("{label} selected task failed: {error:#}"));
+}
+
+async fn run_child_domcontentloaded_then_host_load_for_wait(
+ page_vm: &mut PageVm,
+ label: &str,
+) -> ChildFrameSemanticTurnKind {
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ &format!("{label} DOMContentLoaded transition"),
+ )
.await;
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ &format!("{label} complete transition"),
+ )
+ .await;
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ page_vm,
+ ChildFrameSemanticTurnKind::HostLoad,
+ label,
+ )
+ .await
}
-#[tokio::test(flavor = "current_thread")]
-async fn parser_module_script_observes_prior_modulepreload_failure() {
- run_page_vm_async_test(async move {
- let loader =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse("https://example.com/page.html").expect("document URL");
- let mut page_vm =
- test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url.clone());
-
- let module_url = Url::parse("https://example.com/module.mjs").expect("module URL");
- let modulepreload = NativeModuleSingleFetchRequest::new(
- module_url.clone(),
- module_url.clone(),
- document_url,
- ModuleMapKey::java_script(module_url.clone()),
- ModuleFetchMetadata::default(),
- );
- let start = page_vm
- .vm_mut()
- .document_runtime
- .fetch_single_native_module_for_modulepreload(modulepreload)
- .expect("modulepreload registration should succeed");
- let crate::module_runtime::NativeModulepreloadFetchStart::Started(modulepreload) = start
- else {
- panic!("new modulepreload should start a single-module fetch");
- };
- let modulepreload_load_id = page_vm
- .vm_mut()
- .document_runtime
- .suspend_native_modulepreload_fetch(*modulepreload);
-
- enqueue_main_modulepreload_fetch_error_for_test(
- &mut page_vm,
- modulepreload_load_id,
- &module_url,
- "modulepreload integrity failed",
- );
- assert!(
- run_next_main_module_fetch_terminal_for_test(&mut page_vm)
- .expect("modulepreload completion should run")
- .is_some(),
- "modulepreload completion should be consumed"
- );
-
- let module_script =
- prepared_external_module_for_page_vm_test_with_node(&page_vm, 9401, module_url.clone());
- let parser_module_work = install_parser_module_defer_work(&mut page_vm, module_script);
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(&loader, parser_module_work)
- .await
- .expect("module defer page task should watch failed tree");
- assert!(
- !page_vm.has_pending_parser_owned_module_script(),
- "the parser-deferred owner turn should consume the already-terminal failure"
- );
- assert!(
- !page_vm.has_ready_parser_owned_document_script_action(),
- "sticky failure must not materialize broad ready work"
- );
-
- let root_failure = page_vm
- .report
- .runs
- .iter()
- .find(|run| run.url() == &module_url)
- .and_then(|run| match run.outcome() {
- ScriptRunOutcome::Failed(message) => Some(message),
- _ => None,
- })
- .expect("parser module script should fail from sticky modulepreload failure");
- assert!(
- root_failure.contains("modulepreload integrity failed"),
- "module script should report sticky modulepreload failure: {root_failure}"
- );
- })
+async fn run_child_interactive_domcontentloaded_then_host_load_for_wait(
+ page_vm: &mut PageVm,
+ label: &str,
+) -> ChildFrameSemanticTurnKind {
+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
+ page_vm,
+ ChildFrameSemanticTurnKind::DocumentLifecycle,
+ &format!("{label} interactive transition"),
+ )
.await;
+ run_child_domcontentloaded_then_host_load_for_wait(page_vm, label).await
}
-#[tokio::test(flavor = "current_thread")]
-async fn parser_module_script_joins_inflight_same_url_modulepreload_failure() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let document_url = Url::parse("https://example.com/page.html").expect("document URL");
- let mut page_vm =
- test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url.clone());
+fn prepared_inline_module_for_page_vm_test(
+ page_vm: &PageVm,
+ node: u32,
+ source: &str,
+) -> PreparedScript {
+ PreparedScript {
+ position: node as usize,
+ node_id: NodeId::new(node as usize),
+ kind: ScriptKind::Module,
+ mode: ScriptMode::ModuleDefer,
+ source_kind: ScriptSourceKind::Inline,
+ fetch_metadata: ScriptFetchMetadata::default(),
+ source: ScriptSource::Inline(source.to_owned()),
+ initiator_url: page_vm.vm().document_runtime.document_url().clone(),
+ base_url: page_vm.vm().document_runtime.document_url().clone(),
+ url: page_vm.vm().document_runtime.document_url().clone(),
+ host_script_handle: None,
+ }
+}
- let module_url = Url::parse("https://example.com/module.mjs").expect("module URL");
- let modulepreload = NativeModuleSingleFetchRequest::new(
- module_url.clone(),
- module_url.clone(),
- document_url,
- ModuleMapKey::java_script(module_url.clone()),
- ModuleFetchMetadata::default(),
- );
- let start = page_vm
- .vm_mut()
- .document_runtime
- .fetch_single_native_module_for_modulepreload(modulepreload)
- .expect("modulepreload registration should succeed");
- let crate::module_runtime::NativeModulepreloadFetchStart::Started(modulepreload) = start
- else {
- panic!("new modulepreload should start a single-module fetch");
- };
- let modulepreload_load_id = page_vm
- .vm_mut()
- .document_runtime
- .suspend_native_modulepreload_fetch(*modulepreload);
+fn prepared_loaded_classic_for_page_vm_test(
+ page_vm: &PageVm,
+ node: u32,
+ source: &str,
+) -> PreparedScript {
+ PreparedScript {
+ position: node as usize,
+ node_id: NodeId::new(node as usize),
+ kind: ScriptKind::Classic,
+ mode: ScriptMode::Normal,
+ source_kind: ScriptSourceKind::Inline,
+ fetch_metadata: ScriptFetchMetadata::default(),
+ source: ScriptSource::Loaded(source.to_owned()),
+ initiator_url: page_vm.vm().document_runtime.document_url().clone(),
+ base_url: page_vm.vm().document_runtime.document_url().clone(),
+ url: page_vm.vm().document_runtime.document_url().clone(),
+ host_script_handle: None,
+ }
+}
- let module_script =
- prepared_external_module_for_page_vm_test_with_node(&page_vm, 9501, module_url.clone());
- let parser_module_work = install_parser_module_defer_work(&mut page_vm, module_script);
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- parser_module_work,
- )
- .await
- .expect("module defer page task should watch joined modulepreload");
- assert!(
- page_vm.has_pending_parser_owned_module_fetch(),
- "parser root graph should wait on the in-flight same-URL modulepreload entry"
+fn append_parser_owned_external_classic_defer_for_page_vm_test(
+ page_vm: &mut PageVm,
+ position: usize,
+ element_id: &str,
+ script_url: Url,
+ source: ScriptSource,
+ completion_attribute: (&str, &str),
+) -> PreparedScript {
+ let body = page_vm
+ .vm()
+ .snapshot_live_document()
+ .document_body_handle()
+ .expect("test document body");
+ let script_node = page_vm
+ .vm_mut()
+ .document_runtime
+ .dom_host_mut()
+ .create_parser_element_without_attributes(
+ "script".to_owned(),
+ "http://www.w3.org/1999/xhtml".to_owned(),
+ None,
);
+ {
+ let dom_host = page_vm.vm_mut().document_runtime.dom_host_mut();
+ assert!(dom_host.set_attribute(script_node, "id", element_id));
+ assert!(dom_host.set_attribute(script_node, "src", script_url.as_str()));
+ assert!(dom_host.set_attribute(
+ script_node,
+ completion_attribute.0,
+ completion_attribute.1,
+ ));
+ assert!(dom_host.append_child(body, script_node));
+ }
+ let host_script_handle = page_vm
+ .vm_mut()
+ .document_runtime
+ .bind_parser_owned_script_handle_for_node(script_node);
+ PreparedScript {
+ position,
+ node_id: NodeId::new(script_node.index()),
+ kind: ScriptKind::Classic,
+ mode: ScriptMode::Defer,
+ source_kind: ScriptSourceKind::External,
+ fetch_metadata: ScriptFetchMetadata::default(),
+ source,
+ initiator_url: page_vm.vm().document_runtime.document_url().clone(),
+ base_url: script_url.clone(),
+ url: script_url,
+ host_script_handle: Some(host_script_handle),
+ }
+}
- enqueue_main_modulepreload_fetch_error_for_test(
- &mut page_vm,
- modulepreload_load_id,
- &module_url,
- "modulepreload integrity failed",
- );
- assert!(
- run_next_main_module_fetch_terminal_for_test(&mut page_vm)
- .expect("modulepreload completion should run")
- .is_some(),
- "modulepreload completion should be consumed"
- );
- run_next_native_module_owner_event_for_test(
- &mut page_vm,
- &loader,
- "same-URL joined modulepreload failure",
- )
- .await;
- assert!(
- !page_vm.has_pending_parser_owned_module_fetch(),
- "same-URL joined parser graph should be woken by modulepreload failure"
- );
- assert!(
- page_vm.has_pending_parser_owned_module_script(),
- "same-URL joined parser graph failure should wait for the document-owned ready dispatch"
- );
- run_ready_parser_deferred_body_for_test(
- &mut page_vm,
- &loader,
- "same-URL joined modulepreload failure",
- )
- .await;
- assert!(
- !page_vm.has_pending_parser_owned_module_script(),
- "same-URL joined parser graph failure should leave no pending parser-owned module script"
- );
+fn enqueue_parser_owned_module_script_fetch_completion_for_test(
+ page_vm: &mut PageVm,
+ load_id: u64,
+ module_url: &Url,
+ source: &str,
+) {
+ let target = page_vm
+ .vm()
+ .current_main_parser_module_graph_fetch_target(load_id)
+ .unwrap_or_else(|| panic!("parser module fetch {load_id} must retain its exact target"));
+ enqueue_parser_owned_module_script_fetch_completion_for_target_for_test(
+ page_vm, target, module_url, source,
+ );
+}
- let root_failure = page_vm
- .report
- .runs
- .iter()
- .find(|run| run.url() == &module_url)
- .and_then(|run| match run.outcome() {
- ScriptRunOutcome::Failed(message) => Some(message),
- _ => None,
- })
- .expect("parser module script should fail from same-URL modulepreload failure");
- assert!(
- root_failure.contains("modulepreload integrity failed"),
- "module script should report joined modulepreload failure: {root_failure}"
- );
- })
- .await;
+fn enqueue_parser_owned_module_script_fetch_completion_for_target_for_test(
+ page_vm: &mut PageVm,
+ target: MainParserModuleGraphFetchTarget,
+ module_url: &Url,
+ source: &str,
+) {
+ let document_url = page_vm.vm().document_runtime.document_url().clone();
+ page_vm
+ .vm()
+ .resource_completion_sender_for_test()
+ .send_main_parser_module_graph_fetch(MainParserModuleGraphFetchCompletion::new(
+ target,
+ Ok(ModuleGraphFetchedSource::new(
+ module_url.clone(),
+ false,
+ ModuleSource::text(source.to_owned()),
+ )),
+ None,
+ MainModuleFetchNetworkAttribution::new(document_url, module_url.clone()),
+ ))
+ .expect("module graph completion should enqueue");
}
-#[tokio::test(flavor = "current_thread")]
-async fn document_replacement_drops_parser_pending_module_tree_owner() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/page.html").expect("document URL"),
- );
- let module_url = Url::parse("https://example.com/replaced-module.mjs")
- .expect("module URL");
- let module_script = prepared_external_module_for_page_vm_test(&page_vm, module_url.clone());
+fn enqueue_parser_owned_module_script_fetch_error_for_test(
+ page_vm: &mut PageVm,
+ load_id: u64,
+ module_url: &Url,
+ message: &str,
+) {
+ let target = page_vm
+ .vm()
+ .current_main_parser_module_graph_fetch_target(load_id)
+ .unwrap_or_else(|| panic!("parser module fetch {load_id} must retain its exact target"));
+ let document_url = page_vm.vm().document_runtime.document_url().clone();
+ page_vm
+ .vm()
+ .resource_completion_sender_for_test()
+ .send_main_parser_module_graph_fetch(MainParserModuleGraphFetchCompletion::new(
+ target,
+ Err(message.to_owned()),
+ None,
+ MainModuleFetchNetworkAttribution::new(document_url, module_url.clone()),
+ ))
+ .expect("module graph error completion should enqueue");
+}
- let parser_module_work = install_parser_module_defer_work(&mut page_vm, module_script);
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- parser_module_work,
- )
- .await
- .expect("module defer page task should watch loading pending tree");
- assert!(
- page_vm.has_pending_parser_owned_module_fetch(),
- "module tree should be waiting for its root fetch before replacement"
- );
- let stale_target = page_vm
- .vm()
- .current_main_parser_module_graph_fetch_target(0)
- .expect("loading parser root must expose its exact terminal target");
+fn run_next_main_module_fetch_terminal_for_test(
+ page_vm: &mut PageVm,
+) -> anyhow::Result<Option<RendererOwnerResourceActivitySource>> {
+ let outcome = run_next_resource_completion_as_typed_page_turn(page_vm)?;
+ anyhow::ensure!(
+ outcome.action.source == RendererOwnerResourceActivitySource::ModuleGraphFetch,
+ "expected a typed main module fetch terminal, got {:?}",
+ outcome.action.source
+ );
+ Ok(Some(outcome.action.source))
+}
- let replacement_script = prepared_loaded_classic_for_page_vm_test(
- &page_vm,
- 9100,
- "document.open(); document.write('<!doctype html><p>replacement</p>'); document.close();",
- );
- page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- classic_defer_work(replacement_script),
- )
- .await
- .expect("replacement script task should run");
+async fn run_next_native_module_owner_event_for_test(
+ page_vm: &mut PageVm,
+ loader: &crate::network::ResourceRequestClient,
+ label: &str,
+) {
+ let outcome = page_vm
+ .run_page_main_document_runtime_body_for_test(loader)
+ .await
+ .unwrap_or_else(|error| panic!("{label} owner event should run: {error}"))
+ .unwrap_or_else(|| panic!("{label} should retain one native module owner-event turn"));
+ assert_eq!(
+ outcome.action.kind(),
+ crate::page_task_queue::PageMainDocumentRuntimeActionKind::NativeModuleOwnerEvent,
+ "{label} must resume joined module-map clients through their typed owner source"
+ );
+}
+
+fn enqueue_main_modulepreload_fetch_error_for_test(
+ page_vm: &mut PageVm,
+ load_id: u64,
+ module_url: &Url,
+ message: &str,
+) {
+ let target = page_vm
+ .vm()
+ .current_main_modulepreload_fetch_target(load_id)
+ .unwrap_or_else(|| panic!("modulepreload fetch {load_id} must retain its exact target"));
+ let document_url = page_vm.vm().document_runtime.document_url().clone();
+ page_vm
+ .vm()
+ .resource_completion_sender_for_test()
+ .send_main_modulepreload_fetch(MainModulepreloadFetchCompletion::new(
+ target,
+ Err(message.to_owned()),
+ None,
+ MainModuleFetchNetworkAttribution::new(document_url, module_url.clone()),
+ ))
+ .expect("modulepreload graph completion should enqueue");
+}
+async fn run_parser_module_completion_turns_for_test(
+ page_vm: &mut PageVm,
+ loader: &crate::network::ResourceRequestClient,
+ expected_ready_turns: usize,
+ label: &str,
+) {
+ page_vm
+ .vm_mut()
+ .perform_script_task_checkpoint(None)
+ .expect("module evaluation reaction checkpoint should run");
+ while page_vm
+ .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::ModuleReaction, loader)
+ .await
+ .expect("module reactions should run")
+ {}
+ for turn in 0..expected_ready_turns {
assert!(
- !page_vm.has_pending_parser_owned_module_fetch(),
- "document replacement must drop parser-owned module fetch continuations"
- );
- assert!(
- !page_vm.has_pending_parser_owned_module_script(),
- "document replacement must drop parser pending module scripts"
+ run_one_parser_owned_main_document_runtime_turn_for_test(page_vm, loader)
+ .await
+ .expect("module evaluation completion should run"),
+ "{label} should run parser-owned ready turn {} of {expected_ready_turns}",
+ turn + 1
);
+ }
+ assert!(
+ !page_vm.has_ready_parser_owned_document_script_action(),
+ "{label} should not leave another concrete parser-owned module action ready"
+ );
+}
- let replacement_document_url = page_vm.vm().document_runtime.document_url().clone();
- page_vm
- .vm()
- .resource_completion_sender_for_test()
- .send_main_parser_module_graph_fetch(MainParserModuleGraphFetchCompletion::new(
- stale_target,
- Ok(ModuleGraphFetchedSource::new(
- module_url.clone(),
- false,
- ModuleSource::text(
- "globalThis.__oldModuleAfterReplacement = true; export const value = 1;"
- .to_owned(),
- ),
- )),
- None,
- MainModuleFetchNetworkAttribution::new(
- replacement_document_url,
- module_url.clone(),
- ),
- ))
- .expect("stale exact parser terminal should still enter the stable Page source");
- let outcome = run_next_resource_completion_as_typed_page_turn(&mut page_vm)
- .expect("old module graph completion should consume one typed turn");
- assert!(
- matches!(
- outcome.action.document_effect,
- PageResourceCompletionDocumentEffect::DiscardedStaleOwner { .. }
+async fn run_one_parser_owned_main_document_runtime_turn_for_test(
+ page_vm: &mut PageVm,
+ loader: &crate::network::ResourceRequestClient,
+) -> anyhow::Result<bool> {
+ page_vm.admit_ready_parser_owned_document_script_action();
+ page_vm
+ .run_exact_selected_page_task_for_test(
+ PageSelectedTaskTestSelector::MainDocumentRuntime(
+ crate::page_task_queue::PageMainDocumentRuntimeActionKind::ParserOwnedModuleContinuation,
),
- "old exact parser target must be rejected before module-map application: {outcome:?}"
- );
-
- assert_eq!(
- page_vm
- .vm_mut()
- .eval("String(globalThis.__oldModuleAfterReplacement)")
- .expect("read old module side effect"),
- "undefined",
- "old parser module tree must not execute after document replacement"
- );
- assert!(
- page_vm
- .capture_page_state()
- .expect("page state capture")
- .report
- .lifecycle_errors()
- .is_empty(),
- "typed stale-owner rejection is an expected terminal outcome, not a lifecycle error"
- );
- })
- .await;
+ loader,
+ )
+ .await
}
-#[tokio::test(flavor = "current_thread")]
-async fn stale_main_parser_module_terminal_drops_after_pending_script_retirement() {
- run_page_vm_async_test(async move {
- let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let mut page_vm = test_page_vm_with_loader_and_document_url(
- &loader,
- Vec::new(),
- Url::parse("https://example.com/page.html").expect("document URL"),
- );
- let old_task_owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("original main document task owner should exist");
- let old_owner = MainParserDocumentOwner::new(old_task_owner);
- let module_url =
- Url::parse("https://example.com/stale-ready-module.mjs").expect("module URL");
- let module_script =
- prepared_external_module_for_page_vm_test(&page_vm, module_url.clone());
+fn post_parse_document_script_work(
+ lane: DocumentScriptExecutionLane,
+ script: PreparedScript,
+) -> PostParsePageOwnedWork {
+ PostParsePageOwnedWork::document_script_work(PageOwnedDocumentScriptWork::script(lane, script))
+}
- let replacement_script = prepared_loaded_classic_for_page_vm_test(
- &page_vm,
- 9200,
- "document.open(); document.write('<!doctype html><p>replacement</p>'); document.close();",
- );
+fn install_parser_module_defer_work(
+ page_vm: &mut PageVm,
+ script: PreparedScript,
+) -> PostParsePageOwnedWork {
+ let task_owner = page_vm
+ .vm()
+ .current_main_document_task_owner()
+ .expect("parser module test requires a current document owner");
+ assert!(
page_vm
- .execute_post_parse_page_owned_task_on_named_owner_lane(
- &loader,
- classic_defer_work(replacement_script),
- )
- .await
- .expect("replacement script task should run");
- let stale_pending_script_id =
- crate::document_script_scheduler::ParserPendingScriptId::new(
- old_owner,
- &module_script,
- );
- let stale_continuation = ModuleScriptContinuation::new_parser(
- module_script,
- stale_pending_script_id,
- )
- .with_completed_graph(ModuleGraphHandle {
- root_entry: ModuleEntryId::for_test(1),
- entries: vec![ModuleEntryId::for_test(1)],
- });
- let main_task_owner = page_vm
- .vm()
- .current_main_document_task_owner()
- .expect("main document task owner should exist");
- let main_owner = MainParserDocumentOwner::new(main_task_owner);
- assert_ne!(main_task_owner.document_id, old_task_owner.document_id);
- assert_eq!(
- main_task_owner.scheduler_lane_id,
- old_task_owner.scheduler_lane_id,
- "main document replacement should retain the browsing-context scheduler lane"
- );
- assert_eq!(
- main_task_owner.local_window_id,
- old_task_owner.local_window_id,
- "document.open() should retain the main LocalWindow"
- );
- assert_ne!(
- main_owner, old_owner,
- "document replacement should install a new document-scoped parser owner"
- );
- let stale_work = stale_continuation.into_main_document_graph_ready_work();
- let accepted = page_vm
.vm_mut()
- .document_runtime
- .parser_module_document_scripts_mut()
- .notify_module_script_graph_ready_work(stale_work);
- assert!(
- !accepted,
- "terminal must fail closed after its original PendingScript is retired"
- );
- assert!(
- !page_vm
- .vm()
- .document_runtime
- .parser_module_document_scripts()
- .has_load_blocking_document_script_work(old_owner),
- "retired owner must not be rematerialized by a stale terminal"
- );
- assert!(
- !page_vm
- .vm()
- .document_runtime
- .parser_module_document_scripts()
- .has_load_blocking_document_script_work(main_owner),
- "stale terminal must not enter the replacement document scheduler"
- );
- assert!(
- !page_vm.has_ready_parser_owned_document_script_action(),
- "stale terminal must not synthesize a ready action without its PendingScript"
- );
-
- assert!(
- !run_one_parser_owned_main_document_runtime_turn_for_test(&mut page_vm, &loader)
- .await
- .expect("stale parser module ready lane should remain idle"),
- "retired PendingScript terminal must not reach owner-specific execution"
- );
- assert!(
- !page_vm.has_ready_parser_owned_document_script_action(),
- "stale ready action should be removed from the ready lane"
- );
- assert!(
- page_vm.report.runs.iter().all(|run| run.url() != &module_url),
- "stale main parser module ready action must not produce a script run: {:?}",
- page_vm.report.runs
- );
- })
- .await;
-}
-
-#[test]
-fn module_graph_network_result_records_staged_response_started_with_cache_state() {
- let mut page_vm = test_page_vm_with_document_url(
- Url::parse("https://example.com/page.html").expect("document URL"),
- );
- let request_url = Url::parse("https://example.com/module.js").expect("request URL");
- let response = crate::types::NavigationResponse::from_head_and_text_body(
- moli_fetch::ResponseHead {
- final_url: request_url.clone(),
- status: 200,
- headers: vec![("content-type".to_owned(), b"text/javascript".to_vec())],
- request_cookie_report: None,
- cookie_set_reports: Vec::new(),
- redirected: false,
- redirect_chain: Vec::new(),
- from_cache: true,
- negotiated_http_version: None,
- },
- "export default 1;".to_owned(),
+ .claim_main_parser_deferred_script(task_owner, script, None, None, Default::default(),)
+ .expect("parser module PendingScript acceptance should start its graph")
);
- let completion = ModuleGraphFetchCompletion {
- load_id: 7,
- requester: ModuleGraphFetchRequester::DynamicImport,
- ordering: ModuleGraphFetchOrdering::Runtime,
- request_url: request_url.clone(),
- result: Err("source is not used by this test".to_owned()),
- network_result: None,
- };
-
page_vm
- .vm_mut()
- .record_module_graph_subresource_network_result(&completion, &Ok(response));
+ .seal_main_parser_deferred_scripts(task_owner)
+ .expect("parser module PendingScript should install into after-parsing order")
+}
- let items: Vec<_> = page_vm
- .vm_mut()
- .take_network_output()
- .into_items()
- .collect();
- assert_eq!(
- items.len(),
- 3,
- "module fetch should record staged network output"
- );
- let ScriptNetworkOutputItem::SubresourceRequestStarted(request) = &items[0] else {
- panic!("first item should be requestStarted: {items:?}");
+/// Execute only the parser-deferred domain body.
+///
+/// This helper intentionally does not prove selected-task checkpoint or exact
+/// DCL handoff behavior. Tests asserting a complete parser task must use
+/// `run_and_finish_ready_parser_deferred_task_for_test()` instead.
+async fn run_ready_parser_deferred_body_for_test(
+ page_vm: &mut PageVm,
+ loader: &crate::network::ResourceRequestClient,
+ label: &str,
+) {
+ let action = poll_post_parse_document_processing_action_for_test(page_vm)
+ .unwrap_or_else(|| panic!("{label} should expose a ready parser-deferred owner action"));
+ let crate::document_runtime::DocumentProcessingAction::PostParsePageOwnedWork(work) = action
+ else {
+ panic!("{label} should produce page-owned parser-deferred work");
};
- assert_eq!(request.url(), &request_url);
- assert_eq!(request.resource_type(), SubresourceResourceType::Script);
+ assert!(
+ work.main_parser_deferred_scripts_owner().is_some(),
+ "{label} should produce the armed parser-deferred marker, got {work:?}"
+ );
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(loader, *work)
+ .await
+ .unwrap_or_else(|error| panic!("{label} parser-deferred turn should run: {error}"));
+}
- let ScriptNetworkOutputItem::SubresourceResponseStarted(response) = &items[1] else {
- panic!("second item should be responseStarted: {items:?}");
+async fn run_and_finish_ready_parser_deferred_task_for_test(
+ page_vm: &mut PageVm,
+ loader: &crate::network::ResourceRequestClient,
+ label: &str,
+) {
+ let action = poll_post_parse_document_processing_action_for_test(page_vm)
+ .unwrap_or_else(|| panic!("{label} should expose a ready parser-deferred owner action"));
+ let crate::document_runtime::DocumentProcessingAction::PostParsePageOwnedWork(work) = action
+ else {
+ panic!("{label} should produce page-owned parser-deferred work");
};
- assert_eq!(response.final_url(), &request_url);
assert!(
- response.from_cache(),
- "module responseStarted must preserve fetch cache state"
+ work.main_parser_deferred_scripts_owner().is_some(),
+ "{label} should produce the armed parser-deferred marker, got {work:?}"
);
-
- let ScriptNetworkOutputItem::SubresourceBodyFinished(body) = &items[2] else {
- panic!("third item should be bodyFinished: {items:?}");
+ let completion = page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(loader, *work)
+ .await
+ .unwrap_or_else(|error| panic!("{label} parser-deferred body should run: {error}"));
+ let super::parser_completion::SelectedPostParsePageOwnedCompletion::MainParser(completion) =
+ completion
+ else {
+ panic!("{label} must retain its main-parser completion authority");
};
- assert!(matches!(
- body.result(),
- SubresourceBodyFinishedResult::Ready(_)
- ));
+ page_vm
+ .finish_parse_time_main_parser_boundary(completion)
+ .await
+ .unwrap_or_else(|error| panic!("{label} parser task completion should run: {error}"));
}
-#[tokio::test(flavor = "current_thread")]
-async fn direct_page_vm_wait_commands_fail_closed() {
- run_page_vm_async_test(async move {
- let loader_owner =
- crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
- let loader = loader_owner.handle();
-
- let commands = [
- (
- RendererPageCommand::WaitForSelector {
- selector: "#never".to_owned(),
- timeout_ms: 1_000,
- loader: loader.clone(),
- },
- "wait-for-selector must be routed through the renderer owner continuation",
- ),
- (
- RendererPageCommand::WaitForScriptTruthy {
- expression: "false".to_owned(),
- timeout_ms: 1_000,
- loader: loader.clone(),
- },
- "wait-for-script-truthy must be routed through the renderer owner continuation",
- ),
- (
- RendererPageCommand::WaitForSubresourceResponse {
- criteria: SubresourceResponseWaitCriteria::default(),
- timeout_ms: 1_000,
- loader,
- },
- "wait-for-subresource-response must be routed through the renderer owner continuation",
- ),
- ];
+fn poll_post_parse_document_processing_action_for_test(
+ page_vm: &mut PageVm,
+) -> Option<crate::document_runtime::DocumentProcessingAction> {
+ let (vm, task_queue) = (&mut page_vm.vm, &mut page_vm.page_task_queue);
+ vm.as_mut()
+ .expect("test PageVm should retain ScriptVm")
+ .document_runtime
+ .poll_document_processing_action(task_queue, Option::<&crate::dom::native::NativeDom>::None)
+}
- for (command, expected_error) in commands {
- let mut page_vm = test_page_vm();
- let error = match page_vm
- .dispatch_renderer_page_command(command)
- {
- Ok(_) => panic!("direct wait command should fail closed"),
- Err(error) => error,
- };
- assert!(
- error.to_string().contains(expected_error),
- "unexpected error: {error}"
+async fn run_main_async_script_load_delay_settlement_for_test(
+ page_vm: &mut PageVm,
+ loader: &crate::network::ResourceRequestClient,
+ owner: crate::frame_owner_model::FrameDocumentTaskOwner,
+ label: &str,
+) {
+ for turn in 0..2 {
+ if let Some(outcome) = page_vm
+ .run_page_main_document_runtime_body_for_test(loader)
+ .await
+ .unwrap_or_else(|error| panic!("{label} follow-up turn should run: {error}"))
+ {
+ assert_eq!(
+ outcome.action.kind(),
+ crate::page_task_queue::PageMainDocumentRuntimeActionKind::PostParseWork
+ );
+ assert_eq!(outcome.action.owner().document_owner(), owner);
+ assert_eq!(
+ outcome.action.target_effect(),
+ crate::page_task_queue::PageMainDocumentRuntimeTargetEffect::AppliedToCurrentOwner
);
+ } else {
+ // Parse-time async classic work can finish before DCL. Its event
+ // and settlement therefore remain lifecycle-owned rather than
+ // entering the post-DCL MainDocumentRuntime source.
+ let action = page_vm
+ .vm_mut()
+ .document_runtime
+ .pop_parser_owned_pre_domcontentloaded_action()
+ .or_else(|| poll_post_parse_document_processing_action_for_test(page_vm))
+ .unwrap_or_else(|| panic!("{label} should enqueue an explicit follow-up"));
+ let crate::document_runtime::DocumentProcessingAction::PostParsePageOwnedWork(work) =
+ action
+ else {
+ panic!("{label} async follow-up must remain page-owned work");
+ };
+ if let Some(PostParseLifecycleWork::SettleMainDocumentScriptLoadDelay(binding)) =
+ work.as_lifecycle_work()
+ {
+ assert_eq!(binding.owner(), owner);
+ }
+ page_vm
+ .execute_post_parse_page_owned_task_on_named_owner_lane(loader, *work)
+ .await
+ .unwrap_or_else(|error| panic!("{label} lifecycle follow-up should run: {error}"));
}
- })
- .await;
+ if page_vm
+ .vm()
+ .current_main_document_has_async_script_load_delay(owner)
+ == Some(false)
+ {
+ return;
+ }
+ assert_eq!(
+ turn, 0,
+ "{label} must settle after at most one observable event turn"
+ );
+ }
+ panic!("{label} left its exact main-Document load delay unsettled");
+}
+
+fn classic_defer_work(script: PreparedScript) -> PostParsePageOwnedWork {
+ post_parse_document_script_work(DocumentScriptExecutionLane::ClassicDefer, script)
}
fn split_network_output_items(
@@ -15129,3 +2259,4 @@ pub(super) async fn drain_page_work_until_no_pending_subresources(
page_vm.pending_subresource_request_count()
)
}
+mod extracted;