buninu-browser 0.5.0 → 0.6.0

package/test/node-iterator.test.js

@@ -0,0 +1,81 @@
+import { afterAll, beforeAll, expect, test } from 'bun:test';
+import { RendererHost } from '../lib/renderer/host.js';
+import { nodeIteratorCases } from './fixtures/node-iterator-cases.js';
+import chromium from './fixtures/node-iterator-chromium.json';
+
+const host = new RendererHost({timeout: 20000, fetch: async () => new Response('')});
+beforeAll(async () => {
+  await host.call('loadDocument', {url:'https://iterator.test/',source:'<body></body>',contentType:'text/html',status:200});
+  await host.call('whenLoaded');
+});
+afterAll(() => host.close());
+const evaluate = async expression => JSON.parse(await host.call('evaluate', `JSON.stringify(${expression})`));
+
+test('NodeIterator traversal, replacement and WebIDL conversion match Chromium and DOM', async () => {
+  const actual = await evaluate(`(${nodeIteratorCases})()`);
+  const expected = chromium.map(row => {
+    // Chromium retains a detached reference when replacing a node with its
+    // following sibling while the pointer is before it. DOM replace adopts
+    // (detaches) that sibling first, then removes the old node: the repaired
+    // reference must be root, not the now-detached old node/descendant.
+    // https://dom.spec.whatwg.org/#concept-node-replace steps 6–7
+    if (row[1] === 'sibling' && [1,2].includes(row[2]) && row[3]) {
+      return [...row.slice(0,4), 'root', false, 'b', 'b', 'b'];
+    }
+    return row;
+  });
+  expect(actual).toEqual(expected);
+});
+
+test('failed replacements leave the tree and iterator position unchanged', async () => {
+  expect(await evaluate(`(() => {
+    const results=[];
+    for(const kind of ['ancestor','missing','document','textDocument','twoElements']) {
+      const root=document.createElement('div');root.id='root';root.innerHTML='<b id="a"></b><i id="b"></i>';
+      const doc=document.implementation.createHTMLDocument('');
+      const parent=kind==='textDocument'||kind==='twoElements'?doc:root;
+      const old=parent.firstChild;
+      const it=document.createNodeIterator(parent);it.nextNode();it.nextNode();
+      const reference=it.referenceNode,before=it.pointerBeforeReferenceNode;
+      const children=[...parent.childNodes];
+      let incoming=kind==='ancestor'?root:kind==='document'?document:document.createElement('em');
+      if(kind==='textDocument')incoming=document.createTextNode('invalid');
+      if(kind==='twoElements'){incoming=document.createDocumentFragment();incoming.append(document.createElement('i'),document.createElement('b'));}
+      let error;
+      try{parent.replaceChild(incoming,kind==='missing'?document.createElement('b'):old)}catch(e){error=e.name}
+      results.push([kind,error,it.referenceNode===reference,it.pointerBeforeReferenceNode===before,
+        children.length===parent.childNodes.length&&children.every((n,i)=>n===parent.childNodes[i])]);
+    }
+    return results;
+  })()`)).toEqual([
+    ['ancestor','HierarchyRequestError',true,true,true],['missing','NotFoundError',true,true,true],
+    ['document','HierarchyRequestError',true,true,true],['textDocument','HierarchyRequestError',true,true,true],
+    ['twoElements','HierarchyRequestError',true,true,true]
+  ]);
+});
+
+test('filter replacement repairs both active and stored iterator cursors', async () => {
+  expect(await evaluate(`(() => {
+    const root=document.createElement('div');root.id='root';root.innerHTML='<b id="a"></b><i id="b"></i>';
+    const it=document.createNodeIterator(root,1,n=>{
+      if(n.id==='a'){const replacement=document.createElement('em');replacement.id='x';root.replaceChild(replacement,n)}
+      return 1;
+    });
+    const got=[];for(let n,i=0;i<8&&(n=it.nextNode());i++)got.push(n.id);
+    return got;
+  })()`)).toEqual(['root','a','x','b']);
+});
+
+test('batch removal follows DOM tree order and keeps references attached', async () => {
+  expect(await evaluate(`(() => {
+    const results=[];
+    for(const operation of ['replaceChildren','innerHTML','textContent'])for(const before of [false,true]) {
+      const root=document.createElement('div');root.innerHTML='<i>a</i><i>b</i>';
+      const it=document.createNodeIterator(root);it.nextNode();it.nextNode();it.nextNode();
+      if(before)it.previousNode();
+      if(operation==='replaceChildren')root.replaceChildren();else root[operation]='';
+      results.push([it.referenceNode===root,it.pointerBeforeReferenceNode,it.nextNode()]);
+    }
+    return results;
+  })()`)).toEqual(Array.from({length:6},()=>[true,false,null]));
+});

package/test/observer-invalidation.test.js

@@ -0,0 +1,12 @@
+import { expect, test } from "bun:test";
+
+test("unchanged geometry skips observer measurements without hiding real changes", async () => {
+  const child = Bun.spawn([process.execPath, new URL("./fixtures/observer-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("observer invalidation integration passed");
+}, 30_000);

package/test/page-scripts.test.js

@@ -1186,6 +1186,41 @@ test("page RegExp instances can override their own toString without changing the
   expect(await evaluate("regexpOverride")).toEqual(["custom", "/other/"]);
 });
 
+test("import methods keep their names and receivers alongside real dynamic imports", async () => {
+  scripts.set("https://page.test/import-method.js", `
+    export class Module {
+      static import(value) { return this.prefix + value }
+      static prefix = 'module:';
+    }
+    export const answer = 42;
+  `);
+  await load(`<script>
+    class Registry extends HTMLElement {
+      static import(value) { return this.prefix + value }
+      static prefix = 'class:';
+    }
+    customElements.define('import-registry', Registry);
+    const object = { prefix: 'object:', import(value) { return this.prefix + value } };
+    window.importNames = [
+      Registry.import('a'), Registry . import /* gap */ ('b'),
+      object.import('c'), object . /* gap */ import ('d'),
+      customElements.get('import-registry').import.name,
+      Object.hasOwn(Registry, 'import'), Object.hasOwn(Registry, '__import__'),
+      Registry.import.toString(),
+    ];
+    Promise.all([
+      import /* gap */ ('./import-method.js'),
+      import\n('./import-method.js'),
+    ]).then(([a, b]) => { window.dynamicImportNames = [a.answer, a === b, a.Module.import('e')]; });
+  </script>`);
+  expect(await evaluate("importNames")).toEqual([
+    "class:a", "class:b", "object:c", "object:d", "import", true, false,
+    "import(value) { return this.prefix + value }",
+  ]);
+  await waitFor("typeof dynamicImportNames !== 'undefined'");
+  expect(await evaluate("dynamicImportNames")).toEqual([42, true, "module:e"]);
+});
+
 test("ES modules: graphs, live exports, JSON, import.meta, dynamic import, TLA, cycles, import maps", async () => {
   const base = "https://page.test/modules/";
   scripts.set(`${base}math.js`, `
@@ -1997,14 +2032,24 @@ test("a click inside an iframe goes to the element under it in the frame's docum
 test("dynamic linked stylesheets fire load after their rules become available", async () => {
   await load(`<div id="target"></div><script>
     window.sheetLoaded = false;
+    window.sheetEvents = [];
     const link = document.createElement('link');
     link.rel = 'stylesheet';
     link.href = '/slow.css';
-    link.onload = () => { window.sheetLoaded = getComputedStyle(document.body).color; };
+    window.styleTestLink = link;
+    link.onerror = () => sheetEvents.push('error');
+    link.onload = () => { sheetEvents.push('load'); window.sheetLoaded = getComputedStyle(document.body).color; };
     document.head.appendChild(link);
   </script>`);
   for (let i = 0; i < 60 && await evaluate('sheetLoaded') === false; i++) await Bun.sleep(25);
   expect(await evaluate('sheetLoaded')).toBe('rgba(255, 0, 0, 1)');
+  expect(await evaluate('sheetEvents.join()')).toBe('load');
+  await evaluate("styleTestLink.href='/missing.css'; window.eventsAfterHref=sheetEvents.join()");
+  expect(await evaluate('eventsAfterHref')).toBe('load');
+  expect(await waitFor("sheetEvents.join() === 'load,error'")).toBe(true);
+  await evaluate("styleTestLink.href='/slow.css'; window.eventsAfterHref=sheetEvents.join()");
+  expect(await evaluate('eventsAfterHref')).toBe('load,error');
+  expect(await waitFor("sheetEvents.join() === 'load,error,load'")).toBe(true);
 });
 
 test("decoded dynamic images report natural dimensions and fire load", async () => {
@@ -2154,3 +2199,108 @@ test("the page scrolls over content that overflows a 100vh layout, not over clip
   expect(await evaluate(`(scrollTo(0, 99999), [scrollY, Math.round(document.getElementById("end").getBoundingClientRect().bottom)])`))
     .toEqual([2090 - 300, 300]);
 });
+
+test("NodeIterator includes its root, preserves direction, and skips rejected nodes without pruning", async () => {
+  await load('<div id="root"><p id="a"><b id="child"></b></p><!--note--><p id="b"></p></div>');
+  expect(await evaluate(`(() => {
+    const root = document.getElementById('root');
+    const filter = {acceptNode(n) {return n.id === 'a' ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_ACCEPT}};
+    const it = document.createNodeIterator(root, NodeFilter.SHOW_ELEMENT, filter);
+    const initial = [it instanceof NodeIterator,it.root === root,it.referenceNode === root,it.pointerBeforeReferenceNode,it.filter === filter];
+    const forward=[];let n;while(n=it.nextNode())forward.push(n.id);
+    const reverse=[];while(n=it.previousNode())reverse.push(n.id);
+    it.detach();
+    return JSON.stringify([initial,forward,reverse,it.nextNode().id]);
+  })()`)).toBe(JSON.stringify([[true,true,true,true,true],['root','child','b'],['b','child','root'],'root']));
+});
+
+test("NodeIterator survives sanitizer removals, reparenting, and rejected reentrant filters", async () => {
+  await load('<div id="root"><i id="a"><b id="child"></b></i><i id="b"></i><i id="c"></i></div>');
+  expect(await evaluate(`(() => {
+    const root=document.getElementById('root'),it=document.createNodeIterator(root,1);
+    it.nextNode();it.nextNode();it.nextNode();
+    root.firstChild.remove();
+    const removed=[it.referenceNode.id,it.nextNode().id];
+    it.previousNode();root.firstChild.remove();
+    const before=[it.referenceNode.id,it.pointerBeforeReferenceNode,it.nextNode().id];
+    document.body.appendChild(root.firstChild);
+    const moved=[it.referenceNode.id,it.nextNode()];
+    let error;const recur=document.createNodeIterator(root,1,()=>{try{recur.nextNode()}catch(e){error=e.name}return 1});
+    recur.nextNode();
+    const fresh=document.createNodeIterator(root,NodeFilter.SHOW_TEXT);
+    root.innerHTML='hello<b>world</b>';
+    return JSON.stringify([removed,before,moved,error,fresh.nextNode().data,fresh.nextNode().data]);
+  })()`)).toBe(JSON.stringify([['root','b'],['c',true,'c'],['root',null],'InvalidStateError','hello','world']));
+});
+
+// Expectations independently checked against Chromium Headless Shell.
+test("NodeIterator repairs an active filter cursor when the candidate or its ancestor is removed", async () => {
+  await load("<body></body>");
+  expect(await evaluate(`JSON.stringify((()=>{const results=[];for(const direction of ['nextNode','previousNode'])for(const remove of ['self','ancestor'])for(const verdict of [1,3]){
+ const root=document.createElement('div');root.id='root';root.innerHTML='<i id="a"></i><section id="parent"><b id="b"></b><b id="c"></b></section><i id="d"></i>';document.body.append(root);
+ let armed=false,once=false;const seen=[];const it=document.createNodeIterator(root,1,n=>{if(armed)seen.push(n.id);if(armed&&!once&&n.id==='b'){once=true;(remove==='self'?n:n.parentNode).remove();return verdict;}return 1});
+ if(direction==='previousNode')while(it.nextNode());armed=true;
+ const got=[];for(let n,k=0;k<15&&(n=it[direction]());k++)got.push(n.id);
+ results.push({direction,remove,verdict,seen,got,reference:it.referenceNode.id,before:it.pointerBeforeReferenceNode});root.remove();
+}return results.map(r=>[r.direction,r.remove,r.verdict,r.seen.join(','),r.got.join(','),r.reference,r.before])})())`)).toBe(JSON.stringify([
+    ["nextNode", "self", 1, "root,a,parent,b,c,d", "root,a,parent,b,c,d", "d", false],
+    ["nextNode", "self", 3, "root,a,parent,b,c,d", "root,a,parent,c,d", "d", false],
+    ["nextNode", "ancestor", 1, "root,a,parent,b,d", "root,a,parent,b,d", "d", false],
+    ["nextNode", "ancestor", 3, "root,a,parent,b,d", "root,a,parent,d", "d", false],
+    ["previousNode", "self", 1, "d,c,b,parent,a,root", "d,c,b,parent,a,root", "root", true],
+    ["previousNode", "self", 3, "d,c,b,parent,a,root", "d,c,parent,a,root", "root", true],
+    ["previousNode", "ancestor", 1, "d,c,b,a,root", "d,c,b,a,root", "root", true],
+    ["previousNode", "ancestor", 3, "d,c,b,a,root", "d,c,a,root", "root", true]
+  ]));
+});
+
+test("NodeIterator releases its active cursor after a filter throws", async () => {
+  await load('<div id="root"><b id="child"></b></div>');
+  expect(await evaluate(`(() => {
+    const root=document.getElementById('root');let first=true;
+    const it=document.createNodeIterator(root,1,()=>{if(first){first=false;throw Error('filter failed')}return 1});
+    let message;try{it.nextNode()}catch(e){message=e.message}
+    return [message,it.nextNode().id,it.nextNode().id].join(',');
+  })()`)).toBe('filter failed,root,child');
+});
+
+test("NodeIterator repairs removals through proxy-backed select and form parents", async () => {
+  await load('<body></body>');
+  expect(await evaluate(`(() => {
+    const results=[];
+    for(const tag of ['div','select','form']) for(const outerRoot of [false,true])
+      for(const operation of ['remove','removeChild','innerHTML','reparent']) {
+        const outer=document.createElement('div'),parent=document.createElement(tag);
+        outer.append(parent);document.body.append(outer);
+        parent.innerHTML='<option id="a"></option><option id="b"></option>';
+        const it=document.createNodeIterator(outerRoot?outer:parent,1);
+        while(it.nextNode()?.id!=='a') {}
+        const child=parent.firstChild;
+        if(operation==='remove')child.remove();
+        else if(operation==='removeChild')parent.removeChild(child);
+        else if(operation==='innerHTML')parent.innerHTML='';
+        else outer.append(child);
+        results.push([it.referenceNode===parent,it.nextNode()?.id??null]);
+        outer.remove();
+      }
+    return JSON.stringify(results);
+  })()`)).toBe(JSON.stringify(Array.from({length:6},()=>[
+    [true,'b'],[true,'b'],[true,null],[true,'b']
+  ]).flat()));
+});
+
+test("NodeIterator validates nullable callback-interface filters at creation", async () => {
+  await load('<body></body>');
+  expect(await evaluate(`(() => {
+    const results=[];
+    for(const filter of [0,1,false,true,'','x',Symbol('filter'),1n]) {
+      try { document.createNodeIterator(document.body,0,filter);results.push('accepted'); }
+      catch(error) { results.push(error.name); }
+    }
+    for(const filter of [null,undefined,()=>1,{acceptNode(){return 1}},{}]) {
+      const it=document.createNodeIterator(document.body,0,filter);
+      results.push(it.filter===(filter??null) && it.nextNode()===null);
+    }
+    return JSON.stringify(results);
+  })()`)).toBe(JSON.stringify([...Array(8).fill('TypeError'),...Array(5).fill(true)]));
+});

package/test/page-timers.test.js

@@ -0,0 +1,67 @@
+import { afterAll, beforeAll, expect, test } from 'bun:test';
+import { RendererHost } from '../lib/renderer/host.js';
+
+const nestingScript = `new Promise(resolve => {
+  const gaps = []; let previous = performance.now();
+  function step() {
+    const now = performance.now(); gaps.push(now - previous); previous = now;
+    if (gaps.length === 12) resolve(gaps);
+    else Promise.resolve().then(() => {}).then(() => queueMicrotask(() => setTimeout(step, 0)));
+  }
+  setTimeout(step, 0);
+})`;
+const intervalScript = `new Promise(resolve => {
+  let conversions = 0, calls = 0;
+  const id = setInterval(() => {
+    if (++calls === 8) { clearTimeout(id); resolve({conversions, calls}); }
+  }, {valueOf() { conversions++; return 0; }});
+})`;
+const scripts = new Map([
+  ['/nested.js', `${nestingScript}.then(gaps => postMessage(gaps))`],
+  ['/interval.js', `${intervalScript}.then(result => postMessage(result))`],
+]);
+let renderer;
+beforeAll(async () => {
+  renderer = new RendererHost({timeout: 20000, fetch: async url => {
+    const script = scripts.get(new URL(url).pathname);
+    return new Response(script ?? '', {headers: {'content-type': 'text/javascript'}});
+  }});
+  await renderer.start();
+  await renderer.call('loadDocument', {url: 'https://timers.test/', source: '<!doctype html><p>Timers</p>', contentType: 'text/html'});
+  await renderer.call('whenLoaded');
+});
+afterAll(() => renderer?.close());
+const evaluate = code => renderer.call('evaluate', code);
+const worker = path => evaluate(`new Promise((resolve, reject) => {
+  const worker = new Worker(${JSON.stringify(path)});
+  worker.onmessage = event => { worker.terminate(); resolve(event.data); };
+  worker.onerror = event => { worker.terminate(); reject(Error(event.message)); };
+})`);
+
+for (const scope of ['Window', 'Worker']) {
+  test(`${scope} preserves nested timer depth through Promise and queueMicrotask`, async () => {
+    const gaps = scope === 'Window' ? await evaluate(nestingScript) : await worker('/nested.js');
+    expect(gaps).toHaveLength(12);
+    // Only a lower bound: a loaded CI host can delay callbacks arbitrarily.
+    // The deterministic helper test checks the exact 0/4ms requested sequence.
+    expect(gaps.slice(6).reduce((sum, ms) => sum + ms, 0)).toBeGreaterThanOrEqual(20);
+  });
+  test(`${scope} converts interval delay once and either clear method cancels it`, async () => {
+    expect(scope === 'Window' ? await evaluate(intervalScript) : await worker('/interval.js'))
+      .toEqual({conversions: 1, calls: 8});
+  });
+}
+
+test('handler string and delay conversion happen at registration and errors stay synchronous', async () => {
+  expect(await evaluate(`new Promise(resolve => {
+    const calls = []; globalThis.timerText = '';
+    setTimeout({toString() { calls.push('handler'); return 'timerText = "executed"'; }},
+      {valueOf() { calls.push('delay'); return 0; }});
+    calls.push('registered');
+    for (const delay of [1n, Symbol()]) {
+      try { setTimeout(() => {}, delay); calls.push('accepted'); }
+      catch (error) { calls.push(error.name); }
+    }
+    setTimeout(() => resolve({calls, timerText}), 20);
+  })`)).toEqual({calls: ['handler', 'delay', 'registered', 'TypeError', 'TypeError'], timerText: 'executed'});
+});

package/test/paint-frame.test.js

@@ -1,5 +1,5 @@
 import { expect, test } from 'bun:test';
-import { cropViewport, encodeImage, encodeImageBase64 } from '../lib/paint/frame.js';
+import { cropViewport, encodeImage, encodeImageBase64, rawFrame } from '../lib/paint/frame.js';
 import { FrameCaptureCache } from '../lib/paint/frame-cache.js';
 import { appendParagraphText } from '../lib/paint/paragraph-text.js';
 
@@ -101,3 +101,20 @@ test('paragraphs batch ordinary text while preserving whole emoji graphemes and
   expect(runs[0].text).toBe(ordinary);
   expect(runs.at(-1)).toEqual({ text: ' end', emoji: false });
 });
+
+test('raw capture copies borrowed pixels but can consume private offset snapshots',async()=>{
+  const pixels=new Uint8Array([10,20,30,40, 50,60,70,80]);
+  expect([...rawFrame(pixels,2,1,'bgra').pixels]).toEqual([30,20,10,40,70,60,50,80]);
+  expect([...pixels]).toEqual([10,20,30,40,50,60,70,80]);
+  const bytes=new Uint8Array(16);bytes.set(pixels,4);
+  const frame=rawFrame(bytes.subarray(4,12),2,1,'bgra',{takeOwnership:true});
+  expect(frame.pixels.buffer).toBe(bytes.buffer);
+  expect([...frame.pixels]).toEqual([30,20,10,40,70,60,50,80]);
+  expect([...bytes.subarray(0,4)]).toEqual([0,0,0,0]);
+});
+
+test("raw screenshots accept already composed BGRA without converting it twice", () => {
+  const pixels = Uint8Array.of(3, 2, 1, 255);
+  expect(rawFrame(pixels, 1, 1, "bgra", {inputFormat:"bgra"}).pixels).toEqual(pixels);
+  expect(rawFrame(pixels, 1, 1, "rgba", {inputFormat:"bgra"}).pixels).toEqual(Uint8Array.of(1,2,3,255));
+ });

package/test/pcm.test.js

@@ -0,0 +1,63 @@
+import { expect, test } from 'bun:test';
+import { floatToS16 } from '../lib/audio/pcm.js';
+
+// The previous implementation is a byte-order-explicit reference, independent
+// of native Int16Array storage. Check full output bytes, not native readings.
+function reference(samples) {
+  const out = new Uint8Array(samples.length * 2), view = new DataView(out.buffer);
+  for (let i = 0; i < samples.length; i++) {
+    const value = Math.max(-1, Math.min(1, samples[i]));
+    view.setInt16(i * 2, Math.round(value < 0 ? value * 32768 : value * 32767), true);
+  }
+  return out;
+}
+
+// Exercise the actual DataView fallback on little-endian test machines. Only
+// replace the host-endian probe; the function under test stays the source file.
+const source = await Bun.file(new URL('../lib/audio/pcm.js', import.meta.url)).text();
+const probe = 'const LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;';
+if (!source.includes(probe)) throw new Error('Update the endian-fallback test probe');
+const fallbackModule = await import('data:text/javascript;base64,' + Buffer.from(
+  source.replace(probe, 'const LITTLE_ENDIAN = false;'),
+).toString('base64'));
+
+for (const [name, convert] of [['native', floatToS16], ['explicit little-endian fallback', fallbackModule.floatToS16]]) {
+  test(`s16le ${name}: zero, clamp, NaN, infinities, subnormals and signed rounding`, () => {
+    const values = [0, -0, NaN, Infinity, -Infinity, 1, -1, 2, -2,
+      Number.MAX_VALUE, -Number.MAX_VALUE, Number.MIN_VALUE, -Number.MIN_VALUE,
+      0.5, -0.5, 0.5 / 32767, -0.5 / 32768, 1.5 / 32767, -1.5 / 32768,
+      32766.5 / 32767, -32767.5 / 32768];
+    expect(convert(values)).toEqual(reference(values));
+    expect(convert(new Float32Array(values))).toEqual(reference(new Float32Array(values)));
+    expect([...convert(new Float32Array([1, -1, 0.5, -0.5]))]).toEqual([255,127,0,128,0,64,0,192]);
+    expect(convert(new Float32Array())).toEqual(new Uint8Array());
+  });
+
+  test(`s16le ${name}: every signed integer midpoint and adjacent inputs match previous rounding`, () => {
+    const values = [];
+    for (let value = -32768; value < 32767; value++) {
+      const midpoint = (value + 0.5) / (value < 0 ? 32768 : 32767);
+      values.push(midpoint - Number.EPSILON, midpoint, midpoint + Number.EPSILON);
+    }
+    expect(convert(values)).toEqual(reference(values));
+    const decoded = new Float32Array(values);
+    expect(convert(decoded)).toEqual(reference(decoded));
+  });
+
+  test(`s16le ${name}: randomized Float32 bit patterns preserve exact bytes and ownership`, () => {
+    const storage = new ArrayBuffer(4 * 100002), words = new Uint32Array(storage);
+    let state = 0xa538f219;
+    for (let i = 0; i < words.length; i++) words[i] = state = (Math.imul(state, 1664525) + 1013904223) >>> 0;
+    words.set([0x80000000, 0x7f800000, 0xff800000, 0x7fc00001, 0xffc00001, 1, 0x80000001], 1);
+    const input = new Float32Array(storage, 4, 100000), before = new Uint8Array(storage).slice();
+    const first = convert(input), second = convert(input);
+    expect(first).toEqual(reference(input));
+    expect(first).toEqual(second);
+    expect(first.buffer).not.toBe(input.buffer);
+    expect(first.buffer).not.toBe(second.buffer);
+    expect(first.byteOffset).toBe(0);
+    first.buffer.transfer(0);
+    expect(second.byteLength).toBe(input.length * 2);
+    expect(new Uint8Array(storage)).toEqual(before);
+  });
+}

package/test/prepaint-scheduling.test.js

@@ -0,0 +1,13 @@
+import {expect, test} from 'bun:test';
+
+for (const scenario of ['loading', 'loading-scroll', 'pending-frame', 'video']) {
+  test(`prepaint scheduling preserves visible work and eventual idle expansion: ${scenario}`, async () => {
+    const child = Bun.spawn([process.execPath,
+      new URL('./fixtures/prepaint-scheduling.js', import.meta.url).pathname, scenario], {stdout:'pipe', stderr:'pipe'});
+    const [output, 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(output).toContain(`prepaint ${scenario} passed`);
+  }, 15000);
+}

package/test/pulse-client.test.js

@@ -219,3 +219,168 @@ test("measured device progress governs the media clock and bounded audio queue t
     await new Promise(resolve => server.close(resolve));
   }
 });
+
+// Keep the real connection/open/close path, but drive only the playback
+// intervals with a virtual monotonic clock. Latency responses are controlled
+// at the client boundary; the test above covers their wire representation.
+async function playbackTimers(run) {
+  const { createServer } = await import("node:net");
+  const server = createServer(socket => {
+    let input = Buffer.alloc(0);
+    socket.on("data", chunk => {
+      input = Buffer.concat([input, chunk]);
+      while (input.length >= 20 && input.length >= 20 + input.readUInt32BE(0)) {
+        const length = input.readUInt32BE(0), channel = input.readUInt32BE(4);
+        const body = input.subarray(20, 20 + length);
+        input = input.subarray(20 + length);
+        if (channel !== 0xffffffff) continue;
+        const command = body.readUInt32BE(1), tag = body.readUInt32BE(6);
+        const extra = command === 3 ? [0x4c, ...u32(1), 0x4c, ...u32(1), 0x4c, ...u32(1e7)] : [];
+        const reply = Buffer.from([0x4c, ...u32(2), 0x4c, ...u32(tag), ...extra]);
+        socket.write(Buffer.concat([header(reply.length, 0xffffffff), reply]));
+      }
+    });
+  });
+  await new Promise(resolve => server.listen(0, "127.0.0.1", resolve));
+  let client, now = 0;
+  const intervals = new Map(), sent = [];
+  const originalSet = globalThis.setInterval, originalClear = globalThis.clearInterval;
+  const originalNow = performance.now;
+  const flush = async () => { await Promise.resolve(); await Promise.resolve(); };
+  try {
+    client = await PulseClient.connect({ port: server.address().port });
+    client.writeAudio = (index, bytes) => sent.push({ at: now, bytes: bytes.length });
+    globalThis.setInterval = (callback, delay) => {
+      const token = {};
+      intervals.set(token, { callback, delay, at: now + delay });
+      return token;
+    };
+    globalThis.clearInterval = token => {
+      if (!intervals.delete(token)) originalClear(token);
+    };
+    performance.now = () => now;
+    const advance = async duration => {
+      const end = now + duration;
+      for (;;) {
+        const next = [...intervals.values()].sort((a, b) => a.at - b.at)[0];
+        if (!next || next.at > end) break;
+        now = next.at;
+        next.at += next.delay;
+        next.callback();
+        await flush();
+      }
+      now = end;
+      await flush();
+    };
+    await run({ client, intervals, sent, advance, flush, now: () => now });
+  } finally {
+    client?.close();
+    globalThis.setInterval = originalSet;
+    globalThis.clearInterval = originalClear;
+    performance.now = originalNow;
+    await new Promise(resolve => server.close(resolve));
+  }
+}
+
+test("16 ms measured timing leaves PCM on its 50 ms cadence and holds a stale device clock", async () => {
+  await playbackTimers(async ({ client, intervals, sent, advance, now }) => {
+    const requests = [], times = [], polls = [];
+    let stalled = false, lastPlayed = 0;
+    const totalSent = () => sent.reduce((sum, packet) => sum + packet.bytes, 0);
+    client.playbackTiming = () => {
+      polls.push(now());
+      if (!stalled) lastPlayed = Math.min(now(), totalSent());
+      return { writeIndex: totalSent(), readIndex: totalSent(),
+        sinkSeconds: (totalSent() - lastPlayed) / 1000, playing: true };
+    };
+    const stream = await client.openPlayback({ rate: 500, channels: 1,
+      onRequest: bytes => requests.push(bytes), onTiming: timing => times.push(timing.seconds) });
+    expect([...intervals.values()].map(timer => timer.delay).sort((a, b) => a - b)).toEqual([16, 50]);
+    stream.write(new Uint8Array(2000));
+    expect(totalSent()).toBe(500);
+    await advance(49);
+    expect(polls).toEqual([16, 32, 48]);
+    expect(times.at(-1)).toBeCloseTo(0.048, 6);
+    expect(totalSent()).toBe(500); // timing callbacks do not send PCM
+    await advance(51);
+    expect(polls).toEqual([16, 32, 48, 64, 80, 96]);
+    expect(sent.every(packet => packet.at === 0 || packet.at === 50 || packet.at === 100)).toBe(true);
+    expect(totalSent()).toBe(596); // only the measured 96 ms has replenished the budget
+    expect(totalSent() - lastPlayed).toBe(500);
+    stalled = true;
+    await advance(1000);
+    expect(times.at(-1)).toBeCloseTo(0.096, 6);
+    expect(totalSent()).toBe(596); // neither wall time nor more queries invent progress
+    expect(requests.reduce((sum, bytes) => sum + bytes, 0)).toBeLessThanOrEqual(2600);
+    stream.kill();
+    expect(intervals.size).toBe(0);
+    const count = polls.length;
+    await advance(1000);
+    expect(polls).toHaveLength(count);
+    expect(stream.queued).toBe(0);
+  });
+});
+
+test("slow timing responses stay single-flight and a reply after kill cannot publish or restart polling", async () => {
+  await playbackTimers(async ({ client, intervals, advance, flush }) => {
+    let calls = 0, resolve;
+    const times = [], errors = [];
+    client.playbackTiming = () => { calls++; return new Promise(done => { resolve = done; }); };
+    const stream = await client.openPlayback({ rate: 500, channels: 1,
+      onTiming: value => times.push(value), onTimingError: error => errors.push(error) });
+    stream.write(new Uint8Array(2000));
+    await advance(160);
+    expect(calls).toBe(1);
+    expect(times).toEqual([]);
+    resolve({ writeIndex: 500, readIndex: 500, sinkSeconds: 0.4, playing: true });
+    await flush();
+    expect(times.map(value => value.seconds)).toEqual([0.1]);
+    await advance(160);
+    expect(calls).toBe(2);
+    stream.kill();
+    expect(intervals.size).toBe(0);
+    resolve({ writeIndex: 600, readIndex: 600, sinkSeconds: 0, playing: true });
+    await flush();
+    await advance(160);
+    expect(calls).toBe(2);
+    expect(times.map(value => value.seconds)).toEqual([0.1]);
+    expect(errors).toEqual([]);
+  });
+});
+
+test("streams without a timing consumer keep only the PCM pacing timer", async () => {
+  await playbackTimers(async ({ client, intervals, advance }) => {
+    let polls = 0;
+    client.playbackTiming = () => { polls++; throw Error("unexpected timing query"); };
+    const stream = await client.openPlayback({ rate: 500, channels: 1 });
+    expect([...intervals.values()].map(timer => timer.delay)).toEqual([50]);
+    await advance(1000);
+    expect(polls).toBe(0);
+    await stream.close();
+    expect(intervals.size).toBe(0);
+  });
+});
+
+test("timing rejection permits a retry and a late rejection after kill stays silent", async () => {
+  await playbackTimers(async ({ client, advance, flush }) => {
+    const pending = [], errors = [], times = [];
+    client.playbackTiming = () => new Promise((resolve, reject) => pending.push({ resolve, reject }));
+    const stream = await client.openPlayback({ rate: 500, channels: 1,
+      onTiming: value => times.push(value), onTimingError: error => errors.push(error.message) });
+    stream.write(new Uint8Array(2000));
+    await advance(160);
+    expect(pending).toHaveLength(1);
+    pending[0].reject(Error("pulse: timing request timed out"));
+    await flush();
+    expect(errors).toEqual(["pulse: timing request timed out"]);
+    await advance(16);
+    expect(pending).toHaveLength(2);
+    stream.kill();
+    pending[1].reject(Error("late timeout"));
+    await flush();
+    await advance(160);
+    expect(pending).toHaveLength(2);
+    expect(errors).toHaveLength(1);
+    expect(times).toEqual([]);
+  });
+});