Skip to content

armgit / moli

Public Imported from GitHub
0

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

158 KB
Raw Blame
use super::*;

#[tokio::test(flavor = "multi_thread")]
async fn typed_attributes_resolve_scoped_references_against_live_nodes() {
    use super::{RendererDocumentNodeAttributesResolution as Attributes, RendererDomNodeReference};

    async fn attributes(
        page: &super::RendererPageHandle,
        reference: RendererDomNodeReference,
    ) -> Attributes {
        let (reply, _) = page
            .run_async_command(RendererPageCommand::DocumentNodeAttributes { reference })
            .await
            .expect("typed attributes query completes");
        let RendererPageReply::DocumentNodeAttributesResolution(result) = reply else {
            panic!("expected typed attribute resolution");
        };
        result
    }

    let runtime = JsRuntime::initialize();
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default())
        .expect("default resource request client");
    let page = create_test_html_page(
        &runtime,
        &loader,
        url::Url::parse("https://example.test/attributes").unwrap(),
        "<!doctype html><html><body><input id='probe' data-state='before'></body></html>",
    )
    .await;
    let (reply, _) = page
        .run_async_command(RendererPageCommand::DocumentQuerySelectorForDocument {
            inspector_session_id: Some("attributes-a".to_owned()),
            include_whitespace: false,
            selector: "#probe".to_owned(),
            multiple: false,
        })
        .await
        .expect("bind the frontend node in session A");
    let RendererPageReply::DocumentQuerySelectorResolution(
        RendererDocumentQuerySelectorResolution::Found(nodes),
    ) = reply
    else {
        panic!("expected probe node");
    };
    let node = nodes[0];
    let frontend = RendererDomNodeReference::FrontendNodeId {
        inspector_session_id: Some("attributes-a".to_owned()),
        frontend_node_id: node.frontend_node_id,
    };
    assert_eq!(
        attributes(&page, frontend.clone()).await,
        Attributes::Found(vec![
            ("id".to_owned(), "probe".to_owned()),
            ("data-state".to_owned(), "before".to_owned()),
        ])
    );
    assert_eq!(
        attributes(
            &page,
            RendererDomNodeReference::FrontendNodeId {
                inspector_session_id: Some("attributes-b".to_owned()),
                frontend_node_id: node.frontend_node_id,
            },
        )
        .await,
        Attributes::MissingNode,
        "a frontend node ID must not inherit another session's binding"
    );
    page.run_async_command(RendererPageCommand::EvaluateExpression {
        expression: "document.querySelector('#probe').setAttribute('data-state', 'after')"
            .to_owned(),
        await_promise: false,
    })
    .await
    .expect("mutate the live node");
    let backend = RendererDomNodeReference::BackendNodeId(node.backend_node_id);
    assert_eq!(
        attributes(&page, frontend.clone()).await,
        attributes(&page, backend.clone()).await,
        "frontend and backend references must read the same live node"
    );
    assert!(matches!(
        attributes(&page, backend.clone()).await,
        Attributes::Found(values) if values.contains(&("data-state".to_owned(), "after".to_owned()))
    ));
    page.run_async_command(RendererPageCommand::DiscardDomAgentFrontendBindings {
        inspector_session_id: Some("attributes-a".to_owned()),
    })
    .await
    .expect("discard session A's frontend bindings");
    assert_eq!(attributes(&page, frontend).await, Attributes::MissingNode);

    let other_page = create_test_html_page(
        &runtime,
        &loader,
        url::Url::parse("https://example.test/other-attributes").unwrap(),
        "<!doctype html><html><body><input id='other'></body></html>",
    )
    .await;
    assert_eq!(
        attributes(&other_page, backend).await,
        Attributes::MissingNode,
        "backend references must belong to the queried Page document"
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn outer_html_document_command_includes_only_author_shadow_roots() {
    let runtime = JsRuntime::initialize();
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default())
        .expect("default resource request client");
    let url = url::Url::parse("https://example.test/outer-html-shadow").unwrap();
    let page = create_test_html_page(
        &runtime,
        &loader,
        url,
        concat!(
            "<!doctype html><html><body>",
            "<x-host id='host'><template shadowrootmode='closed'>",
            "<span>shadow</span></template>light</x-host>",
            "<input id='control'>",
            "</body></html>"
        ),
    )
    .await;

    let ordinary = outer_html_for_renderer_document(&page, false).await;
    let serialize_html = serialize_html_for_renderer_page(&page).await;
    assert_eq!(ordinary, serialize_html);
    assert!(!ordinary.contains("shadowrootmode"));
    assert!(!ordinary.contains("shadow"));

    let including_shadow = outer_html_for_renderer_document(&page, true).await;
    assert!(including_shadow.contains(concat!(
        "<x-host id=\"host\"><template shadowrootmode=\"closed\">",
        "<span>shadow</span></template>light</x-host>"
    )));
    assert_eq!(
        including_shadow
            .matches("<template shadowrootmode=")
            .count(),
        1
    );
    assert!(including_shadow.contains("<input id=\"control\">"));
    assert!(!including_shadow.contains("<input id=\"control\"><template"));
}
#[tokio::test(flavor = "multi_thread")]
async fn bounded_viewport_clip_keeps_root_controls_while_page_clip_omits_them() {
    let runtime = initialize_layout_test_runtime();
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default())
        .expect("default resource request client");
    let url = url::Url::parse("https://example.test/viewport-control-capture").unwrap();
    let page = create_test_html_page(
        &runtime,
        &loader,
        url,
        concat!(
            "<!doctype html><style>",
            "html,body{margin:0}",
            "html{scrollbar-color:rgb(255,0,0) rgb(0,0,255)}",
            "#content{width:200px;height:200px}",
            "</style><div id='content'></div>",
        ),
    )
    .await;
    let viewport = crate::protocol_types::ViewportSurface {
        inner_width: 100,
        inner_height: 100,
        outer_width: 100,
        outer_height: 100,
        device_pixel_ratio: 1.0,
        screen_width: 100,
        screen_height: 100,
        screen_avail_width: 100,
        screen_avail_height: 100,

        ..Default::default()
    };
    page.run_async_command(RendererPageCommand::SetViewportSurface(Some(viewport)))
        .await
        .expect("viewport should update");
    let clip = super::RendererScreenshotClip {
        x: 0.0,
        y: 0.0,
        width: 100.0,
        height: 100.0,
        scale: 1.0,
    };

    let viewport_clip = capture_screenshot_with_request(
        &page,
        super::RendererCaptureScreenshotRequest {
            base_background_color: [255; 4],
            format: super::RendererScreenshotFormat::Png,
            quality: 100,
            region: super::RendererScreenshotRegion::ViewportClip(clip),
            optimize_for_speed: false,
            max_width: None,
            max_height: None,
        },
    )
    .await;
    assert_eq!(
        decoded_png_pixel(&viewport_clip.bytes, 95, 30),
        [255, 0, 0, 255],
        "a bounded live-viewport capture includes its fixed root thumb"
    );
    assert_eq!(
        decoded_png_pixel(&viewport_clip.bytes, 92, 8),
        [255, 0, 0, 255],
        "the root control paints Chromium's up-arrow glyph"
    );
    assert_eq!(
        decoded_png_pixel(&viewport_clip.bytes, 87, 8),
        [0, 0, 255, 255],
        "the arrow remains centered inside its author-colored button"
    );

    let page_clip = capture_screenshot_with_request(
        &page,
        super::RendererCaptureScreenshotRequest {
            base_background_color: [255; 4],
            format: super::RendererScreenshotFormat::Png,
            quality: 100,
            region: super::RendererScreenshotRegion::PageClip(clip),
            optimize_for_speed: false,
            max_width: None,
            max_height: None,
        },
    )
    .await;
    assert_eq!(
        decoded_png_pixel(&page_clip.bytes, 95, 30),
        [255, 255, 255, 255],
        "a capture-beyond-viewport page clip omits compositor controls"
    );
}
#[test]
fn page_ids_are_unique_across_threads() {
    let runtime = JsRuntime::initialize();
    let renderer_owner = runtime.renderer_owner_handle();
    let ids = Arc::new(Mutex::new(Vec::new()));
    let mut workers = Vec::new();

    for _ in 0..4 {
        let renderer_owner = renderer_owner.clone();
        let ids = ids.clone();
        workers.push(std::thread::spawn(move || {
            let id = renderer_owner.allocate_page_id().as_u64();
            ids.lock().push(id);
        }));
    }

    for worker in workers {
        worker.join().expect("worker should finish");
    }

    let ids = ids.lock();
    assert_eq!(ids.len(), 4);
    let unique = ids.iter().copied().collect::<HashSet<_>>();
    assert_eq!(unique.len(), 4);
}
#[tokio::test(flavor = "multi_thread")]
async fn dropping_page_handle_runs_detached_owner_cleanup() {
    let runtime = JsRuntime::initialize();
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default())
        .expect("default resource request client");
    let url = url::Url::parse("https://example.test/detached-drop-cleanup").unwrap();
    let page = create_test_html_page(&runtime, &loader, url, "<!doctype html>").await;
    let testing = RendererPageTestingHandle::new_for_testing(&page);

    testing
        .owner_slot_async()
        .await
        .expect("page should initially occupy an owner slot");
    drop(page);

    let owner_slot_after_drop =
        tokio::time::timeout(Duration::from_secs(1), testing.owner_slot_async())
            .await
            .expect("detached remove-page command should not stall");
    assert!(
        owner_slot_after_drop.is_err(),
        "dropping the page handle should remove its owner slot"
    );
}
#[tokio::test(flavor = "multi_thread")]
async fn javascript_location_assignment_executes_renderer_owned_task_on_delegate_pages() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let url = url::Url::parse("https://javascript-location-ghost.test/start.html").unwrap();
    let mut page = create_test_html_page_with_navigation_dispatch(
        &runtime,
        &loader,
        url,
        "<!doctype html><title>start</title>",
        RendererTopLevelNavigationDispatch::DelegateToBrowser,
    )
    .await;

    let (set_reply, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"
globalThis.__javascriptLocationDone = new Promise(resolve => {
  globalThis.__resolveJavascriptLocation = resolve;
});
location.href = "javascript:document.title = 'LOC-RAN'; globalThis.__resolveJavascriptLocation('ran'); void 0";
"set"
"#
            .to_owned(),
            await_promise: false,
        })
        .await
        .expect("javascript: location assignment should complete");
    assert_eq!(
        renderer_json_value(set_reply),
        Some(serde_json::json!("set"))
    );

    let (href_reply, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: "location.href".to_owned(),
            await_promise: false,
        })
        .await
        .expect("location.href readback should complete");
    assert_eq!(
        renderer_json_value(href_reply),
        Some(serde_json::json!(
            "https://javascript-location-ghost.test/start.html"
        )),
        "assigning a javascript: URL must not ghost location.href"
    );

    let (task_reply, _) = tokio::time::timeout(
        Duration::from_secs(2),
        page.run_async_command(RendererPageCommand::EvaluateExpression {
            expression: "globalThis.__javascriptLocationDone".to_owned(),
            await_promise: true,
        }),
    )
    .await
    .expect("renderer-owned javascript: task should settle its promise")
    .expect("javascript: task promise should evaluate");
    assert_eq!(
        renderer_json_value(task_reply),
        Some(serde_json::json!("ran")),
        "the javascript: task must run after the assigning command"
    );

    let (title_reply, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: "document.title".to_owned(),
            await_promise: false,
        })
        .await
        .expect("document.title readback should complete");
    assert_eq!(
        renderer_json_value(title_reply),
        Some(serde_json::json!("LOC-RAN"))
    );

    page.close_async()
        .await
        .expect("javascript location ghost page should close");
}
#[tokio::test(flavor = "current_thread")]
async fn parser_failed_custom_element_construction_uses_unknown_element_surface() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let url = url::Url::parse("https://example.test/parser-failed-custom-element").unwrap();
    let html = r#"<!doctype html>
<body>
<script>
window.onerror = () => true;
globalThis.__ReturnsText = class extends HTMLElement {
  constructor() {
    super();
    return document.createTextNode("text");
  }
};
customElements.define("wpt-parser-returns-text", globalThis.__ReturnsText);
globalThis.__ReturnsObject = class extends HTMLElement {
  constructor() {
    super();
    return {};
  }
};
customElements.define("wpt-parser-returns-object", globalThis.__ReturnsObject);
globalThis.__LacksSuper = class extends HTMLElement {
  constructor() {}
};
customElements.define("wpt-parser-lacks-super", globalThis.__LacksSuper);
globalThis.__ThrowsElement = class extends HTMLElement {
  constructor() {
    throw new Error("boom");
  }
};
customElements.define("wpt-parser-throws", globalThis.__ThrowsElement);
</script>
<wpt-parser-returns-text></wpt-parser-returns-text>
<wpt-parser-returns-object></wpt-parser-returns-object>
<wpt-parser-lacks-super></wpt-parser-lacks-super>
<wpt-parser-throws></wpt-parser-throws>
</body>"#;
    let mut page = create_test_html_page(&runtime, &loader, url, html).await;

    let (reply, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"
(() => {
  function summarize(selector, constructor) {
    const element = document.querySelector(selector);
    return [
      element instanceof HTMLElement,
      element instanceof HTMLUnknownElement,
      element instanceof constructor
    ].join(":");
  }
  return [
    summarize("wpt-parser-returns-text", globalThis.__ReturnsText),
    summarize("wpt-parser-returns-object", globalThis.__ReturnsObject),
    summarize("wpt-parser-lacks-super", globalThis.__LacksSuper),
    summarize("wpt-parser-throws", globalThis.__ThrowsElement)
  ].join("|");
})()
"#
            .to_owned(),
            await_promise: false,
        })
        .await
        .expect("parser failed custom element fallback surface should evaluate");

    assert_eq!(
        renderer_json_value(reply),
        Some(serde_json::json!(
            "true:true:false|true:true:false|true:true:false|true:true:false"
        ))
    );
    page.close_async()
        .await
        .expect("parser failed custom element page should close");
}
#[tokio::test(flavor = "current_thread")]
async fn parser_custom_element_document_write_microtasks_wait_for_outer_script() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let url =
        url::Url::parse("https://example.test/parser-custom-element-write-microtasks").unwrap();
    let html = r#"<!doctype html><body>
<script>
window.onerror = () => true;
globalThis.constructorMicrotaskLog = [];
class WrittenElement extends HTMLElement {
  constructor() {
    super();
    constructorMicrotaskLog.push("constructor");
    Promise.resolve().then(() => {
      constructorMicrotaskLog.push("microtask");
      this.setAttribute("data-constructed", "yes");
    });
  }
}
customElements.define("microtask-written-element", WrittenElement);
document.write("<microtask-written-element></microtask-written-element>");
constructorMicrotaskLog.push("after-write");
constructorMicrotaskLog.push(document.querySelector("microtask-written-element") instanceof WrittenElement);
</script>
<script>constructorMicrotaskLog.push("following-script");</script>
</body>"#;
    let mut page = create_test_html_page(&runtime, &loader, url, html).await;

    let (reply, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: "JSON.stringify({log: constructorMicrotaskLog, value: document.querySelector('microtask-written-element').getAttribute('data-constructed')})".to_owned(),
            await_promise: false,
        })
        .await
        .expect("parser document.write microtask order should evaluate");

    assert_eq!(
        renderer_json_value(reply),
        Some(serde_json::json!(
            r#"{"log":["constructor","after-write",true,"microtask","following-script"],"value":"yes"}"#
        ))
    );
    page.close_async()
        .await
        .expect("parser document.write microtask page should close");
}
#[tokio::test(flavor = "current_thread")]
async fn parser_custom_element_microtask_mutation_fails_before_validation() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let url =
        url::Url::parse("https://example.test/parser-custom-element-microtask-failure").unwrap();
    let html = r#"<!doctype html>
<body>
<script>
window.onerror = () => true;
globalThis.__ParserMicrotaskMutates = class extends HTMLElement {
  constructor() {
    super();
    Promise.resolve().then(() => this.setAttribute("attribute", "value"));
  }
};
customElements.define("wpt-parser-microtask-mutates", globalThis.__ParserMicrotaskMutates);
</script>
<wpt-parser-microtask-mutates></wpt-parser-microtask-mutates>
</body>"#;
    let mut page = create_test_html_page(&runtime, &loader, url, html).await;

    let (reply, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"
(() => {
  const element = document.querySelector("wpt-parser-microtask-mutates");
  return [
    element.hasAttribute("attribute"),
    element instanceof HTMLUnknownElement,
    element instanceof globalThis.__ParserMicrotaskMutates
  ].join(":");
})()
"#
            .to_owned(),
            await_promise: false,
        })
        .await
        .expect("parser microtask mutation fallback should evaluate");

    assert_eq!(
        renderer_json_value(reply),
        Some(serde_json::json!("false:true:false"))
    );
    page.close_async()
        .await
        .expect("parser microtask mutation page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn runtime_binding_replay_cannot_consume_same_id_frontend_deferred_response() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url = url::Url::parse("https://example.test/inspector-internal-id-collision").unwrap();
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        "<!doctype html><body>inspector internal id collision</body>",
    )
    .await;

    let colliding_call_id = 900_100_000;
    let (response_tx, mut response_rx) = oneshot::channel();
    let (dispatch, _) = page
        .run_async_command(
            RendererPageCommand::dispatch_runtime_protocol_message_with_deferred_response(
                None,
                serde_json::json!({
                    "id": colliding_call_id,
                    "method": "Runtime.evaluate",
                    "params": {
                        "expression": "new Promise(resolve => { globalThis.__resolveInspectorCollision = resolve; })",
                        "awaitPromise": true,
                        "returnByValue": true,
                    },
                })
                .to_string(),
                RendererRuntimeInspectorResponseSender::new(
                    colliding_call_id,
                    response_tx,
                ),
            ),
        )
        .await
        .expect("frontend awaitPromise should remain deferred");
    assert!(matches!(
        dispatch,
        RendererPageReply::RuntimeInspectorProtocolMessages(ref messages) if messages.is_empty()
    ));

    let binding = crate::protocol_types::RuntimeBindingRegistration {
        devtools_session: None,
        name: "internalCollisionBinding".to_owned(),
        execution_context_name: None,
    };
    set_runtime_binding_state_for_test(&page, None, Vec::new(), vec![binding])
        .await
        .expect("runtime binding state should become pending for replay");
    let replay_trigger_messages = dispatch_runtime_protocol_for_test(
        &page,
        serde_json::json!({
            "id": 710_100,
            "method": "Runtime.evaluate",
            "params": {
                "expression": "typeof internalCollisionBinding",
                "returnByValue": true,
            },
        }),
    )
    .await
    .expect("a later frontend dispatch should replay the new binding");
    assert_eq!(
        runtime_protocol_response_by_id(&replay_trigger_messages, 710_100)
            .expect("replay trigger response")["result"]["result"]["value"],
        serde_json::json!("function")
    );
    assert!(
        matches!(
            response_rx.try_recv(),
            Err(tokio::sync::oneshot::error::TryRecvError::Empty)
        ),
        "the internal Runtime.addBinding response must not complete the same-id frontend await"
    );

    let (resolved, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: "__resolveInspectorCollision('frontend-result'); 'resolved'".to_owned(),
            await_promise: false,
        })
        .await
        .expect("the page should resolve the original frontend promise");
    assert_eq!(
        renderer_json_value(resolved),
        Some(serde_json::json!("resolved"))
    );
    let completion = tokio::time::timeout(Duration::from_secs(2), &mut response_rx)
        .await
        .expect("the frontend promise response publication should not stall")
        .expect("the frontend promise response should retain its callback owner");
    assert_eq!(completion.call_id, colliding_call_id);
    let response = completion
        .output
        .protocol_response(colliding_call_id)
        .expect("frontend completion should contain its protocol response");
    assert_eq!(
        response["result"]["result"]["value"],
        serde_json::json!("frontend-result")
    );

    page.close_async()
        .await
        .expect("internal collision test page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn page_document_isolate_completes_real_v8_foreground_task() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url = url::Url::parse("https://example.test/shared-v8-foreground-task").unwrap();

    let (page, _, _, _creation_artifacts, pending_download) = runtime
        .create_html_page_from_response(
            page_url.clone(),
            page_url,
            None,
            false,
            0,
            200,
            vec![("content-type".to_owned(), b"text/html".to_vec())],
            &loader,
            crate::RendererWebStorageHandles::ephemeral(),
            "<!doctype html><body>shared v8 foreground task</body>".to_owned(),
            crate::RendererDocumentOptions {
                ..Default::default()
            },
        )
        .await
        .expect("shared-isolate page should load");
    assert!(pending_download.is_none());

    let (observed, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"(async () => {
  try {
    await WebAssembly.compile(new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0]));
    return "compiled";
  } catch (error) {
    return "error:" + error.name;
  }
})()"#
                .to_owned(),
            await_promise: true,
        })
        .await
        .expect("wasm compilation should finish through the Page isolate foreground-task route");
    assert_eq!(
        renderer_json_value(observed),
        Some(serde_json::json!("compiled")),
        "the Page isolate must remain routable while V8 completes foreground work"
    );
}
#[tokio::test(flavor = "multi_thread")]
async fn child_default_runtime_evaluate_pending_await_promise_does_not_leak_internal_token() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url = url::Url::parse("https://example.test/child-runtime-await-promise").unwrap();
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        r#"<!doctype html><body><iframe srcdoc="<body>pending promise child</body>"></iframe></body>"#,
    )
    .await;

    let child_context_ids = child_default_context_ids_for_test(&page)
        .await
        .expect("child context events should replay");
    assert_eq!(
        child_context_ids.len(),
        1,
        "page should expose exactly one child default context"
    );
    let child_context_id = child_context_ids[0];

    let (response_tx, mut response_rx) = oneshot::channel();
    let (evaluate, _) = page
        .run_async_command(
            RendererPageCommand::dispatch_runtime_protocol_message_with_context_resolution_and_deferred_response(
                None,
                "evaluate".to_owned(),
                serde_json::json!({
                    "id": 67,
                    "method": "Runtime.evaluate",
                    "params": {
                        "contextId": child_context_id,
                        "expression": "new Promise(resolve => { globalThis.resolveChildAwait = resolve; })",
                        "awaitPromise": true,
                        "returnByValue": true
                    }
                }).to_string(),
                RendererRuntimeInspectorResponseSender::new(67, response_tx),
            ),
        )
        .await
        .expect("child Runtime.evaluate awaitPromise should dispatch");
    assert!(matches!(
        evaluate,
        RendererPageReply::RuntimeInspectorProtocolMessages(ref messages) if messages.is_empty()
    ));
    assert!(matches!(
        response_rx.try_recv(),
        Err(tokio::sync::oneshot::error::TryRecvError::Empty)
    ));

    let resolved = dispatch_runtime_protocol_with_context_resolution_for_test(
        &page,
        "evaluate",
        serde_json::json!({
            "id": 68,
            "method": "Runtime.evaluate",
            "params": {
                "contextId": child_context_id,
                "expression": "resolveChildAwait('child-result'); 'resolved'",
                "returnByValue": true
            }
        }),
    )
    .await
    .expect("the pending child evaluation must release Page dispatch");
    assert_eq!(
        runtime_protocol_response_by_id(&resolved, 68).expect("resolver response")["result"]["result"]
            ["value"],
        serde_json::json!("resolved")
    );
    let completion = tokio::time::timeout(Duration::from_secs(2), &mut response_rx)
        .await
        .expect("the child Promise response must settle on its Page owner")
        .expect("the child response must retain its callback owner");
    assert_eq!(completion.call_id, 67);
    let response = completion
        .output
        .protocol_response(67)
        .expect("child awaitPromise response");
    let messages: Vec<_> = completion
        .output
        .messages()
        .iter()
        .cloned()
        .map(RendererRuntimeInspectorMessage::into_v8_inspector_message)
        .collect();
    let messages_json =
        serde_json::to_string(&messages).expect("Runtime.evaluate messages should serialize");
    assert!(
        !messages_json.contains("__moliAwaitPromiseToken"),
        "child Runtime.evaluate awaitPromise leaked internal polling token: {messages_json}"
    );
    assert!(
        !messages_json.contains("__moliPendingPromise"),
        "child Runtime.evaluate awaitPromise leaked internal pending marker: {messages_json}"
    );
    assert!(
        response.get("error").is_none() && response["result"].get("exceptionDetails").is_none(),
        "a resolved child Promise must return its native result: {response:?}"
    );
    assert_eq!(response["result"]["result"]["value"], "child-result");

    page.close_async()
        .await
        .expect("child runtime awaitPromise page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn runtime_enable_waits_for_queued_child_realm_before_reporting_contexts() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url =
        url::Url::parse("https://example.test/runtime-enable-child-barrier").expect("test url");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        "<!doctype html><body>child realm barrier</body>",
    )
    .await;

    // Queue Runtime.enable before yielding. The Page scheduler admits the
    // child-realm wake after the setup command, then permits one already-ready
    // command to overtake that Page turn. This makes the production race
    // deterministic: Runtime.enable must park behind the exact-Document realm
    // task instead of reporting an incomplete current-context inventory.
    let setup = page
        .enqueue_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"(() => {
  const frame = document.createElement("iframe");
  frame.id = "runtime-enable-barrier-child";
  document.body.appendChild(frame);
  void frame.contentWindow.Function;
  return "queued";
})()"#
                .to_owned(),
            await_promise: false,
        })
        .expect("child realm setup command should enqueue");
    let enable = page
        .enqueue_async_command(RendererPageCommand::runtime_enable_events(Some(
            "SID-runtime-enable-child-barrier".to_owned(),
        )))
        .expect("Runtime.enable command should enqueue behind child realm setup");

    let setup = setup
        .wait()
        .await
        .expect("child realm setup command should complete");
    let (setup, _) = setup.into_completion_and_predecessor();
    let (setup_reply, _, _) = setup.into_parts();
    assert_eq!(
        renderer_json_value(setup_reply),
        Some(serde_json::json!("queued"))
    );

    let enable = enable
        .wait()
        .await
        .expect("Runtime.enable should resume after child realm materialization");
    let (enable, _) = enable.into_completion_and_predecessor();
    let (enable_reply, _, _) = enable.into_parts();
    let RendererPageReply::RuntimeInspectorProtocolMessages(output) = enable_reply else {
        panic!("Runtime.enable should return inspector protocol messages");
    };
    let messages = output
        .into_messages()
        .into_iter()
        .map(runtime_inspector_message_protocol_message_for_test)
        .collect::<Vec<_>>();
    let child_context = messages.iter().find(|message| {
        message["method"] == serde_json::json!("Runtime.executionContextCreated")
            && message["params"]["context"]["auxData"]["isDefault"] == serde_json::json!(true)
            && message["params"]["context"]["auxData"]["frameId"].is_string()
    });
    assert!(
        child_context.is_some(),
        "Runtime.enable must report the child context created by its materialization prerequisite: {messages:?}"
    );

    page.close_async()
        .await
        .expect("Runtime.enable child barrier page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn runtime_enable_events_for_new_inspector_session_replays_existing_isolated_worlds() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url =
        url::Url::parse("https://example.test/runtime-enable-new-session").expect("test url");

    let (page, _, _, _creation_artifacts, pending_download) = runtime
        .create_html_page_from_response(
            page_url.clone(),
            page_url,
            None,
            false,
            0,
            200,
            vec![("content-type".to_owned(), b"text/html".to_vec())],
            &loader,
            crate::RendererWebStorageHandles::ephemeral(),
            "<!doctype html><body>new inspector session</body>".to_owned(),
            crate::RendererDocumentOptions {
                ..Default::default()
            },
        )
        .await
        .expect("new-session runtime replay test page should load");
    assert!(pending_download.is_none());

    let world_context_id = create_isolated_world_for_test(&page, "new-session-utility")
        .await
        .expect("isolated world should be created before the inspector session enables Runtime");

    let events = runtime_enable_events_for_inspector_session_for_test(
        &page,
        Some("SID-new-runtime-session"),
    )
    .await
    .expect("new inspector session Runtime.enable should run");
    let context_ids = runtime_execution_context_ids(&events);
    assert!(
        context_ids.contains(&world_context_id),
        "new inspector session Runtime.enable should replay existing isolated world: {events:?}"
    );
}
#[tokio::test(flavor = "multi_thread")]
async fn runtime_enable_events_include_renderer_root_frame_id_for_default_context() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url =
        url::Url::parse("https://example.test/runtime-enable-root-frame").expect("test url");
    let root_frame_id = "TID-runtime-enable-root-frame";

    let (mut page, _, _, _creation_artifacts, pending_download) = runtime
        .create_html_page_from_response(
            page_url.clone(),
            page_url,
            None,
            false,
            0,
            200,
            vec![("content-type".to_owned(), b"text/html".to_vec())],
            &loader,
            crate::RendererWebStorageHandles::ephemeral(),
            "<!doctype html><body>root frame id</body>".to_owned(),
            crate::RendererDocumentOptions {
                root_frame_id: Some(root_frame_id.to_owned()),
                ..Default::default()
            },
        )
        .await
        .expect("root-frame test page should load");
    assert!(pending_download.is_none());

    let events = runtime_enable_events_for_test(&page)
        .await
        .expect("Runtime.enable replay should run");
    let default_contexts = events
        .iter()
        .filter(|message| {
            message.get("method") == Some(&serde_json::json!("Runtime.executionContextCreated"))
                && message["params"]["context"]["auxData"]["isDefault"] == serde_json::json!(true)
                && message["params"]["context"]["auxData"]["type"] == serde_json::json!("default")
        })
        .collect::<Vec<_>>();

    assert_eq!(
        default_contexts.len(),
        1,
        "Runtime.enable should expose exactly one top-level default context: {events:?}"
    );
    assert_eq!(
        default_contexts[0]["params"]["context"]["auxData"]["frameId"],
        serde_json::json!(root_frame_id),
        "renderer Runtime.enable output should carry the root frame id before protocol emission"
    );
    assert_eq!(
        default_contexts[0]["params"]["context"]["origin"],
        serde_json::json!("https://example.test"),
        "renderer Runtime.enable output should carry the document security origin"
    );

    page.close_async()
        .await
        .expect("root-frame test page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn set_runtime_binding_state_updates_renderer_inspector_session_store() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let url = url::Url::parse("https://example.test/renderer-runtime-binding-state").unwrap();
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        url,
        "<!doctype html><body>renderer runtime binding state</body>",
    )
    .await;
    let binding = crate::protocol_types::RuntimeBindingRegistration {
        devtools_session: None,
        name: "rendererSessionStoredBinding".to_owned(),
        execution_context_name: None,
    };

    set_runtime_binding_state_for_test(&page, None, vec![binding.clone()], vec![binding])
        .await
        .expect("renderer runtime binding state should update");
    runtime_enable_events_for_test(&page)
        .await
        .expect("Runtime.enable should replay renderer-stored bindings");

    let (binding_type, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"typeof rendererSessionStoredBinding"#.to_owned(),
            await_promise: false,
        })
        .await
        .expect("renderer-stored binding type should evaluate");
    assert_eq!(
        renderer_json_value(binding_type),
        Some(serde_json::json!("function")),
        "Runtime.enable should replay bindings from renderer inspector session state"
    );

    page.close_async()
        .await
        .expect("renderer binding state test page should close");

    let clearing_url =
        url::Url::parse("https://example.test/renderer-runtime-binding-state-cleared").unwrap();
    let mut clearing_page = create_test_html_page(
        &runtime,
        &loader,
        clearing_url,
        "<!doctype html><body>renderer runtime binding state cleared</body>",
    )
    .await;
    let scoped_binding = crate::protocol_types::RuntimeBindingRegistration {
        devtools_session: None,
        name: "rendererSessionClearedBinding".to_owned(),
        execution_context_name: Some("cleared-binding-world".to_owned()),
    };

    set_runtime_binding_state_for_test(
        &clearing_page,
        None,
        vec![scoped_binding.clone()],
        vec![scoped_binding],
    )
    .await
    .expect("renderer runtime binding state should accept pending named-world binding");
    set_runtime_binding_state_for_test(&clearing_page, None, Vec::new(), Vec::new())
        .await
        .expect("renderer runtime binding state should clear pending named-world binding");
    runtime_enable_events_for_test(&clearing_page)
        .await
        .expect("Runtime.enable should run with cleared renderer session state");
    let cleared_world_context_id =
        create_isolated_world_for_test(&clearing_page, "cleared-binding-world")
            .await
            .expect("cleared binding world should be created");
    let (cleared_binding_type, _) = clearing_page
        .run_async_command(RendererPageCommand::EvaluateExpressionInExecutionContext {
            execution_context_id: cleared_world_context_id,
            expression: r#"typeof rendererSessionClearedBinding"#.to_owned(),
            await_promise: false,
        })
        .await
        .expect("cleared renderer-stored binding type should evaluate");
    assert_eq!(
        renderer_json_value(cleared_binding_type),
        Some(serde_json::json!("undefined")),
        "cleared renderer inspector session state must not replay stale named-world bindings"
    );

    clearing_page
        .close_async()
        .await
        .expect("renderer binding clearing test page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn apply_runtime_protocol_state_keeps_session_binding_replay_scoped() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let url =
        url::Url::parse("https://example.test/runtime-protocol-state-session-bindings").unwrap();
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        url,
        "<!doctype html><body>runtime protocol state session bindings</body>",
    )
    .await;
    let stored_only_binding = crate::protocol_types::RuntimeBindingRegistration {
        devtools_session: None,
        name: "storedOnlySessionBinding".to_owned(),
        execution_context_name: Some("stored-only-world".to_owned()),
    };

    let (reply, _) = page
        .run_async_command(RendererPageCommand::apply_runtime_protocol_state(
            Some("SID-primary".to_owned()),
            Vec::new(),
            Vec::new(),
            vec![stored_only_binding],
            Vec::new(),
        ))
        .await
        .expect("runtime protocol state should apply");
    assert!(
        matches!(reply, RendererPageReply::Unit),
        "expected ApplyRuntimeProtocolState to return unit reply"
    );

    let context_id = create_isolated_world_runtime_activity_for_test(
        &page,
        Some("SID-primary"),
        "stored-only-world",
    )
    .await
    .expect("runtime activity should create stored-only world");
    let (binding_type, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpressionInExecutionContext {
            execution_context_id: context_id,
            expression: "typeof storedOnlySessionBinding".to_owned(),
            await_promise: false,
        })
        .await
        .expect("stored-only binding type should evaluate");
    assert_eq!(
        renderer_json_value(binding_type),
        Some(serde_json::json!("undefined")),
        "ApplyRuntimeProtocolState must not copy page-level stored bindings into the current inspector session replay store"
    );

    page.close_async()
        .await
        .expect("renderer protocol-state session binding test page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn inspector_output_flushes_v8_state_for_commands_and_notifications() {
    let runtime = JsRuntime::initialize();
    let (output_tx, mut output_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(output_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let url = url::Url::parse("https://example.test/inspector-state-output").unwrap();
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        url,
        "<!doctype html><body>inspector state output</body>",
    )
    .await;

    let (enable_messages, enable_output) = dispatch_runtime_protocol_with_output_for_test(
        &page,
        serde_json::json!({
            "id": 701,
            "method": "Runtime.enable",
        }),
    )
    .await
    .expect("Runtime.enable should dispatch");
    assert!(
        runtime_protocol_response_by_id(&enable_messages, 701)
            .is_some_and(|message| message.get("error").is_none()),
        "Runtime.enable should return a successful response: {enable_messages:?}"
    );
    let command_state = enable_output
        .v8_state_update()
        .expect("a V8 command response should flush the latest session state");
    assert!(
        !command_state.is_empty(),
        "Runtime.enable should produce a non-empty V8 state cookie"
    );
    assert!(
        output_rx.drain().iter().all(|publication| {
            publication.records().iter().all(|record| {
                !matches!(
                    record.item(),
                    RendererOutputItem::Observation(
                        RendererProtocolObservation::RuntimeInspector(batch)
                    ) if batch.messages.iter().any(|message| matches!(
                        message,
                        RendererRuntimeInspectorMessage::Protocol(message)
                            if message.get("id").and_then(serde_json::Value::as_i64) == Some(701)
                    ))
                )
            })
        }),
        "a synchronous Runtime response must not leak into the live notification stream"
    );

    page.run_async_command(RendererPageCommand::EvaluateExpression {
        expression: "console.log('state-notification-marker')".to_owned(),
        await_promise: false,
    })
    .await
    .expect("console evaluation should complete");
    assert!(
        output_rx.drain().iter().any(|publication| {
            publication.records().iter().any(|record| matches!(
                record.item(),
                RendererOutputItem::Observation(RendererProtocolObservation::RuntimeInspector(batch))
                    if batch.v8_state_update
                        .as_ref()
                        .is_some_and(|state| !state.is_empty())
                        && batch.messages.iter().any(|message| matches!(
                            message,
                            RendererRuntimeInspectorMessage::Protocol(message)
                                if message.get("method")
                                    == Some(&serde_json::json!("Runtime.consoleAPICalled"))
                        ))
            ))
        }),
        "the producing turn's concrete Runtime notification must carry the latest V8 state"
    );

    page.close_async()
        .await
        .expect("inspector state output page should close");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn owner_command_fences_exact_cursor_when_later_output_is_already_published() {
    let runtime = JsRuntime::initialize();
    let (output_tx, mut output_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(output_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let url = url::Url::parse("https://example.test/concurrent-command-output").unwrap();
    let mut page =
        create_test_html_page(&runtime, &loader, url, "<!doctype html><body>before</body>").await;

    let (enable_messages, _) = dispatch_runtime_protocol_with_output_for_test(
        &page,
        serde_json::json!({
            "id": 711,
            "method": "Runtime.enable",
        }),
    )
    .await
    .expect("Runtime.enable should dispatch");
    assert!(
        runtime_protocol_response_by_id(&enable_messages, 711)
            .is_some_and(|message| message.get("error").is_none()),
        "Runtime.enable should succeed before the command-output race: {enable_messages:?}"
    );
    output_rx.drain();

    runtime.publish_next_command_output_before_owner_settlement_for_testing();
    let pending_evaluate = page
        .enqueue_async_command(RendererPageCommand::EvaluateExpression {
            expression: "console.log('concurrent-command-output'); 'done'".to_owned(),
            await_promise: false,
        })
        .expect("Runtime.evaluate should enqueue");
    let concurrent_publication = tokio::time::timeout(Duration::from_secs(3), output_rx.recv())
        .await
        .expect("the test publication should not hang")
        .expect("the test hook should settle the pending owner-command records");
    assert!(
        concurrent_publication
            .records()
            .iter()
            .any(|record| matches!(
                record.item(),
                RendererOutputItem::Observation(RendererProtocolObservation::RuntimeInspector(batch))
                    if batch.messages.iter().any(|message| matches!(
                        message,
                        RendererRuntimeInspectorMessage::Protocol(message)
                            if message.get("method")
                                == Some(&serde_json::json!("Runtime.consoleAPICalled"))
                    ))
            )),
        "the early publication must own the Runtime notification emitted by the owner command"
    );
    let trailing_publication = tokio::time::timeout(Duration::from_secs(3), output_rx.recv())
        .await
        .expect("the trailing test publication should not hang")
        .expect("final owner settlement should publish a later independent batch");
    assert!(
        trailing_publication.records().iter().any(|record| matches!(
            record.item(),
            RendererOutputItem::Observation(RendererProtocolObservation::RuntimeLifecycleError {
                text,
                execution_context_id: None,
            }) if text == "test trailing output publication"
        )),
        "final Page settlement should publish the independent trailing test output"
    );
    assert_eq!(
        trailing_publication.cursor().sequence(),
        concurrent_publication.cursor().sequence() + 1,
        "the independent output must follow the command publication"
    );

    let evaluate_output = tokio::time::timeout(Duration::from_secs(3), pending_evaluate.wait())
        .await
        .expect("owner command should not hang after the IO publication")
        .expect("owner command should complete after its records were settled by IO");
    assert_eq!(
        evaluate_output
            .renderer_output_predecessor()
            .expect("owner response must retain the concurrently settled prefix")
            .cursor(),
        concurrent_publication.cursor()
    );
    assert_ne!(
        evaluate_output
            .renderer_output_predecessor()
            .expect("owner response must retain an exact output prefix")
            .cursor(),
        trailing_publication.cursor(),
        "the response fence must not drift to output published after its command batch"
    );

    page.close_async()
        .await
        .expect("concurrent command output page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn page_diagnostics_snapshot_is_read_only_for_current_inspector_output() {
    let runtime = JsRuntime::initialize();
    let (output_tx, mut output_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(output_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let url = url::Url::parse("https://example.test/exact-document-inspector-snapshot").unwrap();
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        url,
        "<!doctype html><body>exact document inspector snapshot</body>",
    )
    .await;

    let (identity_reply, _) = page
        .run_async_command(RendererPageCommand::PageDiagnosticsSnapshot)
        .await
        .expect("initial page diagnostics snapshot should complete");
    let RendererPageReply::PageDiagnosticsSnapshot(identity_snapshot) = identity_reply else {
        panic!("page diagnostics command should return an activity snapshot");
    };
    let current_document = identity_snapshot
        .document_lifecycle_identity()
        .expect("snapshot should carry the current Document identity");
    while output_rx.try_recv().is_ok() {}

    dispatch_runtime_protocol_with_output_for_test(
        &page,
        serde_json::json!({
            "id": 702,
            "method": "Runtime.enable",
        }),
    )
    .await
    .expect("Runtime.enable should dispatch");
    while output_rx.try_recv().is_ok() {}
    page.enqueue_async_command(RendererPageCommand::EvaluateExpression {
        expression: "console.log('exact-document-snapshot-marker')".to_owned(),
        await_promise: false,
    })
    .expect("console evaluation should enqueue")
    .wait()
    .await
    .expect("console evaluation should complete");
    assert!(
        output_rx.drain().iter().any(|publication| {
            publication.records().iter().any(|record| matches!(
                record.item(),
                RendererOutputItem::Observation(RendererProtocolObservation::RuntimeInspector(batch))
                    if batch.messages.iter().any(|message| matches!(
                        message,
                        RendererRuntimeInspectorMessage::Protocol(message)
                            if message.get("method")
                                == Some(&serde_json::json!("Runtime.consoleAPICalled"))
                    ))
            ))
        }),
        "console output must be frozen in the producing turn's concrete publication"
    );

    let (snapshot_reply, _) = page
        .run_async_command(RendererPageCommand::PageDiagnosticsSnapshot)
        .await
        .expect("read-only activity snapshot should complete");
    let RendererPageReply::PageDiagnosticsSnapshot(snapshot) = snapshot_reply else {
        panic!("activity command should return a snapshot");
    };
    assert_eq!(
        snapshot.document_lifecycle_identity(),
        Some(current_document)
    );
    assert_eq!(
        snapshot.diagnostics.pending_inspector_messages, 0,
        "published Inspector messages must not remain as a diagnostics-owned output queue"
    );
    assert!(
        snapshot
            .runtime_observable_source()
            .is_some_and(|source| source.source_items().iter().any(|item| matches!(
                item,
                super::RendererRuntimeObservableSourceItem::ConsoleMessage { message, .. }
                    if message.message == "log: exact-document-snapshot-marker"
            ))),
        "diagnostics should expose read-only source state without owning the protocol publication"
    );

    page.close_async()
        .await
        .expect("read-only Inspector diagnostics page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn failed_stateful_inspector_command_preserves_v8_state() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let url = url::Url::parse("https://example.test/inspector-failed-state").unwrap();
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        url,
        "<!doctype html><body>failed inspector state</body>",
    )
    .await;

    for request in [
        serde_json::json!({"id": 711, "method": "Profiler.enable"}),
        serde_json::json!({
            "id": 712,
            "method": "Profiler.setSamplingInterval",
            "params": {"interval": 937},
        }),
        serde_json::json!({"id": 713, "method": "Profiler.start"}),
    ] {
        let response_id = request["id"].as_i64().expect("numeric request id");
        let (messages, _) = dispatch_runtime_protocol_with_output_for_test(&page, request)
            .await
            .expect("Profiler setup command should dispatch");
        assert!(
            runtime_protocol_response_by_id(&messages, response_id)
                .is_some_and(|message| message.get("error").is_none()),
            "Profiler setup command {response_id} should succeed: {messages:?}"
        );
    }
    let (_, before_failed_command) = dispatch_runtime_protocol_with_output_for_test(
        &page,
        serde_json::json!({"id": 714, "method": "Runtime.enable"}),
    )
    .await
    .expect("state checkpoint command should dispatch");
    let before_failed_command = before_failed_command
        .v8_state_update()
        .cloned()
        .expect("state checkpoint should flush a cookie");

    let (failed_messages, failed_output) = dispatch_runtime_protocol_with_output_for_test(
        &page,
        serde_json::json!({
            "id": 715,
            "method": "Profiler.setSamplingInterval",
            "params": {"interval": 123},
        }),
    )
    .await
    .expect("invalid stateful command should still return a protocol response");
    assert!(
        runtime_protocol_response_by_id(&failed_messages, 715)
            .is_some_and(|message| message.get("error").is_some()),
        "changing the sampling interval while profiling should fail: {failed_messages:?}"
    );
    assert_eq!(
        failed_output.v8_state_update(),
        Some(&before_failed_command),
        "a failed stateful command must not advance the opaque V8 state"
    );

    page.close_async()
        .await
        .expect("failed inspector state page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn stored_document_start_script_remove_uses_registry_key_namespace() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let url = url::Url::parse("https://example.test/stored-preload-registry-key").unwrap();

    let (mut page, _, _, _creation_artifacts, download) = runtime
        .create_html_page_from_response(
            url.clone(),
            url,
            None,
            false,
            0,
            200,
            vec![("content-type".to_owned(), b"text/html".to_vec())],
            &loader,
            crate::RendererWebStorageHandles::ephemeral(),
            "<!doctype html><body>stored preload key namespace</body>".to_owned(),
            crate::RendererDocumentOptions {
                ..Default::default()
            },
        )
        .await
        .expect("registry-key stored-preload page should load");
    assert!(download.is_none());

    set_stored_document_start_scripts_for_test(
        &page,
        vec![
            crate::DocumentStartScript {
                registry_key: Some("default:1".to_owned()),
                devtools_session: None,
                source: r#"globalThis.__defaultPreload = "default";"#.to_owned(),
                world_name: Some("registry-key-world".to_owned()),
                has_bidi_channel_argument: false,
                bidi_channel_handoffs: Vec::new(),
            },
            crate::DocumentStartScript {
                registry_key: Some("target:TID-1:1".to_owned()),
                devtools_session: None,
                source: r#"globalThis.__targetPreload = "target";"#.to_owned(),
                world_name: Some("registry-key-world".to_owned()),
                has_bidi_channel_argument: false,
                bidi_channel_handoffs: Vec::new(),
            },
        ],
    )
    .await
    .expect("stored document-start scripts should install");

    let (remove_reply, _) = page
        .run_async_command(RendererPageCommand::RemoveDocumentStartScriptByRegistryKey(
            "target:TID-1:1".to_owned(),
        ))
        .await
        .expect("registry-key remove should run");
    assert!(matches!(remove_reply, RendererPageReply::Unit));

    let replacement_url = "data:text/html;charset=utf-8,%3C!doctype%20html%3E%3Cbody%3Eregistry%20key%20replacement%3C/body%3E";
    let (navigation_reply, _) = page
        .run_async_command(
            RendererPageCommand::EvaluateExpressionAndFollowPendingNavigation {
                expression: format!(
                    r#"(() => {{
  location.href = {replacement_url:?};
  return "navigating";
}})()"#
                ),
                await_promise: false,
            },
        )
        .await
        .expect("registry-key stored-preload page should navigate");
    assert_eq!(
        renderer_json_value(navigation_reply),
        Some(serde_json::json!("navigating"))
    );

    let context_id = create_isolated_world_for_test(&page, "registry-key-world")
        .await
        .expect("registry-key isolated world should be created");
    let (value, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpressionInExecutionContext {
            execution_context_id: context_id,
            expression: r#"JSON.stringify({
                defaultValue: globalThis.__defaultPreload,
                targetValue: globalThis.__targetPreload ?? "absent"
            })"#
            .to_owned(),
            await_promise: false,
        })
        .await
        .expect("registry-key isolated world value should evaluate");
    assert_eq!(
        renderer_json_value(value),
        Some(serde_json::json!(
            r#"{"defaultValue":"default","targetValue":"absent"}"#
        ))
    );

    page.close_async()
        .await
        .expect("registry-key stored-preload page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn webcrypto_checkpoint_reconciles_document_replacement_before_restoring_page_residence() {
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url = url::Url::parse("https://example.test/webcrypto-checkpoint-document-open")
        .expect("page URL");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        "<!doctype html><body>initial WebCrypto document</body>",
    )
    .await;
    let document_open_session = "SID-document-open-agent";
    runtime_enable_events_for_inspector_session_for_test(&page, Some(document_open_session))
        .await
        .expect("attached Runtime session should attach before document.open");
    let inspector_before = runtime_heap_usage_for_test(&page).await;
    let inspector_before = &inspector_before["moli"]["runtime"];
    let context_group_before = inspector_before["inspectorContextGroupId"].clone();
    let session_count_before = inspector_before["inspectorSessionCount"].clone();
    let registration_count_before = inspector_before["inspectorContextRegistrationCount"].clone();
    assert_eq!(session_count_before, serde_json::json!(2));
    assert_eq!(registration_count_before, serde_json::json!(1));

    let _ = page
        .run_async_command(RendererPageCommand::TakeDocumentLifecycleEvents)
        .await
        .expect("initial lifecycle events should be drainable");
    while activity_wake_rx.try_recv().is_ok() {}

    let (scheduled, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"(() => {
  crypto.subtle.digest("SHA-256", new TextEncoder().encode("replace-document"))
    .then(() => {
      document.open();
      document.write('<main id="webcrypto-checkpoint-replacement">replacement</main>');
      document.close();
    });
  return "scheduled";
})()"#
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("WebCrypto replacement reaction should schedule");
    assert_eq!(
        renderer_json_value(scheduled),
        Some(serde_json::json!("scheduled"))
    );

    let replacement_events = tokio::time::timeout(
        Duration::from_secs(2),
        recv_page_lifecycle_until(
            &mut activity_wake_rx,
            &page,
            RendererDocumentLifecycleMilestone::Load,
        ),
    )
    .await
    .expect("the WebCrypto task-end checkpoint should install and schedule replacement lifecycle");
    assert!(replacement_events.iter().any(|event| matches!(
        event.kind,
        RendererDocumentLifecycleEventKind::Milestone(
            RendererDocumentLifecycleMilestone::DomContentLoaded
        )
    )));

    let (replacement, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression:
                "document.querySelector('#webcrypto-checkpoint-replacement')?.textContent ?? 'missing'"
                    .to_owned(),
            await_promise: false,
        })
        .await
        .expect("replacement DOM should evaluate");
    assert_eq!(
        renderer_json_value(replacement),
        Some(serde_json::json!("replacement"))
    );
    let inspector_after = runtime_heap_usage_for_test(&page).await;
    let inspector_after = &inspector_after["moli"]["runtime"];
    assert_eq!(
        inspector_after["inspectorContextGroupId"], context_group_before,
        "same-Page document.open must preserve the local-root context group"
    );
    assert_eq!(
        inspector_after["inspectorSessionCount"], session_count_before,
        "same-Page document.open must not detach frontend V8 sessions"
    );
    assert_eq!(
        inspector_after["inspectorContextRegistrationCount"], registration_count_before,
        "same-Page document.open must preserve the existing Window context registration"
    );
    assert_eq!(
        inspector_after["inspectorSessionRegistryOwner"],
        serde_json::json!("renderer-devtools-agent")
    );
    runtime_enable_events_for_inspector_session_for_test(&page, Some(document_open_session))
        .await
        .expect("the existing attached Runtime session should remain dispatchable");

    page.close_async()
        .await
        .expect("WebCrypto checkpoint replacement page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn broadcast_channel_checkpoint_reconciles_replacement_before_page_restore() {
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url = url::Url::parse("https://example.test/broadcast-checkpoint-document-open")
        .expect("page URL");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        "<!doctype html><body>initial BroadcastChannel document</body>",
    )
    .await;

    let _ = page
        .run_async_command(RendererPageCommand::TakeDocumentLifecycleEvents)
        .await
        .expect("initial lifecycle events should be drainable");
    while activity_wake_rx.try_recv().is_ok() {}

    let (scheduled, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"(() => {
  globalThis.__broadcastCheckpointReceiver =
    new BroadcastChannel("broadcast-checkpoint-replacement");
  __broadcastCheckpointReceiver.onmessage = () => {
    Promise.resolve().then(() => {
      document.open();
      document.write('<main id="broadcast-checkpoint-replacement">replacement</main>');
      document.close();
    });
  };
  globalThis.__broadcastCheckpointSender =
    new BroadcastChannel("broadcast-checkpoint-replacement");
  __broadcastCheckpointSender.postMessage("replace");
  return "scheduled";
})()"#
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("BroadcastChannel replacement reaction should schedule");
    assert_eq!(
        renderer_json_value(scheduled),
        Some(serde_json::json!("scheduled"))
    );

    let replacement_events = tokio::time::timeout(
        Duration::from_secs(2),
        recv_page_lifecycle_until(
            &mut activity_wake_rx,
            &page,
            RendererDocumentLifecycleMilestone::Load,
        ),
    )
    .await
    .expect("the BroadcastChannel task-end checkpoint should install replacement lifecycle");
    assert!(replacement_events.iter().any(|event| matches!(
        event.kind,
        RendererDocumentLifecycleEventKind::Milestone(
            RendererDocumentLifecycleMilestone::DomContentLoaded
        )
    )));

    let (replacement, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression:
                "document.querySelector('#broadcast-checkpoint-replacement')?.textContent ?? 'missing'"
                    .to_owned(),
            await_promise: false,
        })
        .await
        .expect("replacement DOM should evaluate");
    assert_eq!(
        renderer_json_value(replacement),
        Some(serde_json::json!("replacement"))
    );

    page.close_async()
        .await
        .expect("BroadcastChannel checkpoint replacement page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn storage_event_checkpoint_reconciles_replacement_before_page_restore() {
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url = url::Url::parse("https://example.test/storage-event-checkpoint-document-open")
        .expect("page URL");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        "<!doctype html><body><iframe id=\"storage-source\"></iframe></body>",
    )
    .await;

    let _ = page
        .run_async_command(RendererPageCommand::TakeDocumentLifecycleEvents)
        .await
        .expect("initial lifecycle events should be drainable");
    while activity_wake_rx.try_recv().is_ok() {}

    let (scheduled, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"(() => {
  addEventListener("storage", () => {
    Promise.resolve().then(() => {
      document.open();
      document.write('<main id="storage-event-checkpoint-replacement">replacement</main>');
      document.close();
    });
  }, { once: true });
  document.getElementById("storage-source").contentWindow.localStorage
    .setItem("storage-event-checkpoint-key", "replace-document");
  return "scheduled";
})()"#
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("StorageEvent replacement reaction should schedule");
    assert_eq!(
        renderer_json_value(scheduled),
        Some(serde_json::json!("scheduled"))
    );

    let replacement_events = tokio::time::timeout(
        Duration::from_secs(2),
        recv_page_lifecycle_until(
            &mut activity_wake_rx,
            &page,
            RendererDocumentLifecycleMilestone::Load,
        ),
    )
    .await
    .expect(
        "the StorageEvent task-end checkpoint should install and schedule replacement lifecycle",
    );
    assert!(replacement_events.iter().any(|event| matches!(
        event.kind,
        RendererDocumentLifecycleEventKind::Milestone(
            RendererDocumentLifecycleMilestone::DomContentLoaded
        )
    )));

    let (replacement, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression:
                "document.querySelector('#storage-event-checkpoint-replacement')?.textContent ?? 'missing'"
                    .to_owned(),
            await_promise: false,
        })
        .await
        .expect("replacement DOM should evaluate");
    assert_eq!(
        renderer_json_value(replacement),
        Some(serde_json::json!("replacement"))
    );

    page.close_async()
        .await
        .expect("StorageEvent checkpoint replacement page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn hashchange_checkpoint_reconciles_replacement_before_page_restore() {
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url = url::Url::parse("https://example.test/hashchange-checkpoint-document-open")
        .expect("page URL");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        "<!doctype html><body>initial hashchange document</body>",
    )
    .await;

    let _ = page
        .run_async_command(RendererPageCommand::TakeDocumentLifecycleEvents)
        .await
        .expect("initial lifecycle events should be drainable");
    while activity_wake_rx.try_recv().is_ok() {}

    let (scheduled, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r##"(() => {
  addEventListener("hashchange", () => {
    Promise.resolve().then(() => {
      document.open();
      document.write('<main id="hashchange-checkpoint-replacement">replacement</main>');
      document.close();
    });
  }, { once: true });
  location.hash = "#replace";
  return "scheduled";
})()"##
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("hashchange replacement reaction should schedule");
    assert_eq!(
        renderer_json_value(scheduled),
        Some(serde_json::json!("scheduled"))
    );

    let replacement_events = tokio::time::timeout(
        Duration::from_secs(2),
        recv_page_lifecycle_until(
            &mut activity_wake_rx,
            &page,
            RendererDocumentLifecycleMilestone::Load,
        ),
    )
    .await
    .expect("the hashchange task-end checkpoint should install replacement lifecycle");
    assert!(replacement_events.iter().any(|event| matches!(
        event.kind,
        RendererDocumentLifecycleEventKind::Milestone(
            RendererDocumentLifecycleMilestone::DomContentLoaded
        )
    )));

    let (replacement, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression:
                "document.querySelector('#hashchange-checkpoint-replacement')?.textContent ?? 'missing'"
                    .to_owned(),
            await_promise: false,
        })
        .await
        .expect("replacement DOM should evaluate");
    assert_eq!(
        renderer_json_value(replacement),
        Some(serde_json::json!("replacement"))
    );

    page.close_async()
        .await
        .expect("hashchange checkpoint replacement page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn element_toggle_checkpoint_reconciles_replacement_before_page_restore() {
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url = url::Url::parse("https://example.test/element-toggle-checkpoint-document-open")
        .expect("page URL");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        r#"<!doctype html><body>
<details id="element-toggle-checkpoint"><summary>summary</summary></details>
</body>"#,
    )
    .await;

    let _ = page
        .run_async_command(RendererPageCommand::TakeDocumentLifecycleEvents)
        .await
        .expect("initial lifecycle events should be drainable");
    while activity_wake_rx.try_recv().is_ok() {}

    let (scheduled, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"(() => {
  const details = document.getElementById("element-toggle-checkpoint");
  details.addEventListener("toggle", () => {
    Promise.resolve().then(() => {
      document.open();
      document.write('<main id="element-toggle-replacement">replacement</main>');
      document.close();
    });
  }, { once: true });
  details.open = true;
  return "scheduled";
})()"#
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("element-toggle replacement reaction should schedule");
    assert_eq!(
        renderer_json_value(scheduled),
        Some(serde_json::json!("scheduled"))
    );

    let replacement_events = tokio::time::timeout(
        Duration::from_secs(2),
        recv_page_lifecycle_until(
            &mut activity_wake_rx,
            &page,
            RendererDocumentLifecycleMilestone::Load,
        ),
    )
    .await
    .expect("the element-toggle task-end checkpoint should install replacement lifecycle");
    assert!(replacement_events.iter().any(|event| matches!(
        event.kind,
        RendererDocumentLifecycleEventKind::Milestone(
            RendererDocumentLifecycleMilestone::DomContentLoaded
        )
    )));

    let (replacement, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression:
                "document.querySelector('#element-toggle-replacement')?.textContent ?? 'missing'"
                    .to_owned(),
            await_promise: false,
        })
        .await
        .expect("replacement DOM should evaluate");
    assert_eq!(
        renderer_json_value(replacement),
        Some(serde_json::json!("replacement"))
    );

    page.close_async()
        .await
        .expect("element-toggle checkpoint replacement page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn image_load_checkpoint_reconciles_replacement_before_page_restore() {
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url =
        url::Url::parse("https://example.test/image-checkpoint-document-open").expect("page URL");
    let mut page =
        create_test_html_page(&runtime, &loader, page_url, "<!doctype html><body></body>").await;

    let _ = page
        .run_async_command(RendererPageCommand::TakeDocumentLifecycleEvents)
        .await
        .expect("initial lifecycle events should be drainable");
    while activity_wake_rx.try_recv().is_ok() {}

    let (scheduled, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"(() => {
  const image = new Image();
  image.addEventListener("load", () => {
    Promise.resolve().then(() => {
      document.open();
      document.write('<main id="image-replacement">replacement</main>');
      document.close();
    });
  }, { once: true });
  document.body.appendChild(image);
  image.src = "/not-fetched-by-policy.png";
  return "scheduled";
})()"#
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("image replacement reaction should schedule");
    assert_eq!(
        renderer_json_value(scheduled),
        Some(serde_json::json!("scheduled"))
    );

    let replacement_events = tokio::time::timeout(
        Duration::from_secs(2),
        recv_page_lifecycle_until(
            &mut activity_wake_rx,
            &page,
            RendererDocumentLifecycleMilestone::Load,
        ),
    )
    .await
    .expect("the image task-end checkpoint should install replacement lifecycle");
    assert!(replacement_events.iter().any(|event| matches!(
        event.kind,
        RendererDocumentLifecycleEventKind::Milestone(
            RendererDocumentLifecycleMilestone::DomContentLoaded
        )
    )));

    let (replacement, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: "document.querySelector('#image-replacement')?.textContent ?? 'missing'"
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("replacement DOM should evaluate");
    assert_eq!(
        renderer_json_value(replacement),
        Some(serde_json::json!("replacement"))
    );

    page.close_async()
        .await
        .expect("image checkpoint replacement page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn connected_style_checkpoint_reconciles_replacement_before_page_restore() {
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url =
        url::Url::parse("https://example.test/style-checkpoint-document-open").expect("page URL");
    let mut page =
        create_test_html_page(&runtime, &loader, page_url, "<!doctype html><body></body>").await;

    let _ = page
        .run_async_command(RendererPageCommand::TakeDocumentLifecycleEvents)
        .await
        .expect("initial lifecycle events should be drainable");
    while activity_wake_rx.try_recv().is_ok() {}

    let (scheduled, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"(() => {
  const style = document.createElement("style");
  style.textContent = "body { color: teal; }";
  style.addEventListener("load", () => {
    Promise.resolve().then(() => {
      document.open();
      document.write('<main id="style-replacement">replacement</main>');
      document.close();
    });
  }, { once: true });
  document.head.appendChild(style);
  return "scheduled";
})()"#
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("connected-style replacement reaction should schedule");
    assert_eq!(
        renderer_json_value(scheduled),
        Some(serde_json::json!("scheduled"))
    );

    let replacement_events = tokio::time::timeout(
        Duration::from_secs(2),
        recv_page_lifecycle_until(
            &mut activity_wake_rx,
            &page,
            RendererDocumentLifecycleMilestone::Load,
        ),
    )
    .await
    .expect("the connected-style task-end checkpoint should install replacement lifecycle");
    assert!(replacement_events.iter().any(|event| matches!(
        event.kind,
        RendererDocumentLifecycleEventKind::Milestone(
            RendererDocumentLifecycleMilestone::DomContentLoaded
        )
    )));

    let (replacement, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: "document.querySelector('#style-replacement')?.textContent ?? 'missing'"
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("replacement DOM should evaluate");
    assert_eq!(
        renderer_json_value(replacement),
        Some(serde_json::json!("replacement"))
    );

    page.close_async()
        .await
        .expect("connected-style checkpoint replacement page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn connected_style_microtasks_run_before_the_delayed_window_load_task() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url = url::Url::parse("https://example.test/style-microtask-before-window-load")
        .expect("page URL");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        concat!(
            "<!doctype html><head>",
            "<script>",
            "globalThis.__styleLoadOrder = [];",
            "window.addEventListener('load', () => __styleLoadOrder.push('window-load'));",
            "</script>",
            "<style id='ordered-style'>body { color: olive; }</style>",
            "<script>",
            "document.getElementById('ordered-style').addEventListener('load', () => {",
            "  __styleLoadOrder.push('style-load');",
            "  Promise.resolve().then(() => __styleLoadOrder.push('style-microtask'));",
            "});",
            "</script>",
            "</head><body></body>",
        ),
    )
    .await;

    let (order, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: "__styleLoadOrder.join('|')".to_owned(),
            await_promise: false,
        })
        .await
        .expect("connected-style/window load order should evaluate");
    assert_eq!(
        renderer_json_value(order),
        Some(serde_json::json!("style-load|style-microtask|window-load")),
        "the element event task must release its delay before returning, while its task-end checkpoint still runs before the later window-load task"
    );

    page.close_async()
        .await
        .expect("connected-style load-order page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn user_interaction_checkpoint_reconciles_replacement_before_page_restore() {
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url =
        url::Url::parse("https://example.test/user-interaction-checkpoint-document-open")
            .expect("page URL");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        "<!doctype html><body>initial user-interaction document</body>",
    )
    .await;

    let _ = page
        .run_async_command(RendererPageCommand::TakeDocumentLifecycleEvents)
        .await
        .expect("initial lifecycle events should be drainable");
    while activity_wake_rx.try_recv().is_ok() {}

    let (scheduled, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"(() => {
  const dialog = document.createElement("dialog");
  dialog.addEventListener("close", () => {
    Promise.resolve().then(() => {
      document.open();
      document.write('<main id="user-interaction-checkpoint-replacement">replacement</main>');
      document.close();
    });
  });
  document.body.append(dialog);
  dialog.show();
  dialog.close();
  return "scheduled";
})()"#
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("user-interaction replacement reaction should schedule");
    assert_eq!(
        renderer_json_value(scheduled),
        Some(serde_json::json!("scheduled"))
    );

    let replacement_events = tokio::time::timeout(
        Duration::from_secs(2),
        recv_page_lifecycle_until(
            &mut activity_wake_rx,
            &page,
            RendererDocumentLifecycleMilestone::Load,
        ),
    )
    .await
    .expect(
        "the user-interaction task-end checkpoint should install and schedule replacement lifecycle",
    );
    assert!(replacement_events.iter().any(|event| matches!(
        event.kind,
        RendererDocumentLifecycleEventKind::Milestone(
            RendererDocumentLifecycleMilestone::DomContentLoaded
        )
    )));

    let (replacement, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression:
                "document.querySelector('#user-interaction-checkpoint-replacement')?.textContent ?? 'missing'"
                    .to_owned(),
            await_promise: false,
        })
        .await
        .expect("replacement DOM should evaluate");
    assert_eq!(
        renderer_json_value(replacement),
        Some(serde_json::json!("replacement"))
    );

    page.close_async()
        .await
        .expect("user-interaction checkpoint replacement page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn window_message_checkpoint_reconciles_document_replacement_before_restoring_page_residence()
{
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url = url::Url::parse("https://example.test/window-message-checkpoint-document-open")
        .expect("page URL");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        "<!doctype html><body>initial Window.postMessage document</body>",
    )
    .await;

    let _ = page
        .run_async_command(RendererPageCommand::TakeDocumentLifecycleEvents)
        .await
        .expect("initial lifecycle events should be drainable");
    while activity_wake_rx.try_recv().is_ok() {}

    let (scheduled, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"(() => {
  onmessage = () => {
    Promise.resolve().then(() => {
      document.open();
      document.write('<main id="window-message-checkpoint-replacement">replacement</main>');
      document.close();
    });
  };
  postMessage("replace-document", "*");
  return "scheduled";
})()"#
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("Window.postMessage replacement reaction should schedule");
    assert_eq!(
        renderer_json_value(scheduled),
        Some(serde_json::json!("scheduled"))
    );

    let replacement_events = tokio::time::timeout(
        Duration::from_secs(2),
        recv_page_lifecycle_until(
            &mut activity_wake_rx,
            &page,
            RendererDocumentLifecycleMilestone::Load,
        ),
    )
    .await
    .expect(
        "the Window.postMessage task-end checkpoint should install and schedule replacement lifecycle",
    );
    assert!(replacement_events.iter().any(|event| matches!(
        event.kind,
        RendererDocumentLifecycleEventKind::Milestone(
            RendererDocumentLifecycleMilestone::DomContentLoaded
        )
    )));

    let (replacement, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression:
                "document.querySelector('#window-message-checkpoint-replacement')?.textContent ?? 'missing'"
                    .to_owned(),
            await_promise: false,
        })
        .await
        .expect("replacement DOM should evaluate");
    assert_eq!(
        renderer_json_value(replacement),
        Some(serde_json::json!("replacement"))
    );

    page.close_async()
        .await
        .expect("Window.postMessage checkpoint replacement page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn message_port_checkpoint_reconciles_document_replacement_before_restoring_page_residence() {
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url = url::Url::parse("https://example.test/message-port-checkpoint-document-open")
        .expect("page URL");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        "<!doctype html><body>initial MessagePort document</body>",
    )
    .await;

    let _ = page
        .run_async_command(RendererPageCommand::TakeDocumentLifecycleEvents)
        .await
        .expect("initial lifecycle events should be drainable");
    while activity_wake_rx.try_recv().is_ok() {}

    let (scheduled, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"(() => {
  globalThis.__lmCheckpointMessagePortChannel = new MessageChannel();
  const { port1, port2 } = __lmCheckpointMessagePortChannel;
  port1.onmessage = () => {
    Promise.resolve().then(() => {
      document.open();
      document.write('<main id="message-port-checkpoint-replacement">replacement</main>');
      document.close();
    });
  };
  port2.postMessage("replace-document");
  return "scheduled";
})()"#
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("MessagePort replacement reaction should schedule");
    assert_eq!(
        renderer_json_value(scheduled),
        Some(serde_json::json!("scheduled"))
    );

    let replacement_events = tokio::time::timeout(
        Duration::from_secs(2),
        recv_page_lifecycle_until(
            &mut activity_wake_rx,
            &page,
            RendererDocumentLifecycleMilestone::Load,
        ),
    )
    .await
    .expect(
        "the MessagePort task-end checkpoint should install and schedule replacement lifecycle",
    );
    assert!(replacement_events.iter().any(|event| matches!(
        event.kind,
        RendererDocumentLifecycleEventKind::Milestone(
            RendererDocumentLifecycleMilestone::DomContentLoaded
        )
    )));

    let (replacement, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression:
                "document.querySelector('#message-port-checkpoint-replacement')?.textContent ?? 'missing'"
                    .to_owned(),
            await_promise: false,
        })
        .await
        .expect("replacement DOM should evaluate");
    assert_eq!(
        renderer_json_value(replacement),
        Some(serde_json::json!("replacement"))
    );

    page.close_async()
        .await
        .expect("MessagePort checkpoint replacement page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn timer_checkpoint_reconciles_replacement_before_page_restore() {
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url =
        url::Url::parse("https://example.test/timer-checkpoint-document-open").expect("page URL");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        "<!doctype html><body>initial timer document</body>",
    )
    .await;

    let _ = page
        .run_async_command(RendererPageCommand::TakeDocumentLifecycleEvents)
        .await
        .expect("initial lifecycle events should be drainable");
    while activity_wake_rx.try_recv().is_ok() {}

    let (scheduled, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"(() => {
  setTimeout(() => {
    Promise.resolve().then(() => {
      document.open();
      document.write('<main id="timer-checkpoint-replacement">replacement</main>');
      document.close();
    });
  }, 0);
  return "scheduled";
})()"#
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("timer replacement reaction should schedule");
    assert_eq!(
        renderer_json_value(scheduled),
        Some(serde_json::json!("scheduled"))
    );

    let replacement_events = tokio::time::timeout(
        Duration::from_secs(2),
        recv_page_lifecycle_until(
            &mut activity_wake_rx,
            &page,
            RendererDocumentLifecycleMilestone::Load,
        ),
    )
    .await
    .expect("the timer task-end checkpoint should install and schedule replacement lifecycle");
    assert!(replacement_events.iter().any(|event| matches!(
        event.kind,
        RendererDocumentLifecycleEventKind::Milestone(
            RendererDocumentLifecycleMilestone::DomContentLoaded
        )
    )));

    let (replacement, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression:
                "document.querySelector('#timer-checkpoint-replacement')?.textContent ?? 'missing'"
                    .to_owned(),
            await_promise: false,
        })
        .await
        .expect("replacement DOM should evaluate");
    assert_eq!(
        renderer_json_value(replacement),
        Some(serde_json::json!("replacement"))
    );

    page.close_async()
        .await
        .expect("timer checkpoint replacement page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn owner_runtime_expression_await_uses_page_wake_or_timer_deadline() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url =
        url::Url::parse("https://example.test/runtime-expression-await").expect("page url");
    let (page, _, _creation_diagnostics, _creation_artifacts, pending_download) = runtime
        .create_html_page_from_response(
            page_url.clone(),
            page_url,
            None,
            false,
            0,
            200,
            vec![("content-type".to_owned(), b"text/html".to_vec())],
            &loader,
            crate::RendererWebStorageHandles::ephemeral(),
            "<!doctype html><body>runtime expression await</body>".to_owned(),
            crate::RendererDocumentOptions {
                ..Default::default()
            },
        )
        .await
        .expect("page should load");
    assert!(pending_download.is_none());

    let (observed, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"new Promise(resolve => {
  setTimeout(() => resolve("owner-await-timer"), 25);
})"#
            .to_owned(),
            await_promise: true,
        })
        .await
        .expect("owner runtime expression await should settle from page timer");
    assert_eq!(
        renderer_json_value(observed),
        Some(serde_json::json!("owner-await-timer"))
    );

    let (globals, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"JSON.stringify(Object.getOwnPropertyNames(globalThis).sort())"#
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("global property snapshot should evaluate");
    let globals = renderer_json_value(globals)
        .and_then(|value| value.as_str().map(str::to_owned))
        .expect("global property snapshot should be a string");
    assert!(
        !globals.contains("__lmAwaitPromise"),
        "page-level await must not leave legacy global token properties: {globals}"
    );
    assert!(
        !globals.contains("__moliAwaitPromiseToken"),
        "page-level await must not expose legacy await token payloads: {globals}"
    );
    assert!(
        !globals.contains("__moliCompleteRuntimeExpressionAwait"),
        "page-level await must not expose an internal completion binding: {globals}"
    );
}
#[tokio::test(flavor = "multi_thread")]
async fn script_snapshot_ignores_window_indexed_child_frame_globals() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url =
        url::Url::parse("https://example.test/snapshot-child-frame-index").expect("page url");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        r#"<!doctype html>
<iframe srcdoc="<p>child</p>"></iframe>
<script>globalThis.__lm_snapshot_marker = "parent";</script>"#,
    )
    .await;

    let snapshot = RendererPageTestingHandle::new_for_testing(&page)
        .current_page_state_async()
        .await
        .expect("snapshot should refresh");
    let globals = snapshot.script_execution.globals();

    assert_eq!(
        globals.get("__lm_snapshot_marker"),
        Some(&crate::types::JsValueSnapshot::String("parent".to_owned()))
    );
    assert!(
        !globals.contains_key("0"),
        "Window child-frame indexed properties must not be reported as script globals: {globals:?}"
    );

    page.close_async()
        .await
        .expect("snapshot child frame test page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn script_snapshot_does_not_stringify_unsupported_globals() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url =
        url::Url::parse("https://example.test/snapshot-unsupported-globals").expect("page url");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        r#"<!doctype html>
<script>
globalThis.__lm_snapshot_to_string_calls = 0;
globalThis.__lm_snapshot_object = {
  toString() {
    globalThis.__lm_snapshot_to_string_calls += 1;
    return "side-effect";
  }
};
globalThis.__lm_snapshot_large_array = new Array(25000).fill("large-item-value");
const __lm_snapshot_revocable_array = Proxy.revocable([], {});
globalThis.__lm_snapshot_revoked_array = __lm_snapshot_revocable_array.proxy;
__lm_snapshot_revocable_array.revoke();
</script>"#,
    )
    .await;

    let snapshot = RendererPageTestingHandle::new_for_testing(&page)
        .current_page_state_async()
        .await
        .expect("snapshot should refresh");
    let globals = snapshot.script_execution.globals();

    assert_eq!(
        globals.get("__lm_snapshot_object"),
        Some(&crate::types::JsValueSnapshot::Unsupported(
            "[object]".to_owned()
        ))
    );
    assert_eq!(
        globals.get("__lm_snapshot_large_array"),
        Some(&crate::types::JsValueSnapshot::Unsupported(
            "[array]".to_owned()
        ))
    );
    assert_eq!(
        globals.get("__lm_snapshot_revoked_array"),
        Some(&crate::types::JsValueSnapshot::Unsupported(
            "[object]".to_owned()
        ))
    );
    assert_eq!(
        globals.get("__lm_snapshot_to_string_calls"),
        Some(&crate::types::JsValueSnapshot::Number(0.0)),
        "snapshot must not run user-defined toString while describing unsupported globals"
    );

    page.close_async()
        .await
        .expect("unsupported globals snapshot test page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn native_terminals_publish_before_waiters_are_polled() {
    use super::{RendererCdpCall, RendererNativeOperation, RendererNativeProtocolResponse};
    use moli_page_types::{DevToolsSessionKey, RendererAgentAttachmentId};
    let runtime = JsRuntime::initialize();
    let (output_tx, mut output_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(output_tx);
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        url::Url::parse("https://example.test/native-terminals").unwrap(),
        "<!doctype html><title>Native terminals</title>",
    )
    .await;
    output_rx.drain();
    let attachment = RendererAgentAttachmentId::allocate();
    let mut pending = Vec::new();
    let mut guards = Vec::new();
    for command_id in [100, 101, 102] {
        let (command, guard) = RendererCdpCall::new(
            moli_page_types::FrontendCommandId::new(command_id),
            DevToolsSessionKey::Attached("session-a".to_owned()),
            attachment,
            RendererNativeOperation::new(RendererPageCommand::ChildFrameTreeSnapshot, |reply| {
                let RendererPageReply::ChildFrameTreeSnapshots(children) = reply.unwrap() else {
                    panic!("child frame tree snapshot reply");
                };
                RendererNativeProtocolResponse::success(serde_json::json!({
                    "childCount": children.len(),
                }))
            }),
        );
        if command_id == 100 {
            // Cancellation precedes admission, so no scheduling race can
            // decide whether this request may publish a terminal.
            drop(guard);
        } else {
            guards.push(guard);
        }
        pending.push((
            command_id,
            page.enqueue_protocol_command_in_inspector_session(
                RendererPageCommand::Native(command),
                Some("session-a".to_owned()),
            )
            .expect("enqueue native terminal"),
        ));
    }
    let later = page
        .enqueue_protocol_command_in_inspector_session(
            RendererPageCommand::EvaluateExpression {
                expression: "42".to_owned(),
                await_promise: false,
            },
            Some("session-a".to_owned()),
        )
        .expect("enqueue concrete same-session gate");
    // Intentionally poll the last command before either native waiter. A
    // receipt/decode handoff would deadlock here. The timeout only diagnoses
    // a blocked gate; no ordering assertion depends on an elapsed interval.
    let later = tokio::time::timeout(std::time::Duration::from_secs(3), later.wait())
        .await
        .expect("published terminals must not retain the Main lane")
        .expect("later evaluation completes");
    assert_eq!(
        renderer_json_value(later.into_reply_and_state().0),
        Some(serde_json::json!(42))
    );
    // Retire the stream before polling native waiters or publication receipts.
    // Already-published replies and their exact fences must survive teardown.
    page.close_async()
        .await
        .expect("close page before consuming native replies");
    let terminals = output_rx
        .drain()
        .into_iter()
        .flat_map(|publication| {
            let cursor = publication.cursor();
            publication
                .into_records()
                .into_iter()
                .filter_map(move |record| match record.into_parts().1 {
                    RendererOutputItem::NativeTerminal(terminal) => Some((cursor, terminal)),
                    _ => None,
                })
        })
        .collect::<Vec<_>>();
    assert_eq!(
        terminals
            .iter()
            .map(|(_, reply)| reply.command_id.get())
            .collect::<Vec<_>>(),
        [101, 102]
    );
    for ((cursor, terminal), guard) in terminals.iter().zip(guards) {
        assert_eq!(terminal.attachment_id, attachment);
        assert_eq!(terminal.session.wire_session_id(), Some("session-a"));
        assert_eq!(
            terminal.reply.result,
            Ok(serde_json::json!({ "childCount": 0 })),
        );
        // Even if an adapter loses its value channel, a committed publication
        // wins over cancellation and suppresses a second terminal error.
        assert_eq!(
            guard
                .cancel_or_published()
                .await
                .expect("publication already committed")
                .cursor(),
            *cursor
        );
    }
    // Decode in reverse order, with a scheduler yield between receives. It
    // cannot change the producer order already observed on the journal.
    while let Some((command_id, pending)) = pending.pop() {
        tokio::task::yield_now().await;
        if command_id == 100 {
            let Err(error) = pending.wait().await else {
                panic!("a canceled native response must not publish");
            };
            assert!(error.to_string().contains("native response was canceled"));
            continue;
        }
        let completion = pending
            .wait()
            .await
            .expect("receive native completion after page retirement");
        let terminal_cursor = terminals
            .iter()
            .find(|(_, terminal)| terminal.command_id.get() == command_id)
            .expect("native terminal was published before retirement")
            .0;
        assert_eq!(
            completion
                .renderer_output_predecessor()
                .expect("native terminal fence")
                .cursor(),
            terminal_cursor,
            "retirement must retain the exact committed terminal boundary",
        );
        let reply = completion.into_reply_and_state().0;
        assert!(matches!(reply, RendererPageReply::NativeCommandPublished));
    }
}

#[tokio::test(flavor = "multi_thread")]
async fn projected_native_success_and_error_publish_without_adapter_receipt() {
    use super::{RendererCdpCall, RendererNativeOperation, RendererNativeProtocolResponse};
    use moli_page_types::{DevToolsSessionKey, FrontendCommandId, RendererAgentAttachmentId};
    let runtime = JsRuntime::initialize();
    let (output_tx, mut output_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(output_tx);
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        url::Url::parse("https://example.test/native-projection").unwrap(),
        "<!doctype html><title>Native projection</title>",
    )
    .await;
    output_rx.drain();
    let attachment = RendererAgentAttachmentId::allocate();
    let mut waiters = Vec::new();
    let mut guards = Vec::new();
    for id in [1, 2] {
        let (command, guard) = RendererCdpCall::new(
            FrontendCommandId::new(id),
            DevToolsSessionKey::Attached("native".to_owned()),
            attachment,
            RendererNativeOperation::new(
                RendererPageCommand::ComputedStyleProperties {
                    reference:
                        crate::runtime::page_surface::RendererDomNodeReference::BackendNodeId(
                            u32::MAX,
                        ),
                },
                move |reply| {
                    assert!(matches!(
                        reply.unwrap(),
                        RendererPageReply::ComputedStyleProperties(None)
                    ));
                    if id == 1 {
                        RendererNativeProtocolResponse::success(serde_json::json!({"found": false}))
                    } else {
                        RendererNativeProtocolResponse::error(
                            -32000,
                            "Could not find node with given id",
                        )
                    }
                },
            ),
        );
        guards.push(guard);
        waiters.push(
            page.enqueue_protocol_command_in_inspector_session(
                RendererPageCommand::Native(command),
                Some("native".to_owned()),
            )
            .unwrap(),
        );
    }
    let gate = page
        .enqueue_protocol_command_in_inspector_session(
            RendererPageCommand::EvaluateExpression {
                expression: "42".to_owned(),
                await_promise: false,
            },
            Some("native".to_owned()),
        )
        .unwrap();
    tokio::time::timeout(std::time::Duration::from_secs(3), gate.wait())
        .await
        .expect("native publication cannot wait for adapter receipt")
        .unwrap();
    let terminals = output_rx
        .drain()
        .into_iter()
        .flat_map(|publication| publication.into_records())
        .filter_map(|record| match record.into_parts().1 {
            RendererOutputItem::NativeTerminal(terminal) => Some(terminal),
            _ => None,
        })
        .collect::<Vec<_>>();
    assert_eq!(
        terminals
            .iter()
            .map(|terminal| terminal.command_id.get())
            .collect::<Vec<_>>(),
        [1, 2]
    );
    let first = &terminals[0].reply;
    assert_eq!(
        first.result.as_ref().unwrap(),
        &serde_json::json!({"found": false})
    );
    let second = &terminals[1].reply;
    assert_eq!(second.result.as_ref().unwrap_err().code, -32000);
    for guard in guards {
        assert!(guard.cancel_or_published().await.is_some());
    }
    for waiter in waiters.into_iter().rev() {
        tokio::task::yield_now().await;
        assert!(matches!(
            waiter.wait().await.unwrap().into_reply_and_state().0,
            RendererPageReply::NativeCommandPublished
        ));
    }
    page.close_async().await.unwrap();
}

#[tokio::test(flavor = "multi_thread")]
async fn unpolled_internal_reply_does_not_block_later_main_dispatch() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        url::Url::parse("https://example.test/main-reply-handoff").expect("page url"),
        "<!doctype html><title>Main reply handoff</title>",
    )
    .await;

    let snapshot = page
        .enqueue_protocol_command_in_inspector_session(
            RendererPageCommand::ChildFrameTreeSnapshot,
            Some("session-a".to_owned()),
        )
        .expect("enqueue snapshot without polling its reply receiver");
    let later = page
        .enqueue_protocol_command_in_inspector_session(
            RendererPageCommand::EvaluateExpression {
                expression: "globalThis.handoffMarker = 42".to_owned(),
                await_promise: false,
            },
            Some("session-a".to_owned()),
        )
        .expect("enqueue later command in the same session");

    // Complete the later command without polling the earlier typed reply.
    // The timeout diagnoses a receiver gate; it is not an ordering assertion.
    let (later_reply, _) = tokio::time::timeout(std::time::Duration::from_secs(5), later.wait())
        .await
        .expect("internal reply polling must not gate Main dispatch")
        .expect("later command")
        .into_reply_and_state();
    assert_eq!(
        renderer_json_value(later_reply),
        Some(serde_json::json!(42))
    );
    let snapshot = snapshot
        .wait()
        .await
        .expect("receive retained snapshot reply");
    let (snapshot_reply, _) = snapshot.into_reply_and_state();
    assert!(matches!(
        snapshot_reply,
        RendererPageReply::ChildFrameTreeSnapshots(_)
    ));
    page.close_async().await.expect("close test page");
}

#[tokio::test(flavor = "multi_thread")]
async fn protocol_turn_keeps_page_facts_current_and_marks_globals_snapshot_dirty() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url =
        url::Url::parse("https://example.test/globals-snapshot/start").expect("page url");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        r#"<!doctype html><title>before</title><script>
globalThis.__lm_snapshot_before = 1;
</script>"#,
    )
    .await;

    let initial = RendererPageTestingHandle::new_for_testing(&page)
        .current_page_state_async()
        .await
        .expect("initial page state");
    assert!(initial.script_execution.globals_are_fresh());
    assert_eq!(
        initial.script_execution.global("__lm_snapshot_before"),
        Some(&crate::types::JsValueSnapshot::Number(1.0))
    );

    let output = page
        .enqueue_protocol_command(RendererPageCommand::EvaluateExpression {
            expression: r#"(() => {
  delete globalThis.__lm_snapshot_before;
  globalThis.__lm_snapshot_after = 2;
  document.title = "after";
  history.pushState({}, "", "/globals-snapshot/after");
  return "updated";
})()"#
                .to_owned(),
            await_promise: false,
        })
        .expect("protocol command should enqueue")
        .wait()
        .await
        .expect("protocol command should finish");
    let protocol_state = output.completion().page_state();

    assert_eq!(
        protocol_state.script_execution.globals_snapshot_state(),
        crate::types::ScriptGlobalsSnapshotState::Dirty
    );
    assert!(protocol_state.script_execution.fresh_globals().is_none());
    assert_eq!(
        protocol_state
            .script_execution
            .global("__lm_snapshot_before"),
        Some(&crate::types::JsValueSnapshot::Number(1.0)),
        "dirty compatibility access must remain the last complete snapshot"
    );
    assert!(
        protocol_state
            .script_execution
            .global("__lm_snapshot_after")
            .is_none()
    );
    assert_eq!(protocol_state.document_title(), "after");
    assert_eq!(
        protocol_state.final_url().as_str(),
        "https://example.test/globals-snapshot/after"
    );

    let (_, refreshed) = page
        .run_async_command(RendererPageCommand::RefreshFullPageState)
        .await
        .expect("full report refresh should finish");
    assert!(refreshed.script_execution.globals_are_fresh());
    assert!(
        refreshed
            .script_execution
            .global("__lm_snapshot_before")
            .is_none()
    );
    assert_eq!(
        refreshed.script_execution.global("__lm_snapshot_after"),
        Some(&crate::types::JsValueSnapshot::Number(2.0))
    );

    page.close_async()
        .await
        .expect("globals freshness test page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn owner_page_creation_applies_document_write_terminal_from_stable_page_route() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let (base_url, server) = spawn_owner_wake_server_with_content_type(
        "/owner-document-write.js",
        "globalThis.__lm_owner_document_write_events.push('external');",
        "application/javascript",
        Duration::ZERO,
    )
    .await;
    let page_url = url::Url::parse(&format!("{base_url}/page")).expect("page url");
    let html = r#"<!doctype html><body><script>
globalThis.__lm_owner_document_write_events = ['inline-before'];
document.write(`<script src="/owner-document-write.js" onload="globalThis.__lm_owner_document_write_events.push('load')"><\/script><main id="owner-written-tail">written</main>`);
globalThis.__lm_owner_document_write_events.push('inline-after');
</script><p id="owner-parser-tail">parser</p></body>"#;

    let mut page = create_test_html_page(&runtime, &loader, page_url, html).await;
    server
        .await
        .expect("owner document.write script server should finish");

    let (reply, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"JSON.stringify({
  events: globalThis.__lm_owner_document_write_events,
  writtenTail: !!document.getElementById('owner-written-tail'),
  parserTail: !!document.getElementById('owner-parser-tail')
})"#
            .to_owned(),
            await_promise: false,
        })
        .await
        .expect("owner-routed document.write result should evaluate");
    assert_eq!(
        renderer_json_value(reply),
        Some(serde_json::json!(
            r#"{"events":["inline-before","inline-after","external","load"],"writtenTail":true,"parserTail":true}"#
        )),
        "the public Page creation path must admit, authorize, and apply the typed terminal before completing creation"
    );

    page.close_async()
        .await
        .expect("owner document.write page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn owner_page_creation_replays_ready_document_write_after_older_timer_turn() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let (base_url, request_seen, timer_effect_seen, release_response, server) =
        spawn_gated_resource_with_concurrent_effect(
            "/owner-document-write-after-timer.js",
            "globalThis.__lm_owner_document_write_timer_events.push('external');",
            "application/javascript",
            "/owner-document-write-timer-fired",
        )
        .await;
    let page_url = url::Url::parse(&format!("{base_url}/page")).expect("page url");
    let html = r#"<!doctype html><body><script>
globalThis.__lm_owner_document_write_timer_events = ['inline-before'];
setTimeout(() => {
  globalThis.__lm_owner_document_write_timer_events.push('timer');
  fetch('/owner-document-write-timer-fired');
}, 0);
document.write(`<script src="/owner-document-write-after-timer.js" onload="globalThis.__lm_owner_document_write_timer_events.push('load')"><\/script>`);
globalThis.__lm_owner_document_write_timer_events.push('inline-after');
</script></body>"#;

    let mut creation = Box::pin(create_test_html_page(&runtime, &loader, page_url, html));
    tokio::select! {
        seen = request_seen => {
            seen.expect("document.write request should reach the gated server");
        }
        _ = &mut creation => {
            panic!("page creation must remain parked while the script response is gated");
        }
    }
    tokio::time::timeout(Duration::from_secs(2), timer_effect_seen)
        .await
        .expect("the due timer must run while the resource response is still gated")
        .expect("timer effect signal should remain open");
    release_response
        .send(())
        .expect("document.write response should release after the timer turn");
    let mut page = creation.await;
    server
        .await
        .expect("owner timer/document.write script server should finish");
    let (reply, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: "JSON.stringify(globalThis.__lm_owner_document_write_timer_events)"
                .to_owned(),
            await_promise: false,
        })
        .await
        .expect("owner timer/document.write result should evaluate");
    assert_eq!(
        renderer_json_value(reply),
        Some(serde_json::json!(
            r#"["inline-before","inline-after","timer","external","load"]"#
        )),
        "a ready typed terminal must receive a fresh internal Page admission after the older timer wins the first turn"
    );

    page.close_async()
        .await
        .expect("owner timer/document.write page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn domcontentloaded_page_creation_reply_resumes_owner_to_load_without_external_work() {
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url = url::Url::parse("https://example.test/dcl-reply-load-tail").expect("page url");
    let (completion_tx, completion_rx) = oneshot::channel();
    let (body_tx, raw_body) = ExternalRawDocumentBodyStream::channel(completion_rx);
    let producer = tokio::spawn(async move {
        body_tx
            .send(b"<!doctype html><body>ready</body>".to_vec())
            .await
            .expect("html chunk should send");
        drop(body_tx);
        completion_tx.send(Ok(())).expect("completion should send");
    });

    let (mut page, _, _, creation_artifacts, pending_download) = runtime
        .create_streaming_raw_page_from_external_body(
            page_url.clone(),
            page_url,
            None,
            false,
            0,
            Vec::new(),
            200,
            vec![("content-type".to_owned(), b"text/html".to_vec())],
            &loader,
            crate::RendererWebStorageHandles::ephemeral(),
            raw_body,
            false,
            PageVmInitStage::DomContentLoaded,
            crate::RendererReplyBoundary::Stage,
            RendererTopLevelNavigationDispatch::FollowInStandaloneAdapter,
            RendererNavigationReplyPolicy::FollowBeforeReply,
            None,
            None,
            crate::RendererDocumentOptions {
                ..Default::default()
            },
        )
        .await
        .expect("page should reply at DOMContentLoaded");
    producer.await.expect("producer should finish");
    assert!(pending_download.is_none());
    assert!(
        creation_artifacts
            .lifecycle_snapshot
            .dom_content_loaded
            .is_some()
    );
    assert!(creation_artifacts.lifecycle_snapshot.load.is_none());

    let load_events = tokio::time::timeout(
        Duration::from_millis(500),
        recv_page_lifecycle_until(
            &mut activity_wake_rx,
            &page,
            RendererDocumentLifecycleMilestone::Load,
        ),
    )
    .await
    .expect("renderer owner should resume the DCL page reply through load");
    assert!(load_events.iter().any(|event| matches!(
        event.kind,
        RendererDocumentLifecycleEventKind::Milestone(RendererDocumentLifecycleMilestone::Load)
    )));

    page.close_async()
        .await
        .expect("DCL reply load-tail page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn document_commit_background_dcl_completion_resumes_owner_to_load() {
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let predecessor_url = url::Url::parse("about:blank").expect("predecessor page url");
    let mut predecessor =
        create_test_html_page(&runtime, &loader, predecessor_url, "<body>initial</body>").await;
    let page_url =
        url::Url::parse("https://example.test/document-commit-dcl-tail").expect("page url");
    let (completion_tx, completion_rx) = oneshot::channel();
    let (body_tx, raw_body) = ExternalRawDocumentBodyStream::channel(completion_rx);
    let producer = tokio::spawn(async move {
        body_tx
            .send(b"<!doctype html><body>ready</body>".to_vec())
            .await
            .expect("html chunk should send");
        drop(body_tx);
        completion_tx.send(Ok(())).expect("completion should send");
    });

    let (mut page, _, _, creation_artifacts, pending_download) = runtime
        .create_streaming_raw_page_from_external_body(
            page_url.clone(),
            page_url,
            None,
            false,
            0,
            Vec::new(),
            200,
            vec![("content-type".to_owned(), b"text/html".to_vec())],
            &loader,
            crate::RendererWebStorageHandles::ephemeral(),
            raw_body,
            false,
            PageVmInitStage::DomContentLoaded,
            RendererReplyBoundary::DocumentCommit,
            RendererTopLevelNavigationDispatch::DelegateToBrowser,
            RendererNavigationReplyPolicy::ReturnWithPendingNavigation,
            None,
            None,
            crate::RendererDocumentOptions {
                root_frame_id: Some("TID-1".to_owned()),
                ..Default::default()
            },
        )
        .await
        .expect("page should attach at document commit");
    producer.await.expect("producer should finish");
    assert!(pending_download.is_none());
    assert!(
        creation_artifacts
            .lifecycle_snapshot
            .dom_content_loaded
            .is_none()
    );
    assert!(creation_artifacts.lifecycle_snapshot.load.is_none());
    predecessor
        .close_async()
        .await
        .expect("predecessor page should close after replacement attach");
    page.take_committed_document_post_response_continuation()
        .expect("DocumentCommit should defer parser continuation")
        .release();

    let observed = tokio::time::timeout(
        Duration::from_millis(500),
        recv_page_lifecycle_until(
            &mut activity_wake_rx,
            &page,
            RendererDocumentLifecycleMilestone::Load,
        ),
    )
    .await
    .expect("document-commit background continuation should reach load");
    let milestones = observed
        .iter()
        .filter_map(|event| match event.kind {
            RendererDocumentLifecycleEventKind::Milestone(milestone) => Some(milestone),
            _ => None,
        })
        .collect::<Vec<_>>();
    assert_eq!(
        milestones,
        vec![
            RendererDocumentLifecycleMilestone::DomContentLoaded,
            RendererDocumentLifecycleMilestone::Load,
        ]
    );

    page.close_async()
        .await
        .expect("document-commit DCL-tail page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn document_title_observation_precedes_dcl_for_exact_document() {
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url = url::Url::parse("https://example.test/title-before-dcl").expect("page url");
    let mut page = create_test_html_page_at_document_commit(
        &runtime,
        &loader,
        page_url,
        "<!doctype html><title>committed title</title><main>ready</main>",
    )
    .await;

    let (observed, title_identity, dcl_identity) =
        tokio::time::timeout(Duration::from_secs(2), async {
            let mut observed = Vec::new();
            let mut title_identity = None;
            loop {
                let publication = activity_wake_rx
                    .recv()
                    .await
                    .expect("renderer output channel should stay open");
                if !publication_is_for_page(&publication, &page) {
                    continue;
                }
                for record in publication.records() {
                    match record.item() {
                        RendererOutputItem::Observation(
                            RendererProtocolObservation::DocumentTitleChanged(change),
                        ) => {
                            assert_eq!(change.title, "committed title");
                            assert!(
                                title_identity.replace(change.source_document).is_none(),
                                "an unchanged title must not be published twice"
                            );
                            observed.push("title");
                        }
                        RendererOutputItem::Observation(
                            RendererProtocolObservation::DocumentLifecycle(event),
                        ) if event.kind
                            == RendererDocumentLifecycleEventKind::Milestone(
                                RendererDocumentLifecycleMilestone::DomContentLoaded,
                            ) =>
                        {
                            observed.push("dcl");
                            let identity = super::RendererDocumentLifecycleIdentity {
                                frame: event.frame,
                                document: event.document,
                                epoch: event.epoch,
                            };
                            return (observed, title_identity, identity);
                        }
                        _ => {}
                    }
                }
            }
        })
        .await
        .expect("title and DCL observations should be published");

    assert_eq!(observed, vec!["title", "dcl"]);
    assert_eq!(
        title_identity,
        Some(dcl_identity),
        "the title observation must be sourced from the exact DCL document"
    );

    page.close_async()
        .await
        .expect("title observation page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn document_commit_release_runs_parser_script_location_handoff_in_background() {
    let runtime = JsRuntime::initialize();
    let (activity_wake_tx, mut activity_wake_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(activity_wake_tx);
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url =
        url::Url::parse("https://example.test/parser-location-source").expect("page url");
    let mut page = create_test_html_page_at_document_commit_with_navigation_dispatch(
        &runtime,
        &loader,
        page_url,
        r#"<!doctype html><script>location.href = "/final"</script>"#,
        RendererTopLevelNavigationDispatch::DelegateToBrowser,
        RendererNavigationReplyPolicy::ReturnWithPendingNavigation,
    )
    .await;

    tokio::time::timeout(Duration::from_secs(2), async {
        while let Some(publication) = activity_wake_rx.recv().await {
            if !publication_is_for_page(&publication, &page) {
                continue;
            }
            if publication.records().iter().any(|record| {
                matches!(
                    record.item(),
                    super::RendererOutputItem::OwnerAction(
                        super::RendererOwnerAction::TopLevelLocationNavigation(_)
                    )
                )
            }) {
                return;
            }
        }
        panic!("renderer output channel closed before parser location handoff");
    })
    .await
    .expect("released parser continuation should publish its location handoff");

    page.close_async()
        .await
        .expect("parser location handoff page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn command_turn_output_scope_is_removed_after_command_error() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let page_url = url::Url::parse("https://example.test/command-turn-error").expect("page url");
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        page_url,
        "<!doctype html><body>initial</body>",
    )
    .await;

    let (invalid_response_tx, _invalid_response_rx) = oneshot::channel();
    let invalid = page
        .enqueue_async_command(
            RendererPageCommand::dispatch_runtime_protocol_message_with_context_resolution_and_deferred_response(
                None,
                "evaluate".to_owned(),
                "{".to_owned(),
                RendererRuntimeInspectorResponseSender::new(
                    710_220,
                    invalid_response_tx,
                ),
            ),
        )
        .expect("invalid Runtime.evaluate should enqueue")
        .wait()
        .await;
    assert!(
        invalid.is_err(),
        "malformed protocol JSON should fail the command"
    );

    let call_id = 710_221;
    let (response_tx, _response_rx) = oneshot::channel();
    let completion = page
        .enqueue_async_command(
            RendererPageCommand::dispatch_runtime_protocol_message_with_deferred_response(
                None,
                serde_json::json!({
                    "id": call_id,
                    "method": "Runtime.evaluate",
                    "params": {
                        "expression": "42",
                        "returnByValue": true,
                    },
                })
                .to_string(),
                RendererRuntimeInspectorResponseSender::new(call_id, response_tx),
            ),
        )
        .expect("the command after an error should enqueue")
        .wait()
        .await
        .expect("the failed command must not leave an active command-turn output scope");
    assert_eq!(
        completion
            .runtime_inspector_output()
            .and_then(|output| output.protocol_response(call_id))
            .expect("the next Runtime command should retain its response")["result"]["result"]["value"],
        serde_json::json!(42)
    );

    page.close_async()
        .await
        .expect("command-turn error cleanup test page should close");
}
#[tokio::test(flavor = "multi_thread")]
async fn load_target_observer_remains_pending_after_domcontentloaded() {
    let runtime = JsRuntime::initialize();
    let loader =
        ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
    let (
        base_url,
        async_script_request_seen,
        domcontentloaded_request_seen,
        release_async_script_response,
        server,
    ) = spawn_owner_lifecycle_gated_async_server().await;
    let page_url = url::Url::parse(&format!("{base_url}/page")).expect("page url");
    let (completion_tx, completion_rx) = oneshot::channel();
    let (body_tx, raw_body) = ExternalRawDocumentBodyStream::channel(completion_rx);
    let producer = tokio::spawn(async move {
        body_tx
            .send(
                br#"<!doctype html><body>
<script async src="/async.js"></script>
<script>
document.addEventListener("DOMContentLoaded", () => {
  fetch("/domcontentloaded-seen");
}, { once: true });
</script>
</body>"#
                    .to_vec(),
            )
            .await
            .expect("html chunk should send");
        drop(body_tx);
        completion_tx.send(Ok(())).expect("completion should send");
    });

    let creation = runtime.create_streaming_raw_page_from_external_body(
        page_url.clone(),
        page_url,
        None,
        false,
        0,
        Vec::new(),
        200,
        vec![("content-type".to_owned(), b"text/html".to_vec())],
        &loader,
        crate::RendererWebStorageHandles::ephemeral(),
        raw_body,
        false,
        PageVmInitStage::Load,
        crate::RendererReplyBoundary::Stage,
        RendererTopLevelNavigationDispatch::FollowInStandaloneAdapter,
        RendererNavigationReplyPolicy::FollowBeforeReply,
        None,
        None,
        crate::RendererDocumentOptions {
            ..Default::default()
        },
    );
    tokio::pin!(creation);

    tokio::select! {
        _result = &mut creation => {
            panic!("Load observer completed before its gated async script request")
        }
        seen = async_script_request_seen => {
            seen.expect("gated async script request channel should stay open");
        }
    }
    tokio::select! {
        _result = &mut creation => {
            panic!("Load observer completed before DOMContentLoaded was observable")
        }
        seen = domcontentloaded_request_seen => {
            seen.expect("DOMContentLoaded signal request channel should stay open");
        }
    }
    producer.await.expect("producer should finish");

    let (probe_tx, probe_rx) = oneshot::channel();
    probe_tx.send(()).expect("readiness probe should send");
    tokio::select! {
        biased;
        _result = &mut creation => {
            panic!("Load observer returned at DOMContentLoaded while async work was blocked")
        }
        _ = probe_rx => {}
    }

    release_async_script_response
        .send(())
        .expect("release gated async script response");
    let (mut page, _, _creation_diagnostics, creation_artifacts, pending_download) =
        tokio::time::timeout(Duration::from_secs(2), creation)
            .await
            .expect("Load observer should complete after the async script response")
            .expect("page should reach Load");
    assert!(pending_download.is_none());
    assert!(
        creation_artifacts
            .lifecycle_snapshot
            .dom_content_loaded
            .is_some()
    );
    assert!(creation_artifacts.lifecycle_snapshot.load.is_some());
    let (marker, _) = page
        .run_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"globalThis.__lm_load_target_async_marker ?? "pending""#.to_owned(),
            await_promise: false,
        })
        .await
        .expect("async marker should evaluate");
    assert_eq!(
        renderer_json_value(marker),
        Some(serde_json::json!("executed"))
    );

    page.close_async()
        .await
        .expect("Load observer test page should close");
    server.await.expect("lifecycle gated server should finish");
}
#[test]
fn script_execution_domain_is_allowed_on_plain_current_thread_runtime() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let executor = JsLocalExecutor::new();

    runtime.block_on(async move {
        assert!(
            super::is_on_script_execution_domain_for(&executor),
            "plain current-thread runtime should remain a valid script execution fallback"
        );
    });
}
#[test]
fn script_execution_domain_is_allowed_on_matching_executor_lane() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let local = tokio::task::LocalSet::new();
    let executor = JsLocalExecutor::new();

    local.block_on(&runtime, async move {
        let executor_for_assert = executor.clone();
        executor
            .run(async move {
                assert!(
                    super::is_on_script_execution_domain_for(&executor_for_assert),
                    "matching executor lane should remain a valid script execution domain"
                );
            })
            .await;
    });
}
#[test]
fn script_execution_domain_is_allowed_on_scaffold_lane() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let local = tokio::task::LocalSet::new();
    let executor = JsLocalExecutor::new();

    local.block_on(&runtime, async move {
        scope_on_scaffold_js_local_executor(async move {
            assert!(
                super::is_on_script_execution_domain_for(&executor),
                "parse-time scaffold lane should remain a valid script execution domain"
            );
        })
        .await;
    });
}
#[test]
fn script_execution_domain_is_rejected_on_different_executor_lane() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let local = tokio::task::LocalSet::new();
    let first_executor = JsLocalExecutor::new();
    let second_executor = JsLocalExecutor::new();

    local.block_on(&runtime, async move {
        first_executor
            .run(async move {
                assert!(
                    !super::is_on_script_execution_domain_for(&second_executor),
                    "a different executor lane should not count as this page's script execution domain"
                );
            })
            .await;
    });
}
#[test]
fn script_execution_lane_is_rejected_on_plain_current_thread_runtime() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let executor = JsLocalExecutor::new();

    runtime.block_on(async move {
        assert!(
            !is_on_script_execution_lane_for(&executor),
            "plain current-thread runtime fallback must not count as a lane-backed script execution domain"
        );
    });
}
#[test]
fn script_execution_lane_is_allowed_on_matching_executor_lane() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let local = tokio::task::LocalSet::new();
    let executor = JsLocalExecutor::new();

    local.block_on(&runtime, async move {
        let executor_for_assert = executor.clone();
        executor
            .run(async move {
                assert!(
                    is_on_script_execution_lane_for(&executor_for_assert),
                    "matching executor lane should count as a lane-backed script execution domain"
                );
            })
            .await;
    });
}
#[test]
fn script_execution_lane_is_allowed_on_scaffold_lane() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let local = tokio::task::LocalSet::new();
    let executor = JsLocalExecutor::new();

    local.block_on(&runtime, async move {
        scope_on_scaffold_js_local_executor(async move {
            assert!(
                is_on_script_execution_lane_for(&executor),
                "scaffold lane should count as a lane-backed script execution domain"
            );
        })
        .await;
    });
}
#[test]
fn script_execution_lane_is_rejected_on_different_executor_lane() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let local = tokio::task::LocalSet::new();
    let first_executor = JsLocalExecutor::new();
    let second_executor = JsLocalExecutor::new();

    local.block_on(&runtime, async move {
        first_executor
            .run(async move {
                assert!(
                    !is_on_script_execution_lane_for(&second_executor),
                    "a different executor lane must not count as this page's lane-backed script execution domain"
                );
            })
            .await;
    });
}
#[test]
fn scaffold_lane_uses_distinct_script_and_runtime_access_paths() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let local = tokio::task::LocalSet::new();
    let executor = JsLocalExecutor::new();

    local.block_on(&runtime, async move {
        scope_on_scaffold_js_local_executor(async move {
            assert_eq!(
                super::script_execution_domain_path(&executor),
                super::ScriptExecutionDomainPath::DirectScaffoldLane,
                "parse-time scaffold should stay a script-execution domain"
            );
            assert_eq!(
                super::owner_local_runtime_access_path(&executor),
                super::OwnerLocalRuntimeAccessPath::ExecutorHop,
                "parse-time scaffold must not become an owner-local runtime direct path"
            );
        })
        .await;
    });
}
#[test]
fn current_thread_fallback_uses_distinct_direct_paths() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let executor = JsLocalExecutor::new();

    runtime.block_on(async move {
        assert_eq!(
            super::script_execution_domain_path(&executor),
            super::ScriptExecutionDomainPath::CurrentThreadFallback,
            "plain current-thread runtime should remain a script-execution fallback"
        );
        assert_eq!(
            super::script_execution_lane_path(&executor),
            super::ScriptExecutionLanePath::Inaccessible,
            "plain current-thread runtime fallback should no longer count as a lane-backed script execution path"
        );
        assert_eq!(
            super::owner_local_runtime_access_path(&executor),
            super::OwnerLocalRuntimeAccessPath::CurrentThreadFallback,
            "plain current-thread runtime should remain a current-thread owner-local runtime fallback"
        );
        assert_eq!(
            super::owner_local_runtime_entry_path(&executor),
            super::OwnerLocalRuntimeEntryPath::ExecutorHop,
            "plain current-thread runtime fallback should no longer count as a direct owner-local runtime entry path"
        );
    });
}
#[test]
fn current_thread_fallback_is_rejected_on_multithread_runtime() {
    let runtime = tokio::runtime::Builder::new_multi_thread()
        .worker_threads(1)
        .enable_all()
        .build()
        .expect("multi-thread runtime should build");
    let executor = JsLocalExecutor::new();

    runtime.block_on(async move {
        assert!(
            matches!(
                executor.current_access_context(),
                crate::local_executor::JsLocalExecutorAccessContext::Outside
            ),
            "multi-thread runtimes should stay outside any direct current-thread fallback context"
        );
        assert_eq!(
            super::script_execution_domain_path(&executor),
            super::ScriptExecutionDomainPath::Inaccessible,
            "multi-thread runtimes should not count as direct script-execution fallbacks"
        );
        assert_eq!(
            super::owner_local_runtime_access_path(&executor),
            super::OwnerLocalRuntimeAccessPath::ExecutorHop,
            "multi-thread runtimes should not count as direct owner-local-runtime fallbacks"
        );
    });
}
#[test]
fn named_owner_execution_lane_is_rejected_on_plain_current_thread_runtime() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let executor = JsLocalExecutor::new();

    runtime.block_on(async move {
        assert!(
            !super::is_on_named_owner_execution_lane_for(&executor),
            "plain current-thread fallback must not count as a named owner lane"
        );
    });
}
#[test]
fn named_owner_execution_lane_is_allowed_on_matching_executor_lane() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let local = tokio::task::LocalSet::new();
    let executor = JsLocalExecutor::new();

    local.block_on(&runtime, async move {
        let executor_for_assert = executor.clone();
        executor
            .run(async move {
                assert!(
                    super::is_on_named_owner_execution_lane_for(&executor_for_assert),
                    "matching executor lane should count as the named owner lane"
                );
            })
            .await;
    });
}
#[test]
fn named_owner_execution_lane_is_rejected_on_scaffold_lane() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let local = tokio::task::LocalSet::new();
    let executor = JsLocalExecutor::new();

    local.block_on(&runtime, async move {
        scope_on_scaffold_js_local_executor(async move {
            assert!(
                !super::is_on_named_owner_execution_lane_for(&executor),
                "scaffold lane must not count as the named owner lane"
            );
        })
        .await;
    });
}
#[test]
fn named_owner_execution_lane_is_rejected_on_different_executor_lane() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let local = tokio::task::LocalSet::new();
    let first_executor = JsLocalExecutor::new();
    let second_executor = JsLocalExecutor::new();

    local.block_on(&runtime, async move {
        first_executor
            .run(async move {
                assert!(
                    !super::is_on_named_owner_execution_lane_for(&second_executor),
                    "a different executor lane must not count as this page's named owner lane"
                );
            })
            .await;
    });
}
#[test]
fn parse_time_scaffold_lane_is_allowed_on_scaffold_lane() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let local = tokio::task::LocalSet::new();

    local.block_on(&runtime, async move {
        scope_on_scaffold_js_local_executor(async move {
            assert!(
                super::is_on_parse_time_scaffold_lane(),
                "parse-time scaffold lane should be recognized as itself"
            );
        })
        .await;
    });
}
#[test]
fn parse_time_scaffold_lane_is_rejected_on_plain_current_thread_runtime() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");

    runtime.block_on(async move {
        assert!(
            !super::is_on_parse_time_scaffold_lane(),
            "plain current-thread fallback must not count as the parse-time scaffold lane"
        );
    });
}
#[test]
fn parse_time_scaffold_lane_is_rejected_on_named_executor_lane() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("current-thread runtime should build");
    let local = tokio::task::LocalSet::new();
    let executor = JsLocalExecutor::new();

    local.block_on(&runtime, async move {
        executor
            .run(async move {
                assert!(
                    !super::is_on_parse_time_scaffold_lane(),
                    "named owner lanes must not count as the parse-time scaffold lane"
                );
            })
            .await;
    });
}

#[tokio::test(flavor = "multi_thread")]
async fn pending_expression_publishes_console_output_before_settlement() {
    let runtime = JsRuntime::initialize();
    let (output_tx, mut output_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(output_tx);
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
    let url = url::Url::parse("https://example.test/pending-expression-output").unwrap();
    let mut page = create_test_html_page(
        &runtime,
        &loader,
        url,
        "<!doctype html><body>pending</body>",
    )
    .await;
    dispatch_runtime_protocol_with_output_for_test(
        &page,
        serde_json::json!({"id": 731, "method": "Runtime.enable"}),
    )
    .await
    .unwrap();
    output_rx.drain();
    let pending = page
        .enqueue_async_command(RendererPageCommand::EvaluateExpression {
            expression: r#"new Promise(resolve => {
                globalThis.__resolvePendingExpression = resolve;
                console.log('owner-output-before-await');
                setTimeout(() => console.log('owner-output-during-await'), 0);
            })"#
            .to_owned(),
            await_promise: true,
        })
        .expect("the pending expression should enqueue");
    let mut completion = Box::pin(pending.wait());
    let observed = tokio::time::timeout(Duration::from_secs(3), async {
        let mut observed = Vec::new();
        while observed.len() < 2 {
            let output = tokio::select! {
                result = &mut completion => panic!("the unresolved expression completed; error: {:?}", result.err()),
                output = output_rx.recv() => output.expect("the output stream should stay open"),
            };
            for record in output.records() {
                let RendererOutputItem::Observation(RendererProtocolObservation::RuntimeInspector(batch)) = record.item() else {
                    continue;
                };
                for message in &batch.messages {
                    let RendererRuntimeInspectorMessage::Protocol(message) = message else {
                        continue;
                    };
                    if message.get("method").and_then(serde_json::Value::as_str)
                        == Some("Runtime.consoleAPICalled")
                        && let Some(value) = message["params"]["args"][0]["value"].as_str()
                    {
                        observed.push(value.to_owned());
                    }
                }
            }
        }
        observed
    })
    .await
    .expect("console output must arrive before promise settlement");
    assert_eq!(
        observed,
        ["owner-output-before-await", "owner-output-during-await"]
    );

    tokio::time::timeout(
        Duration::from_secs(3),
        page.run_async_command(RendererPageCommand::EvaluateExpression {
            expression: "__resolvePendingExpression('done'); 'resolved'".to_owned(),
            await_promise: false,
        }),
    )
    .await
    .expect("a pending expression must allow another command to run")
    .expect("the resolver command should succeed");
    let output = tokio::time::timeout(Duration::from_secs(3), &mut completion)
        .await
        .expect("the expression should complete after its explicit resolution")
        .expect("the resolved expression should succeed");
    let (completion, _) = output.into_completion_and_predecessor();
    let (reply, _, _) = completion.into_parts();
    assert_eq!(renderer_json_value(reply), Some(serde_json::json!("done")));
    page.close_async()
        .await
        .expect("close pending-expression page");
}

#[tokio::test(flavor = "multi_thread")]
async fn navigation_follow_publishes_command_output_before_replacing_document() {
    let runtime = JsRuntime::initialize();
    let (output_tx, mut output_rx) = renderer_external_activity_test_channel();
    runtime.set_renderer_output_transport_sender(output_tx);
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
    let url = url::Url::parse("https://example.test/navigation-command-output").unwrap();
    let mut page =
        create_test_html_page(&runtime, &loader, url, "<!doctype html><body>source</body>").await;
    dispatch_runtime_protocol_with_output_for_test(
        &page,
        serde_json::json!({"id": 732, "method": "Runtime.enable"}),
    )
    .await
    .unwrap();
    page.run_async_command(RendererPageCommand::EvaluateExpression {
        expression: "document.title = 'source document'".to_owned(),
        await_promise: false,
    })
    .await
    .expect("the source Document title should publish");
    let initial_publications = output_rx.drain();
    let source_stream = initial_publications
        .last()
        .expect("Runtime.enable must publish the source Document's output")
        .cursor()
        .stream();
    let source_document = initial_publications
        .iter()
        .flat_map(|publication| publication.records())
        .find_map(|record| match record.item() {
            RendererOutputItem::Observation(RendererProtocolObservation::DocumentTitleChanged(
                change,
            )) if change.title == "source document" => Some(change.source_document),
            _ => None,
        })
        .expect("the source title observation must identify its exact Document");
    let replacement_url = "data:text/html;charset=utf-8,%3C!doctype%20html%3E%3Ctitle%3Ereplacement%3C/title%3E%3Cbody%3Ereplacement%3C/body%3E";
    let (reply, state) = tokio::time::timeout(
        Duration::from_secs(3),
        page.run_async_command(RendererPageCommand::EvaluateExpressionAndFollowPendingNavigation {
            expression: format!(
                "console.log('command-output-before-navigation'); location.href = {replacement_url:?}; 'navigating'"
            ),
            await_promise: false,
        }),
    )
    .await
    .expect("navigation follow should complete")
    .expect("the command should survive its navigation");
    assert_eq!(
        renderer_json_value(reply),
        Some(serde_json::json!("navigating"))
    );
    assert_eq!(state.document_title, "replacement");

    let publications = output_rx.drain();
    let source_output = publications
        .iter()
        .position(|publication| {
            publication.records().iter().any(|record| matches!(
                record.item(),
                RendererOutputItem::Observation(RendererProtocolObservation::RuntimeInspector(batch))
                    if batch.messages.iter().any(|message| matches!(
                        message,
                        RendererRuntimeInspectorMessage::Protocol(message)
                            if message["method"] == "Runtime.consoleAPICalled"
                                && message["params"]["args"][0]["value"] == "command-output-before-navigation"
                    ))
            ))
        })
        .expect("the source command's console notification must be retained");
    assert_eq!(publications[source_output].cursor().stream(), source_stream);
    let replacement_output = publications
        .iter()
        .position(|publication| {
            publication.records().iter().any(|record| matches!(
                record.item(),
                RendererOutputItem::Observation(RendererProtocolObservation::DocumentTitleChanged(change))
                    if change.title == "replacement" && change.source_document != source_document
            ))
        })
        .expect("the replacement title observation must identify its new Document");
    assert!(
        source_output < replacement_output,
        "command output must be published before replacing its source Document"
    );
    page.close_async()
        .await
        .expect("close navigation-output page");
}