buninu-browser 0.5.0 → 0.6.0

package/test/raw-capture.test.js

@@ -1,6 +1,7 @@
-import {test,expect} from 'bun:test';
+import {test,expect,spyOn} from 'bun:test';
 import {readFileSync,existsSync,unlinkSync} from 'node:fs';
 import {dirname} from 'node:path';
+import {Server} from 'node:net';
 import {RendererHost} from '../lib/renderer/host.js';
 import {PacketReader,encodePacket,listenCompositor,connectCompositor} from '../lib/renderer/compositor-channel.js';
 import {RawFrames} from '../lib/paint/raw-frames.js';
@@ -85,17 +86,45 @@ test('normal CDP routes raw requests to the controller without changing standard
   expect([crop.readUInt32BE(16),crop.readUInt32BE(20)]).toEqual([7,4]);
   await cdp.send('Page.screencastFrameAck',{sessionId:event.params.sessionId});
   await cdp.send('Page.stopScreencast');
+  cdp.events.length=0;
+  const zero={x:0,y:0,width:0,height:0,scale:1};
+  await cdp.send('Page.startScreencast',{format:'png',clip:zero});
+  let notice;for(let i=0;i<100;i++){notice=cdp.events.find(e=>e.method==='Page.screencastFrame');if(notice)break;await Bun.sleep(20);}
+  expect(notice).toBeDefined();
+  const placeholder=Buffer.from(notice.params.data,'base64');
+  expect([placeholder.readUInt32BE(16),placeholder.readUInt32BE(20)]).toEqual([1,1]);
+  await cdp.send('Page.stopScreencast');
+  await expect(cdp.send('Page.captureScreenshot',{format:'png',clip:zero})).rejects.toThrow('Invalid screenshot clip');
   const png=await cdp.send('Page.captureScreenshot',{format:'png'});
   expect([...Buffer.from(png.data,'base64').subarray(0,4)]).toEqual([137,80,78,71]);
  }finally{cdp.close();server.stop(true);browser.close();}
  expect(existsSync(directory)).toBe(false);
 },20000);
 
-test('closing during listener startup rejects promptly and a new start remains usable',async()=>{
- const host=new RendererHost();
- const pending=host.start();host.close();
+test('closing during listener startup releases the listener and only a new host remains usable',async()=>{
+ const host=new RendererHost(),listeners=[],closed=[];
+ const original=Server.prototype.listen;
+ const listening=spyOn(Server.prototype,'listen').mockImplementation(function(...args){
+  listeners.push(this);closed.push(new Promise(resolve=>this.once('close',resolve)));
+  return original.apply(this,args);
+ });
+ let pending;
+ try{pending=host.start();host.close();}finally{listening.mockRestore();}
  await expect(pending).rejects.toThrow('closed');
- try{await host.start();expect(host.pid).toBeGreaterThan(0);}finally{host.close();}
+ expect(listeners).toHaveLength(1);
+ // Cancellation rejects before listen() resolves. Its later continuation
+ // must close that newly-created listener instead of leaving a server alive.
+ await Promise.all(closed);
+ expect(listeners[0].listening).toBe(false);
+ await expect(host.start()).rejects.toThrow('Renderer is closed');
+ expect(host.pid).toBeNull();
+ const fresh=new RendererHost();
+ try{
+  await fresh.start();expect(fresh.pid).toBeGreaterThan(0);
+  await fresh.call('loadDocument',{url:'about:blank',source:'<body>fresh host</body>',contentType:'text/html'});
+  const png=await fresh.composite('screenshot',{format:'png'});
+  expect([...Buffer.from(png,'base64').subarray(0,4)]).toEqual([137,80,78,71]);
+ }finally{fresh.close();}
 },15000);
 
 for(const compositor of [true,false])test(`fractional CDP clips preserve exact physical dimensions and raw pixels (compositor=${compositor})`,async()=>{

package/test/renderer-host.test.js

@@ -24,6 +24,57 @@ test("runs calls in a separate process with an empty environment", async () => {
   expect(result.argument.hello).toEqual(new Uint8Array([1, 2]));
 });
 
+test("slow startup outlives the method deadline without replacing the child", async () => {
+  const renderer = host({ timeout: 20, args: ['--ready-delay=200'] });
+  const ready = renderer.start();
+  const pid = renderer.pid;
+  await ready;
+  expect(renderer.pid).toBe(pid);
+  expect(renderer.pid).toBeGreaterThan(0);
+});
+
+test("disabled watchdog lets slow methods finish and still permits explicit close", async () => {
+  const renderer = host({ timeout: 0 });
+  expect(await renderer.call('slow')).toBe('completed');
+  const hanging = renderer.call('hang').catch(error => error.message);
+  await Bun.sleep(20);
+  renderer.close();
+  expect(await hanging).toBe('Renderer closed');
+});
+
+test("closing during slow startup rejects the wait", async () => {
+  const renderer = host({ args: ['--ready-delay=60000'] });
+  const ready = renderer.start();
+  const result = ready.then(() => 'unexpected ready', error => error.message);
+  renderer.close();
+  expect(await result).toBe('Renderer closed during startup');
+  expect(renderer.pid).toBeNull();
+});
+
+test("slow document loading is not killed by the interactive method deadline", async () => {
+  const renderer = host({ timeout: 20 });
+  await renderer.start();
+  const pid = renderer.pid;
+  expect(await renderer.call('loadDocument', { url: 'https://example.test/', delay: 200 })).toBe('loaded');
+  expect(await renderer.call('showFragment', 'https://example.test/#section')).toBe('positioned');
+  expect(renderer.pid).toBe(pid);
+});
+
+test("closing cancels a pending document load", async () => {
+  const renderer = host();
+  await renderer.start();
+  const loading = renderer.call('loadDocument', { url: 'https://example.test/', delay: 60000 });
+  const result = loading.then(() => 'unexpected completion', error => error.message);
+  await Bun.sleep(20);
+  renderer.close();
+  expect(await result).toBe('Renderer closed');
+});
+
+test("exit before ready rejects startup without waiting for a deadline", async () => {
+  const renderer = host({ args: ['--exit-before-ready'] });
+  await expect(renderer.start()).rejects.toThrow('renderer exited during startup');
+});
+
 test("kills a renderer that misses its deadline and restarts it on the next call", async () => {
   const restarts = [];
   const renderer = host({

package/test/resource-discovery.test.js

@@ -0,0 +1,12 @@
+import { expect, test } from "bun:test";
+
+test("geometry reads reuse discovery while newly inserted media stays fresh", async () => {
+  const child = Bun.spawn([process.execPath, new URL("./fixtures/resource-discovery.js", import.meta.url).pathname], {
+    stdout: "pipe", stderr: "pipe",
+  });
+  const [out, error, code] = await Promise.all([
+    new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited,
+  ]);
+  expect({ code, error }).toEqual({ code: 0, error: "" });
+  expect(out).toContain("resource discovery integration passed");
+}, 30_000);

package/test/resource-elements.test.js

@@ -0,0 +1,234 @@
+import { expect, test } from "bun:test";
+import { parseHTMLDocument } from "../lib/happy-dom/parser.js";
+import { createResourceElements } from "../lib/renderer/resource-elements.js";
+
+async function fixture(run) {
+  const { window, document } = parseHTMLDocument(`<!doctype html><head>
+    <style>body {color:red}</style><link rel="preload" href="one.css"></head>
+    <body><img src="one.png"><video></video><iframe></iframe></body>`, "https://resource.test/");
+  const query = document.querySelectorAll.bind(document), queries = [];
+  document.querySelectorAll = selector => { queries.push(selector); return query(selector); };
+  const cache = createResourceElements(document);
+  try { await run({ window, document, cache, queries }); }
+  finally { cache.dispose(); await window.happyDOM.close(); }
+}
+
+test("metadata changes retain discovery while resource attributes and sheet text remain live", async () => {
+  await fixture(async ({ document, cache, queries }) => {
+    const before = Object.fromEntries(["media", "images", "sheets", "frames"].map(kind => [kind, cache.get(kind)]));
+    const [image] = before.images, [style] = before.sheets;
+    queries.length = 0;
+    for (let i = 0; i < 20; i++) {
+      document.body.setAttribute("data-counter", String(i));
+      image.setAttribute("aria-label", String(i));
+      image.setAttribute("class", `item-${i}`);
+      for (const kind of Object.keys(before)) expect(cache.get(kind)).toBe(before[kind]);
+    }
+    image.setAttribute("src", "two.png");
+    image.setAttribute("crossorigin", "anonymous");
+    style.setAttribute("media", "print");
+    style.setAttribute("type", "text/plain");
+    style.firstChild.data = "body {color:blue}";
+    expect(cache.get("images")[0].getAttribute("src")).toBe("two.png");
+    expect(cache.get("images")[0].getAttribute("crossorigin")).toBe("anonymous");
+    expect(cache.get("sheets")[0].textContent).toBe("body {color:blue}");
+    expect(cache.get("sheets")[0].getAttribute("media")).toBe("print");
+    expect(cache.get("sheets")[0].getAttribute("type")).toBe("text/plain");
+    expect(queries).toEqual([]);
+  });
+});
+
+test("rel membership is refreshed synchronously without rescanning other resource kinds", async () => {
+  await fixture(async ({ document, cache, queries }) => {
+    const imageList = cache.get("images"), sheets = cache.get("sheets");
+    const link = document.getElementsByTagName("link")[0];
+    queries.length = 0;
+    link.setAttribute("rel", "alternate stylesheet");
+    expect(cache.get("sheets")).toEqual([sheets[0], link]);
+    expect(cache.get("images")).toBe(imageList);
+    link.setAttribute("href", "two.css");
+    link.setAttribute("disabled", "");
+    expect(cache.get("sheets")[1].getAttribute("href")).toBe("two.css");
+    expect(cache.get("sheets")[1].hasAttribute("disabled")).toBe(true);
+    link.removeAttribute("rel");
+    expect(cache.get("sheets")).toEqual(sheets);
+    expect(queries).toEqual(["style, link[rel~='stylesheet']", "style, link[rel~='stylesheet']"]);
+  });
+});
+
+test("text and comment replacement preserves element discovery but stylesheet contents stay live", async () => {
+  await fixture(async ({ document, cache, queries }) => {
+    const counter = document.createElement("span");
+    document.body.append(counter);
+    const kinds = ["media", "images", "sheets", "frames"];
+    const lists = Object.fromEntries(kinds.map(kind => [kind, cache.get(kind)]));
+    const style = lists.sheets[0];
+    queries.length = 0;
+    for (let index = 0; index < 20; index++) {
+      counter.textContent = String(index);
+      const comment = document.createComment("counter");
+      counter.append(comment);
+      comment.remove();
+      style.textContent = `body { z-index: ${index} }`;
+      for (const kind of kinds) expect(cache.get(kind)).toBe(lists[kind]);
+      expect(cache.get("sheets")[0].textContent).toBe(`body { z-index: ${index} }`);
+    }
+    counter.textContent = "after delivery";
+    await Bun.sleep(10);
+    for (const kind of kinds) expect(cache.get(kind)).toBe(lists[kind]);
+    expect(queries).toEqual([]);
+    // An element removed through textContent still invalidates membership.
+    counter.append(lists.images[0]);
+    cache.get("images");
+    counter.textContent = "removed image";
+    expect(cache.get("images")).toEqual([]);
+  });
+});
+
+test("insert, remove and reattach are discovered before and after observer delivery", async () => {
+  await fixture(async ({ document, cache }) => {
+    const old = cache.get("images")[0];
+    const subtree = document.createElement("section");
+    subtree.innerHTML = '<img src="new.png"><audio></audio><style>p{color:red}</style><iframe></iframe>';
+    document.body.append(subtree);
+    expect(cache.get("images")).toEqual([old, subtree.firstChild]);
+    expect(cache.get("media").map(element => element.tagName)).toEqual(["VIDEO", "AUDIO"]);
+    expect(cache.get("frames")).toHaveLength(2);
+    expect(cache.get("sheets")).toHaveLength(2);
+    subtree.remove();
+    expect(cache.get("images")).toEqual([old]);
+    document.body.append(subtree);
+    await Bun.sleep(10); // exercise the observer callback, not just takeRecords()
+    expect(cache.get("frames")).toHaveLength(2);
+    old.remove();
+    expect(cache.get("images")).toEqual([subtree.firstChild]);
+    document.body.append(old);
+    expect(cache.get("images")).toEqual([subtree.firstChild, old]);
+  });
+});
+
+test("navigation/disposal releases old discovery and base URLs are read from live elements", async () => {
+  await fixture(async ({ document, cache }) => {
+    const image = cache.get("images")[0];
+    const base = document.createElement("base");
+    base.setAttribute("href", "/first/"); document.head.prepend(base);
+    expect(cache.get("images")[0]).toBe(image);
+    expect(new URL(image.getAttribute("src"), image.baseURI).href).toBe("https://resource.test/first/one.png");
+    base.setAttribute("href", "/second/");
+    expect(new URL(cache.get("images")[0].getAttribute("src"), image.baseURI).href).toBe("https://resource.test/second/one.png");
+    cache.dispose();
+    expect(() => cache.get("images")).toThrow("disposed");
+    const fresh = createResourceElements(document);
+    try {
+      image.remove();
+      expect(fresh.get("images")).toEqual([]);
+    } finally { fresh.dispose(); }
+  });
+});
+
+test("ordinary subtree edits retain resource lists and image edits only rescan images", async () => {
+  for (const delivered of [false, true]) await fixture(async ({ document, cache, queries }) => {
+    const container = document.createElement("div");
+    document.body.append(container);
+    const before = Object.fromEntries(["media", "images", "sheets", "frames"].map(kind => [kind, cache.get(kind)]));
+    queries.length = 0;
+    for (let index = 0; index < 3; index++) {
+      container.innerHTML = `<section><span>counter ${index}</span></section>`;
+      if (delivered) await Bun.sleep(10);
+      for (const kind of Object.keys(before)) expect(cache.get(kind)).toBe(before[kind]);
+    }
+    expect(queries).toEqual([]);
+    // Several connected insertion records overlap the same subtree.
+    let parent = container;
+    for (let index = 0; index < 100; index++) {
+      const child = document.createElement("div");
+      parent.append(child); parent = child;
+    }
+    const image = document.createElement("img");
+    parent.append(image);
+    if (delivered) await Bun.sleep(10);
+    expect(cache.get("images")).toEqual([...before.images, image]);
+    for (const kind of ["media", "sheets", "frames"]) expect(cache.get(kind)).toBe(before[kind]);
+    expect(queries).toEqual(["img"]);
+  });
+});
+
+test("removed subtrees still invalidate after their resource descendants are detached", async () => {
+  for (const delivered of [false, true]) await fixture(async ({ document, cache }) => {
+    const kinds = ["media", "images", "sheets", "frames"];
+    const original = Object.fromEntries(kinds.map(kind => [kind, [...cache.get(kind)]]));
+    const subtree = document.createElement("section");
+    subtree.innerHTML = '<div><img><audio></audio><style>p{color:blue}</style><iframe></iframe></div>';
+    document.body.append(subtree);
+    for (const kind of kinds) expect(cache.get(kind)).toHaveLength(original[kind].length + 1);
+    subtree.remove();
+    subtree.firstChild.replaceChildren();
+    subtree.replaceChildren();
+    if (delivered) await Bun.sleep(10);
+    for (const kind of kinds) expect(cache.get(kind)).toEqual(original[kind]);
+  });
+});
+
+test("detached rel edits, reordering and moves into shadow roots refresh old membership", async () => {
+  for (const delivered of [false, true]) await fixture(async ({ document, cache }) => {
+    const subtree = document.createElement("section");
+    subtree.innerHTML = '<link rel="alternate stylesheet"><img id="second">';
+    document.body.append(subtree);
+    const sheets = cache.get("sheets"), images = cache.get("images");
+    const link = subtree.firstChild, second = subtree.lastChild;
+    subtree.remove();
+    link.setAttribute("rel", "preload");
+    document.body.prepend(subtree);
+    if (delivered) await Bun.sleep(10);
+    expect(cache.get("sheets")).toEqual(sheets.filter(element => element !== link));
+    expect(cache.get("images")).toEqual([second, images[0]]);
+    const host = document.createElement("div");
+    document.body.append(host);
+    host.attachShadow({ mode: "open" }).append(second);
+    if (delivered) await Bun.sleep(10);
+    expect(cache.get("images")).toEqual([images[0]]);
+    document.body.append(second);
+    expect(cache.get("images")).toEqual([images[0], second]);
+  });
+});
+
+test("adopting resource subtrees updates discovery in both documents", async () => {
+  await fixture(async ({ document, cache }) => {
+    const other = parseHTMLDocument("<body></body>");
+    const next = createResourceElements(other.document);
+    try {
+      const image = cache.get("images")[0];
+      expect(next.get("images")).toEqual([]);
+      const container = document.createElement("section");
+      document.body.append(container); container.append(image);
+      cache.get("images");
+      other.document.body.append(container);
+      expect(cache.get("images")).toEqual([]);
+      expect(next.get("images")).toEqual([image]);
+      container.remove(); container.replaceChildren();
+      await Bun.sleep(10);
+      expect(next.get("images")).toEqual([]);
+    } finally { next.dispose(); await other.window.happyDOM.close(); }
+  });
+});
+
+test("foreign element tag names follow the same matching rules as discovery selectors", async () => {
+  await fixture(async ({ document, cache }) => {
+    const selectors = { media: "video, audio", images: "img", sheets: "style, link[rel~='stylesheet']", frames: "iframe" };
+    for (const kind of Object.keys(selectors)) cache.get(kind);
+    for (const namespace of ["http://www.w3.org/2000/svg", "urn:resource-test"]) {
+      for (const name of ["img", "IMG", "ImG", "x:img", "STYLE", "StYle", "LINK", "lInK", "aUdIo", "ViDeO", "IfRaMe"]) {
+        const node = document.createElementNS(namespace, name);
+        node.setAttribute("rel", "stylesheet");
+        document.body.append(node);
+        for (const [kind, selector] of Object.entries(selectors)) {
+          expect(cache.get(kind)).toEqual([...document.querySelectorAll(selector)]);
+        }
+        node.remove();
+        for (const [kind, selector] of Object.entries(selectors)) {
+          expect(cache.get(kind)).toEqual([...document.querySelectorAll(selector)]);
+        }
+      }
+    }
+  });
+});

package/test/root-self-style.test.js

@@ -0,0 +1,104 @@
+import {expect, test} from 'bun:test';
+import {parseHTMLDocument} from '../lib/happy-dom/parser.js';
+import {StyleEngine} from '../lib/style/computed-style.js';
+
+function fixture(source, sheets = []) {
+  const parsed = parseHTMLDocument(source);
+  return {...parsed, sheets, engine: new StyleEngine().compute(parsed.document, sheets)};
+}
+
+function matchesFull({document, sheets, engine}) {
+  const reference = new StyleEngine().compute(document, sheets);
+  for (const element of document.querySelectorAll('*')) {
+    expect(engine.get(element)).toEqual(reference.get(element));
+    expect(engine.customPropertiesOf(element)).toEqual(reference.customPropertiesOf(element));
+    for (const pseudo of ['before', 'after']) expect(engine.getPseudo(element, pseudo)).toEqual(reference.getPseudo(element, pseudo));
+  }
+}
+
+test('an unchanged root-only selector match does not recascade its descendants', () => {
+  const f = fixture('<html><body><div><span>content</span></div></body></html>', ['html[data-check] { opacity:1 }']);
+  try {
+    const root = f.document.documentElement;
+    const retained = [...f.document.querySelectorAll('*')].map(element => [element, f.engine.get(element)]);
+    root.setAttribute('data-check', 'ready');
+    f.engine.compute(f.document, f.sheets, {}, new Set(), new Set([root]));
+    expect(f.engine.restyled).toBe(1);
+    for (const [element, style] of retained) expect(f.engine.get(element)).toBe(style);
+    matchesFull(f);
+  } finally { f.window.happyDOM.abort(); }
+});
+
+test('an unchanged root still processes simultaneous dirty subtrees and self-only elements', () => {
+  const f = fixture('<html><body><div id="subtree"><span>first</span></div><p id="other">other</p></body></html>', ['html[data-check] { opacity:1 }']);
+  try {
+    const root = f.document.documentElement, subtree = f.document.querySelector('#subtree'), other = f.document.querySelector('#other');
+    root.setAttribute('data-check', 'ready');
+    subtree.style.color = 'red';
+    subtree.insertAdjacentHTML('beforeend', '<span>new</span>');
+    other.style.color = 'blue';
+    f.engine.compute(f.document, f.sheets, {}, new Set([subtree]), new Set([root, other]));
+    expect(f.engine.restyled).toBe(5);
+    expect(f.engine.get(subtree.lastElementChild).color).toBe('rgba(255, 0, 0, 1)');
+    expect(f.engine.get(other).color).toBe('rgba(0, 0, 255, 1)');
+    matchesFull(f);
+  } finally { f.window.happyDOM.abort(); }
+});
+
+test('root-only font changes update inherited and rem sizes using the initial root font basis', () => {
+  const f = fixture('<html style="font-size:2rem"><body><div id="child" style="width:2rem;font-size:150%">text</div></body></html>');
+  try {
+    const root = f.document.documentElement, child = f.document.querySelector('#child');
+    // Rechecking the unchanged root must not multiply 2rem by its prior 32px.
+    f.engine.compute(f.document, f.sheets, {}, new Set(), new Set([root]));
+    expect(f.engine.restyled).toBe(1);
+    expect(f.engine.get(root).fontSize).toBe(32);
+    expect(f.engine.get(child)).toMatchObject({width:64, fontSize:48});
+    root.style.fontSize = '1.5rem';
+    f.engine.compute(f.document, f.sheets, {}, new Set(), new Set([root]));
+    expect(f.engine.get(root).fontSize).toBe(24);
+    expect(f.engine.get(child)).toMatchObject({width:48, fontSize:36});
+    matchesFull(f);
+  } finally { f.window.happyDOM.abort(); }
+});
+
+test('root custom properties and explicit inheritance still recascade descendants', () => {
+  const f = fixture('<html style="--accent:red;width:120px"><body style="width:inherit"><div id="child" style="color:var(--accent);width:inherit">text</div></body></html>');
+  try {
+    const root = f.document.documentElement, child = f.document.querySelector('#child');
+    const before = f.engine.get(root);
+    root.style.setProperty('--accent', 'blue');
+    child.insertAdjacentHTML('beforeend', '<span>inserted during the root change</span>');
+    f.engine.compute(f.document, f.sheets, {}, new Set([child]), new Set([root]));
+    expect(f.engine.get(root)).toBe(before);
+    expect(f.engine.get(child).color).toBe('rgba(0, 0, 255, 1)');
+    expect(f.engine.get(child.lastElementChild).color).toBe('rgba(0, 0, 255, 1)');
+    matchesFull(f);
+    root.style.width = '200px';
+    f.engine.compute(f.document, f.sheets, {}, new Set(), new Set([root]));
+    expect(f.engine.get(child).width).toBe(200);
+    matchesFull(f);
+  } finally { f.window.happyDOM.abort(); }
+});
+
+test('a root feature used by descendant selectors keeps the subtree invalidation path', () => {
+  const f = fixture('<html><body><div class="target">text</div></body></html>', ['html.active .target { color:red }']);
+  try {
+    const root = f.document.documentElement;
+    root.className = 'active';
+    f.engine.compute(f.document, f.sheets, {}, new Set([root]), new Set([root]));
+    expect(f.engine.get(f.document.querySelector('.target')).color).toBe('rgba(255, 0, 0, 1)');
+    matchesFull(f);
+  } finally { f.window.happyDOM.abort(); }
+});
+
+test('root pseudo changes remain observable with an unchanged principal style', () => {
+  const f = fixture('<html><body><div>text</div></body></html>', ['html[data-check]::before { content:"ready";color:red }']);
+  try {
+    const root = f.document.documentElement;
+    root.setAttribute('data-check', 'ready');
+    f.engine.compute(f.document, f.sheets, {}, new Set(), new Set([root]));
+    expect(f.engine.getPseudo(root, 'before').content).toBe('ready');
+    matchesFull(f);
+  } finally { f.window.happyDOM.abort(); }
+});

package/test/script-rewrite.test.js

@@ -15,6 +15,41 @@ test("HTML comment markers in JavaScript values are escaped without changing the
   expect(Function(`${escaped}; return [a, b.test('-->'), c]`)()).toEqual(["<!-- start -->", true, "<!-- 1 -->"]);
 });
 
+test("SES preparation protects import property names while leaving dynamic imports to the loader", () => {
+  const source = `class Module {
+    static import(value) { return this.prefix + value }
+    static prefix = "class:";
+    import(value) { return value }
+  }
+  const object = { prefix: "object:", import(value) { return this.prefix + value } };
+  result = [Module . import ("a"), object. /* gap */ import /* gap */ ("b"),
+    Module.import.name, Object.hasOwn(Module, "import"), new Module().import(7)];`;
+  const code = escapeSesHtmlComments(source);
+  const result = Function(`let result; ${code}; return result`)();
+  expect(result).toEqual(["class:a", "object:b", "import", true, 7]);
+  expect(restoreSourceText(code)).toBe(source);
+  const dynamic = `import /* module */ ("./module.js"); import\n("./other.js");`;
+  expect(escapeSesHtmlComments(dynamic)).toBe(dynamic);
+});
+
+test("SES preparation preserves import.meta alongside module methods and dynamic imports", async () => {
+  const source = `const registry = { import(value) { return value + 1 } };
+    export const meta = import.meta.url;
+    export const commentedMeta = import /* keyword */ .meta.url;
+    export const result = registry.import(6);
+    export const name = registry.import.name;
+    export const dynamic = (await import("data:text/javascript,export default 9")).default;`;
+  const code = escapeSesHtmlComments(source, "module");
+  expect(code).toContain("import.meta.url");
+  expect(code).toContain("import /* keyword */ .meta.url");
+  expect(restoreSourceText(code)).toBe(source);
+  const url = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
+  const module = await import(url);
+  expect(module.meta).toContain("data:text/javascript;base64,");
+  expect(module.commentedMeta).toBe(module.meta);
+  expect([module.result, module.name, module.dynamic]).toEqual([7, "import", 9]);
+});
+
 test("constructor reads go through the helper; writes, delete and optional chains do not", () => {
   expect(rewrite("var A = Object.getPrototypeOf(async function () {}).constructor;"))
     .toBe("var A = $buninu$constructor(Object.getPrototypeOf(async function () {}));");

package/test/seccomp.test.js

@@ -7,6 +7,51 @@ const RET_ALLOW = 0x7fff0000;
 const RET_EPERM = 0x00050001;
 const RET_ENOSYS = 0x00050026;
 
+// Execute the encoded classic-BPF instructions against a seccomp_data record.
+// This checks actual jump destinations and argument loads, including the
+// architecture we cannot install on the current test machine.
+function filterVerdict(program, arch, syscall, args = []) {
+  const code = new DataView(encodeFilter(program)), data = new DataView(new ArrayBuffer(64));
+  data.setUint32(0, SYSCALL_NUMBERS[arch][syscall], true);
+  data.setUint32(4, arch === "x64" ? 0xc000003e : 0xc00000b7, true);
+  args.forEach((value, index) => data.setBigUint64(16 + index * 8, BigInt.asUintN(64, BigInt(value)), true));
+  let accumulator = 0, pc = 0;
+  for (let steps = 0; steps < program.length; steps++) {
+    const offset = pc * 8, op = code.getUint16(offset, true), value = code.getUint32(offset + 4, true);
+    const yes = code.getUint8(offset + 2), no = code.getUint8(offset + 3);
+    switch (op) {
+      case 0x20: accumulator = data.getUint32(value, true); pc++; break;
+      case 0x15: pc += 1 + (accumulator === value ? yes : no); break;
+      case 0x35: pc += 1 + (accumulator >= value ? yes : no); break;
+      case 0x45: pc += 1 + ((accumulator & value) !== 0 ? yes : no); break;
+      case RET: return value;
+      default: throw new Error(`unsupported BPF opcode ${op}`);
+    }
+  }
+  throw new Error("filter did not return a verdict");
+}
+
+test("signal filters allow this process but never let tkill target an arbitrary thread", () => {
+  const pid = 1234;
+  for (const arch of ["x64", "arm64"]) {
+    // Even explicitly including the signal syscalls in the unconditional
+    // allowlist must not bypass their target checks.
+    for (const allowed of [ALLOWED_SYSCALLS, [...ALLOWED_SYSCALLS, "kill", "tkill", "tgkill"]]) {
+      const program = buildFilter(arch, pid, allowed);
+      for (const name of ["kill", "tkill", "tgkill"]) {
+        expect(filterVerdict(program, arch, name, [pid, 0, 0])).toBe(RET_ALLOW);
+        for (const other of [pid + 1, 1, 0, -1]) {
+          expect(filterVerdict(program, arch, name, [other, 0, 0])).toBe(RET_EPERM);
+        }
+        expect(program.filter(([op, , , value]) => op === 0x15 && value === SYSCALL_NUMBERS[arch][name])).toHaveLength(1);
+      }
+      // Exercise the syscall-number reload after the restricted signal blocks.
+      expect(filterVerdict(program, arch, "read")).toBe(RET_ALLOW);
+      expect(filterVerdict(program, arch, "openat")).toBe(RET_EPERM);
+    }
+  }
+});
+
 test("builds an allowlist program that checks the architecture first and denies by default", () => {
   for (const arch of ["x64", "arm64"]) {
     const program = buildFilter(arch, 1234);

package/test/spare-renderer-scheduling.test.js

@@ -0,0 +1,8 @@
+import {test,expect} from 'bun:test';
+
+test('spare warmup follows document load with bounded fallback and safe cancellation',async()=>{
+  const child=Bun.spawn([process.execPath,new URL('./fixtures/spare-renderer-scheduling.js',import.meta.url).pathname],{stdout:'pipe',stderr:'pipe'});
+  const [out,error,code]=await Promise.all([new Response(child.stdout).text(),new Response(child.stderr).text(),child.exited]);
+  expect({code,error}).toEqual({code:0,error:''});
+  expect(out).toContain('spare scheduling lifecycle, isolation, cancellation and failure checks passed');
+},15000);