Skip to content

armgit / moli

Public Imported from GitHub
0

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

34.0 KB
Raw Blame
use super::*;

#[test]
fn structured_clone_deserializes_in_the_receiver_realm() {
    let mut vm = new_storage_test_vm("https://structured-clone-receiver-realm.test/");

    vm.eval(
        r#"
        (() => {
          const frame = document.createElement("iframe");
          (document.body || document.documentElement || document).appendChild(frame);
          globalThis.__structuredCloneRealmFrame = frame;
          return "ready";
        })()
        "#,
    )
    .expect("structuredClone receiver Realm setup should evaluate");
    vm.drain_pending_child_frame_work_for_test();

    let result = vm
        .eval(
            r#"
            (() => {
              const frame = globalThis.__structuredCloneRealmFrame;
              const child = frame.contentWindow;
              const constructors = ["Object", "Array", "Date", "RegExp"];
              const intoTop = constructors.map(name => {
                const clone = child.structuredClone.call(window, new child[name]);
                return Object.getPrototypeOf(clone) === window[name].prototype;
              });
              const intoChild = constructors.map(name => {
                const clone = window.structuredClone.call(child, new window[name]);
                return Object.getPrototypeOf(clone) === child[name].prototype;
              });

              const buffer = new child.ArrayBuffer(8);
              const transferred = child.structuredClone.call(window, buffer, {
                transfer: [buffer]
              });

              const exceptionRealm = callback => {
                try {
                  callback();
                  return "missing";
                } catch (error) {
                  return error instanceof child.TypeError ? "child" : "other";
                }
              };
              const illegalInvocation = exceptionRealm(() =>
                child.structuredClone.call({}, 1));
              const missingArgument = exceptionRealm(() =>
                child.structuredClone.call(window));

              frame.remove();
              const detached = child.structuredClone("detached") === undefined;

              return JSON.stringify({
                intoTop,
                intoChild,
                transfer: [
                  buffer.byteLength,
                  transferred.byteLength,
                  transferred instanceof window.ArrayBuffer
                ],
                illegalInvocation,
                missingArgument,
                detached
              });
            })()
            "#,
        )
        .expect("cross-Realm structuredClone probe should evaluate");

    assert_eq!(
        result,
        r#"{"intoTop":[true,true,true,true],"intoChild":[true,true,true,true],"transfer":[0,8,true],"illegalInvocation":"child","missingArgument":"child","detached":true}"#,
    );
}

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

    let result = vm
        .eval(
            r#"
            (() => {
              const module = new WebAssembly.Module(
                new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0])
              );
              const clone = structuredClone(module);
              const instance = new WebAssembly.Instance(clone, {});
              return [
                clone instanceof WebAssembly.Module,
                clone === module,
                Object.keys(instance.exports).length
              ].join("|");
            })()
            "#,
        )
        .expect("WebAssembly.Module structuredClone should evaluate");

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

#[test]
fn structured_clone_rejects_native_dom_nodes() {
    let mut vm = new_storage_test_vm("https://example.com/dom-node-clone");

    let result = vm
        .eval(
            r#"
            (() => {
              const probe = value => {
                try {
                  structuredClone(value);
                  return "ok";
                } catch (error) {
                  return error && error.name;
                }
              };
              const liveElement = document.createElement("div");
              const detached = document.implementation.createHTMLDocument("detached");
              return [
                probe(document),
                probe(liveElement),
                probe(detached),
                probe(detached.body)
              ].join("|");
            })()
            "#,
        )
        .expect("DOM node structuredClone probe should evaluate");

    assert_eq!(
        result,
        "DataCloneError|DataCloneError|DataCloneError|DataCloneError"
    );
}

#[test]
fn structured_clone_rejects_non_serializable_platform_objects_without_prototype_spoofing() {
    let mut vm = new_storage_test_vm("https://platform-object-structured-clone.test/");

    let result = vm
        .eval(
            r#"
            (() => {
              const probe = value => {
                try {
                  structuredClone(value);
                  return "ok";
                } catch (error) {
                  return error && error.name;
                }
              };

              const fakeResponse = Object.create(Response.prototype);
              fakeResponse.value = 7;
              const fakeResponseClone = structuredClone(fakeResponse);
              const fakeEvent = Object.create(Event.prototype);
              fakeEvent.value = 9;
              const fakeEventClone = structuredClone(fakeEvent);

              return JSON.stringify({
                response: probe(new Response()),
                event: probe(new Event("event")),
                messageChannel: probe(new MessageChannel()),
                fakeResponse: [
                  fakeResponseClone.value,
                  fakeResponseClone instanceof Response
                ],
                fakeEvent: [fakeEventClone.value, fakeEventClone instanceof Event]
              });
            })()
            "#,
        )
        .expect("non-serializable platform object structuredClone probe should evaluate");

    assert_eq!(
        result,
        r#"{"response":"DataCloneError","event":"DataCloneError","messageChannel":"DataCloneError","fakeResponse":[7,false],"fakeEvent":[9,false]}"#
    );
}

#[test]
fn structured_clone_rejects_real_performance_entries_without_prototype_spoofing() {
    let document_url = Url::parse("https://performance-entry-clone.test/").expect("document URL");
    let mut vm = new_storage_test_vm(document_url.as_str());
    vm.record_script_subresource_network_result(
        document_url.clone(),
        document_url.join("resource.js").expect("resource URL"),
        &Err("synthetic resource failure".to_owned()),
    );

    let result = vm
        .eval(
            r#"
            (() => {
              const probe = callback => {
                try {
                  callback();
                  return "ok";
                } catch (error) {
                  return error && error.name;
                }
              };
              const navigation = performance.getEntriesByType("navigation")[0];
              const resource = performance.getEntriesByType("resource")[0];
              performance.mark("clone-mark");
              const mark = performance.getEntriesByName("clone-mark")[0];
              performance.measure("clone-measure");
              const measure = performance.getEntriesByName("clone-measure")[0];
              navigation.expando = "still not clonable";

              const fake = Object.create(PerformanceEntry.prototype);
              fake.value = 7;
              const fakeClone = structuredClone(fake);
              const plainClone = structuredClone({
                name: navigation.name,
                entryType: navigation.entryType,
                startTime: navigation.startTime,
                duration: navigation.duration
              });

              return JSON.stringify({
                navigation: probe(() => structuredClone(navigation)),
                resource: probe(() => structuredClone(resource)),
                mark: probe(() => structuredClone(mark)),
                measure: probe(() => structuredClone(measure)),
                postMessage: probe(() => window.postMessage(navigation, "*")),
                fake: [fakeClone.value, fakeClone instanceof PerformanceEntry],
                plain: [plainClone.entryType, typeof plainClone.startTime]
              });
            })()
            "#,
        )
        .expect("PerformanceEntry structured clone probe should evaluate");

    assert_eq!(
        result,
        r#"{"navigation":"DataCloneError","resource":"DataCloneError","mark":"DataCloneError","measure":"DataCloneError","postMessage":"DataCloneError","fake":[7,false],"plain":["navigation","number"]}"#
    );
}

#[test]
fn structured_clone_performance_entry_brand_is_private_and_survives_prototype_changes() {
    let mut vm = new_storage_test_vm("https://performance-entry-brand.test/");

    let result = vm
        .eval(
            r#"
            (() => {
              const probe = callback => {
                try {
                  callback();
                  return "ok";
                } catch (error) {
                  return error && error.name;
                }
              };
              const mark = performance.mark("factory-mark");
              const constructed = new PerformanceMark("constructed-mark");
              class DerivedMark extends PerformanceMark {}
              const derived = new DerivedMark("derived-mark");
              const inherited = Object.create(mark);
              inherited.value = 7;
              const inheritedClone = structuredClone(inherited);
              const forgedClone = structuredClone({ __moliWebApiType: true });
              const hiddenBrand = !Reflect.ownKeys(mark).includes("__moliWebApiType");
              mark.__moliWebApiType = false;
              Object.setPrototypeOf(mark, null);
              Object.setPrototypeOf(constructed, Object.prototype);

              return JSON.stringify({
                hiddenBrand,
                alteredFactory: probe(() => structuredClone(mark)),
                alteredConstructor: probe(() => structuredClone(constructed)),
                derived: probe(() => structuredClone(derived)),
                nested: probe(() => structuredClone({ entry: mark })),
                detail: probe(() => performance.mark("entry-as-detail", { detail: mark })),
                inherited: [inheritedClone.value, inheritedClone instanceof PerformanceEntry],
                forged: [forgedClone.__moliWebApiType, forgedClone instanceof PerformanceEntry]
              });
            })()
            "#,
        )
        .expect("PerformanceEntry private brand probe should evaluate");

    assert_eq!(
        result,
        r#"{"hiddenBrand":true,"alteredFactory":"DataCloneError","alteredConstructor":"DataCloneError","derived":"DataCloneError","nested":"DataCloneError","detail":"DataCloneError","inherited":[7,false],"forged":[true,false]}"#
    );
}

#[test]
fn structured_clone_preserves_dom_exception_fields_and_brand() {
    let mut vm = new_storage_test_vm("https://dom-exception-clone.test/");

    let result = vm
        .eval(
            r#"
            (() => {
              const source = new DOMException("chunk could not be cloned", "DataCloneError");
              source.expando = "not serialized";
              const clone = structuredClone(source);
              return [
                clone instanceof DOMException,
                Object.getPrototypeOf(clone) === DOMException.prototype,
                clone.name,
                clone.message,
                clone.code,
                clone.expando === undefined
              ].join("|");
            })()
            "#,
        )
        .expect("DOMException structured clone should evaluate");

    assert_eq!(
        result,
        "true|true|DataCloneError|chunk could not be cloned|25|true"
    );
}

#[test]
fn structured_clone_transfers_array_buffer_and_preserves_view_aliases() {
    let mut vm = new_storage_test_vm("https://array-buffer-transfer.test/");

    let result = vm
        .eval(
            r#"
            (() => {
              const buffer = new ArrayBuffer(10);
              const data = new DataView(buffer);
              data.setUint32(0, 0x01020304, false);
              const words = new Uint16Array(buffer, 4, 3);
              words.set([7, 500, 65535]);
              const clone = structuredClone(
                { buffer, data, words, nested: new Map([["words", words]]) },
                { transfer: [buffer] }
              );
              let duplicate;
              const duplicateBuffer = new ArrayBuffer(1);
              try {
                structuredClone(duplicateBuffer, {
                  transfer: [duplicateBuffer, duplicateBuffer]
                });
                duplicate = "missing";
              } catch (error) {
                duplicate = error.name;
              }
              return JSON.stringify({
                sourceLength: buffer.byteLength,
                cloneLength: clone.buffer.byteLength,
                bytes: Array.from(new Uint8Array(clone.buffer)),
                aliases: [
                  clone.data.buffer === clone.buffer,
                  clone.words.buffer === clone.buffer,
                  clone.nested.get("words").buffer === clone.buffer
                ],
                brands: [
                  clone.data instanceof DataView,
                  clone.words instanceof Uint16Array,
                  clone.nested instanceof Map
                ],
                duplicate
              });
            })()
            "#,
        )
        .expect("ArrayBuffer structuredClone transfer should evaluate");

    assert_eq!(
        result,
        r#"{"sourceLength":0,"cloneLength":10,"bytes":[1,2,3,4,7,0,244,1,255,255],"aliases":[true,true,true],"brands":[true,true,true],"duplicate":"DataCloneError"}"#
    );
}

#[test]
fn structured_clone_preserves_opfs_locator_and_source_handle() {
    let mut vm = new_storage_page_task_executor_test_vm("https://opfs-structured-clone.test/");

    vm.exec(
        r#"
        globalThis.__opfsStructuredCloneProbe = "pending";
        (async () => {
          const root = await navigator.storage.getDirectory();
          const directory = await root.getDirectoryHandle("clone-dir", { create: true });
          const file = await directory.getFileHandle("clone.txt", { create: true });
          const writer = await file.createWritable();
          await writer.write("clone bytes");
          await writer.close();

          const cloned = structuredClone({ root, handles: [file, file] });
          const clonedFile = cloned.handles[0];
          globalThis.__opfsStructuredCloneProbe = JSON.stringify({
            rootBrand: cloned.root instanceof FileSystemDirectoryHandle,
            fileBrand: clonedFile instanceof FileSystemFileHandle,
            sharedReference: cloned.handles[0] === cloned.handles[1],
            distinctFromSource: clonedFile !== file,
            sameEntry: await clonedFile.isSameEntry(file),
            resolved: await cloned.root.resolve(clonedFile),
            text: await (await clonedFile.getFile()).text()
          });
        })().catch(error => {
          globalThis.__opfsStructuredCloneProbe =
            `error:${error && error.name}:${error && error.message}`;
        });
        "#,
        None,
    )
    .expect("OPFS structuredClone probe should schedule");

    let result = vm
        .eval_after_selected_page_tasks("String(globalThis.__opfsStructuredCloneProbe)")
        .expect("OPFS structuredClone probe should settle");
    assert_eq!(
        result,
        r#"{"rootBrand":true,"fileBrand":true,"sharedReference":true,"distinctFromSource":true,"sameEntry":true,"resolved":["clone-dir","clone.txt"],"text":"clone bytes"}"#
    );
}

#[tokio::test]
async fn blob_iframe_inherits_secure_origin_for_opfs_handle_messages() {
    let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
    let mut vm = new_storage_page_task_executor_test_vm_with_loader(
        "https://opfs-blob-frame-clone.test/page.html",
        &loader,
    );

    let setup = vm
        .eval(
            r#"
(() => {
  globalThis.__opfsBlobFrameCloneProbe = "pending";
  let frame;
  addEventListener("message", async event => {
    if (!event.data || event.source !== frame.contentWindow) {
      return;
    }
    if (event.data.kind === "ready") {
      const root = await navigator.storage.getDirectory();
      frame.contentWindow.postMessage({ kind: "handle", root }, "*");
      return;
    }
    if (event.data.kind === "result" || event.data.kind === "messageerror") {
      globalThis.__opfsBlobFrameCloneProbe = JSON.stringify(event.data);
    }
  });

  const childMarkup = `<!doctype html><script>
    addEventListener("message", event => {
      const root = event.data && event.data.root;
      parent.postMessage({
        kind: "result",
        secure: isSecureContext,
        interfaceExposed: "FileSystemHandle" in globalThis,
        directoryInterfaceExposed: "FileSystemDirectoryHandle" in globalThis,
        directoryBrand: root instanceof FileSystemDirectoryHandle,
        rootName: root.name
      }, "*");
    });
    addEventListener("messageerror", () => {
      parent.postMessage({ kind: "messageerror", secure: isSecureContext }, "*");
    });
    parent.postMessage({ kind: "ready" }, "*");
  <\/script>`;
  frame = document.createElement("iframe");
  frame.src = URL.createObjectURL(new Blob([childMarkup], { type: "text/html" }));
  (document.body || document.documentElement || document).appendChild(frame);
  return "queued";
})()
"#,
        )
        .expect("blob iframe OPFS clone setup should evaluate");
    assert_eq!(setup, "queued");

    advance_page_task_executor_until_eval_equals(
        &mut vm,
        &loader,
        "String(globalThis.__opfsBlobFrameCloneProbe)",
        r#"{"kind":"result","secure":true,"interfaceExposed":true,"directoryInterfaceExposed":true,"directoryBrand":true,"rootName":""}"#,
        "blob iframe OPFS clone",
    )
    .await;
}

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

    let setup = vm
        .eval(
            r#"
(() => {
  globalThis.__sandboxedBlobFrameProbe = "pending";
  let frame;
  let sourceFile;
  let sourceDirectory;
  let rejectionCount = 0;
  addEventListener("message", async event => {
    if (!event.data || event.source !== frame.contentWindow) {
      return;
    }
    if (event.data.kind === "ready") {
      const root = await navigator.storage.getDirectory();
      sourceFile = await root.getFileHandle("sequential-file", { create: true });
      sourceDirectory =
        await root.getDirectoryHandle("sequential-directory", { create: true });
      frame.contentWindow.postMessage({ kind: "handle", handle: sourceFile }, "*");
      return;
    }
    if (event.data.kind === "message") {
      globalThis.__sandboxedBlobFrameProbe = "unexpected-message";
      return;
    }
    if (event.data.kind === "messageerror") {
      rejectionCount += 1;
      if (rejectionCount === 1) {
        frame.contentWindow.postMessage(
          { kind: "handle", handle: sourceDirectory },
          "*"
        );
        return;
      }
      globalThis.__sandboxedBlobFrameProbe = JSON.stringify({
        rejectionCount,
        origin: event.data.origin,
        secure: event.data.secure,
        interfaceExposed: event.data.interfaceExposed,
        storageExposed: event.data.storageExposed,
        getDirectory: event.data.getDirectory,
        sourceStillUsable:
          sourceFile.name === "sequential-file" &&
          sourceDirectory.name === "sequential-directory"
      });
    }
  });
  const childMarkup = `<!doctype html><script>
    addEventListener("message", () => {
      parent.postMessage({ kind: "message" }, "*");
    });
    addEventListener("messageerror", async () => {
      let getDirectory;
      try {
        await navigator.storage.getDirectory();
        getDirectory = "resolved";
      } catch (error) {
        getDirectory = error && error.name;
      }
      parent.postMessage({
        kind: "messageerror",
        origin: location.origin,
        secure: isSecureContext,
        interfaceExposed: "FileSystemHandle" in globalThis,
        storageExposed: "storage" in navigator,
        getDirectory
      }, "*");
    });
    parent.postMessage({ kind: "ready" }, "*");
  <\/script>`;
  frame = document.createElement("iframe");
  frame.setAttribute("sandbox", "allow-scripts");
  frame.src = URL.createObjectURL(new Blob([childMarkup], { type: "text/html" }));
  (document.body || document.documentElement || document).appendChild(frame);
  return "queued";
})()
"#,
        )
        .expect("sandboxed blob iframe setup should evaluate");
    assert_eq!(setup, "queued");

    advance_page_task_executor_until_eval_equals(
        &mut vm,
        &loader,
        "String(globalThis.__sandboxedBlobFrameProbe)",
        r#"{"rejectionCount":2,"origin":"null","secure":true,"interfaceExposed":true,"storageExposed":true,"getDirectory":"SecurityError","sourceStillUsable":true}"#,
        "sandboxed blob iframe OPFS rejection",
    )
    .await;
}

#[test]
fn structured_clone_preserves_quota_exceeded_error_fields_and_brand() {
    let mut vm = new_storage_test_vm("https://quota-exceeded-error-clone.test/");

    let result = vm
        .eval(
            r#"
            (() => {
              const source = new QuotaExceededError("full", {
                quota: 0.1,
                requested: 1
              });
              source.expando = "not serialized";
              const clone = structuredClone(source);
              const empty = structuredClone(new QuotaExceededError("empty"));
              return [
                clone instanceof QuotaExceededError,
                clone instanceof DOMException,
                Object.getPrototypeOf(clone) === QuotaExceededError.prototype,
                clone.name,
                clone.message,
                clone.code,
                clone.quota,
                clone.requested,
                clone.expando === undefined,
                empty.quota === null,
                empty.requested === null
              ].join("|");
            })()
            "#,
        )
        .expect("QuotaExceededError structured clone should evaluate");

    assert_eq!(
        result,
        "true|true|true|QuotaExceededError|full|22|0.1|1|true|true|true"
    );
}

#[test]
fn structured_clone_rejects_platform_objects_in_nested_graphs_without_running_their_getters() {
    let mut vm = new_storage_test_vm("https://platform-identity-clone.test/");
    let result = vm.eval(r#"
      (() => {
        const objects = [
          new URL('https://example.test/'), new URLSearchParams('a=b'), new Headers(),
          new Request('https://example.test/'), new Response('body'), new Response().headers, new FormData(),
          new Event('event'), new EventTarget(), new AbortController(), new AbortController().signal,
          navigator, performance, history, localStorage, new Highlight(), CSS.highlights, customElements, new CustomElementRegistry(),
          document, document.implementation, document.childNodes, document.children, document.querySelectorAll('*'), document.createElement('div').attributes, new XMLHttpRequest().upload, document.createElement('select'), document.createTextNode('text'),
          document.implementation.createHTMLDocument('detached').body,
          new TextEncoder(), new TextDecoder(), new TextEncoderStream(), new TextDecoderStream(),
          new CompressionStream('gzip'), new DecompressionStream('gzip'),
          new URLSearchParams().entries(), new Headers().entries(), new Highlight().values(),
        ];
        const failures = [];
        for (const [index, object] of objects.entries()) {
          let getterCalls = 0;
          Object.defineProperty(object, 'cloneProbe', {enumerable: true, get() { getterCalls++; return 1; }});
          try { structuredClone({nested: new Map([['entry', object]])}); failures.push(`${index}:accepted`); }
          catch (error) { if (error.name !== 'DataCloneError') failures.push(`${index}:${error.name}`); }
          if (getterCalls) failures.push(`${index}:getter`);
        }
        const buffer = new ArrayBuffer(4);
        try { structuredClone({buffer, rejected: objects[0]}, {transfer: [buffer]}); }
        catch (error) { if (error.name !== 'DataCloneError') failures.push('transfer-error'); }
        if (buffer.byteLength !== 4) failures.push('premature-detach');
        return failures.join('|');
      })()
    "#).expect("platform identity clone matrix should evaluate");
    assert_eq!(result, "");
}

#[test]
fn structured_clone_does_not_read_fake_private_slots_or_inherit_native_identity() {
    let mut vm = new_storage_test_vm("https://platform-identity-forgery.test/");
    let result = vm.eval(r#"
      (() => {
        let reads = 0;
        const prototype = Object.create(new URL('https://example.test/'));
        for (const key of ['__moliWebApiType', '__lmUrlHref', '__lmUrlSearchParamsPairs', '__lmFormDataEntries']) {
          Object.defineProperty(prototype, key, {get() { reads++; throw Error('must not run'); }});
        }
        const object = Object.create(prototype);
        object.value = 7;
        const clone = structuredClone(object);
        const forged = structuredClone({__moliWebApiType: 'URL', __lmUrlHref: 'public'});
        return [reads, clone.value, Object.getPrototypeOf(clone) === Object.prototype,
          forged.__moliWebApiType, forged.__lmUrlHref].join('|');
      })()
    "#).expect("ordinary records must not trigger native identity checks through author properties");
    assert_eq!(result, "0|7|true|URL|public");
}

#[test]
fn encoding_stream_wrappers_do_not_inherit_transform_transferability() {
    let mut vm = new_storage_test_vm("https://platform-transfer-types.test/");
    let result = vm.eval(r#"
      [new TextEncoderStream(), new TextDecoderStream(), new CompressionStream('gzip'), new DecompressionStream('gzip')]
        .map(stream => { try { structuredClone(stream, {transfer: [stream]}); return 'accepted'; }
          catch (error) { return error.name; } }).join('|')
    "#).expect("only actual transferable stream interfaces should be accepted");
    assert_eq!(
        result,
        "DataCloneError|DataCloneError|DataCloneError|DataCloneError"
    );
}

#[test]
fn shared_array_buffers_fail_consistently_at_root_and_inside_message_graphs() {
    let mut vm = new_storage_test_vm("https://shared-buffer-clone.test/");
    let result = vm.eval(r#"
      (() => {
        const shared = new SharedArrayBuffer(8);
        const channel = new MessageChannel();
        const probe = fn => { try { fn(); return 'accepted'; } catch (error) { return error.name; } };
        return [
          probe(() => structuredClone(shared)),
          probe(() => structuredClone({nested: new Map([['shared', shared]])})),
          probe(() => channel.port1.postMessage({shared})),
          probe(() => window.postMessage({shared}, '*')),
          shared.byteLength
        ].join('|');
      })()
    "#).expect("unsupported shared buffers must report DataCloneError at every depth");
    assert_eq!(
        result,
        "DataCloneError|DataCloneError|DataCloneError|DataCloneError|8"
    );
}

#[test]
fn supported_platform_codecs_preserve_payloads_after_prototype_changes() {
    let mut vm = new_storage_test_vm("https://supported-platform-codecs.test/");
    let result = vm.eval(r#"
      (() => {
        const blob = new (class extends Blob {})(['abc'], {type: 'text/plain'});
        const file = new File(['def'], 'note.txt', {type: 'text/plain', lastModified: 17});
        const pixels = new ImageData(new Uint8ClampedArray([1, 2, 3, 4]), 1, 1);
        const exception = new DOMException('message', 'AbortError');
        let getterCalls = 0;
        for (const object of [blob, file, pixels, exception]) {
          Object.setPrototypeOf(object, null);
          Object.defineProperty(object, 'expando', {enumerable: true, get() { getterCalls++; return 1; }});
        }
        const clone = structuredClone({blob, file, pixels, exception, again: blob});
        return [clone.blob instanceof Blob, clone.blob.size, clone.blob.type, clone.blob === clone.again,
          clone.file instanceof File, clone.file.name, clone.file.lastModified,
          clone.pixels instanceof ImageData, Array.from(clone.pixels.data).join(','),
          clone.exception instanceof DOMException, clone.exception.name, clone.exception.message,
          getterCalls, clone.blob.expando === undefined].join('|');
      })()
    "#).expect("native codecs should ignore mutable prototypes and author expandos");
    assert_eq!(
        result,
        "true|3|text/plain|true|true|note.txt|17|true|1,2,3,4|true|AbortError|message|0|true"
    );
}

#[test]
fn observer_and_webgl_factory_results_have_native_identity() {
    let mut vm = new_storage_test_vm("https://factory-result-identity.test/");
    let result = vm
        .eval(
            r#"
      (() => {
        const target = document.createElement('div');
        target.style.cssText = 'width: 41px; height: 23px';
        const html = document.documentElement || document.appendChild(document.createElement('html'));
        const body = document.body || html.appendChild(document.createElement('body'));
        body.appendChild(target);
        const observer = new ResizeObserver(() => {});
        observer.observe(target);
        const entry = observer.takeRecords()[0];
        const gl = document.createElement('canvas').getContext('webgl');
        const precision = gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.HIGH_FLOAT);
        return [entry, entry.contentBoxSize[0], entry.borderBoxSize[0], precision].map(value => {
          try { structuredClone({value}); return 'accepted'; }
          catch (error) { return error.name; }
        }).join('|');
      })()
    "#,
        )
        .expect("factory results must be identified before structured clone");
    assert_eq!(
        result,
        "DataCloneError|DataCloneError|DataCloneError|DataCloneError"
    );
}

#[test]
fn dom_exception_factories_capture_v8_stacks_without_author_lookup() {
    let mut vm = new_storage_page_task_executor_test_vm("https://native-error-stack.test/");
    assert_eq!(vm.eval(r#"(() => {
      document.body.innerHTML = '<iframe></iframe>';
      const other = document.querySelector('iframe').contentWindow;
      for (const realm of [window, other]) {
        const descriptor = Object.getOwnPropertyDescriptor(realm.Error, 'captureStackTrace');
        Object.defineProperty(realm.Error, 'captureStackTrace', {configurable:true, get() {throw 42;}});
        try {
          for (const error of [new realm.DOMException('message', 'AbortError'),
            new realm.QuotaExceededError('full'), new realm.RTCError({errorDetail:'dtls-failure'}, 'rtc')]) {
            const stack = error.stack;
            if (typeof stack !== 'string' || !stack.startsWith(error.name + ': ' + error.message) ||
                !Object.hasOwn(error,'stack') || Object.getOwnPropertyDescriptor(error,'stack').enumerable) throw Error('native stack');
          }
          let syntax;
          try { document.querySelector('['); } catch(error) { syntax = error; }
          if (!(syntax instanceof DOMException) || typeof syntax.stack !== 'string') throw Error('native factory');
        } finally {
          if(descriptor)Object.defineProperty(realm.Error,'captureStackTrace',descriptor);
          else delete realm.Error.captureStackTrace;
        }
      }
      return true;
    })()"#).unwrap(), "true");
}

#[test]
fn dom_exception_getters_read_registered_native_proxy_targets() {
    let mut vm = new_storage_page_task_executor_test_vm("https://native-error-receiver.test/");
    vm.eval("globalThis.errors = [new DOMException('message','AbortError'),new QuotaExceededError('full',{quota:12}),new RTCError({errorDetail:'dtls-failure'},'rtc')]").unwrap();
    let context_ptr = &vm.page_default_runtime.context as *const _;
    vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| {
        let global = scope.get_current_context().global(scope);
        let key = crate::util::v8str(scope, "errors");
        let errors =
            v8::Local::<v8::Array>::try_from(global.get(scope, key.into()).unwrap()).unwrap();
        let proxies = v8::Array::new(scope, 3);
        for index in 0..3 {
            let error =
                v8::Local::<v8::Object>::try_from(errors.get_index(scope, index).unwrap()).unwrap();
            let handler = crate::util::new_null_prototype_object(scope);
            let proxy = v8::Proxy::new(scope, error, handler).unwrap();
            moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap();
            assert!(crate::web_api_interfaces::DOMException::is_instance(
                scope,
                proxy.into()
            ));
            assert_eq!(proxies.set_index(scope, index, proxy.into()), Some(true));
        }
        let key = crate::util::v8str(scope, "nativeProxies");
        assert_eq!(
            global.create_data_property(scope, key.into(), proxies.into()),
            Some(true)
        );
        Ok(())
    })
    .unwrap();
    assert_eq!(vm.eval(r#"(() => {
      for(let index=0;index<errors.length;index++) {
        const original=errors[index],proxy=nativeProxies[index];
        for(const name of ['name','message','code']) {
          const getter=Object.getOwnPropertyDescriptor(DOMException.prototype,name).get;
          if(getter.call(proxy)!==getter.call(original))throw Error('native target '+name);
          let traps=0,error;
          const author=new Proxy(proxy,{get(){traps++;throw 42;},getPrototypeOf(){traps++;throw 43;}});
          try{getter.call(author);}catch(caught){error=caught;}
          if(!(error instanceof TypeError)||traps)throw Error('author proxy');
        }
      }
      if(nativeProxies[1].quota!==12||nativeProxies[2].errorDetail!=='dtls-failure')throw Error('derived native target');
      return true;
    })()"#).unwrap(), "true");
}