diff --git a/moli-renderer-v8/src/document_script_scheduler/frame_module_script_owner.rs b/moli-renderer-v8/src/document_script_scheduler/frame_module_script_owner.rs index cadd53baf16..788cefdbe4f 100644 --- a/moli-renderer-v8/src/document_script_scheduler/frame_module_script_owner.rs +++ b/moli-renderer-v8/src/document_script_scheduler/frame_module_script_owner.rs @@ -10,10 +10,12 @@ use crate::{ frame_owner_model::{ FrameDocumentScriptElementEventKind, FrameDocumentTaskOwner, FrameRealmId, }, + host::ModuleFailurePolicy, module_runtime::{ModuleEntryId, ModuleGraphHandle, ModuleLoadError, ModuleMapKey}, module_script_continuation::ModuleScriptEvaluationReactionState, parser_module_evaluation::ParserModuleEvaluationContinuation, planning::PreparedScript, + types::{ScriptErrorValue, ScriptSourceKind}, }; use super::{ @@ -232,6 +234,15 @@ pub(crate) trait FrameModuleScriptDocumentScriptHooks { kind: FrameDocumentScriptElementEventKind, ) -> Result<()>; + fn report_module_exception( + &mut self, + owner: FrameDocumentTaskOwner, + realm_id: FrameRealmId, + message: &str, + filename: &str, + error_value: Option, + ) -> Result<()>; + fn finish_graph_failure<'owner>( &'owner mut self, work: &Self::GraphFailureWork, @@ -282,6 +293,7 @@ enum FrameModuleScriptExecutionResult { EvaluationRejected { work: GraphReady, reason: String, + error_value: Option, }, EvaluationPending { work: GraphReady, @@ -644,9 +656,14 @@ where completion_kind: FrameModuleScriptEvaluationCompletionKind::TopLevelAwait, } } - ModuleScriptEvaluationReactionState::Rejected { reason, .. } => { - FrameModuleScriptExecutionResult::EvaluationRejected { work, reason } - } + ModuleScriptEvaluationReactionState::Rejected { + reason, + error_value, + } => FrameModuleScriptExecutionResult::EvaluationRejected { + work, + reason, + error_value, + }, ModuleScriptEvaluationReactionState::Pending => { FrameModuleScriptExecutionResult::EvaluationPending { work } } @@ -686,7 +703,9 @@ where } else { FrameModuleScriptTaskActivity::NoScriptOrEvent }; - if completion_kind.dispatches_script_load_event() { + if completion_kind.dispatches_script_load_event() + && work.script().source_kind == ScriptSourceKind::External + { let event_result = self .hooks .dispatch_script_element_event(&work, FrameDocumentScriptElementEventKind::Load); @@ -730,9 +749,10 @@ where let owner = work.owner(); let realm_id = work.realm_id(); let script_handle = work.script_handle(); - if let Err(error) = self - .hooks - .dispatch_script_element_event(&work, FrameDocumentScriptElementEventKind::Load) + if work.script().source_kind == ScriptSourceKind::External + && let Err(error) = self + .hooks + .dispatch_script_element_event(&work, FrameDocumentScriptElementEventKind::Load) { tracing::warn!( owner = ?owner, @@ -756,19 +776,39 @@ where let realm_id = work.realm_id(); let script_handle = work.script_handle(); let request_url = work.request_key().url().clone(); - let event_result = self.hooks.dispatch_graph_failure_script_element_event( - &work, - FrameDocumentScriptElementEventKind::Error, + let reports_exception = matches!( + ModuleFailurePolicy::for_module_load_error(work.error()), + ModuleFailurePolicy::GraphFailure | ModuleFailurePolicy::EvaluationFailure ); - let event_dispatched = event_result.is_ok(); - if let Err(error) = event_result { + let exception_reported = reports_exception + && self.report_module_exception( + owner, + realm_id, + work.error().message(), + work.script().url.as_str(), + work.error().error_value(), + ); + let event_kind = if reports_exception { + FrameDocumentScriptElementEventKind::Load + } else { + FrameDocumentScriptElementEventKind::Error + }; + let event_result = (!reports_exception + || work.script().source_kind == ScriptSourceKind::External) + .then(|| { + self.hooks + .dispatch_graph_failure_script_element_event(&work, event_kind) + }); + let event_dispatched = + exception_reported || event_result.as_ref().is_some_and(|result| result.is_ok()); + if let Some(Err(error)) = event_result { tracing::warn!( owner = ?owner, realm_id = ?realm_id, script_handle = ?script_handle, url = %request_url, error = ?error, - "frame parser module script error event dispatch failed after graph failure" + "frame module script terminal event dispatch failed after graph failure" ); } self.hooks.record_runtime_warning(format_args!( @@ -804,16 +844,24 @@ where let owner = work.owner(); let realm_id = work.realm_id(); let script_handle = work.script_handle(); - let event_result = self - .hooks - .dispatch_script_element_event(&work, FrameDocumentScriptElementEventKind::Error); - if let Err(dispatch_error) = event_result { + self.report_module_exception( + owner, + realm_id, + error.message(), + work.script().url.as_str(), + error.error_value(), + ); + if work.script().source_kind == ScriptSourceKind::External + && let Err(dispatch_error) = self + .hooks + .dispatch_script_element_event(&work, FrameDocumentScriptElementEventKind::Load) + { tracing::warn!( owner = ?owner, realm_id = ?realm_id, script_handle = ?script_handle, error = ?dispatch_error, - "frame parser module script error event dispatch failed" + "frame module script load event dispatch failed after evaluation failure" ); } self.hooks.record_runtime_warning(format_args!( @@ -830,15 +878,48 @@ where &mut self, work: Hooks::GraphReadyWork, reason: String, + error_value: Option, ) -> FrameModuleScriptOutputAction { let request_url = work.request_key().url().clone(); self.hooks.record_runtime_warning(format_args!( "frame parser module graph `{}` pending evaluation rejected: {}", request_url, reason )); - FrameModuleScriptOutputAction::without_script_or_event( - FrameModuleScriptFinalizationAction::FinishEvaluationRejected { work }, - ) + let reported = self.report_module_exception( + work.owner(), + work.realm_id(), + &reason, + work.script().url.as_str(), + error_value, + ); + let finalization = FrameModuleScriptFinalizationAction::FinishEvaluationRejected { work }; + if reported { + FrameModuleScriptOutputAction::after_script_or_event(finalization) + } else { + FrameModuleScriptOutputAction::without_script_or_event(finalization) + } + } + + fn report_module_exception( + &mut self, + owner: FrameDocumentTaskOwner, + realm_id: FrameRealmId, + message: &str, + filename: &str, + error_value: Option, + ) -> bool { + match self + .hooks + .report_module_exception(owner, realm_id, message, filename, error_value) + { + Ok(()) => true, + Err(error) => { + self.hooks.record_runtime_warning(format_args!( + "frame module exception reporting failed for `{filename}`: {error}" + )); + false + } + } } } @@ -910,9 +991,11 @@ where FrameModuleScriptExecutionResult::GraphFailure { work } => { self.apply_graph_failure(work) } - FrameModuleScriptExecutionResult::EvaluationRejected { work, reason } => { - self.apply_evaluation_rejected(work, reason) - } + FrameModuleScriptExecutionResult::EvaluationRejected { + work, + reason, + error_value, + } => self.apply_evaluation_rejected(work, reason, error_value), FrameModuleScriptExecutionResult::EvaluationPending { work } => { FrameModuleScriptOutputAction::without_script_or_event( FrameModuleScriptFinalizationAction::FinishEvaluationPending { work }, @@ -1284,6 +1367,17 @@ mod tests { Ok(()) } + fn report_module_exception( + &mut self, + _owner: FrameDocumentTaskOwner, + _realm_id: FrameRealmId, + _message: &str, + _filename: &str, + _error_value: Option, + ) -> Result<()> { + Ok(()) + } + fn finish_graph_failure<'owner>( &'owner mut self, _work: &DocumentModuleGraphFailedWork, @@ -1603,7 +1697,7 @@ mod tests { ); assert!( runner.hooks.dispatch_script_element_event_called, - "failed graph evaluation should dispatch the error event" + "failed graph evaluation should still dispatch the external script load event" ); assert!( runner.hooks.record_runtime_warning_called, diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/child_module_document_script_ready.rs b/moli-renderer-v8/src/runtime/page_vm/tests/child_module_document_script_ready.rs index 4fb75e1fffb..b530338b46e 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/child_module_document_script_ready.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/child_module_document_script_ready.rs @@ -1,6 +1,6 @@ use super::*; -async fn queue_child_module_document_script_ready( +pub(super) async fn queue_child_module_document_script_ready( page_vm: &mut PageVm, base_url: &str, create_reaction_child: bool, diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/child_module_error_reporting.rs b/moli-renderer-v8/src/runtime/page_vm/tests/child_module_error_reporting.rs new file mode 100644 index 00000000000..b5ac645ba46 --- /dev/null +++ b/moli-renderer-v8/src/runtime/page_vm/tests/child_module_error_reporting.rs @@ -0,0 +1,360 @@ +use super::child_module_document_script_ready::queue_child_module_document_script_ready; +use super::child_parser_module_root_start_completion::advance_to_child_parser_module_root; +use super::*; + +async fn queue_inline_child_error( + page_vm: &mut PageVm, + loader: &crate::network::ResourceRequestClient, + source: &str, + value: &str, +) -> anyhow::Result<()> { + let html = format!(""); + page_vm.vm_mut().eval(&format!( + r#" + const frame = document.createElement('iframe'); + frame.id = 'module-error-child'; + frame.srcdoc = {html}; + document.body.appendChild(frame); + "#, + html = serde_json::to_string(&html)? + ))?; + advance_to_child_parser_module_root(page_vm, loader).await?; + install_child_error_observers(page_vm, "module-error-child", value)?; + assert!( + page_vm + .run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::ChildParserModuleRootStart, + loader, + ) + .await? + ); + // The inline root completes its graph in the root-start body. Parser + // completion still has to release the deferred-script ordering barrier. + for _ in 0..4 { + if page_vm.has_ready_child_frame_semantic_turn_for_test( + ChildFrameSemanticTurnKind::DocumentScriptReady, + ) { + return Ok(()); + } + anyhow::ensure!( + page_vm + .run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::ChildDocumentLifecycle, + loader, + ) + .await?, + "inline module must finish its parser before becoming runnable" + ); + } + anyhow::bail!("inline child module did not become runnable") +} + +fn install_child_error_observers( + page_vm: &mut PageVm, + frame_id: &str, + value: &str, +) -> anyhow::Result<()> { + page_vm.vm_mut().eval(&format!( + r#" + globalThis.__childErrors = []; + globalThis.__childOnerrors = []; + globalThis.__childErrorOrder = []; + globalThis.__parentErrors = 0; + globalThis.__scriptErrors = 0; + globalThis.__scriptLoads = 0; + globalThis.__coercions = 0; + globalThis.__unhandled = 0; + addEventListener('error', event => {{ ++__parentErrors; event.preventDefault(); }}); + const child = document.getElementById({frame_id:?}).contentWindow; + child.__reason = {value}; + const expectedReason = child.__reason; + child.addEventListener('unhandledrejection', event => {{ ++__unhandled; event.preventDefault(); }}); + child.addEventListener('error', event => {{ + __childErrors.push([ + event.error, event instanceof child.ErrorEvent, + event.target === child, event.isTrusted, + event.error instanceof child.SyntaxError + ]); + __childErrorOrder.push('window-error'); + Promise.resolve().then(() => __childErrorOrder.push('error-microtask')); + event.preventDefault(); + }}); + child.onerror = (message, filename, line, column, error) => {{ + __childOnerrors.push(error); + return true; + }}; + const script = child.document.querySelector('script[type=module]'); + script.addEventListener('error', () => ++__scriptErrors); + script.addEventListener('load', () => {{ ++__scriptLoads; __childErrorOrder.push('script-load'); }}); + "# + ))?; + Ok(()) +} + +#[tokio::test(flavor = "current_thread")] +async fn child_module_error_reporting_reports_root_parse_error_to_its_window() { + run_page_vm_async_test(async { + let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let (mut page_vm, _resource, _wake) = page_vm_with_bound_task_sources_and_owner_wake( + &loader, + Url::parse("https://example.com/child-module-errors.html").unwrap(), + ); + queue_inline_child_error(&mut page_vm, &loader, "export const broken = ;", "null").await?; + assert!( + page_vm + .run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::ChildDocumentScriptReady, + &loader, + ) + .await? + ); + assert_eq!( + page_vm + .vm_mut() + .eval_without_microtask_checkpoint_for_test( + r#" + JSON.stringify([ + __childErrors.length, __childOnerrors.length, + __childErrors[0]?.slice(1).every(Boolean), + __childErrors[0]?.[0] === __childOnerrors[0], + __parentErrors, __scriptErrors, __scriptLoads, + __childErrorOrder.join('|') + ]) + "# + )?, + r#"[1,1,true,true,0,0,0,"window-error|error-microtask"]"# + ); + Ok::<_, anyhow::Error>(()) + }) + .await + .unwrap(); +} + +#[tokio::test(flavor = "current_thread")] +async fn child_module_error_reporting_preserves_synchronous_thrown_values() { + run_page_vm_async_test(async { + for value in [ + "Object.freeze(new child.TypeError('original'))", + "undefined", + "null", + "false", + "-0", + "NaN", + "17n", + "Symbol('original')", + "Object.freeze({marker: 42})", + "({toString() { ++__coercions; throw new Error('must not coerce'); }})", + ] { + let loader = + crate::network::ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let (mut page_vm, _resource, _wake) = page_vm_with_bound_task_sources_and_owner_wake( + &loader, + Url::parse("https://example.com/child-module-errors.html").unwrap(), + ); + queue_inline_child_error(&mut page_vm, &loader, "throw globalThis.__reason;", value) + .await?; + assert!( + page_vm + .run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::ChildDocumentScriptReady, + &loader, + ) + .await? + ); + assert_eq!( + page_vm + .vm_mut() + .eval_without_microtask_checkpoint_for_test( + r#" + JSON.stringify([ + __childErrors.length, __childOnerrors.length, + Object.is(__childErrors[0]?.[0], child.__reason), + Object.is(__childOnerrors[0], child.__reason), + __childErrors[0]?.slice(1, 4).every(Boolean), + __parentErrors, __scriptErrors, __scriptLoads, __coercions + ]) + "# + )?, + "[1,1,true,true,true,0,0,0,0]", + "{value}" + ); + } + Ok::<_, anyhow::Error>(()) + }) + .await + .unwrap(); +} + +#[tokio::test(flavor = "current_thread")] +async fn child_module_error_reporting_distinguishes_fetch_parse_and_evaluation_failures() { + run_page_vm_async_test(async { + for kind in ["fetch", "parse", "evaluate", "retire"] { + let status = if kind == "fetch" { "HTTP/1.1 404 Not Found" } else { "HTTP/1.1 200 OK" }; + let source = if kind == "parse" { "export const broken = ;" } else { "throw globalThis.__reason;" }; + let (base_url, server) = spawn_path_response_http_server(vec![( + "/child-module-task-boundary.js", status, source.to_owned(), Duration::from_millis(50), + )]).await; + let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let (mut page_vm, _resource, _wake) = page_vm_with_bound_task_sources_and_owner_wake( + &loader, Url::parse(&format!("{base_url}/page")).unwrap(), + ); + queue_child_module_document_script_ready(&mut page_vm, &base_url, false).await?; + install_child_error_observers(&mut page_vm, "child-module-task-boundary", "Object.freeze(new child.TypeError('original'))")?; + if kind == "retire" { + page_vm.vm_mut().eval("child.addEventListener('error', () => document.getElementById('child-module-task-boundary').remove())")?; + } + assert!(page_vm.run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::ChildDocumentScriptReady, &loader, + ).await?); + let expected = match kind { + "fetch" => "0|0|0|1|0|0", + "retire" => "1|1|0|0|0|0", + _ => "1|1|0|0|1|0", + }; + assert_eq!(page_vm.vm_mut().eval_without_microtask_checkpoint_for_test( + "[__childErrors.length, __childOnerrors.length, __parentErrors, __scriptErrors, __scriptLoads, __unhandled].join('|')", + )?, expected, "{kind}"); + assert_eq!(page_vm.vm_mut().eval_without_microtask_checkpoint_for_test(&format!(r#" + __childErrors.every((entry, i) => entry[1] && entry[2] && entry[3] && + entry[0] === __childOnerrors[i] && + ({parse} ? entry[4] : Object.is(entry[0], expectedReason))) + "#, parse = kind == "parse"))?, "true", "{kind}"); + if matches!(kind, "parse" | "evaluate") { + assert_eq!(page_vm.vm_mut().eval_without_microtask_checkpoint_for_test( + "__childErrorOrder.indexOf('window-error') < __childErrorOrder.indexOf('script-load') && __childErrorOrder.includes('error-microtask')", + )?, "true", "{kind}"); + } + server.await.unwrap(); + } + Ok::<_, anyhow::Error>(()) + }).await.unwrap(); +} + +#[tokio::test(flavor = "current_thread")] +async fn child_module_error_reporting_preserves_deferred_rejections_without_repeating_load() { + run_page_vm_async_test(async { + for value in [ + "Object.freeze(new child.TypeError('original'))", + "undefined", + "({toString() { ++__coercions; throw new Error('must not coerce'); }})", + ] { + let (base_url, server) = spawn_path_response_http_server(vec![( + "/child-module-task-boundary.js", + "HTTP/1.1 200 OK", + "await new Promise((_, reject) => { globalThis.__reject = reject; });".to_owned(), + Duration::from_millis(50), + )]) + .await; + let loader = + crate::network::ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let (mut page_vm, _resource, _wake) = page_vm_with_bound_task_sources_and_owner_wake( + &loader, + Url::parse(&format!("{base_url}/page")).unwrap(), + ); + queue_child_module_document_script_ready(&mut page_vm, &base_url, false).await?; + install_child_error_observers(&mut page_vm, "child-module-task-boundary", value)?; + assert!( + page_vm + .run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::ChildDocumentScriptReady, + &loader, + ) + .await? + ); + assert_eq!( + page_vm + .vm_mut() + .eval_without_microtask_checkpoint_for_test( + "[__childErrors.length, __scriptLoads].join('|')", + )?, + "0|1" + ); + run_child_domcontentloaded_then_host_load_for_wait(&mut page_vm, "pending child TLA") + .await; + page_vm.vm_mut().eval("child.__reject(expectedReason)")?; + assert!( + page_vm + .run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::ModuleReaction, + &loader, + ) + .await? + ); + assert!( + page_vm + .run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::ChildDocumentScriptReady, + &loader, + ) + .await? + ); + assert_eq!( + page_vm + .vm_mut() + .eval_without_microtask_checkpoint_for_test( + r#" + JSON.stringify([ + __childErrors.length, __childOnerrors.length, + Object.is(__childErrors[0]?.[0], expectedReason), + Object.is(__childOnerrors[0], expectedReason), + __childErrors[0]?.slice(1, 4).every(Boolean), + __scriptErrors, __scriptLoads, __parentErrors, __unhandled, __coercions, + __childErrorOrder.includes('error-microtask') + ]) + "# + )?, + "[1,1,true,true,true,0,1,0,0,0,true]", + "{value}" + ); + server.await.unwrap(); + } + Ok::<_, anyhow::Error>(()) + }) + .await + .unwrap(); +} + +#[tokio::test(flavor = "current_thread")] +async fn child_module_error_reporting_body_leaves_the_checkpoint_to_the_selected_task() { + run_page_vm_async_test(async { + let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let (mut page_vm, _resource, _wake) = page_vm_with_bound_task_sources_and_owner_wake( + &loader, Url::parse("https://example.com/child-module-errors.html").unwrap(), + ); + queue_inline_child_error(&mut page_vm, &loader, "export const broken = ;", "null").await?; + let outcome = page_vm.run_page_child_document_script_ready_body_for_test().await?.unwrap(); + assert!(matches!(outcome.action.target_effect, + crate::page_task_queue::PageChildDocumentScriptReadyTargetEffect::AppliedScriptOrEventToCurrentOwner { made_progress: true } + )); + assert_eq!(page_vm.vm_mut().eval_without_microtask_checkpoint_for_test( + "__childErrorOrder.join('|')", + )?, "window-error"); + Ok::<_, anyhow::Error>(()) + }).await.unwrap(); +} + +#[tokio::test(flavor = "current_thread")] +async fn child_module_error_reporting_discards_a_claim_from_a_replaced_document() { + run_page_vm_async_test(async { + let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let (mut page_vm, _resource, _wake) = page_vm_with_bound_task_sources_and_owner_wake( + &loader, Url::parse("https://example.com/child-module-errors.html").unwrap(), + ); + queue_inline_child_error(&mut page_vm, &loader, "export const broken = ;", "null").await?; + let claim = page_vm.claim_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::ChildDocumentScriptReady, + ).unwrap(); + page_vm.vm_mut().eval("document.getElementById('module-error-child').srcdoc = 'replacement'")?; + assert!(page_vm.run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::ChildNavigationCommit, &loader, + ).await?); + page_vm.vm_mut().eval_without_microtask_checkpoint_for_test( + "globalThis.__retiredCheckpoint = 0; Promise.resolve().then(() => ++__retiredCheckpoint)", + )?; + page_vm.run_claimed_selected_page_task_for_test(claim, &loader).await?; + assert_eq!(page_vm.vm_mut().eval_without_microtask_checkpoint_for_test( + "[__childErrors.length, __parentErrors, __scriptErrors, __scriptLoads, __retiredCheckpoint].join('|')", + )?, "0|0|0|0|0"); + Ok::<_, anyhow::Error>(()) + }).await.unwrap(); +} diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/child_parser_module_root_start_completion.rs b/moli-renderer-v8/src/runtime/page_vm/tests/child_parser_module_root_start_completion.rs index 7a5a8a991d3..2b4be1ec246 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/child_parser_module_root_start_completion.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/child_parser_module_root_start_completion.rs @@ -27,7 +27,7 @@ document.body.appendChild(frame); Ok(()) } -async fn advance_to_child_parser_module_root( +pub(super) async fn advance_to_child_parser_module_root( page_vm: &mut PageVm, loader: &crate::network::ResourceRequestClient, ) -> anyhow::Result<()> { 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 index 585c4405813..8908e4cc2fa 100644 --- 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 @@ -823,6 +823,13 @@ globalThis.__childModuleDeferFailureOrderFirst = 1;