Skip to content

armgit / moli

Public Imported from GitHub
0

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

151 KB
Raw Blame
use super::*;
use crate::dynamic_script_owner::DynamicScriptRunnable;

fn dynamic_script_owner_id(raw: u64) -> crate::dynamic_script_owner::DynamicScriptOwnerId {
    crate::dynamic_script_owner::DynamicScriptOwnerId::from_u64(raw)
}

fn take_main_document_runtime_action(
    queue: &crate::page_task_queue::PageTaskQueueTestHarness,
) -> Option<RendererPageMainDocumentRuntimeAction> {
    queue
        .task_sources()
        .take_main_document_runtime_for_executor_test()
        .map(|task| task.into_action())
}

fn prepared_post_parse_script(position: usize, mode: ScriptMode) -> PreparedScript {
    let attribute = match mode {
        ScriptMode::Async => " async",
        ScriptMode::Defer => " defer",
        ScriptMode::Normal => "",
        other => panic!("unsupported test script mode: {other:?}"),
    };
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
            Url::parse("https://example.com/").expect("test url"),
            format!(
                "<!doctype html><html><head><script{attribute} src=\"/script-{position}.js\"></script></head><body></body></html>"
            ),
        );
    let script = document
        .script_handles()
        .first()
        .copied()
        .expect("script handle");
    let classification = classify_parser_script(&document, script).expect("script classification");
    let final_url = document.final_url_clone().expect("document final url");
    let document_base_url = document
        .document_base_url_clone()
        .expect("document base url");
    match build_prepared_script(
        &classification,
        final_url,
        document_base_url,
        script,
        position,
    ) {
        PrepareScriptOutcome::Prepared(script) => *script,
        _ => panic!("expected prepared post-parse script"),
    }
}

fn test_post_parse_lifecycle_driver_for(
    stage: crate::renderer::PageVmInitStage,
) -> PostParseLifecycleDriver {
    PostParseLifecycleDriver::new(
        stage,
        PostParseLifecycleRound {
            queue_stats: PostParseLifecycleQueueStats::default(),
            phase_started: Instant::now(),
        },
    )
}

fn ready_dynamic_runtime_script(position: usize) -> PreparedScript {
    PreparedScript {
        position,
        node_id: NodeId::new(position + 1),
        kind: ScriptKind::Classic,
        mode: ScriptMode::Async,
        source_kind: ScriptSourceKind::External,
        fetch_metadata: crate::planning::ScriptFetchMetadata::default(),
        source: ScriptSource::External,
        url: Url::parse(&format!("https://example.com/dynamic-{position}.js")).unwrap(),
        base_url: Url::parse(&format!("https://example.com/dynamic-{position}.js")).unwrap(),
        initiator_url: Url::parse("https://example.com/").unwrap(),
        host_script_handle: None,
    }
}

#[tokio::test]
async fn successful_external_classic_script_drains_microtasks_before_completion() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_test_vm_with_loader("https://example.com/", &loader);
    let script = ready_dynamic_runtime_script(6);

    let outcome = vm
        .execute_loaded_prepared_script_source(
            &script,
            r#"
            globalThis.__classicScriptOrder = ["body"];
            queueMicrotask(() => globalThis.__classicScriptOrder.push("microtask"));
            "#,
            None,
        )
        .await
        .expect("external classic script should complete");

    assert!(matches!(
        outcome,
        crate::script_vm::LoadedScriptExecutionOutcome::Completed(
            crate::script_vm::PreparedScriptBodyActivity::Entered
        )
    ));
    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__classicScriptOrder)")
            .expect("classic script microtask should be observable at completion"),
        r#"["body","microtask"]"#,
    );
}

#[tokio::test]
async fn classic_script_exception_reports_window_error_then_completes() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_test_vm_with_loader("https://example.com/", &loader);
    vm.eval(
        r#"
        globalThis.__classicScriptOrder = [];
        globalThis.__classicScriptError = null;
        window.onerror = (message, source, line, column, error) => {
          globalThis.__classicScriptOrder.push("global-error");
          globalThis.__classicScriptError = {
            message,
            source,
            linePositive: typeof line === "number" && line > 0,
            columnPositive: typeof column === "number" && column > 0,
            exactPrimitive: error === 7,
          };
          return true;
        };
        "installed";
        "#,
    )
    .expect("window error observer should install");

    let mut script = ready_dynamic_runtime_script(7);
    script.url = Url::parse("data:,throw 7").expect("data script URL");
    script.base_url = script.url.clone();
    let outcome = vm
        .execute_loaded_prepared_script_source(
            &script,
            r#"
            globalThis.__classicScriptOrder.push("body");
            queueMicrotask(() => globalThis.__classicScriptOrder.push("microtask"));
            throw 7;
            "#,
            None,
        )
        .await
        .expect("a page-thrown exception should not fail classic script loading");

    assert!(matches!(
        outcome,
        crate::script_vm::LoadedScriptExecutionOutcome::Completed(
            crate::script_vm::PreparedScriptBodyActivity::Entered
        )
    ));
    assert_eq!(
        vm.eval(
            r#"
            JSON.stringify({
              order: globalThis.__classicScriptOrder,
              error: globalThis.__classicScriptError,
            })
            "#,
        )
        .expect("classic script error report should remain observable"),
        r#"{"order":["body","global-error","microtask"],"error":{"message":"Uncaught 7","source":"data:,throw 7","linePositive":true,"columnPositive":true,"exactPrimitive":true}}"#,
    );
}

fn is_document_script_execution_work(
    work: &PostParsePageOwnedWork,
    lane: crate::document_script_scheduler::DocumentScriptExecutionLane,
    position: usize,
) -> bool {
    let work = match work {
        PostParsePageOwnedWork::DocumentScript(work)
        | PostParsePageOwnedWork::DocumentScriptWithStylesheetSnapshot { work, .. } => work,
        PostParsePageOwnedWork::Lifecycle(_) => return false,
    };
    matches!(
        work.as_ref(),
        crate::document_script_scheduler::PageOwnedDocumentScriptWork::Script {
            lane: actual_lane,
            script,
            ..
        } if *actual_lane == lane && script.position == position
    )
}

fn pop_post_parse_page_task(page_task_queue: &mut PageTaskQueue) -> Option<PageTask> {
    page_task_queue
        .post_parse_pop_front()
        .and_then(PostParsePageOwnedWork::into_page_task)
}

fn post_parse_lifecycle_work(work: PostParseLifecycleWork) -> PostParsePageOwnedWork {
    PostParsePageOwnedWork::lifecycle_work(work)
}

fn post_parse_lifecycle_action(work: PostParseLifecycleWork) -> PostParseProcessingAction {
    PostParseProcessingAction::from_page_owned_work(post_parse_lifecycle_work(work))
}

fn post_parse_document_script_action(
    lane: crate::document_script_scheduler::DocumentScriptExecutionLane,
    script: PreparedScript,
) -> PostParseProcessingAction {
    PostParseProcessingAction::from_page_owned_work(post_parse_document_script_work(lane, script))
}

fn post_parse_document_script_work(
    lane: crate::document_script_scheduler::DocumentScriptExecutionLane,
    script: PreparedScript,
) -> PostParsePageOwnedWork {
    PostParsePageOwnedWork::document_script_work(
        crate::document_script_scheduler::PageOwnedDocumentScriptWork::script(lane, script),
    )
}

fn post_parse_owner_step_for_lifecycle_work(
    work: PostParseLifecycleWork,
) -> PostParseOwnerDriverStep {
    PostParseOwnerDriverStep::Ready(Box::new(DocumentProcessingAction::PostParsePageOwnedWork(
        Box::new(post_parse_lifecycle_work(work)),
    )))
}

fn ready_dynamic_runtime_module_script(position: usize, node_id: NodeId) -> PreparedScript {
    PreparedScript {
        position,
        node_id,
        kind: ScriptKind::Module,
        mode: ScriptMode::ModuleInOrder,
        source_kind: ScriptSourceKind::External,
        fetch_metadata: crate::planning::ScriptFetchMetadata::default(),
        source: ScriptSource::Loaded(
            "import './dep.js'; globalThis.dynamicModuleRan = true;".to_owned(),
        ),
        url: Url::parse(&format!("https://example.com/dynamic-module-{position}.js")).unwrap(),
        base_url: Url::parse(&format!("https://example.com/dynamic-module-{position}.js")).unwrap(),
        initiator_url: Url::parse("https://example.com/").unwrap(),
        host_script_handle: Some(format!("runtime-module-{position}")),
    }
}

#[test]
fn csp_request_treats_missing_dynamic_script_node_as_not_parser_inserted() {
    let vm = new_storage_test_vm("https://app.test/page.html");
    let script = ready_dynamic_runtime_script(1);

    let request = vm.content_security_policy_script_element_request(&script);

    assert!(
        !request.parser_inserted,
        "an unknown DOM node should not make a dynamic script parser-inserted"
    );
}

#[test]
fn external_script_redirect_final_url_obeys_script_src_csp() {
    let mut vm = new_storage_test_vm("https://app.test/page.html");
    vm.set_response_content_security_policies(&["script-src 'self'".to_owned()]);
    vm.eval(
        r#"
        globalThis.__scriptCspEvents = [];
        document.addEventListener("securitypolicyviolation", event => {
            globalThis.__scriptCspEvents.push({
                blockedURI: event.blockedURI,
                effectiveDirective: event.effectiveDirective,
                disposition: event.disposition,
                instance: event instanceof SecurityPolicyViolationEvent,
            });
        });
        "#,
    )
    .expect("install CSP listener");
    let script = PreparedScript {
        position: 1,
        node_id: NodeId::new(2),
        kind: ScriptKind::Classic,
        mode: ScriptMode::Async,
        source_kind: ScriptSourceKind::External,
        fetch_metadata: crate::planning::ScriptFetchMetadata::default(),
        source: ScriptSource::External,
        url: Url::parse("https://app.test/redirect.js").unwrap(),
        base_url: Url::parse("https://app.test/redirect.js").unwrap(),
        initiator_url: Url::parse("https://app.test/page.html").unwrap(),
        host_script_handle: None,
    };
    let final_url = Url::parse("https://cdn.test/final.js").unwrap();
    let response = Ok(crate::types::NavigationResponse::from_head_and_text_body(
        moli_fetch::ResponseHead {
            status_text: None,
            final_url: final_url.clone(),
            status: 200,
            headers: Vec::new(),
            request_cookie_report: None,
            cookie_set_reports: Vec::new(),
            redirected: true,
            redirect_chain: Vec::new(),
            from_cache: false,
            negotiated_http_version: None,
        },
        "globalThis.__redirectScriptRan = true;".to_owned(),
    ));

    let error = vm
        .enforce_external_script_redirect_csp(&script, Some(&response))
        .expect_err("redirected script final URL should be blocked by script-src");
    assert!(error.message().contains("Content Security Policy"));
    assert_eq!(
        drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm),
        1
    );
    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__scriptCspEvents)")
            .expect("read CSP events"),
        format!(
            r#"[{{"blockedURI":"{}","effectiveDirective":"script-src-elem","disposition":"enforce","instance":true}}]"#,
            final_url
        )
    );
}

#[test]
fn module_graph_redirect_final_url_obeys_script_src_csp() {
    let mut vm = new_storage_test_vm("https://app.test/page.html");
    vm.set_response_content_security_report_only_policies(&["script-src 'self'".to_owned()]);
    vm.set_response_content_security_policies(&["script-src 'self'".to_owned()]);
    vm.eval(
        r#"
        globalThis.__moduleCspEvents = [];
        document.addEventListener("securitypolicyviolation", event => {
            globalThis.__moduleCspEvents.push({
                blockedURI: event.blockedURI,
                effectiveDirective: event.effectiveDirective,
                disposition: event.disposition,
                instance: event instanceof SecurityPolicyViolationEvent,
            });
        });
        "#,
    )
    .expect("install module CSP listener");
    let final_url = Url::parse("https://cdn.test/dependency.js").unwrap();
    let fetched_source = crate::module_runtime::ModuleGraphFetchedSource::new(
        final_url.clone(),
        true,
        crate::module_runtime::ModuleSource::text("export default 1;".to_owned()),
    );

    let error = vm
        .module_graph_fetched_source_or_csp_error(
            7,
            fetched_source,
            &crate::module_runtime::ModuleFetchMetadata::default(),
        )
        .expect_err("redirected module final URL should be blocked by script-src");
    assert!(error.message().contains("Content Security Policy"));
    assert_eq!(
        drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm),
        2
    );
    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__moduleCspEvents)")
            .expect("read module CSP events"),
        format!(
            r#"[{{"blockedURI":"{}","effectiveDirective":"script-src-elem","disposition":"report","instance":true}},{{"blockedURI":"{}","effectiveDirective":"script-src-elem","disposition":"enforce","instance":true}}]"#,
            final_url, final_url
        )
    );
}

#[tokio::test]
async fn external_module_prepared_script_hides_root_graph_fetch_in_owner_state() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/page.html").expect("test url"),
        "<!doctype html><html><head><script type=\"module\" src=\"/entry\"></script></head></html>"
            .to_owned(),
    );
    let script_handle = document
        .script_handles()
        .first()
        .copied()
        .expect("module script handle");
    let classification =
        classify_parser_script(&document, script_handle).expect("script classification");
    let final_url = document.final_url_clone().expect("document final url");
    let document_base_url = document
        .document_base_url_clone()
        .expect("document base url");
    let mut prepared = match build_prepared_script(
        &classification,
        final_url,
        document_base_url,
        script_handle,
        0,
    ) {
        PrepareScriptOutcome::Prepared(script) => *script,
        _ => panic!("expected prepared external module script"),
    };
    assert!(matches!(prepared.source, ScriptSource::External));

    let page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    vm.bind_prepared_script_handle_if_needed(&mut prepared, ScriptHandleSource::ParserOwned);

    let task_owner = vm
        .current_main_document_task_owner()
        .expect("main document task owner");
    assert!(
        vm.claim_main_parser_deferred_script(
            task_owner,
            prepared.clone(),
            None,
            None,
            Default::default(),
        )
        .expect("external module acceptance should start its graph")
    );
    let root_key = crate::module_runtime::ModuleMapKey::java_script(prepared.url.clone());
    let entry = vm
        .document_runtime
        .native_module_entry_id(&root_key)
        .expect("root graph fetch should reserve module map entry");
    assert_eq!(
        vm.document_runtime.native_module_entry_state(entry),
        crate::module_runtime::ModuleMapEntryState::Fetching
    );
    let parser_owner = crate::module_script_continuation::MainParserDocumentOwner::new(task_owner);
    let pending_script_id =
        crate::document_script_scheduler::ParserPendingScriptId::new(parser_owner, &prepared);
    assert!(
        vm.document_runtime
            .parser_module_document_scripts()
            .has_module_script(pending_script_id),
        "graph start must remain attached to its preparation-time PendingScript"
    );
    let marker = vm
        .seal_main_parser_deferred_scripts(task_owner)
        .expect("parser EOF should arm the accepted module-defer queue");
    assert_eq!(
        marker
            .as_lifecycle_work()
            .expect("parser-deferred marker should be lifecycle work")
            .main_parser_deferred_script_count(),
        1
    );
    assert!(
        vm.document_runtime
            .parser_module_document_scripts()
            .has_after_parsing_script(parser_owner),
        "parser EOF must expose the accepted script through parser order"
    );
}

#[tokio::test]
async fn page_timer_turn_catches_callback_exception_variants_and_continues() {
    let mut vm = new_storage_test_vm("https://example.com/");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    vm.eval(
        r#"
        globalThis.__timerEvents = [];
        globalThis.__timerReportedErrors = [];
        globalThis.__timerErrorObject = new Error("timer error object");
        addEventListener("error", event => {
            globalThis.__timerReportedErrors.push(
                event.error === globalThis.__timerErrorObject
                    ? "same-error-object"
                    : String(event.error)
            );
        });
        setTimeout(() => {
            globalThis.__timerEvents.push("error-before");
            throw globalThis.__timerErrorObject;
        }, 0);
        setTimeout(() => {
            globalThis.__timerEvents.push("primitive-before");
            throw "timer primitive";
        }, 0);
        setTimeout(() => {
            globalThis.__timerEvents.push("after");
        }, 0);
        "scheduled";
        "#,
    )
    .expect("timer setup");

    for _ in 0..3 {
        assert!(
            vm.run_next_due_timer_callback_for_test(&loader)
                .await
                .expect("timer turn")
        );
    }

    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__timerEvents)")
            .expect("events"),
        r#"["error-before","primitive-before","after"]"#
    );
    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__timerReportedErrors)")
            .expect("reported timer errors"),
        r#"["same-error-object","timer primitive"]"#
    );
    let runtime_warnings = vm.runtime_observable_lifecycle_errors_for_testing();
    assert!(
        runtime_warnings
            .iter()
            .any(|warning| warning.contains("timer callback dispatch failed")
                && warning.contains("timer error object")),
        "runtime warnings: {:?}",
        runtime_warnings
    );
    assert!(
        runtime_warnings
            .iter()
            .any(|warning| warning.contains("timer callback dispatch failed")
                && warning.contains("timer primitive")),
        "runtime warnings: {:?}",
        runtime_warnings
    );
}

#[tokio::test]
async fn window_timer_uses_webidl_callback_function_semantics() {
    let mut vm = new_storage_test_vm("https://window-timer-webidl-callback.test/");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    vm.eval(
        r#"
        const frame = document.createElement("iframe");
        (document.body || document.documentElement || document).appendChild(frame);
        globalThis.__windowTimerCallbackFrame = frame;
        "#,
    )
    .expect("window timer callback-realm setup");
    materialize_single_child_default_realm_for_test(&mut vm, "window timer callback-realm setup");

    vm.eval(
        r#"
        (() => {
          const child = __windowTimerCallbackFrame.contentWindow;
          globalThis.__windowTimerCallbackFacts = null;
          globalThis.__windowTimerProxyCalls = 0;
          const callback = child.Function(`
            return new Proxy(
              function(value) {
                "use strict";
                parent.__windowTimerCallbackFacts = {
                  callbackRealm:
                    globalThis === parent.__windowTimerCallbackFrame.contentWindow,
                  receiverIsTargetWindow: this === parent,
                  argumentCount: arguments.length,
                  value,
                  proxyCalls: parent.__windowTimerProxyCalls
                };
              },
              {
                apply(target, receiver, argumentsList) {
                  parent.__windowTimerProxyCalls++;
                  return Reflect.apply(target, receiver, argumentsList);
                }
              }
            );
          `)();
          setTimeout(callback, 0, "extra-argument");
          return "scheduled";
        })()
        "#,
    )
    .expect("Window timer Web IDL callback should schedule");

    vm.advance_timers_until_deadline_for_test(&loader)
        .await
        .expect("Window timer Web IDL callback should drain");
    assert_eq!(
        vm.eval("JSON.stringify(__windowTimerCallbackFacts)")
            .expect("Window timer Web IDL callback facts"),
        r#"{"callbackRealm":true,"receiverIsTargetWindow":true,"argumentCount":1,"value":"extra-argument","proxyCalls":1}"#
    );
}

#[tokio::test]
async fn request_animation_frame_callbacks_share_one_timestamp_per_batch() {
    let mut vm = new_storage_test_vm("https://example.com/");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    vm.eval(
        r#"
        globalThis.__animationFrameTimestamps = [];
        globalThis.__animationFrameRequestTime = performance.now();
        requestAnimationFrame(timestamp => {
            globalThis.__animationFrameTimestamps.push(timestamp);
            requestAnimationFrame(nextTimestamp => {
                globalThis.__animationFrameTimestamps.push(nextTimestamp);
            });
        });
        requestAnimationFrame(timestamp => {
            globalThis.__animationFrameTimestamps.push(timestamp);
        });
        "scheduled";
        "#,
    )
    .expect("animation frame setup");

    vm.advance_timers_until_deadline_for_test(&loader)
        .await
        .expect("animation frame callbacks");

    assert_eq!(
        vm.eval(
            r#"
            JSON.stringify({
                count: globalThis.__animationFrameTimestamps.length,
                sameBatch:
                    globalThis.__animationFrameTimestamps[0] ===
                    globalThis.__animationFrameTimestamps[1],
                nextBatchIsLater:
                    globalThis.__animationFrameTimestamps[2] >
                    globalThis.__animationFrameTimestamps[0],
                usesPerformanceTimeline:
                    globalThis.__animationFrameTimestamps[0] >=
                        globalThis.__animationFrameRequestTime &&
                    globalThis.__animationFrameTimestamps[0] < performance.timeOrigin,
            })
            "#,
        )
        .expect("animation frame result"),
        r#"{"count":3,"sameBatch":true,"nextBatchIsLater":true,"usesPerformanceTimeline":true}"#
    );
}

#[tokio::test]
async fn request_animation_frame_reports_exceptions_to_the_callback_realm() {
    let mut vm = new_storage_test_vm("https://example.com/");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    vm.eval(
        r#"
        for (let index = 0; index < 3; index++) {
            (document.body || document.documentElement || document)
                .appendChild(document.createElement("iframe"));
        }
        globalThis.__animationFrameErrorWindows = [];
        frames[0].onerror = () => __animationFrameErrorWindows.push("frame0");
        frames[1].onerror = () => __animationFrameErrorWindows.push("frame1");
        frames[2].onerror = () => __animationFrameErrorWindows.push("frame2");
        frames[0].requestAnimationFrame(
            new frames[1].Function(
                `throw new parent.frames[2].Error("animation frame error");`
            )
        );
        "scheduled";
        "#,
    )
    .expect("cross-realm animation frame setup");

    vm.advance_timers_until_deadline_for_test(&loader)
        .await
        .expect("cross-realm animation frame callback");

    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__animationFrameErrorWindows)")
            .expect("reported animation frame errors"),
        r#"["frame1"]"#
    );
}

#[tokio::test]
async fn request_animation_frame_uses_webidl_callback_function_semantics() {
    let mut vm = new_storage_test_vm("https://animation-frame-webidl-callback.test/");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    vm.eval(
        r#"
        const frame = document.createElement("iframe");
        (document.body || document.documentElement || document).appendChild(frame);
        globalThis.__animationFrameCallbackFrame = frame;
        "#,
    )
    .expect("animation frame callback-realm setup");
    materialize_single_child_default_realm_for_test(
        &mut vm,
        "animation frame callback-realm setup",
    );

    vm.eval(
        r#"
        (() => {
          const child = __animationFrameCallbackFrame.contentWindow;
          globalThis.__animationFrameCallbackFacts = null;
          globalThis.__animationFrameProxyCalls = 0;
          const callback = child.Function(`
            return new Proxy(
              function(timestamp) {
                "use strict";
                parent.__animationFrameCallbackFacts = {
                  callbackRealm:
                    globalThis === parent.__animationFrameCallbackFrame.contentWindow,
                  receiverUndefined: this === undefined,
                  argumentCount: arguments.length,
                  timestampFinite: Number.isFinite(timestamp),
                  proxyCalls: parent.__animationFrameProxyCalls
                };
              },
              {
                apply(target, receiver, argumentsList) {
                  parent.__animationFrameProxyCalls++;
                  if (receiver !== undefined)
                    throw new Error("animation frame callback receiver was not undefined");
                  return Reflect.apply(target, receiver, argumentsList);
                }
              }
            );
          `)();
          requestAnimationFrame(callback);
          return "scheduled";
        })()
        "#,
    )
    .expect("animation frame Web IDL callback should schedule");

    vm.advance_timers_until_deadline_for_test(&loader)
        .await
        .expect("animation frame Web IDL callback should drain");
    assert_eq!(
        vm.eval("JSON.stringify(__animationFrameCallbackFacts)")
            .expect("animation frame Web IDL callback facts"),
        r#"{"callbackRealm":true,"receiverUndefined":true,"argumentCount":1,"timestampFinite":true,"proxyCalls":1}"#
    );
}

#[tokio::test]
async fn request_animation_frame_retires_with_its_callback_realm() {
    let mut vm = new_storage_test_vm("https://animation-frame-callback-retirement.test/");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    vm.eval(
        r#"
        const frame = document.createElement("iframe");
        (document.body || document.documentElement || document).appendChild(frame);
        globalThis.__retiredAnimationFrameCallbackFrame = frame;
        globalThis.__retiredAnimationFrameCallbackRan = false;
        "#,
    )
    .expect("animation frame callback retirement setup");
    materialize_single_child_default_realm_for_test(
        &mut vm,
        "animation frame callback retirement setup",
    );

    vm.eval(
        r#"
        (() => {
          const child = __retiredAnimationFrameCallbackFrame.contentWindow;
          requestAnimationFrame(child.Function(
            `parent.__retiredAnimationFrameCallbackRan = true;`
          ));
          __retiredAnimationFrameCallbackFrame.remove();
          return "scheduled";
        })()
        "#,
    )
    .expect("retired animation frame callback should schedule");

    vm.advance_timers_until_deadline_for_test(&loader)
        .await
        .expect("retired animation frame callback should leave the timer source quiescent");
    assert_eq!(
        vm.eval("String(__retiredAnimationFrameCallbackRan)")
            .expect("retired animation frame callback result"),
        "false"
    );
}

#[tokio::test]
async fn window_timer_stringifies_non_function_handler_before_queueing() {
    let mut vm = new_storage_test_vm("https://example.com/");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    vm.eval(
        r#"
        globalThis.__timerLog = "";
        function logger(value) {
          globalThis.__timerLog += value + " ";
        }
        setTimeout({ toString() {
          setTimeout("logger('ONE')", 0);
          return "logger('TWO')";
        } }, 0);
        "scheduled";
        "#,
    )
    .expect("timer setup");

    for _ in 0..2 {
        assert!(
            vm.run_next_due_timer_callback_for_test(&loader)
                .await
                .expect("timer turn")
        );
    }

    assert_eq!(
        vm.eval("globalThis.__timerLog").expect("timer log"),
        "ONE TWO "
    );
}

#[test]
fn window_string_timers_apply_trusted_types_default_policy() {
    let mut vm = new_storage_test_vm("https://trusted-types-window-timers.test/");
    vm.set_response_content_security_policies(&["require-trusted-types-for 'script'".to_owned()]);

    vm.eval(
        r#"
        globalThis.__trustedTimerLog = [];
        globalThis.__trustedTimerPolicyCalls = [];
        trustedTypes.createPolicy("default", {
          createScript(source, type, sink) {
            __trustedTimerPolicyCalls.push([source, type, sink]);
            if (source === "timeout-token") {
              return "__trustedTimerLog.push('timeout')";
            }
            return "__trustedTimerLog.push('interval'); clearInterval(__trustedIntervalId)";
          }
        });
        setTimeout("timeout-token", 0);
        globalThis.__trustedIntervalId = setInterval("interval-token", 0);
        "scheduled";
        "#,
    )
    .expect("trusted timer setup should evaluate");

    for timer_name in ["timeout", "interval"] {
        assert!(
            matches!(
                vm.run_next_timeout_for_test()
                    .unwrap_or_else(|error| panic!("{timer_name} should run: {error}")),
                crate::host::HostTimeoutRunResult::Consumed
            ),
            "{timer_name} callback should execute successfully"
        );
    }

    assert_eq!(
        vm.eval("JSON.stringify({calls: __trustedTimerPolicyCalls, log: __trustedTimerLog})")
            .expect("trusted timer result should evaluate"),
        r#"{"calls":[["timeout-token","TrustedScript","Window setTimeout"],["interval-token","TrustedScript","Window setInterval"]],"log":["timeout","interval"]}"#
    );
}

#[test]
fn window_string_timers_apply_eval_csp_before_scheduling() {
    let mut vm = new_storage_test_vm("https://string-timer-csp.test/page.html");
    vm.set_response_content_security_policies(&["script-src 'self' 'unsafe-inline'".to_owned()]);
    vm.eval(
        r#"
        globalThis.__stringTimerRuns = [];
        globalThis.__stringTimerCspEvents = [];
        document.addEventListener("securitypolicyviolation", event => {
          __stringTimerCspEvents.push({
            blockedURI: event.blockedURI,
            effectiveDirective: event.effectiveDirective,
            disposition: event.disposition,
          });
        });
        globalThis.__stringTimerTimeout = setTimeout(
          "__stringTimerRuns.push('timeout')",
          0
        );
        globalThis.__stringTimerInterval = setInterval(
          "__stringTimerRuns.push('interval')",
          0
        );
        "scheduled";
        "#,
    )
    .expect("blocked string timer installation should not throw");

    assert!(matches!(
        vm.run_next_timeout_for_test()
            .expect("blocked string timers should leave the scheduler idle"),
        crate::host::HostTimeoutRunResult::Idle
    ));
    assert_eq!(
        drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm),
        2
    );
    assert_eq!(
        vm.eval(
            "JSON.stringify({timeoutId: __stringTimerTimeout, intervalId: __stringTimerInterval, runs: __stringTimerRuns, events: __stringTimerCspEvents})"
        )
            .expect("string timer CSP outcome should be observable"),
        r#"{"timeoutId":0,"intervalId":0,"runs":[],"events":[{"blockedURI":"eval","effectiveDirective":"script-src","disposition":"enforce"},{"blockedURI":"eval","effectiveDirective":"script-src","disposition":"enforce"}]}"#
    );
}

#[test]
fn window_string_timer_report_only_eval_csp_reports_and_runs() {
    let mut vm = new_storage_test_vm("https://string-timer-csp-report-only.test/page.html");
    vm.set_response_content_security_report_only_policies(&["script-src 'self'".to_owned()]);
    vm.eval(
        r#"
        globalThis.__reportOnlyStringTimerRan = false;
        globalThis.__reportOnlyStringTimerEvents = [];
        document.addEventListener("securitypolicyviolation", event => {
          __reportOnlyStringTimerEvents.push({
            blockedURI: event.blockedURI,
            effectiveDirective: event.effectiveDirective,
            disposition: event.disposition,
          });
        });
        setTimeout("__reportOnlyStringTimerRan = true", 0);
        "scheduled";
        "#,
    )
    .expect("report-only string timer should schedule");

    assert!(matches!(
        vm.run_next_timeout_for_test()
            .expect("report-only string timer should run"),
        crate::host::HostTimeoutRunResult::Consumed
    ));
    assert_eq!(
        drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm),
        1
    );
    assert_eq!(
        vm.eval(
            "JSON.stringify({ran: __reportOnlyStringTimerRan, events: __reportOnlyStringTimerEvents})"
        )
        .expect("report-only string timer result should be observable"),
        r#"{"ran":true,"events":[{"blockedURI":"eval","effectiveDirective":"script-src","disposition":"report"}]}"#
    );
}

#[test]
fn window_string_timer_unsafe_eval_runs_without_reporting() {
    let mut vm = new_storage_test_vm("https://string-timer-csp-allowed.test/page.html");
    vm.set_response_content_security_policies(&["script-src 'self' 'unsafe-eval'".to_owned()]);
    vm.eval(
        r#"
        globalThis.__allowedStringTimerRan = false;
        globalThis.__allowedStringTimerEvents = 0;
        document.addEventListener("securitypolicyviolation", () => {
          __allowedStringTimerEvents++;
        });
        setTimeout("__allowedStringTimerRan = true", 0);
        "scheduled";
        "#,
    )
    .expect("allowed string timer should schedule");

    assert!(matches!(
        vm.run_next_timeout_for_test()
            .expect("allowed string timer should run"),
        crate::host::HostTimeoutRunResult::Consumed
    ));
    assert_eq!(
        drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm),
        0
    );
    assert_eq!(
        vm.eval(
            "JSON.stringify({ran: __allowedStringTimerRan, events: __allowedStringTimerEvents})"
        )
        .expect("allowed string timer result should be observable"),
        r#"{"ran":true,"events":0}"#
    );
}

#[test]
fn window_string_timer_honors_trusted_types_eval_with_enforced_require() {
    let mut vm = new_storage_test_vm("https://string-timer-trusted-types-eval.test/page.html");
    vm.set_response_content_security_policies(&[
        "script-src 'trusted-types-eval'; require-trusted-types-for 'script'".to_owned(),
    ]);
    vm.eval(
        r#"
        globalThis.__trustedTypesEvalTimerRan = false;
        globalThis.__trustedTypesEvalTimerEvents = 0;
        trustedTypes.createPolicy("default", { createScript: source => source });
        document.addEventListener("securitypolicyviolation", () => {
          __trustedTypesEvalTimerEvents++;
        });
        setTimeout("__trustedTypesEvalTimerRan = true", 0);
        "scheduled";
        "#,
    )
    .expect("trusted-types-eval string timer should schedule");

    assert!(matches!(
        vm.run_next_timeout_for_test()
            .expect("trusted-types-eval string timer should run"),
        crate::host::HostTimeoutRunResult::Consumed
    ));
    assert_eq!(
        drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm),
        0
    );
    assert_eq!(
        vm.eval(
            "JSON.stringify({ran: __trustedTypesEvalTimerRan, events: __trustedTypesEvalTimerEvents})"
        )
        .expect("trusted-types-eval timer result should be observable"),
        r#"{"ran":true,"events":0}"#
    );
}

#[tokio::test]
async fn window_timer_delay_uses_webidl_long_conversion() {
    let mut vm = new_storage_test_vm("https://example.com/");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    vm.eval(
        r#"
        globalThis.__timeoutFired = false;
        globalThis.__intervalFired = false;
        let intervalId = setInterval(() => {
          globalThis.__intervalFired = true;
          clearInterval(intervalId);
        }, Math.pow(2, 32));
        setTimeout(() => {
          globalThis.__timeoutFired = true;
        }, Math.pow(2, 32));
        "scheduled";
        "#,
    )
    .expect("timer setup");

    for _ in 0..2 {
        assert!(
            vm.run_next_due_timer_callback_for_test(&loader)
                .await
                .expect("timer turn")
        );
    }

    assert_eq!(
        vm.eval("[globalThis.__timeoutFired, globalThis.__intervalFired].join(',')")
            .expect("timer flags"),
        "true,true"
    );
}

#[tokio::test]
async fn page_timer_turn_propagates_host_driver_failure() {
    let mut vm = new_storage_test_vm("https://example.com/");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    vm.fail_next_timeout_for_testing("host timeout driver failed for test");

    let error = match vm.run_next_due_timer_callback_for_test(&loader).await {
        Ok(_) => panic!("host timeout driver failure should propagate"),
        Err(error) => error,
    };
    assert!(
        error
            .to_string()
            .contains("host timeout driver failed for test"),
        "{error:?}"
    );
    let runtime_warnings = vm.runtime_observable_lifecycle_errors_for_testing();
    assert!(
        runtime_warnings.is_empty(),
        "runtime warnings: {runtime_warnings:?}"
    );
}

#[tokio::test]
async fn post_parse_round_injects_lifecycle_boundary_tasks_around_trailing_work() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let mut report = ScriptExecutionReport::default();
    let detached_run = ScriptRun::skipped(
        NodeId::new(99),
        ScriptKind::Classic,
        ScriptMode::Async,
        ScriptSourceKind::External,
        Url::parse("https://example.com/detached.js").unwrap(),
        ScriptSkipReason::NotInMainDocument,
    );

    let _driver = vm
        .start_post_parse_lifecycle_round(
            crate::renderer::PageVmInitStage::Load,
            &mut page_task_queue,
            &mut report,
            vec![post_parse_lifecycle_work(
                PostParseLifecycleWork::RecordDetachedPostParseRuns(vec![detached_run]),
            )],
        )
        .await;

    assert!(
        page_task_queue
            .post_parse_pop_front()
            .is_some_and(|work| work.is_main_document_interactive_task())
    );
    assert!(matches!(
        pop_post_parse_page_task(&mut page_task_queue),
        Some(PageTask::DispatchDomContentLoaded)
    ));
    assert!(matches!(
        pop_post_parse_page_task(&mut page_task_queue),
        Some(PageTask::RecordDetachedPostParseRuns(_))
    ));
    assert!(matches!(
        pop_post_parse_page_task(&mut page_task_queue),
        Some(PageTask::DispatchWindowLoad)
    ));
    assert!(page_task_queue.is_empty());
}

#[test]
fn deferred_page_owned_tasks_preserve_original_lane_when_drained() {
    let mut deferred = DeferredPageTaskState::default();
    deferred.enter_scope();

    assert_eq!(
        deferred.enqueue_or_defer(
            DeferredPageTask::page_owned_work(
                post_parse_document_script_work(
                    crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
                    prepared_post_parse_script(40, ScriptMode::Async),
                ),
                DeferredPageTaskLane::PreDomContentLoaded,
            )
            .expect("pre-DCL page-owned work should be deferrable"),
            |_| unreachable!("deferred task should not enqueue immediately"),
        ),
        FollowupPageTaskDisposition::Deferred
    );
    assert_eq!(
        deferred.enqueue_or_defer(
            DeferredPageTask::page_owned_work(
                post_parse_document_script_work(
                    crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
                    prepared_post_parse_script(41, ScriptMode::Async),
                ),
                DeferredPageTaskLane::PostDomContentLoaded,
            )
            .expect("post-DCL page-owned work should be deferrable"),
            |_| unreachable!("deferred task should not enqueue immediately"),
        ),
        FollowupPageTaskDisposition::Deferred
    );

    deferred.exit_scope();

    let mut drained = Vec::new();
    deferred.drain_into(|task| drained.push(task));

    assert_eq!(drained.len(), 2);
    assert_eq!(drained[0].lane, DeferredPageTaskLane::PreDomContentLoaded);
    assert!(is_document_script_execution_work(
        drained[0].page_owned_work_ref(),
        crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
        40,
    ));
    assert_eq!(drained[1].lane, DeferredPageTaskLane::PostDomContentLoaded);
    assert!(is_document_script_execution_work(
        drained[1].page_owned_work_ref(),
        crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
        41,
    ));
}

#[test]
fn deferred_pre_domcontentloaded_lane_stores_explicit_page_owned_work() {
    let mut vm = new_storage_test_vm("https://example.com/");

    vm.document_runtime.deferred_page_tasks_mut().enter_scope();
    assert_eq!(
        vm.enqueue_page_owned_work_or_defer(
            post_parse_document_script_work(
                crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
                prepared_post_parse_script(42, ScriptMode::Async),
            ),
            DeferredPageTaskLane::PreDomContentLoaded,
        )
        .expect("pre-DCL page task should defer"),
        FollowupPageTaskDisposition::Deferred
    );

    let mut drained = Vec::new();
    vm.document_runtime
        .deferred_page_tasks_mut()
        .drain_into(|deferred| drained.push(deferred));

    assert_eq!(drained.len(), 1);
    assert_eq!(drained[0].lane, DeferredPageTaskLane::PreDomContentLoaded);
    assert!(
        is_document_script_execution_work(
            drained[0].page_owned_work_ref(),
            crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
            42,
        ),
        "pre-DCL deferred tasks should be projected before entering the deferred queue"
    );
}

#[test]
fn deferred_post_domcontentloaded_script_lane_stores_explicit_page_owned_work() {
    let mut vm = new_storage_test_vm("https://example.com/");

    vm.document_runtime.deferred_page_tasks_mut().enter_scope();
    assert_eq!(
        vm.enqueue_page_owned_work_or_defer(
            post_parse_document_script_work(
                crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
                prepared_post_parse_script(43, ScriptMode::Async),
            ),
            DeferredPageTaskLane::PostDomContentLoaded,
        )
        .expect("post-DCL script page task should defer"),
        FollowupPageTaskDisposition::Deferred
    );

    let mut drained = Vec::new();
    vm.document_runtime
        .deferred_page_tasks_mut()
        .drain_into(|deferred| drained.push(deferred));

    assert_eq!(drained.len(), 1);
    assert_eq!(drained[0].lane, DeferredPageTaskLane::PostDomContentLoaded);
    assert!(
        is_document_script_execution_work(
            drained[0].page_owned_work_ref(),
            crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
            43,
        ),
        "post-DCL deferred script tasks should not rely on the page-task sender bridge"
    );
}

#[test]
fn document_open_synchronously_clears_document_owned_runtime_script_work() {
    let mut vm = new_storage_test_vm("https://example.com/");

    vm.document_runtime
        .runtime_script_work_mut()
        .dynamic_scripts
        .requeue_ready_script_front(
            dynamic_script_owner_id(1),
            ready_dynamic_runtime_script(1),
            None,
        );
    vm.document_runtime
        .runtime_script_work_mut()
        .pause_for_deferred_page_tasks(RuntimeScriptWorkPauseKind::StablePageTurnContinuation);

    vm.document_runtime.deferred_page_tasks_mut().enter_scope();
    assert_eq!(
        vm.document_runtime
            .deferred_page_tasks_mut()
            .enqueue_or_defer(
                DeferredPageTask::page_owned_work(
                    post_parse_document_script_work(
                        crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
                        prepared_post_parse_script(44, ScriptMode::Async),
                    ),
                    DeferredPageTaskLane::PostDomContentLoaded,
                )
                .expect("post-DCL work should be deferrable"),
                |_| unreachable!("task should be deferred before document replacement"),
            ),
        FollowupPageTaskDisposition::Deferred
    );
    assert!(
        vm.document_runtime
            .runtime_script_work_mut()
            .has_pending_work()
    );

    vm.document_runtime.open_document();

    assert!(
        !vm.document_runtime
            .runtime_script_work_mut()
            .has_pending_work()
    );
    assert!(
        !vm.document_runtime
            .runtime_script_work_mut()
            .is_paused_for_deferred_page_tasks()
    );
    let mut drained = Vec::new();
    vm.document_runtime
        .deferred_page_tasks_mut()
        .drain_into(|deferred| drained.push(deferred));
    assert!(drained.is_empty());
}

#[tokio::test]
async fn document_replacement_round_restart_does_not_duplicate_live_parser_owned_script() {
    let mut vm = new_storage_test_vm("https://replacement-restart.test/page.html");
    vm.eval(
        r#"
document.open();
document.write(`<!doctype html><script id="replacement-script">globalThis.__replacementRestartRuns = (globalThis.__replacementRestartRuns || 0) + 1;</script>`);
document.close();
"#,
    )
    .expect("document replacement should parse");
    assert_eq!(
        vm.eval("String(globalThis.__replacementRestartRuns)")
            .expect("replacement script count should be readable"),
        "1",
        "the live replacement parser executes an inline classic script synchronously"
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let mut report = ScriptExecutionReport::default();

    assert!(
        vm.restart_post_parse_lifecycle_round_if_invalidated(&mut page_task_queue, &mut report,)
            .await,
        "replacement should restart the post-parse owner round"
    );
    assert!(
        vm.document_runtime
            .pop_parser_owned_pre_domcontentloaded_action()
            .is_none()
    );
    assert_eq!(
        vm.eval("String(globalThis.__replacementRestartRuns)")
            .expect("replacement script count should remain readable"),
        "1",
        "restarting the owner round must not replay a script already consumed by the live parser"
    );
}

#[tokio::test]
async fn completed_load_restarts_replacement_before_runtime_followup_publication() {
    let mut vm = new_storage_test_vm("https://replacement-load-restart.test/page.html");
    vm.eval(
        r#"
document.open();
document.write(`<!doctype html><script id="replacement-script">globalThis.__replacementLoadRestartRuns = (globalThis.__replacementLoadRestartRuns || 0) + 1;</script>`);
document.close();
"#,
    )
    .expect("post-load document replacement should parse");
    assert_eq!(
        vm.eval("String(globalThis.__replacementLoadRestartRuns)")
            .expect("replacement script count should be readable"),
        "1"
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let mut report = ScriptExecutionReport::default();
    let completed_load = PostParsePageOwnedTask {
        work: None,
        completion: PostParseTaskCompletion {
            token: PostParseTaskExecutionToken {
                boundary_completion: Some(PostParseLifecycleCompletionAction::ReturnAtStage(
                    "load",
                )),
                invalidation_policy: PostParseTaskInvalidationPolicy::RestartIfInvalidated,
                requires_runtime_followup_publication: true,
            },
        },
    };

    let advance = vm
        .finish_completed_post_parse_page_owned_task_or_continue(
            &mut page_task_queue,
            &mut report,
            Some(completed_load),
        )
        .await
        .expect("replacement completion should restart the owner round");

    assert!(
        advance.is_none(),
        "the retired document's load boundary must not complete the replacement round"
    );
    assert!(
        vm.document_runtime
            .pop_parser_owned_pre_domcontentloaded_action()
            .is_none()
    );
    assert_eq!(
        vm.eval("String(globalThis.__replacementLoadRestartRuns)")
            .expect("replacement script count should remain readable"),
        "1",
        "a retired load completion must not replay replacement parser work"
    );
}

#[test]
fn followup_lanes_track_script_semantics() {
    assert_eq!(
        crate::host::HostScriptScheduler::followup_lane_for_script(
            ScriptHandleSource::Unknown,
            ScriptMode::Normal
        ),
        DeferredPageTaskLane::PreDomContentLoaded
    );
    assert_eq!(
        crate::host::HostScriptScheduler::followup_lane_for_script(
            ScriptHandleSource::ParserOwned,
            ScriptMode::Normal
        ),
        DeferredPageTaskLane::ParserBoundary
    );
    assert_eq!(
        crate::host::HostScriptScheduler::followup_lane_for_script(
            ScriptHandleSource::DocumentWriteOwned,
            ScriptMode::Normal,
        ),
        DeferredPageTaskLane::PreDomContentLoaded
    );
    assert_eq!(
        crate::host::HostScriptScheduler::followup_lane_for_script(
            ScriptHandleSource::ParserOwned,
            ScriptMode::Defer
        ),
        DeferredPageTaskLane::PreDomContentLoaded
    );
    assert_eq!(
        crate::host::HostScriptScheduler::followup_lane_for_script(
            ScriptHandleSource::Unknown,
            ScriptMode::Defer
        ),
        DeferredPageTaskLane::PreDomContentLoaded
    );
    assert_eq!(
        crate::host::HostScriptScheduler::followup_lane_for_script(
            ScriptHandleSource::DocumentWriteOwned,
            ScriptMode::ModuleDefer,
        ),
        DeferredPageTaskLane::PreDomContentLoaded
    );
    assert_eq!(
        crate::host::HostScriptScheduler::followup_lane_for_script(
            ScriptHandleSource::DocumentWriteOwned,
            ScriptMode::InOrder,
        ),
        DeferredPageTaskLane::PreDomContentLoaded
    );
    assert_eq!(
        crate::host::HostScriptScheduler::followup_lane_for_script(
            ScriptHandleSource::ParserOwned,
            ScriptMode::Async
        ),
        DeferredPageTaskLane::PostDomContentLoaded
    );
    assert_eq!(
        crate::host::HostScriptScheduler::followup_lane_for_script(
            ScriptHandleSource::DocumentWriteOwned,
            ScriptMode::ModuleInOrder,
        ),
        DeferredPageTaskLane::PreDomContentLoaded
    );
    assert_eq!(
        crate::host::HostScriptScheduler::followup_lane_for_script(
            ScriptHandleSource::DocumentWriteOwned,
            ScriptMode::ImportMapInOrder,
        ),
        DeferredPageTaskLane::PreDomContentLoaded
    );
    assert_eq!(
        crate::host::HostScriptScheduler::followup_lane_for_script(
            ScriptHandleSource::RuntimeOwned,
            ScriptMode::Normal
        ),
        DeferredPageTaskLane::PostDomContentLoaded
    );
    assert_eq!(
        crate::host::HostScriptScheduler::followup_lane_for_script(
            ScriptHandleSource::RuntimeOwned,
            ScriptMode::Defer
        ),
        DeferredPageTaskLane::PostDomContentLoaded
    );
    assert_eq!(
        crate::host::HostScriptScheduler::followup_lane_for_script(
            ScriptHandleSource::RuntimeOwned,
            ScriptMode::Async
        ),
        DeferredPageTaskLane::PostDomContentLoaded
    );
}

#[test]
fn storage_set_item_stringifies_null_key() {
    let mut vm = new_storage_test_vm("https://storage-null-key.test/");

    let result = vm
            .eval(
                "(() => { localStorage.clear(); localStorage.setItem(null, 'value'); return `${localStorage.getItem('null')}|${localStorage.length}`; })()",
            )
            .expect("storage script should execute");

    assert_eq!(result, "value|1");
}

#[test]
fn storage_get_item_stringifies_undefined_key() {
    let mut vm = new_storage_test_vm("https://storage-undefined-key.test/");

    let result = vm
            .eval(
                "(() => { localStorage.clear(); localStorage.setItem('undefined', 'value'); return String(localStorage.getItem(undefined)); })()",
            )
            .expect("storage script should execute");

    assert_eq!(result, "value");
}

#[test]
fn storage_remove_item_stringifies_null_key() {
    let mut vm = new_storage_test_vm("https://storage-remove-null-key.test/");

    let result = vm
            .eval(
                "(() => { localStorage.clear(); localStorage.setItem('null', 'value'); localStorage.removeItem(null); return String(localStorage.length); })()",
            )
            .expect("storage script should execute");

    assert_eq!(result, "0");
}

#[test]
fn storage_methods_parse_webidl_arguments() {
    let mut vm = new_storage_test_vm("https://storage-webidl-args.test/");

    let result = vm
        .eval(
            r#"
(() => {
  localStorage.clear();
  function probe(callback) {
    try {
      return callback();
    } catch (error) {
      return 'throw:' + error.name;
    }
  }
  localStorage.setItem(null, undefined);
  return [
    localStorage.getItem('null'),
    localStorage.key(0),
    localStorage.key(-1),
    probe(() => localStorage.getItem(Symbol())),
    probe(() => localStorage.setItem('symbol', Symbol())),
    probe(() => localStorage.removeItem(Symbol())),
    localStorage.length,
    localStorage.getItem('symbol')
  ].join('|');
})()
"#,
        )
        .expect("storage WebIDL argument conversion should execute");

    assert_eq!(
        result,
        "undefined|null||throw:TypeError|throw:TypeError|throw:TypeError|1|"
    );
}

#[test]
fn storage_prototype_methods_are_declared_operations() {
    let mut vm = new_storage_test_vm("https://storage-prototype-methods.test/");

    let result = vm
        .eval(
            r#"
(() => {
  localStorage.clear();
  sessionStorage.clear();
  const names = ["getItem", "setItem", "removeItem", "clear", "key"];
  const descriptors = names.map(name => {
    const descriptor = Object.getOwnPropertyDescriptor(Storage.prototype, name);
    return [
      name,
      typeof descriptor.value,
      descriptor.value.name,
      descriptor.value.length,
      descriptor.enumerable,
      descriptor.writable,
      descriptor.configurable,
      Object.prototype.hasOwnProperty.call(localStorage, name),
      Object.prototype.hasOwnProperty.call(sessionStorage, name)
    ].join(":");
  });
  const lengthDescriptor = Object.getOwnPropertyDescriptor(Storage.prototype, "length");
  const lengthShape = [
    "length",
    typeof lengthDescriptor.get,
    lengthDescriptor.get.name,
    lengthDescriptor.get.length,
    typeof lengthDescriptor.set,
    lengthDescriptor.enumerable,
    lengthDescriptor.configurable,
    Object.prototype.hasOwnProperty.call(localStorage, "length"),
    Object.prototype.hasOwnProperty.call(sessionStorage, "length")
  ].join(":");
  localStorage.setItem("alpha", "one");
  sessionStorage.setItem("beta", "two");
  const behavior = [
    localStorage.getItem("alpha"),
    sessionStorage.getItem("beta"),
    localStorage.key(0),
    sessionStorage.key(0),
    localStorage.removeItem("alpha"),
    String(localStorage.getItem("alpha")),
    sessionStorage.clear(),
    sessionStorage.length
  ].join(":");
  return descriptors.concat(lengthShape).join("|") + "|" + behavior + "|" + Object.keys(Storage.prototype).join(",");
})()
"#,
        )
        .expect("storage prototype method descriptor test should execute");

    assert_eq!(
        result,
        "getItem:function:getItem:1:true:true:true:false:false|setItem:function:setItem:2:true:true:true:false:false|removeItem:function:removeItem:1:true:true:true:false:false|clear:function:clear:0:true:true:true:false:false|key:function:key:1:true:true:true:false:false|length:function:get length:0:undefined:true:true:false:false|one:two:alpha:beta::null::0|getItem,setItem,removeItem,clear,key,length"
    );
}

#[test]
fn storage_window_object_cache_ignores_reflection_and_spoofing() {
    let mut vm = new_storage_test_vm("https://storage-window-cache-private-slots.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const slots = [
    "__moliWindowLocalStorage",
    "__moliWindowSessionStorage"
  ];
  const internalNames = () => Object.getOwnPropertyNames(globalThis)
    .filter(name => slots.includes(name))
    .sort()
    .join(",");
  const beforeAccess = internalNames();
  const firstLocal = localStorage;
  const firstSession = sessionStorage;
  firstLocal.clear();
  firstSession.clear();
  firstLocal.setItem("cache", "local");
  firstSession.setItem("cache", "session");
  const afterAccess = internalNames();
  Object.defineProperty(globalThis, "__moliWindowLocalStorage", {
    value: { spoof: "local" },
    configurable: true,
    writable: true
  });
  Object.defineProperty(globalThis, "__moliWindowSessionStorage", {
    value: { spoof: "session" },
    configurable: true,
    writable: true
  });
  try {
    const afterSpoof = internalNames();
    const secondLocal = localStorage;
    const secondSession = sessionStorage;
    return JSON.stringify({
      beforeAccess,
      afterAccess,
      afterSpoof,
      publicSpoof: [
        globalThis.__moliWindowLocalStorage.spoof,
        globalThis.__moliWindowSessionStorage.spoof
      ].join(","),
      sameObjects: [firstLocal === secondLocal, firstSession === secondSession].join(","),
      values: [secondLocal.getItem("cache"), secondSession.getItem("cache")].join(",")
    });
  } finally {
    delete globalThis.__moliWindowLocalStorage;
    delete globalThis.__moliWindowSessionStorage;
    firstLocal.clear();
    firstSession.clear();
  }
})()
"#,
        )
        .expect("storage window cache private slot test should execute");

    assert_eq!(
        result,
        r#"{"beforeAccess":"","afterAccess":"","afterSpoof":"__moliWindowLocalStorage,__moliWindowSessionStorage","publicSpoof":"local,session","sameObjects":"true,true","values":"local,session"}"#
    );
}

#[test]
fn storage_symbol_interceptor_values_throw_without_mutating_store() {
    let mut vm = new_storage_test_vm("https://storage-symbol-value.test/");

    let result = vm
        .eval(
            r#"
(() => {
  localStorage.clear();
  let setThrew = false;
  let defineThrew = false;
  try {
    localStorage.symbolValue = Symbol("value");
  } catch (error) {
    setThrew = error instanceof TypeError;
  }
  try {
    Object.defineProperty(localStorage, "definedSymbol", { value: Symbol("value") });
  } catch (error) {
    defineThrew = error instanceof TypeError;
  }
  return JSON.stringify({
    setThrew,
    defineThrew,
    length: localStorage.length,
    symbolValue: localStorage.getItem("symbolValue"),
    definedSymbol: localStorage.getItem("definedSymbol")
  });
})()
"#,
        )
        .expect("storage Symbol conversion test should execute");

    assert_eq!(
        result,
        r#"{"setThrew":true,"defineThrew":true,"length":0,"symbolValue":null,"definedSymbol":null}"#
    );
}

#[test]
fn storage_property_access_respects_prototype_shadowing_for_indexed_keys() {
    let mut vm = new_storage_test_vm("https://storage-prototype-index-shadow.test/");

    let result = vm
        .eval(
            r#"
(() => {
  function probeWptShape(name, key) {
    const proto = "proto";
    Storage.prototype[key] = proto;
    try {
      const storage = window[name];
      storage.clear();
      const before = storage[key];
      const assignment = (storage[key] = "next");
      const after = storage[key];
      const item = storage.getItem(String(key));
      const own = Object.getOwnPropertyDescriptor(storage, key);
      return [name, String(key), before, assignment, after, item, String(own === undefined)].join(":");
    } finally {
      delete Storage.prototype[key];
      window[name].clear();
    }
  }
  function probeValue(key, proto) {
    Storage.prototype[key] = proto;
    try {
      return probe(key);
    } finally {
      delete Storage.prototype[key];
      localStorage.clear();
    }
  }
  function probeAccessor(key, descriptor) {
    Object.defineProperty(Storage.prototype, key, {
      ...descriptor,
      configurable: true
    });
    try {
      return probe(key);
    } finally {
      delete Storage.prototype[key];
      localStorage.clear();
    }
  }
  function probe(key) {
    localStorage.clear();
    localStorage.setItem(String(key), "existing");
    const before = localStorage[key];
    const assignment = (localStorage[key] = "next");
    const after = localStorage[key];
    const item = localStorage.getItem(String(key));
    const own = Object.getOwnPropertyDescriptor(localStorage, key);
    return [String(key), before, assignment, after, item, String(own === undefined)].join(":");
  }
  return [
    probeWptShape("localStorage", 9),
    probeWptShape("sessionStorage", 9),
    probeValue(9, "proto-9"),
    probeValue("x", "proto-x"),
    probeAccessor(10, {
      get() { return "getter-10"; },
      set() { throw new Error("prototype setter should not run"); }
    })
  ].join("|");
})()
"#,
        )
        .expect("storage prototype shadowing test should execute");

    assert_eq!(
        result,
        "localStorage:9:proto:next:proto:next:true|sessionStorage:9:proto:next:proto:next:true|9:proto-9:next:proto-9:next:true|x:proto-x:next:proto-x:next:true|10:getter-10:next:getter-10:next:true"
    );
}

#[test]
fn storage_declared_descriptor_objects_preserve_reflection_shape() {
    let mut vm = new_storage_test_vm("https://storage-descriptor-shape.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const cacheSlot = "__moliStoragePrototypeIndexedDescriptors";
  const cacheSlotNames = () => Object.getOwnPropertyNames(globalThis)
    .filter(name => name === cacheSlot)
    .join(",");
  localStorage.clear();
  localStorage.setItem("alpha", "stored");
  const initialGlobalNames = cacheSlotNames();
  const valueDescriptor = Object.getOwnPropertyDescriptor(localStorage, "alpha");
  Object.defineProperty(Storage.prototype, 12, {
    get() { return "getter-12"; },
    set(value) { this.setItem("setter-12", value); },
    enumerable: false,
    configurable: true
  });
  try {
    const afterCacheGlobalNames = cacheSlotNames();
    const accessorDescriptor = Object.getOwnPropertyDescriptor(Storage.prototype, 12);
    Object.defineProperty(globalThis, cacheSlot, {
      value: { 12: { value: "spoofed" } },
      configurable: true,
      writable: true
    });
    const afterSpoofGlobalNames = cacheSlotNames();
    const spoofedDescriptor = Object.getOwnPropertyDescriptor(Storage.prototype, 12);
    return JSON.stringify({
      initialGlobalNames,
      afterCacheGlobalNames,
      afterSpoofGlobalNames,
      valueDescriptorKeys: Object.keys(valueDescriptor),
      value: valueDescriptor.value,
      writable: valueDescriptor.writable,
      enumerable: valueDescriptor.enumerable,
      configurable: valueDescriptor.configurable,
      accessorDescriptorKeys: Object.keys(accessorDescriptor),
      getType: typeof accessorDescriptor.get,
      setType: typeof accessorDescriptor.set,
      accessorEnumerable: accessorDescriptor.enumerable,
      accessorConfigurable: accessorDescriptor.configurable,
      accessorHasValue: Object.prototype.hasOwnProperty.call(accessorDescriptor, "value"),
      accessorHasWritable: Object.prototype.hasOwnProperty.call(accessorDescriptor, "writable"),
      spoofedGetType: typeof spoofedDescriptor.get,
      spoofedSetType: typeof spoofedDescriptor.set,
      spoofedHasValue: Object.prototype.hasOwnProperty.call(spoofedDescriptor, "value")
    });
  } finally {
    delete Storage.prototype[12];
    delete globalThis[cacheSlot];
    localStorage.clear();
  }
})()
"#,
        )
        .expect("storage descriptor reflection test should execute");

    assert_eq!(
        result,
        r#"{"initialGlobalNames":"","afterCacheGlobalNames":"","afterSpoofGlobalNames":"__moliStoragePrototypeIndexedDescriptors","valueDescriptorKeys":["value","writable","enumerable","configurable"],"value":"stored","writable":true,"enumerable":true,"configurable":true,"accessorDescriptorKeys":["get","set","enumerable","configurable"],"getType":"function","setType":"function","accessorEnumerable":false,"accessorConfigurable":true,"accessorHasValue":false,"accessorHasWritable":false,"spoofedGetType":"function","spoofedSetType":"function","spoofedHasValue":false}"#
    );
}

#[test]
fn storage_named_query_respects_prototype_shadowing() {
    let mut vm = new_storage_test_vm("https://storage-named-query-shadow.test/");

    let result = vm
        .eval(
            r#"
(() => {
  function probe(name) {
    const storage = window[name];
    storage.clear();
    storage.setItem("getItem", "stored");
    const descriptor = Object.getOwnPropertyDescriptor(storage, "getItem");
    const hasOwn = Object.prototype.hasOwnProperty.call(storage, "getItem");
    const value = Storage.prototype.getItem.call(storage, "getItem");
    return [
      name,
      typeof storage.getItem,
      value,
      String(descriptor === undefined),
      String(hasOwn)
    ].join(":");
  }
  return [probe("localStorage"), probe("sessionStorage")].join("|");
})()
"#,
        )
        .expect("storage named query shadowing test should execute");

    assert_eq!(
        result,
        "localStorage:function:stored:true:false|sessionStorage:function:stored:true:false"
    );
}

#[test]
fn form_data_symbol_filename_throws_without_mutating_entries() {
    let mut vm = new_storage_test_vm("https://formdata-symbol-filename.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const formData = new FormData();
  let appendThrew = false;
  let setThrew = false;
  try {
    formData.append("file", new Blob(["x"]), Symbol("name"));
  } catch (error) {
    appendThrew = error instanceof TypeError;
  }
  formData.append("keep", "value");
  try {
    formData.set("keep", new Blob(["y"]), Symbol("name"));
  } catch (error) {
    setThrew = error instanceof TypeError;
  }
  return JSON.stringify({
    appendThrew,
    setThrew,
    keys: Array.from(formData.keys()),
    keep: formData.get("keep")
  });
})()
"#,
        )
        .expect("FormData Symbol filename conversion test should execute");

    assert_eq!(
        result,
        r#"{"appendThrew":true,"setThrew":true,"keys":["keep"],"keep":"value"}"#
    );
}

#[test]
fn form_data_constructor_parses_webidl_arguments() {
    let mut vm = new_storage_test_vm("https://formdata-constructor-webidl.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const probe = callback => {
    try {
      const value = callback();
      return value === undefined ? 'undefined' : String(value);
    } catch (error) {
      return `throw:${error && error.name}`;
    }
  };
  const form = document.createElement('form');
  const input = document.createElement('input');
  input.name = 'field';
  input.value = 'value';
  form.appendChild(input);
  const submit = document.createElement('button');
  submit.type = 'submit';
  submit.name = 'go';
  submit.value = 'yes';
  form.appendChild(submit);

  const empty = Array.from(new FormData(undefined)).length;
  const fromForm = Array.from(new FormData(form, null)).join(',');
  const withSubmitter = Array.from(new FormData(form, submit)).join(',');

  return [
    empty,
    fromForm,
    withSubmitter,
    probe(() => new FormData(null)),
    probe(() => new FormData(Symbol('form'))),
    probe(() => new FormData(form, Symbol('submitter')))
  ].join('|');
})()
            "#,
        )
        .expect("FormData constructor WebIDL probe should run");

    assert_eq!(
        result,
        "0|field,value|field,value,go,yes|throw:TypeError|throw:TypeError|throw:TypeError"
    );
}

#[test]
fn form_data_image_submitter_entries_follow_tree_order() {
    let mut vm = new_storage_test_vm("https://formdata-image-submitter-order.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const form = document.createElement('form');
  form.innerHTML =
    '<input name="n1" value="v1">' +
    '<input type="image" name="image">' +
    '<input name="n3" value="v3">';
  const image = form.querySelector('[type="image"]');
  return JSON.stringify({
    listedControls: form.elements.length,
    entries: Array.from(new FormData(form, image)),
  });
})()
            "#,
        )
        .expect("image submitter FormData entries should serialize");

    assert_eq!(
        result,
        r#"{"listedControls":2,"entries":[["n1","v1"],["image.x","0"],["image.y","0"],["n3","v3"]]}"#
    );
}

#[test]
fn form_data_entries_ignore_slot_property_spoofing() {
    let mut vm = new_storage_test_vm("https://formdata-prototype-slot-spoof.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const formData = new FormData();
  formData.append("real", "value");
  const ownSlotsBefore = Object.getOwnPropertyNames(formData)
    .filter(name => name.startsWith("__moliFormData"))
    .sort();
  Object.defineProperty(FormData.prototype, "__moliFormDataEntries", {
    value: [["proto-spoof", "bad"]],
    configurable: true
  });
  Object.defineProperty(formData, "__moliFormDataEntries", {
    value: [["own-spoof", "bad"]],
    configurable: true
  });
  const ownSpoofWasWritten = Object.prototype.hasOwnProperty.call(
    formData,
    "__moliFormDataEntries"
  );
  const beforeDelete = Array.from(formData);
  const deletedOwnSpoof = delete formData.__moliFormDataEntries;
  const afterDelete = Array.from(formData);
  formData.append("second", "value2");
  return JSON.stringify({
    ownSlotsBefore,
    ownSpoofWasWritten,
    beforeDelete,
    deletedOwnSpoof,
    afterDelete,
    afterAppend: Array.from(formData),
    protoSpoof: formData.get("proto-spoof"),
    ownSpoof: formData.get("own-spoof")
  });
})()
            "#,
        )
        .expect("FormData slot spoofing probe should run");

    assert_eq!(
        result,
        r#"{"ownSlotsBefore":[],"ownSpoofWasWritten":true,"beforeDelete":[["real","value"]],"deletedOwnSpoof":true,"afterDelete":[["real","value"]],"afterAppend":[["real","value"],["second","value2"]],"protoSpoof":null,"ownSpoof":null}"#
    );
}

#[test]
fn form_data_reads_parsed_control_state() {
    let mut vm = new_storage_test_vm("https://formdata-parsed-controls.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const form = document.createElement('form');
  form.innerHTML =
    '<input name="foo" value="bara">' +
    '<textarea name="area">bar</textarea>' +
    '<input name="nokeygen" value="barb"><keygen>';
  return Array.from(new FormData(form))
    .map(([name, value]) => `${name}=${value}`)
    .join('&');
})()
            "#,
        )
        .expect("parsed FormData values should serialize");

    assert_eq!(result, "foo=bara&area=bar&nokeygen=barb");
}

#[test]
fn local_storage_reuses_explicit_partition_handles_for_same_origin_pages() {
    let storage = crate::RendererWebStorageHandles::ephemeral();
    let mut first = new_storage_test_vm("https://storage-share.test/a");
    let mut second = new_storage_test_vm("https://storage-share.test/b");
    first.set_web_storage_handles(&storage);
    second.set_web_storage_handles(&storage);

    first
        .eval("localStorage.clear(); localStorage.setItem('k', 'v');")
        .expect("first page should write localStorage");
    let result = second
        .eval("localStorage.getItem('k')")
        .expect("second page should read localStorage");

    assert_eq!(result, "v");
}

#[test]
fn local_storage_does_not_cross_partition_handle_boundaries_for_same_origin_pages() {
    let mut first = new_storage_test_vm("https://storage-isolated.test/a");
    let mut second = new_storage_test_vm("https://storage-isolated.test/b");
    first.set_web_storage_handles(&crate::RendererWebStorageHandles::ephemeral());
    second.set_web_storage_handles(&crate::RendererWebStorageHandles::ephemeral());

    first
        .eval("localStorage.clear(); localStorage.setItem('k', 'v');")
        .expect("first page should write localStorage");
    let result = second
        .eval("String(localStorage.getItem('k'))")
        .expect("second page should read localStorage");

    assert_eq!(result, "null");
}

#[test]
fn session_storage_reuses_explicit_browsing_context_handles_for_same_origin_pages() {
    let storage = crate::RendererWebStorageHandles::ephemeral();
    let mut first = new_storage_test_vm("https://session-share.test/a");
    let mut second = new_storage_test_vm("https://session-share.test/b");
    first.set_web_storage_handles(&storage);
    second.set_web_storage_handles(&storage);

    first
        .eval("sessionStorage.clear(); sessionStorage.setItem('k', 'v');")
        .expect("first page should write sessionStorage");
    let result = second
        .eval("sessionStorage.getItem('k')")
        .expect("second page should read sessionStorage");

    assert_eq!(result, "v");
}

#[test]
fn session_storage_does_not_cross_browsing_context_handle_boundaries() {
    let mut first = new_storage_test_vm("https://session-isolated.test/a");
    let mut second = new_storage_test_vm("https://session-isolated.test/b");
    first.set_web_storage_handles(&crate::RendererWebStorageHandles::ephemeral());
    second.set_web_storage_handles(&crate::RendererWebStorageHandles::ephemeral());

    first
        .eval("sessionStorage.clear(); sessionStorage.setItem('k', 'v');")
        .expect("first page should write sessionStorage");
    let result = second
        .eval("String(sessionStorage.getItem('k'))")
        .expect("second page should read sessionStorage");

    assert_eq!(result, "null");
}

#[tokio::test]
async fn poll_next_post_parse_driver_step_requests_wait_when_owner_progress_is_pending_but_not_ready()
 {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
            Url::parse("https://example.com/").unwrap(),
            "<!doctype html><html><head><link rel=stylesheet href='/app.css'></head><body></body></html>"
                .to_owned(),
        );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let snapshot = vm.document_runtime.snapshot_document();
    let head = snapshot.document_head_handle().expect("head handle");
    let link = snapshot
        .child_nodes(head)
        .expect("head children")
        .into_iter()
        .find(|handle| {
            snapshot
                .node(*handle)
                .and_then(Node::as_element)
                .is_some_and(|element| element.is_html_element("link"))
        })
        .expect("stylesheet link");
    vm.document_runtime
        .enqueue_pending_connected_style_load_for_test(link);
    vm.document_runtime.note_dom_content_loaded_dispatched();
    page_task_queue.extend_post_parse_work([post_parse_lifecycle_work(
        PostParseLifecycleWork::test_window_load(),
    )]);

    let step = vm.poll_next_post_parse_driver_step(&mut page_task_queue);

    assert!(matches!(step, PostParseDriverStep::AwaitProgress));
}

#[tokio::test]
async fn poll_next_post_parse_driver_step_prefers_owner_action_over_runtime_continuation() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
            Url::parse("https://example.com/").unwrap(),
            "<!doctype html><html><head><link rel=stylesheet href='/app.css'></head><body></body></html>"
                .to_owned(),
        );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let snapshot = vm.document_runtime.snapshot_document();
    let head = snapshot.document_head_handle().expect("head handle");
    let link = snapshot
        .child_nodes(head)
        .expect("head children")
        .into_iter()
        .find(|handle| {
            snapshot
                .node(*handle)
                .and_then(Node::as_element)
                .is_some_and(|element| element.is_html_element("link"))
        })
        .expect("stylesheet link");
    vm.document_runtime
        .enqueue_ready_connected_style_load_for_test(link);
    vm.document_runtime.note_dom_content_loaded_dispatched();
    vm.enqueue_test_pending_runtime_source_load();
    vm.arm_runtime_script_work_continuation_if_needed();

    let step = vm.poll_next_post_parse_driver_step(&mut page_task_queue);

    assert!(matches!(
        step,
        PostParseDriverStep::Ready(action)
            if matches!(
                action.as_ref(),
                ReadyPostParseAction::Processing(processing)
                    if matches!(
                        processing.as_ref(),
                        PostParseProcessingAction {
                            work,
                            ..
                        } if matches!(
                            work.as_lifecycle_work(),
                            Some(crate::page_task_queue::PostParseLifecycleWork::DispatchConnectedStyleLoad(ready))
                                if ready.owner() == link
                        )
                    )
            )
    ));
}

#[tokio::test]
async fn poll_next_post_parse_driver_step_requests_wait_for_runtime_backlog_without_owner_progress()
{
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let mut loading_async_script = ready_dynamic_runtime_script(9);
    loading_async_script.source_kind = ScriptSourceKind::External;
    loading_async_script.source = crate::planning::ScriptSource::External;
    vm.document_runtime.note_dom_content_loaded_dispatched();
    vm.document_runtime
        .runtime_script_work_mut()
        .dynamic_scripts
        .enqueue_loading_script_for_test(loading_async_script);
    vm.arm_runtime_script_work_continuation_if_needed();

    let step = vm.poll_next_post_parse_driver_step(&mut page_task_queue);

    assert!(matches!(step, PostParseDriverStep::AwaitProgress));
}

#[tokio::test]
async fn pre_domcontentloaded_runtime_source_wait_yields_to_stable_page_continuation() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_test_vm_with_loader("https://example.com/", &loader);
    let script_node = vm.document_runtime.dom_host_mut().create_element("script");
    let mut script = vm.test_pending_runtime_source_load_script();
    script.node_id = script_node;
    script.mode = ScriptMode::InOrder;
    vm.bind_prepared_script_handle_if_needed(&mut script, ScriptHandleSource::DocumentWriteOwned);
    let handle = script
        .host_script_handle
        .as_deref()
        .expect("external document.write script must have an exact host handle");
    assert_eq!(
        vm.document_runtime.script_handle_followup_lane(handle),
        Some(DeferredPageTaskLane::PreDomContentLoaded)
    );
    vm.document_runtime
        .runtime_script_work_mut()
        .dynamic_scripts
        .enqueue_loading_script_for_test(script);

    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let mut report = ScriptExecutionReport::default();
    let step = tokio::time::timeout(
        std::time::Duration::from_secs(1),
        vm.next_post_parse_processing_step(&loader, &mut page_task_queue, &mut report),
    )
    .await
    .expect("post-parse runtime source wait must not retain the executor")
    .expect("post-parse runtime source wait should remain valid");

    assert!(matches!(
        step,
        crate::script_vm::PostParseProcessingStep::AwaitProgress
    ));
    assert_eq!(
        vm.document_runtime.runtime_script_work_mut().pause_kind(),
        Some(RuntimeScriptWorkPauseKind::StablePageTurnContinuation),
        "the unresolved producer must retain an exact stable continuation route"
    );
    assert!(
        vm._page_task_residence_for_executor_test
            .as_ref()
            .expect("standalone fixture must retain its production Page source")
            .task_sources()
            .take_main_document_runtime_for_executor_test()
            .is_none(),
        "waiting for a source must not manufacture a runnable continuation"
    );
}

#[test]
fn post_parse_lifecycle_driver_targets_page_vm_stage_boundaries() {
    assert_eq!(
        PostParseLifecycleDriver::target_boundary_for_stage(
            crate::renderer::PageVmInitStage::DomContentLoaded,
        ),
        PostParseStageBoundary::DomContentLoaded
    );
    assert_eq!(
        PostParseLifecycleDriver::target_boundary_for_stage(crate::renderer::PageVmInitStage::Load,),
        PostParseStageBoundary::WindowLoad
    );
}

#[test]
fn post_parse_task_execution_captures_only_the_requested_lifecycle_boundary() {
    let dcl_execution =
        test_post_parse_lifecycle_driver_for(crate::renderer::PageVmInitStage::DomContentLoaded)
            .task_execution_for_action(post_parse_lifecycle_action(
                PostParseLifecycleWork::test_domcontentloaded(),
            ));
    assert!(matches!(
        dcl_execution.token.boundary_completion,
        Some(PostParseLifecycleCompletionAction::ReturnAtStage(
            "DOMContentLoaded"
        ))
    ));

    let dcl_while_waiting_for_load =
        test_post_parse_lifecycle_driver_for(crate::renderer::PageVmInitStage::Load)
            .task_execution_for_action(post_parse_lifecycle_action(
                PostParseLifecycleWork::test_domcontentloaded(),
            ));
    assert!(
        dcl_while_waiting_for_load
            .token
            .boundary_completion
            .is_none()
    );

    let load_execution =
        test_post_parse_lifecycle_driver_for(crate::renderer::PageVmInitStage::Load)
            .task_execution_for_action(post_parse_lifecycle_action(
                PostParseLifecycleWork::test_window_load(),
            ));
    assert!(matches!(
        load_execution.token.boundary_completion,
        Some(PostParseLifecycleCompletionAction::ReturnAtStage("Load"))
    ));
}

#[test]
fn post_parse_lifecycle_driver_marks_only_host_event_tasks_for_runtime_followup_publication() {
    let driver = test_post_parse_lifecycle_driver_for(crate::renderer::PageVmInitStage::Load);

    let lifecycle_execution = driver.task_execution_for_action(post_parse_lifecycle_action(
        PostParseLifecycleWork::test_window_load(),
    ));
    assert!(
        lifecycle_execution
            .token
            .requires_runtime_followup_publication,
        "lifecycle event tasks must publish runtime-produced follow-up work"
    );

    let script_execution = driver.task_execution_for_action(post_parse_document_script_action(
        crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
        prepared_post_parse_script(15, ScriptMode::Async),
    ));
    assert!(
        !script_execution.token.requires_runtime_followup_publication,
        "script-carrying page tasks already run through the script execution path"
    );
}

#[test]
fn post_parse_lifecycle_driver_task_execution_preserves_explicit_invalidation_policy() {
    let driver = test_post_parse_lifecycle_driver_for(crate::renderer::PageVmInitStage::Load);

    let connected_style_execution =
        driver.task_execution_for_action(PostParseProcessingAction::without_invalidation_restart(
            crate::page_task_queue::PostParseLifecycleWork::DispatchConnectedStyleLoad(
                crate::document_runtime::ReadyConnectedStyleLoad::for_owner(
                    DomHandle::new(7),
                    true,
                    crate::document_runtime::ConnectedStyleEventElementKind::Link,
                ),
            ),
        ));
    assert!(matches!(
        connected_style_execution.token.invalidation_policy,
        PostParseTaskInvalidationPolicy::KeepCurrentTask
    ));

    let lifecycle_execution = driver.task_execution_for_action(post_parse_lifecycle_action(
        PostParseLifecycleWork::test_window_load(),
    ));
    assert!(matches!(
        lifecycle_execution.token.invalidation_policy,
        PostParseTaskInvalidationPolicy::RestartIfInvalidated
    ));
}

#[test]
fn post_parse_selector_keeps_window_load_ahead_of_generic_runtime_backlog() {
    let selected = select_post_parse_driver_step(
        post_parse_owner_step_for_lifecycle_work(PostParseLifecycleWork::test_window_load()),
        PostParseRuntimeDriverStep::PendingBacklog,
    );

    assert!(matches!(
        selected,
        PostParseDriverStep::Ready(action) if matches!(
            action.as_ref(),
            ReadyPostParseAction::Processing(action) if action.work.is_window_load_task()
        )
    ));
}

#[test]
fn post_parse_lifecycle_driver_idle_completion_preserves_round_stats() {
    let driver = PostParseLifecycleDriver {
        round: PostParseLifecycleRound {
            queue_stats: PostParseLifecycleQueueStats {
                defer_count: 2,
                async_count: 3,
                detached_count: 4,
            },
            phase_started: Instant::now(),
        },
        target_boundary: PostParseStageBoundary::WindowLoad,
    };

    let PostParseLifecycleCompletionAction::Finalize(finalization) =
        driver.idle_completion_action()
    else {
        panic!("idle driver completion should finalize the post-parse round");
    };

    assert_eq!(finalization.defer_count(), 2);
    assert_eq!(finalization.async_count(), 3);
    assert_eq!(finalization.detached_count(), 4);
}

#[tokio::test]
async fn next_post_parse_lifecycle_advance_from_driver_returns_complete_when_driver_is_idle() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut report = ScriptExecutionReport::default();
    let driver = PostParseLifecycleDriver {
        round: PostParseLifecycleRound {
            queue_stats: PostParseLifecycleQueueStats::default(),
            phase_started: Instant::now(),
        },
        target_boundary: PostParseStageBoundary::WindowLoad,
    };

    let advance = vm
        .next_post_parse_lifecycle_advance_from_driver(
            &loader,
            &mut page_task_queue,
            &mut report,
            driver,
        )
        .await
        .expect("driver helper should succeed");

    assert!(matches!(
        advance,
        PostParseLifecycleAdvance::Complete(PostParseLifecycleCompletionAction::Finalize(_))
    ));
}

#[tokio::test]
async fn next_post_parse_lifecycle_advance_from_driver_returns_page_owned_task_for_ready_processing_action()
 {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut report = ScriptExecutionReport::default();
    let driver = PostParseLifecycleDriver {
        round: PostParseLifecycleRound {
            queue_stats: PostParseLifecycleQueueStats::default(),
            phase_started: Instant::now(),
        },
        target_boundary: PostParseStageBoundary::WindowLoad,
    };

    vm.document_runtime.note_dom_content_loaded_dispatched();
    page_task_queue.extend_post_parse_work([post_parse_document_script_work(
        crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
        prepared_post_parse_script(11, ScriptMode::Async),
    )]);

    let advance = vm
        .next_post_parse_lifecycle_advance_from_driver(
            &loader,
            &mut page_task_queue,
            &mut report,
            driver,
        )
        .await
        .expect("driver helper should succeed");

    let PostParseLifecycleAdvance::PageOwnedTask(mut task) = advance else {
        panic!("ready processing action should become a page-owned task");
    };
    assert!(is_document_script_execution_work(
        &task.take_work_for_execution(),
        crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
        11,
    ));
}

#[tokio::test]
async fn finish_completed_post_parse_page_owned_task_or_continue_returns_boundary_completion() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let mut report = ScriptExecutionReport::default();
    let completed_task = PostParsePageOwnedTask {
        work: None,
        completion: PostParseTaskCompletion {
            token: PostParseTaskExecutionToken {
                boundary_completion: Some(PostParseLifecycleCompletionAction::ReturnAtStage(
                    "DOMContentLoaded",
                )),
                invalidation_policy: PostParseTaskInvalidationPolicy::KeepCurrentTask,
                requires_runtime_followup_publication: false,
            },
        },
    };

    let advance = vm
        .finish_completed_post_parse_page_owned_task_or_continue(
            &mut page_task_queue,
            &mut report,
            Some(completed_task),
        )
        .await
        .expect("completion helper should succeed");

    assert!(matches!(
        advance,
        Some(PostParseLifecycleAdvance::Complete(
            PostParseLifecycleCompletionAction::ReturnAtStage("DOMContentLoaded")
        ))
    ));
}

#[tokio::test]
async fn advance_post_parse_lifecycle_returns_completion_from_completed_boundary_task() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut report = ScriptExecutionReport::default();
    let driver = PostParseLifecycleDriver {
        round: PostParseLifecycleRound {
            queue_stats: PostParseLifecycleQueueStats::default(),
            phase_started: Instant::now(),
        },
        target_boundary: PostParseStageBoundary::DomContentLoaded,
    };
    let completed_task = PostParsePageOwnedTask {
        work: None,
        completion: PostParseTaskCompletion {
            token: PostParseTaskExecutionToken {
                boundary_completion: Some(PostParseLifecycleCompletionAction::ReturnAtStage(
                    "DOMContentLoaded",
                )),
                invalidation_policy: PostParseTaskInvalidationPolicy::KeepCurrentTask,
                requires_runtime_followup_publication: false,
            },
        },
    };

    let advance = vm
        .advance_post_parse_lifecycle(
            &loader,
            &mut page_task_queue,
            &mut report,
            driver,
            Some(completed_task),
        )
        .await
        .expect("driver should succeed");

    assert!(matches!(
        advance,
        PostParseLifecycleAdvance::Complete(PostParseLifecycleCompletionAction::ReturnAtStage(
            "DOMContentLoaded"
        ))
    ));
}

#[tokio::test]
async fn advance_post_parse_lifecycle_continues_to_driver_after_non_boundary_completion() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut report = ScriptExecutionReport::default();
    let driver = PostParseLifecycleDriver {
        round: PostParseLifecycleRound {
            queue_stats: PostParseLifecycleQueueStats::default(),
            phase_started: Instant::now(),
        },
        target_boundary: PostParseStageBoundary::WindowLoad,
    };
    let completed_task = PostParsePageOwnedTask {
        work: None,
        completion: PostParseTaskCompletion {
            token: PostParseTaskExecutionToken {
                boundary_completion: None,
                invalidation_policy: PostParseTaskInvalidationPolicy::KeepCurrentTask,
                requires_runtime_followup_publication: false,
            },
        },
    };

    vm.document_runtime.note_dom_content_loaded_dispatched();
    page_task_queue.extend_post_parse_work([post_parse_document_script_work(
        crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
        prepared_post_parse_script(13, ScriptMode::Async),
    )]);

    let advance = vm
        .advance_post_parse_lifecycle(
            &loader,
            &mut page_task_queue,
            &mut report,
            driver,
            Some(completed_task),
        )
        .await
        .expect("driver should succeed");

    let PostParseLifecycleAdvance::PageOwnedTask(mut task) = advance else {
        panic!("non-boundary completion should fall through to the driver");
    };
    assert!(is_document_script_execution_work(
        &task.take_work_for_execution(),
        crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
        13,
    ));
}

#[tokio::test]
async fn advance_post_parse_lifecycle_restarts_invalidated_round_after_completed_task_before_returning_task()
 {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut report = ScriptExecutionReport::default();
    let driver = PostParseLifecycleDriver {
        round: PostParseLifecycleRound {
            queue_stats: PostParseLifecycleQueueStats::default(),
            phase_started: Instant::now(),
        },
        target_boundary: PostParseStageBoundary::WindowLoad,
    };
    let completed_task = PostParsePageOwnedTask {
        work: None,
        completion: PostParseTaskCompletion {
            token: PostParseTaskExecutionToken {
                boundary_completion: None,
                invalidation_policy: PostParseTaskInvalidationPolicy::RestartIfInvalidated,
                requires_runtime_followup_publication: false,
            },
        },
    };

    vm.document_runtime.open_document();

    let advance = vm
        .advance_post_parse_lifecycle(
            &loader,
            &mut page_task_queue,
            &mut report,
            driver,
            Some(completed_task),
        )
        .await
        .expect("driver should succeed");

    let PostParseLifecycleAdvance::PageOwnedTask(mut task) = advance else {
        panic!("restarted round should continue with rebuilt document lifecycle work");
    };
    assert!(
        task.take_work_for_execution()
            .is_main_document_interactive_task(),
        "a restarted round must begin with the replacement interactive transition"
    );
}

#[tokio::test]
async fn advance_post_parse_lifecycle_restarts_invalidated_round_before_boundary_completion() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut report = ScriptExecutionReport::default();
    let driver =
        test_post_parse_lifecycle_driver_for(crate::renderer::PageVmInitStage::DomContentLoaded);
    let completed_task = PostParsePageOwnedTask {
        work: None,
        completion: PostParseTaskCompletion {
            token: PostParseTaskExecutionToken {
                boundary_completion: Some(PostParseLifecycleCompletionAction::ReturnAtStage(
                    "DOMContentLoaded",
                )),
                invalidation_policy: PostParseTaskInvalidationPolicy::RestartIfInvalidated,
                requires_runtime_followup_publication: false,
            },
        },
    };

    vm.document_runtime.open_document();

    let advance = vm
        .advance_post_parse_lifecycle(
            &loader,
            &mut page_task_queue,
            &mut report,
            driver,
            Some(completed_task),
        )
        .await
        .expect("driver should succeed");

    let PostParseLifecycleAdvance::PageOwnedTask(mut task) = advance else {
        panic!("invalidated round must restart before returning boundary completion");
    };
    assert!(
        task.take_work_for_execution()
            .is_main_document_interactive_task(),
        "invalidation must restart at the replacement interactive transition before the old boundary"
    );
}

#[tokio::test]
async fn prepare_post_parse_task_execution_keeps_non_restartable_task_after_invalidation() {
    let mut vm = new_storage_test_vm("https://example.com/");
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let mut report = ScriptExecutionReport::default();
    let execution = test_post_parse_lifecycle_driver_for(crate::renderer::PageVmInitStage::Load)
        .task_execution_for_action(PostParseProcessingAction::without_invalidation_restart(
            crate::page_task_queue::PostParseLifecycleWork::DispatchConnectedStyleLoad(
                crate::document_runtime::ReadyConnectedStyleLoad::for_owner(
                    DomHandle::new(7),
                    true,
                    crate::document_runtime::ConnectedStyleEventElementKind::Link,
                ),
            ),
        ));

    vm.document_runtime.open_document();

    let restarted = vm
        .prepare_post_parse_task_execution(&mut page_task_queue, &mut report, execution.token)
        .await;

    assert!(
        !restarted,
        "non-restartable connected style load tasks must survive a stale schedule"
    );
    assert!(
        vm.document_runtime.take_post_parse_schedule_invalidated(),
        "keeping the current task must not consume the pending schedule invalidation"
    );
}

#[tokio::test]
async fn prepare_post_parse_task_execution_restarts_restartable_task_after_invalidation() {
    let mut vm = new_storage_test_vm("https://example.com/");
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let mut report = ScriptExecutionReport::default();
    let execution =
        test_post_parse_lifecycle_driver_for(crate::renderer::PageVmInitStage::DomContentLoaded)
            .task_execution_for_action(post_parse_lifecycle_action(
                PostParseLifecycleWork::test_domcontentloaded(),
            ));

    vm.document_runtime.open_document();

    let restarted = vm
        .prepare_post_parse_task_execution(&mut page_task_queue, &mut report, execution.token)
        .await;

    assert!(
        restarted,
        "restartable lifecycle tasks must yield to a freshly invalidated post-parse round"
    );
    assert!(
        !vm.document_runtime.take_post_parse_schedule_invalidated(),
        "restarting must consume the pending schedule invalidation"
    );
    assert!(
        page_task_queue
            .post_parse_front()
            .is_some_and(PostParsePageOwnedWork::is_main_document_interactive_task),
        "restartable lifecycle work must rebuild from the replacement interactive transition"
    );
}

#[test]
fn poll_next_post_parse_driver_step_returns_idle_without_owner_or_runtime_work() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let step = vm.poll_next_post_parse_driver_step(&mut page_task_queue);

    assert!(matches!(step, PostParseDriverStep::Idle));
}

#[test]
fn runtime_script_work_pause_tracks_internal_pause_kind() {
    let mut work = RuntimeScriptWorkState::default();
    work.dynamic_scripts.requeue_ready_script_front(
        dynamic_script_owner_id(1),
        ready_dynamic_runtime_script(1),
        None,
    );

    work.pause_for_deferred_page_tasks(RuntimeScriptWorkPauseKind::StablePageTurnContinuation);

    assert!(work.is_paused_for_deferred_page_tasks());
    assert_eq!(
        work.pause_kind(),
        Some(RuntimeScriptWorkPauseKind::StablePageTurnContinuation)
    );

    work.resume_after_deferred_page_tasks();

    assert!(!work.is_paused_for_deferred_page_tasks());
    assert_eq!(work.pause_kind(), None);
}

#[test]
fn selected_post_parse_action_settlement_publishes_concrete_runtime_followup() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");

    vm.document_runtime
        .runtime_script_work_mut()
        .dynamic_scripts
        .requeue_ready_script_front(
            dynamic_script_owner_id(1),
            ready_dynamic_runtime_script(1),
            None,
        );
    vm.publish_post_parse_action_followups(&mut page_task_queue);

    assert_eq!(
        take_main_document_runtime_action(&page_task_queue).map(|action| action.kind()),
        Some(PageMainDocumentRuntimeActionKind::RuntimeScriptContinuation),
        "runnable runtime progress must publish a concrete production task"
    );
}

#[test]
fn selected_post_parse_action_settlement_arms_stable_continuation_state() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    vm.document_runtime.note_dom_content_loaded_dispatched();
    vm.document_runtime
        .runtime_script_work_mut()
        .dynamic_scripts
        .requeue_ready_script_front(
            dynamic_script_owner_id(1),
            ready_dynamic_runtime_script(1),
            None,
        );

    vm.publish_post_parse_action_followups(&mut page_task_queue);

    assert!(
        vm.document_runtime
            .runtime_script_work_mut()
            .is_paused_for_deferred_page_tasks(),
        "runtime work should be re-armed on the stable continuation state"
    );
    assert_eq!(
        vm.document_runtime.runtime_script_work_mut().pause_kind(),
        Some(RuntimeScriptWorkPauseKind::StablePageTurnContinuation)
    );
    assert_eq!(
        take_main_document_runtime_action(&page_task_queue).map(|action| action.kind()),
        Some(PageMainDocumentRuntimeActionKind::RuntimeScriptContinuation),
        "settlement must admit the ready continuation to the production source"
    );
}

#[test]
fn runtime_owned_module_source_ready_before_domcontentloaded_publishes_task_without_starting_graph_inline()
 {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let body = vm
        .document_runtime
        .snapshot_document()
        .document_body_handle()
        .expect("body should exist");
    let script_node = vm.document_runtime.dom_host_mut().create_element("script");
    assert!(
        vm.document_runtime
            .dom_host_mut()
            .append_child(body, script_node),
        "runtime-owned module script node should attach"
    );
    vm.document_runtime
        .bind_runtime_owned_script_handle_for_node(script_node, "runtime-module-7");
    vm.document_runtime
        .runtime_script_work_mut()
        .dynamic_scripts
        .requeue_ready_script_front(
            dynamic_script_owner_id(7),
            ready_dynamic_runtime_module_script(7, script_node),
            None,
        );
    vm.publish_post_parse_action_followups(&mut page_task_queue);

    assert_eq!(
        take_main_document_runtime_action(&page_task_queue).map(|action| action.kind()),
        Some(PageMainDocumentRuntimeActionKind::RuntimeScriptContinuation),
        "source-ready runtime module must publish one concrete scheduler task before DOMContentLoaded"
    );
    assert!(
        !vm.has_pending_runtime_owned_module_script_graph(),
        "admission must not start the module graph outside its selected Page turn"
    );
    assert!(
        vm.document_runtime
            .runtime_script_work_mut()
            .dynamic_scripts
            .next_runnable_script()
            .is_some(),
        "the selected runtime continuation owns consumption of the runnable module"
    );
}

#[test]
fn explicitly_domcontentloaded_gated_runtime_head_is_not_admitted_early() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let body = vm
        .document_runtime
        .snapshot_document()
        .document_body_handle()
        .expect("body should exist");
    let script_node = vm.document_runtime.dom_host_mut().create_element("script");
    assert!(
        vm.document_runtime
            .dom_host_mut()
            .append_child(body, script_node),
        "gated script node should attach"
    );
    let handle = vm
        .document_runtime
        .bind_runtime_owned_script_handle_for_node(script_node, "explicitly-dcl-gated-script");
    vm.document_runtime
        .set_script_handle_waits_until_dom_content_loaded(&handle);
    let mut script = ready_dynamic_runtime_script(9);
    script.node_id = script_node;
    script.host_script_handle = Some(handle);
    vm.document_runtime
        .runtime_script_work_mut()
        .dynamic_scripts
        .requeue_ready_script_front(dynamic_script_owner_id(9), script, None);

    vm.publish_post_parse_action_followups(&mut page_task_queue);

    assert!(
        take_main_document_runtime_action(&page_task_queue).is_none(),
        "an explicitly gated head must remain durable without becoming runnable before DCL"
    );
    assert!(
        vm.document_runtime
            .runtime_script_work_mut()
            .dynamic_scripts
            .has_immediately_runnable_work(),
        "the denied head must remain in its authoritative owner"
    );

    vm.document_runtime.note_dom_content_loaded_dispatched();
    vm.publish_post_parse_action_followups(&mut page_task_queue);

    assert_eq!(
        take_main_document_runtime_action(&page_task_queue).map(|action| action.kind()),
        Some(PageMainDocumentRuntimeActionKind::RuntimeScriptContinuation),
        "the same durable head must become admitted once its DCL gate opens"
    );
}

#[tokio::test]
async fn reentrant_runtime_admission_survives_page_task_claim_in_stable_authority() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let body = vm
        .document_runtime
        .snapshot_document()
        .document_body_handle()
        .expect("body should exist");
    let script_node = vm.document_runtime.dom_host_mut().create_element("script");
    assert!(
        vm.document_runtime
            .dom_host_mut()
            .append_child(body, script_node),
        "runtime-owned classic script node should attach"
    );
    vm.document_runtime
        .bind_runtime_owned_script_handle_for_node(script_node, "runtime-classic-8");
    let mut script = ready_dynamic_runtime_script(8);
    script.node_id = script_node;
    script.host_script_handle = Some("runtime-classic-8".to_owned());
    script.source_kind = ScriptSourceKind::Inline;
    script.source = ScriptSource::Inline("globalThis.runtimeClassicRan = true;".to_owned());
    let owner = vm
        .current_main_document_task_owner()
        .expect("main document owner");
    let lease = vm
        ._context_host
        .borrow_mut()
        .acquire_current_main_document_script_load_delay(
            owner,
            crate::frame_owner_model::MainDocumentScriptLoadDelayKind::Classic,
        )
        .expect("runtime classic script should acquire an exact load-delay lease");
    let document_loader = vm
        .current_main_document_resource_loader()
        .expect("standalone VM should retain its Document resource authority");
    let loader = document_loader.request_client().clone();
    let task_runner = document_loader.task_runner();
    vm.admit_main_document_runtime_script_task(
        &loader,
        task_runner.clone(),
        crate::host::RuntimeScriptAdmission::new(
            crate::host::RuntimeScriptAdmissionPayload::Script(script),
            lease,
        ),
    );
    let second_script_node = vm.document_runtime.dom_host_mut().create_element("script");
    assert!(
        vm.document_runtime
            .dom_host_mut()
            .append_child(body, second_script_node)
    );
    let second_handle = vm
        .document_runtime
        .bind_runtime_owned_script_handle_for_node(second_script_node, "runtime-classic-9");
    let mut second_script = ready_dynamic_runtime_script(9);
    second_script.node_id = second_script_node;
    second_script.host_script_handle = Some(second_handle);
    second_script.source_kind = ScriptSourceKind::Inline;
    second_script.source =
        ScriptSource::Inline("globalThis.runtimeClassicSecondRan = true;".to_owned());
    let second_lease = vm
        ._context_host
        .borrow_mut()
        .acquire_current_main_document_script_load_delay(
            owner,
            crate::frame_owner_model::MainDocumentScriptLoadDelayKind::Classic,
        )
        .expect("second runtime classic script should acquire its own exact lease");
    let mut reentrant_admission = Some(crate::host::RuntimeScriptAdmission::new(
        crate::host::RuntimeScriptAdmissionPayload::Script(second_script),
        second_lease,
    ));
    vm.document_runtime.note_dom_content_loaded_dispatched();
    let runtime_script_work = vm.document_runtime.runtime_script_work_handle();

    let request_origin = vm
        .current_main_document_resource_loader()
        .unwrap()
        .fetch_context()
        .request_origin();
    let mut emitted = Vec::new();
    assert!(
        vm.emit_ready_runtime_page_owned_work(|work| {
            runtime_script_work
                .borrow_mut()
                .dynamic_scripts
                .enqueue_admission(
                    &loader,
                    request_origin.clone(),
                    task_runner.clone(),
                    reentrant_admission
                        .take()
                        .expect("enqueue callback should admit the second script once"),
                    None,
                    None,
                );
            emitted.push(work);
        })
        .is_some()
    );

    assert_eq!(emitted.len(), 1);
    let Some(PostParsePageOwnedWork::DocumentScript(work)) = emitted.pop() else {
        panic!("runtime classic script should become concrete page-owned work");
    };
    let crate::document_script_scheduler::PageOwnedDocumentScriptWork::Script {
        lane: crate::document_script_scheduler::DocumentScriptExecutionLane::AsyncPhase,
        script,
        runtime_script_claim: Some(claim),
        source_network_result: None,
        load_delay_binding: None,
    } = *work
    else {
        panic!("runtime classic page task should carry its exact terminal claim");
    };
    assert_eq!(script.position, 8);
    assert_eq!(claim.owner(), owner);
    let first_script_owner_id = claim.id();

    assert_eq!(
        vm._context_host
            .borrow()
            .current_main_document_has_async_script_load_delay(owner),
        Some(true),
        "claiming page work must leave the task-owned lease active"
    );
    let _ = vm.finish_claimed_runtime_owned_script_success_body(claim, &script);
    assert!(
        runtime_script_work
            .borrow_mut()
            .dynamic_scripts
            .finish_script_terminal(first_script_owner_id)
            .is_none(),
        "a claimed terminal cannot settle the same script through the owner a second time"
    );
    assert_eq!(
        vm._context_host
            .borrow()
            .current_main_document_has_async_script_load_delay(owner),
        Some(true),
        "settling one task-owned lease must not release the reentrant script's lease"
    );
    assert!(
        !runtime_script_work.borrow_mut().dynamic_scripts.is_idle(),
        "the reentrant script must remain in the same stable runtime authority"
    );

    let mut emitted = Vec::new();
    assert!(
        vm.emit_ready_runtime_page_owned_work(|work| {
            emitted.push(work);
        })
        .is_some()
    );
    let Some(PostParsePageOwnedWork::DocumentScript(work)) = emitted.pop() else {
        panic!("second runtime classic script should become concrete page-owned work");
    };
    let crate::document_script_scheduler::PageOwnedDocumentScriptWork::Script {
        script,
        runtime_script_claim: Some(claim),
        ..
    } = *work
    else {
        panic!("second runtime classic page task should carry its exact terminal claim");
    };
    vm.cancel_claimed_runtime_owned_script_load_delay_body(claim, &script);
    assert_eq!(
        vm._context_host
            .borrow()
            .current_main_document_has_async_script_load_delay(owner),
        Some(false),
        "the last task-owned lease must settle without looking it up in runtime authority"
    );
    assert!(
        runtime_script_work.borrow_mut().dynamic_scripts.is_idle(),
        "both claimed scripts should leave the stable runtime authority idle"
    );
}

#[test]
fn script_terminal_event_body_defers_listener_reaction_to_task_completion() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let body = vm
        .document_runtime
        .snapshot_document()
        .document_body_handle()
        .expect("body should exist");
    let script_node = vm.document_runtime.dom_host_mut().create_element("script");
    assert!(
        vm.document_runtime
            .dom_host_mut()
            .append_child(body, script_node)
    );
    assert!(vm.document_runtime.dom_host_mut().set_attribute(
        script_node,
        "id",
        "runtime-terminal-script"
    ));
    assert!(vm.document_runtime.dom_host_mut().set_attribute(
        script_node,
        "src",
        "/runtime-terminal.js"
    ));
    let handle = vm
        .document_runtime
        .bind_runtime_owned_script_handle_for_node(script_node, "runtime-binding-9");
    vm.eval(
        r#"
        globalThis.__runtimeTerminalOrder = [];
        document.getElementById("runtime-terminal-script").onload = () => {
          __runtimeTerminalOrder.push("load");
          queueMicrotask(() => __runtimeTerminalOrder.push("load-microtask"));
        };
        "installed";
        "#,
    )
    .expect("runtime terminal listener should install");

    vm.dispatch_script_event_body_best_effort(&crate::host::ScriptEventTask::new(
        crate::host::ScriptEventKind::Load,
        handle,
    ));
    assert_eq!(
        vm.eval_without_microtask_checkpoint_for_test("__runtimeTerminalOrder.join('|')")
            .expect("terminal body order should be readable without a checkpoint"),
        "load",
        "the terminal body must not perform the enclosing task-end checkpoint"
    );
    vm.perform_script_task_checkpoint(None)
        .expect("selected task completion checkpoint should run");
    assert_eq!(
        vm.eval_without_microtask_checkpoint_for_test("__runtimeTerminalOrder.join('|')")
            .expect("terminal completion order should be readable"),
        "load|load-microtask"
    );
    assert!(
        take_main_document_runtime_action(&page_task_queue).is_none(),
        "a terminal event body must not manufacture a second task"
    );
}

#[test]
fn runtime_dynamic_script_terminal_consumes_its_accepted_document_lease_inline() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let body = vm
        .document_runtime
        .snapshot_document()
        .document_body_handle()
        .expect("body should exist");
    let script_node = vm.document_runtime.dom_host_mut().create_element("script");
    assert!(
        vm.document_runtime
            .dom_host_mut()
            .append_child(body, script_node)
    );
    let handle = vm
        .document_runtime
        .bind_runtime_owned_script_handle_for_node(script_node, "runtime-binding-9");
    let mut script = ready_dynamic_runtime_script(9);
    script.node_id = script_node;
    script.host_script_handle = Some(handle);
    script.kind = ScriptKind::Module;
    script.source_kind = ScriptSourceKind::Inline;
    script.source = ScriptSource::Inline("globalThis.__dynamicBindingRan = true;".to_owned());

    let owner = vm
        .current_main_document_task_owner()
        .expect("main document owner");
    let document_loader = vm
        .current_main_document_resource_loader()
        .expect("standalone VM should retain its Document resource authority");
    let loader = document_loader.request_client().clone();
    let task_runner = document_loader.task_runner();
    let lease = vm
        ._context_host
        .borrow_mut()
        .acquire_current_main_document_script_load_delay(
            owner,
            crate::frame_owner_model::MainDocumentScriptLoadDelayKind::Module,
        )
        .expect("dynamic script should acquire the current main Document lease");
    vm.document_runtime.note_dom_content_loaded_dispatched();
    vm.admit_main_document_runtime_script_task(
        &loader,
        task_runner,
        crate::host::RuntimeScriptAdmission::new(
            crate::host::RuntimeScriptAdmissionPayload::Script(script),
            lease,
        ),
    );
    assert_eq!(
        vm._context_host
            .borrow()
            .current_main_document_has_async_script_load_delay(owner),
        Some(true),
        "admission must retain lifecycle ownership before execution"
    );

    let DynamicScriptRunnable::Execute { id, script, .. } = vm
        .document_runtime
        .runtime_script_work_mut()
        .dynamic_scripts
        .next_runnable_script()
        .expect("inline dynamic script should be ready")
    else {
        panic!("expected dynamic script execution work");
    };
    let lease = vm
        .document_runtime
        .runtime_script_work_mut()
        .dynamic_scripts
        .finish_script_terminal(id)
        .expect("selected terminal must retain its acceptance-time lease");
    vm.apply_runtime_script_success_terminal(&script, lease);
    assert_eq!(
        vm._context_host
            .borrow()
            .current_main_document_has_async_script_load_delay(owner),
        Some(false),
        "the selected terminal must release its exact Document lease"
    );
    assert!(
        vm.document_runtime
            .runtime_script_work_mut()
            .dynamic_scripts
            .finish_script_terminal(id)
            .is_none(),
        "the same terminal cannot consume its lease twice"
    );
    while let Some(action) = take_main_document_runtime_action(&page_task_queue) {
        if let RendererPageMainDocumentRuntimeAction::ExecuteReadyPostParseWork(work) = action {
            assert!(
                !matches!(
                    work.into_post_parse_work(),
                    PostParsePageOwnedWork::Lifecycle(work)
                        if matches!(
                            work.as_ref(),
                            PostParseLifecycleWork::SettleMainDocumentScriptLoadDelay(_)
                        )
                ),
                "runtime terminal settlement must not create a second hidden lifecycle task"
            );
        }
    }
}

#[test]
fn runtime_owned_inline_importmap_bypasses_dcl_gate() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let body = vm
        .document_runtime
        .snapshot_document()
        .document_body_handle()
        .expect("body should exist");
    let script_node = vm.document_runtime.dom_host_mut().create_element("script");
    assert!(
        vm.document_runtime
            .dom_host_mut()
            .append_child(body, script_node),
        "runtime-owned import map script node should attach"
    );
    let handle = vm
        .document_runtime
        .bind_runtime_owned_script_handle_for_node(script_node, "runtime-importmap-1");
    vm.document_runtime
        .set_script_handle_waits_until_dom_content_loaded(&handle);

    let script = PreparedScript {
        position: 1,
        node_id: script_node,
        kind: ScriptKind::ImportMap,
        mode: ScriptMode::ImportMapInOrder,
        source_kind: ScriptSourceKind::Inline,
        fetch_metadata: crate::planning::ScriptFetchMetadata::default(),
        source: ScriptSource::Inline("{\"imports\":{}}".to_owned()),
        url: Url::parse("https://example.com/").unwrap(),
        base_url: Url::parse("https://example.com/").unwrap(),
        initiator_url: Url::parse("https://example.com/").unwrap(),
        host_script_handle: Some(handle),
    };

    assert!(
        dynamic_script_execute_is_runnable_before_dom_content_loaded(&vm.document_runtime, &script),
        "dynamic inline import maps must register in the current flush"
    );
    assert!(
        !vm.prepared_script_uses_runtime_owned_page_task_execution(&script),
        "dynamic inline import maps should not wait for the runtime-owned page-task lane"
    );
}

#[test]
fn followup_task_boundary_preserves_pending_dynamic_source_residence() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    vm.enqueue_test_pending_runtime_source_load();

    assert!(vm.pause_runtime_script_work_at_followup_task_boundary(
        FollowupPageTaskDisposition::Enqueued
    ));
    assert_eq!(
        vm.document_runtime
            .runtime_script_work()
            .dynamic_scripts
            .pending_source_load_count_for_test(),
        1,
        "the explicit boundary must not manufacture or consume a source terminal"
    );
    assert!(
        vm.document_runtime
            .runtime_script_work_mut()
            .is_paused_for_deferred_page_tasks(),
        "the pending producer must retain a stable continuation residence"
    );
}

#[tokio::test]
async fn queued_pre_domcontentloaded_runtime_tasks_are_backfilled_ahead_of_domcontentloaded() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let mut report = ScriptExecutionReport::default();

    let _driver = vm
        .start_post_parse_lifecycle_round(
            crate::renderer::PageVmInitStage::Load,
            &mut page_task_queue,
            &mut report,
            vec![],
        )
        .await;
    vm.document_runtime
        .enqueue_parser_owned_pre_domcontentloaded_page_owned_work(post_parse_lifecycle_work(
            PostParseLifecycleWork::RecordDetachedPostParseRuns(Vec::new()),
        ));

    assert!(matches!(
        vm.document_runtime
            .poll_next_post_parse_owner_driver_step(&mut page_task_queue, false),
        PostParseOwnerDriverStep::Ready(action)
            if matches!(
                action.as_ref(),
                DocumentProcessingAction::PostParsePageOwnedWork(work)
                    if matches!(
                        work.as_page_task(),
                        Some(PageTask::RecordDetachedPostParseRuns(_))
                    )
            )
    ));
    assert!(
        page_task_queue
            .post_parse_pop_front()
            .is_some_and(|work| work.is_main_document_interactive_task())
    );
    assert!(matches!(
        pop_post_parse_page_task(&mut page_task_queue),
        Some(PageTask::DispatchDomContentLoaded)
    ));
}

#[test]
fn selected_post_parse_action_keeps_pending_dynamic_source_out_of_pre_dcl_lane_after_dcl() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    vm.document_runtime.note_dom_content_loaded_dispatched();
    vm.enqueue_test_pending_runtime_source_load();

    vm.publish_post_parse_action_followups(&mut page_task_queue);

    assert!(
        !vm.document_runtime
            .has_parser_owned_pre_domcontentloaded_page_tasks(),
        "a pending dynamic source load must never manufacture parser-owned work"
    );
    assert!(
        vm.document_runtime
            .runtime_script_work_mut()
            .is_paused_for_deferred_page_tasks(),
        "the pending dynamic producer should stay on its runtime continuation state"
    );
    assert_eq!(
        vm.document_runtime.runtime_script_work_mut().pause_kind(),
        Some(RuntimeScriptWorkPauseKind::StablePageTurnContinuation)
    );
    assert!(
        take_main_document_runtime_action(&page_task_queue).is_none(),
        "an unresolved source must not manufacture a runnable continuation before its producer completes"
    );
}

#[test]
fn post_parse_owner_readiness_does_not_block_window_load_for_generic_post_dcl_pause_state() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head></head><body></body></html>".to_owned(),
    );
    let mut page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    vm.document_runtime.note_dom_content_loaded_dispatched();
    vm.enqueue_test_pending_runtime_source_load();
    vm.arm_runtime_script_work_continuation_if_needed();
    page_task_queue.extend_post_parse_work([post_parse_lifecycle_work(
        PostParseLifecycleWork::test_window_load(),
    )]);

    let has_post_domcontentloaded_runtime_backlog =
        vm.has_post_domcontentloaded_runtime_backlog(&mut page_task_queue);
    assert!(has_post_domcontentloaded_runtime_backlog);
    let readiness = vm
        .document_runtime
        .post_parse_owner_readiness(&mut page_task_queue, false);

    assert!(!readiness.blocks_page_task_pop);
    assert!(!readiness.has_pending_progress_source);
}

#[test]
fn document_write_owned_inline_normal_defers_already_started_until_execution_without_handle() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
        Url::parse("https://example.com/").unwrap(),
        "<!doctype html><html><head><script>window.test = 1;</script></head><body></body></html>"
            .to_owned(),
    );
    let script = document
        .script_handles()
        .first()
        .copied()
        .expect("inline script handle");
    let page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document.clone()),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");
    let mut prepared = PreparedScript {
        position: 0,
        node_id: NodeId::new(script.index()),
        kind: ScriptKind::Classic,
        mode: ScriptMode::Normal,
        source_kind: ScriptSourceKind::Inline,
        fetch_metadata: crate::planning::ScriptFetchMetadata::default(),
        source: ScriptSource::Inline("window.test = 1;".to_owned()),
        url: Url::parse("https://example.com/inline.js").unwrap(),
        base_url: Url::parse("https://example.com/inline.js").unwrap(),
        initiator_url: Url::parse("https://example.com/").unwrap(),
        host_script_handle: None,
    };

    assert!(
        !vm.document_runtime
            .snapshot_document()
            .node(script)
            .and_then(|node| node.as_element())
            .is_some_and(|element| element.script_already_started())
    );

    vm.bind_prepared_script_handle_if_needed(&mut prepared, ScriptHandleSource::DocumentWriteOwned);

    assert!(
        prepared.host_script_handle.is_none(),
        "inline classic normal still executes without a document-write host handle"
    );
    assert!(
        !vm.document_runtime
            .snapshot_document()
            .node(script)
            .and_then(|node| node.as_element())
            .is_some_and(|element| element.script_already_started()),
        "document.write-owned inline classic normal scripts are marked already-started when execution begins, not when planned"
    );
}

#[test]
fn script_inner_text_exposes_inline_json_payload() {
    let _js_runtime = crate::JsRuntime::initialize();
    let document = HtmlParser::SCRIPTING_ENABLED.parse(
            Url::parse("https://example.com/").unwrap(),
            "<!doctype html><html><body><script id=\"RENDER_DATA\" type=\"application/json\">%7B%22data%22%3A1%7D</script></body></html>"
                .to_owned(),
        );
    let page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
    let post_domcontentloaded_page_task_sender =
        page_task_queue.owner_attached_runtime_page_task_sender_for_test();
    let script_event_parser_boundary_sender = page_task_queue.parser_boundary_sender();
    let mut vm = ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
        DomHost::from_dom(document),
        post_domcontentloaded_page_task_sender,
        script_event_parser_boundary_sender,
    )
    .expect("script vm bootstrap")
    .finish()
    .expect("script vm finish");

    let inner_text = vm
        .eval("document.getElementById('RENDER_DATA').innerText")
        .expect("script innerText should be readable");

    assert_eq!(inner_text, "%7B%22data%22%3A1%7D");
}

#[test]
fn indexed_db_globals_are_present() {
    let mut vm = new_storage_test_vm("https://indexeddb-globals.test/");

    let result = vm
            .eval(
                "(() => { const ev = new IDBVersionChangeEvent('upgradeneeded', { oldVersion: 1, newVersion: 2 }); return [typeof indexedDB, typeof indexedDB.open, typeof IDBIndex, typeof IDBCursor, typeof IDBCursorWithValue, typeof IDBKeyRange, typeof IDBVersionChangeEvent, `${ev.oldVersion}/${ev.newVersion}`].join('|'); })()",
            )
            .expect("indexeddb globals should exist");

    assert_eq!(
        result,
        "object|function|function|function|function|function|function|1/2"
    );
}

#[test]
fn indexed_db_declared_methods_have_webidl_operation_descriptors() {
    let mut vm = new_storage_test_vm("https://indexeddb-descriptors.test/");

    let result = vm
        .eval(
            r#"
            (() => {
              const methods = [
                [IDBFactory.prototype, "open", 1],
                [IDBFactory.prototype, "deleteDatabase", 1],
                [IDBFactory.prototype, "databases", 0],
                [IDBFactory.prototype, "cmp", 2],
                [IDBFactory.prototype, "databases", 0],
                [IDBDatabase.prototype, "createObjectStore", 2],
                [IDBDatabase.prototype, "deleteObjectStore", 1],
                [IDBDatabase.prototype, "transaction", 2],
                [IDBDatabase.prototype, "close", 0],
                [IDBDatabase.prototype, "addEventListener", 2],
                [IDBDatabase.prototype, "removeEventListener", 2],
                [IDBDatabase.prototype, "dispatchEvent", 1],
                [IDBTransaction.prototype, "objectStore", 1],
                [IDBTransaction.prototype, "abort", 0],
                [IDBTransaction.prototype, "commit", 0],
                [IDBTransaction.prototype, "addEventListener", 2],
                [IDBTransaction.prototype, "removeEventListener", 2],
                [IDBTransaction.prototype, "dispatchEvent", 1],
                [IDBRequest.prototype, "addEventListener", 2],
                [IDBRequest.prototype, "removeEventListener", 2],
                [IDBRequest.prototype, "dispatchEvent", 1],
                [IDBObjectStore.prototype, "get", 1],
                [IDBObjectStore.prototype, "getAll", 2],
                [IDBObjectStore.prototype, "getKey", 1],
                [IDBObjectStore.prototype, "getAllKeys", 2],
                [IDBObjectStore.prototype, "count", 1],
                [IDBObjectStore.prototype, "put", 2],
                [IDBObjectStore.prototype, "add", 2],
                [IDBObjectStore.prototype, "delete", 1],
                [IDBObjectStore.prototype, "clear", 0],
                [IDBObjectStore.prototype, "createIndex", 3],
                [IDBObjectStore.prototype, "index", 1],
                [IDBObjectStore.prototype, "deleteIndex", 1],
                [IDBObjectStore.prototype, "openCursor", 2],
                [IDBObjectStore.prototype, "openKeyCursor", 2],
                [IDBIndex.prototype, "get", 1],
                [IDBIndex.prototype, "getKey", 1],
                [IDBIndex.prototype, "getAll", 2],
                [IDBIndex.prototype, "getAllKeys", 2],
                [IDBIndex.prototype, "count", 1],
                [IDBIndex.prototype, "openCursor", 2],
                [IDBIndex.prototype, "openKeyCursor", 2],
                [IDBCursor.prototype, "advance", 1],
                [IDBCursor.prototype, "continue", 1],
                [IDBCursor.prototype, "continuePrimaryKey", 2],
                [IDBCursor.prototype, "update", 1],
                [IDBCursor.prototype, "delete", 0],
                [IDBKeyRange.prototype, "includes", 1],
                [IDBKeyRange, "only", 1],
                [IDBKeyRange, "bound", 2],
                [IDBKeyRange, "lowerBound", 1],
                [IDBKeyRange, "upperBound", 1],
              ];
              for (const [target, name, length] of methods) {
                const inherited = ["addEventListener", "removeEventListener", "dispatchEvent"].includes(name);
                if (inherited && (Object.hasOwn(target, name) || target[name] !== EventTarget.prototype[name]))
                    throw new Error(`${name} should be inherited from EventTarget`);
                const descriptor = Object.getOwnPropertyDescriptor(inherited ? EventTarget.prototype : target, name);
                if (!descriptor || typeof descriptor.value !== "function") {
                  throw new Error(`${name} should be a declared function`);
                }
                if (descriptor.value.length !== length ||
                    descriptor.value.name !== name ||
                    descriptor.writable !== true ||
                    descriptor.enumerable !== true ||
                    descriptor.configurable !== true) {
                  throw new Error(`${name} descriptor should match Web IDL operation shape`);
                }
              }
              return "ok";
            })()
            "#,
        )
        .expect("indexeddb declared method descriptors should evaluate");

    assert_eq!(result, "ok");
}