buninu-browser 0.5.0 → 0.6.0

package/test/font-loading.test.js

@@ -72,6 +72,83 @@ test("font sources try local/fetch alternatives and pending requests abort on do
   expect(aborted).toBe(1);
 });
 
+test("font indexes preserve subset order, case-insensitive families, and changed face lists", async () => {
+  const { CanvasKit, builtinTypefaces, fontCollection } = await loadGraphics();
+  const local = { sources: [{ local: builtinTypefaces[0].family }] };
+  const fonts = new DocumentFonts({ CanvasKit, builtins: builtinTypefaces, defaultCollection: fontCollection,
+    fetch: () => { throw new Error("local faces must not fetch"); } });
+  try {
+    const latin = face("Indexed", 400, [[0, 127]], local);
+    const capitals = face("iNDEXED", 400, [[65, 90]], local);
+    const cjk = face("Indexed", 400, [[0x4e00, 0x9fff]], local);
+    fonts.update([latin, capitals, cjk], [run("Aa中", ["INDEXED"])]);
+    await fonts.ready();
+    const latinAlias = fonts.resolve("indexed", 400, "normal", 97)[0];
+    const capitalsAlias = fonts.resolve("INDEXED", 400, "normal", 65)[0];
+    const cjkAlias = fonts.resolve("Indexed", 400, "normal", 0x4e2d)[0];
+    expect(new Set([latinAlias, capitalsAlias, cjkAlias]).size).toBe(3);
+    expect(fonts.resolve("iNdExEd", 400, "normal", 65)).toEqual([capitalsAlias, latinAlias]);
+    expect(fonts.resolve("indexed")).toEqual([cjkAlias, capitalsAlias, latinAlias]);
+
+    fonts.setFaces([cjk, capitals, latin]);
+    expect(fonts.resolve("Indexed", 400, "normal", 65)).toEqual([latinAlias, capitalsAlias]);
+    fonts.setFaces([cjk]);
+    expect(fonts.resolve("Indexed", 400, "normal", 65)).toEqual([]);
+    expect(fonts.resolve("Indexed", 400, "normal", 0x4e2d)).toEqual([cjkAlias]);
+    fonts.setFaces([]);
+    expect(fonts.hasUnicodeRanges).toBe(false);
+    expect(fonts.resolve("Indexed")).toEqual([]);
+    // Equivalent new descriptor objects still refer to the existing record.
+    fonts.setFaces([structuredClone(latin)]);
+    expect(fonts.resolve("Indexed", 400, "normal", 65)).toEqual([latinAlias]);
+    const returned = fonts.resolve("Indexed"); returned.length = 0;
+    expect(fonts.resolve("Indexed")).toEqual([latinAlias]);
+
+    // setFaces must also notice edits to an existing descriptor/array.
+    const mutable = [latin];
+    fonts.setFaces(mutable);
+    latin.family = "Renamed";
+    latin.unicodeRanges = [[0x400, 0x4ff]];
+    fonts.update(mutable, [run("Ж", ["renamed"])]);
+    await fonts.ready();
+    expect(fonts.resolve("Indexed")).toEqual([]);
+    expect(fonts.resolve("Renamed", 400, "normal", 65)).toEqual([]);
+    expect(fonts.resolve("Renamed", 400, "normal", 0x416)).toHaveLength(1);
+  } finally { fonts.dispose(); }
+});
+
+test("ranked faces observe aliases loaded later and changed font weights/styles", async () => {
+  const { CanvasKit, builtinTypefaces, fontCollection } = await loadGraphics();
+  const bytes = await Bun.file(new URL("../usr/share/fonts/DejaVuSansMono.ttf", import.meta.url)).bytes();
+  let finish;
+  const response = new Promise(resolve => { finish = resolve; });
+  const fonts = new DocumentFonts({ CanvasKit, builtins: builtinTypefaces, defaultCollection: fontCollection,
+    fetch: () => response });
+  try {
+    const regular = face("Delayed", 400, [[0, 127]]);
+    const medium = face("Delayed", 500, [[0, 127]]);
+    const italic = face("Delayed", 400, [[0, 127]], { style: "italic" });
+    fonts.update([regular, medium, italic], [run("a", ["Delayed"]), run("a", ["Delayed"], 500), run("a", ["Delayed"], 400, "italic")]);
+    expect(fonts.resolve("Delayed", 400, "normal", 65)).toEqual([]);
+    expect(fonts.resolve("Delayed", 450, "normal", 65)).toEqual([]);
+    expect(fonts.resolve("Delayed", 400, "italic", 65)).toEqual([]);
+    finish({ status: 200, body: bytes });
+    await fonts.ready();
+    const regularAlias = fonts.resolve("Delayed", 400, "normal", 65)[0];
+    const mediumAlias = fonts.resolve("Delayed", 500, "normal", 65)[0];
+    const italicAlias = fonts.resolve("Delayed", 400, "italic", 65)[0];
+    expect(new Set([regularAlias, mediumAlias, italicAlias]).size).toBe(3);
+    expect(fonts.resolve("Delayed", 450, "normal", 65)).toEqual([mediumAlias, regularAlias, italicAlias]);
+    expect(fonts.resolve("Delayed", 400, "italic", 65)).toEqual([italicAlias, regularAlias, mediumAlias]);
+    fonts.setFaces([medium]);
+    expect(fonts.resolve("Delayed", 400, "normal", 65)).toEqual([mediumAlias]);
+    // More style combinations than the bounded rank cache can hold must not
+    // change either a new lookup or one evicted earlier.
+    for (let weight = 1; weight <= 160; weight++) expect(fonts.resolve("Delayed", weight, "normal", 65)).toEqual([mediumAlias]);
+    expect(fonts.resolve("Delayed", 450, "normal", 65)).toEqual([mediumAlias]);
+  } finally { fonts.dispose(); }
+});
+
 test("loaded web font updates geometry, respects Unicode ranges, and resets on navigation", async () => {
   const bytes = await Bun.file(new URL("../usr/share/fonts/DejaVuSansMono.ttf", import.meta.url)).bytes();
   let finish;

package/test/font-metrics-invalidation.test.js

@@ -0,0 +1,60 @@
+import { expect, test } from "bun:test";
+import { parseHTMLDocument } from "../lib/happy-dom/parser.js";
+import { StyleEngine } from "../lib/style/computed-style.js";
+
+test("computed font-metric dependencies include resolved variables, pseudos and root lengths", () => {
+  const cases = [
+    ["#box{font-size:20px;line-height:normal;width:10em;height:2rem}", false],
+    ["#box{--unused:10ch;width:20px}", false],
+    ["#box{width:10ch}", true],
+    ["body{--size:4ch}#box{width:calc(var(--size) + 2px)}", true],
+    ["#box{width:var(--missing,3ch)}", true],
+    ["#box::before{content:'x';width:2ch}", true],
+    ["html{font-size:2ch}#box{width:10rem}", true],
+  ];
+  for (const [sheet, dependent] of cases) {
+    const { document, window } = parseHTMLDocument('<div id="box">text</div>');
+    try {
+      const engine = new StyleEngine({ measureText: () => 7 }).compute(document, [sheet]);
+      expect(engine.usesFontMetrics).toBe(dependent);
+      engine.compute(document, [sheet], {}, new Set(), new Set([document.getElementById("box")]));
+      expect(engine.usesFontMetrics).toBe(dependent);
+    } finally { window.happyDOM.abort(); }
+  }
+});
+
+test("font-metric dependencies survive incremental changes but reset for a new document", () => {
+  const first = parseHTMLDocument('<div id="box" style="width:2ch">first</div>');
+  const second = parseHTMLDocument('<div>second</div>');
+  try {
+    const engine = new StyleEngine({ measureText: () => 8 }).compute(first.document);
+    expect(engine.usesFontMetrics).toBe(true);
+    first.document.getElementById("box").style.width = "20px";
+    engine.compute(first.document, [], {}, new Set(), new Set([first.document.getElementById("box")]));
+    expect(engine.usesFontMetrics).toBe(true);
+    engine.compute(second.document);
+    expect(engine.usesFontMetrics).toBe(false);
+  } finally { first.window.happyDOM.abort(); second.window.happyDOM.abort(); }
+});
+
+test("font completion refreshes geometry with pixel parity while avoiding unnecessary cascades", async () => {
+  const child = Bun.spawn([process.execPath, new URL("./fixtures/font-metrics-invalidation.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("font metrics invalidation integration passed");
+}, 30_000);
+
+test("font definition edits refresh geometry and pixels without unnecessary full cascades", async () => {
+  const child = Bun.spawn([process.execPath, new URL("./fixtures/font-definition-invalidation.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("font definition invalidation integration passed");
+}, 30_000);

package/test/fractional-text-scale.test.js

@@ -0,0 +1,6 @@
+import {test,expect} from 'bun:test';
+test('fractional font sizes retain the final glyph at different device scales',async()=>{
+ const child=Bun.spawn([process.execPath,new URL('./fixtures/fractional-text-scale.js',import.meta.url).pathname],{stdout:'pipe',stderr:'pipe'});
+ const [exit,stderr]=await Promise.all([child.exited,new Response(child.stderr).text()]);
+ expect({exit,stderr}).toEqual({exit:0,stderr:''});
+},30000);

package/test/full-style-identity.test.js

@@ -0,0 +1,191 @@
+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 = [], options = {}) {
+  const parsed = parseHTMLDocument(source);
+  const viewport = { width:800, height:600 };
+  const engine = new StyleEngine(options).compute(parsed.document, sheets, viewport);
+  return { ...parsed, sheets, options, viewport, engine, get:id => parsed.document.getElementById(id) };
+}
+
+function full(f) {
+  f.engine.compute(f.document, f.sheets, f.viewport);
+  expect(f.engine.incremental).toBe(false);
+  expect(f.engine.restyled).toBe(f.document.querySelectorAll('*').length);
+  const reference = new StyleEngine(f.options).compute(f.document, f.sheets, f.viewport);
+  for (const element of f.document.querySelectorAll('*')) {
+    expect(f.engine.get(element)).toEqual(reference.get(element));
+    expect(f.engine.customPropertiesOf(element)).toEqual(reference.customPropertiesOf(element));
+    for (const pseudo of ['before', 'after']) expect(f.engine.getPseudo(element, pseudo)).toEqual(reference.getPseudo(element, pseudo));
+  }
+}
+
+test('full cascades retain equal style, custom property and pseudo identities', () => {
+  const f = fixture('<div id="parent" style="--tone:red"><span id="child">text</span></div>', [
+    '#child {color:var(--tone)} #child::before {content:"before";color:var(--tone)}',
+  ]);
+  try {
+    const child = f.get('child'), style = f.engine.get(child);
+    const custom = f.engine.customPropertiesOf(child), pseudo = f.engine.getPseudo(child, 'before');
+    f.sheets.push('.unmatched { width:20px }');
+    full(f);
+    expect(f.engine.get(child)).toBe(style);
+    expect(f.engine.customPropertiesOf(child)).toBe(custom);
+    expect(f.engine.getPseudo(child, 'before')).toBe(pseudo);
+    f.get('parent').style.setProperty('--tone', 'blue');
+    full(f);
+    expect(f.engine.get(child)).not.toBe(style);
+    expect(f.engine.customPropertiesOf(child)).not.toBe(custom);
+    expect(f.engine.getPseudo(child, 'before')).not.toBe(pseudo);
+    expect(style.color).toBe('rgba(255, 0, 0, 1)');
+    expect(custom.get('--tone')).toBe('red');
+    expect(pseudo.color).toBe('rgba(255, 0, 0, 1)');
+    f.sheets.push('#child::before {content:none} #child::after {content:"after";width:inherit}');
+    full(f);
+    expect(f.engine.getPseudo(child, 'before')).toBeNull();
+    expect(f.engine.getPseudo(child, 'after').content).toBe('after');
+  } finally { f.window.happyDOM.abort(); }
+});
+
+for (const incremental of [false, true]) {
+  test(`style identity comparison preserves signed-zero and NaN decisions (${incremental ? 'incremental' : 'full'})`, () => {
+    const f = fixture('<div id="zero" style="margin:0px">zero</div><div id="nan" style="width:calc(1e309 * 0px)">non-finite</div>');
+    try {
+      const zero = f.get('zero'), nan = f.get('nan');
+      const zeroStyle = f.engine.get(zero), nanStyle = f.engine.get(nan);
+      expect(Number.isNaN(nanStyle.width.px)).toBe(true);
+      expect(Number.isNaN(nanStyle.width.percent)).toBe(true);
+      zero.setAttribute('style', 'margin:-0px');
+      const fresh = new StyleEngine().compute(f.document, f.sheets);
+      expect(Object.is(fresh.get(zero).margin[0], -0)).toBe(true);
+      f.engine.compute(f.document, f.sheets, f.viewport, incremental ? new Set([zero, nan]) : null);
+      expect(f.engine.get(zero)).toBe(zeroStyle);
+      expect(f.engine.get(nan)).not.toBe(nanStyle);
+      expect(Number.isNaN(f.engine.get(nan).width.px)).toBe(true);
+    } finally { f.window.happyDOM.abort(); }
+  });
+}
+
+test('full cascades recompute media, viewport, root rem and font metric inputs', () => {
+  let advance = 7;
+  const f = fixture('<html style="font-size:2rem"><body><div id="parent" style="width:10vw;direction:rtl"><span id="child" style="font-size:50%;width:2rem;margin-inline-start:3px">text</span><i id="metric" style="width:10ch">metric</i></div></body></html>', [
+    '@media(min-width:1000px) { #child {padding:7px} }',
+  ], { measureText:() => advance });
+  try {
+    const oldMetric = f.engine.get(f.get('metric'));
+    full(f);
+    expect(f.engine.get(f.get('metric'))).toBe(oldMetric);
+    advance = 11;
+    f.viewport = { width:1200, height:700 };
+    f.document.documentElement.style.fontSize = '1.5rem';
+    full(f);
+    expect(f.engine.get(f.get('parent')).width).toBe(120);
+    expect(f.engine.get(f.get('child'))).toMatchObject({ width:48, fontSize:12, padding:[7,7,7,7], margin:[0,3,0,0] });
+    expect(f.engine.get(f.get('metric')).width).toBe(110);
+    expect(f.engine.get(f.get('metric'))).not.toBe(oldMetric);
+    expect(f.engine.usesFontMetrics).toBe(true);
+  } finally { f.window.happyDOM.abort(); }
+});
+
+test('retaining a full-pass style still refreshes explicit inheritance dependencies', () => {
+  const f = fixture('<div id="parent" style="width:100px"><span id="child" style="width:100px">text</span></div>');
+  try {
+    const original = f.engine.get(f.get('child'));
+    f.get('child').style.width = 'inherit';
+    full(f);
+    expect(f.engine.get(f.get('child'))).toBe(original);
+    f.get('parent').style.width = '200px';
+    f.engine.compute(f.document, f.sheets, f.viewport, new Set(), new Set([f.get('parent')]));
+    expect(f.engine.get(f.get('child')).width).toBe(200);
+    const inherited = f.engine.get(f.get('child'));
+    f.get('child').style.width = '200px';
+    full(f);
+    expect(f.engine.get(f.get('child'))).toBe(inherited);
+    f.get('parent').style.width = '300px';
+    f.engine.compute(f.document, f.sheets, f.viewport, new Set(), new Set([f.get('parent')]));
+    expect(f.engine.restyled).toBe(1);
+    expect(f.engine.get(f.get('child')).width).toBe(200);
+  } finally { f.window.happyDOM.abort(); }
+});
+
+test('full-pass maps drop detached nodes and do not restore them on later insertion', () => {
+  const f = fixture('<div id="parent"><span id="child" style="width:41px;--private:red">text</span></div>', ['#child::before {content:"x"}']);
+  try {
+    const child = f.get('child'), old = f.engine.get(child);
+    child.remove();
+    full(f);
+    expect(f.engine.get(child).width).toBe('auto');
+    expect(f.engine.customPropertiesOf(child).size).toBe(0);
+    expect(f.engine.getPseudo(child, 'before')).toBeNull();
+    f.get('parent').appendChild(child);
+    f.engine.compute(f.document, f.sheets, f.viewport, new Set([child]));
+    expect(f.engine.get(child).width).toBe(41);
+    expect(f.engine.get(child)).not.toBe(old);
+    f.document.documentElement.remove();
+    full(f);
+    expect(f.engine.get(child).width).toBe('auto');
+    expect(f.engine.getPseudo(child, 'before')).toBeNull();
+  } finally { f.window.happyDOM.abort(); }
+});
+
+test('a new document cannot reuse adopted nodes from the previous document', () => {
+  const f = fixture('<p id="child" style="width:41px;--private:red">text</p>', ['#child::before {content:"x"}']);
+  const other = parseHTMLDocument('<body></body>');
+  try {
+    const child = f.get('child'), oldRoot = f.document.documentElement;
+    const old = [f.engine.get(child), f.engine.customPropertiesOf(child), f.engine.getPseudo(child, 'before')];
+    other.document.body.appendChild(child);
+    f.engine.compute(other.document, f.sheets);
+    const current = [f.engine.get(child), f.engine.customPropertiesOf(child), f.engine.getPseudo(child, 'before')];
+    for (let i = 0; i < old.length; i++) {
+      expect(current[i]).toEqual(old[i]);
+      expect(current[i]).not.toBe(old[i]);
+    }
+    expect(f.engine.get(oldRoot).display).toBe('inline');
+  } finally { f.window.happyDOM.abort(); other.window.happyDOM.abort(); }
+});
+
+test('a callback starting another document compute cannot access the outer fallback', () => {
+  const first = parseHTMLDocument('<html style="width:1ch"><body><p style="color:red">moved</p></body></html>');
+  const second = parseHTMLDocument('<body></body>');
+  try {
+    let trigger = false, nestedStyle;
+    const child = first.document.querySelector('p');
+    const engine = new StyleEngine({ measureText() {
+      if (trigger) {
+        trigger = false;
+        second.document.body.appendChild(child);
+        engine.compute(second.document);
+        nestedStyle = engine.get(child);
+      }
+      return 8;
+    } });
+    engine.compute(first.document);
+    const old = engine.get(child);
+    trigger = true;
+    engine.compute(first.document);
+    expect(nestedStyle).toEqual(old);
+    expect(nestedStyle).not.toBe(old);
+  } finally { first.window.happyDOM.abort(); second.window.happyDOM.abort(); }
+});
+
+test('a failed full traversal cannot retain fallback maps for a later incremental pass', () => {
+  const f = fixture('<div id="parent"><span id="child" style="width:41px">text</span></div>');
+  try {
+    const child = f.get('child'), old = f.engine.get(child);
+    Object.defineProperty(f.get('parent'), 'getAttribute', { configurable:true, value() { throw Error('injected failure'); } });
+    expect(() => f.engine.compute(f.document, f.sheets)).toThrow('injected failure');
+    delete f.get('parent').getAttribute;
+    f.engine.compute(f.document, f.sheets, f.viewport, new Set([f.get('parent')]));
+    expect(f.engine.get(child).width).toBe(41);
+    expect(f.engine.get(child)).not.toBe(old);
+    full(f);
+  } finally { f.window.happyDOM.abort(); }
+});
+
+test('full identity reuse preserves render and layout caches under SES', async () => {
+  const child = Bun.spawn([process.execPath, new URL('./fixtures/full-style-identity.js', import.meta.url).pathname], { stdout:'pipe', stderr:'pipe' });
+  const [exit, stdout, stderr] = await Promise.all([child.exited, new Response(child.stdout).text(), new Response(child.stderr).text()]);
+  expect({ exit, stdout, stderr }).toEqual({ exit:0, stdout:'', stderr:'' });
+}, 15_000);

package/test/hidden-style-lazy.test.js

@@ -0,0 +1,31 @@
+import { expect, test } from "bun:test";
+
+async function fixture(name, args = []) {
+  const child = Bun.spawn(
+    [
+      process.execPath,
+      new URL(`./fixtures/${name}.js`, import.meta.url).pathname,
+      ...args,
+    ],
+    { stdout: "pipe", stderr: "pipe" },
+  );
+  const [exit, stdout, stderr] = await Promise.all([
+    child.exited,
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+  ]);
+  expect(stderr).toBe("");
+  expect(exit).toBe(0);
+  expect(JSON.parse(stdout).pass).toBe(true);
+}
+for (const args of [[], ["--ses"]])
+  test(
+    `deferred hidden styles equal eager styles ${args.length ? "under SES" : "normally"}`,
+    () => fixture("hidden-style-engine", args),
+    20_000,
+  );
+test(
+  "hidden updates and reveals preserve pixels, geometry and resource discovery",
+  () => fixture("hidden-style-renderer"),
+  60_000,
+);

package/test/hidden-style-reentry.test.js

@@ -0,0 +1,20 @@
+import { expect, test } from "bun:test";
+for (const args of [[], ["--ses"]])
+  test(`hidden style measurement callbacks cannot restart unfinished chains ${args.length ? "under SES" : "normally"}`, async () => {
+    const child = Bun.spawn(
+      [
+        process.execPath,
+        new URL("./fixtures/hidden-style-reentry.js", import.meta.url).pathname,
+        ...args,
+      ],
+      { stdout: "pipe", stderr: "pipe" },
+    );
+    const [exit, stdout, stderr] = await Promise.all([
+      child.exited,
+      new Response(child.stdout).text(),
+      new Response(child.stderr).text(),
+    ]);
+    expect(stderr).toBe("");
+    expect(exit).toBe(0);
+    expect(JSON.parse(stdout).pass).toBe(true);
+  }, 20_000);

package/test/idle-callback.test.js

@@ -0,0 +1,89 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { RendererHost } from "../lib/renderer/host.js";
+
+let renderer;
+beforeAll(async () => {
+  renderer = new RendererHost({ timeout: 20_000 });
+  await renderer.start();
+  await renderer.call("loadDocument", {
+    url: "https://page.test/", source: "<!doctype html><p>idle callbacks</p>",
+    contentType: "text/html", status: 200,
+  });
+  await renderer.call("whenLoaded");
+});
+afterAll(() => renderer?.close());
+const evaluate = (source) => renderer.call("evaluate", source);
+
+test("idle work consumes its monotonic budget and yields", async () => {
+  const result = await evaluate(`new Promise(resolve => requestIdleCallback(deadline => {
+    const start = performance.now(), before = deadline.timeRemaining();
+    // Bound the regression: the old constant deadline must not hang the test.
+    while (deadline.timeRemaining() > 0 && performance.now() - start < 30) {}
+    resolve({before, after: deadline.timeRemaining(), didTimeout: deadline.didTimeout});
+  }))`);
+  expect(result.before).toBeGreaterThanOrEqual(0);
+  expect(result.before).toBeLessThanOrEqual(10);
+  expect(result.after).toBe(0);
+  expect(result.didTimeout).toBeFalse();
+});
+
+test("a burst of idle work does not drain before an ordinary due timer", async () => {
+  const result = await evaluate(`new Promise(resolve => {
+    let completed = 0, whenTimer = null;
+    const finish = () => { if (completed === 16 && whenTimer !== null) resolve({completed, whenTimer}); };
+    for (let i = 0; i < 16; i++) requestIdleCallback(deadline => {
+      const start = performance.now();
+      while (deadline.timeRemaining() > 0 && performance.now() - start < 30) {}
+      completed++; finish();
+    });
+    setTimeout(() => { whenTimer = completed; finish(); }, 20);
+  })`);
+  expect(result.completed).toBe(16);
+  // Check task ordering, rather than imposing a real-clock upper bound on a
+  // slow CI machine. The old separate 1ms timers drain all sixteen first.
+  expect(result.whenTimer).toBeLessThan(16);
+});
+
+test("an expired timeout has no idle budget", async () => {
+  const result = await evaluate(`new Promise(resolve => {
+    requestIdleCallback(deadline => resolve({
+      didTimeout: deadline.didTimeout, remaining: deadline.timeRemaining()
+    }), {timeout: 1});
+    const start = performance.now();
+    while (performance.now() - start < 20) {}
+  })`);
+  expect(result).toEqual({ didTimeout: true, remaining: 0 });
+});
+
+test("zero timeout does not expire and cancellation prevents delivery", async () => {
+  const result = await evaluate(`new Promise(resolve => {
+    const calls = [];
+    const id = requestIdleCallback(() => calls.push("cancelled"), {timeout: 1});
+    cancelIdleCallback(id);
+    requestIdleCallback(deadline => {
+      calls.push(deadline.didTimeout);
+      setTimeout(() => resolve(calls), 10);
+    }, {timeout: 0});
+    const start = performance.now();
+    while (performance.now() - start < 10) {}
+  })`);
+  expect(result).toEqual([false]);
+});
+
+test("a timeout above the host timer limit does not expire immediately", async () => {
+  const result = await evaluate(`new Promise(resolve => {
+    requestIdleCallback(deadline => resolve({didTimeout: deadline.didTimeout}), {timeout: 2147483648});
+  })`);
+  expect(result).toEqual({ didTimeout: false });
+});
+
+test("idle callbacks validate their Web IDL inputs", async () => {
+  expect(await evaluate(`(() => {
+    const failures = [];
+    for (const args of [[null], ["code"], [() => {}, 1], [() => {}, {timeout: Symbol()}]]) {
+      try { requestIdleCallback(...args); failures.push(false); }
+      catch (error) { failures.push(error.name === "TypeError"); }
+    }
+    return failures;
+  })()`)).toEqual([true, true, true, true]);
+});

package/test/idle-scheduler.test.js

@@ -0,0 +1,148 @@
+import { expect, test } from 'bun:test';
+import { createIdleCallbacks } from '../lib/renderer/idle-callbacks.js';
+
+function fixture() {
+  let time = 0, id = 0;
+  const tasks = new Map(), errors = [];
+  const clock = {
+    now: () => time,
+    consume: ms => { time += ms; },
+    setTimer(callback, delay) {
+      const handle = ++id;
+      tasks.set(handle, { callback, at: time + Math.max(1, delay) });
+      return handle;
+    },
+    clearTimer: handle => tasks.delete(handle),
+    run() {
+      let iterations = 0;
+      while (tasks.size) {
+        if (++iterations > 1000) throw new Error('Idle scheduler did not finish');
+        const [handle, task] = [...tasks].sort((a, b) => a[1].at - b[1].at || a[0] - b[0])[0];
+        tasks.delete(handle);
+        time = Math.max(time, task.at);
+        task.callback();
+      }
+    },
+  };
+  const idle = createIdleCallbacks({ ...clock, invoke(callback, deadline) {
+    try { callback(deadline); } catch (error) { errors.push(error.message); }
+  } });
+  return { clock, idle, tasks, errors };
+}
+
+test('a burst of cooperative idle work gives an already due timer a turn', () => {
+  const { clock, idle, tasks } = fixture();
+  let completed = 0, timer;
+  for (let i = 0; i < 16; i++) idle.request(i, deadline => {
+    expect(deadline.didTimeout).toBe(false);
+    clock.consume(deadline.timeRemaining());
+    expect(deadline.timeRemaining()).toBe(0);
+    completed++;
+  }, 0);
+  clock.setTimer(() => { timer = { at: clock.now(), completed }; }, 20);
+  // Sixteen requests share one dispatch task; they are not sixteen overdue timers.
+  expect(tasks.size).toBe(2);
+  clock.run();
+  expect(timer).toEqual({ at: 22, completed: 2 });
+  expect(completed).toBe(16);
+  expect(tasks.size).toBe(0);
+});
+
+test('callbacks share their period deadline and nested requests wait for the next period', () => {
+  const { clock, idle } = fixture();
+  const seen = [];
+  idle.request(1, deadline => {
+    seen.push({ id: 1, at: clock.now(), budget: deadline.timeRemaining() });
+    idle.request(3, nested => seen.push({ id: 3, at: clock.now(), budget: nested.timeRemaining() }), 0);
+    clock.consume(3);
+  }, 0);
+  idle.request(2, deadline => seen.push({ id: 2, at: clock.now(), budget: deadline.timeRemaining() }), 0);
+  clock.run();
+  expect(seen).toEqual([{ id: 1, at: 1, budget: 10 }, { id: 2, at: 5, budget: 6 }, { id: 3, at: 11, budget: 10 }]);
+});
+
+test('positive timeout interrupts an idle backlog once, with no budget or retained timeout', () => {
+  const { clock, idle, tasks } = fixture();
+  let completed = 0;
+  const seen = [];
+  for (let i = 0; i < 16; i++) idle.request(i, deadline => {
+    clock.consume(deadline.timeRemaining()); completed++;
+  }, 0);
+  idle.request(20, deadline => seen.push({ at: clock.now(), completed, didTimeout: deadline.didTimeout, remaining: deadline.timeRemaining() }), 5);
+  clock.run();
+  expect(seen).toEqual([{ at: 11, completed: 1, didTimeout: true, remaining: 0 }]);
+  expect(completed).toBe(16);
+  expect(tasks.size).toBe(0);
+});
+
+test('unsigned-long timeouts are chunked and rechecked before expiring', () => {
+  let time = 0, next = 0;
+  const timers = new Map(), seen = [];
+  const idle = createIdleCallbacks({
+    now: () => time,
+    setTimer(callback, delay) {
+      expect(delay).toBeGreaterThanOrEqual(1);
+      expect(delay).toBeLessThanOrEqual(2147483647);
+      timers.set(++next, { callback, delay });
+      return next;
+    },
+    clearTimer: id => timers.delete(id),
+    invoke: (callback, deadline) => callback(deadline),
+  });
+  idle.request(1, deadline => seen.push([deadline.didTimeout, deadline.timeRemaining()]), 4294967295);
+  const fire = (id, at) => {
+    time = at;
+    const task = timers.get(id);
+    timers.delete(id);
+    task.callback();
+  };
+  expect(timers.get(1).delay).toBe(2147483647);
+  // Exercise timeout tasks without running the idle-dispatch task: reaching a
+  // host timer's maximum delay is not the idle callback's expiration.
+  fire(1, 2147483647);
+  expect(seen).toEqual([]);
+  expect(timers.get(3).delay).toBe(2147483647);
+  fire(3, 4294967294);
+  expect(seen).toEqual([]);
+  expect(timers.get(4).delay).toBe(1);
+  fire(4, 4294967295);
+  expect(seen).toEqual([[true, 0]]);
+  expect(timers.size).toBe(0);
+});
+
+test('cancellation works before dispatch, inside a period and for timeout tasks', () => {
+  const { clock, idle, tasks } = fixture();
+  const seen = [];
+  idle.request(1, () => seen.push(1), 1);
+  idle.cancel(1);
+  expect(tasks.size).toBe(0);
+  idle.request(2, () => { seen.push(2); idle.cancel(3); }, 0);
+  idle.request(3, () => seen.push(3), 3);
+  idle.request(4, () => seen.push(4), 50);
+  clock.run();
+  expect(seen).toEqual([2, 4]);
+  expect(clock.now()).toBeLessThan(50);
+  expect(tasks.size).toBe(0);
+});
+
+test('disposal inside a callback clears remaining dispatch and timeout work', () => {
+  const { clock, idle, tasks } = fixture();
+  const seen = [];
+  idle.request(1, () => { seen.push(1); idle.dispose(); idle.request(3, () => seen.push(3), 1); }, 0);
+  idle.request(2, () => seen.push(2), 50);
+  clock.run();
+  expect(seen).toEqual([1]);
+  expect(tasks.size).toBe(0);
+  idle.dispose();
+});
+
+test('reported callback errors leave subsequent idle work runnable', () => {
+  const { clock, idle, tasks, errors } = fixture();
+  let complete = false;
+  idle.request(1, () => { throw Error('page exception'); }, 0);
+  idle.request(2, () => { complete = true; }, 0);
+  clock.run();
+  expect(errors).toEqual(['page exception']);
+  expect(complete).toBe(true);
+  expect(tasks.size).toBe(0);
+});