buninu-browser 0.5.0 → 0.6.0

package/test/fixtures/node-iterator-cases.js

@@ -0,0 +1,59 @@
+// Runs unchanged in the renderer and Chromium; keep this function standalone.
+export function nodeIteratorCases() {
+  const results = [];
+  const label = n => n ? n.id || n.nodeName : null;
+  for (const tag of ['div', 'form', 'select'])
+    for (const operation of ['remove', 'replace', 'replaceWith', 'self', 'sibling', 'fragment', 'descendant', 'multiple'])
+      for (const position of [0, 1, 2, 3]) for (const before of [false, true]) {
+        const root = document.createElement(tag);root.id = 'root';
+        for (const id of ['a', 'b']) {
+          const node = document.createElement('option');node.id = id;root.append(node);
+        }
+        const nested = document.createElement('span');nested.id = 'nested';root.firstChild.append(nested);
+        const it = document.createNodeIterator(root, 1);
+        for (let i = 0; i <= position; i++) it.nextNode();
+        if (before) it.previousNode();
+        const old = root.firstChild, x = document.createElement('em');x.id = 'x';
+        if (operation === 'remove') old.remove();
+        if (operation === 'replace') root.replaceChild(x, old);
+        if (operation === 'replaceWith') old.replaceWith(x);
+        if (operation === 'self') root.replaceChild(old, old);
+        if (operation === 'sibling') root.replaceChild(root.lastChild, old);
+        if (operation === 'descendant') root.replaceChild(nested, old);
+        if (operation === 'fragment') {
+          const fragment = document.createDocumentFragment();fragment.append(x);
+          const y = document.createElement('em');y.id = 'y';fragment.append(y);
+          root.replaceChild(fragment, old);
+        }
+        if (operation === 'multiple') old.replaceWith(x, old, root.lastChild);
+        results.push([tag, operation, position, before, label(it.referenceNode),
+          it.pointerBeforeReferenceNode, label(it.nextNode()), label(it.previousNode()),
+          [...root.childNodes].map(label).join(',')]);
+      }
+  for (const whatToShow of [0, 1, -1, 4294967297, NaN, Infinity, '1', null, 1n, Object(1n), Symbol('x')]) {
+    try { results.push(['mask', String(whatToShow), document.createNodeIterator(document.body, whatToShow).whatToShow]); }
+    catch (e) { results.push(['mask', String(whatToShow), e.name]); }
+  }
+  for (const verdict of [1, 65537, -65535, NaN, Infinity, '1', null, 1n, Object(1n), Symbol('x')]) {
+    try { results.push(['filter', String(verdict), !!document.createNodeIterator(document.body, 1, () => verdict).nextNode()]); }
+    catch (e) { results.push(['filter', String(verdict), e.name]); }
+  }
+  // Filtering and root types: rejection must not prune descendants.
+  for (const rootKind of ['element', 'fragment', 'text', 'comment', 'doctype'])
+    for (const mask of [0, 1, 4, 128, 0xffffffff]) for (const mode of ['accept', 'reject', 'skip', 'alternating']) {
+      const root = rootKind === 'fragment' ? document.createDocumentFragment()
+        : rootKind === 'text' ? document.createTextNode('text')
+        : rootKind === 'comment' ? document.createComment('comment')
+        : rootKind === 'doctype' ? document.implementation.createDocumentType('html', '', '') : document.createElement('div');
+      if (rootKind === 'element' || rootKind === 'fragment') {
+        const child = document.createElement('b');child.append('text');root.append(child, document.createComment('comment'));
+      }
+      const it = document.createNodeIterator(root, mask, n => mode === 'accept' ? 1
+        : mode === 'reject' ? 2 : mode === 'skip' ? 3 : n.nodeType === 1 ? 2 : 1);
+      const forward = [], backward = [];
+      for (let n; (n = it.nextNode());) forward.push(n.nodeType);
+      for (let n; (n = it.previousNode());) backward.push(n.nodeType);
+      results.push(['walk', rootKind, mask, mode, forward.join(','), backward.join(',')]);
+    }
+  return results;
+}

package/test/fixtures/node-iterator-chromium.json

@@ -0,0 +1,315 @@
+[
+  ["div","remove",0,false,"root",false,"b","b","b"],
+  ["div","remove",0,true,"root",true,"root","root","b"],
+  ["div","remove",1,false,"root",false,"b","b","b"],
+  ["div","remove",1,true,"b",true,"b","b","b"],
+  ["div","remove",2,false,"root",false,"b","b","b"],
+  ["div","remove",2,true,"b",true,"b","b","b"],
+  ["div","remove",3,false,"b",false,null,"b","b"],
+  ["div","remove",3,true,"b",true,"b","b","b"],
+  ["div","replace",0,false,"root",false,"x","x","x,b"],
+  ["div","replace",0,true,"root",true,"root","root","x,b"],
+  ["div","replace",1,false,"root",false,"x","x","x,b"],
+  ["div","replace",1,true,"b",true,"b","b","x,b"],
+  ["div","replace",2,false,"root",false,"x","x","x,b"],
+  ["div","replace",2,true,"b",true,"b","b","x,b"],
+  ["div","replace",3,false,"b",false,null,"b","x,b"],
+  ["div","replace",3,true,"b",true,"b","b","x,b"],
+  ["div","replaceWith",0,false,"root",false,"x","x","x,b"],
+  ["div","replaceWith",0,true,"root",true,"root","root","x,b"],
+  ["div","replaceWith",1,false,"root",false,"x","x","x,b"],
+  ["div","replaceWith",1,true,"b",true,"b","b","x,b"],
+  ["div","replaceWith",2,false,"root",false,"x","x","x,b"],
+  ["div","replaceWith",2,true,"b",true,"b","b","x,b"],
+  ["div","replaceWith",3,false,"b",false,null,"b","x,b"],
+  ["div","replaceWith",3,true,"b",true,"b","b","x,b"],
+  ["div","self",0,false,"root",false,"a","a","a,b"],
+  ["div","self",0,true,"root",true,"root","root","a,b"],
+  ["div","self",1,false,"root",false,"a","a","a,b"],
+  ["div","self",1,true,"b",true,"b","b","a,b"],
+  ["div","self",2,false,"root",false,"a","a","a,b"],
+  ["div","self",2,true,"b",true,"b","b","a,b"],
+  ["div","self",3,false,"b",false,null,"b","a,b"],
+  ["div","self",3,true,"b",true,"b","b","a,b"],
+  ["div","sibling",0,false,"root",false,"b","b","b"],
+  ["div","sibling",0,true,"root",true,"root","root","b"],
+  ["div","sibling",1,false,"root",false,"b","b","b"],
+  ["div","sibling",1,true,"a",true,"a","a","b"],
+  ["div","sibling",2,false,"root",false,"b","b","b"],
+  ["div","sibling",2,true,"nested",true,"nested","nested","b"],
+  ["div","sibling",3,false,"root",false,"b","b","b"],
+  ["div","sibling",3,true,"root",false,"b","b","b"],
+  ["div","fragment",0,false,"root",false,"x","x","x,y,b"],
+  ["div","fragment",0,true,"root",true,"root","root","x,y,b"],
+  ["div","fragment",1,false,"root",false,"x","x","x,y,b"],
+  ["div","fragment",1,true,"b",true,"b","b","x,y,b"],
+  ["div","fragment",2,false,"root",false,"x","x","x,y,b"],
+  ["div","fragment",2,true,"b",true,"b","b","x,y,b"],
+  ["div","fragment",3,false,"b",false,null,"b","x,y,b"],
+  ["div","fragment",3,true,"b",true,"b","b","x,y,b"],
+  ["div","descendant",0,false,"root",false,"nested","nested","nested,b"],
+  ["div","descendant",0,true,"root",true,"root","root","nested,b"],
+  ["div","descendant",1,false,"root",false,"nested","nested","nested,b"],
+  ["div","descendant",1,true,"b",true,"b","b","nested,b"],
+  ["div","descendant",2,false,"root",false,"nested","nested","nested,b"],
+  ["div","descendant",2,true,"b",true,"b","b","nested,b"],
+  ["div","descendant",3,false,"b",false,null,"b","nested,b"],
+  ["div","descendant",3,true,"b",true,"b","b","nested,b"],
+  ["div","multiple",0,false,"root",false,"x","x","x,a,b"],
+  ["div","multiple",0,true,"root",true,"root","root","x,a,b"],
+  ["div","multiple",1,false,"root",false,"x","x","x,a,b"],
+  ["div","multiple",1,true,"root",false,"x","x","x,a,b"],
+  ["div","multiple",2,false,"root",false,"x","x","x,a,b"],
+  ["div","multiple",2,true,"root",false,"x","x","x,a,b"],
+  ["div","multiple",3,false,"root",false,"x","x","x,a,b"],
+  ["div","multiple",3,true,"root",false,"x","x","x,a,b"],
+  ["form","remove",0,false,"root",false,"b","b","b"],
+  ["form","remove",0,true,"root",true,"root","root","b"],
+  ["form","remove",1,false,"root",false,"b","b","b"],
+  ["form","remove",1,true,"b",true,"b","b","b"],
+  ["form","remove",2,false,"root",false,"b","b","b"],
+  ["form","remove",2,true,"b",true,"b","b","b"],
+  ["form","remove",3,false,"b",false,null,"b","b"],
+  ["form","remove",3,true,"b",true,"b","b","b"],
+  ["form","replace",0,false,"root",false,"x","x","x,b"],
+  ["form","replace",0,true,"root",true,"root","root","x,b"],
+  ["form","replace",1,false,"root",false,"x","x","x,b"],
+  ["form","replace",1,true,"b",true,"b","b","x,b"],
+  ["form","replace",2,false,"root",false,"x","x","x,b"],
+  ["form","replace",2,true,"b",true,"b","b","x,b"],
+  ["form","replace",3,false,"b",false,null,"b","x,b"],
+  ["form","replace",3,true,"b",true,"b","b","x,b"],
+  ["form","replaceWith",0,false,"root",false,"x","x","x,b"],
+  ["form","replaceWith",0,true,"root",true,"root","root","x,b"],
+  ["form","replaceWith",1,false,"root",false,"x","x","x,b"],
+  ["form","replaceWith",1,true,"b",true,"b","b","x,b"],
+  ["form","replaceWith",2,false,"root",false,"x","x","x,b"],
+  ["form","replaceWith",2,true,"b",true,"b","b","x,b"],
+  ["form","replaceWith",3,false,"b",false,null,"b","x,b"],
+  ["form","replaceWith",3,true,"b",true,"b","b","x,b"],
+  ["form","self",0,false,"root",false,"a","a","a,b"],
+  ["form","self",0,true,"root",true,"root","root","a,b"],
+  ["form","self",1,false,"root",false,"a","a","a,b"],
+  ["form","self",1,true,"b",true,"b","b","a,b"],
+  ["form","self",2,false,"root",false,"a","a","a,b"],
+  ["form","self",2,true,"b",true,"b","b","a,b"],
+  ["form","self",3,false,"b",false,null,"b","a,b"],
+  ["form","self",3,true,"b",true,"b","b","a,b"],
+  ["form","sibling",0,false,"root",false,"b","b","b"],
+  ["form","sibling",0,true,"root",true,"root","root","b"],
+  ["form","sibling",1,false,"root",false,"b","b","b"],
+  ["form","sibling",1,true,"a",true,"a","a","b"],
+  ["form","sibling",2,false,"root",false,"b","b","b"],
+  ["form","sibling",2,true,"nested",true,"nested","nested","b"],
+  ["form","sibling",3,false,"root",false,"b","b","b"],
+  ["form","sibling",3,true,"root",false,"b","b","b"],
+  ["form","fragment",0,false,"root",false,"x","x","x,y,b"],
+  ["form","fragment",0,true,"root",true,"root","root","x,y,b"],
+  ["form","fragment",1,false,"root",false,"x","x","x,y,b"],
+  ["form","fragment",1,true,"b",true,"b","b","x,y,b"],
+  ["form","fragment",2,false,"root",false,"x","x","x,y,b"],
+  ["form","fragment",2,true,"b",true,"b","b","x,y,b"],
+  ["form","fragment",3,false,"b",false,null,"b","x,y,b"],
+  ["form","fragment",3,true,"b",true,"b","b","x,y,b"],
+  ["form","descendant",0,false,"root",false,"nested","nested","nested,b"],
+  ["form","descendant",0,true,"root",true,"root","root","nested,b"],
+  ["form","descendant",1,false,"root",false,"nested","nested","nested,b"],
+  ["form","descendant",1,true,"b",true,"b","b","nested,b"],
+  ["form","descendant",2,false,"root",false,"nested","nested","nested,b"],
+  ["form","descendant",2,true,"b",true,"b","b","nested,b"],
+  ["form","descendant",3,false,"b",false,null,"b","nested,b"],
+  ["form","descendant",3,true,"b",true,"b","b","nested,b"],
+  ["form","multiple",0,false,"root",false,"x","x","x,a,b"],
+  ["form","multiple",0,true,"root",true,"root","root","x,a,b"],
+  ["form","multiple",1,false,"root",false,"x","x","x,a,b"],
+  ["form","multiple",1,true,"root",false,"x","x","x,a,b"],
+  ["form","multiple",2,false,"root",false,"x","x","x,a,b"],
+  ["form","multiple",2,true,"root",false,"x","x","x,a,b"],
+  ["form","multiple",3,false,"root",false,"x","x","x,a,b"],
+  ["form","multiple",3,true,"root",false,"x","x","x,a,b"],
+  ["select","remove",0,false,"root",false,"b","b","b"],
+  ["select","remove",0,true,"root",true,"root","root","b"],
+  ["select","remove",1,false,"root",false,"b","b","b"],
+  ["select","remove",1,true,"b",true,"b","b","b"],
+  ["select","remove",2,false,"root",false,"b","b","b"],
+  ["select","remove",2,true,"b",true,"b","b","b"],
+  ["select","remove",3,false,"b",false,null,"b","b"],
+  ["select","remove",3,true,"b",true,"b","b","b"],
+  ["select","replace",0,false,"root",false,"x","x","x,b"],
+  ["select","replace",0,true,"root",true,"root","root","x,b"],
+  ["select","replace",1,false,"root",false,"x","x","x,b"],
+  ["select","replace",1,true,"b",true,"b","b","x,b"],
+  ["select","replace",2,false,"root",false,"x","x","x,b"],
+  ["select","replace",2,true,"b",true,"b","b","x,b"],
+  ["select","replace",3,false,"b",false,null,"b","x,b"],
+  ["select","replace",3,true,"b",true,"b","b","x,b"],
+  ["select","replaceWith",0,false,"root",false,"x","x","x,b"],
+  ["select","replaceWith",0,true,"root",true,"root","root","x,b"],
+  ["select","replaceWith",1,false,"root",false,"x","x","x,b"],
+  ["select","replaceWith",1,true,"b",true,"b","b","x,b"],
+  ["select","replaceWith",2,false,"root",false,"x","x","x,b"],
+  ["select","replaceWith",2,true,"b",true,"b","b","x,b"],
+  ["select","replaceWith",3,false,"b",false,null,"b","x,b"],
+  ["select","replaceWith",3,true,"b",true,"b","b","x,b"],
+  ["select","self",0,false,"root",false,"a","a","a,b"],
+  ["select","self",0,true,"root",true,"root","root","a,b"],
+  ["select","self",1,false,"root",false,"a","a","a,b"],
+  ["select","self",1,true,"b",true,"b","b","a,b"],
+  ["select","self",2,false,"root",false,"a","a","a,b"],
+  ["select","self",2,true,"b",true,"b","b","a,b"],
+  ["select","self",3,false,"b",false,null,"b","a,b"],
+  ["select","self",3,true,"b",true,"b","b","a,b"],
+  ["select","sibling",0,false,"root",false,"b","b","b"],
+  ["select","sibling",0,true,"root",true,"root","root","b"],
+  ["select","sibling",1,false,"root",false,"b","b","b"],
+  ["select","sibling",1,true,"a",true,"a","a","b"],
+  ["select","sibling",2,false,"root",false,"b","b","b"],
+  ["select","sibling",2,true,"nested",true,"nested","nested","b"],
+  ["select","sibling",3,false,"root",false,"b","b","b"],
+  ["select","sibling",3,true,"root",false,"b","b","b"],
+  ["select","fragment",0,false,"root",false,"x","x","x,y,b"],
+  ["select","fragment",0,true,"root",true,"root","root","x,y,b"],
+  ["select","fragment",1,false,"root",false,"x","x","x,y,b"],
+  ["select","fragment",1,true,"b",true,"b","b","x,y,b"],
+  ["select","fragment",2,false,"root",false,"x","x","x,y,b"],
+  ["select","fragment",2,true,"b",true,"b","b","x,y,b"],
+  ["select","fragment",3,false,"b",false,null,"b","x,y,b"],
+  ["select","fragment",3,true,"b",true,"b","b","x,y,b"],
+  ["select","descendant",0,false,"root",false,"nested","nested","nested,b"],
+  ["select","descendant",0,true,"root",true,"root","root","nested,b"],
+  ["select","descendant",1,false,"root",false,"nested","nested","nested,b"],
+  ["select","descendant",1,true,"b",true,"b","b","nested,b"],
+  ["select","descendant",2,false,"root",false,"nested","nested","nested,b"],
+  ["select","descendant",2,true,"b",true,"b","b","nested,b"],
+  ["select","descendant",3,false,"b",false,null,"b","nested,b"],
+  ["select","descendant",3,true,"b",true,"b","b","nested,b"],
+  ["select","multiple",0,false,"root",false,"x","x","x,a,b"],
+  ["select","multiple",0,true,"root",true,"root","root","x,a,b"],
+  ["select","multiple",1,false,"root",false,"x","x","x,a,b"],
+  ["select","multiple",1,true,"root",false,"x","x","x,a,b"],
+  ["select","multiple",2,false,"root",false,"x","x","x,a,b"],
+  ["select","multiple",2,true,"root",false,"x","x","x,a,b"],
+  ["select","multiple",3,false,"root",false,"x","x","x,a,b"],
+  ["select","multiple",3,true,"root",false,"x","x","x,a,b"],
+  ["mask","0",0],
+  ["mask","1",1],
+  ["mask","-1",4294967295],
+  ["mask","4294967297",1],
+  ["mask","NaN",0],
+  ["mask","Infinity",0],
+  ["mask","1",1],
+  ["mask","null",0],
+  ["mask","1","TypeError"],
+  ["mask","1","TypeError"],
+  ["mask","Symbol(x)","TypeError"],
+  ["filter","1",true],
+  ["filter","65537",true],
+  ["filter","-65535",true],
+  ["filter","NaN",false],
+  ["filter","Infinity",false],
+  ["filter","1",true],
+  ["filter","null",false],
+  ["filter","1","TypeError"],
+  ["filter","1","TypeError"],
+  ["filter","Symbol(x)","TypeError"],
+  ["walk","element",0,"accept","",""],
+  ["walk","element",0,"reject","",""],
+  ["walk","element",0,"skip","",""],
+  ["walk","element",0,"alternating","",""],
+  ["walk","element",1,"accept","1,1","1,1"],
+  ["walk","element",1,"reject","",""],
+  ["walk","element",1,"skip","",""],
+  ["walk","element",1,"alternating","",""],
+  ["walk","element",4,"accept","3","3"],
+  ["walk","element",4,"reject","",""],
+  ["walk","element",4,"skip","",""],
+  ["walk","element",4,"alternating","3","3"],
+  ["walk","element",128,"accept","8","8"],
+  ["walk","element",128,"reject","",""],
+  ["walk","element",128,"skip","",""],
+  ["walk","element",128,"alternating","8","8"],
+  ["walk","element",4294967295,"accept","1,1,3,8","8,3,1,1"],
+  ["walk","element",4294967295,"reject","",""],
+  ["walk","element",4294967295,"skip","",""],
+  ["walk","element",4294967295,"alternating","3,8","8,3"],
+  ["walk","fragment",0,"accept","",""],
+  ["walk","fragment",0,"reject","",""],
+  ["walk","fragment",0,"skip","",""],
+  ["walk","fragment",0,"alternating","",""],
+  ["walk","fragment",1,"accept","1","1"],
+  ["walk","fragment",1,"reject","",""],
+  ["walk","fragment",1,"skip","",""],
+  ["walk","fragment",1,"alternating","",""],
+  ["walk","fragment",4,"accept","3","3"],
+  ["walk","fragment",4,"reject","",""],
+  ["walk","fragment",4,"skip","",""],
+  ["walk","fragment",4,"alternating","3","3"],
+  ["walk","fragment",128,"accept","8","8"],
+  ["walk","fragment",128,"reject","",""],
+  ["walk","fragment",128,"skip","",""],
+  ["walk","fragment",128,"alternating","8","8"],
+  ["walk","fragment",4294967295,"accept","11,1,3,8","8,3,1,11"],
+  ["walk","fragment",4294967295,"reject","",""],
+  ["walk","fragment",4294967295,"skip","",""],
+  ["walk","fragment",4294967295,"alternating","11,3,8","8,3,11"],
+  ["walk","text",0,"accept","",""],
+  ["walk","text",0,"reject","",""],
+  ["walk","text",0,"skip","",""],
+  ["walk","text",0,"alternating","",""],
+  ["walk","text",1,"accept","",""],
+  ["walk","text",1,"reject","",""],
+  ["walk","text",1,"skip","",""],
+  ["walk","text",1,"alternating","",""],
+  ["walk","text",4,"accept","3","3"],
+  ["walk","text",4,"reject","",""],
+  ["walk","text",4,"skip","",""],
+  ["walk","text",4,"alternating","3","3"],
+  ["walk","text",128,"accept","",""],
+  ["walk","text",128,"reject","",""],
+  ["walk","text",128,"skip","",""],
+  ["walk","text",128,"alternating","",""],
+  ["walk","text",4294967295,"accept","3","3"],
+  ["walk","text",4294967295,"reject","",""],
+  ["walk","text",4294967295,"skip","",""],
+  ["walk","text",4294967295,"alternating","3","3"],
+  ["walk","comment",0,"accept","",""],
+  ["walk","comment",0,"reject","",""],
+  ["walk","comment",0,"skip","",""],
+  ["walk","comment",0,"alternating","",""],
+  ["walk","comment",1,"accept","",""],
+  ["walk","comment",1,"reject","",""],
+  ["walk","comment",1,"skip","",""],
+  ["walk","comment",1,"alternating","",""],
+  ["walk","comment",4,"accept","",""],
+  ["walk","comment",4,"reject","",""],
+  ["walk","comment",4,"skip","",""],
+  ["walk","comment",4,"alternating","",""],
+  ["walk","comment",128,"accept","8","8"],
+  ["walk","comment",128,"reject","",""],
+  ["walk","comment",128,"skip","",""],
+  ["walk","comment",128,"alternating","8","8"],
+  ["walk","comment",4294967295,"accept","8","8"],
+  ["walk","comment",4294967295,"reject","",""],
+  ["walk","comment",4294967295,"skip","",""],
+  ["walk","comment",4294967295,"alternating","8","8"],
+  ["walk","doctype",0,"accept","",""],
+  ["walk","doctype",0,"reject","",""],
+  ["walk","doctype",0,"skip","",""],
+  ["walk","doctype",0,"alternating","",""],
+  ["walk","doctype",1,"accept","",""],
+  ["walk","doctype",1,"reject","",""],
+  ["walk","doctype",1,"skip","",""],
+  ["walk","doctype",1,"alternating","",""],
+  ["walk","doctype",4,"accept","",""],
+  ["walk","doctype",4,"reject","",""],
+  ["walk","doctype",4,"skip","",""],
+  ["walk","doctype",4,"alternating","",""],
+  ["walk","doctype",128,"accept","",""],
+  ["walk","doctype",128,"reject","",""],
+  ["walk","doctype",128,"skip","",""],
+  ["walk","doctype",128,"alternating","",""],
+  ["walk","doctype",4294967295,"accept","10","10"],
+  ["walk","doctype",4294967295,"reject","",""],
+  ["walk","doctype",4294967295,"skip","",""],
+  ["walk","doctype",4294967295,"alternating","10","10"]
+]

package/test/fixtures/observer-invalidation.js

@@ -0,0 +1,105 @@
+// Host scripting and the style-read counter stay outside the test runner.
+import { strict as assert } from "node:assert";
+import { createPageRenderer } from "../../lib/renderer/page-renderer.js";
+import { nodeOf } from "../../lib/renderer/bindings.js";
+import { StyleEngine } from "../../lib/style/computed-style.js";
+
+const font = await Bun.file(new URL("../../usr/share/fonts/DejaVuSansMono.ttf", import.meta.url)).bytes();
+const sleep = Bun.sleep;
+let finishFont;
+const fontResponse = new Promise(resolve => { finishFont = resolve; });
+const renderer = await createPageRenderer({
+  fetchResource: async url => ({ ok: false, status: 404, url, body: new Uint8Array() }),
+  pageFetch: () => fontResponse,
+});
+const evaluate = code => renderer.evaluate(code);
+const eventually = async (code, check, message) => {
+  for (let attempt = 0; attempt < 100; attempt++) {
+    const value = await evaluate(code);
+    if (check(value)) return value;
+    await sleep(10);
+  }
+  assert.fail(message);
+};
+const originalGet = StyleEngine.prototype.get;
+try {
+  renderer.resize(400, 300, 1);
+  renderer.setScripting("host");
+  await renderer.loadDocument({ url: "https://observer.test/", contentType: "text/html", source: `<!doctype html>
+    <style id=sheet>body{margin:0}#box{width:100px;height:50px}
+      body[data-wide] #box{width:175px}
+      #viewport{width:50%;height:10px}
+      #scroller{position:absolute;top:80px;width:100px;height:100px;overflow:auto}
+      #inside{position:absolute;top:150px;width:20px;height:20px}
+      #below{position:absolute;top:500px;width:20px;height:20px}</style>
+    <div id=box></div><div id=viewport></div>
+    <div id=scroller><div style="position:relative;height:300px"><div id=inside></div></div></div>
+    <div id=below></div><div style="height:1000px"></div>` });
+  await renderer.whenLoaded();
+  await evaluate(`window.box=document.getElementById('box');window.sizes=[];window.intersections=[];
+    window.ro=new ResizeObserver(entries=>sizes.push(entries[0].contentRect.width));ro.observe(box);
+    window.io=new IntersectionObserver(entries=>intersections.push(entries[0].isIntersecting));io.observe(box);`);
+  await eventually("sizes.length===1&&intersections.length===1", Boolean, "initial observers should be delivered");
+  // Consume initial focus bookkeeping, then count actual style measurements
+  // of the observed box. Reading body geometry itself cannot touch this box.
+  await evaluate("document.body.setAttribute('data-warm','1');document.body.clientWidth");
+  await sleep(40);
+  const target = nodeOf(globalThis.document.getElementById("box"));
+  let measurements = 0;
+  StyleEngine.prototype.get = function (element) {
+    if (element === target) measurements++;
+    return originalGet.call(this, element);
+  };
+  for (let i = 0; i < 5; i++) {
+    await evaluate(`document.body.setAttribute('data-counter','${i}');document.body.clientWidth`);
+    await sleep(30);
+  }
+  assert.equal(measurements, 0, "metadata flushes must not remeasure unchanged observer targets");
+  assert.deepEqual(await evaluate("[sizes,intersections]"), [[100], [true]]);
+  StyleEngine.prototype.get = originalGet;
+
+  // observe() itself still queues a first measurement without a new version.
+  await evaluate("window.newSizes=[];window.newRO=new ResizeObserver(e=>newSizes.push(e[0].contentRect.width));newRO.observe(box)");
+  await eventually("newSizes[0]", value => value === 100, "new observers must not wait for invalidation");
+  await evaluate("box.style.width='150px';document.body.clientWidth");
+  await eventually("sizes.at(-1)", value => value === 150, "inline size changes must notify");
+  await evaluate("box.style.width='';document.body.setAttribute('data-wide','');document.body.clientWidth");
+  await eventually("sizes.at(-1)", value => value === 175, "selector-observed metadata must still invalidate");
+  await evaluate("document.getElementById('sheet').textContent+='body[data-wide] #box{width:190px}';document.body.clientWidth");
+  await eventually("sizes.at(-1)", value => value === 190, "stylesheet changes must notify");
+
+  await evaluate(`window.insideChanges=[];window.belowChanges=[];window.viewportSizes=[];window.deviceSizes=[];
+    window.insideIO=new IntersectionObserver(e=>insideChanges.push(e[0].isIntersecting));insideIO.observe(document.getElementById('inside'));
+    window.belowIO=new IntersectionObserver(e=>belowChanges.push(e[0].isIntersecting));belowIO.observe(document.getElementById('below'));
+    window.viewportRO=new ResizeObserver(e=>viewportSizes.push(e[0].contentRect.width));viewportRO.observe(document.getElementById('viewport'));
+    window.deviceRO=new ResizeObserver(e=>deviceSizes.push(e[0].devicePixelContentBoxSize[0].inlineSize));deviceRO.observe(box,{box:'device-pixel-content-box'});`);
+  await eventually("insideChanges.length===1&&belowChanges.length===1&&viewportSizes.length===1&&deviceSizes.length===1", Boolean,
+    "scroll/viewport observers should be initialized");
+  assert.deepEqual(await evaluate("[insideChanges,belowChanges,viewportSizes,deviceSizes]"), [[false], [false], [200], [190]]);
+  await evaluate("document.getElementById('scroller').scrollTop=100");
+  await eventually("insideChanges.at(-1)", Boolean, "element scrolling must notify");
+  renderer.scrollTo(0, 450);
+  await eventually("belowChanges.at(-1)", Boolean, "viewport scrolling must notify");
+  renderer.scrollTo(0, 0);
+  renderer.resize(400, 300, 2);
+  await eventually("deviceSizes.at(-1)", value => value === 380, "DPR-only changes must notify without layout invalidation");
+  renderer.resize(600, 300, 2);
+  await eventually("viewportSizes.at(-1)", value => value === 300, "viewport resizing must notify");
+  await evaluate("box.remove();document.body.clientWidth");
+  await eventually("sizes.at(-1)===0&&intersections.at(-1)===false", Boolean, "removing a target must notify");
+  await evaluate("document.body.prepend(box);document.body.clientWidth");
+  await eventually("sizes.at(-1)===190&&intersections.at(-1)===true", Boolean, "reattaching a target must notify");
+
+  // Font completion is a resource invalidation even with no DOM mutation.
+  await evaluate(`document.body.insertAdjacentHTML('beforeend',
+    '<span id=text style="display:inline-block;font-family:ObserverMono,sans-serif;font-size:30px">iiii</span>')`);
+  await evaluate("window.fontSizes=[];window.fontRO=new ResizeObserver(e=>fontSizes.push(e[0].contentRect.width));fontRO.observe(document.getElementById('text'))");
+  const before = await eventually("fontSizes[0]", value => value > 0, "fallback font should be measured");
+  await evaluate(`document.getElementById('sheet').textContent+='@font-face{font-family:ObserverMono;src:url(/font.ttf)}';document.body.clientWidth`);
+  finishFont({ status: 200, body: font });
+  await eventually("fontSizes.at(-1)", value => value > before * 2, "loaded font metrics must notify");
+  process.stdout.write("observer invalidation integration passed\n");
+} finally {
+  StyleEngine.prototype.get = originalGet;
+  renderer.dispose();
+}

package/test/fixtures/prepaint-scheduling.js

@@ -0,0 +1,73 @@
+// Host scripting installs browser globals, so each scenario runs separately.
+import {strict as assert} from 'node:assert';
+import {createPageRenderer} from '../../lib/renderer/page-renderer.js';
+
+const scenario = process.argv[2];
+const frames = [], errors = [], videos = [];
+let finishScript;
+const pendingScript = new Promise(resolve => { finishScript = resolve; });
+const renderer = await createPageRenderer({
+  renderMinInterval: 180,
+  onFrame: ({tile}) => frames.push(tile),
+  onVideo: message => videos.push(message),
+  reportError: error => errors.push(String(error)),
+  fetchResource: async url => {
+    if (url.endsWith('slow.js')) await pendingScript;
+    return {ok:true, url, body:new Uint8Array([32]), contentType:url.endsWith('.js') ? 'text/javascript' : 'video/mp4'};
+  },
+  videoDecoder: {
+    probe: async () => ({duration:10, video:{width:20, height:12}}),
+    decode: async () => ({width:20, height:12, fps:30,
+      nextFrame(w,h) { return new Uint8Array(w*h*4).fill(255); }, seek() {}, close() {}}),
+  },
+});
+
+try {
+  renderer.resize(64,36,1);
+  renderer.setScripting('host');
+  frames.length = 0;
+  const loading = scenario.startsWith('loading');
+  const media = scenario === 'video';
+  await renderer.loadDocument({url:'https://prepaint.test/', contentType:'text/html',
+    source:'<style>body{margin:0}#marker{height:500px;background:red}video{display:block;width:20px;height:12px}</style>'
+      + (media ? '<video id=v src="clip.mp4"></video>' : '') + '<div id=marker></div>'
+      + (loading ? '<script src="slow.js"></script>' : '')});
+
+  if (loading) {
+    await Bun.sleep(400);
+    assert(frames.length > 0);
+    assert(frames.every(tile => tile.height === 36), 'pending scripts must not expand an already visible tile');
+    if (scenario === 'loading-scroll') {
+      renderer.applyCompositorScroll(0,140);
+      await Bun.sleep(90);
+      assert(frames.some(tile => tile.y <= 140 && tile.y+tile.height >= 176),
+        'scrolling beyond the old tile must still paint while loading');
+    }
+    finishScript();
+    await renderer.whenLoaded();
+    // The script has no visual effect: refresh need not call render. The
+    // deferred prepaint still needs to wake and expand the unchanged tile.
+    await Bun.sleep(550);
+    assert(frames.some(tile => tile.height > 36), 'prepaint resumes after a no-op load settles');
+  } else {
+    await renderer.whenLoaded();
+    if (media) {
+      await renderer.evaluate('document.getElementById("v").play()');
+      await Bun.sleep(400);
+      assert(videos.some(message => message.type === 'video-open'));
+      assert(frames.some(tile => tile.height > 36 && tile.videoLayer),
+        'independent video playback alone must not block idle prepaint');
+    } else {
+      await renderer.evaluate('setTimeout(()=>document.documentElement.setAttribute("data-bookkeeping","changed"),1)');
+      await Bun.sleep(80);
+      assert(frames.every(tile => tile.height === 36), 'pending frame takes priority over speculative raster');
+      await Bun.sleep(550);
+      assert(frames.some(tile => tile.height > 36), 'prepaint resumes after a queued no-op frame');
+    }
+  }
+  assert.deepEqual(errors, []);
+  process.stdout.write(`prepaint ${scenario} passed\n`);
+} finally {
+  finishScript();
+  renderer.dispose();
+}

package/test/fixtures/resource-discovery.js

@@ -0,0 +1,32 @@
+// Host scripting is isolated from the test runner's globals.
+import { strict as assert } from "node:assert";
+import { createPageRenderer } from "../../lib/renderer/page-renderer.js";
+import { nodeOf } from "../../lib/renderer/bindings.js";
+const renderer = await createPageRenderer({
+  fetchResource: async url => ({ ok: false, status: 404, url, body: new Uint8Array() }),
+});
+try {
+  renderer.resize(400, 300, 1);
+  renderer.setScripting("host");
+  await renderer.loadDocument({ url: "https://resource.test/", contentType: "text/html",
+    source: '<!doctype html><style>body{color:red}</style><body>' + '<div>Item</div>'.repeat(100) + '</body>' });
+  await renderer.whenLoaded();
+  await renderer.evaluate("document.body.setAttribute('data-warm','1');document.body.clientWidth");
+  const document = nodeOf(globalThis.document), query = document.querySelectorAll.bind(document);
+  const watched = new Set(["video, audio", "img", "style, link[rel~='stylesheet']", "iframe"]);
+  const queries = [];
+  document.querySelectorAll = selector => {
+    if (watched.has(selector)) queries.push(selector);
+    return query(selector);
+  };
+  await renderer.evaluate(`for(let i=0;i<30;i++) {
+    document.body.setAttribute('data-counter',String(i));
+    document.body.setAttribute('aria-label',String(i));
+    document.body.clientWidth;
+  }`);
+  assert.deepEqual(queries, [], "metadata-only geometry flushes retain resource discovery");
+  await renderer.evaluate("document.body.insertAdjacentHTML('beforeend','<video></video>');document.body.clientWidth");
+  assert.ok(queries.includes("video, audio"), "structural insertion refreshes media discovery synchronously");
+  assert.equal(await renderer.evaluate("document.querySelector('video').offsetWidth"), 300);
+  process.stdout.write("resource discovery integration passed\n");
+} finally { renderer.dispose(); }