buninu-browser 0.5.1 → 0.6.0

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([]);
+  });
+});

package/test/raw-capture.test.js

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

package/test/renderer-host.test.js

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

package/test/resource-discovery.test.js

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