From cf7e6e8b3e7310c826eeccdfd07d9522080a38b9 Mon Sep 17 00:00:00 2001
From: ldm0 <ldm2993593805@163.com>
Date: Wed, 9 Sep 2026 08:31:31 +0800
Subject: [PATCH] fix(document): initialize child navigation readiness

---
 moli-core/tests/scripts.rs                    |  3 +
 .../tests/scripts/child_error_insertion.rs    |  9 +-
 moli-core/tests/scripts/child_readiness.rs    | 86 +++++++++++++++++++
 .../context_host/child_documents/commit.rs    |  9 +-
 .../src/runtime/page_vm/tests/mod.rs          |  6 +-
 5 files changed, 108 insertions(+), 5 deletions(-)
 create mode 100644 moli-core/tests/scripts/child_readiness.rs

diff --git a/moli-core/tests/scripts.rs b/moli-core/tests/scripts.rs
index 1b37ef655d..5e7f9cf08b 100644
--- a/moli-core/tests/scripts.rs
+++ b/moli-core/tests/scripts.rs
@@ -22,6 +22,9 @@ mod preparation_errors;
 #[path = "scripts/child_error_insertion.rs"]
 mod child_error_insertion;
 
+#[path = "scripts/child_readiness.rs"]
+mod child_readiness;
+
 fn diagnostic_global<'a>(
     page: &'a moli_core::page::Page,
     name: &str,
diff --git a/moli-core/tests/scripts/child_error_insertion.rs b/moli-core/tests/scripts/child_error_insertion.rs
index a089a056a3..d9521bc783 100644
--- a/moli-core/tests/scripts/child_error_insertion.rs
+++ b/moli-core/tests/scripts/child_error_insertion.rs
@@ -28,7 +28,7 @@ async fn child_script_error_write_probe(
         parent.childErrorObserved({text: document.body.textContent,
           currentScriptIsNull: document.currentScript === null,
           tailMissing: document.getElementById('tail') === null,
-          eventType: event.type,
+          readyState: document.readyState, eventType: event.type,
           nestedRan: globalThis.nestedRan === true});
       }`;
       frame.srcdoc = '<!doctype html><head><script>' + handler + '<' + '/script></head>' +
@@ -73,3 +73,10 @@ async fn child_parser_fetch_error_write_executes_nested_inline_scripts() -> Resu
     assert_eq!(result["nestedRan"], true, "{result}");
     Ok(())
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn child_parser_fetch_error_handler_observes_loading_document() -> Result<()> {
+    let result = child_script_error_write_probe(false, false).await?;
+    assert_eq!(result["during"]["readyState"], "loading", "{result}");
+    Ok(())
+}
diff --git a/moli-core/tests/scripts/child_readiness.rs b/moli-core/tests/scripts/child_readiness.rs
new file mode 100644
index 0000000000..c912ac545d
--- /dev/null
+++ b/moli-core/tests/scripts/child_readiness.rs
@@ -0,0 +1,86 @@
+use super::*;
+
+#[tokio::test(flavor = "multi_thread")]
+async fn child_document_readiness_starts_loading_before_parser_scripts() -> Result<()> {
+    let server = FixtureServer::spawn().await?;
+    let browser = Browser::new(AppConfig::default())?;
+    let mut page = browser.fetch(&server.url("/static")).await?;
+    let result = page
+        .evaluate_runtime_expression_with_await_async(
+            r#"(async () => {
+              const srcdoc = await new Promise(resolve => {
+                const frame = document.createElement('iframe');
+                frame.onload = () => {
+                  resolve({states: frame.contentWindow.readyStates,
+                    readyState: frame.contentDocument.readyState});
+                  frame.remove();
+                };
+                frame.srcdoc = '<!doctype html><head><script>' +
+                  'window.readyStates = [document.readyState];' +
+                  'document.addEventListener("readystatechange", () => readyStates.push(document.readyState));' +
+                  '<' + '/script></head><body>ready';
+                document.body.append(frame);
+              });
+              const network = await new Promise(resolve => {
+                const frame = document.createElement('iframe');
+                frame.onload = () => {
+                  resolve({duringScriptLoad: frame.contentWindow.parserConnectedLoadWriteReadyState,
+                    readyState: frame.contentDocument.readyState});
+                  frame.remove();
+                };
+                frame.src = '/compat/parser-connected-external-classic-load-document-write-insertion-point';
+                document.body.append(frame);
+              });
+              return JSON.stringify({srcdoc, network, parent: document.readyState});
+            })()"#,
+            true,
+        )
+        .await?;
+    server.shutdown().await;
+    let value: serde_json::Value =
+        serde_json::from_str(result["value"].as_str().expect("child readiness probe"))?;
+    assert_eq!(
+        value,
+        serde_json::json!({
+            "srcdoc": {"states": ["loading", "interactive", "complete"], "readyState": "complete"},
+            "network": {"duringScriptLoad": "loading", "readyState": "complete"},
+            "parent": "complete"
+        })
+    );
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn child_document_readiness_keeps_initial_empty_and_detached_documents_complete() -> Result<()>
+{
+    let server = FixtureServer::spawn().await?;
+    let browser = Browser::new(AppConfig::default())?;
+    let mut page = browser.fetch(&server.url("/static")).await?;
+    let result = page
+        .evaluate_runtime_expression_with_await_async(
+            r#"(() => {
+              const frame = document.createElement('iframe');
+              document.body.append(frame);
+              const initialEmpty = frame.contentDocument.readyState;
+              frame.remove();
+              return JSON.stringify({initialEmpty,
+                detachedHtml: new DOMParser().parseFromString('<p>detached', 'text/html').readyState,
+                detachedXml: new DOMParser().parseFromString('<detached/>', 'application/xml').readyState,
+                createdHtml: document.implementation.createHTMLDocument('').readyState,
+                constructed: new Document().readyState});
+            })()"#,
+            true,
+        )
+        .await?;
+    server.shutdown().await;
+    let value: serde_json::Value =
+        serde_json::from_str(result["value"].as_str().expect("detached readiness probe"))?;
+    assert_eq!(
+        value,
+        serde_json::json!({
+            "initialEmpty": "complete", "detachedHtml": "complete", "detachedXml": "complete",
+            "createdHtml": "complete", "constructed": "complete"
+        })
+    );
+    Ok(())
+}
diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_documents/commit.rs b/moli-renderer-v8/src/native_bridge/context_host/child_documents/commit.rs
index ab48fb2216..390b3d6aad 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/child_documents/commit.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/child_documents/commit.rs
@@ -5,7 +5,10 @@ use crate::frame_owner_model::{
     DocumentCreationKind, FrameDocumentInteractiveLifecycleAction,
     FrameDocumentLocalWindowTransition, FrameLocalWindowOwnerTransition,
 };
-use crate::{document_runtime::DomHandle, frame_owner_model::FrameDocumentOwnerTransition};
+use crate::{
+    document_runtime::DomHandle, dom::native::DocumentReadyState,
+    frame_owner_model::FrameDocumentOwnerTransition,
+};
 use moli_web_mime::is_dom_parser_xml_mime;
 use url::Url;
 
@@ -200,6 +203,10 @@ impl JsContextHost {
                 );
             document_handle
         };
+        // Navigation-created Documents start loading before parser scripts can
+        // observe them. Keep the generic detached/initial-empty default complete.
+        let _ = self
+            .set_dom_document_ready_state_for_handle(document_handle, DocumentReadyState::Loading);
         let document_url = self.document_url_for_handle(document_handle);
         let document_base_url = self.document_base_url_for_handle(document_handle);
         let parser_document_url = document_url.clone();
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 01925d6800..a6f1b9b2c9 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs
@@ -3674,8 +3674,8 @@ async fn page_vm_child_parser_blocking_classic_waits_for_preceding_stylesheet()
                     page_vm
                         .vm_mut()
                         .eval("__childParserStylesheetEvents.join('|')")?,
-                    "script:stylesheet-ready:complete",
-                    "stylesheet source must be installed before the parser-blocking script executes"
+                    "script:stylesheet-ready:loading",
+                    "stylesheet source must be installed before the parser-blocking script executes while the document is still loading"
                 );
                 followup_sources.push(
                     run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
@@ -3752,7 +3752,7 @@ async fn page_vm_child_parser_blocking_classic_waits_for_preceding_stylesheet()
                 ChildFrameSemanticTurnKind::HostLoad,
             ]
         );
-        assert_eq!(final_events, "script:stylesheet-ready:complete|load");
+        assert_eq!(final_events, "script:stylesheet-ready:loading|load");
         server.await.expect("child parser stylesheet server should finish");
     })
     .await;