Skip to content

armgit / moli

Public Imported from GitHub
0

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

205 KB
Raw Blame
use super::*;

mod specifiers;
use crate::worker::handle::WorkerParentErrorEventKind;
use crate::worker::{WorkerErrorPhase, WorkerScriptResourceKind};
use moli_crypto::sha256_hex;

mod response_mime;
mod source_phase;

const WORKER_WASM_IMPORT_PM: &[u8] = &[
    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x02, 0x60, 0x01, 0x7f, 0x00, 0x60,
    0x00, 0x00, 0x02, 0x19, 0x01, 0x12, 0x2e, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x2d, 0x68,
    0x65, 0x6c, 0x70, 0x65, 0x72, 0x2e, 0x6a, 0x73, 0x02, 0x70, 0x6d, 0x00, 0x00, 0x03, 0x02, 0x01,
    0x01, 0x08, 0x01, 0x01, 0x0a, 0x08, 0x01, 0x06, 0x00, 0x41, 0x2a, 0x10, 0x00, 0x0b,
];

const WORKER_WASM_EXPORTED_NAMES: &[u8] = &[
    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x04, 0x01, 0x60, 0x00, 0x00, 0x03, 0x02,
    0x01, 0x00, 0x04, 0x04, 0x01, 0x6f, 0x00, 0x0a, 0x05, 0x04, 0x01, 0x01, 0x00, 0x0a, 0x06, 0x06,
    0x01, 0x7f, 0x00, 0x41, 0x00, 0x0b, 0x07, 0x1b, 0x04, 0x04, 0x67, 0x6c, 0x6f, 0x62, 0x03, 0x00,
    0x03, 0x6d, 0x65, 0x6d, 0x02, 0x00, 0x03, 0x74, 0x61, 0x62, 0x01, 0x00, 0x04, 0x66, 0x75, 0x6e,
    0x63, 0x00, 0x00, 0x0a, 0x04, 0x01, 0x02, 0x00, 0x0b,
];

const WORKER_MUTABLE_GLOBAL_WASM: &[u8] = &[
    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x04, 0x01, 0x60, 0x00, 0x00, 0x03, 0x02,
    0x01, 0x00, 0x04, 0x04, 0x01, 0x6f, 0x00, 0x0a, 0x05, 0x04, 0x01, 0x01, 0x00, 0x0a, 0x06, 0x06,
    0x01, 0x7f, 0x01, 0x41, 0x00, 0x0b, 0x07, 0x1b, 0x04, 0x04, 0x67, 0x6c, 0x6f, 0x62, 0x03, 0x00,
    0x03, 0x6d, 0x65, 0x6d, 0x02, 0x00, 0x03, 0x74, 0x61, 0x62, 0x01, 0x00, 0x04, 0x66, 0x75, 0x6e,
    0x63, 0x00, 0x00, 0x0a, 0x04, 0x01, 0x02, 0x00, 0x0b,
];

const WORKER_MUTABLE_GLOBAL_LIVE_WASM: &[u8] = &[
    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x09, 0x02, 0x60, 0x01, 0x7f, 0x00, 0x60,
    0x00, 0x01, 0x7f, 0x03, 0x03, 0x02, 0x00, 0x01, 0x06, 0x06, 0x01, 0x7f, 0x01, 0x41, 0x2a, 0x0b,
    0x07, 0x28, 0x03, 0x0c, 0x6d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
    0x03, 0x00, 0x09, 0x73, 0x65, 0x74, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x00, 0x00, 0x09, 0x67,
    0x65, 0x74, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x00, 0x01, 0x0a, 0x0d, 0x02, 0x06, 0x00, 0x20,
    0x00, 0x24, 0x00, 0x0b, 0x04, 0x00, 0x23, 0x00, 0x0b,
];

const WORKER_MUTABLE_GLOBAL_REEXPORT_WASM: &[u8] = &[
    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x09, 0x02, 0x60, 0x01, 0x7f, 0x00, 0x60,
    0x00, 0x01, 0x7f, 0x02, 0x2e, 0x01, 0x1c, 0x2e, 0x2f, 0x6d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65,
    0x2d, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x2d, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77,
    0x61, 0x73, 0x6d, 0x0c, 0x6d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
    0x03, 0x7f, 0x01, 0x03, 0x03, 0x02, 0x00, 0x01, 0x07, 0x42, 0x03, 0x16, 0x72, 0x65, 0x65, 0x78,
    0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x4d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c,
    0x75, 0x65, 0x03, 0x00, 0x11, 0x73, 0x65, 0x74, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64,
    0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x00, 0x00, 0x11, 0x67, 0x65, 0x74, 0x49, 0x6d, 0x70, 0x6f,
    0x72, 0x74, 0x65, 0x64, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x00, 0x01, 0x0a, 0x0d, 0x02, 0x06,
    0x00, 0x20, 0x00, 0x24, 0x00, 0x0b, 0x04, 0x00, 0x23, 0x00, 0x0b,
];

const WORKER_INVALID_MODULE_WASM: &[u8] = &[
    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x05, 0x01, 0x60, 0x00, 0x01, 0x7f, 0x03,
    0x02, 0x01, 0x00, 0x0a, 0x06, 0x01, 0x04, 0x00, 0x42, 0x00, 0x0b,
];

const WORKER_WASM_IMPORT_CYCLE_JS: &[u8] = &[
    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x04, 0x01, 0x60, 0x00, 0x00, 0x02, 0x10,
    0x01, 0x0a, 0x2e, 0x2f, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x2e, 0x6a, 0x73, 0x01, 0x66, 0x00, 0x00,
    0x03, 0x02, 0x01, 0x00, 0x07, 0x07, 0x01, 0x03, 0x72, 0x75, 0x6e, 0x00, 0x01, 0x0a, 0x06, 0x01,
    0x04, 0x00, 0x10, 0x00, 0x0b,
];

fn worker_wasm_import_pm_body() -> String {
    String::from_utf8(WORKER_WASM_IMPORT_PM.to_vec()).expect("test wasm should be ASCII bytes")
}

fn worker_wasm_exported_names_body() -> String {
    String::from_utf8(WORKER_WASM_EXPORTED_NAMES.to_vec()).expect("test wasm should be ASCII bytes")
}

fn worker_mutable_global_wasm_body() -> String {
    String::from_utf8(WORKER_MUTABLE_GLOBAL_WASM.to_vec()).expect("test wasm should be ASCII bytes")
}

fn worker_mutable_global_live_wasm_body() -> String {
    String::from_utf8(WORKER_MUTABLE_GLOBAL_LIVE_WASM.to_vec())
        .expect("test wasm should be ASCII bytes")
}

fn worker_mutable_global_reexport_wasm_body() -> String {
    String::from_utf8(WORKER_MUTABLE_GLOBAL_REEXPORT_WASM.to_vec())
        .expect("test wasm should be ASCII bytes")
}

fn worker_invalid_module_wasm_body() -> String {
    String::from_utf8(WORKER_INVALID_MODULE_WASM.to_vec()).expect("test wasm should be ASCII bytes")
}

fn worker_wasm_import_cycle_js_body() -> String {
    String::from_utf8(WORKER_WASM_IMPORT_CYCLE_JS.to_vec())
        .expect("test wasm should be ASCII bytes")
}

#[tokio::test]
async fn worker_importscripts_symbol_throws_type_error() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        try {
            importScripts(Symbol("worker.js"));
            postMessage("unexpected");
        } catch (error) {
            postMessage(error.name);
        }
        "#
        .into(),
        "test://importscripts_symbol".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#""TypeError""#);
}

#[tokio::test]
async fn worker_importscripts_invalid_url_throws_syntax_error_before_running_any_script() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        try {
            importScripts(
                "data:text/javascript,globalThis.__ran=true",
                "http://foo bar"
            );
            postMessage("unexpected");
        } catch (error) {
            postMessage({
                name: error && error.name,
                ran: globalThis.__ran === true,
            });
        }
        close();
        "#
        .into(),
        "http://127.0.0.1/worker/main.js".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"name":"SyntaxError","ran":false}"#
    );
}

#[tokio::test]
async fn worker_importscripts_obeys_response_csp_script_src() {
    ensure_v8();
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            const events = [];
            addEventListener("securitypolicyviolation", event => {
                events.push({
                    type: event.type,
                    effectiveDirective: event.effectiveDirective,
                    violatedDirective: event.violatedDirective,
                    blockedURI: event.blockedURI,
                    documentURI: event.documentURI,
                    originalPolicy: event.originalPolicy,
                    disposition: event.disposition,
                    instance: event instanceof SecurityPolicyViolationEvent
                });
            });
            try {
                importScripts("data:text/javascript,globalThis.__ran=true");
                postMessage("unexpected");
            } catch (error) {
                postMessage({
                    events,
                    name: error && error.name,
                    ran: globalThis.__ran === true,
                });
            }
            close();
            "#
            .into(),
            "https://app.test/worker/main.js".into(),
        )
        .with_content_security_policies(vec!["script-src 'none'".into()]),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"events":[{"type":"securitypolicyviolation","effectiveDirective":"script-src","violatedDirective":"script-src","blockedURI":"data","documentURI":"https://app.test/worker/main.js","originalPolicy":"script-src 'none'","disposition":"enforce","instance":true}],"name":"NetworkError","ran":false}"#
    );
}

#[tokio::test]
async fn worker_csp_violation_event_survives_mutated_event_globals() {
    ensure_v8();
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            const getBlockedURI = Object.getOwnPropertyDescriptor(SecurityPolicyViolationEvent.prototype, "blockedURI").get;
            self.Event = null;
            Object.defineProperty(SecurityPolicyViolationEvent.prototype, "blockedURI", {
                value: "prototype-blocked-uri",
                writable: false,
                configurable: true
            });
            const events = [];
            addEventListener("securitypolicyviolation", event => {
                events.push({
                    type: event.type,
                    blockedURI: getBlockedURI.call(event),
                    publicBlockedURI: event.blockedURI,
                    bubbles: event.bubbles,
                    cancelable: event.cancelable,
                    composed: event.composed,
                    effectiveDirective: event.effectiveDirective,
                    disposition: event.disposition,
                    instance: event instanceof SecurityPolicyViolationEvent
                });
            });
            try {
                importScripts("data:text/javascript,globalThis.__ran=true");
                postMessage("unexpected");
            } catch (error) {
                postMessage({
                    events,
                    name: error && error.name,
                    ran: globalThis.__ran === true,
                });
            }
            close();
            "#
            .into(),
            "https://app.test/worker/main.js".into(),
        )
        .with_content_security_policies(vec!["script-src 'none'".into()]),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"events":[{"type":"securitypolicyviolation","blockedURI":"data","publicBlockedURI":"prototype-blocked-uri","bubbles":true,"cancelable":false,"composed":true,"effectiveDirective":"script-src","disposition":"enforce","instance":true}],"name":"NetworkError","ran":false}"#
    );
}

#[tokio::test]
async fn shared_worker_importscripts_csp_block_dispatches_securitypolicyviolation_event() {
    ensure_v8();
    let storage_key = moli_storage_key::MoliStorageKey::new(
        "https://app.test".to_owned(),
        "https://app.test".to_owned(),
        None,
        moli_storage_key::StoragePartitionRelation::FirstParty,
    );
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            onconnect = () => {
                let matched = false;
                addEventListener("securitypolicyviolation", event => {
                    matched = event.type === "securitypolicyviolation" &&
                        event.effectiveDirective === "script-src" &&
                        event.violatedDirective === "script-src" &&
                        event.blockedURI === "data" &&
                        event.documentURI === "https://app.test/shared-worker.js" &&
                        event.originalPolicy === "script-src 'none'" &&
                        event.disposition === "enforce" &&
                        event instanceof SecurityPolicyViolationEvent;
                });
                try {
                    importScripts("data:text/javascript,globalThis.__ran=true");
                } catch (_) {
                    if (matched && globalThis.__ran !== true) {
                        close();
                    }
                }
            };
            "#
            .into(),
            "https://app.test/shared-worker.js".into(),
        )
        .with_global_kind(super::super::WorkerGlobalKind::Shared {
            name: "shared".to_owned(),
            storage_key,
        })
        .with_content_security_policies(vec!["script-src 'none'".into()]),
    );

    handle
        .tx
        .send(crate::worker::WorkerMessage::SharedWorkerConnect(0))
        .expect("connect shared worker");
    loop {
        let msg = timeout(TIMEOUT, handle.recv())
            .await
            .expect("timed out")
            .expect("channel closed");
        if matches!(msg, WorkerToParentMessage::SharedWorkerClosed) {
            break;
        }
    }
}

#[tokio::test]
async fn worker_importscripts_report_only_csp_dispatches_without_blocking() {
    ensure_v8();
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            const events = [];
            addEventListener("securitypolicyviolation", event => {
                events.push({
                    type: event.type,
                    effectiveDirective: event.effectiveDirective,
                    violatedDirective: event.violatedDirective,
                    blockedURI: event.blockedURI,
                    documentURI: event.documentURI,
                    originalPolicy: event.originalPolicy,
                    disposition: event.disposition,
                    instance: event instanceof SecurityPolicyViolationEvent
                });
            });
            importScripts("data:text/javascript,globalThis.__ran=true");
            postMessage({
                events,
                ran: globalThis.__ran === true,
            });
            close();
            "#
            .into(),
            "https://app.test/worker/main.js".into(),
        )
        .with_content_security_report_only_policies(vec!["script-src 'none'".into()]),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"events":[{"type":"securitypolicyviolation","effectiveDirective":"script-src","violatedDirective":"script-src","blockedURI":"data","documentURI":"https://app.test/worker/main.js","originalPolicy":"script-src 'none'","disposition":"report","instance":true}],"ran":true}"#
    );
}

#[tokio::test]
async fn shared_worker_importscripts_report_only_csp_dispatches_without_blocking() {
    ensure_v8();
    let storage_key = moli_storage_key::MoliStorageKey::new(
        "https://app.test".to_owned(),
        "https://app.test".to_owned(),
        None,
        moli_storage_key::StoragePartitionRelation::FirstParty,
    );
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            onconnect = () => {
                let matched = false;
                addEventListener("securitypolicyviolation", event => {
                    matched = event.type === "securitypolicyviolation" &&
                        event.effectiveDirective === "script-src" &&
                        event.violatedDirective === "script-src" &&
                        event.blockedURI === "data" &&
                        event.documentURI === "https://app.test/shared-worker.js" &&
                        event.originalPolicy === "script-src 'none'" &&
                        event.disposition === "report" &&
                        event instanceof SecurityPolicyViolationEvent;
                });
                importScripts("data:text/javascript,globalThis.__ran=true");
                if (matched && globalThis.__ran === true) {
                    close();
                }
            };
            "#
            .into(),
            "https://app.test/shared-worker.js".into(),
        )
        .with_global_kind(super::super::WorkerGlobalKind::Shared {
            name: "shared".to_owned(),
            storage_key,
        })
        .with_content_security_report_only_policies(vec!["script-src 'none'".into()]),
    );

    handle
        .tx
        .send(crate::worker::WorkerMessage::SharedWorkerConnect(0))
        .expect("connect shared worker");
    loop {
        let msg = timeout(TIMEOUT, handle.recv())
            .await
            .expect("timed out")
            .expect("channel closed");
        if matches!(msg, WorkerToParentMessage::SharedWorkerClosed) {
            break;
        }
    }
}

#[tokio::test]
async fn worker_importscripts_syntax_error_preserves_prior_side_effects_and_stops_later_scripts() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        try {
            importScripts(
                "data:text/javascript,globalThis.__first='ok'",
                "data:text/javascript,globalThis.__broken = ;",
                "data:text/javascript,globalThis.__third='unexpected'"
            );
            postMessage("unexpected");
        } catch (error) {
            postMessage({
                first: globalThis.__first,
                hasThird: Object.prototype.hasOwnProperty.call(globalThis, "__third"),
                name: error && error.name,
                syntax: error instanceof SyntaxError,
            });
        }
        close();
        "#
        .into(),
        "http://127.0.0.1/worker/main.js".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"first":"ok","hasThird":false,"name":"SyntaxError","syntax":true}"#
    );
}

#[tokio::test]
async fn worker_importscripts_runtime_throw_preserves_thrown_value_and_stops_later_scripts() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        try {
            importScripts(
                "data:text/javascript,globalThis.__x=1",
                "data:text/javascript,throw 2",
                "data:text/javascript,globalThis.__z=3"
            );
            postMessage("unexpected");
        } catch (error) {
            postMessage({
                x: globalThis.__x,
                thrown: error,
                hasZ: Object.prototype.hasOwnProperty.call(globalThis, "__z"),
            });
        }
        close();
        "#
        .into(),
        "http://127.0.0.1/worker/main.js".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#"{"x":1,"thrown":2,"hasZ":false}"#);
}

#[tokio::test]
async fn worker_importscripts_revoked_blob_url_throws_network_error() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const scriptUrl = URL.createObjectURL(new Blob([
            "globalThis.__ran = true;"
        ], { type: "text/javascript" }));
        URL.revokeObjectURL(scriptUrl);
        try {
            importScripts(scriptUrl);
            postMessage("unexpected");
        } catch (error) {
            postMessage({
                name: error && error.name,
                ran: globalThis.__ran === true,
            });
        }
        close();
        "#
        .into(),
        "http://127.0.0.1/worker/main.js".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"name":"NetworkError","ran":false}"#
    );
}

#[tokio::test]
async fn worker_importscripts_prepared_blob_url_survives_revoke_in_earlier_script() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const runScriptUrl = URL.createObjectURL(new Blob([
            "globalThis.__ran = true;"
        ], { type: "text/javascript" }));
        const revokeScriptUrl = URL.createObjectURL(new Blob([
            `URL.revokeObjectURL(${JSON.stringify(runScriptUrl)});`
        ], { type: "text/javascript" }));
        importScripts(revokeScriptUrl, runScriptUrl);
        postMessage(globalThis.__ran === true);
        close();
        "#
        .into(),
        "http://127.0.0.1/worker/main.js".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), "true");
}

#[tokio::test]
async fn worker_importscripts_stringifies_undefined_null_and_number_arguments() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![
        (
            "/worker/undefined",
            "HTTP/1.1 200 OK",
            "application/javascript",
            "globalThis.__undefinedLoaded = true;".to_owned(),
            Duration::ZERO,
        ),
        (
            "/worker/null",
            "HTTP/1.1 200 OK",
            "application/javascript",
            "globalThis.__nullLoaded = true;".to_owned(),
            Duration::ZERO,
        ),
        (
            "/worker/1",
            "HTTP/1.1 200 OK",
            "application/javascript",
            "globalThis.__oneLoaded = true;".to_owned(),
            Duration::ZERO,
        ),
    ])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker importScripts loader");
    let mut handle = spawn_worker_with_request_client(
        r#"
        importScripts(undefined, null, 1);
        postMessage({
            undefinedLoaded: globalThis.__undefinedLoaded === true,
            nullLoaded: globalThis.__nullLoaded === true,
            oneLoaded: globalThis.__oneLoaded === true,
        });
        close();
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"undefinedLoaded":true,"nullLoaded":true,"oneLoaded":true}"#
    );
    server.await.expect("stringification server should finish");
}

#[tokio::test]
async fn worker_trusted_types_importscripts_enforces_script_url_sink() {
    ensure_v8();
    let script_url = worker_data_url(
        r#"
        globalThis.__trustedImportLoaded = true;
        "#,
    );
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            format!(
                r#"
                const policy = trustedTypes.createPolicy("p", {{
                    createScriptURL: value => value
                }});
                const blocked = (() => {{
                    try {{
                        importScripts({script_url:?});
                        return "unexpected";
                    }} catch (error) {{
                        return error.name;
                    }}
                }})();
                importScripts(policy.createScriptURL({script_url:?}));
                postMessage({{
                    blocked,
                    loaded: globalThis.__trustedImportLoaded === true,
                    trusted: trustedTypes.isScriptURL(policy.createScriptURL("data:text/javascript,")),
                }});
                close();
                "#
            ),
            "https://app.test/worker/main.js".to_owned(),
        )
        .with_content_security_policies(vec!["require-trusted-types-for 'script'".into()]),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"blocked":"TypeError","loaded":true,"trusted":true}"#
    );
}

#[tokio::test]
async fn worker_trusted_types_rejects_forged_named_properties() {
    ensure_v8();
    let script_url = worker_data_url("globalThis.__forgedImportLoaded = true;");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            format!(
                r#"
                const forged = {{
                    __moliTrustedTypeKind: "script-url",
                    __moliTrustedTypeValue: {script_url:?},
                }};
                const accepted = (() => {{
                    try {{
                        importScripts(forged);
                        return true;
                    }} catch (error) {{
                        return false;
                    }}
                }})();
                postMessage({{
                    accepted,
                    isScriptURL: trustedTypes.isScriptURL(forged),
                    loaded: globalThis.__forgedImportLoaded === true,
                }});
                close();
                "#
            ),
            "https://app.test/worker/main.js".to_owned(),
        )
        .with_content_security_policies(vec!["require-trusted-types-for 'script'".into()]),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"accepted":false,"isScriptURL":false,"loaded":false}"#
    );
}

#[tokio::test]
async fn worker_trusted_types_policy_create_survives_global_constructor_override() {
    ensure_v8();
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            const policy = trustedTypes.createPolicy("p", {
                createHTML: value => value,
                createScript: value => value,
                createScriptURL: value => value,
            });
            const originalNames = [
                TrustedHTML.name,
                TrustedScript.name,
                TrustedScriptURL.name,
            ];
            TrustedHTML = function FakeTrustedHTML() {};
            TrustedScript = function FakeTrustedScript() {};
            TrustedScriptURL = function FakeTrustedScriptURL() {};
            const html = policy.createHTML("<p>ok</p>");
            const script = policy.createScript("3 + 4");
            const scriptURL = policy.createScriptURL("data:text/javascript,");
            const evalValue = eval(script);
            postMessage({
                originalNames,
                evalValue,
                isHTML: trustedTypes.isHTML(html),
                isScript: trustedTypes.isScript(script),
                isScriptURL: trustedTypes.isScriptURL(scriptURL),
                values: [String(html), String(script), String(scriptURL)],
                constructorNames: [
                    html.constructor.name,
                    script.constructor.name,
                    scriptURL.constructor.name,
                ],
            });
            close();
            "#
            .to_owned(),
            "https://app.test/worker/main.js".to_owned(),
        )
        .with_content_security_policies(vec!["require-trusted-types-for 'script'".into()]),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"originalNames":["TrustedHTML","TrustedScript","TrustedScriptURL"],"evalValue":7,"isHTML":true,"isScript":true,"isScriptURL":true,"values":["<p>ok</p>","3 + 4","data:text/javascript,"],"constructorNames":["TrustedHTML","TrustedScript","TrustedScriptURL"]}"#
    );
}

#[tokio::test]
async fn worker_trusted_types_policy_callbacks_follow_webidl_contract() {
    ensure_v8();
    let mut handle = spawn_test_worker_with_options(WorkerSpawnOptions::new(
        r#"
        const facts = {};
        const extra = {};
        const callback = new Proxy(function() {
            "use strict";
            facts.thisIsUndefined = this === undefined;
            facts.arguments = [
                arguments[0],
                arguments[1],
                arguments[2] === extra,
                arguments.length,
            ];
            return null;
        }, {
            apply(target, receiver, args) {
                facts.proxyApply = (facts.proxyApply || 0) + 1;
                return Reflect.apply(target, receiver, args);
            },
        });
        const policy = trustedTypes.createPolicy("worker-callback", {
            createHTML: callback,
            createScriptURL: () => "\ud800",
        });
        const html = policy.createHTML("input", 7, extra);
        const scriptURL = policy.createScriptURL("url");
        let missingError = "none";
        try {
            policy.createScript("missing");
        } catch (error) {
            missingError = error && error.name;
        }
        const revoked = Proxy.revocable(() => "revoked", {});
        revoked.revoke();
        const revokedPolicy = trustedTypes.createPolicy("worker-revoked", {
            createHTML: revoked.proxy,
        });
        let revokedError = "none";
        try {
            revokedPolicy.createHTML("x");
        } catch (error) {
            revokedError = error && error.name;
        }
        postMessage({
            facts,
            methods: [
                typeof policy.createHTML,
                typeof policy.createScript,
                typeof policy.createScriptURL,
            ],
            html: String(html),
            scriptURLCodePoint: String(scriptURL).codePointAt(0),
            missingError,
            revokedError,
        });
        close();
        "#
        .to_owned(),
        "https://app.test/worker/main.js".to_owned(),
    ));

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"facts":{"proxyApply":1,"thisIsUndefined":true,"arguments":["input",7,true,3]},"methods":["function","function","function"],"html":"","scriptURLCodePoint":65533,"missingError":"TypeError","revokedError":"TypeError"}"#
    );
}

#[tokio::test]
async fn worker_csp_string_compilation_keywords_preserve_source_token_boundaries() {
    ensure_v8();
    for keyword in ["unsafe-eval", "wasm-unsafe-eval", "none"] {
        for (prefix, suffix, valid) in [
            ("", "", true),
            ("\t\n", " \r\u{000c}", true),
            ("\u{000b}", "", false),
            ("", "\u{000b}", false),
        ] {
            let policy = format!("default-src 'none'; script-src {prefix}'{keyword}'{suffix}");
            let source = format!(
                "postMessage(({}).slice(0, 2)); close();",
                include_str!("../../../../tests/fixtures/csp-eval-source-tokens.js"),
            );
            let options =
                WorkerSpawnOptions::new(source, "https://app.test/worker/main.js".to_owned())
                    .with_content_security_policies(vec![policy.clone().into()]);
            let mut handle = spawn_test_worker_with_options(options);
            let message = timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap();
            let expected = serde_json::json!([
                if valid && keyword == "unsafe-eval" {
                    "allowed"
                } else {
                    "EvalError"
                },
                if valid && keyword == "unsafe-eval" {
                    "allowed"
                } else {
                    "EvalError"
                },
            ]);
            assert_eq!(
                expect_post_json(message),
                expected.to_string(),
                "{policy:?}"
            );
        }
    }
}

#[tokio::test]
async fn worker_string_timer_csp_blocks_and_reports_without_blocking_functions() {
    ensure_v8();
    for (policy, report_only, blocked, reports) in [
        ("script-src 'self' 'report-sample'", false, true, true),
        ("default-src 'self' 'report-sample'", false, true, true),
        ("script-src 'self' 'report-sample'", true, false, true),
        ("script-src 'unsafe-eval'", false, false, false),
    ] {
        let source = r#"
            globalThis.ran = [];
            const events = [];
            const first = setTimeout("globalThis.ran.push('timeout')", 10);
            globalThis.interval = setInterval("globalThis.ran.push('interval'); clearInterval(globalThis.interval)", 10);
            addEventListener('securitypolicyviolation', e => events.push({
                directive: e.effectiveDirective, blocked: e.blockedURI,
                disposition: e.disposition, policy: e.originalPolicy,
                source: e.sourceFile, line: e.lineNumber, sample: e.sample,
            }));
            const synchronousEvents = events.length;
            setTimeout((value) => ran.push(value), 10, 'function');
            setTimeout(() => {
                postMessage({zeroIds: [first === 0, interval === 0], ran: ran.sort(), synchronousEvents, events});
                close();
            }, 80);
        "#;
        let options = WorkerSpawnOptions::new(
            source.to_owned(),
            "https://app.test/worker/main.js".to_owned(),
        );
        let options = if report_only {
            options.with_content_security_report_only_policies(vec![policy.to_owned().into()])
        } else {
            options.with_content_security_policies(vec![policy.to_owned().into()])
        };
        let mut handle = spawn_test_worker_with_options(options);
        let message = timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap();
        let value: serde_json::Value = serde_json::from_str(&expect_post_json(message)).unwrap();
        assert_eq!(value["zeroIds"], serde_json::json!([blocked, blocked]));
        assert_eq!(
            value["ran"],
            if blocked {
                serde_json::json!(["function"])
            } else {
                serde_json::json!(["function", "interval", "timeout"])
            }
        );
        assert_eq!(value["synchronousEvents"], 0);
        let events = value["events"].as_array().unwrap();
        assert_eq!(events.len(), if reports { 2 } else { 0 });
        for (event, (line, sample)) in events.iter().zip([
            (4, "globalThis.ran.push('timeout')"),
            (5, "globalThis.ran.push('interval'); clearIn"),
        ]) {
            assert_eq!(
                event,
                &serde_json::json!({
                    "directive": "script-src", "blocked": "eval",
                    "disposition": if report_only { "report" } else { "enforce" },
                    "policy": policy, "source": "https://app.test/worker/main.js", "line": line, "sample": sample,
                })
            );
        }
    }
}

#[tokio::test]
async fn worker_string_timer_csp_converts_arguments_before_policy_and_preserves_exceptions() {
    ensure_v8();
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(r#"
            const order = [];
            const events = [];
            const marker = {};
            const errors = [];
            for (const method of ['setTimeout', 'setInterval']) {
                try {
                    self[method]({toString() { order.push('handler'); throw marker; }}, {valueOf() { order.push('unexpected'); return 0; }});
                } catch (e) { errors.push(e === marker); }
                try {
                    self[method]({toString() { order.push('handler'); return "postMessage('unexpected')"; }}, {valueOf() { order.push('delay'); throw marker; }});
                } catch (e) { errors.push(e === marker); }
            }
            addEventListener('securitypolicyviolation', e => events.push(e.blockedURI));
            setTimeout(() => { postMessage({order, errors, events}); close(); }, 50);
        "#.to_owned(), "https://app.test/worker/main.js".to_owned())
            .with_content_security_policies(vec!["script-src 'none'; require-trusted-types-for 'script'".into()]),
    );
    let message = timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap();
    let value: serde_json::Value = serde_json::from_str(&expect_post_json(message)).unwrap();
    assert_eq!(
        value,
        serde_json::json!({
            "order": ["handler", "handler", "delay", "handler", "handler", "delay"],
            "errors": [true, true, true, true], "events": [],
        })
    );
}

#[tokio::test]
async fn worker_string_timer_csp_preserves_trusted_types_relaxation_and_default_policy_order() {
    ensure_v8();
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(r#"
            globalThis.ran = [];
            const order = [];
            trustedTypes.createPolicy('default', {createScript(value, type, sink) { order.push(sink); return value; }});
            const explicit = trustedTypes.createPolicy('explicit', {createScript: value => value});
            const first = setTimeout({toString() { order.push('handler'); return "ran.push('default')"; }}, {valueOf() { order.push('delay'); return 10; }});
            const trusted = explicit.createScript("ran.push('trusted')");
            trusted.toString = () => { throw new Error('must not coerce TrustedScript'); };
            const second = setTimeout(trusted, 10);
            setTimeout(() => { postMessage({positiveIds: [first > 0, second > 0], ran, order}); close(); }, 50);
        "#.to_owned(), "https://app.test/worker/main.js".to_owned())
            .with_content_security_policies(vec!["script-src 'trusted-types-eval'; require-trusted-types-for 'script'".into()]),
    );
    let message = timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap();
    let value: serde_json::Value = serde_json::from_str(&expect_post_json(message)).unwrap();
    assert_eq!(
        value,
        serde_json::json!({
            "positiveIds": [true, true], "ran": ["default", "trusted"],
            "order": ["handler", "delay", "WorkerGlobalScope setTimeout"],
        })
    );
}

#[tokio::test]
async fn worker_trusted_types_timers_and_eval_use_script_sink() {
    ensure_v8();
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            const policy = trustedTypes.createPolicy("p", {
                createScript: value => value.replace("__VALUE__", "7")
            });
            const blockedTimer = (() => {
                try {
                    setTimeout("postMessage('unexpected')");
                    return "unexpected";
                } catch (error) {
                    return error.name;
                }
            })();
            const blockedEval = (() => {
                try {
                    eval("2");
                    return "unexpected";
                } catch (error) {
                    return `${error.name}:${error instanceof EvalError}`;
                }
            })();
            const evalValue = eval(policy.createScript("__VALUE__"));
            let defaultSink = null;
            trustedTypes.createPolicy("default", {
                createScript: (value, _, sink) => {
                    defaultSink = sink;
                    return value;
                }
            });
            const defaultEvalValue = eval("9");
            setTimeout(policy.createScript("postMessage({blockedTimer, blockedEval, evalValue, defaultEvalValue, defaultSink})"));
            "#
            .to_owned(),
            "https://app.test/worker/main.js".to_owned(),
        )
        .with_content_security_policies(vec!["require-trusted-types-for 'script'".into()]),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"blockedTimer":"TypeError","blockedEval":"EvalError:true","evalValue":7,"defaultEvalValue":9,"defaultSink":"eval"}"#
    );
}

#[tokio::test]
async fn worker_trusted_script_eval_is_unwrapped_with_trusted_types_eval_keyword() {
    ensure_v8();
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            const policy = trustedTypes.createPolicy("p", {
                createScript: value => value
            });
            postMessage({
                trusted: eval(policy.createScript("3 + 4")),
                string: eval("4 + 5"),
            });
            close();
            "#
            .to_owned(),
            "https://app.test/worker/main.js".to_owned(),
        )
        .with_content_security_policies(vec![
            "script-src 'trusted-types-eval'; require-trusted-types-for 'script'".into(),
        ]),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#"{"trusted":7,"string":9}"#);
}

#[tokio::test]
async fn worker_module_static_imports_resolve_http_dependencies_against_module_url() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![
        (
            "/worker/dep.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            [
                "export const answer = 42;",
                "export const suffix = 'dep';",
                "export default 'default-value';",
                "export function double(value) { return value * 2; }",
                "export class Box { constructor(value) { this.value = value; } }",
            ]
            .join("\n"),
            Duration::ZERO,
        ),
        (
            "/worker/reexport.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            [
                "export { answer as importedAnswer, default as importedDefault } from './dep.js';",
                "export * as depNamespace from './dep.js';",
            ]
            .join("\n"),
            Duration::ZERO,
        ),
        (
            "/worker/star.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            "export * from './dep.js';".to_owned(),
            Duration::ZERO,
        ),
    ])
    .await;
    let loader = ResourceRequestClient::new(&FetchConfig::default()).expect("worker module loader");
    let script_url = format!("{base_url}/worker/main.js");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import defaultValue, { answer, suffix as renamed, double, Box } from "./dep.js";
        import * as re from "./reexport.js";
        import { answer as starAnswer } from "./star.js";
        var box = new Box(9);
        postMessage({
            defaultValue,
            answer,
            renamed,
            doubled: double(21),
            boxValue: box.value,
            importedAnswer: re.importedAnswer,
            importedDefault: re.importedDefault,
            namespaceAnswer: re.depNamespace.answer,
            starAnswer,
            importScriptsType: typeof importScripts,
            metaUrl: import.meta.url,
        });
        close();
        "#
        .into(),
        script_url.clone(),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        format!(
            r#"{{"defaultValue":"default-value","answer":42,"renamed":"dep","doubled":42,"boxValue":9,"importedAnswer":42,"importedDefault":"default-value","namespaceAnswer":42,"starAnswer":42,"importScriptsType":"function","metaUrl":"{script_url}"}}"#
        )
    );
    server
        .await
        .expect("worker module import server should finish");
}

#[tokio::test]
async fn worker_module_static_sibling_dependencies_fetch_in_parallel() {
    ensure_v8();
    let listener = TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind worker module sibling server");
    let addr = listener.local_addr().expect("worker module sibling addr");
    let base_url = format!("http://{addr}");
    let server = tokio::spawn(async move {
        let mut first_stream = None;
        let mut first_path = String::new();
        let mut second_stream = None;
        let mut second_path = String::new();
        for _ in 0..2 {
            let (mut stream, _) = listener
                .accept()
                .await
                .expect("accept worker module sibling request");
            let request = read_http_request_head(&mut stream)
                .await
                .expect("read worker module sibling request");
            let path = request
                .lines()
                .next()
                .and_then(|line| line.split_whitespace().nth(1))
                .expect("worker module sibling request path")
                .to_owned();
            if first_stream.is_none() {
                first_path = path;
                first_stream = Some(stream);
            } else {
                second_path = path;
                second_stream = Some(stream);
            }
        }
        let mut paths = vec![first_path.clone(), second_path.clone()];
        paths.sort();
        assert_eq!(paths, vec!["/worker/a.js", "/worker/b.js"]);
        for (path, stream) in [
            (first_path, first_stream.expect("first sibling stream")),
            (second_path, second_stream.expect("second sibling stream")),
        ] {
            let body = match path.as_str() {
                "/worker/a.js" => "export const a = 'a';",
                "/worker/b.js" => "export const b = 'b';",
                other => panic!("unexpected worker module sibling path: {other}"),
            };
            let response = format!(
                "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
                body.len(),
                body
            );
            let mut stream = stream;
            stream
                .write_all(response.as_bytes())
                .await
                .expect("write worker module sibling response");
        }
    });

    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker module sibling loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import { a } from "./a.js";
        import { b } from "./b.js";
        postMessage({ a, b });
        close();
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#"{"a":"a","b":"b"}"#);
    server
        .await
        .expect("worker module sibling server should finish");
}

#[tokio::test]
async fn worker_module_fetches_completed_sibling_descendants_before_slow_sibling_finishes() {
    ensure_v8();
    let listener = TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind worker module descendant server");
    let addr = listener
        .local_addr()
        .expect("worker module descendant addr");
    let base_url = format!("http://{addr}");
    let server = tokio::spawn(async move {
        let mut first_stream = None;
        let mut first_path = String::new();
        let mut second_stream = None;
        let mut second_path = String::new();
        for _ in 0..2 {
            let (mut stream, _) = listener
                .accept()
                .await
                .expect("accept worker module sibling request");
            let request = read_http_request_head(&mut stream)
                .await
                .expect("read worker module sibling request");
            let path = request
                .lines()
                .next()
                .and_then(|line| line.split_whitespace().nth(1))
                .expect("worker module sibling request path")
                .to_owned();
            if first_stream.is_none() {
                first_path = path;
                first_stream = Some(stream);
            } else {
                second_path = path;
                second_stream = Some(stream);
            }
        }

        let (mut a_stream, mut b_stream) = match (
            first_path.as_str(),
            first_stream.expect("first sibling stream"),
            second_path.as_str(),
            second_stream.expect("second sibling stream"),
        ) {
            ("/worker/a.js", a_stream, "/worker/b.js", b_stream)
            | ("/worker/b.js", b_stream, "/worker/a.js", a_stream) => (a_stream, b_stream),
            (first, _, second, _) => panic!("unexpected sibling paths: {first}, {second}"),
        };

        let a_body = "import { child } from './a-child.js'; export const a = `a${child}`;";
        let a_response = format!(
            "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
            a_body.len(),
            a_body
        );
        a_stream
            .write_all(a_response.as_bytes())
            .await
            .expect("write worker module a response");

        let (mut child_stream, _) = listener
            .accept()
            .await
            .expect("accept worker module child request before b finishes");
        let child_request = read_http_request_head(&mut child_stream)
            .await
            .expect("read worker module child request");
        let child_path = child_request
            .lines()
            .next()
            .and_then(|line| line.split_whitespace().nth(1))
            .expect("worker module child request path");
        assert_eq!(
            child_path, "/worker/a-child.js",
            "completed sibling descendants should start before slow sibling completes"
        );

        let child_body = "export const child = 'child';";
        let child_response = format!(
            "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
            child_body.len(),
            child_body
        );
        child_stream
            .write_all(child_response.as_bytes())
            .await
            .expect("write worker module child response");

        let b_body = "export const b = 'b';";
        let b_response = format!(
            "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
            b_body.len(),
            b_body
        );
        b_stream
            .write_all(b_response.as_bytes())
            .await
            .expect("write worker module b response");
    });

    let loader = ResourceRequestClient::new(&FetchConfig::default())
        .expect("worker module descendant loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import { a } from "./a.js";
        import { b } from "./b.js";
        postMessage({ a, b });
        close();
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#"{"a":"achild","b":"b"}"#);
    server
        .await
        .expect("worker module descendant server should finish");
}

#[tokio::test]
async fn worker_module_importscripts_is_exposed_but_throws_type_error() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        try {
            importScripts("data:text/javascript,postMessage('unexpected')");
            postMessage("unexpected");
        } catch (error) {
            postMessage({
                importScriptsType: typeof importScripts,
                name: error && error.name,
                message: error && error.message,
            });
        }
        close();
        "#
        .into(),
        "test://worker_module_importscripts".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"importScriptsType":"function","name":"TypeError","message":"Module scripts don't support importScripts()."}"#
    );
}

#[tokio::test]
async fn worker_module_same_origin_dependency_fetch_sends_cookies() {
    ensure_v8();
    let listener = TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind worker module cookie server");
    let addr = listener.local_addr().expect("worker module cookie addr");
    let base_url = format!("http://{addr}");
    let server = tokio::spawn(async move {
        let (mut stream, _) = listener
            .accept()
            .await
            .expect("accept worker module dependency request");
        let request = read_http_request_head(&mut stream)
            .await
            .expect("read worker module dependency request");
        let cookie_seen = request
            .lines()
            .any(|line| line.eq_ignore_ascii_case("cookie: wpt_worker_module_credentials=fixture"));
        let body = format!(
            "export const credentialCookie = '{}';",
            if cookie_seen { "seen" } else { "missing" }
        );
        let response = format!(
            "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
            body.len(),
            body
        );
        stream
            .write_all(response.as_bytes())
            .await
            .expect("write worker module dependency response");
    });

    let cookie_store = moli_cookie_jar::new_shared_browser_cookie_store();
    {
        let mut jar = cookie_store.lock();
        jar.store_response_headers(
            &url::Url::parse(&format!("{base_url}/worker/main.js")).unwrap(),
            &[(
                "set-cookie".to_owned(),
                b"wpt_worker_module_credentials=fixture; Path=/worker; SameSite=Lax".to_vec(),
            )],
        );
    }
    let loader = ResourceRequestClient::new_with_cookie_store(
        &FetchConfig::default(),
        Arc::clone(&cookie_store),
    )
    .expect("worker module loader");
    let script_url = format!("{base_url}/worker/main.js");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import { credentialCookie } from "./dep.js";
        postMessage(credentialCookie);
        close();
        "#
        .into(),
        script_url,
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#""seen""#);
    server
        .await
        .expect("worker module cookie server should finish");
}

#[tokio::test]
async fn worker_module_redirected_http_dependency_uses_final_response_url_as_base() {
    ensure_v8();
    let dep_source = [
        "export const leafValue = 'redirect-leaf';",
        "export const leafMetaUrl = import.meta.url;",
    ]
    .join("\n");
    let entry_source = [
        "import { leafMetaUrl, leafValue } from './dep.js';",
        "export { leafMetaUrl, leafValue };",
        "export const entryMetaUrl = import.meta.url;",
    ]
    .join("\n");
    let dep_response = format!(
        "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nAccess-Control-Allow-Origin: *\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
        dep_source.len(),
        dep_source
    );
    let entry_response = format!(
        "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nAccess-Control-Allow-Origin: *\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
        entry_source.len(),
        entry_source
    );
    let (base_url, script_server) = spawn_raw_path_response_http_server(vec![
        ("/worker/final/dep.js", dep_response, Duration::ZERO),
        ("/worker/final/entry.js", entry_response, Duration::ZERO),
    ])
    .await;
    let redirect_response = format!(
        "HTTP/1.1 302 Found\r\nLocation: {base_url}/worker/final/entry.js\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
    );
    let (redirect_base_url, redirect_server) = spawn_raw_path_response_http_server(vec![(
        "/worker/redirect-entry.js",
        redirect_response,
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker module redirect loader");
    let script_url = format!("{redirect_base_url}/worker/main.js");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import { entryMetaUrl, leafMetaUrl, leafValue } from "./redirect-entry.js";
        postMessage({
            entryMetaUrl,
            leafMetaUrl,
            leafValue,
            mainMetaUrl: import.meta.url,
        });
        close();
        "#
        .into(),
        script_url.clone(),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        format!(
            r#"{{"entryMetaUrl":"{base_url}/worker/final/entry.js","leafMetaUrl":"{base_url}/worker/final/dep.js","leafValue":"redirect-leaf","mainMetaUrl":"{script_url}"}}"#
        )
    );
    redirect_server
        .await
        .expect("worker module redirect server should finish");
    script_server
        .await
        .expect("worker module final-url server should finish");
}

#[tokio::test]
async fn worker_module_redirected_http_dependency_final_url_obeys_script_src() {
    ensure_v8();
    let target_source = "postMessage('unexpected module target');";
    let target_response = format!(
        "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nAccess-Control-Allow-Origin: *\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
        target_source.len(),
        target_source
    );
    let (target_base_url, target_server) = spawn_raw_path_response_http_server(vec![(
        "/worker/final/entry.js",
        target_response,
        Duration::ZERO,
    )])
    .await;
    let redirect_response = format!(
        "HTTP/1.1 302 Found\r\nLocation: {target_base_url}/worker/final/entry.js\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
    );
    let (source_base_url, source_server) = spawn_raw_path_response_http_server(vec![(
        "/worker/redirect-entry.js",
        redirect_response,
        Duration::ZERO,
    )])
    .await;
    let loader = ResourceRequestClient::new(&FetchConfig::default())
        .expect("worker module CSP redirect loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
        import "./redirect-entry.js";
        postMessage("unexpected main");
        "#
            .into(),
            format!("{source_base_url}/worker/main.js"),
        )
        .with_request_client(loader)
        .with_script_kind(WorkerScriptKind::Module)
        .with_module_static_import_content_security_policies(vec!["script-src 'self'".into()]),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Error { message, phase, .. } => {
            assert!(
                message.contains("Content Security Policy"),
                "expected CSP error, got {message:?}"
            );
            assert_eq!(phase, WorkerErrorPhase::Bootstrap);
        }
        other => panic!("expected Error, got {other:?}"),
    }
    source_server
        .await
        .expect("worker module CSP redirect source server should finish");
    target_server
        .await
        .expect("worker module CSP redirect target server should finish");
}

#[tokio::test]
async fn worker_module_redirected_request_url_remains_module_key() {
    ensure_v8();
    let (base_url, request_paths_rx, server) =
        spawn_worker_redirected_module_key_reuse_server().await;
    let loader = ResourceRequestClient::new(&FetchConfig::default())
        .expect("worker module redirect key loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
        import { metaUrl as staticMetaUrl, value as staticValue } from "./redirect-entry.js";
        const dynamic = await import("./redirect-entry.js");
        postMessage({
          dynamicMetaUrl: dynamic.metaUrl,
          dynamicValue: dynamic.value,
          staticMetaUrl,
          staticValue,
        });
        close();
        "#
            .into(),
            format!("{base_url}/worker/main.js"),
        )
        .with_request_client(loader)
        .with_script_kind(WorkerScriptKind::Module),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out waiting for worker redirected key result")
        .expect("channel closed");
    let final_url = format!("{base_url}/worker/final/entry.js");
    assert_eq!(
        expect_post_json(msg),
        format!(
            r#"{{"dynamicMetaUrl":"{final_url}","dynamicValue":"redirect-key","staticMetaUrl":"{final_url}","staticValue":"redirect-key"}}"#
        )
    );
    let request_paths = request_paths_rx
        .await
        .expect("worker redirect key server should report paths");
    assert_eq!(
        request_paths,
        ["/worker/redirect-entry.js", "/worker/final/entry.js"]
    );
    handle.terminate_and_join();
    server
        .await
        .expect("worker redirect key server should finish");
}

async fn spawn_worker_redirected_module_key_reuse_server()
-> (String, oneshot::Receiver<Vec<String>>, JoinHandle<()>) {
    let listener = TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind worker redirect key server");
    let addr = listener
        .local_addr()
        .expect("worker redirect key server addr");
    let base_url = format!("http://{addr}");
    let server_base_url = base_url.clone();
    let (paths_tx, paths_rx) = oneshot::channel();
    let server = tokio::spawn(async move {
        let mut request_paths = Vec::new();
        loop {
            let accept_result = if request_paths.len() < 2 {
                listener.accept().await.ok()
            } else {
                tokio::time::timeout(Duration::from_millis(250), listener.accept())
                    .await
                    .ok()
                    .and_then(Result::ok)
            };
            let Some((mut stream, _)) = accept_result else {
                break;
            };
            let request = read_http_request_head(&mut stream)
                .await
                .expect("read worker redirect key request");
            let path = request
                .lines()
                .next()
                .and_then(|line| line.split_whitespace().nth(1))
                .expect("worker redirect key request path")
                .to_owned();
            request_paths.push(path.clone());
            let response = match path.as_str() {
                "/worker/redirect-entry.js" => format!(
                    "HTTP/1.1 302 Found\r\nLocation: {server_base_url}/worker/final/entry.js\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
                ),
                "/worker/final/entry.js" => {
                    let body = r#"export const value = "redirect-key";
export const metaUrl = import.meta.url;"#;
                    format!(
                        "HTTP/1.1 200 OK\r\nAccess-Control-Allow-Origin: *\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
                        body.len(),
                        body
                    )
                }
                _ => "HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
                    .to_owned(),
            };
            stream
                .write_all(response.as_bytes())
                .await
                .expect("write worker redirect key response");
            if request_paths.len() >= 4 {
                break;
            }
        }
        let _ = paths_tx.send(request_paths);
    });
    (base_url, paths_rx, server)
}

#[tokio::test]
async fn worker_module_static_import_uses_outside_csp_not_worker_response_csp() {
    ensure_v8();
    let target_source = r#"export const value = "static-ok";"#;
    let target_response = format!(
        "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nAccess-Control-Allow-Origin: *\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
        target_source.len(),
        target_source
    );
    let (target_base_url, target_server) = spawn_raw_path_response_http_server(vec![(
        "/worker/dep.js",
        target_response,
        Duration::ZERO,
    )])
    .await;
    let dep_specifier = serde_json::to_string(&format!("{target_base_url}/worker/dep.js"))
        .expect("dependency URL should serialize");
    let loader = ResourceRequestClient::new(&FetchConfig::default())
        .expect("worker module static CSP loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            format!(
                r#"
        import {{ value }} from {dep_specifier};
        postMessage(value);
        close();
        "#
            ),
            "https://app.test/worker/main.js".to_owned(),
        )
        .with_request_client(loader)
        .with_script_kind(WorkerScriptKind::Module)
        .with_module_static_import_initiator_url(
            url::Url::parse("https://app.test/page.html").unwrap(),
        )
        .with_module_static_import_content_security_policies(vec![
            "worker-src *; script-src 'self'".into(),
        ])
        .with_content_security_policies(vec!["script-src 'self'".into()]),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#""static-ok""#);
    target_server
        .await
        .expect("worker module static CSP server should finish");
}

#[tokio::test]
async fn worker_module_response_referrer_policy_controls_descendant_fetch() {
    ensure_v8();
    let (base_url, child_headers_rx, server) =
        spawn_worker_module_referrer_policy_descendant_server().await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker module referrer loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
        import "./a.js";
        "#
            .into(),
            format!("{base_url}/worker/main.js"),
        )
        .with_request_client(loader)
        .with_script_kind(WorkerScriptKind::Module)
        .with_module_static_import_initiator_url(
            url::Url::parse("http://127.0.0.1:1/page.html").unwrap(),
        )
        .with_referrer_policy(Some("origin".to_owned())),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out waiting for worker module referrer result")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#""referrer-policy-ok""#);
    let child_headers = child_headers_rx
        .await
        .expect("worker module referrer server should report child headers");
    assert!(
        !child_headers
            .lines()
            .any(|line| line.to_ascii_lowercase().starts_with("referer:")),
        "descendant request should inherit parent module response Referrer-Policy: no-referrer; headers were {child_headers:?}"
    );
    handle.terminate_and_join();
    server
        .await
        .expect("worker module referrer server should finish");
}

async fn spawn_worker_module_referrer_policy_descendant_server()
-> (String, oneshot::Receiver<String>, JoinHandle<()>) {
    let listener = TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind worker module referrer policy server");
    let addr = listener
        .local_addr()
        .expect("worker module referrer policy server addr");
    let (headers_tx, headers_rx) = oneshot::channel();
    let server = tokio::spawn(async move {
        let (mut first_stream, _) = listener
            .accept()
            .await
            .expect("accept worker module referrer parent request");
        let first_request = read_http_request_head(&mut first_stream)
            .await
            .expect("read worker module referrer parent request");
        let first_path = first_request
            .lines()
            .next()
            .and_then(|line| line.split_whitespace().nth(1))
            .expect("worker module referrer parent request path");
        assert_eq!(first_path, "/worker/a.js");
        let parent_body = r#"import { value } from "./a-child.js";
postMessage(value);
close();"#;
        let parent_response = format!(
            "HTTP/1.1 200 OK\r\nAccess-Control-Allow-Origin: *\r\nContent-Type: application/javascript\r\nReferrer-Policy: no-referrer\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
            parent_body.len(),
            parent_body
        );
        first_stream
            .write_all(parent_response.as_bytes())
            .await
            .expect("write worker module referrer parent response");

        let (mut child_stream, _) = listener
            .accept()
            .await
            .expect("accept worker module referrer child request");
        let child_request = read_http_request_head(&mut child_stream)
            .await
            .expect("read worker module referrer child request");
        let child_path = child_request
            .lines()
            .next()
            .and_then(|line| line.split_whitespace().nth(1))
            .expect("worker module referrer child request path");
        assert_eq!(child_path, "/worker/a-child.js");
        let _ = headers_tx.send(child_request);
        let child_body = r#"export const value = "referrer-policy-ok";"#;
        let child_response = format!(
            "HTTP/1.1 200 OK\r\nAccess-Control-Allow-Origin: *\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
            child_body.len(),
            child_body
        );
        child_stream
            .write_all(child_response.as_bytes())
            .await
            .expect("write worker module referrer child response");
    });
    (format!("http://{addr}"), headers_rx, server)
}

#[tokio::test]
async fn classic_worker_dynamic_import_uses_worker_referrer_policy() {
    ensure_v8();
    let (base_url, headers_rx, server) =
        spawn_classic_worker_dynamic_import_referrer_policy_server().await;
    let loader = ResourceRequestClient::new(&FetchConfig::default())
        .expect("classic dynamic referrer loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
        import("./dynamic.js").then((ns) => {
          postMessage(ns.value);
          close();
        }).catch((error) => {
          postMessage("rejected:" + String(error && error.message));
          close();
        });
        "#
            .into(),
            format!("{base_url}/worker/main.js"),
        )
        .with_request_client(loader)
        .with_referrer_policy(Some("no-referrer".to_owned())),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out waiting for classic dynamic referrer result")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#""classic-dynamic-referrer-ok""#);
    let headers = headers_rx
        .await
        .expect("classic dynamic referrer server should report headers");
    assert!(
        !headers
            .lines()
            .any(|line| line.to_ascii_lowercase().starts_with("referer:")),
        "classic worker dynamic import root should inherit worker no-referrer policy; headers were {headers:?}"
    );
    handle.terminate_and_join();
    server
        .await
        .expect("classic dynamic referrer server should finish");
}

async fn spawn_classic_worker_dynamic_import_referrer_policy_server()
-> (String, oneshot::Receiver<String>, JoinHandle<()>) {
    let listener = TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind classic dynamic referrer policy server");
    let addr = listener
        .local_addr()
        .expect("classic dynamic referrer policy server addr");
    let (headers_tx, headers_rx) = oneshot::channel();
    let server = tokio::spawn(async move {
        let (mut stream, _) = listener
            .accept()
            .await
            .expect("accept classic dynamic referrer request");
        let request = read_http_request_head(&mut stream)
            .await
            .expect("read classic dynamic referrer request");
        let path = request
            .lines()
            .next()
            .and_then(|line| line.split_whitespace().nth(1))
            .expect("classic dynamic referrer request path");
        assert_eq!(path, "/worker/dynamic.js");
        let _ = headers_tx.send(request);
        let body = r#"export const value = "classic-dynamic-referrer-ok";"#;
        let response = format!(
            "HTTP/1.1 200 OK\r\nAccess-Control-Allow-Origin: *\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
            body.len(),
            body
        );
        stream
            .write_all(response.as_bytes())
            .await
            .expect("write classic dynamic referrer response");
    });
    (format!("http://{addr}"), headers_rx, server)
}

#[tokio::test]
async fn worker_dynamic_import_root_joins_inflight_fetch() {
    ensure_v8();
    let (base_url, request_paths_rx, server) =
        spawn_worker_dynamic_import_duplicate_root_server_with_response(
            "HTTP/1.1 200 OK",
            r#"export const value = "joined-root";"#,
        )
        .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker dynamic join loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
        const events = [];
        const first = import("./dynamic.js").then((ns) => events.push("first:" + ns.value));
        const second = import("./dynamic.js").then((ns) => events.push("second:" + ns.value));
        Promise.all([first, second]).then(() => {
          postMessage(events.sort().join("|"));
          close();
        }).catch((error) => {
          postMessage("rejected:" + String(error && error.message));
          close();
        });
        "#
            .into(),
            format!("{base_url}/worker/main.js"),
        )
        .with_request_client(loader),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out waiting for worker dynamic root join result")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#""first:joined-root|second:joined-root""#
    );
    let request_paths = request_paths_rx
        .await
        .expect("worker dynamic join server should report paths");
    assert_eq!(request_paths, ["/worker/dynamic.js"]);
    handle.terminate_and_join();
    server
        .await
        .expect("worker dynamic join server should finish");
}

#[tokio::test]
async fn worker_dynamic_import_root_join_waits_for_descendant_graph() {
    ensure_v8();
    let (base_url, request_paths_rx, server) =
        spawn_worker_dynamic_import_duplicate_root_with_dependency_server().await;
    let loader = ResourceRequestClient::new(&FetchConfig::default())
        .expect("worker dynamic descendant join loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
        const events = [];
        const first = import("./dynamic.js").then((ns) => events.push("first:" + ns.value));
        const second = import("./dynamic.js").then((ns) => events.push("second:" + ns.value));
        Promise.all([first, second]).then(() => {
          postMessage(events.sort().join("|"));
          close();
        }).catch((error) => {
          postMessage("rejected:" + String(error && error.message));
          close();
        });
        "#
            .into(),
            format!("{base_url}/worker/main.js"),
        )
        .with_request_client(loader),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out waiting for worker dynamic descendant join result")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#""first:root-dep|second:root-dep""#);
    let request_paths = request_paths_rx
        .await
        .expect("worker dynamic descendant join server should report paths");
    assert_eq!(request_paths, ["/worker/dynamic.js", "/worker/dep.js"]);
    handle.terminate_and_join();
    server
        .await
        .expect("worker dynamic descendant join server should finish");
}

#[tokio::test]
async fn worker_dynamic_import_root_failure_fans_out_to_joined_import() {
    ensure_v8();
    let (base_url, request_paths_rx, server) =
        spawn_worker_dynamic_import_duplicate_root_server_with_response(
            "HTTP/1.1 500 Internal Server Error",
            "server-error",
        )
        .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker dynamic failure loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
        const events = [];
        const first = import("./dynamic.js").then(
          () => events.push("first:resolved"),
          (error) => events.push("first:" + String(error && error.message).includes("500"))
        );
        const second = import("./dynamic.js").then(
          () => events.push("second:resolved"),
          (error) => events.push("second:" + String(error && error.message).includes("500"))
        );
        Promise.all([first, second]).then(() => {
          postMessage(events.sort().join("|"));
          close();
        });
        "#
            .into(),
            format!("{base_url}/worker/main.js"),
        )
        .with_request_client(loader),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out waiting for worker dynamic root failure result")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#""first:true|second:true""#);
    let request_paths = request_paths_rx
        .await
        .expect("worker dynamic failure server should report paths");
    assert_eq!(request_paths, ["/worker/dynamic.js"]);
    handle.terminate_and_join();
    server
        .await
        .expect("worker dynamic failure server should finish");
}

async fn spawn_worker_dynamic_import_duplicate_root_server_with_response(
    status_line: &'static str,
    body: &'static str,
) -> (String, oneshot::Receiver<Vec<String>>, JoinHandle<()>) {
    let listener = TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind worker dynamic duplicate root server");
    let addr = listener
        .local_addr()
        .expect("worker dynamic duplicate root server addr");
    let (paths_tx, paths_rx) = oneshot::channel();
    let server = tokio::spawn(async move {
        let mut request_paths = Vec::new();
        let (mut stream, _) = listener
            .accept()
            .await
            .expect("accept first worker dynamic root request");
        let request = read_http_request_head(&mut stream)
            .await
            .expect("read first worker dynamic root request");
        let path = request
            .lines()
            .next()
            .and_then(|line| line.split_whitespace().nth(1))
            .expect("first worker dynamic root request path")
            .to_owned();
        request_paths.push(path);
        let response = format!(
            "{status_line}\r\nAccess-Control-Allow-Origin: *\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
            body.len(),
            body
        );
        stream
            .write_all(response.as_bytes())
            .await
            .expect("write first worker dynamic root response");

        let duplicate_deadline = tokio::time::Instant::now() + Duration::from_millis(250);
        tokio::select! {
            accept = listener.accept() => {
                let (mut duplicate_stream, _) =
                    accept.expect("accept duplicate worker dynamic root request");
                let duplicate_request = read_http_request_head(&mut duplicate_stream)
                    .await
                    .expect("read duplicate worker dynamic root request");
                let duplicate_path = duplicate_request
                    .lines()
                    .next()
                    .and_then(|line| line.split_whitespace().nth(1))
                    .expect("duplicate worker dynamic root request path")
                    .to_owned();
                request_paths.push(duplicate_path);
                let _ = duplicate_stream.write_all(response.as_bytes()).await;
            }
            _ = tokio::time::sleep_until(duplicate_deadline) => {
            }
        }
        let _ = paths_tx.send(request_paths);
    });
    (format!("http://{addr}"), paths_rx, server)
}

async fn spawn_worker_dynamic_import_duplicate_root_with_dependency_server()
-> (String, oneshot::Receiver<Vec<String>>, JoinHandle<()>) {
    let listener = TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind worker dynamic duplicate dependency server");
    let addr = listener
        .local_addr()
        .expect("worker dynamic duplicate dependency server addr");
    let (paths_tx, paths_rx) = oneshot::channel();
    let server = tokio::spawn(async move {
        let mut request_paths = Vec::new();
        for expected_path in ["/worker/dynamic.js", "/worker/dep.js"] {
            let (mut stream, _) = listener
                .accept()
                .await
                .expect("accept worker dynamic dependency request");
            let request = read_http_request_head(&mut stream)
                .await
                .expect("read worker dynamic dependency request");
            let path = request
                .lines()
                .next()
                .and_then(|line| line.split_whitespace().nth(1))
                .expect("worker dynamic dependency request path")
                .to_owned();
            request_paths.push(path.clone());
            assert_eq!(path, expected_path);
            let body = match path.as_str() {
                "/worker/dynamic.js" => {
                    r#"import { value as dep } from "./dep.js";
export const value = "root-" + dep;"#
                }
                "/worker/dep.js" => r#"export const value = "dep";"#,
                _ => unreachable!("unexpected worker dynamic dependency path"),
            };
            let response = format!(
                "HTTP/1.1 200 OK\r\nAccess-Control-Allow-Origin: *\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
                body.len(),
                body
            );
            stream
                .write_all(response.as_bytes())
                .await
                .expect("write worker dynamic dependency response");
        }

        let duplicate_deadline = tokio::time::Instant::now() + Duration::from_millis(250);
        tokio::select! {
            accept = listener.accept() => {
                let (mut duplicate_stream, _) =
                    accept.expect("accept duplicate worker dynamic dependency request");
                let duplicate_request = read_http_request_head(&mut duplicate_stream)
                    .await
                    .expect("read duplicate worker dynamic dependency request");
                let duplicate_path = duplicate_request
                    .lines()
                    .next()
                    .and_then(|line| line.split_whitespace().nth(1))
                    .expect("duplicate worker dynamic dependency request path")
                    .to_owned();
                request_paths.push(duplicate_path);
                let _ = duplicate_stream.write_all(
                    b"HTTP/1.1 500 Internal Server Error\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
                ).await;
            }
            _ = tokio::time::sleep_until(duplicate_deadline) => {}
        }
        let _ = paths_tx.send(request_paths);
    });
    (format!("http://{addr}"), paths_rx, server)
}

#[tokio::test]
async fn worker_dynamic_import_uses_worker_response_csp_not_outside_static_csp() {
    ensure_v8();
    let dep_specifier = serde_json::to_string("http://127.0.0.1:9/worker/dynamic.js")
        .expect("dependency URL should serialize");
    let loader = ResourceRequestClient::new(&FetchConfig::default())
        .expect("worker module dynamic CSP loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            format!(
                r#"
        const events = [];
        addEventListener("securitypolicyviolation", event => {{
            events.push({{
                type: event.type,
                effectiveDirective: event.effectiveDirective,
                violatedDirective: event.violatedDirective,
                blockedURI: event.blockedURI,
                documentURI: event.documentURI,
                originalPolicy: event.originalPolicy,
                disposition: event.disposition,
                instance: event instanceof SecurityPolicyViolationEvent
            }});
        }});
        (async () => {{
            try {{
                const mod = await import({dep_specifier});
                postMessage({{ status: "unexpected", value: mod.value }});
            }} catch (error) {{
                postMessage({{
                    status: "blocked",
                    events,
                    name: error && error.name,
                    csp: String(error && error.message).includes("Content Security Policy"),
                }});
            }}
            close();
        }})();
        "#
            ),
            "https://app.test/worker/main.js".to_owned(),
        )
        .with_request_client(loader)
        .with_script_kind(WorkerScriptKind::Module)
        .with_module_static_import_initiator_url(
            url::Url::parse("https://app.test/page.html").unwrap(),
        )
        .with_module_static_import_content_security_policies(vec![
            "worker-src *; script-src 'self'".into(),
        ])
        .with_content_security_policies(vec!["script-src-elem 'self'; script-src *".into()]),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"status":"blocked","events":[{"type":"securitypolicyviolation","effectiveDirective":"script-src-elem","violatedDirective":"script-src-elem","blockedURI":"http://127.0.0.1:9/worker/dynamic.js","documentURI":"https://app.test/worker/main.js","originalPolicy":"script-src-elem 'self'; script-src *","disposition":"enforce","instance":true}],"name":"TypeError","csp":true}"#
    );
}

#[tokio::test]
async fn shared_worker_data_module_dynamic_import_allows_cors_dependency() {
    ensure_v8();
    let dynamic_source = r#"export const value = "cors-ok";"#;
    let dynamic_response = format!(
        "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nAccess-Control-Allow-Origin: *\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
        dynamic_source.len(),
        dynamic_source
    );
    let imported_source = r#"
        const importedModulesPromise =
            import("./dynamic.js")
                .then(module => module.value);

        onconnect = () => {
            importedModulesPromise.then(value => {
                if (value === "cors-ok") {
                    close();
                }
            });
        };
    "#;
    let imported_response = format!(
        "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nAccess-Control-Allow-Origin: *\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
        imported_source.len(),
        imported_source
    );
    let (target_base_url, target_server) = spawn_raw_path_response_http_server(vec![
        ("/worker/imported.js", imported_response, Duration::ZERO),
        ("/worker/dynamic.js", dynamic_response, Duration::ZERO),
    ])
    .await;
    let dep_specifier = serde_json::to_string(&format!("{target_base_url}/worker/imported.js"))
        .expect("imported module URL should serialize");
    let source = format!(
        r#"
        import {dep_specifier};
        "#
    );
    let storage_key = moli_storage_key::MoliStorageKey::new(
        "null".to_owned(),
        "https://app.test".to_owned(),
        Some(moli_storage_key::OpaqueOriginNonce::new(1)),
        moli_storage_key::StoragePartitionRelation::Unknown,
    );
    let loader = ResourceRequestClient::new(&FetchConfig::default())
        .expect("shared worker dynamic import loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(source.clone(), worker_data_url(&source))
            .with_request_client(loader)
            .with_script_kind(WorkerScriptKind::Module)
            .with_global_kind(super::super::WorkerGlobalKind::Shared {
                name: "shared".to_owned(),
                storage_key,
            })
            .with_module_static_import_initiator_url(
                url::Url::parse("https://app.test/page.html").unwrap(),
            ),
    );

    handle
        .tx
        .send(crate::worker::WorkerMessage::SharedWorkerConnect(0))
        .expect("connect shared worker");
    loop {
        let msg = timeout(TIMEOUT, handle.recv())
            .await
            .expect("timed out")
            .expect("channel closed");
        match msg {
            WorkerToParentMessage::SharedWorkerClosed => break,
            WorkerToParentMessage::Error { message, .. } => {
                panic!("shared worker reported unexpected error: {message}");
            }
            _ => {}
        }
    }
    target_server.abort();
}

#[tokio::test]
async fn shared_worker_data_module_dynamic_import_allows_data_dependency() {
    ensure_v8();
    let dep_specifier =
        serde_json::to_string(&worker_data_url(r#"export const value = "data-ok";"#))
            .expect("data dependency URL should serialize");
    let source = format!(
        r#"
        onconnect = () => {{
            import({dep_specifier})
                .then(module => {{
                    if (module.value === "data-ok") {{
                        close();
                    }}
                }});
        }};
        "#
    );
    let storage_key = moli_storage_key::MoliStorageKey::new(
        "null".to_owned(),
        "https://app.test".to_owned(),
        Some(moli_storage_key::OpaqueOriginNonce::new(2)),
        moli_storage_key::StoragePartitionRelation::Unknown,
    );
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(source.clone(), worker_data_url(&source))
            .with_script_kind(WorkerScriptKind::Module)
            .with_global_kind(super::super::WorkerGlobalKind::Shared {
                name: "shared".to_owned(),
                storage_key,
            })
            .with_module_static_import_initiator_url(
                url::Url::parse("https://app.test/page.html").unwrap(),
            ),
    );

    handle
        .tx
        .send(crate::worker::WorkerMessage::SharedWorkerConnect(0))
        .expect("connect shared worker");
    loop {
        let msg = timeout(TIMEOUT, handle.recv())
            .await
            .expect("timed out")
            .expect("channel closed");
        match msg {
            WorkerToParentMessage::SharedWorkerClosed => break,
            WorkerToParentMessage::Error { message, .. } => {
                panic!("shared worker reported unexpected error: {message}");
            }
            _ => {}
        }
    }
}

#[tokio::test]
async fn shared_worker_dynamic_import_csp_block_dispatches_securitypolicyviolation_event() {
    ensure_v8();
    let storage_key = moli_storage_key::MoliStorageKey::new(
        "https://app.test".to_owned(),
        "https://app.test".to_owned(),
        None,
        moli_storage_key::StoragePartitionRelation::FirstParty,
    );
    let loader = ResourceRequestClient::new(&FetchConfig::default())
        .expect("shared worker dynamic CSP loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            onconnect = () => {
                let matched = false;
                addEventListener("securitypolicyviolation", event => {
                    matched = event.type === "securitypolicyviolation" &&
                        event.effectiveDirective === "script-src-elem" &&
                        event.violatedDirective === "script-src-elem" &&
                        event.blockedURI === "http://127.0.0.1:9/worker/dynamic.js" &&
                        event.documentURI === "https://app.test/shared-worker.js" &&
                        event.originalPolicy === "script-src 'self'" &&
                        event.disposition === "enforce" &&
                        event instanceof SecurityPolicyViolationEvent;
                });
                import("http://127.0.0.1:9/worker/dynamic.js").catch(() => {
                    if (matched) {
                        close();
                    }
                });
            };
            "#
            .into(),
            "https://app.test/shared-worker.js".into(),
        )
        .with_request_client(loader)
        .with_global_kind(super::super::WorkerGlobalKind::Shared {
            name: "shared".to_owned(),
            storage_key,
        })
        .with_content_security_policies(vec!["script-src 'self'".into()]),
    );

    handle
        .tx
        .send(crate::worker::WorkerMessage::SharedWorkerConnect(0))
        .expect("connect shared worker");
    loop {
        let msg = timeout(TIMEOUT, handle.recv())
            .await
            .expect("timed out")
            .expect("channel closed");
        if matches!(msg, WorkerToParentMessage::SharedWorkerClosed) {
            break;
        }
    }
}

#[tokio::test]
async fn worker_module_named_imports_read_live_exports() {
    ensure_v8();
    let dep_url = worker_data_url(
        r#"
        export let counter = 1;
        export { counter as default };
        export function bump() { counter += 1; return counter; }
        export function setCounter(value) { counter = value; }
        "#,
    );
    let dep_specifier = serde_json::to_string(&dep_url).expect("data URL should serialize");
    let mut handle = spawn_worker_with_request_client_and_kind(
        format!(
            r#"
        import current, {{ counter, bump, setCounter }} from {dep_specifier};
        function readCounter() {{ return counter; }}
        const before = counter;
        const defaultBefore = current;
        const bumpReturn = bump();
        const afterBump = readCounter();
        setCounter(9);
        const afterSet = counter;
        const defaultAfterSet = current;
        const secondBump = bump();
        const afterSecondBump = readCounter();
        postMessage({{
            before,
            defaultBefore,
            bumpReturn,
            afterBump,
            afterSet,
            defaultAfterSet,
            secondBump,
            afterSecondBump,
        }});
        close();
        "#
        ),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"before":1,"defaultBefore":1,"bumpReturn":2,"afterBump":2,"afterSet":9,"defaultAfterSet":9,"secondBump":10,"afterSecondBump":10}"#
    );
}

#[tokio::test]
async fn worker_module_no_import_source_runs_in_strict_mode() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        export const answer = 42;
        const topLevelThisUndefined = this === undefined;
        function sloppyThis() { return this; }
        let implicitGlobalError = "none";
        try {
            accidentalWorkerGlobal = 7;
        } catch (error) {
            implicitGlobalError = error && error.name;
        }
        postMessage({
            answer,
            topLevelThisUndefined,
            functionThisUndefined: sloppyThis() === undefined,
            implicitGlobalError,
            leakedGlobal: Object.prototype.hasOwnProperty.call(self, "accidentalWorkerGlobal"),
        });
        close();
        "#
        .into(),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"answer":42,"topLevelThisUndefined":true,"functionThisUndefined":true,"implicitGlobalError":"ReferenceError","leakedGlobal":false}"#
    );
}

fn service_worker_module_options(source: String, script_url: String) -> WorkerSpawnOptions {
    let scope_url = url::Url::parse(&script_url).unwrap().join(".").unwrap();
    WorkerSpawnOptions::new(source, script_url)
        .with_script_kind(WorkerScriptKind::Module)
        .with_global_kind(super::super::WorkerGlobalKind::Service {
            registration_id: ServiceWorkerRegistrationId::from_u64_for_test(1),
            version_id: ServiceWorkerVersionId::from_u64_for_test(1),
            scope_url,
        })
}

async fn expect_service_worker_async_module_error(handle: &mut WorkerHandle) {
    loop {
        match timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap() {
            WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. } => {}
            WorkerToParentMessage::Error {
                message,
                phase,
                event_kind,
                ..
            } => {
                assert!(message.contains("TypeError"), "{message}");
                assert!(message.contains("Top-level await"), "{message}");
                assert_eq!(phase, WorkerErrorPhase::Bootstrap);
                assert_eq!(event_kind, WorkerParentErrorEventKind::Event);
                return;
            }
            // Console or skipWaiting would mean module evaluation had begun.
            other => panic!("expected async module rejection before execution, got {other:?}"),
        }
    }
}

#[tokio::test]
async fn service_worker_module_top_level_await_is_rejected_before_execution() {
    ensure_v8();
    for source in [
        "await Promise.resolve();",
        "await new Promise(() => {});",
        "await Promise.reject(new Error('rejected'));",
        "if (false) { await Promise.resolve(); }",
        "for await (const item of []) {}",
    ] {
        let mut handle = spawn_test_worker_with_options(service_worker_module_options(
            format!("console.log('unexpected execution'); {source} skipWaiting();"),
            "https://example.test/worker/sw.js".into(),
        ));
        expect_service_worker_async_module_error(&mut handle).await;
        handle.terminate_and_join();
    }
}

#[tokio::test]
async fn service_worker_module_rejects_async_dependencies_before_execution() {
    ensure_v8();
    for cycle in [false, true] {
        let cycle_import = if cycle { "import './sw.js';" } else { "" };
        let (base_url, server) = spawn_path_response_http_server(vec![
            (
                "/worker/middle.js",
                "HTTP/1.1 200 OK",
                "text/javascript",
                "import './dep.js'; console.log('unexpected middle execution');".into(),
                Duration::ZERO,
            ),
            (
                "/worker/dep.js",
                "HTTP/1.1 200 OK",
                "text/javascript",
                format!("{cycle_import} console.log('unexpected dependency execution'); await 0;"),
                Duration::ZERO,
            ),
        ])
        .await;
        let mut handle = spawn_test_worker_with_options(service_worker_module_options(
            "import './middle.js'; console.log('unexpected root execution'); skipWaiting();".into(),
            format!("{base_url}/worker/sw.js"),
        ));
        expect_service_worker_async_module_error(&mut handle).await;
        handle.terminate_and_join();
        server.await.unwrap();
    }
}

#[tokio::test]
async fn service_worker_module_checks_only_wasm_evaluation_dependencies() {
    ensure_v8();
    for source_only in [false, true] {
        let mut responses = vec![(
            "/worker/worker.wasm",
            "HTTP/1.1 200 OK",
            "application/wasm",
            worker_wasm_import_pm_body(),
            Duration::ZERO,
        )];
        if !source_only {
            responses.push((
                "/worker/worker-helper.js",
                "HTTP/1.1 200 OK",
                "text/javascript",
                "console.log('unexpected helper execution'); export function pm() {} await 0;"
                    .into(),
                Duration::ZERO,
            ));
        }
        let (base_url, server) = spawn_path_response_http_server(responses).await;
        let source = if source_only {
            "import source wasm from './worker.wasm'; console.log(wasm instanceof WebAssembly.Module);"
        } else {
            "import './worker.wasm'; console.log('unexpected root execution'); skipWaiting();"
        };
        let (bootstrap_tx, mut bootstrap_rx) = tokio::sync::mpsc::unbounded_channel();
        let mut handle = spawn_test_worker_with_options(
            service_worker_module_options(source.into(), format!("{base_url}/worker/sw.js"))
                .with_bootstrap_completion_sender(bootstrap_tx),
        );
        if source_only {
            let bootstrap = timeout(TIMEOUT, bootstrap_rx.recv())
                .await
                .unwrap()
                .unwrap();
            assert!(bootstrap.result.is_ok(), "{:?}", bootstrap.result);
            loop {
                match timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap() {
                    WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. } => {}
                    WorkerToParentMessage::Console(message) => {
                        assert_eq!(message.message, "log: true");
                        break;
                    }
                    other => panic!("expected source import without evaluation, got {other:?}"),
                }
            }
        } else {
            expect_service_worker_async_module_error(&mut handle).await;
        }
        handle.terminate_and_join();
        server.await.unwrap();
    }
}

#[tokio::test]
async fn service_worker_module_allows_await_inside_async_functions() {
    ensure_v8();
    for source in [
        "async function run() { await Promise.resolve(); }",
        "(async () => { await Promise.resolve(); })();",
        "const text = 'await Promise.resolve()'; /* await 0 */",
    ] {
        let (bootstrap_tx, mut bootstrap_rx) = tokio::sync::mpsc::unbounded_channel();
        let mut handle = spawn_test_worker_with_options(
            service_worker_module_options(
                format!("{source} console.log('ready');"),
                "https://example.test/worker/sw.js".into(),
            )
            .with_bootstrap_completion_sender(bootstrap_tx),
        );
        let bootstrap = timeout(TIMEOUT, bootstrap_rx.recv())
            .await
            .unwrap()
            .unwrap();
        assert!(bootstrap.result.is_ok(), "{:?}", bootstrap.result);
        match timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap() {
            WorkerToParentMessage::Console(message) => assert_eq!(message.message, "log: ready"),
            other => panic!("expected successful module execution, got {other:?}"),
        }
        handle.terminate_and_join();
    }
}

#[tokio::test]
async fn worker_module_top_level_await_fulfillment_completes_startup() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        await new Promise(resolve => setTimeout(resolve, 0));
        postMessage("tla-fulfilled");
        "#
        .into(),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#""tla-fulfilled""#);
}

#[tokio::test]
async fn worker_module_top_level_await_rejection_reports_parent_error() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        await Promise.reject(new Error("worker tla rejected"));
        postMessage("unexpected");
        "#
        .into(),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Error { message, .. } => {
            assert!(message.contains("worker tla rejected"), "{message}");
        }
        other => panic!("expected Error, got {other:?}"),
    }
}

#[tokio::test]
async fn worker_module_dynamic_import_data_url_resolves_namespace() {
    ensure_v8();
    let dep_url = worker_data_url(
        r#"
        export const answer = 42;
        export default "dynamic-default";
        "#,
    );
    let dep_specifier = serde_json::to_string(&dep_url).expect("data URL should serialize");
    let mut handle = spawn_worker_with_request_client_and_kind(
        format!(
            r#"
        const dep = await import({dep_specifier});
        postMessage({{
            answer: dep.answer,
            defaultValue: dep.default,
            resolved: import.meta.resolve({dep_specifier}),
        }});
        close();
        "#
        ),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        format!(r#"{{"answer":42,"defaultValue":"dynamic-default","resolved":{dep_specifier}}}"#)
    );
}

#[tokio::test]
async fn worker_dynamic_import_report_only_csp_dispatches_without_blocking() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/dynamic.js",
        "HTTP/1.1 200 OK",
        "text/javascript; charset=utf-8",
        "export const value = 42;".to_owned(),
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("dynamic report-only loader");
    let script_url = format!("{base_url}/worker/main.js");
    let dep_url = format!("{base_url}/worker/dynamic.js");
    let dep_specifier = serde_json::to_string("./dynamic.js").expect("specifier should serialize");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            format!(
                r#"
        const events = [];
        addEventListener("securitypolicyviolation", event => {{
            events.push({{
                type: event.type,
                effectiveDirective: event.effectiveDirective,
                violatedDirective: event.violatedDirective,
                blockedURI: event.blockedURI,
                documentURI: event.documentURI,
                originalPolicy: event.originalPolicy,
                disposition: event.disposition,
                instance: event instanceof SecurityPolicyViolationEvent
            }});
        }});
        const mod = await import({dep_specifier});
        postMessage({{ events, value: mod.value }});
        close();
        "#
            ),
            script_url.clone(),
        )
        .with_request_client(loader)
        .with_script_kind(WorkerScriptKind::Module)
        .with_content_security_report_only_policies(vec!["script-src 'none'".into()]),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        format!(
            r#"{{"events":[{{"type":"securitypolicyviolation","effectiveDirective":"script-src-elem","violatedDirective":"script-src-elem","blockedURI":"{dep_url}","documentURI":"{script_url}","originalPolicy":"script-src 'none'","disposition":"report","instance":true}}],"value":42}}"#
        )
    );
    server
        .await
        .expect("dynamic import report-only server should finish");
}

#[tokio::test]
async fn worker_dynamic_import_sibling_dependencies_fetch_in_parallel() {
    ensure_v8();
    let listener = TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind worker dynamic sibling server");
    let addr = listener.local_addr().expect("worker dynamic sibling addr");
    let base_url = format!("http://{addr}");
    let server = tokio::spawn(async move {
        let (mut entry_stream, _) = listener
            .accept()
            .await
            .expect("accept worker dynamic entry request");
        let entry_request = read_http_request_head(&mut entry_stream)
            .await
            .expect("read worker dynamic entry request");
        let entry_path = entry_request
            .lines()
            .next()
            .and_then(|line| line.split_whitespace().nth(1))
            .expect("worker dynamic entry request path");
        assert_eq!(entry_path, "/worker/entry.js");
        let entry_body = [
            "import { a } from './a.js';",
            "import { b } from './b.js';",
            "export const value = `${a}${b}`;",
        ]
        .join("\n");
        let entry_response = format!(
            "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
            entry_body.len(),
            entry_body
        );
        entry_stream
            .write_all(entry_response.as_bytes())
            .await
            .expect("write worker dynamic entry response");

        let mut first_stream = None;
        let mut first_path = String::new();
        let mut second_stream = None;
        let mut second_path = String::new();
        for _ in 0..2 {
            let (mut stream, _) = listener
                .accept()
                .await
                .expect("accept worker dynamic sibling request");
            let request = read_http_request_head(&mut stream)
                .await
                .expect("read worker dynamic sibling request");
            let path = request
                .lines()
                .next()
                .and_then(|line| line.split_whitespace().nth(1))
                .expect("worker dynamic sibling request path")
                .to_owned();
            if first_stream.is_none() {
                first_path = path;
                first_stream = Some(stream);
            } else {
                second_path = path;
                second_stream = Some(stream);
            }
        }
        let mut paths = vec![first_path.clone(), second_path.clone()];
        paths.sort();
        assert_eq!(paths, vec!["/worker/a.js", "/worker/b.js"]);
        for (path, stream) in [
            (
                first_path,
                first_stream.expect("first dynamic sibling stream"),
            ),
            (
                second_path,
                second_stream.expect("second dynamic sibling stream"),
            ),
        ] {
            let body = match path.as_str() {
                "/worker/a.js" => "export const a = 'a';",
                "/worker/b.js" => "export const b = 'b';",
                other => panic!("unexpected worker dynamic sibling path: {other}"),
            };
            let response = format!(
                "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
                body.len(),
                body
            );
            let mut stream = stream;
            stream
                .write_all(response.as_bytes())
                .await
                .expect("write worker dynamic sibling response");
        }
    });

    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker dynamic sibling loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import("./entry.js").then((mod) => {
            postMessage(mod.value);
            close();
        }, (error) => {
            postMessage({ error: error && error.message ? error.message : String(error) });
            close();
        });
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Classic,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#""ab""#);
    server
        .await
        .expect("worker dynamic sibling server should finish");
}

#[tokio::test]
async fn worker_dynamic_import_fetches_completed_sibling_descendants_before_slow_sibling_finishes()
{
    ensure_v8();
    let listener = TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind worker dynamic descendant server");
    let addr = listener
        .local_addr()
        .expect("worker dynamic descendant addr");
    let base_url = format!("http://{addr}");
    let server = tokio::spawn(async move {
        let (mut entry_stream, _) = listener
            .accept()
            .await
            .expect("accept worker dynamic entry request");
        let entry_request = read_http_request_head(&mut entry_stream)
            .await
            .expect("read worker dynamic entry request");
        let entry_path = entry_request
            .lines()
            .next()
            .and_then(|line| line.split_whitespace().nth(1))
            .expect("worker dynamic entry request path");
        assert_eq!(entry_path, "/worker/entry.js");
        let entry_body = [
            "import { a } from './a.js';",
            "import { b } from './b.js';",
            "export const value = `${a}${b}`;",
        ]
        .join("\n");
        let entry_response = format!(
            "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
            entry_body.len(),
            entry_body
        );
        entry_stream
            .write_all(entry_response.as_bytes())
            .await
            .expect("write worker dynamic entry response");

        let mut first_stream = None;
        let mut first_path = String::new();
        let mut second_stream = None;
        let mut second_path = String::new();
        for _ in 0..2 {
            let (mut stream, _) = listener
                .accept()
                .await
                .expect("accept worker dynamic sibling request");
            let request = read_http_request_head(&mut stream)
                .await
                .expect("read worker dynamic sibling request");
            let path = request
                .lines()
                .next()
                .and_then(|line| line.split_whitespace().nth(1))
                .expect("worker dynamic sibling request path")
                .to_owned();
            if first_stream.is_none() {
                first_path = path;
                first_stream = Some(stream);
            } else {
                second_path = path;
                second_stream = Some(stream);
            }
        }

        let (mut a_stream, mut b_stream) = match (
            first_path.as_str(),
            first_stream.expect("first dynamic sibling stream"),
            second_path.as_str(),
            second_stream.expect("second dynamic sibling stream"),
        ) {
            ("/worker/a.js", a_stream, "/worker/b.js", b_stream)
            | ("/worker/b.js", b_stream, "/worker/a.js", a_stream) => (a_stream, b_stream),
            (first, _, second, _) => panic!("unexpected dynamic sibling paths: {first}, {second}"),
        };

        let a_body = "import { child } from './a-child.js'; export const a = `a${child}`;";
        let a_response = format!(
            "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
            a_body.len(),
            a_body
        );
        a_stream
            .write_all(a_response.as_bytes())
            .await
            .expect("write worker dynamic a response");

        let (mut child_stream, _) = listener
            .accept()
            .await
            .expect("accept worker dynamic child request before b finishes");
        let child_request = read_http_request_head(&mut child_stream)
            .await
            .expect("read worker dynamic child request");
        let child_path = child_request
            .lines()
            .next()
            .and_then(|line| line.split_whitespace().nth(1))
            .expect("worker dynamic child request path");
        assert_eq!(
            child_path, "/worker/a-child.js",
            "completed dynamic sibling descendants should start before slow sibling completes"
        );

        let child_body = "export const child = 'child';";
        let child_response = format!(
            "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
            child_body.len(),
            child_body
        );
        child_stream
            .write_all(child_response.as_bytes())
            .await
            .expect("write worker dynamic child response");

        let b_body = "export const b = 'b';";
        let b_response = format!(
            "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
            b_body.len(),
            b_body
        );
        b_stream
            .write_all(b_response.as_bytes())
            .await
            .expect("write worker dynamic b response");
    });

    let loader = ResourceRequestClient::new(&FetchConfig::default())
        .expect("worker dynamic descendant loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import("./entry.js").then((mod) => {
            postMessage(mod.value);
            close();
        }, (error) => {
            postMessage({ error: error && error.message ? error.message : String(error) });
            close();
        });
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Classic,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#""achildb""#);
    server
        .await
        .expect("worker dynamic descendant server should finish");
}

#[tokio::test]
async fn worker_classic_dynamic_wasm_import_fetches_namespace() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/exports.wasm",
        "HTTP/1.1 200 OK",
        "application/wasm",
        worker_wasm_exported_names_body(),
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("classic worker wasm loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import("./exports.wasm").then((mod) => {
            const instance = WebAssembly.namespaceInstance(mod);
            postMessage({
                funcType: typeof mod.func,
                glob: mod.glob,
                memory: mod.mem instanceof WebAssembly.Memory,
                table: mod.tab instanceof WebAssembly.Table,
                instance: instance instanceof WebAssembly.Instance,
            });
            close();
        }, (error) => {
            postMessage({
                error: error && error.message ? error.message : String(error),
            });
            close();
        });
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Classic,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"funcType":"function","glob":0,"memory":true,"table":true,"instance":true}"#
    );
    server
        .await
        .expect("classic worker dynamic wasm server should finish");
}

#[tokio::test]
async fn worker_classic_dynamic_import_preserves_instantiate_exception() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![
        (
            "/worker/bad.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            r#"export { missing } from "./empty.js";"#.to_owned(),
            Duration::ZERO,
        ),
        (
            "/worker/empty.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            "export const present = 1;".to_owned(),
            Duration::ZERO,
        ),
    ])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("classic worker module loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import("./bad.js").then(() => {
            postMessage("unexpected");
            close();
        }, (error) => {
            postMessage({
                name: error && error.name,
                syntax: error instanceof SyntaxError,
            });
            close();
        });
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Classic,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"name":"SyntaxError","syntax":true}"#
    );
    server
        .await
        .expect("classic worker dynamic import syntax server should finish");
}

#[tokio::test]
async fn worker_module_dynamic_import_rejection_can_be_caught() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        try {
            await import("http://[::1");
            postMessage("unexpected");
        } catch (error) {
            postMessage({
                name: error && error.name,
                messageIncludesResolve: String(error && error.message).includes("Failed to resolve"),
            });
        }
        close();
        "#
        .into(),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"name":"TypeError","messageIncludesResolve":true}"#
    );
}

#[tokio::test]
async fn worker_module_dynamic_import_rejects_invalid_attribute_key() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        try {
            await import("data:text/javascript,export%20default%201", { with: { foo: "bar" } });
            postMessage("unexpected");
        } catch (error) {
            postMessage({
                name: error && error.name,
                type: error instanceof TypeError,
                message: String(error && error.message),
            });
        }
        close();
        "#
        .into(),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"name":"TypeError","type":true,"message":"Invalid attribute key \"foo\"."}"#
    );
}

#[tokio::test]
async fn worker_module_dynamic_import_source_rejects_without_hanging() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        const target = "data:text/javascript,export%20default%201";
        try {
            await import.source(target);
            postMessage("unexpected");
        } catch (error) {
            postMessage({
                name: error && error.name,
                messageIncludesSourcePhase: String(error && error.message).includes("source-phase"),
            });
        }
        close();
        "#
        .into(),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"name":"SyntaxError","messageIncludesSourcePhase":true}"#
    );
}

#[tokio::test]
async fn worker_module_static_wasm_import_executes_start_function() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![
        (
            "/worker/worker.wasm",
            "HTTP/1.1 200 OK",
            "application/wasm",
            worker_wasm_import_pm_body(),
            Duration::ZERO,
        ),
        (
            "/worker/worker-helper.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            "export function pm(value) { postMessage(value); }".to_owned(),
            Duration::ZERO,
        ),
    ])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker wasm module loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import "./worker.wasm";
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), "42");
    server
        .await
        .expect("worker wasm import server should finish");
}

#[tokio::test]
async fn worker_module_static_wasm_import_preserves_helper_postmessage_payload() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![
        (
            "/worker/worker.wasm",
            "HTTP/1.1 200 OK",
            "application/wasm",
            worker_wasm_import_pm_body(),
            Duration::ZERO,
        ),
        (
            "/worker/worker-helper.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            r#"
            export function pm(value) {
                postMessage({ value, checks: pm.checks });
            }
            "#
            .to_owned(),
            Duration::ZERO,
        ),
    ])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker wasm module loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import "./worker.wasm";
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#"{"value":42}"#);
    server
        .await
        .expect("worker wasm import helper payload server should finish");
}

#[tokio::test]
async fn worker_module_static_wasm_import_preserves_v8_compile_exception() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/invalid.wasm",
        "HTTP/1.1 200 OK",
        "application/wasm",
        worker_invalid_module_wasm_body(),
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker invalid wasm loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import "./invalid.wasm";
        postMessage("unexpected");
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    let WorkerToParentMessage::Error { message, .. } = msg else {
        panic!("expected worker module compile error, got {msg:?}");
    };
    assert!(message.contains("CompileError"), "{message}");
    assert!(message.contains("WasmModuleObject::Compile"), "{message}");
    assert!(message.contains("expected i32, got i64"), "{message}");
    assert!(
        !message.contains("unknown wasm compile exception"),
        "{message}"
    );
    server
        .await
        .expect("worker invalid wasm server should finish");
}

#[tokio::test]
async fn worker_module_wasm_js_cycle_is_rejected_without_recursive_evaluate() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![
        (
            "/worker/cycle.wasm",
            "HTTP/1.1 200 OK",
            "application/wasm",
            worker_wasm_import_cycle_js_body(),
            Duration::ZERO,
        ),
        (
            "/worker/cycle.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            r#"
            import * as wasm from "./cycle.wasm";
            export function f() {
                return wasm.run();
            }
            "#
            .to_owned(),
            Duration::ZERO,
        ),
    ])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker wasm cycle loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import "./cycle.wasm";
        postMessage("unexpected");
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    let WorkerToParentMessage::Error { message, .. } = msg else {
        panic!("expected worker wasm cycle error, got {msg:?}");
    };
    assert!(
        message.contains(
            "cyclic worker WebAssembly module evaluation through JavaScript dependencies is not supported yet"
        ),
        "{message}"
    );
    server
        .await
        .expect("worker wasm cycle server should finish");
}

#[tokio::test]
#[ignore = "requires worker wasm module records to participate in the V8 module evaluation SCC"]
async fn worker_module_wasm_js_cycle_evaluates_js_dependency_initializers() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![
        (
            "/worker/cycle.wasm",
            "HTTP/1.1 200 OK",
            "application/wasm",
            worker_wasm_import_cycle_js_body(),
            Duration::ZERO,
        ),
        (
            "/worker/cycle.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            r#"
            import * as wasm from "./cycle.wasm";
            globalThis.__wasmCycleDependencyInitialized = true;
            globalThis.__wasmCycleCallCount = 0;
            export function f() {
                globalThis.__wasmCycleCallCount++;
            }
            globalThis.__wasmCycleNamespaceHasRun = typeof wasm.run === "function";
            "#
            .to_owned(),
            Duration::ZERO,
        ),
    ])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker wasm cycle loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import * as wasm from "./cycle.wasm";
        wasm.run();
        postMessage({
            dependencyInitialized: globalThis.__wasmCycleDependencyInitialized,
            callCount: globalThis.__wasmCycleCallCount,
            namespaceHasRun: globalThis.__wasmCycleNamespaceHasRun
        });
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    assert_eq!(
        recv_post_json(&mut handle).await,
        r#"{"dependencyInitialized":true,"callCount":1,"namespaceHasRun":true}"#
    );
    server
        .await
        .expect("worker wasm cycle acceptance server should finish");
}

#[tokio::test]
async fn worker_module_root_wasm_executes_start_function() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/worker-helper.js",
        "HTTP/1.1 200 OK",
        "application/javascript",
        "export function pm(value) { postMessage(value); }".to_owned(),
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker root wasm loader");
    let mut handle = spawn_worker_with_source_and_kind_and_network_policy(
        WorkerScriptSource::binary(WORKER_WASM_IMPORT_PM.to_vec()),
        format!("{base_url}/worker/worker.wasm"),
        loader,
        WorkerScriptKind::Module,
        WorkerNetworkPolicy::default(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), "42");
    server
        .await
        .expect("worker root wasm helper server should finish");
}

#[tokio::test]
async fn worker_module_source_phase_wasm_import_reuses_module_record_without_evaluation() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![
        (
            "/worker/worker.wasm",
            "HTTP/1.1 200 OK",
            "application/wasm",
            worker_wasm_import_pm_body(),
            Duration::ZERO,
        ),
        (
            "/worker/worker-helper.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            r#"
            export function pm(value) {
                postMessage({
                    value,
                    sameSourceObject: pm.sameSourceObject,
                    abstractModuleSourceName: pm.abstractModuleSourceName,
                    abstractModuleSourceHidden: pm.abstractModuleSourceHidden,
                    moduleConstructorExtendsAbstract: pm.moduleConstructorExtendsAbstract,
                    modulePrototypeExtendsAbstract: pm.modulePrototypeExtendsAbstract,
                    staticSourceIsAbstractModuleSource: pm.staticSourceIsAbstractModuleSource
                });
            }
            "#
            .to_owned(),
            Duration::ZERO,
        ),
    ])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker wasm source loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import source staticSource from "./worker.wasm";
        import { pm } from "./worker-helper.js";

        const dynamicSource = await import.source("./worker.wasm");
        const AbstractModuleSource = Object.getPrototypeOf(WebAssembly.Module);
        const AbstractModuleSourceProto =
            Object.getPrototypeOf(WebAssembly.Module.prototype);
        pm.sameSourceObject = dynamicSource === staticSource;
        pm.abstractModuleSourceName = AbstractModuleSource.name;
        pm.abstractModuleSourceHidden = !("AbstractModuleSource" in globalThis);
        pm.moduleConstructorExtendsAbstract = AbstractModuleSource !== Function;
        pm.modulePrototypeExtendsAbstract =
            AbstractModuleSource.prototype === AbstractModuleSourceProto;
        pm.staticSourceIsAbstractModuleSource =
            staticSource instanceof AbstractModuleSource;
        await WebAssembly.instantiate(staticSource, {
            "./worker-helper.js": { pm },
        });
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"value":42,"sameSourceObject":true,"abstractModuleSourceName":"AbstractModuleSource","abstractModuleSourceHidden":true,"moduleConstructorExtendsAbstract":true,"modulePrototypeExtendsAbstract":true,"staticSourceIsAbstractModuleSource":true}"#
    );
    server
        .await
        .expect("worker wasm source server should finish");
}

#[tokio::test]
async fn worker_module_wasm_namespace_instance_returns_cached_instance() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![
        (
            "/worker/exports.wasm",
            "HTTP/1.1 200 OK",
            "application/wasm",
            worker_wasm_exported_names_body(),
            Duration::ZERO,
        ),
        (
            "/worker/js-module.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            "export const answer = 42;".to_owned(),
            Duration::ZERO,
        ),
    ])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker wasm namespace loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import * as staticNamespace from "./exports.wasm";

        try {
            const staticInstance = WebAssembly.namespaceInstance(staticNamespace);
            const dynamicNamespace = await import("./exports.wasm");
            const dynamicInstance =
                WebAssembly.namespaceInstance(dynamicNamespace);
            const dynamicNamespace2 = await import("./exports.wasm");
            const dynamicInstance2 =
                WebAssembly.namespaceInstance(dynamicNamespace2);
            const jsNamespace = await import("./js-module.js");

            let plainObjectRejected = false;
            let jsNamespaceRejected = false;
            try {
                WebAssembly.namespaceInstance({});
            } catch (error) {
                plainObjectRejected = error instanceof TypeError;
            }
            try {
                WebAssembly.namespaceInstance(jsNamespace);
            } catch (error) {
                jsNamespaceRejected = error instanceof TypeError;
            }

            postMessage({
                staticInstance: staticInstance instanceof WebAssembly.Instance,
                shared:
                    staticInstance === dynamicInstance &&
                    dynamicInstance === dynamicInstance2,
                funcType: typeof dynamicInstance.exports.func,
                plainObjectRejected,
                jsNamespaceRejected,
            });
        } catch (error) {
            postMessage({
                error: error && error.message ? error.message : String(error),
            });
        }
        close();
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"staticInstance":true,"shared":true,"funcType":"function","plainObjectRejected":true,"jsNamespaceRejected":true}"#
    );
    server
        .await
        .expect("worker wasm namespace server should finish");
}

#[tokio::test]
async fn worker_module_static_and_dynamic_wasm_import_share_namespace() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/exports.wasm",
        "HTTP/1.1 200 OK",
        "application/wasm",
        worker_wasm_exported_names_body(),
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker wasm namespace loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import * as staticNamespace from "./exports.wasm";

        const dynamicNamespace = await import("./exports.wasm");
        postMessage({
            sameNamespace: dynamicNamespace === staticNamespace,
            sameInstance:
                WebAssembly.namespaceInstance(dynamicNamespace) ===
                WebAssembly.namespaceInstance(staticNamespace),
        });
        close();
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"sameNamespace":true,"sameInstance":true}"#
    );
    server
        .await
        .expect("worker wasm namespace identity server should finish");
}

#[tokio::test]
async fn worker_module_mutable_wasm_global_initial_value_is_unwrapped() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/mutable-global.wasm",
        "HTTP/1.1 200 OK",
        "application/wasm",
        worker_mutable_global_wasm_body(),
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker mutable wasm loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import * as mod from "./mutable-global.wasm";
        import { glob as namedGlob } from "./mutable-global.wasm";

        postMessage({
            type: typeof mod.glob,
            isGlobal: mod.glob instanceof WebAssembly.Global,
            initial: mod.glob,
            namedType: typeof namedGlob,
            namedIsGlobal: namedGlob instanceof WebAssembly.Global,
            namedInitial: namedGlob,
        });
        close();
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"type":"number","isGlobal":false,"initial":0,"namedType":"number","namedIsGlobal":false,"namedInitial":0}"#
    );
    server
        .await
        .expect("worker mutable wasm server should finish");
}

#[tokio::test]
async fn worker_module_wasm_global_unwrap_uses_original_value_getter() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/mutable-global.wasm",
        "HTTP/1.1 200 OK",
        "application/wasm",
        worker_mutable_global_wasm_body(),
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker mutable wasm loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        const descriptor =
            Object.getOwnPropertyDescriptor(WebAssembly.Global.prototype, "value");
        Object.defineProperty(WebAssembly.Global.prototype, "value", {
            configurable: true,
            get() {
                throw new Error("patched WebAssembly.Global getter was used");
            },
            set: descriptor.set,
        });

        try {
            const mod = await import("./mutable-global.wasm");
            postMessage({
                type: typeof mod.glob,
                isGlobal: mod.glob instanceof WebAssembly.Global,
                value: mod.glob,
            });
        } catch (error) {
            postMessage({
                error: error && error.message ? error.message : String(error),
            });
        }
        close();
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"type":"number","isGlobal":false,"value":0}"#
    );
    server
        .await
        .expect("worker mutable wasm getter server should finish");
}

#[tokio::test]
async fn worker_module_static_wasm_global_unwrap_uses_original_value_getter() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![
        (
            "/worker/mutable-global.wasm",
            "HTTP/1.1 200 OK",
            "application/wasm",
            worker_mutable_global_wasm_body(),
            Duration::ZERO,
        ),
        (
            "/worker/static-check.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            r#"
            import * as mod from "./mutable-global.wasm";
            import { glob as namedGlob } from "./mutable-global.wasm";

            export const result = {
                type: typeof mod.glob,
                isGlobal: mod.glob instanceof WebAssembly.Global,
                value: mod.glob,
                namedType: typeof namedGlob,
                namedIsGlobal: namedGlob instanceof WebAssembly.Global,
                namedValue: namedGlob,
            };
            "#
            .to_owned(),
            Duration::ZERO,
        ),
    ])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker mutable wasm loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        const descriptor =
            Object.getOwnPropertyDescriptor(WebAssembly.Global.prototype, "value");
        Object.defineProperty(WebAssembly.Global.prototype, "value", {
            configurable: true,
            get() {
                throw new Error("patched WebAssembly.Global getter was used");
            },
            set: descriptor.set,
        });

        try {
            const { result } = await import("./static-check.js");
            postMessage(result);
        } catch (error) {
            postMessage({
                error: error && error.message ? error.message : String(error),
            });
        }
        close();
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"type":"number","isGlobal":false,"value":0,"namedType":"number","namedIsGlobal":false,"namedValue":0}"#
    );
    server
        .await
        .expect("worker static wasm getter server should finish");
}

#[tokio::test]
#[ignore = "requires V8 wasm-aware module binding loads for mutable global exports"]
async fn worker_module_mutable_wasm_global_export_is_live_binding() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/mutable-global-live.wasm",
        "HTTP/1.1 200 OK",
        "application/wasm",
        worker_mutable_global_live_wasm_body(),
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker mutable wasm loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import * as mod from "./mutable-global-live.wasm";
        import {
            getGlobal,
            mutableValue,
            setGlobal,
        } from "./mutable-global-live.wasm";

        const initialNamespace = mod.mutableValue;
        const initialNamed = mutableValue;
        const initialGetter = getGlobal();
        setGlobal(555);
        postMessage({
            initialNamespace,
            initialNamed,
            initialGetter,
            getterAfterSet: getGlobal(),
            namespaceAfterSet: mod.mutableValue,
            namedAfterSet: mutableValue,
            type: typeof mod.mutableValue,
            isGlobal: mod.mutableValue instanceof WebAssembly.Global,
        });
        close();
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"initialNamespace":42,"initialNamed":42,"initialGetter":42,"getterAfterSet":555,"namespaceAfterSet":555,"namedAfterSet":555,"type":"number","isGlobal":false}"#
    );
    server
        .await
        .expect("worker mutable wasm live binding server should finish");
}

#[tokio::test]
#[ignore = "requires V8 wasm-aware module binding loads for dependency mutable global re-exports"]
async fn worker_module_mutable_wasm_global_dep_reexport_is_live_binding() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![
        (
            "/worker/mutable-global-export.wasm",
            "HTTP/1.1 200 OK",
            "application/wasm",
            worker_mutable_global_live_wasm_body(),
            Duration::ZERO,
        ),
        (
            "/worker/mutable-global-reexport.wasm",
            "HTTP/1.1 200 OK",
            "application/wasm",
            worker_mutable_global_reexport_wasm_body(),
            Duration::ZERO,
        ),
    ])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker mutable wasm loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import * as mod from "./mutable-global-reexport.wasm";
        import {
            getImportedGlobal,
            reexportedMutableValue,
            setImportedGlobal,
        } from "./mutable-global-reexport.wasm";

        const initialNamespace = mod.reexportedMutableValue;
        const initialNamed = reexportedMutableValue;
        const initialGetter = getImportedGlobal();
        setImportedGlobal(777);
        postMessage({
            initialNamespace,
            initialNamed,
            initialGetter,
            getterAfterSet: getImportedGlobal(),
            namespaceAfterSet: mod.reexportedMutableValue,
            namedAfterSet: reexportedMutableValue,
            type: typeof mod.reexportedMutableValue,
            isGlobal: mod.reexportedMutableValue instanceof WebAssembly.Global,
        });
        close();
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"initialNamespace":42,"initialNamed":42,"initialGetter":42,"getterAfterSet":777,"namespaceAfterSet":777,"namedAfterSet":777,"type":"number","isGlobal":false}"#
    );
    server
        .await
        .expect("worker mutable wasm re-export live binding server should finish");
}

#[tokio::test]
async fn worker_module_dynamic_import_fetches_http_dependency_against_module_url() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/dep.js",
        "HTTP/1.1 200 OK",
        "application/javascript",
        r#"
        export const answer = 42;
        export const metaUrl = import.meta.url;
        "#
        .to_owned(),
        Duration::ZERO,
    )])
    .await;
    let loader = ResourceRequestClient::new(&FetchConfig::default())
        .expect("worker module dependency loader");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        const dep = await import("./dep.js");
        postMessage({
            answer: dep.answer,
            metaPath: new URL(dep.metaUrl).pathname,
        });
        close();
        "#
        .into(),
        format!("{base_url}/worker/main.js"),
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"answer":42,"metaPath":"/worker/dep.js"}"#
    );
    server
        .await
        .expect("dynamic import dependency server should finish");
}

#[tokio::test]
async fn worker_module_dynamic_import_fetches_json_with_import_attributes() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/data.json",
        "HTTP/1.1 200 OK",
        "application/json; charset=utf-8",
        r#"{"answer":42,"label":"json-dynamic"}"#.to_owned(),
        Duration::ZERO,
    )])
    .await;
    let loader = ResourceRequestClient::new(&FetchConfig::default()).expect("worker module loader");
    let script_url = format!("{base_url}/worker/main.js");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        const first = await import("./data.json", { with: { type: "json" } });
        const second = await import("./data.json", { with: { type: "json" } });
        postMessage({
            answer: first.default.answer,
            label: first.default.label,
            sameNamespace: first === second,
            sameDefault: first.default === second.default,
        });
        close();
        "#
        .into(),
        script_url,
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"answer":42,"label":"json-dynamic","sameNamespace":true,"sameDefault":true}"#
    );
    server
        .await
        .expect("dynamic JSON import server should finish");
}

#[tokio::test]
async fn worker_module_json_import_uses_json_fetch_destination() {
    ensure_v8();
    let listener = TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind worker JSON module destination server");
    let addr = listener
        .local_addr()
        .expect("worker JSON module destination addr");
    let base_url = format!("http://{addr}");
    let (request_tx, request_rx) = tokio::sync::oneshot::channel();
    let server = tokio::spawn(async move {
        let (mut stream, _) = listener
            .accept()
            .await
            .expect("accept worker JSON module request");
        let request = read_http_request_head(&mut stream)
            .await
            .expect("read worker JSON module request");
        let body = r#"{"answer":42}"#;
        let response = format!(
            "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
            body.len(),
            body
        );
        stream
            .write_all(response.as_bytes())
            .await
            .expect("write worker JSON module response");
        let _ = request_tx.send(request);
    });
    let loader = ResourceRequestClient::new(&FetchConfig::default()).expect("worker module loader");
    let script_url = format!("{base_url}/worker/main.js");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import data from "./data.json" with { type: "json" };
        postMessage(data.answer);
        close();
        "#
        .into(),
        script_url,
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), "42");
    let request = request_rx
        .await
        .expect("worker JSON module request should be captured");
    assert!(
        request
            .to_ascii_lowercase()
            .contains("sec-fetch-dest: json\r\n"),
        "worker JSON module fetch must use json destination, request was:\n{request}"
    );
    server
        .await
        .expect("worker JSON module destination server should finish");
}

#[tokio::test]
async fn worker_module_dynamic_css_import_rejects_invalid_module_type() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        try {
            await import("data:text/css,.answer{}", { with: { type: "css" } });
            postMessage("unexpected");
        } catch (error) {
            postMessage({
                name: error && error.name,
                type: error instanceof TypeError,
                message: String(error && error.message),
            });
        }
        close();
        "#
        .into(),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"name":"TypeError","type":true,"message":"module type `css` is not a valid module type for dynamic import `data:text/css,.answer{}`"}"#
    );
}

#[tokio::test]
async fn worker_module_dynamic_text_import_rejects_invalid_module_type() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        try {
            await import("data:text/plain,hello", { with: { type: "text" } });
            postMessage("unexpected");
        } catch (error) {
            postMessage({
                name: error && error.name,
                type: error instanceof TypeError,
                message: String(error && error.message),
            });
        }
        close();
        "#
        .into(),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"name":"TypeError","type":true,"message":"module type `text` is not a valid module type for dynamic import `data:text/plain,hello`"}"#
    );
}

#[tokio::test]
async fn worker_module_static_text_import_rejects_invalid_module_type() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import text from "data:text/plain,hello" with { type: "text" };
        postMessage("unexpected");
        "#
        .into(),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Error { message, .. } => {
            assert!(
                message.contains("module type `text` is not a valid module type"),
                "{message}"
            );
        }
        other => panic!("expected Error, got {other:?}"),
    }
}

#[tokio::test]
async fn worker_module_static_css_import_rejects_invalid_module_type() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import sheet from "data:text/css,.answer{}" with { type: "css" };
        postMessage("unexpected");
        "#
        .into(),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Error { message, .. } => {
            assert!(
                message.contains("module type `css` is not a valid module type"),
                "{message}"
            );
        }
        other => panic!("expected Error, got {other:?}"),
    }
}

#[tokio::test]
async fn worker_module_namespace_import_source_runs_in_strict_mode() {
    ensure_v8();
    let dep_url = worker_data_url("export const answer = 42;");
    let dep_specifier = serde_json::to_string(&dep_url).expect("data URL should serialize");
    let mut handle = spawn_worker_with_request_client_and_kind(
        format!(
            r#"
        import * as dep from {dep_specifier};
        const topLevelThisUndefined = this === undefined;
        function sloppyThis() {{ return this; }}
        let implicitGlobalError = "none";
        try {{
            namespaceImportGlobal = 7;
        }} catch (error) {{
            implicitGlobalError = error && error.name;
        }}
        postMessage({{
            answer: dep.answer,
            topLevelThisUndefined,
            functionThisUndefined: sloppyThis() === undefined,
            implicitGlobalError,
            leakedGlobal: Object.prototype.hasOwnProperty.call(self, "namespaceImportGlobal"),
        }});
        close();
        "#
        ),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"answer":42,"topLevelThisUndefined":true,"functionThisUndefined":true,"implicitGlobalError":"ReferenceError","leakedGlobal":false}"#
    );
}

#[tokio::test]
async fn worker_module_named_import_source_runs_in_strict_mode() {
    ensure_v8();
    let dep_url = worker_data_url(
        r#"
        export let counter = 1;
        export { counter as default };
        export function setCounter(value) { counter = value; }
        "#,
    );
    let dep_specifier = serde_json::to_string(&dep_url).expect("data URL should serialize");
    let mut handle = spawn_worker_with_request_client_and_kind(
        format!(
            r#"
        import current, {{ counter, setCounter }} from {dep_specifier};
        const before = counter;
        const defaultBefore = current;
        const topLevelThisUndefined = this === undefined;
        function sloppyThis() {{ return this; }}
        let implicitGlobalError = "none";
        try {{
            namedImportGlobal = 7;
        }} catch (error) {{
            implicitGlobalError = error && error.name;
        }}
        let namedAssignment = "none";
        try {{
            counter = 11;
        }} catch (error) {{
            namedAssignment = error && error.name;
        }}
        let defaultAssignment = "none";
        try {{
            current = 12;
        }} catch (error) {{
            defaultAssignment = error && error.name;
        }}
        setCounter(5);
        const afterSet = counter;
        const defaultAfterSet = current;
        postMessage({{
            before,
            defaultBefore,
            afterSet,
            defaultAfterSet,
            topLevelThisUndefined,
            functionThisUndefined: sloppyThis() === undefined,
            implicitGlobalError,
            leakedGlobal: Object.prototype.hasOwnProperty.call(self, "namedImportGlobal"),
            namedAssignment,
            defaultAssignment,
        }});
        close();
        "#
        ),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"before":1,"defaultBefore":1,"afterSet":5,"defaultAfterSet":5,"topLevelThisUndefined":true,"functionThisUndefined":true,"implicitGlobalError":"ReferenceError","leakedGlobal":false,"namedAssignment":"TypeError","defaultAssignment":"TypeError"}"#
    );
}

#[tokio::test]
async fn worker_module_top_level_return_reports_syntax_error() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        return;
        postMessage("unexpected");
        "#
        .into(),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Error {
            message, filename, ..
        } => {
            assert!(message.contains("return"), "{message}");
            assert_eq!(filename, "data:text/javascript,main");
        }
        other => panic!("expected Error, got {other:?}"),
    }
}

#[tokio::test]
async fn worker_module_with_statement_reports_syntax_error() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        with ({ value: 1 }) {
            postMessage(value);
        }
        "#
        .into(),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Error { message, phase, .. } => {
            assert!(
                message.contains("with") || message.contains("strict"),
                "{message}"
            );
            assert_eq!(
                phase,
                WorkerErrorPhase::Bootstrap,
                "dependency parse errors discovered while loading the root module graph are still bootstrap failures"
            );
        }
        other => panic!("expected Error, got {other:?}"),
    }
}

#[tokio::test]
async fn worker_module_dependency_parse_error_reports_syntax_error() {
    ensure_v8();
    let dep_url = worker_data_url(
        r#"
        with ({ value: 1 }) {
            self.__unexpected = value;
        }
        "#,
    );
    let dep_specifier = serde_json::to_string(&dep_url).expect("data URL should serialize");
    let mut handle = spawn_worker_with_request_client_and_kind(
        format!(
            r#"
        import * as dep from {dep_specifier};
        postMessage(dep.__unexpected);
        "#
        ),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Error { message, .. } => {
            assert!(
                message.contains("with") || message.contains("strict"),
                "{message}"
            );
        }
        other => panic!("expected Error, got {other:?}"),
    }
}

#[tokio::test]
async fn worker_module_missing_named_import_reports_link_error() {
    ensure_v8();
    let dep_url = worker_data_url("export const present = 1;");
    let dep_specifier = serde_json::to_string(&dep_url).expect("data URL should serialize");
    let mut handle = spawn_worker_with_request_client_and_kind(
        format!(
            r#"
        import {{ absent }} from {dep_specifier};
        postMessage(absent);
        "#
        ),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Error { message, .. } => {
            assert!(
                message.contains("missing export") || message.contains("SyntaxError"),
                "{message}"
            );
        }
        other => panic!("expected Error, got {other:?}"),
    }
}

#[tokio::test]
async fn worker_module_missing_reexport_reports_link_error() {
    ensure_v8();
    let dep_url = worker_data_url("export const present = 1;");
    let dep_specifier = serde_json::to_string(&dep_url).expect("data URL should serialize");
    let reexport_url = worker_data_url(&format!(
        "export {{ absent as forwarded }} from {dep_specifier};"
    ));
    let reexport_specifier =
        serde_json::to_string(&reexport_url).expect("data URL should serialize");
    let mut handle = spawn_worker_with_request_client_and_kind(
        format!(
            r#"
        import * as reexported from {reexport_specifier};
        postMessage(reexported.forwarded);
        "#
        ),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Error { message, .. } => {
            assert!(
                message.contains("missing export") || message.contains("SyntaxError"),
                "{message}"
            );
        }
        other => panic!("expected Error, got {other:?}"),
    }
}

#[tokio::test]
async fn worker_module_http_dependency_404_reports_load_error() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/missing.js",
        "HTTP/1.1 404 Not Found",
        "application/javascript",
        "missing module dependency".to_owned(),
        Duration::ZERO,
    )])
    .await;
    let loader = ResourceRequestClient::new(&FetchConfig::default()).expect("worker module loader");
    let script_url = format!("{base_url}/worker/main.js");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import "./missing.js";
        postMessage("unexpected");
        "#
        .into(),
        script_url,
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Error { message, .. } => {
            assert!(message.contains("404"), "{message}");
            assert!(message.contains("Not Found"), "{message}");
        }
        other => panic!("expected Error, got {other:?}"),
    }
    server
        .await
        .expect("worker module 404 server should finish");
}

#[tokio::test]
async fn worker_module_http_dependency_rejects_non_script_mime() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/dep.js",
        "HTTP/1.1 200 OK",
        "text/html",
        "export const value = 'html-mime';".to_owned(),
        Duration::ZERO,
    )])
    .await;
    let loader = ResourceRequestClient::new(&FetchConfig::default()).expect("worker module loader");
    let script_url = format!("{base_url}/worker/main.js");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import { value } from "./dep.js";
        postMessage(value);
        "#
        .into(),
        script_url,
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Error { message, .. } => {
            assert!(
                message.contains("unsupported module script MIME type"),
                "{message}"
            );
            assert!(message.contains("text/html"), "{message}");
        }
        other => panic!("expected Error, got {other:?}"),
    }
    server
        .await
        .expect("worker module MIME server should finish");
}

#[tokio::test]
async fn worker_module_http_dependency_accepts_json_suffix_mime_with_attribute() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/dep.json",
        "HTTP/1.1 200 OK",
        "application/manifest+json; charset=utf-8",
        r#"{"answer":42}"#.to_owned(),
        Duration::ZERO,
    )])
    .await;
    let loader = ResourceRequestClient::new(&FetchConfig::default()).expect("worker module loader");
    let script_url = format!("{base_url}/worker/main.js");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import data from "./dep.json" with { type: "json" };
        postMessage(data.answer);
        close();
        "#
        .into(),
        script_url,
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), "42");
    server
        .await
        .expect("worker module JSON server should finish");
}

#[tokio::test]
async fn worker_module_http_dependency_reports_json_attribute_mismatch_before_script_mime() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/plain-json.json",
        "HTTP/1.1 200 OK",
        "text/plain",
        r#"{"answer":42}"#.to_owned(),
        Duration::ZERO,
    )])
    .await;
    let loader = ResourceRequestClient::new(&FetchConfig::default()).expect("worker module loader");
    let script_url = format!("{base_url}/worker/main.js");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import data from "./plain-json.json" with { type: "json" };
        postMessage(data.answer);
        "#
        .into(),
        script_url,
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Error { message, .. } => {
            assert!(message.contains("non-JSON module"), "{message}");
            assert!(message.contains("JSON import attribute"), "{message}");
        }
        other => panic!("expected Error, got {other:?}"),
    }
    server
        .await
        .expect("worker module JSON MIME mismatch server should finish");
}

#[tokio::test]
async fn worker_module_invalid_static_import_specifier_reports_resolution_error() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import "http://[::1";
        postMessage("unexpected");
        "#
        .into(),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Error { message, .. } => {
            assert!(message.contains("Failed to resolve"), "{message}");
        }
        other => panic!("expected Error, got {other:?}"),
    }
}

#[tokio::test]
async fn worker_module_static_import_rejects_invalid_attribute_key() {
    ensure_v8();
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import "data:text/javascript,export%20default%201" with { foo: "bar" };
        postMessage("unexpected");
        "#
        .into(),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Error { message, .. } => {
            assert!(
                message.contains("Invalid attribute key \"foo\"."),
                "{message}"
            );
        }
        other => panic!("expected Error, got {other:?}"),
    }
}

#[tokio::test]
async fn worker_module_http_dependency_cycle_evaluates_once() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![
        (
            "/worker/entry.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            ["import './leaf.js';", "export const entry = 'entry';"].join("\n"),
            Duration::ZERO,
        ),
        (
            "/worker/leaf.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            ["import './entry.js';", "export const leaf = 'leaf';"].join("\n"),
            Duration::ZERO,
        ),
    ])
    .await;
    let loader = ResourceRequestClient::new(&FetchConfig::default()).expect("worker module loader");
    let script_url = format!("{base_url}/worker/main.js");
    let mut handle = spawn_worker_with_request_client_and_kind(
        r#"
        import { entry } from "./entry.js";
        import { leaf } from "./leaf.js";
        postMessage({ entry, leaf });
        "#
        .into(),
        script_url,
        loader,
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#"{"entry":"entry","leaf":"leaf"}"#);
    server
        .await
        .expect("worker module cycle server should finish");
}

#[tokio::test]
async fn worker_module_http_export_cycles_evaluate_once() {
    ensure_v8();
    let cases = [
        (
            "export-list",
            r#"
            import { entry, leaf } from "./entry.js";
            postMessage({ entry, leaf });
            "#,
            [
                "export { leaf } from './leaf.js';",
                "export const entry = 'entry';",
            ]
            .join("\n"),
            [
                "export { entry } from './entry.js';",
                "export const leaf = 'leaf';",
            ]
            .join("\n"),
        ),
        (
            "export-star",
            r#"
            import { entry, leaf } from "./entry.js";
            postMessage({ entry, leaf });
            "#,
            [
                "export * from './leaf.js';",
                "export const entry = 'entry';",
            ]
            .join("\n"),
            ["export * from './entry.js';", "export const leaf = 'leaf';"].join("\n"),
        ),
    ];

    for (label, main_source, entry_source, leaf_source) in cases {
        let (base_url, server) = spawn_path_response_http_server(vec![
            (
                "/worker/entry.js",
                "HTTP/1.1 200 OK",
                "application/javascript",
                entry_source,
                Duration::ZERO,
            ),
            (
                "/worker/leaf.js",
                "HTTP/1.1 200 OK",
                "application/javascript",
                leaf_source,
                Duration::ZERO,
            ),
        ])
        .await;
        let loader =
            ResourceRequestClient::new(&FetchConfig::default()).expect("worker module loader");
        let script_url = format!("{base_url}/worker/main.js");
        let mut handle = spawn_worker_with_request_client_and_kind(
            main_source.into(),
            script_url,
            loader,
            WorkerScriptKind::Module,
        );

        let msg = timeout(TIMEOUT, handle.recv())
            .await
            .unwrap_or_else(|_| panic!("timed out waiting for {label} cycle"))
            .expect("channel closed");
        assert_eq!(
            expect_post_json(msg),
            r#"{"entry":"entry","leaf":"leaf"}"#,
            "{label}"
        );
        server
            .await
            .unwrap_or_else(|_| panic!("{label} cycle server should finish"));
    }
}

#[tokio::test]
async fn worker_module_side_effect_imports_evaluate_dependencies_once_in_order() {
    ensure_v8();
    let shared_url = worker_data_url(
        r#"
        self.__moduleOrder = self.__moduleOrder || [];
        self.__moduleOrder.push("shared");
        export const marker = "shared-marker";
        "#,
    );
    let shared_specifier = serde_json::to_string(&shared_url).expect("data URL should serialize");
    let first_url = worker_data_url(&format!(
        r#"
        import {shared_specifier};
        self.__moduleOrder.push("first");
        export const first = "first-export";
        "#
    ));
    let first_specifier = serde_json::to_string(&first_url).expect("data URL should serialize");
    let second_url = worker_data_url(&format!(
        r#"
        import {{ marker }} from {shared_specifier};
        self.__moduleOrder.push("second:" + marker);
        export const second = marker;
        "#
    ));
    let second_specifier = serde_json::to_string(&second_url).expect("data URL should serialize");

    let mut handle = spawn_worker_with_request_client_and_kind(
        format!(
            r#"
        import {first_specifier};
        import {{ second }} from {second_specifier};
        import {shared_specifier};
        postMessage({{
            order: self.__moduleOrder.join("|"),
            second,
        }});
        close();
        "#
        ),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"order":"shared|first|second:shared-marker","second":"shared-marker"}"#
    );
}

#[tokio::test]
async fn worker_module_imported_bindings_reject_assignment() {
    ensure_v8();
    let dep_url = worker_data_url(
        r#"
        export let counter = 1;
        export { counter as default };
        export function setCounter(value) { counter = value; }
        "#,
    );
    let dep_specifier = serde_json::to_string(&dep_url).expect("data URL should serialize");
    let mut handle = spawn_worker_with_request_client_and_kind(
        format!(
            r#"
        import current, {{ counter, setCounter }} from {dep_specifier};
        function assignmentName(callback) {{
            try {{
                callback();
                return "none";
            }} catch (error) {{
                return error && error.name;
            }}
        }}
        const namedAssignment = assignmentName(function () {{ counter = 7; }});
        const defaultAssignment = assignmentName(function () {{ current = 8; }});
        setCounter(5);
        postMessage({{
            namedAssignment,
            defaultAssignment,
            counter,
            current,
        }});
        close();
        "#
        ),
        "data:text/javascript,main".into(),
        worker_test_request_client(),
        WorkerScriptKind::Module,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"namedAssignment":"TypeError","defaultAssignment":"TypeError","counter":5,"current":5}"#
    );
}

#[tokio::test]
async fn worker_importscripts_cross_origin_failures_throw_network_error() {
    ensure_v8();
    let (base_url, script_server) = spawn_path_response_http_server(vec![
        (
            "/syntax.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            "globalThis.__broken = ;".to_owned(),
            Duration::ZERO,
        ),
        (
            "/throw.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            "globalThis.__crossOriginLoaded = true;".to_owned(),
            Duration::ZERO,
        ),
    ])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker importScripts loader");
    let syntax_url =
        serde_json::to_string(&format!("{base_url}/syntax.js")).expect("serialize syntax url");
    let throw_url =
        serde_json::to_string(&format!("{base_url}/throw.js")).expect("serialize throw url");
    let mut handle = spawn_worker_with_request_client(
        format!(
            r#"
            const results = [];
            for (const url of [{syntax_url}, {throw_url}]) {{
                try {{
                    importScripts(url);
                    results.push({{
                        name: "unexpected",
                        domException: false,
                        loaded: globalThis.__crossOriginLoaded === true,
                    }});
                }} catch (error) {{
                    results.push({{
                        name: error && error.name,
                        domException: error instanceof DOMException,
                        loaded: globalThis.__crossOriginLoaded === true,
                    }});
                }}
                delete globalThis.__crossOriginLoaded;
            }}
            postMessage(results);
            close();
            "#
        ),
        "http://127.0.0.1/worker/main.js".into(),
        loader,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"[{"name":"NetworkError","domException":true,"loaded":false},{"name":"NetworkError","domException":true,"loaded":false}]"#
    );
    script_server
        .await
        .expect("cross-origin importScripts server should finish");
}

#[tokio::test]
async fn worker_importscripts_redirect_to_cross_origin_failure_throws_network_error() {
    ensure_v8();
    let (cross_origin_base_url, script_server) = spawn_path_response_http_server(vec![(
        "/throw.js",
        "HTTP/1.1 200 OK",
        "application/javascript",
        "globalThis.__redirectedCrossOriginLoaded = true;".to_owned(),
        Duration::ZERO,
    )])
    .await;
    let redirect_response = format!(
        "HTTP/1.1 302 Found\r\nLocation: {cross_origin_base_url}/throw.js\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
    );
    let (same_origin_base_url, redirect_server) = spawn_raw_path_response_http_server(vec![(
        "/worker/redirect-throw.js",
        redirect_response,
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker importScripts loader");
    let mut handle = spawn_worker_with_request_client(
        r#"
        try {
            importScripts("./redirect-throw.js");
            postMessage({
                name: "unexpected",
                domException: false,
                loaded: globalThis.__redirectedCrossOriginLoaded === true,
            });
        } catch (error) {
            postMessage({
                name: error && error.name,
                domException: error instanceof DOMException,
                loaded: globalThis.__redirectedCrossOriginLoaded === true,
            });
        }
        close();
        "#
        .into(),
        format!("{same_origin_base_url}/worker/main.js"),
        loader,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"name":"NetworkError","domException":true,"loaded":false}"#
    );
    redirect_server
        .await
        .expect("redirect importScripts server should finish");
    script_server
        .await
        .expect("redirect target importScripts server should finish");
}

#[tokio::test]
async fn worker_importscripts_same_origin_syntax_error_reports_imported_script_location() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/syntax-error.js",
        "HTTP/1.1 200 OK",
        "application/javascript",
        "globalThis.__broken = ;".to_owned(),
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker importScripts loader");
    let mut handle = spawn_worker_with_request_client(
        r#"
        addEventListener("error", function(event) {
            postMessage({
                name: event.error && event.error.name,
                messageIncludesSyntaxError: String(event.message).includes("SyntaxError"),
                filename: event.filename,
                lineno: event.lineno
            });
            event.preventDefault();
            close();
        });
        function doImportScripts(url) {
            importScripts(url);
        }
        doImportScripts("./syntax-error.js");
        "#
        .into(),
        format!("{base_url}/worker/report-error-helper.js"),
        loader,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        format!(
            r#"{{"name":"SyntaxError","messageIncludesSyntaxError":true,"filename":"{base_url}/worker/syntax-error.js","lineno":1}}"#
        )
    );
    server
        .await
        .expect("same-origin importScripts server should finish");
}

#[tokio::test]
async fn service_worker_importscripts_reports_imported_script_resource() {
    ensure_v8();
    let dep_body = "globalThis.__depLoaded = true;";
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/dep.js",
        "HTTP/1.1 200 OK",
        "application/javascript",
        dep_body.to_owned(),
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker importScripts loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            importScripts("./dep.js");
            if (!globalThis.__depLoaded) {
                throw new Error("missing dep");
            }
            skipWaiting();
            "#
            .to_owned(),
            format!("{base_url}/worker/sw.js"),
        )
        .with_request_client(loader)
        .with_global_kind(super::super::WorkerGlobalKind::Service {
            registration_id: ServiceWorkerRegistrationId::from_u64_for_test(7),
            version_id: ServiceWorkerVersionId::from_u64_for_test(9),
            scope_url: url::Url::parse(&format!("{base_url}/worker/")).unwrap(),
        }),
    );

    let expected_import_url = format!("{base_url}/worker/dep.js");
    let expected_hash = sha256_hex(dep_body.as_bytes());
    let mut imported_resource = None;
    let mut saw_skip_waiting = false;
    while imported_resource.is_none() || !saw_skip_waiting {
        let message = timeout(TIMEOUT, handle.recv())
            .await
            .expect("timed out waiting for importScripts resource")
            .expect("channel closed");
        match message {
            WorkerToParentMessage::ServiceWorkerImportedScriptLoaded {
                registration_id,
                version_id,
                resource,
            } => {
                assert_eq!(
                    registration_id,
                    ServiceWorkerRegistrationId::from_u64_for_test(7)
                );
                assert_eq!(version_id, ServiceWorkerVersionId::from_u64_for_test(9));
                imported_resource = Some(resource);
            }
            WorkerToParentMessage::ServiceWorkerSkipWaiting {
                registration_id,
                version_id,
            } => {
                assert_eq!(
                    registration_id,
                    ServiceWorkerRegistrationId::from_u64_for_test(7)
                );
                assert_eq!(version_id, ServiceWorkerVersionId::from_u64_for_test(9));
                saw_skip_waiting = true;
            }
            WorkerToParentMessage::Error { message, .. } => {
                panic!("unexpected service worker error: {message}");
            }
            _ => {}
        }
    }

    let resource = imported_resource.expect("importScripts should report a resource");
    assert_eq!(resource.request_url.as_str(), expected_import_url);
    assert_eq!(resource.final_url.as_str(), expected_import_url);
    assert_eq!(resource.kind, WorkerScriptResourceKind::JavaScript);
    assert_eq!(resource.status, 200);
    assert_eq!(resource.body_len, dep_body.len());
    assert_eq!(resource.body_sha256, expected_hash);
    assert_eq!(
        resource.mime_type.as_deref(),
        Some("application/javascript")
    );
    handle.terminate_and_join();
    server
        .await
        .expect("service worker importScripts resource server should finish");
}

#[tokio::test]
async fn service_worker_module_static_import_reports_imported_script_resource() {
    ensure_v8();
    let dep_body = "export const depLoaded = true;";
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/dep.js",
        "HTTP/1.1 200 OK",
        "application/javascript",
        dep_body.to_owned(),
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("service worker module loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            import { depLoaded } from "./dep.js";
            if (!depLoaded) {
                throw new Error("missing module dep");
            }
            skipWaiting();
            "#
            .to_owned(),
            format!("{base_url}/worker/sw.js"),
        )
        .with_request_client(loader)
        .with_script_kind(WorkerScriptKind::Module)
        .with_global_kind(super::super::WorkerGlobalKind::Service {
            registration_id: ServiceWorkerRegistrationId::from_u64_for_test(7),
            version_id: ServiceWorkerVersionId::from_u64_for_test(9),
            scope_url: url::Url::parse(&format!("{base_url}/worker/")).unwrap(),
        }),
    );

    let expected_import_url = format!("{base_url}/worker/dep.js");
    let expected_hash = sha256_hex(dep_body.as_bytes());
    let mut imported_resource = None;
    let mut saw_skip_waiting = false;
    while imported_resource.is_none() || !saw_skip_waiting {
        let message = timeout(TIMEOUT, handle.recv())
            .await
            .expect("timed out waiting for service worker module resource")
            .expect("channel closed");
        match message {
            WorkerToParentMessage::ServiceWorkerImportedScriptLoaded {
                registration_id,
                version_id,
                resource,
            } => {
                assert_eq!(
                    registration_id,
                    ServiceWorkerRegistrationId::from_u64_for_test(7)
                );
                assert_eq!(version_id, ServiceWorkerVersionId::from_u64_for_test(9));
                imported_resource = Some(resource);
            }
            WorkerToParentMessage::ServiceWorkerSkipWaiting {
                registration_id,
                version_id,
            } => {
                assert_eq!(
                    registration_id,
                    ServiceWorkerRegistrationId::from_u64_for_test(7)
                );
                assert_eq!(version_id, ServiceWorkerVersionId::from_u64_for_test(9));
                saw_skip_waiting = true;
            }
            WorkerToParentMessage::Error { message, .. } => {
                panic!("unexpected service worker module error: {message}");
            }
            _ => {}
        }
    }

    let resource = imported_resource.expect("module static import should report a resource");
    assert_eq!(resource.request_url.as_str(), expected_import_url);
    assert_eq!(resource.final_url.as_str(), expected_import_url);
    assert_eq!(resource.status, 200);
    assert_eq!(resource.body_len, dep_body.len());
    assert_eq!(resource.body_sha256, expected_hash);
    assert_eq!(
        resource.mime_type.as_deref(),
        Some("application/javascript")
    );
    handle.terminate_and_join();
    server
        .await
        .expect("service worker module resource server should finish");
}

#[tokio::test]
async fn service_worker_module_static_json_import_reports_json_resource_kind() {
    ensure_v8();
    let dep_body = r#"{"answer":42}"#;
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/dep.json",
        "HTTP/1.1 200 OK",
        "application/manifest+json; charset=utf-8",
        dep_body.to_owned(),
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("service worker module loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            import data from "./dep.json" with { type: "json" };
            if (data.answer !== 42) {
                throw new Error("missing JSON module dep");
            }
            skipWaiting();
            "#
            .to_owned(),
            format!("{base_url}/worker/sw.js"),
        )
        .with_request_client(loader)
        .with_script_kind(WorkerScriptKind::Module)
        .with_global_kind(super::super::WorkerGlobalKind::Service {
            registration_id: ServiceWorkerRegistrationId::from_u64_for_test(11),
            version_id: ServiceWorkerVersionId::from_u64_for_test(13),
            scope_url: url::Url::parse(&format!("{base_url}/worker/")).unwrap(),
        }),
    );

    let expected_import_url = format!("{base_url}/worker/dep.json");
    let expected_hash = sha256_hex(dep_body.as_bytes());
    let mut imported_resource = None;
    let mut saw_skip_waiting = false;
    while imported_resource.is_none() || !saw_skip_waiting {
        let message = timeout(TIMEOUT, handle.recv())
            .await
            .expect("timed out waiting for service worker module JSON resource")
            .expect("channel closed");
        match message {
            WorkerToParentMessage::ServiceWorkerImportedScriptLoaded {
                registration_id,
                version_id,
                resource,
            } => {
                assert_eq!(
                    registration_id,
                    ServiceWorkerRegistrationId::from_u64_for_test(11)
                );
                assert_eq!(version_id, ServiceWorkerVersionId::from_u64_for_test(13));
                imported_resource = Some(resource);
            }
            WorkerToParentMessage::ServiceWorkerSkipWaiting {
                registration_id,
                version_id,
            } => {
                assert_eq!(
                    registration_id,
                    ServiceWorkerRegistrationId::from_u64_for_test(11)
                );
                assert_eq!(version_id, ServiceWorkerVersionId::from_u64_for_test(13));
                saw_skip_waiting = true;
            }
            WorkerToParentMessage::Error { message, .. } => {
                panic!("unexpected service worker module JSON error: {message}");
            }
            _ => {}
        }
    }

    let resource = imported_resource.expect("module static JSON import should report a resource");
    assert_eq!(resource.request_url.as_str(), expected_import_url);
    assert_eq!(resource.final_url.as_str(), expected_import_url);
    assert_eq!(resource.kind, WorkerScriptResourceKind::JsonModule);
    assert_eq!(resource.status, 200);
    assert_eq!(resource.body_len, dep_body.len());
    assert_eq!(resource.body_sha256, expected_hash);
    assert_eq!(
        resource.mime_type.as_deref(),
        Some("application/manifest+json; charset=utf-8")
    );
    handle.terminate_and_join();
    server
        .await
        .expect("service worker module JSON resource server should finish");
}

#[tokio::test]
async fn service_worker_module_static_css_import_rejects_invalid_module_type() {
    ensure_v8();
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            import sheet from "data:text/css,.answer{}" with { type: "css" };
            skipWaiting();
            "#
            .to_owned(),
            "data:text/javascript,main".to_owned(),
        )
        .with_script_kind(WorkerScriptKind::Module)
        .with_global_kind(super::super::WorkerGlobalKind::Service {
            registration_id: ServiceWorkerRegistrationId::from_u64_for_test(15),
            version_id: ServiceWorkerVersionId::from_u64_for_test(17),
            scope_url: url::Url::parse("https://service-worker-module.invalid/scope/").unwrap(),
        }),
    );

    let message = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out waiting for service worker module CSS error")
        .expect("channel closed");
    match message {
        WorkerToParentMessage::Error { message, .. } => {
            assert!(
                message.contains("module type `css` is not a valid module type"),
                "{message}"
            );
        }
        other => panic!("expected Error, got {other:?}"),
    }
    handle.terminate_and_join();
}

#[tokio::test]
async fn service_worker_module_static_text_import_rejects_invalid_module_type() {
    ensure_v8();
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            import text from "data:text/plain,hello" with { type: "text" };
            skipWaiting();
            "#
            .to_owned(),
            "data:text/javascript,main".to_owned(),
        )
        .with_script_kind(WorkerScriptKind::Module)
        .with_global_kind(super::super::WorkerGlobalKind::Service {
            registration_id: ServiceWorkerRegistrationId::from_u64_for_test(19),
            version_id: ServiceWorkerVersionId::from_u64_for_test(21),
            scope_url: url::Url::parse("https://service-worker-module.invalid/scope/").unwrap(),
        }),
    );

    let message = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out waiting for service worker module text error")
        .expect("channel closed");
    match message {
        WorkerToParentMessage::Error { message, .. } => {
            assert!(
                message.contains("module type `text` is not a valid module type"),
                "{message}"
            );
        }
        other => panic!("expected Error, got {other:?}"),
    }
    handle.terminate_and_join();
}

#[tokio::test]
async fn worker_importscripts_nested_rethrow_preserves_imported_script_location() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![
        (
            "/worker/entry.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            "runTest('./syntax-error.js');".to_owned(),
            Duration::ZERO,
        ),
        (
            "/worker/syntax-error.js",
            "HTTP/1.1 200 OK",
            "application/javascript",
            "globalThis.__broken = ;".to_owned(),
            Duration::ZERO,
        ),
    ])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker importScripts loader");
    let mut handle = spawn_worker_with_request_client(
        r#"
        addEventListener("error", function(event) {
            postMessage({
                name: event.error && event.error.name,
                messageIncludesSyntaxError: String(event.message).includes("SyntaxError"),
                filename: event.filename,
                lineno: event.lineno
            });
            event.preventDefault();
            close();
        });
        function doImportScripts(url) {
            importScripts(url);
        }
        function runTest(url) {
            doImportScripts(url);
        }
        importScripts("./entry.js");
        "#
        .into(),
        format!("{base_url}/worker/report-error-helper.js"),
        loader,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        format!(
            r#"{{"name":"SyntaxError","messageIncludesSyntaxError":true,"filename":"{base_url}/worker/syntax-error.js","lineno":1}}"#
        )
    );
    server
        .await
        .expect("nested importScripts server should finish");
}

#[tokio::test]
async fn worker_importscripts_same_origin_runtime_error_reports_imported_script_location() {
    ensure_v8();
    let (base_url, server) = spawn_path_response_http_server(vec![(
        "/worker/runtime-error.js",
        "HTTP/1.1 200 OK",
        "application/javascript",
        "throw new Error('runtime-boom');".to_owned(),
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker importScripts loader");
    let mut handle = spawn_worker_with_request_client(
        r#"
        addEventListener("error", function(event) {
            postMessage({
                name: event.error && event.error.name,
                errorMessage: event.error && event.error.message,
                filename: event.filename,
                lineno: event.lineno
            });
            event.preventDefault();
            close();
        });
        function doImportScripts(url) {
            importScripts(url);
        }
        doImportScripts("./runtime-error.js");
        "#
        .into(),
        format!("{base_url}/worker/report-error-helper.js"),
        loader,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        format!(
            r#"{{"name":"Error","errorMessage":"runtime-boom","filename":"{base_url}/worker/runtime-error.js","lineno":1}}"#
        )
    );
    server
        .await
        .expect("same-origin runtime importScripts server should finish");
}

#[tokio::test]
async fn worker_importscripts_cross_origin_failure_reports_helper_callsite_from_timer() {
    ensure_v8();
    let (cross_origin_base_url, server) = spawn_path_response_http_server(vec![(
        "/syntax-error.js",
        "HTTP/1.1 200 OK",
        "application/javascript",
        "globalThis.__broken = ;".to_owned(),
        Duration::ZERO,
    )])
    .await;
    let loader =
        ResourceRequestClient::new(&FetchConfig::default()).expect("worker importScripts loader");
    let cross_origin_url =
        serde_json::to_string(&format!("{cross_origin_base_url}/syntax-error.js"))
            .expect("serialize cross-origin url");
    let script_url = "http://127.0.0.1/worker/report-error-helper.js";
    let mut handle = spawn_worker_with_request_client(
        format!(
            "addEventListener(\"error\", function(event) {{\n  postMessage({{name: event.error && event.error.name, domException: event.error instanceof DOMException, messageIsScriptError: event.message === \"Script error.\", filename: event.filename, lineno: event.lineno}});\n  event.preventDefault();\n  close();\n}});\nfunction doImportScripts(url) {{\n  importScripts(url);\n}}\nsetTimeout(function() {{\n  doImportScripts({cross_origin_url});\n}}, 0);\n"
        ),
        script_url.into(),
        loader,
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"name":"NetworkError","domException":true,"messageIsScriptError":false,"filename":"http://127.0.0.1/worker/report-error-helper.js","lineno":7}"#
    );
    server
        .await
        .expect("cross-origin importScripts server should finish");
}

#[tokio::test]
async fn worker_json_imports_use_shared_response_mime_extraction() {
    ensure_v8();
    for (mime, accepts) in [
        ("text/json", true),
        ("TeXt/JsOn; charset=windows-1250", true),
        ("text/plain, text/json", true),
        ("text/json, text/plain", false),
        ("text/plain, application/json", true),
        ("application/json, invalid, */*", true),
        ("application/json, text/plain", false),
        (r#"text/plain; a=",application/json""#, false),
        ("applic(ation/vnd.api+json", false),
        ("*/*", false),
    ] {
        let (base_url, server) = spawn_path_response_http_server(vec![(
            "/worker/module.json",
            "HTTP/1.1 200 OK",
            mime,
            r#"{"answer":42}"#.to_owned(),
            Duration::ZERO,
        )])
        .await;
        let loader = ResourceRequestClient::new(&FetchConfig::default()).unwrap();
        let mut handle = spawn_worker_with_request_client_and_kind(
            "import('./module.json', {with:{type:'json'}}).then(m => postMessage(m.default.answer), e => postMessage(e.name));".into(),
            format!("{base_url}/worker/main.js"), loader, WorkerScriptKind::Module,
        );
        let message = timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap();
        assert_eq!(
            expect_post_json(message),
            if accepts { "42" } else { r#""TypeError""# },
            "{mime}"
        );
        handle.terminate_and_join();
        server.await.unwrap();
    }
}