Skip to content

armgit / moli

Public Imported from GitHub
0

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

124 KB
Raw Blame
use super::*;

#[tokio::test]
async fn media_load_honors_media_src_csp() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://media-csp.test/page.html",
        &loader,
    );
    vm.set_response_content_security_policies(&["media-src 'self'".to_owned()]);
    vm.set_response_content_security_report_only_policies(&["media-src 'none'".to_owned()]);

    vm.eval(
        r#"
(() => {
  globalThis.__lmMediaCspEvents = [];
  document.addEventListener("securitypolicyviolation", event => {
    __lmMediaCspEvents.push(`csp:${event.disposition}:${event.effectiveDirective}:${event.blockedURI}`);
  });
  const video = document.createElement("video");
  video.onloadeddata = () => __lmMediaCspEvents.push("loadeddata");
  video.onerror = () => __lmMediaCspEvents.push("error");
  video.src = "data:video/mp4;base64,AAAAGGZ0eXBtcDQyAAAAAG1wNDJtcDQx";
  (document.body || document.documentElement || document).appendChild(video);
  globalThis.__lmMediaCspVideo = video;
})()
"#,
    )
    .expect("media CSP setup should evaluate");

    assert_eq!(
        drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm),
        2
    );

    run_next_page_media_element_event_for_test(&mut vm, &loader, "blocked media loadstart turn")
        .await;
    run_next_page_media_element_event_for_test(&mut vm, &loader, "blocked media error turn").await;

    assert_eq!(
        vm.eval(
            r#"[
  __lmMediaCspEvents.join("|"),
  __lmMediaCspVideo.readyState,
  __lmMediaCspVideo.networkState
].join("|")"#,
        )
        .expect("media CSP events should evaluate"),
        "csp:report:media-src:data|csp:enforce:media-src:data|error|0|3"
    );
}

#[tokio::test]
async fn media_report_only_csp_reports_without_blocking_load() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://media-csp-report-only.test/page.html",
        &loader,
    );
    vm.set_response_content_security_report_only_policies(&["media-src 'none'".to_owned()]);

    vm.eval(
        r#"
(() => {
  globalThis.__lmMediaReportOnlyEvents = [];
  document.addEventListener('securitypolicyviolation', event => {
    __lmMediaReportOnlyEvents.push(`csp:${event.disposition}:${event.effectiveDirective}`);
  });
  const video = document.createElement('video');
  video.onloadeddata = () => __lmMediaReportOnlyEvents.push('loadeddata');
  video.onerror = () => __lmMediaReportOnlyEvents.push('error');
  video.src = 'data:video/mp4;base64,AAAAGGZ0eXBtcDQyAAAAAG1wNDJtcDQx';
  (document.body || document.documentElement || document).appendChild(video);
  globalThis.__lmMediaReportOnlyVideo = video;
})()
"#,
    )
    .expect("media report-only CSP setup should evaluate");

    assert_eq!(
        drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm),
        1
    );

    for phase in ["loadstart", "loadedmetadata", "loadeddata", "canplay"] {
        run_next_page_media_element_event_for_test(
            &mut vm,
            &loader,
            &format!("report-only media {phase} turn"),
        )
        .await;
    }

    assert_eq!(
        vm.eval(
            r#"[
  __lmMediaReportOnlyEvents.join("|"),
  __lmMediaReportOnlyVideo.readyState,
  __lmMediaReportOnlyVideo.networkState
].join("|")"#,
        )
        .expect("media report-only CSP events should evaluate"),
        "csp:report:media-src|loadeddata|4|1"
    );
}

#[tokio::test]
async fn media_invalid_base_url_fails_before_csp_check() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://media-csp-fallback.test/path/page.html",
        &loader,
    );
    vm.set_response_content_security_policies(&["media-src 'none'".to_owned()]);

    vm.eval(
        r#"
(() => {
  const root = document.documentElement || document.appendChild(document.createElement('html'));
  const base = document.createElement('base');
  base.href = 'about:blank';
  root.prepend(base);

  globalThis.__lmMediaFallbackCspEvents = [];
  document.addEventListener('securitypolicyviolation', event => {
    __lmMediaFallbackCspEvents.push(`csp:${event.effectiveDirective}:${event.blockedURI}`);
  });
  const video = document.createElement('video');
  video.onloadeddata = () => __lmMediaFallbackCspEvents.push('loadeddata');
  video.onerror = () => __lmMediaFallbackCspEvents.push('error');
  video.src = 'asset.mp4';
  root.appendChild(video);
  globalThis.__lmMediaFallbackCspVideo = video;
})()
"#,
    )
    .expect("media fallback CSP setup should evaluate");

    assert_eq!(
        drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm),
        0,
        "an invalid base URL must fail before CSP queues a violation task"
    );

    run_next_page_media_element_event_for_test(
        &mut vm,
        &loader,
        "invalid-base media loadstart turn",
    )
    .await;
    run_next_page_media_element_event_for_test(&mut vm, &loader, "invalid-base media error turn")
        .await;

    assert_eq!(
        vm.eval(
            r#"[
  __lmMediaFallbackCspEvents.join("|"),
  __lmMediaFallbackCspVideo.readyState,
  __lmMediaFallbackCspVideo.networkState
].join("|")"#,
        )
        .expect("media fallback CSP events should evaluate"),
        "error|0|3"
    );
}

#[tokio::test]
async fn media_invalid_request_url_fails_before_load() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://media-invalid-url.test/page.html",
        &loader,
    );

    vm.eval(
        r#"
(() => {
  globalThis.__lmMediaInvalidUrlEvents = [];
  const video = document.createElement('video');
  video.onloadeddata = () => __lmMediaInvalidUrlEvents.push('loadeddata');
  video.onerror = () => __lmMediaInvalidUrlEvents.push('error');
  video.src = 'http://[';
  (document.body || document.documentElement || document).appendChild(video);
  globalThis.__lmMediaInvalidUrlVideo = video;
})()
"#,
    )
    .expect("invalid media URL setup should evaluate");

    run_next_page_media_element_event_for_test(
        &mut vm,
        &loader,
        "invalid-URL media loadstart turn",
    )
    .await;
    run_next_page_media_element_event_for_test(&mut vm, &loader, "invalid-URL media error turn")
        .await;

    assert_eq!(
        vm.eval(
            r#"(() => {
  const firstError = __lmMediaInvalidUrlVideo.error;
  globalThis.__lmMediaInvalidUrlFirstError = firstError;
  const result = [
    __lmMediaInvalidUrlEvents.join("|"),
    __lmMediaInvalidUrlVideo.readyState,
    __lmMediaInvalidUrlVideo.networkState,
    firstError instanceof MediaError,
    firstError && firstError.code,
    firstError && firstError.message.length > 0,
    __lmMediaInvalidUrlVideo.error === firstError
  ].join("|");
  __lmMediaInvalidUrlVideo.load();
  return `${result}|${__lmMediaInvalidUrlVideo.error === null}`;
})()"#,
        )
        .expect("invalid media URL events should evaluate"),
        "error|0|3|true|4|true|true|true"
    );

    run_next_page_media_element_event_for_test(
        &mut vm,
        &loader,
        "reloaded invalid-URL media loadstart turn",
    )
    .await;
    run_next_page_media_element_event_for_test(
        &mut vm,
        &loader,
        "reloaded invalid-URL media error turn",
    )
    .await;
    assert_eq!(
        vm.eval(
            r#"[
  __lmMediaInvalidUrlVideo.error instanceof MediaError,
  __lmMediaInvalidUrlVideo.error.code,
  __lmMediaInvalidUrlVideo.error !== __lmMediaInvalidUrlFirstError
].join("|")"#,
        )
        .expect("reloaded invalid media URL error should evaluate"),
        "true|4|true"
    );
}

#[tokio::test]
async fn media_error_uses_the_native_prototype_after_public_constructor_replacement() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://media-error-intrinsics.test/page.html",
        &loader,
    );

    vm.eval(
        r#"
        globalThis.__mediaErrorNativeConstructor = window.MediaError;
        globalThis.__mediaErrorNativePrototype = MediaError.prototype;
        window.MediaError = function ReplacementMediaError() {};
        const video = document.createElement("video");
        video.src = "http://[";
        (document.body || document.documentElement).appendChild(video);
        globalThis.__mediaErrorIntrinsicVideo = video;
        "queued";
        "#,
    )
    .expect("media error intrinsic setup should evaluate");

    run_next_page_media_element_event_for_test(
        &mut vm,
        &loader,
        "intrinsic media error loadstart turn",
    )
    .await;
    run_next_page_media_element_event_for_test(
        &mut vm,
        &loader,
        "intrinsic media error failure turn",
    )
    .await;

    assert_eq!(
        vm.eval(
            r#"JSON.stringify({
              publicConstructorReplaced: window.MediaError !== __mediaErrorNativeConstructor,
              nativePrototype:
                Object.getPrototypeOf(__mediaErrorIntrinsicVideo.error) ===
                  __mediaErrorNativePrototype,
              nativeInstance:
                __mediaErrorIntrinsicVideo.error instanceof __mediaErrorNativeConstructor,
              code: __mediaErrorIntrinsicVideo.error && __mediaErrorIntrinsicVideo.error.code
            })"#,
        )
        .expect("media error intrinsic result should evaluate"),
        r#"{"publicConstructorReplaced":true,"nativePrototype":true,"nativeInstance":true,"code":4}"#
    );
}

#[tokio::test]
async fn media_blocks_http_dangling_markup_without_blocking_safe_url_inputs() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://media-dangling-markup.test/page.html",
        &loader,
    );

    vm.eval(
        r#"
(() => {
  globalThis.__lmMediaDanglingMarkupEvents = [];
  const probes = [
    ["audio", "blocked", "asset.mp3?\n<", false],
    ["video", "blocked", "asset.mp4?<\tkey", false],
    ["video", "child-source", "asset.mp4?\n<", true],
    ["audio", "data", "data:audio/mp3,bytes\n<", false]
  ];
  for (const [localName, name, source, useChildSource] of probes) {
    const media = document.createElement(localName);
    media.onerror = () => __lmMediaDanglingMarkupEvents.push(`${localName}:${name}:error`);
    media.oncanplay = () => __lmMediaDanglingMarkupEvents.push(`${localName}:${name}:canplay`);
    if (useChildSource) {
      const sourceElement = document.createElement("source");
      sourceElement.src = source;
      media.appendChild(sourceElement);
    } else {
      media.src = source;
    }
    (document.body || document.documentElement || document).appendChild(media);
  }
})()
"#,
    )
    .expect("media dangling markup setup should evaluate");

    for turn in 0..10 {
        run_next_page_media_element_event_for_test(
            &mut vm,
            &loader,
            &format!("dangling-markup media event turn {turn}"),
        )
        .await;
    }

    assert_eq!(
        vm.eval(r#"__lmMediaDanglingMarkupEvents.sort().join("|")"#)
            .expect("media dangling markup events should evaluate"),
        "audio:blocked:error|audio:data:canplay|video:blocked:error|video:child-source:error"
    );
}

#[tokio::test]
async fn media_dangling_markup_still_dispatches_report_only_csp() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://media-dangling-csp.test/page.html",
        &loader,
    );
    vm.set_response_content_security_report_only_policies(&["media-src 'none'".to_owned()]);

    vm.eval(
        r#"
(() => {
  globalThis.__lmMediaDanglingCspEvents = [];
  document.addEventListener("securitypolicyviolation", event => {
    __lmMediaDanglingCspEvents.push(`csp:${event.disposition}:${event.effectiveDirective}`);
  });
  const video = document.createElement("video");
  video.onerror = () => __lmMediaDanglingCspEvents.push("error");
  video.oncanplay = () => __lmMediaDanglingCspEvents.push("canplay");
  video.src = "asset.mp4?\n<";
  (document.body || document.documentElement || document).appendChild(video);
})()
"#,
    )
    .expect("media dangling markup CSP setup should evaluate");

    assert_eq!(
        drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm),
        1
    );
    run_next_page_media_element_event_for_test(
        &mut vm,
        &loader,
        "report-only dangling-markup media loadstart turn",
    )
    .await;
    run_next_page_media_element_event_for_test(
        &mut vm,
        &loader,
        "report-only dangling-markup media error turn",
    )
    .await;

    assert_eq!(
        vm.eval(r#"__lmMediaDanglingCspEvents.join("|")"#)
            .expect("media dangling markup CSP events should evaluate"),
        "csp:report:media-src|error"
    );
}

#[test]
fn media_play_returns_a_fulfilled_promise() {
    let mut vm = new_storage_test_vm("https://media-play-promise.test/");

    vm.exec(
        r#"
(() => {
  const video = document.createElement("video");
  const events = [];
  video.addEventListener("play", () => events.push("play"));
  video.addEventListener("playing", () => events.push("playing"));
  const promise = video.play();
  globalThis.__mediaPlayPromiseProbe = {
    promiseTag: Object.prototype.toString.call(promise),
    paused: video.paused,
    events: events.join(","),
    outcome: "pending"
  };
  promise.then(value => {
    globalThis.__mediaPlayPromiseProbe.outcome = value === undefined
      ? "fulfilled:undefined"
      : "fulfilled:other";
  });
})()
"#,
        None,
    )
    .expect("media play promise probe should execute");

    let result = vm
        .eval("JSON.stringify(globalThis.__mediaPlayPromiseProbe)")
        .expect("media play promise probe should evaluate");

    assert_eq!(
        result,
        r#"{"promiseTag":"[object Promise]","paused":false,"events":"play,playing","outcome":"fulfilled:undefined"}"#
    );
}

#[test]
fn media_numeric_setters_parse_webidl_values() {
    let mut vm = new_storage_test_vm("https://media-numeric-setters-webidl.test/");

    let result = vm
        .eval(
            r##"
(() => {
  const html = document.documentElement || document.appendChild(document.createElement('html'));
  if (!document.body) {
    html.appendChild(document.createElement('body'));
  }
  const video = document.createElement('video');
  let volumeCalls = 0;
  let playbackRateCalls = 0;
  let currentTimeCalls = 0;
  const probe = callback => {
    try {
      return String(callback());
    } catch (error) {
      return `throw:${error && error.name}`;
    }
  };

  video.volume = {
    valueOf() {
      volumeCalls += 1;
      return '0.25';
    }
  };
  const volumeObject = `${video.volume}:${volumeCalls}`;
  video.volume = 2;
  const volumeUpperClamp = video.volume;
  video.volume = -1;
  const volumeLowerClamp = video.volume;
  const volumeInfinity = probe(() => { video.volume = Infinity; });
  const volumeSymbol = probe(() => { video.volume = Symbol('volume'); });

  video.playbackRate = {
    valueOf() {
      playbackRateCalls += 1;
      return '1.5';
    }
  };
  const playbackRateObject = `${video.playbackRate}:${playbackRateCalls}`;
  const playbackRateThrowing = probe(() => {
    video.playbackRate = {
      valueOf() {
        throw new RangeError('rate');
      }
    };
  });
  const playbackRateNaN = probe(() => { video.playbackRate = NaN; });

  video.currentTime = {
    valueOf() {
      currentTimeCalls += 1;
      return '3.5';
    }
  };
  const currentTimeObject = `${video.currentTime}:${currentTimeCalls}`;
  video.currentTime = -4;
  const currentTimeLowerClamp = video.currentTime;
  const currentTimeSymbol = probe(() => { video.currentTime = Symbol('time'); });
  const currentTimeInfinity = probe(() => { video.currentTime = Infinity; });

  return [
    volumeObject,
    volumeUpperClamp,
    volumeLowerClamp,
    volumeInfinity,
    volumeSymbol,
    playbackRateObject,
    playbackRateThrowing,
    playbackRateNaN,
    currentTimeObject,
    currentTimeLowerClamp,
    currentTimeSymbol,
    currentTimeInfinity
  ].join('|');
})()
"##,
        )
        .expect("media numeric setters should parse WebIDL values");

    assert_eq!(
        result,
        "0.25:1|1|0|throw:TypeError|throw:TypeError|1.5:1|throw:RangeError|throw:TypeError|3.5:1|0|throw:TypeError|throw:TypeError"
    );
}

#[tokio::test]
async fn media_pseudo_classes_update_has_ancestor_styles() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://media-pseudo-classes.test/",
        &loader,
    );

    let result = vm
        .eval(
            r##"
(() => {
  if (!document.documentElement) {
    document.appendChild(document.createElement("html"));
  }
  if (!document.head) {
    document.documentElement.appendChild(document.createElement("head"));
  }
  if (!document.body) {
    document.documentElement.appendChild(document.createElement("body"));
  }
  const style = document.createElement("style");
  style.textContent = `
    #subject {
      background-color: rgb(0, 0, 0);
      border: 2px solid rgb(0, 0, 0);
      color: rgb(0, 0, 0);
      accent-color: rgb(0, 0, 0);
    }
    #subject:has(:muted) { background-color: rgb(255, 0, 0); }
    #subject:has(:playing) { border-color: rgb(0, 128, 0); }
    #subject:has(:paused) { color: rgb(255, 165, 0); }
    #subject:has(:seeking) { accent-color: rgb(0, 0, 255); }
  `;
  document.head.appendChild(style);

  const subject = document.createElement("section");
  subject.id = "subject";
  const video = document.createElement("video");
  subject.appendChild(video);
  document.body.appendChild(subject);

  let seekingEvents = 0;
  let seekedEvents = 0;
  video.addEventListener("seeking", () => {
    seekingEvents += 1;
  });
  video.addEventListener("seeked", () => {
    seekedEvents += 1;
  });
  globalThis.__lmMediaPseudo = { video, subject, counts: { get seekingEvents() { return seekingEvents; }, get seekedEvents() { return seekedEvents; } } };

  const snapshot = () => [
    video.matches(":muted"),
    video.matches(":playing"),
    video.matches(":paused"),
    video.matches(":seeking"),
    subject.matches("#subject:has(:muted)"),
    subject.matches("#subject:has(:playing)"),
    subject.matches("#subject:has(:paused)"),
    subject.matches("#subject:has(:seeking)"),
    getComputedStyle(subject).backgroundColor,
    getComputedStyle(subject).borderColor,
    getComputedStyle(subject).color,
    getComputedStyle(subject).accentColor,
    seekingEvents,
    seekedEvents
  ].join(",");

  const supports = [
    CSS.supports("selector(:muted)"),
    CSS.supports("selector(:playing)"),
    CSS.supports("selector(:paused)"),
    CSS.supports("selector(:seeking)")
  ].join(",");
  const before = snapshot();
  video.muted = true;
  const afterMuted = snapshot();
  video.play();
  const afterPlay = snapshot();
  video.currentTime = 10;
  const afterSeeking = snapshot();
  return [supports, before, afterMuted, afterPlay, afterSeeking].join("|");
})()
"##,
        )
        .expect("media pseudo-class style invalidation probe should evaluate");

    assert_eq!(
        result,
        "true,true,true,true|false,false,true,false,false,false,true,false,rgb(0, 0, 0),rgb(0, 0, 0),rgb(255, 165, 0),rgb(0, 0, 0),0,0|true,false,true,false,true,false,true,false,rgb(255, 0, 0),rgb(0, 0, 0),rgb(255, 165, 0),rgb(0, 0, 0),0,0|true,true,false,false,true,true,false,false,rgb(255, 0, 0),rgb(0, 128, 0),rgb(0, 0, 0),rgb(0, 0, 0),0,0|true,true,false,true,true,true,false,true,rgb(255, 0, 0),rgb(0, 128, 0),rgb(0, 0, 0),rgb(0, 0, 255),0,0"
    );

    assert!(
        !vm.has_ready_timeout(),
        "media seeking events must not create Page timer descriptors"
    );

    run_next_page_media_element_event_for_test(&mut vm, &loader, "media seeking event turn").await;

    assert_eq!(
        vm.eval(
            "[__lmMediaPseudo.video.seeking, __lmMediaPseudo.counts.seekingEvents, __lmMediaPseudo.counts.seekedEvents].join(',')"
        )
        .expect("media seeking event turn should evaluate"),
        "true,1,0"
    );

    run_next_page_media_element_event_for_test(&mut vm, &loader, "media seeked event turn").await;

    let after_task = vm
        .eval(
            r##"
(() => {
  const { video, subject, counts } = globalThis.__lmMediaPseudo;
  return [
    video.seeking,
    video.matches(":seeking"),
    subject.matches("#subject:has(:seeking)"),
    getComputedStyle(subject).accentColor,
    counts.seekingEvents,
    counts.seekedEvents
  ].join(",");
})()
"##,
        )
        .expect("media seek completion task should evaluate");

    assert_eq!(after_task, "false,false,false,rgb(0, 0, 0),1,1");
}

#[tokio::test]
async fn media_seek_completion_ignores_stale_seek_tokens() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://media-stale-seek-token.test/",
        &loader,
    );

    let result = vm
        .eval(
            r#"
(() => {
  const html = document.documentElement || document.appendChild(document.createElement('html'));
  if (!document.body) {
    html.appendChild(document.createElement('body'));
  }
  const video = document.createElement('video');
  document.body.appendChild(video);
  let seekingEvents = 0;
  let seekedEvents = 0;
  video.addEventListener('seeking', () => { seekingEvents += 1; });
  video.addEventListener('seeked', () => { seekedEvents += 1; });
  video.currentTime = 1;
  video.currentTime = 2;
  globalThis.__lmStaleSeek = { video, get seekingEvents() { return seekingEvents; }, get seekedEvents() { return seekedEvents; } };
  return [video.seeking, video.currentTime, seekingEvents, seekedEvents].join(',');
})()
"#,
        )
        .expect("stale seek setup should evaluate");

    assert_eq!(result, "true,2,0,0");

    for _ in 0..4 {
        if !vm
            .run_one_media_element_event_executor_turn(&loader)
            .await
            .expect("selected dispatcher should advance stale seek completions")
        {
            break;
        }
    }

    let after_tasks = vm
        .eval(
            r#"
(() => {
  const state = globalThis.__lmStaleSeek;
  return [state.video.seeking, state.video.currentTime, state.seekingEvents, state.seekedEvents].join(',');
})()
"#,
        )
        .expect("stale seek completion result should evaluate");

    assert_eq!(after_tasks, "false,2,2,1");
}

#[tokio::test]
async fn slotted_media_state_invalidates_shadow_stylesheet_source() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://slotted-media-state-shadow.test/",
        &loader,
    );

    let result = vm
        .eval(
            r#"
(() => {
  if (!document.documentElement) {
    document.appendChild(document.createElement('html'));
  }
  if (!document.body) {
    document.documentElement.appendChild(document.createElement('body'));
  }
  const host = document.createElement('section');
  const shadow = host.attachShadow({ mode: 'open' });
  const style = document.createElement('style');
  style.textContent = `
    ::slotted(video) { color: rgb(255, 0, 0); }
    ::slotted(video:seeking) { color: rgb(0, 0, 255); }
  `;
  shadow.appendChild(style);
  shadow.appendChild(document.createElement('slot'));
  const video = document.createElement('video');
  host.appendChild(video);
  document.body.appendChild(host);
  const before = [video.matches(':seeking'), getComputedStyle(video).color].join(',');
  video.currentTime = 1;
  const during = [video.matches(':seeking'), getComputedStyle(video).color].join(',');
  globalThis.__lmSlottedMedia = video;
  return [before, during].join('|');
})()
"#,
        )
        .expect("slotted media-state setup should evaluate");

    assert_eq!(result, "false,rgb(255, 0, 0)|true,rgb(0, 0, 255)");

    for _ in 0..4 {
        if !vm
            .run_one_media_element_event_executor_turn(&loader)
            .await
            .expect("selected dispatcher should advance slotted media completion")
        {
            break;
        }
    }

    let after = vm
        .eval(
            r#"
(() => {
  const video = globalThis.__lmSlottedMedia;
  return [video.matches(':seeking'), getComputedStyle(video).color].join(',');
})()
"#,
        )
        .expect("slotted media-state result should evaluate");

    assert_eq!(after, "false,rgb(255, 0, 0)");
}

#[test]
fn media_text_track_surface_exposes_reflected_tracks_and_lists() {
    let mut vm = new_storage_test_vm("https://media-text-track-surface.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const video = document.createElement('video');
  const manual = video.addTextTrack('subtitles', 'Manual', 'en');
  const track = document.createElement('track');
  track.kind = 'CAPTIONS';
  track.label = 'Caption';
  track.srclang = 'fr';
  video.appendChild(track);
  const elementTrack = track.track;
  const cue = new VTTCue(0, 1, 'caption');
  cue.id = 'cue-id';
  manual.addCue(cue);
  manual.mode = 'showing';
  track.label = 'Caption 2';
  track.srclang = 'fr-CA';

  return [
    track.kind,
    track.getAttribute('kind'),
    track.default,
    track.readyState,
    elementTrack instanceof TextTrack,
    elementTrack.kind,
    elementTrack.label,
    elementTrack.language,
    video.textTracks === video.textTracks,
    video.textTracks.length,
    video.textTracks[0].label,
    video.textTracks[1].label,
    manual.kind,
    manual.label,
    manual.language,
    manual.cues instanceof TextTrackCueList,
    manual.cues.length,
    manual.cues[0] === cue,
    manual.cues.getCueById('cue-id') === cue,
    cue.track === manual
  ].join('|');
})()
"#,
        )
        .expect("media text track surface should evaluate");

    assert_eq!(
        result,
        "captions|CAPTIONS|false|0|true|captions|Caption 2|fr-CA|true|2|Caption 2|Manual|subtitles|Manual|en|true|1|true|true|true"
    );
}

#[test]
fn media_element_prototype_constants_are_declared() {
    let mut vm = new_storage_test_vm("https://media-element-constants-declared.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const constants = [
    ["NETWORK_EMPTY", 0],
    ["NETWORK_IDLE", 1],
    ["NETWORK_LOADING", 2],
    ["NETWORK_NO_SOURCE", 3],
    ["HAVE_NOTHING", 0],
    ["HAVE_METADATA", 1],
    ["HAVE_CURRENT_DATA", 2],
    ["HAVE_FUTURE_DATA", 3],
    ["HAVE_ENOUGH_DATA", 4]
  ];
  const descriptorShape = (owner, name, expected) => {
    const descriptor = Object.getOwnPropertyDescriptor(owner, name);
    return [
      name,
      descriptor && descriptor.value,
      descriptor && descriptor.value === expected,
      descriptor && descriptor.enumerable,
      descriptor && descriptor.writable,
      descriptor && descriptor.configurable
    ].join(":");
  };
  const constructorOwn = (ctor) =>
    constants
      .map(([name]) => name)
      .filter(name => Object.prototype.hasOwnProperty.call(ctor, name));
  const prototypeKeysContainConstants = (prototype) =>
    Object.keys(prototype).some(name =>
      constants.some(([constant]) => constant === name)
    );
  const video = document.createElement("video");
  const audio = document.createElement("audio");
  return JSON.stringify({
    media: constants.map(([name, value]) =>
      descriptorShape(HTMLMediaElement.prototype, name, value)
    ),
    audio: constants.map(([name, value]) =>
      descriptorShape(HTMLAudioElement.prototype, name, value)
    ),
    video: constants.map(([name, value]) =>
      descriptorShape(HTMLVideoElement.prototype, name, value)
    ),
    constructorOwn: {
      media: constructorOwn(HTMLMediaElement),
      audio: constructorOwn(HTMLAudioElement),
      video: constructorOwn(HTMLVideoElement)
    },
    instanceOwn: {
      audio: constants
        .map(([name]) => name)
        .filter(name => Object.prototype.hasOwnProperty.call(audio, name)),
      video: constants
        .map(([name]) => name)
        .filter(name => Object.prototype.hasOwnProperty.call(video, name))
    },
    keysContainConstants: [
      prototypeKeysContainConstants(HTMLMediaElement.prototype),
      prototypeKeysContainConstants(HTMLAudioElement.prototype),
      prototypeKeysContainConstants(HTMLVideoElement.prototype)
    ],
    inheritedValues: [
      audio.networkState === audio.NETWORK_EMPTY,
      video.networkState === video.NETWORK_EMPTY,
      audio.readyState === audio.HAVE_NOTHING,
      video.readyState === video.HAVE_NOTHING
    ]
  });
})()
"#,
        )
        .expect("media element constants descriptor probe should evaluate");

    assert_eq!(
        result,
        r#"{"media":["NETWORK_EMPTY:0:true:true:false:false","NETWORK_IDLE:1:true:true:false:false","NETWORK_LOADING:2:true:true:false:false","NETWORK_NO_SOURCE:3:true:true:false:false","HAVE_NOTHING:0:true:true:false:false","HAVE_METADATA:1:true:true:false:false","HAVE_CURRENT_DATA:2:true:true:false:false","HAVE_FUTURE_DATA:3:true:true:false:false","HAVE_ENOUGH_DATA:4:true:true:false:false"],"audio":["NETWORK_EMPTY:0:true:true:false:false","NETWORK_IDLE:1:true:true:false:false","NETWORK_LOADING:2:true:true:false:false","NETWORK_NO_SOURCE:3:true:true:false:false","HAVE_NOTHING:0:true:true:false:false","HAVE_METADATA:1:true:true:false:false","HAVE_CURRENT_DATA:2:true:true:false:false","HAVE_FUTURE_DATA:3:true:true:false:false","HAVE_ENOUGH_DATA:4:true:true:false:false"],"video":["NETWORK_EMPTY:0:true:true:false:false","NETWORK_IDLE:1:true:true:false:false","NETWORK_LOADING:2:true:true:false:false","NETWORK_NO_SOURCE:3:true:true:false:false","HAVE_NOTHING:0:true:true:false:false","HAVE_METADATA:1:true:true:false:false","HAVE_CURRENT_DATA:2:true:true:false:false","HAVE_FUTURE_DATA:3:true:true:false:false","HAVE_ENOUGH_DATA:4:true:true:false:false"],"constructorOwn":{"media":["NETWORK_EMPTY","NETWORK_IDLE","NETWORK_LOADING","NETWORK_NO_SOURCE","HAVE_NOTHING","HAVE_METADATA","HAVE_CURRENT_DATA","HAVE_FUTURE_DATA","HAVE_ENOUGH_DATA"],"audio":["NETWORK_EMPTY","NETWORK_IDLE","NETWORK_LOADING","NETWORK_NO_SOURCE","HAVE_NOTHING","HAVE_METADATA","HAVE_CURRENT_DATA","HAVE_FUTURE_DATA","HAVE_ENOUGH_DATA"],"video":["NETWORK_EMPTY","NETWORK_IDLE","NETWORK_LOADING","NETWORK_NO_SOURCE","HAVE_NOTHING","HAVE_METADATA","HAVE_CURRENT_DATA","HAVE_FUTURE_DATA","HAVE_ENOUGH_DATA"]},"instanceOwn":{"audio":[],"video":[]},"keysContainConstants":[true,true,true],"inheritedValues":[true,true,true,true]}"#
    );
}

#[test]
fn media_error_constants_are_declared_on_constructor_and_prototype() {
    let mut vm = new_storage_test_vm("https://media-error-constants-declared.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const constants = [
    ["MEDIA_ERR_ABORTED", 1],
    ["MEDIA_ERR_NETWORK", 2],
    ["MEDIA_ERR_DECODE", 3],
    ["MEDIA_ERR_SRC_NOT_SUPPORTED", 4]
  ];
  const descriptorShape = (owner, name, expected) => {
    const descriptor = Object.getOwnPropertyDescriptor(owner, name);
    return [
      name,
      descriptor && descriptor.value,
      descriptor && descriptor.value === expected,
      descriptor && descriptor.enumerable,
      descriptor && descriptor.writable,
      descriptor && descriptor.configurable
    ].join(":");
  };
  const keysContainConstants = owner =>
    Object.keys(owner).some(name =>
      constants.some(([constant]) => constant === name)
    );
  return JSON.stringify({
    constructor: constants.map(([name, value]) =>
      descriptorShape(MediaError, name, value)
    ),
    prototype: constants.map(([name, value]) =>
      descriptorShape(MediaError.prototype, name, value)
    ),
    keysContainConstants: [
      keysContainConstants(MediaError),
      keysContainConstants(MediaError.prototype)
    ],
    constructorMatchesPrototype: constants.every(([name]) =>
      MediaError[name] === MediaError.prototype[name]
    )
  });
})()
"#,
        )
        .expect("MediaError constants descriptor probe should evaluate");

    assert_eq!(
        result,
        r#"{"constructor":["MEDIA_ERR_ABORTED:1:true:true:false:false","MEDIA_ERR_NETWORK:2:true:true:false:false","MEDIA_ERR_DECODE:3:true:true:false:false","MEDIA_ERR_SRC_NOT_SUPPORTED:4:true:true:false:false"],"prototype":["MEDIA_ERR_ABORTED:1:true:true:false:false","MEDIA_ERR_NETWORK:2:true:true:false:false","MEDIA_ERR_DECODE:3:true:true:false:false","MEDIA_ERR_SRC_NOT_SUPPORTED:4:true:true:false:false"],"keysContainConstants":[true,true],"constructorMatchesPrototype":true}"#
    );
}

#[test]
fn media_error_instance_attributes_are_readonly_prototype_accessors() {
    let mut vm = new_storage_test_vm("https://media-error-attributes-declared.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const shape = name => {
    const descriptor = Object.getOwnPropertyDescriptor(MediaError.prototype, name);
    return [
      typeof descriptor.get,
      descriptor.set === undefined,
      descriptor.enumerable,
      descriptor.configurable
    ].join(":");
  };
  let codeBrand;
  let messageBrand;
  try { Reflect.get(MediaError.prototype, "code", {}); } catch (error) { codeBrand = error.name; }
  try { Reflect.get(MediaError.prototype, "message", {}); } catch (error) { messageBrand = error.name; }
  return [shape("code"), shape("message"), codeBrand, messageBrand].join("|");
})()
"#,
        )
        .expect("MediaError attribute descriptor probe should evaluate");

    assert_eq!(
        result,
        "function:true:true:true|function:true:true:true|TypeError|TypeError"
    );
}

#[test]
fn html_track_element_constants_are_declared_on_constructor_and_prototype() {
    let mut vm = new_storage_test_vm("https://html-track-constants-declared.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const constants = [
    ["NONE", 0],
    ["LOADING", 1],
    ["LOADED", 2],
    ["ERROR", 3]
  ];
  const descriptorShape = (owner, name, expected) => {
    const descriptor = Object.getOwnPropertyDescriptor(owner, name);
    return [
      name,
      descriptor && descriptor.value,
      descriptor && descriptor.value === expected,
      descriptor && descriptor.enumerable,
      descriptor && descriptor.writable,
      descriptor && descriptor.configurable
    ].join(":");
  };
  const track = document.createElement("track");
  return JSON.stringify({
    constructor: constants.map(([name, value]) =>
      descriptorShape(HTMLTrackElement, name, value)
    ),
    prototype: constants.map(([name, value]) =>
      descriptorShape(HTMLTrackElement.prototype, name, value)
    ),
    instanceOwn: constants
      .map(([name]) => name)
      .filter(name => Object.prototype.hasOwnProperty.call(track, name)),
    keysContainConstants: Object.keys(HTMLTrackElement).some(name =>
      constants.some(([constant]) => constant === name)
    ) || Object.keys(HTMLTrackElement.prototype).some(name =>
      constants.some(([constant]) => constant === name)
    ),
    readyStateMatchesNone: track.readyState === HTMLTrackElement.NONE
  });
})()
"#,
        )
        .expect("HTMLTrackElement constants descriptor probe should evaluate");

    assert_eq!(
        result,
        r#"{"constructor":["NONE:0:true:true:false:false","LOADING:1:true:true:false:false","LOADED:2:true:true:false:false","ERROR:3:true:true:false:false"],"prototype":["NONE:0:true:true:false:false","LOADING:1:true:true:false:false","LOADED:2:true:true:false:false","ERROR:3:true:true:false:false"],"instanceOwn":[],"keysContainConstants":true,"readyStateMatchesNone":true}"#
    );
}

#[test]
fn media_text_track_surface_is_declared_on_interface_prototypes() {
    let mut vm = new_storage_test_vm("https://media-text-track-declared-surface.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const video = document.createElement('video');
  const trackElement = document.createElement('track');
  trackElement.id = 'caption-track';
  video.appendChild(trackElement);
  const elementTrack = trackElement.track;
  const manual = video.addTextTrack('subtitles', 'Manual', 'en');
  manual.mode = 'hidden';
  const cue = new VTTCue(0, 1, 'caption');
  cue.id = 'cue-id';
  manual.addCue(cue);
  const second = new VTTCue(1, 2, 'second');
  second.id = 'second';
  manual.addCue(second);
  const list = video.textTracks;
  const cues = manual.cues;
  const ownFrom = (object, names) =>
    Object.getOwnPropertyNames(object).filter(name => names.includes(name));
  const accessorDescriptor = (object, name) => {
    const descriptor = Object.getOwnPropertyDescriptor(object, name);
    return {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      getter: `${descriptor.get.name}:${descriptor.get.length}`,
      setter: descriptor.set ? `${descriptor.set.name}:${descriptor.set.length}` : null
    };
  };
  const methodDescriptor = (object, name) => {
    const descriptor = Object.getOwnPropertyDescriptor(object, name);
    return {
      enumerable: descriptor.enumerable,
      writable: descriptor.writable,
      configurable: descriptor.configurable,
      name: descriptor.value.name,
      length: descriptor.value.length
    };
  };
  const probe = callback => {
    try {
      callback();
      return 'ok';
    } catch (error) {
      return error && error.name;
    }
  };
  const listSurfaceNames = ['length', 'onaddtrack', 'onremovetrack', 'getTrackById'];
  const cueListSurfaceNames = ['length', 'getCueById'];
  const trackSurfaceNames = [
    'kind', 'label', 'language', 'id', 'mode', 'cues', 'activeCues',
    'oncuechange', 'addCue', 'removeCue'
  ];
  const secondLookupBeforeRemove = cues.getCueById('second') === second;
  manual.removeCue(second);
  const mode = Object.getOwnPropertyDescriptor(TextTrack.prototype, 'mode');
  mode.set.call(manual, 'showing');

  return JSON.stringify({
    own: {
      list: ownFrom(list, listSurfaceNames),
      cues: ownFrom(cues, cueListSurfaceNames),
      track: ownFrom(manual, trackSurfaceNames)
    },
    prototypes: {
      list: ownFrom(TextTrackList.prototype, listSurfaceNames),
      cues: ownFrom(TextTrackCueList.prototype, cueListSurfaceNames),
      track: ownFrom(TextTrack.prototype, trackSurfaceNames)
    },
    chains: [
      Object.getPrototypeOf(TextTrackList.prototype) === EventTarget.prototype,
      Object.getPrototypeOf(TextTrack.prototype) === EventTarget.prototype
    ],
    accessors: {
      listLength: accessorDescriptor(TextTrackList.prototype, 'length'),
      onaddtrack: accessorDescriptor(TextTrackList.prototype, 'onaddtrack'),
      cueListLength: accessorDescriptor(TextTrackCueList.prototype, 'length'),
      mode: accessorDescriptor(TextTrack.prototype, 'mode'),
      oncuechange: accessorDescriptor(TextTrack.prototype, 'oncuechange')
    },
    methods: {
      getTrackById: methodDescriptor(TextTrackList.prototype, 'getTrackById'),
      getCueById: methodDescriptor(TextTrackCueList.prototype, 'getCueById'),
      addCue: methodDescriptor(TextTrack.prototype, 'addCue'),
      removeCue: methodDescriptor(TextTrack.prototype, 'removeCue')
    },
    borrowed: [
      Object.getOwnPropertyDescriptor(TextTrackList.prototype, 'length').get.call(list),
      Object.getOwnPropertyDescriptor(TextTrackCueList.prototype, 'length').get.call(cues),
      mode.get.call(manual)
    ],
    forged: [
      probe(() => mode.get.call({})),
      probe(() =>
        Object.getOwnPropertyDescriptor(TextTrackList.prototype, 'length').get.call({})
      ),
      probe(() =>
        Object.getOwnPropertyDescriptor(TextTrackCueList.prototype, 'getCueById')
          .value.call({}, 'cue-id')
      )
    ],
    crossBrand: [
      probe(() =>
        Object.getOwnPropertyDescriptor(TextTrackList.prototype, 'length').get.call(cues)
      ),
      probe(() =>
        Object.getOwnPropertyDescriptor(TextTrackCueList.prototype, 'length').get.call(list)
      ),
      probe(() =>
        Object.getOwnPropertyDescriptor(TextTrackList.prototype, 'getTrackById')
          .value.call(cues, 'cue-id')
      ),
      probe(() =>
        Object.getOwnPropertyDescriptor(TextTrackCueList.prototype, 'getCueById')
          .value.call(list, 'caption-track')
      )
    ],
    getTrackByIdBehavior: [
      list.getTrackById('caption-track') === elementTrack,
      list.getTrackById('missing') === null
    ],
    getCueByIdBehavior: [
      cues.getCueById('cue-id') === cue,
      secondLookupBeforeRemove,
      cues.getCueById('second') === null,
      second.track === null
    ]
  });
})()
"#,
        )
        .expect("media text track declared surface probe should evaluate");

    assert_eq!(
        result,
        r#"{"own":{"list":[],"cues":[],"track":[]},"prototypes":{"list":["length","onaddtrack","onremovetrack","getTrackById"],"cues":["length","getCueById"],"track":["kind","id","label","language","mode","cues","activeCues","oncuechange","addCue","removeCue"]},"chains":[true,true],"accessors":{"listLength":{"enumerable":true,"configurable":true,"getter":"get length:0","setter":null},"onaddtrack":{"enumerable":true,"configurable":true,"getter":"get onaddtrack:0","setter":"set onaddtrack:1"},"cueListLength":{"enumerable":true,"configurable":true,"getter":"get length:0","setter":null},"mode":{"enumerable":true,"configurable":true,"getter":"get mode:0","setter":"set mode:1"},"oncuechange":{"enumerable":true,"configurable":true,"getter":"get oncuechange:0","setter":"set oncuechange:1"}},"methods":{"getTrackById":{"enumerable":true,"writable":true,"configurable":true,"name":"getTrackById","length":1},"getCueById":{"enumerable":true,"writable":true,"configurable":true,"name":"getCueById","length":1},"addCue":{"enumerable":true,"writable":true,"configurable":true,"name":"addCue","length":1},"removeCue":{"enumerable":true,"writable":true,"configurable":true,"name":"removeCue","length":1}},"borrowed":[2,1,"showing"],"forged":["TypeError","TypeError","TypeError"],"crossBrand":["TypeError","TypeError","TypeError","TypeError"],"getTrackByIdBehavior":[true,true],"getCueByIdBehavior":[true,true,true,true]}"#
    );
}

#[test]
fn track_event_track_uses_prototype_private_slot() {
    let mut vm = new_storage_test_vm("https://track-event-private-slot.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const video = document.createElement('video');
  const first = video.addTextTrack('subtitles', 'First', 'en');
  const second = video.addTextTrack('captions', 'Second', 'en');
  const event = new TrackEvent('addtrack', { track: first });
  const empty = new TrackEvent('addtrack');
  const descriptor = Object.getOwnPropertyDescriptor(TrackEvent.prototype, 'track');
  const ownBefore = Object.getOwnPropertyNames(event).filter(name => name === 'track');
  event.track = second;
  const fake = { track: second };
  let fakeTrackThrowsTypeError = false;
  try { descriptor.get.call(fake); }
  catch (error) { fakeTrackThrowsTypeError = error instanceof TypeError; }

  return JSON.stringify({
    hasGetter: typeof descriptor.get === 'function',
    getterName: descriptor.get.name,
    getterLength: descriptor.get.length,
    hasSetter: 'set' in descriptor && descriptor.set === undefined,
    enumerable: descriptor.enumerable,
    configurable: descriptor.configurable,
    ownBefore,
    trackAfterAssignment: event.track === first,
    assignmentCreatedOwn: Object.prototype.hasOwnProperty.call(event, 'track'),
    emptyTrackIsNull: empty.track === null,
    fakeTrackThrowsTypeError
  });
})()
"#,
        )
        .expect("TrackEvent private slot probe should evaluate");

    assert_eq!(
        result,
        r#"{"hasGetter":true,"getterName":"get track","getterLength":0,"hasSetter":true,"enumerable":true,"configurable":true,"ownBefore":[],"trackAfterAssignment":true,"assignmentCreatedOwn":false,"emptyTrackIsNull":true,"fakeTrackThrowsTypeError":true}"#
    );
}

#[test]
fn media_text_track_reflection_and_cue_list_indexing_match_wpt_edges() {
    let mut vm = new_storage_test_vm("https://media-text-track-wpt-edges.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const video = document.createElement('video');
  const emptySrcTrack = document.createElement('track');
  emptySrcTrack.src = '';
  const emptyTrackSrc = `${emptySrcTrack.src}:${emptySrcTrack.getAttribute('src')}`;

  const track = document.createElement('track');
  track.label = 'bar';
  track.srclang = 'en';
  video.appendChild(track);
  const elementTrack = track.track;
  track.removeAttribute('label');
  track.removeAttribute('srclang');
  const reflected = `${elementTrack.label}:${elementTrack.language}`;

  const manual = video.addTextTrack('subtitles');
  const cues = manual.cues;
  let strictCreate = 'no-throw';
  try {
    Function('cues', '"use strict"; cues[0] = "x";')(cues);
  } catch (error) {
    strictCreate = error.name;
  }
  cues[0] = 'x';
  const emptyIndex = cues[0] === undefined;

  const first = new VTTCue(0, 1, 'first');
  first.id = 'first';
  const second = new VTTCue(1, 2, 'second');
  second.id = 'second';
  manual.addCue(first);
  manual.addCue(second);
  second.startTime = 0;
  const tieOrder = `${cues[0].id}:${cues[1].id}`;
  let strictSet = 'no-throw';
  try {
    Function('cues', '"use strict"; cues[0] = "x";')(cues);
  } catch (error) {
    strictSet = error.name;
  }
  cues[0] = 'x';
  const retained = cues[0] === second;
  manual.removeCue(second);
  manual.removeCue(first);
  const removedIndex = cues[0] === undefined;

  return [emptyTrackSrc, reflected, strictCreate, emptyIndex, tieOrder, strictSet, retained, removedIndex].join('|');
})()
"#,
        )
        .expect("media text track WPT edge probe should evaluate");

    assert_eq!(
        result,
        "https://media-text-track-wpt-edges.test/:|:|TypeError|true|second:first|TypeError|true|true"
    );
}
#[tokio::test]
async fn media_text_track_data_src_loads_after_media_parent_and_clears_cues() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://media-text-track-loading.test/",
        &loader,
    );

    let before = vm
        .eval(
            r#"
(() => {
  const source = 'data:text/vtt,WEBVTT%0A%0A2%0A00%3A00%3A02.000%20--%3E%2000%3A00%3A03.000%0Atwo%0A%0A1%0A00%3A00%3A00.000%20--%3E%2000%3A00%3A01.000%0Aone';
  const video = document.createElement('video');
  const track = document.createElement('track');
  track.src = source;
  track.default = true;
  const beforeParent = track.readyState;
  video.appendChild(track);
  const beforePreferenceTask = track.track.cues === null;
  video.play();
  globalThis.__lmTrackLoadProbe = { track };
  return [beforeParent, beforePreferenceTask, track.readyState].join('|');
})()
"#,
        )
        .expect("media text track data source setup should evaluate");

    assert_eq!(before, "0|true|0");

    assert!(
        vm.run_one_dom_manipulation_task_executor_turn(
            PageDomManipulationTestFamily::TextTrackDefaultMode,
            &loader,
        )
        .await
        .expect("already-applied default-mode task should settle"),
        "track insertion should queue one coalesced default-mode task"
    );
    assert!(
        vm.run_one_text_track_networking_task_executor_turn(&loader)
            .await
            .expect("text-track load-start networking turn")
    );
    assert!(
        vm.run_one_text_track_networking_task_executor_turn(&loader)
            .await
            .expect("text-track terminal networking turn")
    );

    let after_first_load = vm
        .eval(
            r#"
(() => {
  const track = globalThis.__lmTrackLoadProbe.track;
  const cues = track.track.cues;
  const loaded = `${track.readyState}:${cues.length}:${cues[0].id}:${cues[1].id}`;
  const cue = new VTTCue(1.5, 2, 'middle');
  cue.id = 'middle';
  track.track.addCue(cue);
  const sorted = `${cues.length}:${cues[1].id}`;
  track.src = 'data:text/vtt,WEBVTT';
  globalThis.__lmTrackLoadProbe.cues = cues;
  return [loaded, sorted, cues.length, track.readyState, track.track.cues === cues].join('|');
})()
"#,
        )
        .expect("media text track data source should load and clear cues");

    assert_eq!(after_first_load, "2:2:1:2|3:middle|0|0|true");

    assert!(
        vm.run_one_text_track_networking_task_executor_turn(&loader)
            .await
            .expect("text-track reload-start networking turn")
    );
    assert!(
        vm.run_one_text_track_networking_task_executor_turn(&loader)
            .await
            .expect("text-track reload terminal networking turn")
    );

    let after_second_load = vm
        .eval(
            r#"
(() => {
  const track = globalThis.__lmTrackLoadProbe.track;
  const cues = globalThis.__lmTrackLoadProbe.cues;
  return [track.readyState, cues.length, track.track.cues === cues].join('|');
})()
"#,
        )
        .expect("media text track empty source should finish loading");

    assert_eq!(after_second_load, "2|0|true");

    let before_missing_source = vm
        .eval(
            r#"
(() => {
  const track = globalThis.__lmTrackLoadProbe.track;
  globalThis.__lmTrackLoadProbe.errors = 0;
  track.addEventListener('error', () => globalThis.__lmTrackLoadProbe.errors += 1);
  track.removeAttribute('src');
  return `${track.readyState}:${globalThis.__lmTrackLoadProbe.errors}`;
})()
"#,
        )
        .expect("removing the text-track source should queue failure");
    assert_eq!(before_missing_source, "0:0");

    assert!(
        vm.run_one_text_track_networking_task_executor_turn(&loader)
            .await
            .expect("missing text-track source start should settle")
    );
    assert!(
        vm.run_one_dom_manipulation_task_executor_turn(
            PageDomManipulationTestFamily::TextTrackLoad,
            &loader,
        )
        .await
        .expect("missing text-track source failure should settle")
    );
    assert_eq!(
        vm.eval(
            "`${globalThis.__lmTrackLoadProbe.track.readyState}:${globalThis.__lmTrackLoadProbe.errors}`"
        )
        .expect("missing text-track source state should evaluate"),
        "3:1"
    );
}

#[tokio::test]
async fn media_text_track_load_honors_media_src_csp() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://media-track-csp.test/",
        &loader,
    );
    vm.set_response_content_security_policies(&["media-src 'self'".to_owned()]);

    vm.eval(
        r#"
(() => {
  globalThis.__lmTrackCspEvents = [];
  document.addEventListener('securitypolicyviolation', event => {
    __lmTrackCspEvents.push(`csp:${event.effectiveDirective}:${event.blockedURI}`);
  });
  const video = document.createElement('video');
  const track = document.createElement('track');
  track.default = true;
  track.addEventListener('load', () => __lmTrackCspEvents.push('load'));
  track.addEventListener('error', () => __lmTrackCspEvents.push('error'));
  video.appendChild(track);
  (document.body || document.documentElement || document).appendChild(video);
  track.src = 'data:text/vtt,WEBVTT';
  globalThis.__lmTrackCspElement = track;
})()
"#,
    )
    .expect("text track CSP setup should evaluate");

    assert!(
        vm.run_one_dom_manipulation_task_executor_turn(
            PageDomManipulationTestFamily::TextTrackDefaultMode,
            &loader,
        )
        .await
        .expect("text-track default-mode task should settle"),
        "track insertion should queue one default-mode task"
    );
    assert!(
        vm.run_one_text_track_networking_task_executor_turn(&loader)
            .await
            .expect("text-track CSP load-start networking turn"),
        "track source should queue one typed load-start task"
    );
    assert_eq!(
        drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm),
        1
    );
    assert!(
        vm.run_one_dom_manipulation_task_executor_turn(
            PageDomManipulationTestFamily::TextTrackLoad,
            &loader,
        )
        .await
        .expect("text-track CSP failure terminal DOM-manipulation turn"),
        "blocked track source should queue one typed failure terminal task"
    );

    assert_eq!(
        vm.eval(
            r#"JSON.stringify({
  events: __lmTrackCspEvents.sort(),
  readyState: __lmTrackCspElement.readyState,
  cueCount: __lmTrackCspElement.track.cues.length,
})"#,
        )
        .expect("text track CSP result should evaluate"),
        r#"{"events":["csp:media-src:data","error"],"readyState":3,"cueCount":0}"#
    );
}

#[tokio::test]
async fn media_text_track_list_addtrack_events_are_queued() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://media-text-track-addtrack.test/",
        &loader,
    );

    let before = vm
        .eval(
            r#"
(() => {
  const video = document.createElement('video');
  const trackElement = document.createElement('track');
  video.appendChild(trackElement);
  const first = trackElement.track;
  const list = video.textTracks;
  const events = [];
  list.onaddtrack = event => {
    events.push([
      event.target === list,
      event instanceof TrackEvent,
      event.track === (events.length === 0 ? first : video.textTracks[1])
    ].join(':'));
    if (events.length === 1) {
      video.addTextTrack('captions', 'Caption Track', 'en');
    }
  };
  globalThis.__lmTrackListAddTrackProbe = { video, first, list, events };
  return [list.length, events.length].join('|');
})()
"#,
        )
        .expect("media text track addtrack setup should evaluate");

    assert_eq!(before, "1|0");

    run_next_page_media_element_event_for_test(&mut vm, &loader, "first addtrack event turn").await;
    run_next_page_media_element_event_for_test(&mut vm, &loader, "second addtrack event turn")
        .await;

    let after = vm
        .eval(
            r#"
(() => {
  const probe = globalThis.__lmTrackListAddTrackProbe;
  return [probe.list.length, probe.events.join('|')].join('|');
})()
"#,
        )
        .expect("media text track addtrack events should fire");

    assert_eq!(after, "2|true:true:true|true:true:true");
}
#[tokio::test]
async fn media_active_cues_update_after_media_load_and_play() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://media-active-cues.test/",
        &loader,
    );

    let before = vm
        .eval(
            r#"
(() => {
  if (!document.documentElement) {
    document.appendChild(document.createElement('html'));
  }
  if (!document.body) {
    document.documentElement.appendChild(document.createElement('body'));
  }
  const video = document.createElement('video');
  const track = video.addTextTrack('subtitles');
  const first = new VTTCue(0, 1, 'first');
  const second = new VTTCue(1, 2, 'second');
  track.addCue(first);
  track.addCue(second);
  track.mode = 'showing';
  const active = track.activeCues;
  globalThis.__lmActiveCueProbe = { video, track, active, loaded: false };
  video.onloadeddata = () => {
    const beforePlay = `${active.length}:${video.readyState}`;
    video.play();
    const afterPlay = `${active.length}:${active[0] && active[0].text}`;
    const third = new VTTCue(0, 2, 'third');
    track.addCue(third);
    globalThis.__lmActiveCueProbe.result = [
      beforePlay,
      afterPlay,
      `${active.length}:${active[0].text}:${active[1].text}`
    ].join('|');
    globalThis.__lmActiveCueProbe.loaded = true;
  };
  document.body.appendChild(video);
  video.src = 'data:video/webm;base64,AA==';
  return `${active.length}:${globalThis.__lmActiveCueProbe.loaded}`;
})()
"#,
        )
        .expect("media active cue setup should evaluate");

    assert_eq!(before, "0:false");

    for phase in ["loadstart", "loadedmetadata", "loadeddata", "canplay"] {
        run_next_page_media_element_event_for_test(
            &mut vm,
            &loader,
            &format!("active-cue media {phase} turn"),
        )
        .await;
    }

    let after = vm
        .eval(
            r#"
[
  globalThis.__lmActiveCueProbe.loaded,
  globalThis.__lmActiveCueProbe.result
].join('|')
"#,
        )
        .expect("media active cue result should evaluate");

    assert_eq!(after, "true|0:2|1:first|2:third:first");
}
#[tokio::test]
async fn default_track_inserted_while_playing_refreshes_active_cues() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://default-track-active-cues.test/",
        &loader,
    );

    let before = vm
        .eval(
            r#"
(() => {
  if (!document.documentElement) {
    document.appendChild(document.createElement('html'));
  }
  if (!document.body) {
    document.documentElement.appendChild(document.createElement('body'));
  }
  const video = document.createElement('video');
  document.body.appendChild(video);
  video.play();
  const trackElement = document.createElement('track');
  trackElement.default = true;
  trackElement.src = 'data:text/vtt,WEBVTT%0A%0A00%3A00%3A00.000%20--%3E%2000%3A00%3A01.000%0Aactive';
  video.appendChild(trackElement);
  globalThis.__lmDefaultTrackProbe = {
    track: trackElement.track,
    beforeMode: trackElement.track.mode,
    beforeActive: trackElement.track.activeCues
  };
  return `${globalThis.__lmDefaultTrackProbe.beforeMode}:${globalThis.__lmDefaultTrackProbe.beforeActive}`;
})()
"#,
        )
        .expect("default text track setup should evaluate");

    assert_eq!(before, "disabled:null");

    assert!(
        vm.run_one_dom_manipulation_task_executor_turn(
            PageDomManipulationTestFamily::TextTrackDefaultMode,
            &loader,
        )
        .await
        .expect("default-mode DOM-manipulation task should settle"),
        "dynamic default track should queue one typed mode-selection task"
    );
    assert!(
        vm.run_one_text_track_networking_task_executor_turn(&loader)
            .await
            .expect("default text-track load-start networking turn")
    );
    assert!(
        vm.run_one_text_track_networking_task_executor_turn(&loader)
            .await
            .expect("default text-track terminal networking turn")
    );

    let after = vm
        .eval(
            r#"
[
  globalThis.__lmDefaultTrackProbe.track.mode,
  globalThis.__lmDefaultTrackProbe.track.activeCues.length,
  globalThis.__lmDefaultTrackProbe.track.activeCues[0].text
].join('|')
"#,
        )
        .expect("default text track active cue result should evaluate");

    assert_eq!(after, "showing|1|active");
}
#[test]
fn vtt_cue_get_cue_as_html_returns_text_fragment() {
    let mut vm = new_storage_test_vm("https://vtt-cue-html.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const empty = new VTTCue(0, 1, '');
  const emptyFragment = empty.getCueAsHTML();
  const text = new VTTCue(0, 1, 'hello');
  const textFragment = text.getCueAsHTML();
  return [
    emptyFragment instanceof DocumentFragment,
    emptyFragment.childNodes.length,
    emptyFragment.childNodes[0] instanceof Text,
    emptyFragment.childNodes[0].data,
    textFragment.textContent,
    textFragment.childNodes.length
  ].join('|');
})()
"#,
        )
        .expect("VTTCue getCueAsHTML probe should evaluate");

    assert_eq!(result, "true|1|true||hello|1");
}
#[test]
fn vtt_cue_get_cue_as_html_builds_supported_markup_fragment() {
    let mut vm = new_storage_test_vm("https://vtt-cue-markup.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const cue = new VTTCue(0, 1, 'A <b>bold</b> <i.larger>italic</i> <ruby>Bear<rt>bear</rt></ruby> <c.red.upper>class</c> <v.blue Speaker>voice</v>');
  const fragment = cue.getCueAsHTML();
  const b = fragment.querySelector('b');
  const i = fragment.querySelector('i');
  const ruby = fragment.querySelector('ruby');
  const rt = fragment.querySelector('rt');
  const spans = fragment.querySelectorAll('span');
  return [
    fragment.textContent,
    b && b.textContent,
    i && i.className,
    ruby && ruby.textContent,
    rt && rt.textContent,
    spans[0] && spans[0].className,
    spans[1] && spans[1].className,
    spans[1] && spans[1].title
  ].join('|');
})()
"#,
        )
        .expect("VTTCue getCueAsHTML markup probe should evaluate");

    assert_eq!(
        result,
        "A bold italic Bearbear class voice|bold|larger|Bearbear|bear|red upper|blue|Speaker"
    );
}

#[test]
fn vtt_cue_surface_is_declared_on_interface_prototypes() {
    let mut vm = new_storage_test_vm("https://vtt-cue-declared-surface.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const cue = new VTTCue(1, 2, 'hello');
  const expectedNames = [
    'addEventListener',
    'removeEventListener',
    'dispatchEvent',
    'startTime',
    'endTime',
    'text',
    'id',
    'vertical',
    'snapToLines',
    'line',
    'position',
    'size',
    'align',
    'getCueAsHTML',
    'pauseOnExit',
    'onenter',
    'onexit',
    'track'
  ];
  const descriptor = (object, name) => {
    const desc = Object.getOwnPropertyDescriptor(object, name);
    if (Object.prototype.hasOwnProperty.call(desc, 'value')) {
      return {
        enumerable: desc.enumerable,
        writable: desc.writable,
        configurable: desc.configurable,
        value: desc.value,
        name: typeof desc.value === 'function' ? desc.value.name : undefined,
        length: typeof desc.value === 'function' ? desc.value.length : undefined
      };
    }
    return {
      enumerable: desc.enumerable,
      configurable: desc.configurable,
      hasGetter: typeof desc.get === 'function',
      hasSetter: typeof desc.set === 'function'
    };
  };
  cue.onenter = () => {};
  const onenterAssigned = typeof cue.onenter === 'function';
  cue.onenter = undefined;
  const onenterUndefined = cue.onenter === null;
  const startTime = Object.getOwnPropertyDescriptor(TextTrackCue.prototype, 'startTime');
  const text = Object.getOwnPropertyDescriptor(VTTCue.prototype, 'text');
  const getCueAsHTML =
    Object.getOwnPropertyDescriptor(VTTCue.prototype, 'getCueAsHTML').value;
  const probe = callback => {
    try {
      callback();
      return 'ok';
    } catch (error) {
      return error && error.name;
    }
  };
  startTime.set.call(cue, 1.5);
  return JSON.stringify({
    ownNames: Object.getOwnPropertyNames(cue).filter(name => expectedNames.includes(name)),
    ownKeys: Object.keys(cue).filter(name => expectedNames.includes(name)),
    internalNames: Object.getOwnPropertyNames(cue)
      .filter(name => name.startsWith('__moli')).sort(),
    textTrackCueNames: Object.getOwnPropertyNames(TextTrackCue.prototype)
      .filter(name => expectedNames.includes(name)),
    vttCueNames: Object.getOwnPropertyNames(VTTCue.prototype)
      .filter(name => expectedNames.includes(name)),
    chains: [
      Object.getPrototypeOf(VTTCue.prototype) === TextTrackCue.prototype,
      Object.getPrototypeOf(TextTrackCue.prototype) === EventTarget.prototype,
      cue instanceof EventTarget
    ],
    startTime: descriptor(TextTrackCue.prototype, 'startTime'),
    text: descriptor(VTTCue.prototype, 'text'),
    getCueAsHTML: descriptor(VTTCue.prototype, 'getCueAsHTML'),
    pauseOnExit: descriptor(TextTrackCue.prototype, 'pauseOnExit'),
    onenter: descriptor(TextTrackCue.prototype, 'onenter'),
    track: descriptor(TextTrackCue.prototype, 'track'),
    borrowedStartTime: startTime.get.call(cue),
    forged: [
      probe(() => startTime.get.call({})),
      probe(() => text.set.call({}, 'forged')),
      probe(() => getCueAsHTML.call({}))
    ],
    defaults: [
      cue.startTime,
      cue.endTime,
      cue.text,
      cue.id,
      cue.vertical,
      cue.snapToLines,
      cue.line,
      cue.position,
      cue.size,
      cue.align,
      cue.pauseOnExit,
      cue.onexit === null,
      cue.track === null,
      cue.getCueAsHTML().textContent
    ],
    onenterAssigned,
    onenterUndefined
  });
})()
"#,
        )
        .expect("VTTCue declared surface probe should evaluate");

    assert_eq!(
        result,
        r#"{"ownNames":[],"ownKeys":[],"internalNames":[],"textTrackCueNames":["track","id","startTime","endTime","pauseOnExit","onenter","onexit"],"vttCueNames":["vertical","snapToLines","line","position","size","align","getCueAsHTML","text"],"chains":[true,true,true],"startTime":{"enumerable":true,"configurable":true,"hasGetter":true,"hasSetter":true},"text":{"enumerable":true,"configurable":true,"hasGetter":true,"hasSetter":true},"getCueAsHTML":{"enumerable":true,"writable":true,"configurable":true,"name":"getCueAsHTML","length":0},"pauseOnExit":{"enumerable":true,"configurable":true,"hasGetter":true,"hasSetter":true},"onenter":{"enumerable":true,"configurable":true,"hasGetter":true,"hasSetter":true},"track":{"enumerable":true,"configurable":true,"hasGetter":true,"hasSetter":false},"borrowedStartTime":1.5,"forged":["TypeError","TypeError","TypeError"],"defaults":[1.5,2,"hello","","",true,"auto","auto",100,"center",false,true,true,"hello"],"onenterAssigned":true,"onenterUndefined":true}"#
    );
}

#[test]
fn script_type_and_language_classification_matches_wpt_matrix() {
    let mut vm = new_storage_test_vm("https://script-type-language.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const failures = [];
  if (!document.documentElement) {
    document.appendChild(document.createElement('html'));
  }
  const placeholder = document.createElement('div');
  document.documentElement.appendChild(placeholder);
  window.ran = false;
  const probe = (attr, value, expected) => {
    window.ran = false;
    const script = document.createElement('script');
    script.setAttribute(attr, value);
    script.textContent = 'window.ran = true;';
    placeholder.appendChild(script);
    if (window.ran !== expected) {
      failures.push(`${attr}=${JSON.stringify(value)}:${window.ran}->${expected}`);
    }
  };
  const typeShouldRun = value => probe('type', value, true);
  const typeShouldNotRun = value => probe('type', value, false);
  const languageShouldRun = value => probe('language', value, true);
  const languageShouldNotRun = value => probe('language', value, false);

  const application = ['ecmascript', 'javascript', 'x-ecmascript', 'x-javascript'];
  const text = [
    'ecmascript', 'javascript', 'javascript1.0', 'javascript1.1',
    'javascript1.2', 'javascript1.3', 'javascript1.4', 'javascript1.5',
    'jscript', 'livescript', 'x-ecmascript', 'x-javascript'
  ];
  const legacyTypes = ['javascript1.6', 'javascript1.7', 'javascript1.8', 'javascript1.9'];
  const spaces = [' ', '\t', '\n', '\r', '\f'];

  typeShouldRun('');
  typeShouldNotRun(' ');
  application.map(t => 'application/' + t).forEach(typeShouldRun);
  application.map(t => ('application/' + t).toUpperCase()).forEach(typeShouldRun);
  spaces.forEach(s => {
    application.map(t => 'application/' + t + s).forEach(typeShouldRun);
    application.map(t => s + 'application/' + t).forEach(typeShouldRun);
  });
  application.map(t => 'application/' + t + '\0').forEach(typeShouldNotRun);
  application.map(t => 'application/' + t + '\0foo').forEach(typeShouldNotRun);
  text.map(t => 'text/' + t).forEach(typeShouldRun);
  text.map(t => ('text/' + t).toUpperCase()).forEach(typeShouldRun);
  legacyTypes.map(t => 'text/' + t).forEach(typeShouldNotRun);
  spaces.forEach(s => {
    text.map(t => 'text/' + t + s).forEach(typeShouldRun);
    text.map(t => s + 'text/' + t).forEach(typeShouldRun);
  });
  text.map(t => 'text/' + t + '\0').forEach(typeShouldNotRun);
  text.map(t => 'text/' + t + '\0foo').forEach(typeShouldNotRun);
  text.forEach(typeShouldNotRun);
  legacyTypes.forEach(typeShouldNotRun);

  languageShouldRun('');
  languageShouldNotRun(' ');
  text.forEach(languageShouldRun);
  text.map(t => t.toUpperCase()).forEach(languageShouldRun);
  legacyTypes.forEach(languageShouldNotRun);
  spaces.forEach(s => {
    text.map(t => t + s).forEach(languageShouldNotRun);
    text.map(t => s + t).forEach(languageShouldNotRun);
  });
  text.map(t => t + 'xyz').forEach(languageShouldNotRun);
  text.map(t => 'xyz' + t).forEach(languageShouldNotRun);
  text.map(t => t + '\0').forEach(languageShouldNotRun);
  text.map(t => t + '\0foo').forEach(languageShouldNotRun);

  return failures.join('\n');
})()
"#,
        )
        .expect("script type/language probe should evaluate");

    assert_eq!(result, "");
}
#[test]
fn vtt_cue_accessors_follow_webidl_and_resort_track_cues() {
    let mut vm = new_storage_test_vm("https://vtt-cue-accessors.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const probe = callback => {
    try {
      callback();
      return 'ok';
    } catch (error) {
      return `throw:${error && error.name}`;
    }
  };
  const video = document.createElement('video');
  const track = video.addTextTrack('subtitles');
  const cue = new VTTCue(1, 2, 'one');
  const later = new VTTCue(3, 4, 'two');
  const emptyIdCue = new VTTCue(5, 6, 'empty');
  cue.id = null;
  cue.pauseOnExit = 'yes';
  const idAndPause = `${cue.id}:${cue.pauseOnExit}`;
  cue.pauseOnExit = null;
  const pauseAfterNull = cue.pauseOnExit;
  const startNaN = probe(() => { cue.startTime = NaN; });
  const endPositiveInfinity = probe(() => { cue.endTime = Infinity; });
  const endNegativeInfinity = probe(() => { cue.endTime = -Infinity; });
  cue.position = 25;
  const positionNumber = cue.position;
  cue.position = 'auto';
  const positionAuto = cue.position;
  let entered = false;
  cue.onenter = () => { entered = true; };
  cue.dispatchEvent(new Event('enter'));
  cue.onenter = undefined;
  const onenterUndefined = cue.onenter === null;
  let listenerEntered = false;
  const listener = () => { listenerEntered = true; };
  cue.addEventListener('enter', listener, false);
  cue.dispatchEvent(new Event('enter'));
  cue.removeEventListener('enter', listener, false);
  listenerEntered = false;
  cue.dispatchEvent(new Event('enter'));
  const listenerRemoved = !listenerEntered;
  track.addCue(cue);
  track.addCue(later);
  track.addCue(emptyIdCue);
  later.startTime = 0.5;
  const order = track.cues[0] === later && track.cues[1] === cue;
  const emptyIdLookup = track.cues.getCueById('') === null;
  return [
    idAndPause,
    pauseAfterNull,
    startNaN,
    endPositiveInfinity,
    cue.endTime,
    endNegativeInfinity,
    positionNumber,
    positionAuto,
    entered,
    onenterUndefined,
    listenerRemoved,
    order,
    emptyIdLookup
  ].join('|');
})()
"#,
        )
        .expect("VTTCue accessors should evaluate");

    assert_eq!(
        result,
        "null:true|false|throw:TypeError|throw:TypeError|2|throw:TypeError|25|auto|true|true|true|true|true"
    );
}
#[test]
fn text_track_id_and_cue_order_follow_wpt_edges() {
    let mut vm = new_storage_test_vm("https://text-track-order.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const video = document.createElement('video');
  const trackElement = document.createElement('track');
  trackElement.id = 'LoremIpsum';
  video.appendChild(trackElement);
  const elementTrack = trackElement.track;
  elementTrack.id = 'newvalue';
  const idReadonly = `${elementTrack.id}:${video.textTracks.getTrackById('LoremIpsum') === elementTrack}`;

  const concat = cues => Array.prototype.reduce.call(cues, (acc, cue) => acc + cue.text, '');
  const track = video.addTextTrack('subtitles');
  track.addCue(new VTTCue(2, 5, '1'));
  track.addCue(new VTTCue(2, 5, '2'));
  track.addCue(new VTTCue(2, 5, '3'));
  const initial = concat(track.cues);
  track.cues[0].startTime = 4;
  const movedLast = concat(track.cues);
  track.cues[2].startTime = 2;
  const restoredInsertionOrder = concat(track.cues);
  track.cues[2].endTime = 9;
  const endMovedFirst = concat(track.cues);
  return [idReadonly, initial, movedLast, restoredInsertionOrder, endMovedFirst].join('|');
})()
"#,
        )
        .expect("TextTrack id and cue order probe should evaluate");

    assert_eq!(result, "LoremIpsum:true|123|231|123|312");
}
#[test]
fn media_source_constructor_preserves_prototype_chain_and_static_surface() {
    let mut vm = new_storage_test_vm("https://example.com/");

    let result = vm
        .eval(
            r#"
            (() => {
              const descriptor = Object.getOwnPropertyDescriptor(MediaSource, "isTypeSupported");
              return JSON.stringify({
              ctorType: typeof MediaSource,
              staticType: typeof MediaSource.isTypeSupported,
              staticName: MediaSource.isTypeSupported.name,
              staticLength: MediaSource.isTypeSupported.length,
              staticDescriptor: [
                !!descriptor,
                descriptor && descriptor.enumerable,
                descriptor && descriptor.writable,
                descriptor && descriptor.configurable
              ],
              keysContainStatic: Object.keys(MediaSource).includes("isTypeSupported"),
              instanceOf: (() => {
                const mediaSource = new MediaSource();
                return mediaSource instanceof MediaSource;
              })(),
              prototypeMatches: (() => {
                const mediaSource = new MediaSource();
                return Object.getPrototypeOf(mediaSource) === MediaSource.prototype;
              })(),
              constructorName: (() => {
                const mediaSource = new MediaSource();
                return mediaSource.constructor && mediaSource.constructor.name;
              })(),
              ownKeys: (() => Object.keys(new MediaSource()))()
            });
            })()
            "#,
        )
        .expect("MediaSource constructor probe should evaluate");

    assert_eq!(
        result,
        r#"{"ctorType":"function","staticType":"function","staticName":"isTypeSupported","staticLength":1,"staticDescriptor":[true,true,true,true],"keysContainStatic":true,"instanceOf":true,"prototypeMatches":true,"constructorName":"MediaSource","ownKeys":[]}"#
    );
}
#[test]
fn media_source_is_type_supported_applies_webidl_conversion() {
    let mut vm = new_storage_test_vm("https://media-source-webidl.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const probe = (callback) => {
    try {
      return String(callback());
    } catch (error) {
      return `throw:${error && error.name}`;
    }
  };
  const values = [];
  values.push(probe(() => MediaSource.isTypeSupported()));
  values.push(probe(() => MediaSource.isTypeSupported(Symbol('type'))));
  values.push(probe(() => MediaSource.isTypeSupported({ toString() { throw new RangeError('boom'); } })));
  values.push(probe(() => MediaSource.isTypeSupported(null)));

  let calls = 0;
  values.push(probe(() => MediaSource.isTypeSupported({
    toString() {
      calls += 1;
      return 'video/mp4; codecs="avc1.42E01E"';
    },
  })));
  values.push(String(calls));
  return values.join('|');
})()
"#,
        )
        .expect("MediaSource.isTypeSupported WebIDL conversion probe should evaluate");

    assert_eq!(
        result,
        "throw:TypeError|throw:TypeError|throw:RangeError|false|true|1"
    );
}
#[test]
fn zhihu_probe_media_devices_surface_exposes_promise_methods() {
    let mut vm = new_storage_test_vm("https://example.com/");

    vm.exec(
        r#"
            (() => {
              globalThis.__mediaDevicesProbe = "pending";
              const devices = navigator.mediaDevices;
              const proto = Object.getPrototypeOf(devices);
              const fakeDevices = Object.create(MediaDevices.prototype);
              const summarizeMethodDescriptor = name => {
                const descriptor = Object.getOwnPropertyDescriptor(proto, name);
                return [
                  !!descriptor,
                  typeof descriptor?.value,
                  descriptor?.value?.name,
                  descriptor?.value?.length,
                  descriptor?.enumerable,
                  descriptor?.writable,
                  descriptor?.configurable
                ].join(":");
              };
              const methodOutcome = async (method, receiver, ...args) => {
                let value;
                try {
                  value = devices[method].call(receiver, ...args);
                } catch (error) {
                  return `throw:${error && error.name}`;
                }
                const isPromise = value instanceof Promise;
                try {
                  await value;
                  return `resolved:${isPromise}`;
                } catch (error) {
                  return `rejected:${isPromise}:${error && error.name}`;
                }
              };
              const enumeratePromise = devices.enumerateDevices();
              const userMediaPromise = devices.getUserMedia({ audio: true }).catch(() => null);
              return Promise.all([
                methodOutcome("enumerateDevices", fakeDevices),
                methodOutcome("getUserMedia", fakeDevices, { audio: true })
              ]).then((fakeOutcomes) => {
                globalThis.__mediaDevicesProbe = JSON.stringify({
                  ctorType: typeof MediaDevices,
                  ctorName: devices.constructor && devices.constructor.name,
                  tag: Object.prototype.toString.call(devices),
                  protoCtor: proto && proto.constructor && proto.constructor.name,
                  enumerateDevicesType: typeof devices.enumerateDevices,
                  enumerateDevicesName: devices.enumerateDevices && devices.enumerateDevices.name,
                  enumerateDevicesLength: devices.enumerateDevices && devices.enumerateDevices.length,
                  enumerateDevicesDescriptor: summarizeMethodDescriptor("enumerateDevices"),
                  enumerateDevicesPromiseTag: Object.prototype.toString.call(enumeratePromise),
                  enumerateDevicesThenType: typeof enumeratePromise.then,
                  getUserMediaType: typeof devices.getUserMedia,
                  getUserMediaName: devices.getUserMedia && devices.getUserMedia.name,
                  getUserMediaLength: devices.getUserMedia && devices.getUserMedia.length,
                  getUserMediaDescriptor: summarizeMethodDescriptor("getUserMedia"),
                  getUserMediaPromiseTag: Object.prototype.toString.call(userMediaPromise),
                  getUserMediaThenType: typeof userMediaPromise.then,
                  fakeOutcomes: fakeOutcomes.join("|")
                });
              });
            })()
            "#,
        None,
    )
    .expect("mediaDevices probe should schedule");

    let result = vm
        .eval("String(globalThis.__mediaDevicesProbe)")
        .expect("mediaDevices probe should evaluate");

    assert_eq!(
        result,
        r#"{"ctorType":"function","ctorName":"MediaDevices","tag":"[object MediaDevices]","protoCtor":"MediaDevices","enumerateDevicesType":"function","enumerateDevicesName":"enumerateDevices","enumerateDevicesLength":0,"enumerateDevicesDescriptor":"true:function:enumerateDevices:0:true:true:true","enumerateDevicesPromiseTag":"[object Promise]","enumerateDevicesThenType":"function","getUserMediaType":"function","getUserMediaName":"getUserMedia","getUserMediaLength":1,"getUserMediaDescriptor":"true:function:getUserMedia:1:true:true:true","getUserMediaPromiseTag":"[object Promise]","getUserMediaThenType":"function","fakeOutcomes":"rejected:true:TypeError|rejected:true:TypeError"}"#
    );
}
#[test]
fn zhihu_probe_offline_audio_context_supports_fingerprintjs2_audio_flow() {
    let mut vm = new_storage_test_vm("https://example.com/");

    vm.exec(
        r#"
        (() => {
          const Ctor = window.OfflineAudioContext || window.webkitOfflineAudioContext;
          if (!Ctor) {
            globalThis.__audioProbe = { available: false };
            return;
          }
          const ctx = new Ctor(1, 44100, 44100);
          const osc = ctx.createOscillator();
          osc.type = "triangle";
          osc.frequency.setValueAtTime(10000, ctx.currentTime);
          const comp = ctx.createDynamicsCompressor();
          for (const [name, value] of [["threshold", -50], ["knee", 40], ["ratio", 12], ["reduction", -20], ["attack", 0], ["release", 0.25]]) {
            if (comp[name] !== undefined && typeof comp[name].setValueAtTime === "function") {
              comp[name].setValueAtTime(value, ctx.currentTime);
            }
          }
          osc.connect(comp);
          comp.connect(ctx.destination);
          osc.start(0);
          globalThis.__audioProbe = {
            available: true,
            offlineType: typeof window.OfflineAudioContext,
            webkitType: typeof window.webkitOfflineAudioContext,
            sharedCtor: window.OfflineAudioContext === window.webkitOfflineAudioContext,
            done: false,
            sum: null,
            promiseTag: null,
            ctxCtor: ctx.constructor && ctx.constructor.name,
            oscCtor: osc.constructor && osc.constructor.name,
            compCtor: comp.constructor && comp.constructor.name,
            destinationCtor: ctx.destination && ctx.destination.constructor && ctx.destination.constructor.name,
            reductionType: typeof comp.reduction,
            frequencyValue: osc.frequency && osc.frequency.value,
            thresholdValue: comp.threshold && comp.threshold.value,
            length: ctx.length,
            sampleRate: ctx.sampleRate,
            stateBefore: ctx.state,
          };
          ctx.oncomplete = (event) => {
            const data = event.renderedBuffer.getChannelData(0);
            globalThis.__audioProbe.done = true;
            globalThis.__audioProbe.sum = data.slice(4500, 5000).reduce((acc, value) => acc + Math.abs(value), 0);
            globalThis.__audioProbe.bufferCtor = event.renderedBuffer.constructor && event.renderedBuffer.constructor.name;
            globalThis.__audioProbe.stateAfter = ctx.state;
          };
          const rendering = ctx.startRendering();
          globalThis.__audioProbe.promiseTag = Object.prototype.toString.call(rendering);
        })()
        "#,
        None,
    )
    .expect("offline audio probe should execute");

    let result = vm
        .eval("JSON.stringify(globalThis.__audioProbe)")
        .expect("offline audio probe should be readable");

    let value: serde_json::Value =
        serde_json::from_str(&result).expect("offline audio probe should return valid json");
    assert_eq!(value["available"], true);
    assert_eq!(value["offlineType"], "function");
    assert_eq!(value["webkitType"], "undefined");
    assert_eq!(value["sharedCtor"], false);
    assert_eq!(value["done"], true);
    assert_eq!(value["promiseTag"], "[object Promise]");
    assert_eq!(value["ctxCtor"], "OfflineAudioContext");
    assert_eq!(value["oscCtor"], "OscillatorNode");
    assert_eq!(value["compCtor"], "DynamicsCompressorNode");
    assert_eq!(value["destinationCtor"], "AudioDestinationNode");
    assert_eq!(value["bufferCtor"], "AudioBuffer");
    assert_eq!(value["reductionType"], "number");
    assert_eq!(value["length"], 44100);
    assert_eq!(value["sampleRate"], 44100.0);
    assert_eq!(value["stateBefore"], "suspended");
    assert_eq!(value["stateAfter"], "closed");
    let sum = value["sum"]
        .as_f64()
        .expect("offline audio sum should be numeric");
    assert!(
        (sum - 124.04347527516074).abs() < 0.001,
        "unexpected offline audio fingerprint sum: {sum}"
    );
}

#[test]
fn offline_audio_context_without_connected_sources_renders_silence() {
    let mut vm = new_storage_test_vm("https://short-audio-fingerprint.test/");

    vm.exec(
        r#"
        globalThis.__shortAudioProbe = { done: false };
        const ctx = new OfflineAudioContext(1, 500, 44100);
        ctx.oncomplete = event => {
          const data = event.renderedBuffer.getChannelData(0);
          const nonzero = Array.from(data).filter(value => value !== 0);
          globalThis.__shortAudioProbe = {
            done: true,
            length: data.length,
            nonzero: nonzero.length,
            sum: nonzero.reduce((acc, value) => acc + Math.abs(value), 0)
          };
        };
        ctx.startRendering();
        "#,
        None,
    )
    .expect("short offline audio probe should execute");

    let result = vm
        .eval("JSON.stringify(globalThis.__shortAudioProbe)")
        .expect("short offline audio probe should be readable");
    let value: serde_json::Value =
        serde_json::from_str(&result).expect("short offline audio probe should return valid json");
    assert_eq!(value["done"], true);
    assert_eq!(value["length"], 500);
    assert_eq!(value["nonzero"], 0, "an empty graph must render silence");
    assert_eq!(value["sum"], 0);
}

#[test]
fn offline_audio_context_updates_compressor_reduction_on_complete() {
    let mut vm = new_storage_test_vm("https://compressor-reduction.test/");

    vm.exec(
        r#"
        const ctx = new OfflineAudioContext(1, 500, 44100);
        const osc = ctx.createOscillator();
        const comp = ctx.createDynamicsCompressor();
        osc.connect(comp);
        comp.connect(ctx.destination);
        osc.start(0);
        globalThis.__compressorReductionProbe = {
          before: comp.reduction,
          afterStart: null,
          oncomplete: null,
          afterPromise: null
        };
        ctx.oncomplete = () => {
          globalThis.__compressorReductionProbe.oncomplete = comp.reduction;
        };
        const rendering = ctx.startRendering();
        globalThis.__compressorReductionProbe.afterStart = comp.reduction;
        rendering.then(() => {
          globalThis.__compressorReductionProbe.afterPromise = comp.reduction;
        });
        "#,
        None,
    )
    .expect("compressor reduction timing probe should execute");

    let result = vm
        .eval("JSON.stringify(globalThis.__compressorReductionProbe)")
        .expect("compressor reduction timing probe should be readable");
    let value: serde_json::Value =
        serde_json::from_str(&result).expect("compressor reduction probe should return valid json");
    assert_eq!(value["before"], 0);
    assert_eq!(value["afterStart"], 0);
    assert!(
        value["oncomplete"].as_f64().unwrap_or_default() < 0.0,
        "compressor reduction should update before oncomplete: {result}"
    );
    assert!(
        value["afterPromise"].as_f64().unwrap_or_default() < 0.0,
        "compressor reduction should stay updated after rendering promise settles: {result}"
    );
}

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

    vm.exec(
        r#"
        globalThis.__audioPhases = [];
        const Ctor = window.OfflineAudioContext || window.webkitOfflineAudioContext;
        const ctx = new Ctor(1, 44100, 44100);
        const osc = ctx.createOscillator();
        const comp = ctx.createDynamicsCompressor();
        osc.connect(comp);
        comp.connect(ctx.destination);
        ctx.startRendering();
        globalThis.__audioPhases.push("after-start");
        ctx.oncomplete = () => globalThis.__audioPhases.push("complete");
        globalThis.__audioPhases.push("after-handler");
        "#,
        None,
    )
    .expect("offline audio async ordering probe should execute");

    let result = vm
        .eval("JSON.stringify(globalThis.__audioPhases)")
        .expect("offline audio phases should be readable");
    assert_eq!(result, r#"["after-start","after-handler","complete"]"#);
}

#[test]
fn web_audio_declared_objects_keep_brands_and_hidden_properties() {
    let mut vm = new_storage_test_vm("https://audio-declared-objects.test/");

    vm.exec(
        r#"
(() => {
  const ctx = new OfflineAudioContext(1, 32, 8000);
  const osc = ctx.createOscillator();
  const comp = ctx.createDynamicsCompressor();
  globalThis.__webAudioDeclaredProbe = { completion: null };
  ctx.oncomplete = event => {
    globalThis.__webAudioDeclaredProbe.completion = {
      tag: Object.prototype.toString.call(event),
      ctor: event.constructor && event.constructor.name,
      type: event.type,
      renderedBufferTag: Object.prototype.toString.call(event.renderedBuffer),
      renderedBufferCtor: event.renderedBuffer.constructor && event.renderedBuffer.constructor.name,
      renderedBufferLength: event.renderedBuffer.length,
      renderedBufferSampleRate: event.renderedBuffer.sampleRate,
      renderedBufferDuration: event.renderedBuffer.duration,
      renderedBufferEnumerable: Object.prototype.propertyIsEnumerable.call(event, "renderedBuffer"),
      targetIsContext: event.target === ctx,
      currentTargetIsContext: event.currentTarget === ctx
    };
  };
  const rendering = ctx.startRendering();
  osc.frequency.setValueAtTime(123, 0);
  Object.assign(globalThis.__webAudioDeclaredProbe, {
    ctxTag: Object.prototype.toString.call(ctx),
    ctxCtor: ctx.constructor && ctx.constructor.name,
    ctxLength: ctx.length,
    ctxSampleRate: ctx.sampleRate,
    ctxState: ctx.state,
    lengthEnumerable: Object.prototype.propertyIsEnumerable.call(ctx, "length"),
    destinationTag: Object.prototype.toString.call(ctx.destination),
    destinationCtor: ctx.destination.constructor && ctx.destination.constructor.name,
    destinationKeys: Object.keys(ctx.destination).join(","),
    oscTag: Object.prototype.toString.call(osc),
    oscCtor: osc.constructor && osc.constructor.name,
    oscKeys: Object.keys(osc).join(","),
    oscType: osc.type,
    frequencyTag: Object.prototype.toString.call(osc.frequency),
    frequencyCtor: osc.frequency.constructor && osc.frequency.constructor.name,
    frequencyValue: osc.frequency.value,
    frequencyEnumerable: Object.prototype.propertyIsEnumerable.call(osc, "frequency"),
    setValueAtTimeType: typeof osc.frequency.setValueAtTime,
    compTag: Object.prototype.toString.call(comp),
    compCtor: comp.constructor && comp.constructor.name,
    compKeys: Object.keys(comp).join(","),
    thresholdTag: Object.prototype.toString.call(comp.threshold),
    reduction: comp.reduction,
    reductionOwn: Object.prototype.hasOwnProperty.call(comp, "reduction"),
    promiseTag: Object.prototype.toString.call(rendering)
  });
})()
"#,
        None,
    )
    .expect("web audio declared object probe should execute");

    let result = vm
        .eval("JSON.stringify(globalThis.__webAudioDeclaredProbe)")
        .expect("web audio declared object probe should evaluate");

    assert_eq!(
        result,
        r#"{"completion":{"tag":"[object OfflineAudioCompletionEvent]","ctor":"OfflineAudioCompletionEvent","type":"complete","renderedBufferTag":"[object AudioBuffer]","renderedBufferCtor":"AudioBuffer","renderedBufferLength":32,"renderedBufferSampleRate":8000,"renderedBufferDuration":0.004,"renderedBufferEnumerable":false,"targetIsContext":true,"currentTargetIsContext":true},"ctxTag":"[object OfflineAudioContext]","ctxCtor":"OfflineAudioContext","ctxLength":32,"ctxSampleRate":8000,"ctxState":"closed","lengthEnumerable":false,"destinationTag":"[object AudioDestinationNode]","destinationCtor":"AudioDestinationNode","destinationKeys":"","oscTag":"[object OscillatorNode]","oscCtor":"OscillatorNode","oscKeys":"","oscType":"sine","frequencyTag":"[object AudioParam]","frequencyCtor":"AudioParam","frequencyValue":123,"frequencyEnumerable":false,"setValueAtTimeType":"function","compTag":"[object DynamicsCompressorNode]","compCtor":"DynamicsCompressorNode","compKeys":"","thresholdTag":"[object AudioParam]","reduction":0,"reductionOwn":false,"promiseTag":"[object Promise]"}"#
    );
}

#[test]
fn web_audio_methods_preserve_own_and_shared_prototype_descriptors() {
    let mut vm = new_storage_test_vm("https://audio-declared-own-methods.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const ctx = new OfflineAudioContext(1, 32, 8000);
  const osc = ctx.createOscillator();
  const comp = ctx.createDynamicsCompressor();
  const analyser = ctx.createAnalyser();
  const describe = (object, name) => {
    const descriptor = Object.getOwnPropertyDescriptor(object, name);
    if (!descriptor) {
      return `${name}:missing`;
    }
    return [
      name,
      descriptor.enumerable,
      descriptor.writable,
      descriptor.configurable,
      typeof descriptor.value,
      descriptor.value.name,
      descriptor.value.length
    ].join(":");
  };

  return JSON.stringify({
    ctxKeys: Object.keys(ctx).join(","),
    inheritedEvents: ["addEventListener", "removeEventListener", "dispatchEvent"].every(name => !Object.hasOwn(ctx, name) && ctx[name] === EventTarget.prototype[name]),
    oscKeys: Object.keys(osc).join(","),
    compKeys: Object.keys(comp).join(","),
    analyserKeys: Object.keys(analyser).join(","),
    paramKeys: Object.keys(osc.frequency).join(","),
    ctx: ["addEventListener", "removeEventListener", "dispatchEvent"].map(name => describe(EventTarget.prototype, name)),
    graph: ["connect", "disconnect"].map(name => describe(AudioNode.prototype, name)),
    shared: [ctx.destination, osc, comp, analyser].every(node =>
      ["connect", "disconnect"].every(name =>
        !Object.hasOwn(node, name) && node[name] === AudioNode.prototype[name])),
    oscStart: describe(osc, "start"),
    param: describe(osc.frequency, "setValueAtTime")
  });
})()
"#,
        )
        .expect("web audio declared own method descriptors should evaluate");

    assert_eq!(
        result,
        r#"{"ctxKeys":"","inheritedEvents":true,"oscKeys":"","compKeys":"","analyserKeys":"","paramKeys":"","ctx":["addEventListener:true:true:true:function:addEventListener:2","removeEventListener:true:true:true:function:removeEventListener:2","dispatchEvent:true:true:true:function:dispatchEvent:1"],"graph":["connect:true:true:true:function:connect:1","disconnect:true:true:true:function:disconnect:0"],"shared":true,"oscStart":"start:false:true:true:function:start:1","param":"setValueAtTime:false:true:true:function:setValueAtTime:2"}"#
    );
}

#[test]
fn web_audio_private_backing_slots_ignore_public_spoofing() {
    let mut vm = new_storage_test_vm("https://audio-private-backing-slots.test/");

    vm.exec(
        r#"
(() => {
  const internalNames = object => Object.getOwnPropertyNames(object)
    .filter(name => name.startsWith("__moliOfflineAudio") || name === "__moliDynamicsCompressorReduction")
    .sort()
    .join(",");
  const ctx = new OfflineAudioContext(1, 32, 8000);
  const comp = ctx.createDynamicsCompressor();
  const ctxOwnInternalBefore = internalNames(ctx);
  const compOwnInternalBefore = internalNames(comp);
  ctx.__moliOfflineAudioLength = 999;
  ctx.__moliOfflineAudioSampleRate = 123;
  ctx.__moliOfflineAudioChannelCount = 7;
  ctx.__moliOfflineAudioCompressors = [];
  Object.prototype.__moliOfflineAudioCompleteContext = { spoof: "prototype-context" };
  Object.prototype.__moliOfflineAudioCompleteBuffer = { spoof: "prototype-buffer" };
  ctx.__moliOfflineAudioCompleteContext = { spoof: "context" };
  ctx.__moliOfflineAudioCompleteBuffer = { spoof: "buffer" };
  comp.__moliDynamicsCompressorReduction = 99;
  globalThis.__webAudioPrivateProbe = {
    ctxOwnInternalBefore,
    compOwnInternalBefore,
    ctxOwnInternalAfterSpoof: internalNames(ctx),
    reductionBefore: comp.reduction,
    complete: null
  };
  ctx.oncomplete = event => {
    const buffer = event.renderedBuffer;
    const bufferOwnInternalBefore = internalNames(buffer);
    buffer.__moliOfflineAudioBuffer = { length: 1, 0: 999 };
    const data = buffer.getChannelData(0);
    globalThis.__webAudioPrivateProbe.complete = {
      bufferOwnInternalBefore,
      bufferOwnInternalAfterSpoof: internalNames(buffer),
      targetStable: event.target === ctx,
      currentTargetStable: event.currentTarget === ctx,
      renderedBufferStable: buffer instanceof AudioBuffer,
      bufferLength: buffer.length,
      bufferSampleRate: buffer.sampleRate,
      dataTag: Object.prototype.toString.call(data),
      dataLength: data.length,
      reductionAfter: comp.reduction
    };
  };
  ctx.startRendering();
})()
"#,
        None,
    )
    .expect("web audio private backing slot probe should execute");

    let result = vm
        .eval("JSON.stringify(globalThis.__webAudioPrivateProbe)")
        .expect("web audio private backing slot probe should evaluate");

    assert_eq!(
        result,
        r#"{"ctxOwnInternalBefore":"","compOwnInternalBefore":"","ctxOwnInternalAfterSpoof":"__moliOfflineAudioChannelCount,__moliOfflineAudioCompleteBuffer,__moliOfflineAudioCompleteContext,__moliOfflineAudioCompressors,__moliOfflineAudioLength,__moliOfflineAudioSampleRate","reductionBefore":0,"complete":{"bufferOwnInternalBefore":"","bufferOwnInternalAfterSpoof":"__moliOfflineAudioBuffer","targetStable":true,"currentTargetStable":true,"renderedBufferStable":true,"bufferLength":32,"bufferSampleRate":8000,"dataTag":"[object Float32Array]","dataLength":32,"reductionAfter":0}}"#
    );
}

#[test]
fn offline_audio_context_analyser_supports_probe_data_methods() {
    let mut vm = new_storage_test_vm("https://audio-analyser-probe.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const ctx = new OfflineAudioContext(1, 64, 44100);
  const osc = ctx.createOscillator();
  const analyser = ctx.createAnalyser();
  osc.connect(analyser);
  analyser.connect(ctx.destination);

  const floats = new Float32Array(4);
  const time = new Float32Array(4);
  const bytes = new Uint8Array(4);
  const byteTime = new Uint8Array(4);
  analyser.getFloatFrequencyData(floats);
  analyser.getFloatTimeDomainData(time);
  analyser.getByteFrequencyData(bytes);
  analyser.getByteTimeDomainData(byteTime);

  return JSON.stringify({
    ctorType: typeof AnalyserNode,
    tag: Object.prototype.toString.call(analyser),
    ctor: analyser.constructor && analyser.constructor.name,
    fftSize: analyser.fftSize,
    frequencyBinCount: analyser.frequencyBinCount,
    minDecibels: analyser.minDecibels,
    maxDecibels: analyser.maxDecibels,
    smoothingTimeConstant: analyser.smoothingTimeConstant,
    connectResultCtor: analyser.connect(ctx.destination).constructor.name,
    methods: [
      typeof ctx.createAnalyser,
      typeof analyser.getFloatFrequencyData,
      typeof analyser.getByteFrequencyData,
      typeof analyser.getFloatTimeDomainData,
      typeof analyser.getByteTimeDomainData
    ],
    floats: Array.from(floats, String),
    time: Array.from(time),
    bytes: Array.from(bytes),
    byteTime: Array.from(byteTime)
  });
})()
"#,
        )
        .expect("offline audio analyser probe should evaluate");

    assert_eq!(
        result,
        r#"{"ctorType":"function","tag":"[object AnalyserNode]","ctor":"AnalyserNode","fftSize":2048,"frequencyBinCount":1024,"minDecibels":-100,"maxDecibels":-30,"smoothingTimeConstant":0.8,"connectResultCtor":"AudioDestinationNode","methods":["function","function","function","function","function"],"floats":["-Infinity","-Infinity","-Infinity","-Infinity"],"time":[0,0,0,0],"bytes":[0,0,0,0],"byteTime":[128,128,128,128]}"#
    );
}

#[test]
fn audio_context_exposes_realtime_worklet_surface() {
    let mut vm = new_storage_test_vm("https://audio-worklet.test/");

    let result = vm
        .eval(
            r#"
        (() => {
          const context = new AudioContext();
          return JSON.stringify({
            contextType: typeof AudioContext,
            webkitSame: webkitAudioContext === AudioContext,
            contextTag: Object.prototype.toString.call(context),
            state: context.state,
            sampleRate: context.sampleRate,
            destinationTag: Object.prototype.toString.call(context.destination),
            workletTag: Object.prototype.toString.call(context.audioWorklet),
            addModuleType: typeof context.audioWorklet.addModule,
            nodeType: typeof AudioWorkletNode
          });
        })()
        "#,
        )
        .expect("audio worklet surface should evaluate");
    assert_eq!(
        result,
        r#"{"contextType":"function","webkitSame":true,"contextTag":"[object AudioContext]","state":"running","sampleRate":44100,"destinationTag":"[object AudioDestinationNode]","workletTag":"[object AudioWorklet]","addModuleType":"function","nodeType":"function"}"#
    );
}

#[test]
fn web_audio_internal_maps_and_errors_ignore_public_primordial_overrides() {
    let mut vm = new_storage_test_vm("https://audio-primordial-overrides.test/");

    vm.exec(
        r#"
(() => {
  const IntrinsicMap = Map;
  const IntrinsicError = Error;
  const IntrinsicTypeError = TypeError;
  globalThis.Map = function() {
    throw new IntrinsicError("WebAudio must not construct the public Map");
  };
  globalThis.Error = function() {
    throw new IntrinsicError("WebAudio must not construct the public Error");
  };
  globalThis.TypeError = function() {
    throw new IntrinsicError("WebAudio must not construct the public TypeError");
  };

  const context = new AudioContext();
  const rejected = context.audioWorklet.addModule.call({}, "data:text/javascript,");
  const closed = context.close();
  globalThis.__webAudioPrimordialProbe = {
    contextTag: Object.prototype.toString.call(context),
    closedTag: Object.prototype.toString.call(closed),
    closedState: context.state,
    rejection: "pending"
  };
  rejected.catch(error => {
    globalThis.__webAudioPrimordialProbe.rejection =
      `${error.name}:${error instanceof IntrinsicTypeError}`;
  });

  globalThis.Map = IntrinsicMap;
  globalThis.Error = IntrinsicError;
  globalThis.TypeError = IntrinsicTypeError;
})()
"#,
        None,
    )
    .expect("WebAudio primordial override probe should execute");

    let result = vm
        .eval("JSON.stringify(globalThis.__webAudioPrimordialProbe)")
        .expect("WebAudio primordial override probe should evaluate");
    assert_eq!(
        result,
        r#"{"contextTag":"[object AudioContext]","closedTag":"[object Promise]","closedState":"closed","rejection":"TypeError:true"}"#
    );
}

#[test]
fn navigator_get_autoplay_policy_accepts_declared_overloads() {
    let mut vm = new_storage_test_vm("https://autoplay-policy.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const errorName = callback => {
    try {
      callback();
      return "none";
    } catch (error) {
      return error.name;
    }
  };
  const audioContext = new AudioContext();
  return [
    typeof navigator.getAutoplayPolicy,
    navigator.getAutoplayPolicy.length,
    navigator.getAutoplayPolicy("mediaelement"),
    navigator.getAutoplayPolicy("audiocontext"),
    navigator.getAutoplayPolicy(document.createElement("audio")),
    navigator.getAutoplayPolicy(document.createElement("video")),
    navigator.getAutoplayPolicy(audioContext),
    errorName(() => navigator.getAutoplayPolicy()),
    errorName(() => navigator.getAutoplayPolicy("invalid")),
    errorName(() => navigator.getAutoplayPolicy({})),
    errorName(() => navigator.getAutoplayPolicy(Object.create(AudioContext.prototype))),
    errorName(() => navigator.getAutoplayPolicy.call({}, "mediaelement"))
  ].join("|");
})()
"#,
        )
        .expect("navigator autoplay policy probe should evaluate");

    assert_eq!(
        result,
        "function|1|allowed|allowed|allowed|allowed|allowed|TypeError|TypeError|TypeError|TypeError|TypeError"
    );
}

#[test]
fn audio_worklet_context_store_ignores_reflection_and_spoofing() {
    let mut vm = new_storage_test_vm("https://audio-worklet-private-context.test/");

    vm.exec(
        r#"
(() => {
  const context = new AudioContext();
  const worklet = context.audioWorklet;
  const internal = "__moliContext";
  const internalNames = object => Object.getOwnPropertyNames(object)
    .filter(name => name === internal)
    .join(",");
  const initialNames = internalNames(worklet);
  Object.getPrototypeOf(worklet)[internal] = { spoof: "prototype" };
  worklet[internal] = { spoof: "own" };
  const fake = Object.create(worklet);
  const fakeResult = worklet.addModule.call(fake, "data:text/javascript,");
  globalThis.__audioWorkletContextProbe = {
    initialNames,
    spoofedNames: internalNames(worklet),
    publicSpoof: worklet[internal] && worklet[internal].spoof,
    fakePromiseTag: Object.prototype.toString.call(fakeResult),
    fakeOutcome: "pending"
  };
  fakeResult.then(
    () => { globalThis.__audioWorkletContextProbe.fakeOutcome = "resolved"; },
    error => { globalThis.__audioWorkletContextProbe.fakeOutcome = error && error.name; }
  );
})()
"#,
        None,
    )
    .expect("audio worklet private context probe should execute");

    let result = vm
        .eval("JSON.stringify(globalThis.__audioWorkletContextProbe)")
        .expect("audio worklet private context probe should evaluate");

    assert_eq!(
        result,
        r#"{"initialNames":"","spoofedNames":"__moliContext","publicSpoof":"own","fakePromiseTag":"[object Promise]","fakeOutcome":"TypeError"}"#
    );
}

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

    vm.exec(
        r#"
        (() => {
          const results = {};
          function record(name, callback) {
            try {
              callback();
              results[name] = "no throw";
            } catch (error) {
              results[name] = error && error.name;
            }
          }

          record("ctorMissing", () => new OfflineAudioContext(1, 16));
          record("ctorSymbol", () => new OfflineAudioContext(Symbol("channels"), 16, 44100));

          const ctx = new OfflineAudioContext("1.9", "16.9", "44100");
          results.length = ctx.length;
          results.sampleRate = ctx.sampleRate;

          const osc = ctx.createOscillator();
          record("setMissingTime", () => osc.frequency.setValueAtTime(1));
          record("setSymbol", () => osc.frequency.setValueAtTime(Symbol("value"), 0));
          osc.frequency.setValueAtTime("123.5", ctx.currentTime);
          results.frequency = osc.frequency.value;

          ctx.oncomplete = (event) => {
            const buffer = event.renderedBuffer;
            record("channelMissing", () => buffer.getChannelData());
            record("channelSymbol", () => buffer.getChannelData(Symbol("channel")));
            record("channelRange", () => buffer.getChannelData(1));
            results.channel0 = Object.prototype.toString.call(buffer.getChannelData("0.9"));
          };
          ctx.startRendering();
          globalThis.__audioWebIdlProbe = results;
        })()
        "#,
        None,
    )
    .expect("audio WebIDL argument probe should execute");

    let result = vm
        .eval("JSON.stringify(globalThis.__audioWebIdlProbe)")
        .expect("audio WebIDL argument probe should be readable");

    assert_eq!(
        result,
        r#"{"ctorMissing":"TypeError","ctorSymbol":"TypeError","length":16,"sampleRate":44100,"setMissingTime":"TypeError","setSymbol":"TypeError","frequency":123.5,"channelMissing":"TypeError","channelSymbol":"TypeError","channelRange":"RangeError","channel0":"[object Float32Array]"}"#
    );
}
#[test]
fn zhihu_probe_match_media_orientation_matches_chromium_headless_profile() {
    let mut vm = new_storage_test_vm("https://example.com/");

    let result = vm
        .eval(
            r#"
            JSON.stringify({
              landscape: matchMedia("(orientation: landscape)").matches,
              portrait: matchMedia("(orientation: portrait)").matches,
              screenLandscape: matchMedia("screen and (orientation: landscape)").matches,
              screenPortrait: matchMedia("screen and (orientation: portrait)").matches,
              mediaLandscape: matchMedia("(orientation: landscape)").media,
              mediaPortrait: matchMedia("(orientation: portrait)").media
            })
            "#,
        )
        .expect("orientation matchMedia probe should evaluate");

    assert_eq!(
        result,
        r#"{"landscape":true,"portrait":false,"screenLandscape":true,"screenPortrait":false,"mediaLandscape":"(orientation: landscape)","mediaPortrait":"(orientation: portrait)"}"#
    );
}
#[test]
fn match_media_uses_desktop_viewport_and_input_capabilities() {
    let mut vm = new_storage_test_vm("https://example.com/");

    let result = vm
        .eval(
            r#"
            JSON.stringify({
              minWidth: matchMedia("(min-width: 768px)").matches,
              exactWidth: matchMedia("(width: 1920px)").matches,
              maxWidth: matchMedia("(max-width: 768px)").matches,
              minHeight: matchMedia("(min-height: 720px)").matches,
              exactHeight: matchMedia("(height: 1080px)").matches,
              minDeviceWidth: matchMedia("(min-device-width: 1px)").matches,
              exactDeviceWidth: matchMedia("(device-width: 1920px)").matches,
              maxDeviceWidth: matchMedia("(max-device-width: 1px)").matches,
              minDeviceHeight: matchMedia("(min-device-height: 1px)").matches,
              exactDeviceHeight: matchMedia("(device-height: 1080px)").matches,
              pointer: matchMedia("(pointer)").matches,
              pointerFine: matchMedia("(pointer: fine)").matches,
              pointerCoarse: matchMedia("(pointer: coarse)").matches,
              hover: matchMedia("(hover)").matches,
              hoverHover: matchMedia("(hover: hover)").matches,
              hoverNone: matchMedia("(hover: none)").matches,
              anyPointerFine: matchMedia("(any-pointer: fine)").matches,
              anyHoverHover: matchMedia("(any-hover: hover)").matches
            })
            "#,
        )
        .expect("desktop matchMedia probe should evaluate");

    assert_eq!(
        result,
        r#"{"minWidth":true,"exactWidth":true,"maxWidth":false,"minHeight":true,"exactHeight":true,"minDeviceWidth":true,"exactDeviceWidth":true,"maxDeviceWidth":false,"minDeviceHeight":true,"exactDeviceHeight":true,"pointer":true,"pointerFine":true,"pointerCoarse":false,"hover":true,"hoverHover":true,"hoverNone":false,"anyPointerFine":true,"anyHoverHover":true}"#
    );
}

fn viewport_surface_800_600_on_1920_1080_screen() -> crate::protocol_types::ViewportSurface {
    crate::protocol_types::ViewportSurface {
        inner_width: 800,
        inner_height: 600,
        outer_width: 800,
        outer_height: 600,
        device_pixel_ratio: 1.0,
        screen_width: 1920,
        screen_height: 1080,
        screen_avail_width: 1920,
        screen_avail_height: 1040,

        ..Default::default()
    }
}

#[test]
fn match_media_uses_renderer_viewport_surface_for_viewport_and_screen_queries() {
    let mut vm = new_storage_test_vm("https://match-media-viewport-surface.test/");
    vm.set_viewport_surface(Some(viewport_surface_800_600_on_1920_1080_screen()))
        .expect("viewport surface should update");

    let result = vm
        .eval(
            r#"
            JSON.stringify({
              width: matchMedia("(width: 800px)").matches,
              notDefaultWidth: matchMedia("(width: 1920px)").matches,
              height: matchMedia("(height: 600px)").matches,
              deviceWidth: matchMedia("(device-width: 1920px)").matches,
              notViewportDeviceWidth: matchMedia("(device-width: 800px)").matches,
              deviceHeight: matchMedia("(device-height: 1080px)").matches,
              combined: matchMedia("(width: 800px) and (device-width: 1920px)").matches,
              wrongCombined: matchMedia("(width: 800px) and (device-width: 800px)").matches
            })
            "#,
        )
        .expect("viewport surface matchMedia probe should evaluate");

    assert_eq!(
        result,
        r#"{"width":true,"notDefaultWidth":false,"height":true,"deviceWidth":true,"notViewportDeviceWidth":false,"deviceHeight":true,"combined":true,"wrongCombined":false}"#
    );
}

#[tokio::test(flavor = "current_thread")]
async fn match_media_viewport_surface_change_dispatches_change_event() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
    let mut vm =
        new_storage_page_task_executor_test_vm("https://match-media-viewport-change.test/");

    let initial = vm
        .eval(
            r#"
(() => {
  const mql = matchMedia("(width: 800px) and (device-width: 1920px)");
  globalThis.__viewportMql = mql;
  globalThis.__viewportMqlEvents = [];
  mql.addEventListener("change", event => {
    globalThis.__viewportMqlEvents.push({
      type: event.type,
      media: event.media,
      matches: event.matches,
      targetIsMql: event.target === mql,
      currentTargetIsMql: event.currentTarget === mql
    });
  });
  return `${mql.matches}|${mql.media}`;
})()
"#,
        )
        .expect("viewport matchMedia change setup should evaluate");

    assert_eq!(initial, "false|(width: 800px) and (device-width: 1920px)");

    vm.set_viewport_surface(Some(viewport_surface_800_600_on_1920_1080_screen()))
        .expect("viewport surface should update");
    assert!(
        vm.run_one_rendering_update_executor_turn(&loader)
            .await
            .unwrap()
    );

    let result = vm
        .eval(
            r#"
JSON.stringify({
  matches: globalThis.__viewportMql.matches,
  events: globalThis.__viewportMqlEvents
})
"#,
        )
        .expect("viewport matchMedia change result should evaluate");

    assert_eq!(
        result,
        r#"{"matches":true,"events":[{"type":"change","media":"(width: 800px) and (device-width: 1920px)","matches":true,"targetIsMql":true,"currentTargetIsMql":true}]}"#
    );
}

#[tokio::test(flavor = "current_thread")]
async fn match_media_change_event_uses_event_prototype_and_declared_properties() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
    let mut vm = new_storage_page_task_executor_test_vm("https://match-media-change-event.test/");

    let initial = vm
        .eval(
            r#"
(() => {
  const mql = matchMedia("(prefers-color-scheme: dark)");
  globalThis.__mqlChangeEvents = [];
  mql.addEventListener("change", event => {
    globalThis.__mqlChangeEvents.push({
      tag: Object.prototype.toString.call(event),
      ctor: event.constructor && event.constructor.name,
      protoCtor: Object.getPrototypeOf(event)?.constructor?.name ?? null,
      keys: Object.keys(event).join(","),
      type: event.type,
      media: event.media,
      matches: event.matches,
      mediaEnumerable: Object.prototype.propertyIsEnumerable.call(event, "media"),
      matchesEnumerable: Object.prototype.propertyIsEnumerable.call(event, "matches"),
      targetIsMql: event.target === mql,
      currentTargetIsMql: event.currentTarget === mql,
      bubbles: event.bubbles,
      isTrusted: event.isTrusted,
      cancelable: event.cancelable
    });
  });
  return `${mql.matches}|${mql.media}`;
})()
"#,
        )
        .expect("matchMedia change event setup should evaluate");

    assert_eq!(initial, "false|(prefers-color-scheme: dark)");

    vm.set_emulated_media(&crate::protocol_types::EmulatedMediaOverrides {
        color_scheme: Some("dark".to_owned()),
        ..Default::default()
    });
    assert!(
        vm.run_one_rendering_update_executor_turn(&loader)
            .await
            .unwrap()
    );

    let result = vm
        .eval("JSON.stringify(globalThis.__mqlChangeEvents)")
        .expect("matchMedia change event probe should evaluate");

    assert_eq!(
        result,
        r#"[{"tag":"[object MediaQueryListEvent]","ctor":"MediaQueryListEvent","protoCtor":"MediaQueryListEvent","keys":"isTrusted","type":"change","media":"(prefers-color-scheme: dark)","matches":true,"mediaEnumerable":false,"matchesEnumerable":false,"targetIsMql":true,"currentTargetIsMql":true,"bubbles":false,"isTrusted":true,"cancelable":false}]"#
    );
}

#[tokio::test(flavor = "current_thread")]
async fn match_media_declared_slots_ignore_string_property_spoofing() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
    let mut vm = new_storage_page_task_executor_test_vm("https://match-media-declared-slots.test/");

    let initial = vm
        .eval(
            r#"
(() => {
  const mql = matchMedia("(prefers-color-scheme: dark)");
  globalThis.__mqlSlotProbe = [];
  const ownSlots = Object.getOwnPropertyNames(mql)
    .filter(name => name.startsWith("__moliMediaQueryList"))
    .sort();
  function descriptorShape(name) {
    const descriptor = Object.getOwnPropertyDescriptor(MediaQueryList.prototype, name);
    return [
      typeof descriptor.get,
      descriptor.get.name,
      descriptor.get.length,
      typeof descriptor.set,
      descriptor.set ? descriptor.set.name : "",
      descriptor.set ? descriptor.set.length : -1,
      descriptor.enumerable,
      descriptor.configurable,
      Object.prototype.hasOwnProperty.call(mql, name)
    ].join(":");
  }

  MediaQueryList.prototype.__moliMediaQueryListMedia = "(prefers-color-scheme: light)";
  MediaQueryList.prototype.__moliMediaQueryListMatches = true;
  MediaQueryList.prototype.__moliMediaQueryListOnchange = () => {
    __mqlSlotProbe.push("proto-onchange");
  };
  MediaQueryList.prototype.__moliMediaQueryListListeners = {
    change: [() => __mqlSlotProbe.push("proto-listener")]
  };
  Object.assign(mql, {
    __moliMediaQueryListMedia: "(prefers-color-scheme: light)",
    __moliMediaQueryListMatches: true,
    __moliMediaQueryListOnchange: () => {
      __mqlSlotProbe.push("own-onchange");
    },
    __moliMediaQueryListListeners: {
      change: [() => __mqlSlotProbe.push("own-listener")]
    }
  });

  const before = [
    mql.media,
    mql.matches,
    mql.onchange === null
  ].join("|");
  mql.onchange = () => {
    __mqlSlotProbe.push("stale-handler");
  };
  mql.onchange = event => {
    __mqlSlotProbe.push(`handler:${event.media}:${event.matches}:${event.target === mql}`);
  };
  mql.addEventListener("change", event => {
    __mqlSlotProbe.push(`listener:${event.media}:${event.matches}`);
  });
  mql.addEventListener("change", event => {
    __mqlSlotProbe.push(`once:${event.media}:${event.matches}`);
  }, { once: true });
  const removed = event => {
    __mqlSlotProbe.push(`removed:${event.media}:${event.matches}`);
  };
  mql.addEventListener("change", removed);
  mql.removeEventListener("change", removed);
  const afterSet = [
    typeof mql.onchange,
    mql.onchange === mql.__moliMediaQueryListOnchange
  ].join(":");

  return JSON.stringify({
    ownSlots,
    before,
    afterSet,
    descriptors: {
      media: descriptorShape("media"),
      matches: descriptorShape("matches"),
      onchange: descriptorShape("onchange")
    }
  });
})()
"#,
        )
        .expect("matchMedia declared slot spoofing setup should evaluate");

    assert_eq!(
        initial,
        r#"{"ownSlots":[],"before":"(prefers-color-scheme: dark)|false|true","afterSet":"function:false","descriptors":{"media":"function:get media:0:undefined::-1:true:true:false","matches":"function:get matches:0:undefined::-1:true:true:false","onchange":"function:get onchange:0:function:set onchange:1:true:true:false"}}"#
    );

    vm.set_emulated_media(&crate::protocol_types::EmulatedMediaOverrides {
        color_scheme: Some("dark".to_owned()),
        ..Default::default()
    });
    assert!(
        vm.run_one_rendering_update_executor_turn(&loader)
            .await
            .unwrap()
    );

    let result = vm
        .eval("JSON.stringify(globalThis.__mqlSlotProbe)")
        .expect("matchMedia declared slot spoofing events should evaluate");

    assert_eq!(
        result,
        r#"["handler:(prefers-color-scheme: dark):true:true","listener:(prefers-color-scheme: dark):true","once:(prefers-color-scheme: dark):true"]"#
    );

    vm.set_emulated_media(&crate::protocol_types::EmulatedMediaOverrides {
        color_scheme: Some("light".to_owned()),
        ..Default::default()
    });
    assert!(
        vm.run_one_rendering_update_executor_turn(&loader)
            .await
            .unwrap()
    );

    let result = vm
        .eval("JSON.stringify(globalThis.__mqlSlotProbe)")
        .expect("matchMedia declared slot spoofing second event should evaluate");

    assert_eq!(
        result,
        r#"["handler:(prefers-color-scheme: dark):true:true","listener:(prefers-color-scheme: dark):true","once:(prefers-color-scheme: dark):true","handler:(prefers-color-scheme: dark):false:true","listener:(prefers-color-scheme: dark):false"]"#
    );
}

#[test]
fn media_query_list_listeners_use_event_listener_callback_interface_semantics() {
    let mut vm = new_storage_test_vm("https://mql-callback-interface.test/");

    let result = vm
        .eval(
            r#"
(() => {
  const mql = matchMedia("(min-width: 0px)");
  const calls = [];

  let operationGets = 0;
  const objectListener = {};
  Object.defineProperty(objectListener, "handleEvent", {
    configurable: true,
    get() {
      operationGets++;
      return function(event) {
        calls.push(
          `object:${this === objectListener}:${event.currentTarget === mql}:${window.event === event}`
        );
      };
    }
  });
  mql.addListener(objectListener);
  // The legacy and EventTarget APIs are aliases. A duplicate registration must
  // neither add a second call nor replace the original registration options.
  mql.addEventListener("change", objectListener, { once: true });

  let callableOperationGets = 0;
  function callable(event) {
    "use strict";
    calls.push(`callable:${this === mql}:${event.currentTarget === mql}`);
  }
  Object.defineProperty(callable, "handleEvent", {
    get() {
      callableOperationGets++;
      throw new Error("the callable branch must not resolve handleEvent");
    }
  });
  mql.addListener(callable);

  const removedBeforeVisit = () => calls.push("removed");
  const late = () => calls.push("late");
  const mutator = () => {
    calls.push("mutator");
    mql.removeListener(removedBeforeVisit);
    mql.addListener(late);
  };
  mql.addListener(mutator);
  mql.addListener(removedBeforeVisit);

  let onceCalls = 0;
  const once = () => {
    onceCalls++;
    // `once` is removed before callback entry, so re-registration is a fresh
    // listener and must survive this dispatch.
    mql.addEventListener("change", once, { once: true });
  };
  mql.addEventListener("change", once, { once: true });

  mql.dispatchEvent(new Event("change"));
  mql.dispatchEvent(new Event("change"));

  mql.removeEventListener("change", objectListener);
  mql.removeListener(callable);
  mql.dispatchEvent(new Event("change"));

  return JSON.stringify({
    calls,
    operationGets,
    callableOperationGets,
    onceCalls
  });
})()
"#,
        )
        .expect("MediaQueryList callback-interface semantics should evaluate");

    assert_eq!(
        result,
        r#"{"calls":["object:true:true:true","callable:true:true","mutator","object:true:true:true","callable:true:true","mutator","late","mutator","late"],"operationGets":2,"callableOperationGets":0,"onceCalls":3}"#
    );
}

#[test]
fn media_query_list_listener_uses_callback_realm_and_exact_window_lifetime() {
    let mut vm = new_parsed_test_vm(
        "https://mql-callback-realm.test/",
        "<!doctype html><html><body></body></html>",
    );

    vm.eval(
        r#"
(() => {
  const iframe = document.createElement("iframe");
  iframe.srcdoc = "<!doctype html><html><body></body></html>";
  document.body.appendChild(iframe);
  globalThis.__mqlCallbackRealmFrame = iframe;
})()
"#,
    )
    .expect("cross-Realm MediaQueryList listener setup should evaluate");
    vm.drain_pending_child_frame_work_for_test();

    let result = vm
        .eval(
            r#"
(() => {
  const iframe = globalThis.__mqlCallbackRealmFrame;
  const other = iframe.contentWindow;
  const mql = matchMedia("(min-width: 0px)");
  globalThis.__mqlCallbackRealmTarget = mql;
  globalThis.__mqlCallbackExpectedRealm = other;
  globalThis.__mqlCallbackRealmFacts = [];

  const callback = other.Function(
    "event",
    `"use strict";
     parent.__mqlCallbackRealmFacts.push([
       this === parent.__mqlCallbackRealmTarget,
       globalThis === parent.__mqlCallbackExpectedRealm,
       window.event === event,
       event.currentTarget === parent.__mqlCallbackRealmTarget
     ]);`
  );
  mql.addListener(callback);
  mql.dispatchEvent(new Event("change"));

  let reported = null;
  const missingOperation = new other.Object();
  const onError = event => {
    reported = {
      relevantTypeError:
        event.error instanceof other.TypeError &&
        !(event.error instanceof TypeError),
      targetIsCallbackWindow: event.currentTarget === other
    };
    event.preventDefault();
  };
  other.addEventListener("error", onError);
  mql.addListener(missingOperation);
  mql.dispatchEvent(new Event("change"));
  other.removeEventListener("error", onError);

  iframe.remove();
  mql.dispatchEvent(new Event("change"));

  return JSON.stringify({
    facts: globalThis.__mqlCallbackRealmFacts,
    reported,
    childDetached: iframe.contentWindow === null
  });
})()
"#,
        )
        .expect("cross-Realm MediaQueryList listener invocation should evaluate");

    assert_eq!(
        result,
        r#"{"facts":[[true,true,true,true],[true,true,true,true]],"reported":{"relevantTypeError":true,"targetIsCallbackWindow":true},"childDetached":true}"#
    );
}