Skip to content

armgit / moli

Public Imported from GitHub
0

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

122 KB
Raw Blame
use super::*;

#[tokio::test]
async fn worker_compression_streams_roundtrip_all_formats() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        (async () => {
            const result = [];
            for (const format of ['deflate-raw', 'deflate', 'gzip', 'brotli']) {
                const source = new ReadableStream({start(c) {
                    c.enqueue(new TextEncoder().encode('worker 压缩流'));
                    c.close();
                }});
                const stream = source.pipeThrough(new CompressionStream(format))
                    .pipeThrough(new DecompressionStream(format));
                result.push(await new Response(stream).text());
            }
            postMessage(result);
        })().catch(e => postMessage([e.name,e.message]));
        "#
        .into(),
        "https://compression-worker.test/worker.js".into(),
    );
    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("worker compression must settle")
        .expect("worker must return roundtrip result");
    let result: serde_json::Value = serde_json::from_str(&expect_post_json(msg)).unwrap();
    assert_eq!(
        result,
        serde_json::json!([
            "worker 压缩流",
            "worker 压缩流",
            "worker 压缩流",
            "worker 压缩流"
        ])
    );
}

#[tokio::test]
async fn worker_console_capture_does_not_serialize_or_coerce_page_objects() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        let hits = 0;
        const object = {
            get property() { hits++; return 1; },
            toJSON() { hits++; return {}; },
            [Symbol.toPrimitive]() { hits++; return 'object'; }
        };
        const proxy = new Proxy({}, {
            get() { hits++; }, ownKeys() { hits++; return []; }
        });
        console.log(object, proxy);
        postMessage(hits);
    "#
        .into(),
        "https://console-worker.test/worker.js".into(),
    );
    loop {
        let message = timeout(TIMEOUT, handle.recv())
            .await
            .expect("worker console probe")
            .expect("worker result");
        if matches!(message, WorkerToParentMessage::Console(_)) {
            continue;
        }
        assert_eq!(expect_post_json(message), "0");
        break;
    }
}

#[tokio::test]
async fn worker_does_not_expose_window_only_webrtc_event_interfaces() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"postMessage([typeof RTCPeerConnectionIceEvent, typeof RTCDataChannelEvent]); close();"#
            .into(),
        "test://webrtc-event-exposure".into(),
    );
    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out waiting for worker WebRTC event exposure")
        .expect("channel closed");
    assert_eq!(expect_post_json(msg), r#"["undefined","undefined"]"#);
}

#[tokio::test]
async fn worker_postmessage_to_parent() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"postMessage("hello from worker");"#.into(),
        "test://postmessage".into(),
    );

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

#[tokio::test]
async fn worker_postmessage_object() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"postMessage({ x: 1, y: "two" });"#.into(),
        "test://postmessage_obj".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    let json = expect_post_json(msg);
    assert!(
        json.contains(r#""x":1"#) || json.contains(r#""x": 1"#),
        "json: {json}"
    );
    assert!(
        json.contains(r#""y":"two""#) || json.contains(r#""y": "two""#),
        "json: {json}"
    );
}

#[tokio::test]
async fn worker_resource_owner_uses_context_slot_not_isolate_slot() {
    ensure_v8();
    let handle = spawn_worker(
        r#"postMessage("ready");"#.into(),
        "test://owner-slot".into(),
    );

    let diagnostics = timeout(TIMEOUT, handle.resource_owner_slot_diagnostics())
        .await
        .expect("timed out waiting for worker resource-owner slot diagnostics")
        .expect("worker resource-owner slot diagnostics should complete");

    assert!(
        diagnostics.context_slot_has_owner,
        "worker ResourceOwnerId must be installed on the worker global context"
    );
    assert!(
        diagnostics.current_owner_matches_context,
        "current_resource_owner_id must read the worker owner from the current context slot"
    );
    assert!(
        !diagnostics.isolate_slot_has_owner,
        "worker ResourceOwnerId must not be written to the V8 isolate slot"
    );
    assert!(
        !diagnostics.opfs_owner_state_materialized,
        "an unrelated worker must not eagerly allocate OPFS owner state"
    );
    assert_eq!(
        diagnostics.storage_constructor_materializations, 0,
        "an unrelated worker must not materialize storage constructors"
    );
    assert!(
        !diagnostics.storage_manager_materialized,
        "an unrelated worker must not eagerly create navigator.storage"
    );
    assert!(
        !diagnostics.storage_bucket_manager_materialized,
        "an unrelated worker must not eagerly create navigator.storageBuckets"
    );
}

#[tokio::test]
async fn worker_crypto_subtle_hmac_surface_matches_webcrypto_any_tests() {
    ensure_v8();
    // Chromium's WebCrypto WPT coverage is mostly `any.js`; keep a worker
    // smoke test so future runtime-state changes do not accidentally make the
    // worker global diverge from the window WebCrypto surface.
    let mut handle = spawn_worker(
        r#"
        (async () => {
            const failures = [];
            const typeErrorName = (fn) => {
                try {
                    fn();
                    return "resolved";
                } catch (error) {
                    return error.name;
                }
            };
            if (!(crypto instanceof Crypto)) {
                failures.push("crypto-instance");
            }
            if (!(crypto.subtle instanceof SubtleCrypto)) {
                failures.push("subtle-instance");
            }
            if (typeof CryptoKey !== "function") {
                failures.push("cryptokey-interface");
            }
            if (typeof SubtleCrypto.supports !== "function") {
                failures.push("supports-static");
            }
            const workerCryptoDescriptor = Object.getOwnPropertyDescriptor(
                WorkerGlobalScope.prototype,
                "crypto"
            );
            if (Object.prototype.hasOwnProperty.call(self, "crypto")) {
                failures.push("crypto-own-property");
            }
            if (typeof workerCryptoDescriptor?.get !== "function" || workerCryptoDescriptor.enumerable !== true) {
                failures.push("worker-crypto-descriptor");
            }
            if (crypto !== self.crypto || crypto !== workerCryptoDescriptor.get.call(self)) {
                failures.push("crypto-sameobject");
            }
            if (typeErrorName(() => workerCryptoDescriptor.get.call(WorkerGlobalScope.prototype)) !== "TypeError") {
                failures.push("worker-crypto-prototype-brand");
            }
            if (typeErrorName(() => Crypto.prototype.randomUUID.call({})) !== "TypeError") {
                failures.push("randomUUID-brand");
            }
            const key = await crypto.subtle.generateKey(
                { name: "HMAC", hash: "SHA-256" },
                true,
                ["sign", "verify"]
            );
            const algorithmA = key.algorithm;
            const algorithmB = key.algorithm;
            const usagesA = key.usages;
            const usagesB = key.usages;
            if (algorithmA !== algorithmB || algorithmA.hash !== algorithmB.hash) {
                failures.push("algorithm-cached-wrapper");
            }
            if (usagesA !== usagesB) {
                failures.push("usages-cached-wrapper");
            }
            if (algorithmA.name !== "HMAC" || algorithmA.hash.name !== "SHA-256") {
                failures.push("algorithm-shape");
            }
            if (usagesA.join(",") !== "sign,verify") {
                failures.push("usages-shape");
            }
            const data = new TextEncoder().encode("worker hmac");
            const signature = await crypto.subtle.sign("HMAC", key, data);
            if (!await crypto.subtle.verify("HMAC", key, signature, data)) {
                failures.push("hmac-verify");
            }
            const uuid = crypto.randomUUID();
            const namespaceFormat = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
            const version = parseInt(uuid.split("-")[2].slice(0, 2), 16) & 0b11110000;
            const variant = parseInt(uuid.split("-")[3].slice(0, 2), 16) & 0b11000000;
            if (!namespaceFormat.test(uuid) || version !== 0b01000000 || variant !== 0b10000000) {
                failures.push("randomUUID-shape");
            }
            postMessage(failures);
        })().catch((error) => {
            postMessage(["error:" + error.name + ":" + error.message]);
        });
        "#
        .into(),
        "https://worker-crypto.test/subtle-hmac-surface.js".into(),
    );

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

#[tokio::test]
async fn worker_crypto_subtle_derive_bits_pbkdf2_uses_async_lane_and_matches_vector() {
    ensure_v8();
    // Worker WebCrypto deriveBits routes heavy KDF work through the worker-owned
    // async completion lane (spawn_blocking + completion channel) instead of the
    // synchronous callback fallback. Assert the lane resolves the well-known
    // RFC-style PBKDF2-HMAC-SHA256 vector so the off-loop path stays correct.
    let mut handle = spawn_worker(
        r#"
        (async () => {
            const enc = new TextEncoder();
            const baseKey = await crypto.subtle.importKey(
                "raw",
                enc.encode("password"),
                { name: "PBKDF2" },
                false,
                ["deriveBits"]
            );
            const bits = await crypto.subtle.deriveBits(
                {
                    name: "PBKDF2",
                    salt: enc.encode("salt"),
                    iterations: 1,
                    hash: "SHA-256"
                },
                baseKey,
                256
            );
            const hex = Array.from(new Uint8Array(bits))
                .map((b) => b.toString(16).padStart(2, "0"))
                .join("");
            postMessage(hex);
        })().catch((error) => {
            postMessage("error:" + error.name + ":" + error.message);
        });
        "#
        .into(),
        "https://worker-crypto.test/subtle-derive-bits-pbkdf2.js".into(),
    );

    let payload = recv_post_json(&mut handle).await;
    assert_eq!(
        payload,
        r#""120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b""#,
    );
}

#[tokio::test]
async fn worker_crypto_subtle_derive_bits_does_not_block_event_loop() {
    ensure_v8();
    // The point of the worker async lane is that heavy crypto runs on the
    // blocking pool, so the worker event loop keeps servicing other tasks while
    // a deriveBits is in flight. A concurrently scheduled timer must be able to
    // fire before the (intentionally expensive) derivation resolves.
    let mut handle = spawn_worker(
        r#"
        let timerFiredBeforeDerive = false;
        let deriveResolved = false;
        setTimeout(() => {
            timerFiredBeforeDerive = !deriveResolved;
        }, 0);
        (async () => {
            const enc = new TextEncoder();
            const baseKey = await crypto.subtle.importKey(
                "raw",
                enc.encode("password"),
                { name: "PBKDF2" },
                false,
                ["deriveBits"]
            );
            await crypto.subtle.deriveBits(
                {
                    name: "PBKDF2",
                    salt: enc.encode("salt"),
                    iterations: 1000000,
                    hash: "SHA-256"
                },
                baseKey,
                256
            );
            deriveResolved = true;
            postMessage(timerFiredBeforeDerive ? "timer-first" : "derive-first");
        })().catch((error) => {
            postMessage("error:" + error.name + ":" + error.message);
        });
        "#
        .into(),
        "https://worker-crypto.test/subtle-derive-bits-nonblocking.js".into(),
    );

    let payload = recv_post_json(&mut handle).await;
    assert_eq!(payload, r#""timer-first""#);
}

#[tokio::test]
async fn worker_crypto_subtle_derive_bits_processes_incoming_message_while_pending() {
    ensure_v8();
    // Beyond timers, the worker must keep handling parent postMessage traffic
    // while a heavy derivation is in flight. Start a 1,000,000-iteration
    // deriveBits, then post a message from the parent; the worker should
    // respond to that message before the derivation resolves.
    let mut handle = spawn_worker(
        r#"
        let deriveResolved = false;
        let pingHandledBeforeDerive = null;
        onmessage = (event) => {
            if (event.data === "ping") {
                pingHandledBeforeDerive = !deriveResolved;
                postMessage(pingHandledBeforeDerive ? "ping-first" : "ping-after-derive");
            }
        };
        (async () => {
            const enc = new TextEncoder();
            const baseKey = await crypto.subtle.importKey(
                "raw", enc.encode("password"), { name: "PBKDF2" }, false, ["deriveBits"]
            );
            await crypto.subtle.deriveBits(
                { name: "PBKDF2", salt: enc.encode("salt"), iterations: 1000000, hash: "SHA-256" },
                baseKey, 256
            );
            deriveResolved = true;
        })().catch((error) => {
            postMessage("error:" + error.name + ":" + error.message);
        });
        "#
        .into(),
        "https://worker-crypto.test/subtle-derive-bits-message-responsive.js".into(),
    );

    // Give the worker a moment to install onmessage and start the derivation,
    // then send the ping. The derivation is intentionally long enough that the
    // message must be serviced off the critical path.
    handle.post_message(serialize_test_string("ping"));
    let payload = recv_post_json(&mut handle).await;
    // The responsiveness contract ends while PBKDF2 is still in flight.
    // Terminate and join that live worker explicitly so this test also proves
    // teardown drops a late WebCrypto completion without racing process-wide
    // V8 shutdown.
    handle.terminate_and_join();
    assert_eq!(payload, r#""ping-first""#);
}

#[tokio::test]
async fn worker_crypto_get_random_values_quota_exceeded_error_matches_wpt_any() {
    ensure_v8();
    // WPT's getRandomValues.any.js uses assert_throws_quotaexceedederror(),
    // which checks the modern QuotaExceededError constructor/prototype shape
    // in the worker realm, not just DOMException.name/code.
    let mut handle = spawn_worker(
        r#"
        try {
            crypto.getRandomValues(new Uint8Array(65537));
            postMessage("no-throw");
        } catch (error) {
            postMessage([
                error.name,
                error.code,
                error.constructor === QuotaExceededError,
                error instanceof QuotaExceededError,
                error instanceof DOMException,
                Object.getPrototypeOf(QuotaExceededError.prototype) === DOMException.prototype
            ].join("|"));
        }
        close();
        "#
        .into(),
        "https://worker-crypto.test/get-random-values-quota.js".into(),
    );

    let payload = recv_post_json(&mut handle).await;
    assert_eq!(payload, r#""QuotaExceededError|22|true|true|true|true""#);
}

#[tokio::test]
async fn worker_structured_clone_global_clones_plain_data_for_wpt_vectors() {
    ensure_v8();
    // WebCrypto's ECDSA WPT vector helper uses structuredClone() while running
    // in both window and worker globals. Keep the worker surface wired to the
    // same structured-clone backend as postMessage/history state.
    let mut handle = spawn_worker(
        r#"
        const source = {
            nested: { value: 7 },
            bytes: new Uint8Array([1, 2, 3]).buffer
        };
        const clone = structuredClone(source);
        source.nested.value = 9;
        new Uint8Array(source.bytes)[0] = 99;
        postMessage([
            typeof structuredClone,
            clone !== source,
            clone.nested !== source.nested,
            clone.nested.value,
            Array.from(new Uint8Array(clone.bytes)).join(",")
        ].join("|"));
        close();
        "#
        .into(),
        "https://worker-crypto.test/structured-clone-global.js".into(),
    );

    let payload = recv_post_json(&mut handle).await;
    assert_eq!(payload, r#""function|true|true|7|1,2,3""#);
}

#[tokio::test]
async fn worker_crypto_subtle_hmac_parallel_operations_match_chromium_worker_intent() {
    ensure_v8();
    // Chromium legacy test: crypto/subtle/worker-subtle-crypto-concurrent.html.
    // Chromium's original worker stress case mixes HMAC, RSA, and AES-GCM. In
    // this no-new-deps branch Moli only has vetted HMAC primitives, so
    // keep the same concurrency shape but scope it to supported HMAC work.
    const WORKER_SOURCE: &str = r#"
        const hexBytes = (value) => value.length === 0
            ? new Uint8Array([])
            : new Uint8Array(value.match(/../g).map((byte) => parseInt(byte, 16)));
        const sameBytes = (left, right) => {
            const a = new Uint8Array(left);
            const b = new Uint8Array(right);
            return a.length === b.length && a.every((value, index) => value === b[index]);
        };
        const vector = {
            hash: "SHA-256",
            key: "9779d9120642797f1747025d5b22b7ac607cab08e1758f2f3a46c8be1e25c53b8c6a8f58ffefa176",
            message: "b1689c2591eaf3c9e66070f8a77954ffb81749f1b00346f9dfe0b2ee905dcc288baf4a92de3f4001dd9f44c468c3d07d6c6ee82faceafc97c2fc0fc0601719d2dcd0aa2aec92d1b0ae933c65eb06a03c9c935c2bad0459810241347ab87e9f11adb30415424c6c7f5f22a003b8ab8de54f6ded0e3ab9245fa79568451dfa258e",
            mac: "769f00d3e6a6cc1fb426a14a4f76c6462e6149726e0dee0ec0cf97a16605ac8b"
        };
        async function runHmacRound(index) {
            const failures = [];
            const keyBytes = hexBytes(vector.key);
            const messageBytes = hexBytes(vector.message);
            const macBytes = hexBytes(vector.mac);
            const key = await crypto.subtle.importKey(
                "raw",
                keyBytes,
                { name: "HMAC", hash: { name: vector.hash } },
                true,
                ["verify", "sign"]
            );
            if (
                key.type !== "secret" ||
                key.extractable !== true ||
                key.algorithm.name !== "HMAC" ||
                key.algorithm.hash.name !== vector.hash ||
                key.algorithm.length !== keyBytes.byteLength * 8 ||
                key.usages.join(",") !== "sign,verify"
            ) {
                failures.push(`shape:${index}`);
            }
            const [signature, verified, truncatedVerified, raw, jwk, generated] = await Promise.all([
                crypto.subtle.sign("HMAC", key, messageBytes),
                crypto.subtle.verify("HMAC", key, macBytes, messageBytes),
                crypto.subtle.verify("HMAC", key, macBytes.slice(0, macBytes.byteLength - 1), messageBytes),
                crypto.subtle.exportKey("raw", key),
                crypto.subtle.exportKey("jwk", key),
                crypto.subtle.generateKey({ name: "HMAC", hash: "SHA-1", length: 40 }, true, ["sign"])
            ]);
            if (!sameBytes(signature, macBytes)) failures.push(`sign:${index}`);
            if (verified !== true) failures.push(`verify:${index}`);
            if (truncatedVerified !== false) failures.push(`truncated:${index}`);
            if (!sameBytes(raw, keyBytes)) failures.push(`raw:${index}`);
            if (
                jwk.kty !== "oct" ||
                jwk.alg !== "HS256" ||
                jwk.ext !== true ||
                jwk.key_ops.join(",") !== "sign,verify" ||
                typeof jwk.k !== "string"
            ) {
                failures.push(`jwk:${index}`);
            }
            if (
                generated.type !== "secret" ||
                generated.algorithm.name !== "HMAC" ||
                generated.algorithm.hash.name !== "SHA-1" ||
                generated.algorithm.length !== 40 ||
                generated.usages.join(",") !== "sign"
            ) {
                failures.push(`generated:${index}`);
            }
            return failures;
        }
        (async () => {
            const results = await Promise.all(Array.from({ length: 8 }, (_, index) => runHmacRound(index)));
            postMessage([].concat(...results));
        })().catch((error) => {
            postMessage(["error:" + error.name + ":" + error.message]);
        });
    "#;
    let handles = (0..4)
        .map(|index| {
            spawn_worker(
                WORKER_SOURCE.into(),
                format!("https://worker-crypto.test/subtle-hmac-parallel-{index}.js"),
            )
        })
        .collect::<Vec<_>>();

    for mut handle in handles {
        let msg = timeout(TIMEOUT, handle.recv())
            .await
            .expect("timed out")
            .expect("channel closed");
        assert_eq!(expect_post_json(msg), "[]");
        handle.terminate_and_join();
    }
}

#[tokio::test]
async fn worker_crypto_subtle_chacha20_poly1305_matches_tentative_any_intent() {
    ensure_v8();
    // The current ChaCha20-Poly1305 WebCrypto surface is still based on
    // tentative WPT, but it is exposed in both window and worker globals. Keep
    // a compact worker smoke for key import/export, AEAD, and wrapping.
    let mut handle = spawn_worker(
        r#"
        const sameBytes = (left, right) => {
            const a = new Uint8Array(left);
            const b = new Uint8Array(right);
            return a.length === b.length && a.every((value, index) => value === b[index]);
        };
        (async () => {
            const failures = [];
            const subtle = crypto.subtle;
            const keyBytes = new Uint8Array([
                0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe,
                0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81,
                0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7,
                0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4
            ]);
            const iv = new Uint8Array([
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x4a, 0x00, 0x00, 0x00, 0x00
            ]);
            const additionalData = new TextEncoder().encode("worker chacha aad");
            const data = new TextEncoder().encode("worker chacha plaintext");
            const key = await subtle.importKey(
                "raw-secret",
                keyBytes,
                "ChaCha20-Poly1305",
                true,
                ["encrypt", "decrypt", "wrapKey", "unwrapKey"]
            );
            if (
                key.type !== "secret" ||
                key.extractable !== true ||
                key.algorithm.name !== "ChaCha20-Poly1305" ||
                "length" in key.algorithm ||
                key.usages.join(",") !== "encrypt,decrypt,wrapKey,unwrapKey"
            ) {
                failures.push("shape");
            }
            if (!sameBytes(await subtle.exportKey("raw-secret", key), keyBytes)) {
                failures.push("raw-secret-export");
            }
            const algorithm = {
                name: "ChaCha20-Poly1305",
                iv,
                additionalData,
                tagLength: 128
            };
            const ciphertext = await subtle.encrypt(algorithm, key, data);
            if (!sameBytes(await subtle.decrypt(algorithm, key, ciphertext), data)) {
                failures.push("roundtrip");
            }

            const hmac = await subtle.importKey(
                "raw",
                new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]),
                { name: "HMAC", hash: "SHA-256" },
                true,
                ["sign"]
            );
            const wrapped = await subtle.wrapKey("raw", hmac, key, algorithm);
            const unwrapped = await subtle.unwrapKey(
                "raw",
                wrapped,
                key,
                algorithm,
                { name: "HMAC", hash: "SHA-256" },
                true,
                ["sign"]
            );
            if (!sameBytes(await subtle.exportKey("raw", hmac), await subtle.exportKey("raw", unwrapped))) {
                failures.push("wrap-unwrap");
            }

            postMessage(failures);
        })().catch((error) => {
            postMessage(["error:" + error.name + ":" + error.message]);
        });
        "#
        .into(),
        "https://worker-crypto.test/subtle-chacha20-poly1305.js".into(),
    );

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

#[tokio::test]
async fn worker_postmessage_accepts_cryptokey_from_secure_parent() {
    ensure_v8();
    // Chromium WPT: webmessaging/resources/post-cryptokey-to-opener.html uses
    // CryptoKey as a postMessage host object. This test exercises the same
    // structured-clone boundary in the parent -> dedicated-worker direction and
    // verifies that the deserialized key still drives SubtleCrypto operations.
    let mut handle = spawn_worker(
        r#"
        onmessage = async event => {
            const failures = [];
            const key = event.data && event.data.key;
            const data = new Uint8Array([1, 2, 3, 4]);
            if (!(key instanceof CryptoKey)) failures.push("instance");
            if (key.extraProperty !== undefined) failures.push("expando");
            if (
                key.type !== "secret" ||
                key.extractable !== true ||
                key.algorithm.name !== "HMAC" ||
                key.algorithm.hash.name !== "SHA-256" ||
                key.algorithm.length !== 32 ||
                key.usages.join(",") !== "sign,verify"
            ) {
                failures.push("shape");
            }
            const signature = await crypto.subtle.sign("HMAC", key, data);
            if (!await crypto.subtle.verify("HMAC", key, signature, data)) {
                failures.push("verify");
            }
            postMessage([
                ...failures,
                new Uint8Array(signature).byteLength
            ]);
        };
        "#
        .into(),
        "https://worker-crypto.test/receive-cryptokey.js".into(),
    );

    let payload = serialize_test_crypto_value(
        r#"
        (async () => {
            const key = await crypto.subtle.importKey(
                "raw",
                new Uint8Array([0x30, 0x11, 0x22, 0x33]),
                { name: "HMAC", hash: "SHA-256" },
                true,
                ["sign", "verify"]
            );
            key.extraProperty = "source-only";
            key.algorithm.name = "AES-GCM";
            key.usages.push("encrypt");
            return { key };
        })()
        "#,
    );
    handle.post_message(payload);

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

#[tokio::test]
async fn worker_postmessage_cryptokey_to_nonsecure_worker_fires_messageerror() {
    ensure_v8();
    // Chromium WPT: webmessaging/postMessage_CryptoKey_insecure.sub.html.
    // A receiver that does not expose secure-context-only `CryptoKey` cannot
    // deserialize the host object; the observable delivery result is
    // `messageerror`, not a successful `message` with missing data.
    let mut handle = spawn_worker(
        r#"
        onmessage = event => {
            postMessage(["message", event.type, event.data === undefined]);
        };
        onmessageerror = event => {
            postMessage([
                "messageerror",
                event.type,
                event.data === null,
                String("CryptoKey" in globalThis),
                typeof crypto.subtle
            ]);
        };
        "#
        .into(),
        "http://example.test/receive-cryptokey-insecure.js".into(),
    );

    let payload = serialize_test_crypto_value(
        r#"
        (async () => ({
            key: await crypto.subtle.importKey(
                "raw",
                new Uint8Array([0x30, 0x11, 0x22, 0x33]),
                { name: "HMAC", hash: "SHA-256" },
                true,
                ["sign"]
            )
        }))()
        "#,
    );
    handle.post_message(payload);

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"["messageerror","messageerror",true,"false","undefined"]"#
    );
}

#[tokio::test]
async fn worker_postmessage_cryptokey_exposure_ignores_public_constructor_overrides() {
    ensure_v8();
    for (url, setup, expected) in [
        (
            "https://worker-crypto.test/receive-cryptokey-override.js",
            "Object.defineProperty(globalThis, 'CryptoKey', {get() {throw new Error('public constructor read');}, configurable: true});",
            r#"["message","[object CryptoKey]"]"#,
        ),
        (
            "http://worker-crypto.test/receive-cryptokey-override.js",
            "globalThis.CryptoKey = function FakeCryptoKey() {};",
            r#"["messageerror",true]"#,
        ),
    ] {
        let callbacks = r#"
            onmessage = event => {
                postMessage([event.type, Object.prototype.toString.call(event.data.key)]);
            };
            onmessageerror = event => {
                postMessage([event.type, event.data === null]);
            };
        "#;
        let mut handle = spawn_worker(format!("{setup}\n{callbacks}"), url.into());
        let payload = serialize_test_crypto_value(
            r#"
            (async () => ({key: await crypto.subtle.importKey(
                "raw", new Uint8Array([1, 2, 3, 4]),
                {name: "HMAC", hash: "SHA-256"}, true, ["sign"]
            )}))()
            "#,
        );
        handle.post_message(payload);

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

#[tokio::test]
async fn worker_crypto_subtle_kdf_and_x25519_derivation_match_wpt_any_tests() {
    ensure_v8();
    // Chromium WPT marks WebCrypto derivation tests as `any.js`, so supported
    // derivation paths must work from dedicated workers as well as window
    // globals. Keep this worker test compact and vector-driven to cover the
    // same backend paths without duplicating the full window matrix.
    let mut handle = spawn_worker(
        r#"
        const sameBytes = (left, right) => {
            const a = new Uint8Array(left);
            const b = new Uint8Array(right);
            return a.length === b.length && a.every((value, index) => value === b[index]);
        };
        (async () => {
            const failures = [];
            const subtle = crypto.subtle;

            // Chromium legacy test:
            // crypto/subtle/hkdf/deriveBits-rfc5869-test-vectors.html.
            const hkdfInput = new Uint8Array([
                0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
                0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
                0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b
            ]);
            const hkdfSalt = new Uint8Array([
                0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
                0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c
            ]);
            const hkdfInfo = new Uint8Array([
                0xf0, 0xf1, 0xf2, 0xf3, 0xf4,
                0xf5, 0xf6, 0xf7, 0xf8, 0xf9
            ]);
            const hkdfExpected = new Uint8Array([
                0x3c, 0xb2, 0x5f, 0x25, 0xfa, 0xac, 0xd5, 0x7a,
                0x90, 0x43, 0x4f, 0x64, 0xd0, 0x36, 0x2f, 0x2a,
                0x2d, 0x2d, 0x0a, 0x90, 0xcf, 0x1a, 0x5a, 0x4c,
                0x5d, 0xb0, 0x2d, 0x56, 0xec, 0xc4, 0xc5, 0xbf,
                0x34, 0x00, 0x72, 0x08, 0xd5, 0xb8, 0x87, 0x18,
                0x58, 0x65
            ]);
            const hkdfKey = await subtle.importKey("raw", hkdfInput, "HKDF", false, ["deriveBits", "deriveKey"]);
            const hkdfParams = { name: "HKDF", hash: "SHA-256", salt: hkdfSalt, info: hkdfInfo };
            const hkdfBits = await subtle.deriveBits(hkdfParams, hkdfKey, hkdfExpected.byteLength * 8);
            if (!sameBytes(hkdfBits, hkdfExpected)) {
                failures.push("hkdf:deriveBits");
            }
            const hkdfHmac = await subtle.deriveKey(
                hkdfParams,
                hkdfKey,
                { name: "HMAC", hash: "SHA-256", length: 128 },
                true,
                ["sign"]
            );
            if (!sameBytes(await subtle.exportKey("raw", hkdfHmac), hkdfExpected.slice(0, 16))) {
                failures.push("hkdf:deriveKey:hmac");
            }

            // Chromium legacy test:
            // crypto/subtle/pbkdf2/deriveBits-rfc6070-test-vectors.html.
            const pbkdf2Password = new Uint8Array([112, 97, 115, 115, 119, 111, 114, 100]);
            const pbkdf2Salt = new Uint8Array([115, 97, 108, 116]);
            const pbkdf2Expected = new Uint8Array([
                0x0c, 0x60, 0xc8, 0x0f, 0x96, 0x1f, 0x0e, 0x71,
                0xf3, 0xa9, 0xb5, 0x24, 0xaf, 0x60, 0x12, 0x06,
                0x2f, 0xe0, 0x37, 0xa6
            ]);
            const pbkdf2Key = await subtle.importKey("raw", pbkdf2Password, "PBKDF2", false, ["deriveBits", "deriveKey"]);
            const pbkdf2Params = { name: "PBKDF2", hash: "SHA-1", salt: pbkdf2Salt, iterations: 1 };
            const pbkdf2Bits = await subtle.deriveBits(pbkdf2Params, pbkdf2Key, pbkdf2Expected.byteLength * 8);
            if (!sameBytes(pbkdf2Bits, pbkdf2Expected)) {
                failures.push("pbkdf2:deriveBits");
            }
            const pbkdf2Aes = await subtle.deriveKey(
                pbkdf2Params,
                pbkdf2Key,
                { name: "AES-CBC", length: 128 },
                true,
                ["encrypt"]
            );
            if (!sameBytes(await subtle.exportKey("raw", pbkdf2Aes), pbkdf2Expected.slice(0, 16))) {
                failures.push("pbkdf2:deriveKey:aes");
            }

            // Chromium WPT:
            // WebCryptoAPI/derive_bits_keys/cfrg_curves_bits_fixtures.js.
            const x25519Private = new Uint8Array([
                48, 46, 2, 1, 0, 48, 5, 6, 3, 43, 101, 110, 4, 34, 4, 32,
                200, 131, 142, 118, 208, 87, 223, 183, 216, 201, 90, 105,
                225, 56, 22, 10, 221, 99, 115, 253, 113, 164, 210, 118,
                187, 86, 227, 168, 27, 100, 255, 97
            ]);
            const x25519Public = new Uint8Array([
                48, 42, 48, 5, 6, 3, 43, 101, 110, 3, 33, 0, 28, 242,
                177, 230, 2, 46, 197, 55, 55, 30, 215, 245, 62, 84, 250,
                17, 84, 216, 62, 152, 235, 100, 234, 81, 250, 229, 179,
                48, 124, 254, 151, 6
            ]);
            const x25519Expected = new Uint8Array([
                39, 104, 64, 157, 250, 185, 158, 194, 59, 140, 137, 185,
                63, 245, 136, 2, 149, 247, 97, 118, 8, 143, 137, 228,
                61, 254, 190, 126, 161, 149, 0, 8
            ]);
            const x25519PrivateKey = await subtle.importKey("pkcs8", x25519Private, "X25519", false, ["deriveBits"]);
            const x25519PublicKey = await subtle.importKey("spki", x25519Public, "X25519", false, []);
            const x25519Bits = await subtle.deriveBits(
                { name: "X25519", public: x25519PublicKey },
                x25519PrivateKey,
                256
            );
            if (!sameBytes(x25519Bits, x25519Expected)) {
                failures.push("x25519:deriveBits");
            }

            postMessage(failures);
        })().catch((error) => {
            postMessage(["error:" + error.name + ":" + error.message]);
        });
        "#
        .into(),
        "https://worker-crypto.test/subtle-kdf-x25519-derivation.js".into(),
    );

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

#[tokio::test]
async fn worker_crypto_subtle_asymmetric_and_wrap_operations_match_any_global_intent() {
    ensure_v8();
    // The upstream WebCrypto suites exercise RSA, EC, EdDSA, and wrap/unwrap
    // as `any.js` tests. Keep a compact worker-global smoke so worker runtime
    // wiring cannot regress to only the HMAC/KDF subset while window coverage
    // stays green.
    let mut handle = spawn_worker(
        r#"
        const sameBytes = (left, right) => {
            const a = new Uint8Array(left);
            const b = new Uint8Array(right);
            return a.length === b.length && a.every((value, index) => value === b[index]);
        };
        (async () => {
            const failures = [];
            const subtle = crypto.subtle;
            const data = new TextEncoder().encode("worker asymmetric webcrypto");
            const raw128 = new Uint8Array([
                0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
                0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
            ]);

            const aesKw = await subtle.importKey(
                "raw",
                raw128,
                "AES-KW",
                false,
                ["wrapKey", "unwrapKey"]
            );
            const hmac = await subtle.importKey(
                "raw",
                new Uint8Array([
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 10, 11, 12, 13, 14, 15, 16
                ]),
                { name: "HMAC", hash: "SHA-256" },
                true,
                ["sign"]
            );
            const wrapped = await subtle.wrapKey("raw", hmac, aesKw, "AES-KW");
            const unwrapped = await subtle.unwrapKey(
                "raw",
                wrapped,
                aesKw,
                "AES-KW",
                { name: "HMAC", hash: "SHA-256" },
                true,
                ["sign"]
            );
            if (!sameBytes(await subtle.exportKey("raw", hmac), await subtle.exportKey("raw", unwrapped))) {
                failures.push("aes-kw-wrap-unwrap");
            }

            const rsaOaep = await subtle.generateKey(
                {
                    name: "RSA-OAEP",
                    modulusLength: 1024,
                    publicExponent: new Uint8Array([1, 0, 1]),
                    hash: "SHA-256"
                },
                true,
                ["encrypt", "decrypt"]
            );
            const rsaCiphertext = await subtle.encrypt("RSA-OAEP", rsaOaep.publicKey, data);
            if (!sameBytes(await subtle.decrypt("RSA-OAEP", rsaOaep.privateKey, rsaCiphertext), data)) {
                failures.push("rsa-oaep");
            }

            const ecdsa = await subtle.generateKey(
                { name: "ECDSA", namedCurve: "P-256" },
                true,
                ["sign", "verify"]
            );
            const ecdsaSignature = await subtle.sign(
                { name: "ECDSA", hash: "SHA-256" },
                ecdsa.privateKey,
                data
            );
            if (!await subtle.verify({ name: "ECDSA", hash: "SHA-256" }, ecdsa.publicKey, ecdsaSignature, data)) {
                failures.push("ecdsa");
            }

            const ed25519 = await subtle.generateKey("Ed25519", true, ["sign", "verify"]);
            const ed25519Signature = await subtle.sign("Ed25519", ed25519.privateKey, data);
            if (!await subtle.verify("Ed25519", ed25519.publicKey, ed25519Signature, data)) {
                failures.push("ed25519");
            }

            postMessage(failures);
        })().catch((error) => {
            postMessage(["error:" + error.name + ":" + error.message]);
        });
        "#
        .into(),
        "https://worker-crypto.test/subtle-asymmetric-and-wrap.js".into(),
    );

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

#[tokio::test]
async fn worker_crypto_subtle_hidden_in_nonsecure_context_matches_wpt_historical() {
    ensure_v8();
    // Chromium WPT: WebCryptoAPI/historical.any.js plus webcrypto.idl.
    // Dedicated workers created from non-secure origins keep `crypto` and
    // getRandomValues(), but must not expose the secure-context-only
    // randomUUID/SubtleCrypto/CryptoKey surface.
    let mut handle = spawn_worker(
        r#"
        postMessage([
            String(crypto instanceof Crypto),
            typeof crypto.getRandomValues,
            String("randomUUID" in crypto),
            typeof crypto.randomUUID,
            String("randomUUID" in Crypto.prototype),
            String("subtle" in crypto),
            typeof crypto.subtle,
            String("SubtleCrypto" in globalThis),
            typeof globalThis.SubtleCrypto,
            String("CryptoKey" in globalThis),
            typeof globalThis.CryptoKey
        ]);
        "#
        .into(),
        "http://example.test/non-secure-worker.js".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"["true","function","false","undefined","false","false","undefined","false","undefined","false","undefined"]"#
    );
}

#[tokio::test]
async fn worker_postmessage_arraybuffer_to_parent() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const bytes = new Uint8Array([7, 8, 9]);
        postMessage(bytes.buffer);
        "#
        .into(),
        "test://postmessage_arraybuffer".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Post(payload) => {
            let description = inspect_payload(
                &payload,
                r#"
                (() => [
                    __wire.constructor.name,
                    __wire.byteLength,
                    Array.from(new Uint8Array(__wire)).join(',')
                ].join('|'))()
                "#,
            );
            assert_eq!(description, "ArrayBuffer|3|7,8,9");
        }
        other => panic!("expected Post, got {other:?}"),
    }
}

#[tokio::test]
async fn worker_postmessage_image_data_to_parent_preserves_interface_and_pixels() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const imageData = new ImageData(new Uint8ClampedArray([1, 2, 3, 4]), 1, 1);
        imageData.data[0] = 128;
        postMessage(imageData);
        "#
        .into(),
        "test://postmessage_imagedata".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Post(payload) => {
            let description = inspect_payload_with_image_data(
                &payload,
                r#"
                (() => [
                    '' + __wire,
                    __wire.width,
                    __wire.height,
                    __wire.colorSpace,
                    Array.from(__wire.data).join(',')
                ].join('|'))()
                "#,
            );
            assert_eq!(description, "[object ImageData]|1|1|srgb|128,2,3,4");
        }
        other => panic!("expected Post, got {other:?}"),
    }
}

#[tokio::test]
async fn worker_broadcast_channel_delivers_structured_data() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const receiver = new BroadcastChannel("plain-worker");
        const sender = new BroadcastChannel("plain-worker");
        receiver.onmessage = event => {
            postMessage([
                event.data.marker,
                event.data.nested.text,
                event.data.list.join(','),
                event.origin,
                event.ports.length,
                receiver.name
            ].join('|'));
        };
        sender.postMessage({
            marker: 23,
            nested: { text: "worker" },
            list: [3, 4]
        });
        "#
        .into(),
        "https://worker.example/broadcast".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#""23|worker|3,4|https://worker.example|0|plain-worker""#
    );
}

#[tokio::test]
async fn worker_broadcast_channel_postmessage_preserves_webassembly_module() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const receiver = new BroadcastChannel("wasm-module-worker");
        const sender = new BroadcastChannel("wasm-module-worker");
        const module = new WebAssembly.Module(
            new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0])
        );
        receiver.onmessage = event => {
            const instance = new WebAssembly.Instance(event.data.module, {});
            postMessage([
                event instanceof MessageEvent,
                event.data.module instanceof WebAssembly.Module,
                event.data.module === module,
                Object.keys(instance.exports).length,
                event.data.label,
                event.origin,
                event.ports.length,
                receiver.name
            ].join('|'));
        };
        sender.postMessage({ label: "wasm", module });
        "#
        .into(),
        "https://worker.example/broadcast-wasm-module".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#""true|true|false|0|wasm|https://worker.example|0|wasm-module-worker""#
    );
}

#[tokio::test]
async fn worker_broadcast_channel_postmessage_after_self_close_is_ignored() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const receiver = new BroadcastChannel("closed-worker-postmessage");
        receiver.onmessage = () => postMessage("unexpected");
        const sender = new BroadcastChannel("closed-worker-postmessage");
        close();
        sender.postMessage("leak");
        postMessage("done");
        "#
        .into(),
        "https://worker.example/broadcast-close-after-create".into(),
    );

    assert_eq!(recv_post_json(&mut handle).await, r#""done""#);
    let result = timeout(TIMEOUT, handle.recv()).await.expect("timed out");
    assert!(
        result.is_none(),
        "closed worker BroadcastChannel should not deliver after self.close(): {result:?}"
    );
}

#[tokio::test]
async fn worker_broadcast_channel_created_after_self_close_is_detached() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        close();
        const receiver = new BroadcastChannel("closed-worker-create");
        receiver.onmessage = () => postMessage("unexpected");
        const sender = new BroadcastChannel("closed-worker-create");
        sender.postMessage("leak");
        postMessage("done:" + receiver.name + ":" + sender.name);
        "#
        .into(),
        "https://worker.example/broadcast-close-before-create".into(),
    );

    assert_eq!(
        recv_post_json(&mut handle).await,
        r#""done:closed-worker-create:closed-worker-create""#
    );
    let result = timeout(TIMEOUT, handle.recv()).await.expect("timed out");
    assert!(
        result.is_none(),
        "BroadcastChannel created after self.close() should stay detached: {result:?}"
    );
}

#[tokio::test]
async fn data_url_workers_do_not_share_broadcast_channel_by_null_origin() {
    ensure_v8();
    let registry = crate::broadcast_channel_runtime::new_broadcast_channel_registry();
    let top_level_site = Some("https://app.example".to_owned());

    let receiver_source = r#"
        const channel = new BroadcastChannel("opaque-worker");
        let sawMessage = false;
        channel.onmessage = event => {
            sawMessage = true;
            postMessage("unexpected:" + event.data + ":" + event.origin);
        };
        onmessage = event => {
            if (event.data === "report") {
                postMessage(sawMessage ? "receiver-received" : "receiver-silent");
            }
        };
        postMessage("receiver-ready");
    "#;
    let mut receiver =
        crate::worker::thread::spawn_worker_with_request_client_and_kind_network_policy_and_broadcast_channel_registry(
            receiver_source.into(),
            worker_data_url(receiver_source),
            worker_test_request_client(),
            WorkerScriptKind::Classic,
            crate::worker::handle::WorkerNetworkPolicy::default(),
            registry.clone(),
            top_level_site.clone(),
            None,
        );

    let sender_source = r#"
        const channel = new BroadcastChannel("opaque-worker");
        onmessage = event => {
            if (event.data === "go") {
                channel.postMessage("leak");
                postMessage("sender-sent");
            }
        };
        postMessage("sender-ready");
    "#;
    let mut sender =
        crate::worker::thread::spawn_worker_with_request_client_and_kind_network_policy_and_broadcast_channel_registry(
            sender_source.into(),
            worker_data_url(sender_source),
            worker_test_request_client(),
            WorkerScriptKind::Classic,
            crate::worker::handle::WorkerNetworkPolicy::default(),
            registry,
            top_level_site,
            None,
        );

    assert_eq!(recv_post_json(&mut receiver).await, r#""receiver-ready""#);
    assert_eq!(recv_post_json(&mut sender).await, r#""sender-ready""#);

    sender.post_message(serialize_test_string("go"));
    assert_eq!(recv_post_json(&mut sender).await, r#""sender-sent""#);

    receiver.post_message(serialize_test_string("report"));
    assert_eq!(recv_post_json(&mut receiver).await, r#""receiver-silent""#);

    sender.terminate();
    receiver.terminate();
}

#[tokio::test]
async fn nested_worker_broadcast_channel_inherits_parent_storage_key() {
    ensure_v8();
    let registry = crate::broadcast_channel_runtime::new_broadcast_channel_registry();
    let browser_context_runtime =
        crate::runtime::RendererBrowserContextRuntime::new_with_registries_for_test(
            crate::message_port_runtime::new_message_port_registry(),
            registry,
        );
    let creator_storage_key = moli_storage_key::MoliStorageKey::new(
        "null".to_owned(),
        "https://top.example".to_owned(),
        Some(moli_storage_key::OpaqueOriginNonce::new(19)),
        moli_storage_key::StoragePartitionRelation::Unknown,
    );

    let source = r#"
        const parentChannel = new BroadcastChannel("nested-worker-owner-key");
        parentChannel.onmessage = event => {
            postMessage("parent:" + event.data + ":" + event.origin);
            close();
        };
        const childSource = `
            const childChannel = new BroadcastChannel("nested-worker-owner-key");
            childChannel.onmessage = event => {
                childChannel.postMessage("child-saw:" + event.origin);
            };
            postMessage("ready");
        `;
        const childUrl = URL.createObjectURL(
            new Blob([childSource], { type: "text/javascript" })
        );
        const child = new Worker(childUrl);
        child.onmessage = event => {
            if (event.data === "ready") {
                parentChannel.postMessage("ping");
            }
        };
        child.onerror = event => {
            postMessage("child-error:" + event.message);
            close();
        };
    "#;
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(source.into(), "blob:null/parent-worker".into())
            .with_worker_context_runtime(browser_context_runtime.worker_context_runtime())
            .with_storage_key_top_level_site(Some("https://ignored.example".to_owned()))
            .with_creator_storage_key(creator_storage_key),
    );

    assert_eq!(
        recv_post_json(&mut handle).await,
        r#""parent:child-saw:null:null""#
    );
    handle.terminate();
}

#[tokio::test]
async fn worker_postmessage_wasm_module_to_parent_preserves_module() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const bytes = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0]);
        postMessage(new WebAssembly.Module(bytes));
        "#
        .into(),
        "test://postmessage_wasm_module".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Post(payload) => {
            assert!(payload.metadata.contains_wasm_module);
            assert!(payload.metadata.origin_check_required);
            assert!(payload.metadata.locked_to_sender_agent_cluster);
            let description = inspect_payload(
                &payload,
                r#"
                (() => {
                    const instance = new WebAssembly.Instance(__wire, {});
                    return [
                        __wire instanceof WebAssembly.Module,
                        Object.keys(instance.exports).length
                    ].join('|');
                })()
                "#,
            );
            assert_eq!(description, "true|0");
        }
        other => panic!("expected Post, got {other:?}"),
    }
}

#[tokio::test]
async fn worker_postmessage_wasm_module_from_parent_preserves_module() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        onmessage = function(event) {
            const instance = new WebAssembly.Instance(event.data, {});
            postMessage([
                event.data instanceof WebAssembly.Module,
                Object.keys(instance.exports).length
            ].join('|'));
        };
        "#
        .into(),
        "test://postmessage_wasm_module_from_parent".into(),
    );

    let payload = serialize_test_post_message_value(
        "new WebAssembly.Module(new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0]))",
    );
    assert!(payload.metadata.contains_wasm_module);
    assert!(payload.metadata.origin_check_required);
    assert!(payload.metadata.locked_to_sender_agent_cluster);
    handle.post_message(payload);

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

#[tokio::test]
async fn worker_notification_data_rejects_webassembly_module_for_storage() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const createModule = () => new WebAssembly.Module(
            new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0])
        );
        const probe = (value) => {
            try {
                new Notification("title", { data: value });
                return "ok";
            } catch (error) {
                return error && error.name;
            }
        };

        let before = false;
        let after = false;
        const interleaved = probe([
            { get x() { before = true; return 1; } },
            createModule(),
            { get x() { after = true; return 2; } }
        ]);
        const plain = new Notification("plain", { data: { answer: 42 } });
        const missing = new Notification("missing");
        const explicitUndefined = new Notification(
            "explicit",
            { data: undefined }
        );
        const constructorActions = (() => {
            try {
                new Notification("actions", {
                    actions: [{ action: "reply", title: "Reply" }]
                });
                return "ok";
            } catch (error) {
                return error && error.name;
            }
        })();

        postMessage([
            typeof Notification,
            Notification.permission,
            Notification.maxActions,
            typeof Notification.requestPermission,
            plain.title,
            plain.actions.length,
            plain.data.answer,
            missing.data === null,
            explicitUndefined.data === null,
            constructorActions,
            probe(createModule()),
            interleaved,
            before,
            after
        ].join("|"));
        "#
        .into(),
        "https://example.test/worker_notification_storage_clone.js".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#""function|default|2|function|plain|0|42|true|true|TypeError|DataCloneError|DataCloneError|true|false""#
    );
}

#[tokio::test]
async fn worker_notification_permission_tracks_permission_overrides() {
    ensure_v8();
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            (async () => {
              const requested = await Notification.requestPermission();
              postMessage([Notification.permission, requested].join("|"));
            })().catch(error => {
              postMessage("error:" + error.name);
            });
            "#
            .into(),
            "https://example.test/worker-notification-permission.js".into(),
        )
        .with_network_policy(WorkerNetworkPolicy {
            permission_overrides: vec![crate::protocol_types::PermissionOverrideRegistration {
                permission: serde_json::Value::String("notifications".to_owned()),
                setting: "granted".to_owned(),
                origin: None,
                embedded_origin: None,
            }],
            ..WorkerNetworkPolicy::default()
        }),
    );

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

#[tokio::test]
async fn worker_postmessage_arraybuffer_transfer_to_parent_detaches_sender() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const buffer = new Uint8Array([7, 8, 9]).buffer;
        postMessage(buffer, [buffer]);
        postMessage(buffer.byteLength);
        "#
        .into(),
        "test://postmessage_arraybuffer_transfer".into(),
    );

    let first = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match first {
        WorkerToParentMessage::Post(payload) => {
            let description = inspect_payload(
                &payload,
                r#"
                (() => [
                    __wire.constructor.name,
                    __wire.byteLength,
                    Array.from(new Uint8Array(__wire)).join(',')
                ].join('|'))()
                "#,
            );
            assert_eq!(description, "ArrayBuffer|3|7,8,9");
        }
        other => panic!("expected Post, got {other:?}"),
    }

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

#[tokio::test]
async fn worker_postmessage_transfer_rejects_invalid_entry() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        try {
            postMessage("nope", [new Uint8Array([1])]);
            postMessage("unexpected");
        } catch (error) {
            postMessage(error.name);
        }
        "#
        .into(),
        "test://postmessage_transfer_invalid".into(),
    );

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

#[tokio::test]
async fn worker_postmessage_rejects_wasm_memory_buffer_transfer_with_type_error() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        try {
            const buffer = new WebAssembly.Memory({ initial: 1 }).buffer;
            postMessage("nope", [buffer]);
            postMessage("unexpected");
        } catch (error) {
            postMessage({
                name: error && error.name,
                dataClone: error instanceof DOMException && error.name === "DataCloneError",
            });
        }
        "#
        .into(),
        "test://postmessage_wasm_memory_buffer_transfer".into(),
    );

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

// ─── Ping-pong ──────────────────────────────────────────────────────

#[tokio::test]
async fn worker_pingpong() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        onmessage = function(e) {
            postMessage("pong:" + e.data);
        };
        "#
        .into(),
        "test://pingpong".into(),
    );

    handle.post_message(serialize_test_string("ping"));

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

#[tokio::test]
async fn worker_onmessage_receives_messageevent_instance() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        onmessage = function(event) {
            postMessage({
                isMessageEvent: event instanceof MessageEvent,
                typeString: Object.prototype.toString.call(event),
                type: event.type,
                data: event.data
            });
        };
        "#
        .into(),
        "test://onmessage_event_instance".into(),
    );

    handle.post_message(serialize_test_string("ping"));

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"isMessageEvent":true,"typeString":"[object MessageEvent]","type":"message","data":"ping"}"#
    );
}

#[tokio::test]
async fn worker_pingpong_object_payload() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        onmessage = function(e) {
            postMessage({
                nestedValue: e.data && e.data.nested && e.data.nested.value,
                listLength: Array.isArray(e.data && e.data.list) ? e.data.list.length : -1
            });
        };
        "#
        .into(),
        "test://pingpong_object".into(),
    );

    handle.post_message(serialize_test_value(
        r#"({ nested: { value: "ok" }, list: [1, 2, 3] })"#,
    ));

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"nestedValue":"ok","listLength":3}"#
    );
}

#[tokio::test]
async fn worker_arraybuffer_round_trip_supports_dataview() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        onmessage = function(event) {
            const view = new DataView(event.data);
            postMessage(new Uint8Array([view.getUint8(0) + 1, view.getUint8(1) + 1]));
        };
        "#
        .into(),
        "test://arraybuffer_round_trip".into(),
    );

    handle.post_message(serialize_test_value("new Uint8Array([40, 41]).buffer"));

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    match msg {
        WorkerToParentMessage::Post(payload) => {
            let description = inspect_payload(
                &payload,
                r#"
                (() => [
                    __wire.constructor.name,
                    __wire.length,
                    Array.from(__wire).join(','),
                    String(__wire.buffer instanceof ArrayBuffer)
                ].join('|'))()
                "#,
            );
            assert_eq!(description, "Uint8Array|2|41,42|true");
        }
        other => panic!("expected Post, got {other:?}"),
    }
}

// ─── Multiple messages ──────────────────────────────────────────────

#[tokio::test]
async fn worker_multiple_messages() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        let count = 0;
        onmessage = function(e) {
            count++;
            postMessage(count);
        };
        "#
        .into(),
        "test://multi_msg".into(),
    );

    for expected in 1..=3 {
        handle.post_message(serialize_test_string("go"));
        let msg = timeout(TIMEOUT, handle.recv())
            .await
            .expect("timed out")
            .expect("channel closed");
        assert_eq!(expect_post_json(msg), expected.to_string());
    }
}

// ─── Terminate ──────────────────────────────────────────────────────

#[tokio::test]
async fn worker_terminate() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        onmessage = function(e) {
            postMessage("alive");
        };
        "#
        .into(),
        "test://terminate".into(),
    );

    handle.post_message(serialize_test_string("check"));
    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert!(matches!(msg, WorkerToParentMessage::Post(_)));

    handle.terminate();

    let result = timeout(TIMEOUT, handle.recv()).await.expect("timed out");
    assert!(
        result.is_none(),
        "expected channel to close after terminate"
    );
}

#[tokio::test]
async fn nested_worker_terminate_drops_pending_messages() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const child = new Worker('data:text/javascript,postMessage(%22queued%22);');
        setTimeout(() => {
            child.terminate();
            child.onmessage = () => postMessage("bad");
            setTimeout(() => postMessage("done"), 0);
        }, 20);
        "#
        .into(),
        "https://nested-worker-terminate.test/parent.js".into(),
    );

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

    handle.terminate();
}

// ─── self.close() ───────────────────────────────────────────────────

#[tokio::test]
async fn worker_self_close() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        postMessage("before_close");
        close();
        "#
        .into(),
        "test://self_close".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert!(matches!(msg, WorkerToParentMessage::Post(_)));

    let result = timeout(TIMEOUT, handle.recv()).await.expect("timed out");
    assert!(
        result.is_none(),
        "expected channel to close after self.close()"
    );
}

// ─── Error propagation ──────────────────────────────────────────────

#[tokio::test]
async fn worker_does_not_expose_window_worklet_interfaces() {
    ensure_v8();
    let mut handle = spawn_worker(
        "postMessage({Worklet: 'Worklet' in self, AudioWorklet: 'AudioWorklet' in self}); close();"
            .to_owned(),
        "https://worklet-worker.test/worker.js".into(),
    );
    let message = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(message),
        r#"{"Worklet":false,"AudioWorklet":false}"#
    );
}

#[tokio::test]
async fn worker_error_propagation() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        throw new Error("worker error");
        "#
        .into(),
        "test://error".into(),
    );

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

#[tokio::test]
async fn worker_origin_is_replaceable_across_worker_global_kinds() {
    ensure_v8();
    let storage_key = moli_storage_key::MoliStorageKey::new(
        "https://origin.test".to_owned(),
        "https://origin.test".to_owned(),
        None,
        moli_storage_key::StoragePartitionRelation::FirstParty,
    );
    let dedicated = super::super::WorkerGlobalKind::Dedicated {
        name: String::new(),
    };
    let cases = [
        (
            dedicated.clone(),
            "https://origin.test/worker.js",
            "https://origin.test",
        ),
        (dedicated.clone(), "data:text/javascript,", "null"),
        (
            dedicated,
            "blob:https://origin.test/worker-script",
            "https://origin.test",
        ),
        (
            super::super::WorkerGlobalKind::Shared {
                name: "origin".to_owned(),
                storage_key,
            },
            "https://origin.test/shared.js",
            "https://origin.test",
        ),
        (
            super::super::WorkerGlobalKind::Service {
                registration_id: ServiceWorkerRegistrationId::from_u64_for_test(1),
                version_id: ServiceWorkerVersionId::from_u64_for_test(1),
                scope_url: url::Url::parse("https://origin.test/").unwrap(),
            },
            "https://origin.test/sw.js",
            "https://origin.test",
        ),
    ];
    let probe = r#"
        function check(value, message) {
            if (!value) throw new Error(message);
        }
        function throwsTypeError(callback) {
            try { callback(); } catch (error) { return error instanceof TypeError; }
            return false;
        }
        function checkRequestReferrer() {
            const allowed = 'https://origin.test/referrer';
            const expected = expectedOrigin === 'null' ? 'about:client' : allowed;
            check(new Request('https://origin.test/resource', {referrer: allowed}).referrer === expected,
                  'Request referrer uses the internal worker origin');
            check(new Request('https://origin.test/resource', {referrer: 'https://other.test/referrer'}).referrer === 'about:client',
                  'Request rejects a cross-origin referrer');
        }
        const descriptor = Object.getOwnPropertyDescriptor(WorkerGlobalScope.prototype, 'origin');
        check(typeof descriptor?.get === 'function' && typeof descriptor.set === 'function', 'prototype accessor');
        check(descriptor.enumerable && descriptor.configurable, 'accessor flags');
        check(descriptor.get.length === 0 && descriptor.set.length === 1, 'accessor lengths');
        check(descriptor.get.name === 'get origin' && descriptor.set.name === 'set origin', 'accessor names');
        check(!Object.hasOwn(self, 'origin'), 'no initial own origin');
        check(self.origin === expectedOrigin && location.origin === expectedOrigin, 'initial origin');
        checkRequestReferrer();
        check(descriptor.get.call(null) === expectedOrigin && descriptor.get.call(undefined) === expectedOrigin, 'default getter receiver');

        const replacement = { [Symbol.toPrimitive]() { throw new Error('must not convert'); } };
        check(Reflect.set(WorkerGlobalScope.prototype, 'origin', replacement, self), 'replace through prototype');
        const own = Object.getOwnPropertyDescriptor(self, 'origin');
        check(own.value === replacement && own.writable && own.enumerable && own.configurable, 'replacement descriptor');
        check(descriptor.get.call(self) === expectedOrigin && location.origin === expectedOrigin, 'internal origin survives replacement');
        checkRequestReferrer();
        self.origin = 'https://other.test';
        check(self.origin === 'https://other.test', 'replace with a different origin');
        checkRequestReferrer();
        const symbol = Symbol('replacement');
        (() => { 'use strict'; self.origin = symbol; })();
        check(self.origin === symbol, 'strict assignment preserves value');
        check(delete self.origin, 'delete replacement');
        check(self.origin === expectedOrigin, 'deletion restores internal origin');

        for (const receiver of [{}, Object.create(self), WorkerGlobalScope.prototype, new Proxy(self, {})]) {
            const before = Object.getOwnPropertyDescriptor(receiver, 'origin');
            check(throwsTypeError(() => descriptor.get.call(receiver)), 'getter receiver check');
            check(throwsTypeError(() => descriptor.set.call(receiver, replacement)), 'setter receiver check');
            const after = Object.getOwnPropertyDescriptor(receiver, 'origin');
            check(after?.get === before?.get && after?.set === before?.set && after?.value === before?.value, 'invalid receiver not mutated');
            check(Object.hasOwn(receiver, 'origin') === (before !== undefined), 'invalid receiver own property unchanged');
        }
        descriptor.set.call(null, replacement);
        check(self.origin === replacement, 'default setter receiver');
        delete self.origin;
        descriptor.set.call(self);
        check(Object.hasOwn(self, 'origin') && self.origin === undefined, 'missing setter value');
        delete self.origin;

        const observed = (0, eval)("var origin; var originValues = []; for (origin of ['same-origin', 'cross-origin']) originValues.push(origin); originValues;");
        check(observed.join('|') === 'same-origin|cross-origin', 'global var assignments');
        delete self.origin;
        check(self.origin === expectedOrigin, 'origin survives global var assignments');

        Object.defineProperty(self, 'origin', {value: 'locked', writable: false, enumerable: true, configurable: false});
        check(throwsTypeError(() => descriptor.set.call(self, 'new')), 'failed replacement throws');
        check(self.origin === 'locked' && descriptor.get.call(self) === expectedOrigin, 'failed replacement preserves values');
        checkRequestReferrer();
    "#;
    for (kind, script_url, expected_origin) in cases {
        let (bootstrap_tx, mut bootstrap_rx) = tokio::sync::mpsc::unbounded_channel();
        let source = format!(
            "const expectedOrigin = {};\n{probe}",
            serde_json::to_string(expected_origin).unwrap(),
        );
        let handle = spawn_test_worker_with_options(
            WorkerSpawnOptions::new(source, script_url.to_owned())
                .with_global_kind(kind)
                .with_bootstrap_completion_sender(bootstrap_tx),
        );
        let bootstrap = timeout(TIMEOUT, bootstrap_rx.recv())
            .await
            .expect("origin probe should finish")
            .expect("origin probe should report completion");
        handle.terminate_and_join();
        bootstrap.result.unwrap_or_else(|error| {
            panic!("Worker origin probe failed for {script_url}: {error:?}")
        });
    }
}

#[tokio::test]
async fn worker_performance_now_uses_readonly_monotonic_time_origin() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const original = performance;
        const globalDescriptor = Object.getOwnPropertyDescriptor(
            WorkerGlobalScope.prototype,
            "performance"
        );
        const timeOriginDescriptor = Object.getOwnPropertyDescriptor(
            Performance.prototype,
            "timeOrigin"
        );
        const before = original.timeOrigin;
        try { original.timeOrigin = before + 1000000; } catch (_) {}
        const after = original.timeOrigin;
        const first = original.now();
        const second = original.now();
        const replacement = {};
        self.performance = replacement;
        postMessage({
            interfaceShape:
                original instanceof Performance
                && original instanceof EventTarget
                && Object.getPrototypeOf(original) === Performance.prototype,
            globalAccessor:
                typeof globalDescriptor?.get === "function"
                && typeof globalDescriptor?.set === "function"
                && globalDescriptor.enumerable === true,
            timeOriginAccessor:
                typeof timeOriginDescriptor?.get === "function"
                && timeOriginDescriptor?.set === undefined
                && timeOriginDescriptor.enumerable === true,
            unchanged: after === before,
            numeric: typeof first === "number" && typeof second === "number",
            monotonic: second >= first,
            replaceable:
                performance === replacement
                && Object.prototype.hasOwnProperty.call(self, "performance"),
            originalStillWorks: typeof original.now() === "number",
            noLegacyMemory: !("memory" in original) && !("MemoryInfo" in self)
        });
        close();
        "#
        .into(),
        "test://worker_performance_now".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"interfaceShape":true,"globalAccessor":true,"timeOriginAccessor":true,"unchanged":true,"numeric":true,"monotonic":true,"replaceable":true,"originalStillWorks":true,"noLegacyMemory":true}"#
    );
}

#[tokio::test]
async fn worker_user_timing_uses_shared_mark_measure_runtime() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const capture = callback => {
            try {
                callback();
                return "none";
            } catch (error) {
                return error.name;
            }
        };
        const timingNames = [
            "navigationStart",
            "unloadEventStart",
            "unloadEventEnd",
            "redirectStart",
            "redirectEnd",
            "fetchStart",
            "domainLookupStart",
            "domainLookupEnd",
            "connectStart",
            "connectEnd",
            "secureConnectionStart",
            "requestStart",
            "responseStart",
            "responseEnd",
            "domLoading",
            "domInteractive",
            "domContentLoadedEventStart",
            "domContentLoadedEventEnd",
            "domComplete",
            "loadEventStart",
            "loadEventEnd"
        ];
        const timingNamesAccepted = timingNames.every(name => {
            const mark = performance.mark(name, { startTime: 1 });
            performance.clearMarks(name);
            const measure = performance.measure(name);
            performance.clearMeasures(name);
            return mark.name === name && measure.name === name;
        });

        const sourceDetail = { state: "before" };
        const mark = performance.mark("worker-mark", {
            startTime: 2,
            detail: sourceDetail
        });
        sourceDetail.state = "after";
        const measure = performance.measure("worker-measure", {
            start: "worker-mark",
            end: 5,
            detail: { kind: "measure" }
        });
        const detached = new PerformanceMark("detached", {
            startTime: 3,
            detail: { kind: "detached" }
        });
        const reservedBoundary = capture(() => {
            performance.mark("navigationStart", { startTime: 4 });
            performance.measure("reserved", "navigationStart", "navigationStart");
        });

        postMessage({
            timingNamesAccepted,
            interfaces:
                performance instanceof Performance
                && mark instanceof PerformanceMark
                && mark instanceof PerformanceEntry
                && measure instanceof PerformanceMeasure
                && measure instanceof PerformanceEntry
                && detached instanceof PerformanceMark,
            inheritance:
                Object.getPrototypeOf(Performance) === EventTarget
                && Object.getPrototypeOf(PerformanceMark) === PerformanceEntry
                && Object.getPrototypeOf(PerformanceMeasure) === PerformanceEntry,
            mark: [
                mark.name,
                mark.entryType,
                mark.startTime,
                mark.duration,
                mark.detail.state,
                mark.detail === sourceDetail
            ].join(":"),
            measure: [
                measure.name,
                measure.entryType,
                measure.startTime,
                measure.duration,
                measure.detail.kind
            ].join(":"),
            entryIds:
                Number.isSafeInteger(mark.id)
                && mark.id > 0
                && Number.isSafeInteger(measure.id)
                && measure.id > mark.id
                && mark.navigationId === 0
                && measure.navigationId === 0
                && detached.id === 0
                && detached.navigationId === 0
                && mark.toJSON().id === mark.id
                && mark.toJSON().navigationId === 0,
            detachedTimelineCount:
                performance.getEntriesByName("detached", "mark").length,
            bufferedTypes: performance.getEntries()
                .map(entry => entry.entryType)
                .join(","),
            reservedBoundary,
            missingBoundary: capture(() =>
                performance.measure("missing", "not-a-mark")),
            markBrand: capture(() => performance.mark.call({}, "bad")),
            nowBrand: capture(() => performance.now.call({}))
        });
        close();
        "#
        .into(),
        "test://worker_user_timing".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"timingNamesAccepted":true,"interfaces":true,"inheritance":true,"mark":"worker-mark:mark:2:0:before:false","measure":"worker-measure:measure:2:3:measure","entryIds":true,"detachedTimelineCount":0,"bufferedTypes":"mark,measure,mark","reservedBoundary":"TypeError","missingBoundary":"SyntaxError","markBrand":"TypeError","nowBrand":"TypeError"}"#
    );
}

#[tokio::test]
async fn worker_performance_observer_delivers_live_and_buffered_user_timing_entries() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const firstObserver = new PerformanceObserver((list, observer) => {
            const liveEntries = list.getEntries();
            observer.disconnect();
            const bufferedObserver = new PerformanceObserver(bufferedList => {
                const bufferedEntries = bufferedList.getEntries();
                postMessage({
                    interfaces:
                        firstObserver instanceof PerformanceObserver
                        && list instanceof PerformanceObserverEntryList,
                    prototypeMethods:
                        typeof list.getEntries === "function"
                        && typeof list.getEntriesByType === "function"
                        && typeof list.getEntriesByName === "function",
                    supportedEntryTypes: PerformanceObserver.supportedEntryTypes.join(","),
                    live: liveEntries
                        .map(entry => `${entry.name}:${entry.entryType}`)
                        .join(","),
                    liveMarks: list.getEntriesByType("mark").length,
                    namedMeasure: list.getEntriesByName("worker-observed-measure", "measure").length,
                    buffered: bufferedEntries
                        .map(entry => `${entry.name}:${entry.entryType}`)
                        .join(",")
                });
                bufferedObserver.disconnect();
                close();
            });
            bufferedObserver.observe({ type: "mark", buffered: true });
        });
        firstObserver.observe({ entryTypes: ["mark", "measure"] });
        performance.mark("worker-observed-mark", { startTime: 1 });
        performance.measure("worker-observed-measure", {
            start: 1,
            end: 3
        });
        "#
        .into(),
        "test://worker_performance_observer".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"interfaces":true,"prototypeMethods":true,"supportedEntryTypes":"mark,measure,resource","live":"worker-observed-mark:mark,worker-observed-measure:measure","liveMarks":1,"namedMeasure":1,"buffered":"worker-observed-mark:mark"}"#
    );
}

#[tokio::test]
async fn worker_webgl_interfaces_share_native_value_and_event_bindings() {
    ensure_v8();
    let source = format!(
        "({}).then(passed => {{ postMessage({{ passed, failures: __nodeReplacementResults.failures }}); close(); }}, error => {{ postMessage({{ passed: false, failures: [String(error)] }}); close(); }});",
        include_str!("../../../script_vm/tests/webgl_interfaces.js")
    );
    let mut handle = spawn_worker(source, "test://worker-webgl-interfaces".into());
    let message = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(message),
        r#"{"passed":true,"failures":[]}"#
    );
}

#[tokio::test]
async fn worker_offscreen_canvas_exposes_webgl_identity_consistently() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const canvas = new OffscreenCanvas(1, 1);
        const gl = canvas.getContext("webgl");
        const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
        const twoDimensional = new OffscreenCanvas(1, 1).getContext("2d");
        postMessage({
            offscreenCanvas: typeof OffscreenCanvas,
            offscreen2d: typeof OffscreenCanvasRenderingContext2D,
            webgl: typeof WebGLRenderingContext,
            webgl2: typeof WebGL2RenderingContext,
            extensionGlobal: typeof WEBGL_debug_renderer_info,
            contextInstance: gl instanceof WebGLRenderingContext,
            twoDimensionalInstance:
                twoDimensional instanceof OffscreenCanvasRenderingContext2D,
            vendor: gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL),
            renderer: gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL)
        });
        close();
        "#
        .into(),
        "test://worker_offscreen_canvas_webgl".into(),
    );

    let msg = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(msg),
        r#"{"offscreenCanvas":"function","offscreen2d":"function","webgl":"function","webgl2":"function","extensionGlobal":"undefined","contextInstance":true,"twoDimensionalInstance":true,"vendor":"","renderer":""}"#
    );
}

#[tokio::test]
async fn shared_worker_message_port_handler_can_reply_with_performance_now() {
    ensure_v8();
    let (port_wake_tx, mut port_wake_rx) = tokio::sync::mpsc::unbounded_channel();
    let registry = crate::message_port_runtime::new_message_port_registry();

    let browser_context_runtime =
        crate::runtime::RendererBrowserContextRuntime::new_with_registries_for_test(
            registry.clone(),
            crate::broadcast_channel_runtime::new_broadcast_channel_registry(),
        );
    let storage_key = moli_storage_key::MoliStorageKey::new(
        "https://app.example".to_owned(),
        "https://app.example".to_owned(),
        None,
        moli_storage_key::StoragePartitionRelation::FirstParty,
    );
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            addEventListener("connect", event => {
                const port = event.ports[0];
                port.onmessage = () => {
                    port.postMessage([
                        typeof workerStart,
                        typeof performance,
                        typeof performance.now,
                        performance.now()
                    ]);
                    port.close();
                };
            });
            "#
            .into(),
            "https://app.example/shared-worker-performance-now.js".into(),
        )
        .with_worker_context_runtime(browser_context_runtime.worker_context_runtime())
        .with_global_kind(super::super::WorkerGlobalKind::Shared {
            name: "shared".to_owned(),
            storage_key,
        }),
    );

    let first = connect_shared_worker_test_port_and_read_now(
        &mut handle,
        &registry,
        &port_wake_tx,
        &mut port_wake_rx,
    )
    .await;
    let second = connect_shared_worker_test_port_and_read_now(
        &mut handle,
        &registry,
        &port_wake_tx,
        &mut port_wake_rx,
    )
    .await;
    assert!(
        second >= first,
        "reused SharedWorker connection should compute a fresh performance.now() value"
    );
}

#[tokio::test]
async fn shared_worker_navigator_exposes_canonical_user_agent_data() {
    ensure_v8();
    const USER_AGENT: &str = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.1.2.3 Safari/537.36";
    let (port_wake_tx, mut port_wake_rx) = tokio::sync::mpsc::unbounded_channel();
    let registry = crate::message_port_runtime::new_message_port_registry();
    let browser_context_runtime =
        crate::runtime::RendererBrowserContextRuntime::new_with_registries_for_test(
            registry.clone(),
            crate::broadcast_channel_runtime::new_broadcast_channel_registry(),
        );
    let storage_key = moli_storage_key::MoliStorageKey::new(
        "https://app.example".to_owned(),
        "https://app.example".to_owned(),
        None,
        moli_storage_key::StoragePartitionRelation::FirstParty,
    );
    let mut config = FetchConfig::default();
    config.set_user_agent(USER_AGENT);
    config.push_default_request_header("Accept-Language", "de-DE,de;q=0.8");
    let loader = ResourceRequestClient::new(&config).expect("shared worker loader");
    let mut handle = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            r#"
            addEventListener("connect", event => {
                const port = event.ports[0];
                const uaData = navigator.userAgentData;
                Promise.all([
                    uaData.getHighEntropyValues([]),
                    uaData.getHighEntropyValues(["architecture"])
                ]).then(([empty, selected]) => {
                    port.postMessage({
                        constructorType: typeof NavigatorUAData,
                        dataType: typeof uaData,
                        instance: uaData instanceof NavigatorUAData,
                        sameObject: uaData === navigator.userAgentData,
                        userAgent: navigator.userAgent,
                        languages: Array.from(navigator.languages),
                        languagesFrozen: Object.isFrozen(navigator.languages),
                        brands: uaData.brands,
                        emptyKeys: Object.keys(empty),
                        selectedKeys: Object.keys(selected),
                        architecture: selected.architecture
                    });
                    port.close();
                });
                port.start();
            });
            "#
            .into(),
            "https://app.example/shared-worker-navigator.js".into(),
        )
        .with_request_client(loader)
        .with_worker_context_runtime(browser_context_runtime.worker_context_runtime())
        .with_global_kind(super::super::WorkerGlobalKind::Shared {
            name: "shared".to_owned(),
            storage_key,
        }),
    );

    let (client_port_id, _) =
        connect_shared_worker_test_port(&mut handle, &registry, &port_wake_tx);
    assert_eq!(
        read_message_port_value(
            &registry,
            &mut port_wake_rx,
            client_port_id,
            "JSON.stringify(__wire)",
        )
        .await,
        r#"{"constructorType":"function","dataType":"object","instance":true,"sameObject":false,"userAgent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.1.2.3 Safari/537.36","languages":["de-DE","de"],"languagesFrozen":true,"brands":[{"brand":"Chromium","version":"146"},{"brand":"Not-A.Brand","version":"24"},{"brand":"Google Chrome","version":"146"}],"emptyKeys":["brands","mobile","platform"],"selectedKeys":["architecture","brands","mobile","platform"],"architecture":"x86"}"#
    );
}

#[tokio::test]
async fn data_url_shared_workers_do_not_share_broadcast_channel_by_constructor_key() {
    ensure_v8();
    let (port_wake_tx, mut port_wake_rx) = tokio::sync::mpsc::unbounded_channel();
    let message_port_registry = crate::message_port_runtime::new_message_port_registry();
    let broadcast_channel_registry =
        crate::broadcast_channel_runtime::new_broadcast_channel_registry();
    let browser_context_runtime =
        crate::runtime::RendererBrowserContextRuntime::new_with_registries_for_test(
            message_port_registry.clone(),
            broadcast_channel_registry,
        );
    let constructor_storage_key = moli_storage_key::MoliStorageKey::new(
        "https://app.example".to_owned(),
        "https://app.example".to_owned(),
        None,
        moli_storage_key::StoragePartitionRelation::FirstParty,
    );
    let worker_source = r#"
        addEventListener("connect", event => {
            const port = event.ports[0];
            const channel = new BroadcastChannel("data-url-shared-worker-opaque-bc");
            const seen = [];
            channel.onmessage = event => {
                seen.push(event.data + ":" + event.origin);
            };
            port.onmessage = event => {
                if (event.data === "send") {
                    channel.postMessage("leak");
                    port.postMessage("sent");
                } else if (event.data === "report") {
                    port.postMessage(seen.length === 0 ? "silent" : "received:" + seen.join("|"));
                }
            };
            port.start();
        });
    "#;

    let mut first = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(worker_source.into(), worker_data_url(worker_source))
            .with_worker_context_runtime(browser_context_runtime.worker_context_runtime())
            .with_storage_key_top_level_site(Some("https://app.example".to_owned()))
            .with_global_kind(super::super::WorkerGlobalKind::Shared {
                name: "first".to_owned(),
                storage_key: constructor_storage_key.clone(),
            }),
    );
    let mut second = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(worker_source.into(), worker_data_url(worker_source))
            .with_worker_context_runtime(browser_context_runtime.worker_context_runtime())
            .with_storage_key_top_level_site(Some("https://app.example".to_owned()))
            .with_global_kind(super::super::WorkerGlobalKind::Shared {
                name: "second".to_owned(),
                storage_key: constructor_storage_key,
            }),
    );

    let (first_client_port, first_worker_port) =
        connect_shared_worker_test_port(&mut first, &message_port_registry, &port_wake_tx);
    let (second_client_port, second_worker_port) =
        connect_shared_worker_test_port(&mut second, &message_port_registry, &port_wake_tx);

    message_port_registry.enqueue_message_to_message_port(
        first_client_port,
        serialize_test_post_message_value("'send'"),
    );
    message_port_registry.wake_message_port_if_pending(first_worker_port);
    assert_eq!(
        read_message_port_string(&message_port_registry, &mut port_wake_rx, first_client_port,)
            .await,
        "sent"
    );

    message_port_registry.enqueue_message_to_message_port(
        second_client_port,
        serialize_test_post_message_value("'report'"),
    );
    message_port_registry.wake_message_port_if_pending(second_worker_port);
    assert_eq!(
        read_message_port_string(
            &message_port_registry,
            &mut port_wake_rx,
            second_client_port,
        )
        .await,
        "silent"
    );

    first.terminate();
    second.terminate();
}

#[tokio::test]
async fn blob_url_shared_worker_broadcast_channel_uses_constructor_storage_key() {
    ensure_v8();
    let (port_wake_tx, mut port_wake_rx) = tokio::sync::mpsc::unbounded_channel();
    let message_port_registry = crate::message_port_runtime::new_message_port_registry();
    let broadcast_channel_registry =
        crate::broadcast_channel_runtime::new_broadcast_channel_registry();
    let browser_context_runtime =
        crate::runtime::RendererBrowserContextRuntime::new_with_registries_for_test(
            message_port_registry.clone(),
            broadcast_channel_registry.clone(),
        );
    let constructor_storage_key = moli_storage_key::MoliStorageKey::new(
        "https://app.example".to_owned(),
        "https://app.example".to_owned(),
        None,
        moli_storage_key::StoragePartitionRelation::FirstParty,
    );
    let (broadcast_wake_tx, mut broadcast_wake_rx) = tokio::sync::mpsc::unbounded_channel();
    let page_channel_id = broadcast_channel_registry.create_broadcast_channel(
        constructor_storage_key.clone(),
        "blob-shared-worker-constructor-bc".to_owned(),
        crate::broadcast_channel_runtime::BroadcastChannelOwner::Worker(broadcast_wake_tx),
    );
    let worker_source = r#"
        addEventListener("connect", event => {
            const port = event.ports[0];
            const channel = new BroadcastChannel("blob-shared-worker-constructor-bc");
            port.onmessage = event => {
                if (event.data === "send") {
                    channel.postMessage("from-worker");
                    port.postMessage("posted");
                }
            };
            port.start();
        });
    "#;

    let mut worker = spawn_test_worker_with_options(
        WorkerSpawnOptions::new(
            worker_source.into(),
            "blob:https://app.example/blob-shared-worker.js".into(),
        )
        .with_worker_context_runtime(browser_context_runtime.worker_context_runtime())
        .with_storage_key_top_level_site(Some("https://app.example".to_owned()))
        .with_creator_storage_key(constructor_storage_key.clone())
        .with_global_kind(super::super::WorkerGlobalKind::Shared {
            name: "blob-shared".to_owned(),
            storage_key: constructor_storage_key,
        }),
    );

    let (client_port_id, worker_port_id) =
        connect_shared_worker_test_port(&mut worker, &message_port_registry, &port_wake_tx);
    message_port_registry.enqueue_message_to_message_port(
        client_port_id,
        serialize_test_post_message_value("'send'"),
    );
    message_port_registry.wake_message_port_if_pending(worker_port_id);

    let mut saw_ack = false;
    let mut broadcast_message = None;
    let message = loop {
        match broadcast_wake_rx.try_recv() {
            Ok(crate::worker::WorkerMessage::BroadcastChannelWake(channel_id)) => {
                assert_eq!(channel_id, page_channel_id);
                match broadcast_channel_registry.take_pending_broadcast_channel_event(channel_id) {
                    Some(crate::broadcast_channel_runtime::BroadcastChannelEvent::Message(
                        payload,
                    )) => {
                        broadcast_message = Some(inspect_payload(&payload, "String(__wire)"));
                    }
                    None => panic!("BroadcastChannel woke without a pending event"),
                }
            }
            Ok(other) => panic!("unexpected BroadcastChannel owner wake: {other:?}"),
            Err(tokio::sync::mpsc::error::TryRecvError::Empty) => {}
            Err(tokio::sync::mpsc::error::TryRecvError::Disconnected) => {
                panic!("BroadcastChannel owner wake channel closed")
            }
        }
        match port_wake_rx.try_recv() {
            Ok(crate::worker::WorkerMessage::MessagePortWake(port_id))
                if port_id == client_port_id =>
            {
                let payload = message_port_registry
                    .take_pending_message_port_message(client_port_id)
                    .expect("client port should have an ack message");
                saw_ack |= inspect_payload(&payload, "String(__wire)") == "posted";
            }
            Ok(crate::worker::WorkerMessage::MessagePortWake(_)) => {}
            Ok(other) => {
                panic!("unexpected owner wake while waiting for BroadcastChannel: {other:?}")
            }
            Err(tokio::sync::mpsc::error::TryRecvError::Empty) => {}
            Err(tokio::sync::mpsc::error::TryRecvError::Disconnected) => {
                panic!("MessagePort owner wake channel closed")
            }
        }
        if saw_ack && let Some(message) = broadcast_message.take() {
            break message;
        }
        timeout(TIMEOUT, async {
            tokio::select! {
                biased;
                wake = broadcast_wake_rx.recv() => {
                    let wake = wake.expect("BroadcastChannel owner wake channel should remain open");
                    let crate::worker::WorkerMessage::BroadcastChannelWake(channel_id) = wake else {
                        panic!("unexpected BroadcastChannel owner wake: {wake:?}");
                    };
                    assert_eq!(channel_id, page_channel_id);
                    match broadcast_channel_registry.take_pending_broadcast_channel_event(channel_id) {
                        Some(crate::broadcast_channel_runtime::BroadcastChannelEvent::Message(payload)) => {
                            broadcast_message = Some(inspect_payload(&payload, "String(__wire)"));
                        }
                        None => panic!("BroadcastChannel woke without a pending event"),
                    }
                }
                wake = port_wake_rx.recv() => {
                    let wake = wake.expect("MessagePort owner wake channel should remain open");
                    let crate::worker::WorkerMessage::MessagePortWake(port_id) = wake else {
                        panic!("unexpected MessagePort owner wake: {wake:?}");
                    };
                    if port_id == client_port_id {
                        let payload = message_port_registry
                            .take_pending_message_port_message(client_port_id)
                            .expect("client port should have an ack message");
                        saw_ack |= inspect_payload(&payload, "String(__wire)") == "posted";
                    }
                }
            }
        })
        .await
        .expect("timed out waiting for BroadcastChannel or MessagePort completion");
    };
    assert_eq!(message, "from-worker");
    assert!(
        saw_ack,
        "worker should acknowledge after posting to BroadcastChannel"
    );

    worker.terminate();
}

fn connect_shared_worker_test_port(
    handle: &mut WorkerHandle,
    registry: &crate::message_port_runtime::SharedMessagePortRegistry,
    owner_wake: &tokio::sync::mpsc::UnboundedSender<crate::worker::WorkerMessage>,
) -> (crate::types::MessagePortId, crate::types::MessagePortId) {
    let (client_port_id, worker_port_id) = registry.create_entangled_message_port_pair(
        crate::message_port_runtime::MessagePortOwner::Worker(owner_wake.clone()),
    );
    registry.detach_message_port_owner_for_transfer(worker_port_id);
    handle
        .tx
        .send(crate::worker::WorkerMessage::SharedWorkerConnect(
            worker_port_id,
        ))
        .expect("connect shared worker");
    (client_port_id, worker_port_id)
}

async fn read_message_port_string(
    registry: &crate::message_port_runtime::SharedMessagePortRegistry,
    owner_wake: &mut tokio::sync::mpsc::UnboundedReceiver<crate::worker::WorkerMessage>,
    target_port_id: crate::types::MessagePortId,
) -> String {
    read_message_port_value(registry, owner_wake, target_port_id, "String(__wire)").await
}

async fn read_message_port_value(
    registry: &crate::message_port_runtime::SharedMessagePortRegistry,
    owner_wake: &mut tokio::sync::mpsc::UnboundedReceiver<crate::worker::WorkerMessage>,
    target_port_id: crate::types::MessagePortId,
    expression: &str,
) -> String {
    loop {
        let wake = timeout(TIMEOUT, owner_wake.recv())
            .await
            .expect("timed out waiting for MessagePort wake")
            .expect("MessagePort owner wake channel closed");
        match wake {
            crate::worker::WorkerMessage::MessagePortWake(port_id) if port_id == target_port_id => {
                if let Some(payload) = registry.take_pending_message_port_message(target_port_id) {
                    return inspect_payload(&payload, expression);
                }
                if registry.take_pending_message_port_close(target_port_id) {
                    continue;
                }
                panic!("MessagePort woke without message or close");
            }
            crate::worker::WorkerMessage::MessagePortWake(_) => continue,
            other => panic!("expected MessagePort wake, got {other:?}"),
        }
    }
}

async fn connect_shared_worker_test_port_and_read_now(
    handle: &mut WorkerHandle,
    registry: &crate::message_port_runtime::SharedMessagePortRegistry,
    owner_wake_tx: &tokio::sync::mpsc::UnboundedSender<crate::worker::WorkerMessage>,
    owner_wake_rx: &mut tokio::sync::mpsc::UnboundedReceiver<crate::worker::WorkerMessage>,
) -> f64 {
    let (client_port_id, worker_port_id) = registry.create_entangled_message_port_pair(
        crate::message_port_runtime::MessagePortOwner::Worker(owner_wake_tx.clone()),
    );
    registry.detach_message_port_owner_for_transfer(worker_port_id);
    handle
        .tx
        .send(crate::worker::WorkerMessage::SharedWorkerConnect(
            worker_port_id,
        ))
        .expect("connect shared worker");
    registry
        .enqueue_message_to_message_port(client_port_id, serialize_test_post_message_value("''"));
    registry.wake_message_port_if_pending(worker_port_id);

    loop {
        let wake = match timeout(TIMEOUT, owner_wake_rx.recv()).await {
            Ok(Some(wake)) => wake,
            Ok(None) => panic!("MessagePort owner wake channel closed before reply"),
            Err(error) => {
                let mut worker_events = Vec::new();
                while let Ok(message) = handle.try_recv() {
                    worker_events.push(match message {
                        WorkerToParentMessage::Post(payload) => stringify_payload(&payload),
                        other => format!("{other:?}"),
                    });
                }
                panic!(
                    "timed out waiting for SharedWorker MessagePort reply: {error:?}; worker_events={worker_events:?}"
                );
            }
        };
        match wake {
            crate::worker::WorkerMessage::MessagePortWake(port_id) if port_id == client_port_id => {
                if let Some(payload) = registry.take_pending_message_port_message(client_port_id) {
                    assert_eq!(inspect_payload(&payload, "__wire.length"), "4");
                    assert_eq!(inspect_payload(&payload, "__wire[0]"), "undefined");
                    assert_eq!(inspect_payload(&payload, "__wire[1]"), "object");
                    assert_eq!(inspect_payload(&payload, "__wire[2]"), "function");
                    assert_eq!(inspect_payload(&payload, "__wire[3] >= 0"), "true");
                    return inspect_payload(&payload, "__wire[3]")
                        .parse()
                        .expect("performance.now payload should be numeric");
                }
                if registry.take_pending_message_port_close(client_port_id) {
                    continue;
                }
                panic!("SharedWorker client port woke without message or close");
            }
            crate::worker::WorkerMessage::MessagePortWake(_) => continue,
            other => panic!("expected MessagePort wake, got {other:?}"),
        }
    }
}

// ─── setTimeout ─────────────────────────────────────────────────────

#[tokio::test]
async fn worker_settimeout() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        setTimeout(function() {
            postMessage("delayed");
        }, 50);
        "#
        .into(),
        "test://settimeout".into(),
    );

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

#[tokio::test]
async fn worker_settimeout_with_args() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        setTimeout(function(a, b) {
            postMessage(a + b);
        }, 10, 3, 4);
        "#
        .into(),
        "test://settimeout_args".into(),
    );

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

#[tokio::test]
async fn worker_settimeout_accepts_callable_proxy_with_worker_global_receiver() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const callback = new Proxy(function() {}, {
            apply(_target, receiver, args) {
                postMessage(`${receiver === self}:${args[0] + args[1]}`);
                close();
            }
        });
        setTimeout(callback, 0, 3, 4);
        "#
        .into(),
        "test://settimeout_callable_proxy".into(),
    );

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

#[tokio::test]
async fn worker_settimeout_negative_delay_clamps_to_zero() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        setTimeout(function() {
            postMessage("timer");
        }, -1);
        postMessage("scheduled");
        "#
        .into(),
        "test://settimeout_negative_delay".into(),
    );

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

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

// ─── requestAnimationFrame ─────────────────────────────────────────

#[tokio::test]
async fn worker_request_animation_frame_accepts_callable_proxy_with_webidl_arguments() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const callback = new Proxy(function() {}, {
            apply(_target, receiver, args) {
                postMessage({
                    undefinedReceiver: receiver === undefined,
                    argumentCount: args.length,
                    finiteTimestamp: Number.isFinite(args[0])
                });
                close();
            }
        });
        requestAnimationFrame(callback);
        "#
        .into(),
        "test://request_animation_frame_callable_proxy".into(),
    );

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

#[tokio::test]
async fn worker_request_animation_frame_rejects_non_callable_callback() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        try {
            requestAnimationFrame({});
            postMessage("unexpected");
        } catch (error) {
            postMessage(error.name);
            close();
        }
        "#
        .into(),
        "test://request_animation_frame_non_callable".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_cancel_animation_frame_cancels_exact_callback() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const animationFrameId = requestAnimationFrame(() => {
            postMessage("unexpected");
        });
        cancelAnimationFrame(animationFrameId);
        setTimeout(() => {
            postMessage("cancelled");
            close();
        }, 30);
        "#
        .into(),
        "test://cancel_animation_frame".into(),
    );

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

#[tokio::test]
async fn worker_request_animation_frame_exception_routes_through_worker_global_onerror() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        onerror = function(message, _filename, _lineno, _colno, error) {
            postMessage(`${String(message).includes("frame-boom")}:${error.message}`);
            close();
            return true;
        };
        requestAnimationFrame(() => {
            throw new Error("frame-boom");
        });
        "#
        .into(),
        "test://request_animation_frame_onerror".into(),
    );

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

// ─── clearTimeout ───────────────────────────────────────────────────

#[tokio::test]
async fn worker_cleartimeout() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        let id = setTimeout(function() {
            postMessage("should not fire");
        }, 50);
        clearTimeout(id);
        setTimeout(function() {
            postMessage("ok");
        }, 100);
        "#
        .into(),
        "test://cleartimeout".into(),
    );

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

#[tokio::test]
async fn worker_cleartimeout_after_timer_is_active() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        let id = setTimeout(function() {
            postMessage("should not fire");
        }, 100);
        setTimeout(function() {
            clearTimeout(id);
            setTimeout(function() {
                postMessage("ok");
            }, 40);
        }, 10);
        "#
        .into(),
        "test://cleartimeout_active".into(),
    );

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

#[tokio::test]
async fn worker_postmessage_requires_argument() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        try {
            postMessage();
            postMessage("unexpected");
        } catch (error) {
            postMessage({
                name: error.name,
                required: String(error.message).includes("1 argument required")
            });
        }
        "#
        .into(),
        "test://postmessage_requires_argument".into(),
    );

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

#[tokio::test]
async fn worker_postmessage_function_throws_datacloneerror() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        try {
            postMessage(function nope() {});
            postMessage("unexpected");
        } catch (error) {
            postMessage(error.name);
        }
        "#
        .into(),
        "test://postmessage_datacloneerror".into(),
    );

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

#[tokio::test]
async fn worker_postmessage_formdata_throws_datacloneerror() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        try {
            postMessage(new FormData());
            postMessage("unexpected");
        } catch (error) {
            postMessage(error.name);
        }
        "#
        .into(),
        "test://postmessage_formdata_datacloneerror".into(),
    );

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

#[tokio::test]
async fn worker_postmessage_workernavigator_throws_datacloneerror() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        try {
            postMessage(navigator);
            postMessage("unexpected");
        } catch (error) {
            postMessage(error.name);
        }
        "#
        .into(),
        "test://postmessage_workernavigator_datacloneerror".into(),
    );

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

#[tokio::test]
async fn worker_fallback_message_events_are_native_platform_objects() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        MessageEvent = undefined;
        onmessage = event => {
          let cloneResult = 'accepted';
          try { structuredClone({event}); }
          catch (error) { cloneResult = error.name; }
          postMessage({data: event.data, cloneResult});
          close();
        };
        postMessage('ready');
        "#
        .into(),
        "https://worker-fallback-identity.test/worker.js".into(),
    );
    let ready = timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap();
    assert_eq!(expect_post_json(ready), r#""ready""#);
    handle.post_message(serialize_test_string("ping"));
    let result = timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap();
    assert_eq!(
        expect_post_json(result),
        r#"{"data":"ping","cloneResult":"DataCloneError"}"#
    );
}

#[tokio::test]
async fn worker_does_not_expose_window_media_device_interfaces() {
    ensure_v8();
    let mut handle = spawn_worker("postMessage({MediaDeviceInfo:'MediaDeviceInfo' in self,InputDeviceInfo:'InputDeviceInfo' in self});close();".to_owned(), "https://media-device-worker.test/worker.js".into());
    let message = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(
        expect_post_json(message),
        r#"{"MediaDeviceInfo":false,"InputDeviceInfo":false}"#
    );
}

#[tokio::test]
async fn worker_rectangle_clones_use_native_prototypes_and_message_channel_delivery() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        (async () => {
            const check = (ok, label) => { if (!ok) throw Error(label); };
            for (const name of ['DOMRect', 'DOMRectReadOnly']) {
                const C = self[name];
                const prototype = C.prototype;
                const rect = new C(-0, NaN, Infinity, -Infinity);
                Object.defineProperty(rect, 'x', {get() { throw Error('must read native state'); }});
                self[name] = () => { throw Error('must not call public constructor'); };
                try {
                    const clone = structuredClone({rect, again: rect});
                    check(clone.rect === clone.again, name + ' graph alias');
                    check(Object.getPrototypeOf(clone.rect) === prototype, name + ' intrinsic prototype');
                    check(Object.is(clone.rect.x, -0) && Number.isNaN(clone.rect.y) &&
                        clone.rect.width === Infinity && clone.rect.height === -Infinity, name + ' values');
                    const channel = new MessageChannel();
                    const received = new Promise(resolve => { channel.port2.onmessage = event => resolve(event.data); });
                    channel.port1.postMessage({rect, again: rect});
                    const message = await received;
                    check(message.rect === message.again && message.rect !== rect, name + ' message graph');
                    check(Object.getPrototypeOf(message.rect) === prototype, name + ' message receiver prototype');
                    check(Object.is(message.rect.x, -0) && Number.isNaN(message.rect.y) &&
                        message.rect.width === Infinity && message.rect.height === -Infinity, name + ' message values');
                    channel.port1.close();
                    channel.port2.close();
                } finally { self[name] = C; }
            }
            postMessage('passed');
            close();
        })().catch(error => { postMessage(String(error)); close(); });
        "#
        .into(),
        "https://worker-rectangle.test/clone.js".into(),
    );
    assert_eq!(recv_post_json(&mut handle).await, r#""passed""#);
}

#[tokio::test]
async fn worker_does_not_expose_window_audio_node_interface() {
    ensure_v8();
    let mut handle = spawn_worker(
        "postMessage({AudioNode:'AudioNode' in self});close();".to_owned(),
        "https://audio-node-worker.test/worker.js".into(),
    );
    let message = timeout(TIMEOUT, handle.recv())
        .await
        .expect("timed out")
        .expect("channel closed");
    assert_eq!(expect_post_json(message), r#"{"AudioNode":false}"#);
}

#[tokio::test]
async fn worker_navigator_languages_are_frozen() {
    ensure_v8();
    let mut handle = spawn_worker(
        format!(
            "try {{ postMessage({}); }} catch (error) {{ postMessage(String(error)); }} close();",
            include_str!("../../../../tests/fixtures/navigator-languages.js")
        ),
        "https://navigator-languages.test/worker.js".into(),
    );
    let message = timeout(TIMEOUT, handle.recv())
        .await
        .expect("worker language contract must settle")
        .expect("worker must return a language contract result");
    assert_eq!(expect_post_json(message), r#""ok""#);
}