buninu-browser 0.2.4 → 0.3.0

package/test/fixtures/raw-capture-benchmark.json

@@ -0,0 +1,76 @@
+{
+  "sandbox": {
+    "seccomp": {
+      "installed": true,
+      "reason": null
+    },
+    "ses": {
+      "installed": true,
+      "reason": null
+    }
+  },
+  "capture": [
+    1920,
+    1035
+  ],
+  "reports": [
+    {
+      "format": "png",
+      "count": 20,
+      "meanMs": 168.16266580000007,
+      "medianMs": 167.81952999999976,
+      "bytes": 123889
+    },
+    {
+      "format": "jpeg",
+      "count": 20,
+      "meanMs": 42.5512477499999,
+      "medianMs": 41.08310699999947,
+      "bytes": 150292
+    },
+    {
+      "format": "rgba",
+      "count": 20,
+      "meanMs": 22.61524315000006,
+      "medianMs": 23.11667800000032,
+      "bytes": 7948800
+    },
+    {
+      "format": "bgra",
+      "count": 20,
+      "meanMs": 25.103456849999976,
+      "medianMs": 25.162263999999595,
+      "bytes": 7948800
+    },
+    {
+      "format": "bgra",
+      "count": 20,
+      "meanMs": 24.67374660000005,
+      "medianMs": 25.82330600000023,
+      "bytes": 7948800
+    },
+    {
+      "format": "rgba",
+      "count": 20,
+      "meanMs": 21.321299350000118,
+      "medianMs": 21.798502999999982,
+      "bytes": 7948800
+    },
+    {
+      "format": "jpeg",
+      "count": 20,
+      "meanMs": 43.68695314999977,
+      "medianMs": 46.23293099999864,
+      "bytes": 150292
+    },
+    {
+      "format": "png",
+      "count": 20,
+      "meanMs": 169.70291704999983,
+      "medianMs": 169.88830599999892,
+      "bytes": 123889
+    }
+  ],
+  "method": "Native Intel i5-5200U, alternating viewport crops, three warmups then 20 captures per pass; round trip includes controller file write for raw. Not terminal FPS.",
+  "date": "2026-10-22"
+}

package/test/raw-capture.test.js

@@ -0,0 +1,152 @@
+import {test,expect} from 'bun:test';
+import {readFileSync,existsSync,unlinkSync} from 'node:fs';
+import {dirname} from 'node:path';
+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';
+import CanvasKitInit from '../usr/lib/canvaskit/canvaskit.js';
+const kit=CanvasKitInit({wasmBinary:readFileSync(new URL('../usr/lib/canvaskit/canvaskit.wasm',import.meta.url))});
+
+test('binary channel handles fragmented packets, rejects oversized input and authenticates peers',async()=>{
+ const results=[];const reader=new PacketReader((message,pixels)=>results.push([message,[...pixels]]));
+ const bytes=Buffer.concat([encodePacket({id:1},Uint8Array.of(1,2,3)),encodePacket({id:2})]);
+ for(let i=0;i<bytes.length;i++)reader.push(bytes.subarray(i,i+1));
+ expect(results).toEqual([[{id:1},[1,2,3]],[{id:2},[]]]);
+ const header=Buffer.alloc(8);header.writeUInt32LE(0xffffffff,0);
+ expect(()=>new PacketReader(()=>{}).push(header)).toThrow('size');
+ let reply;const got=new Promise(resolve=>reply=resolve);
+ const server=await listenCompositor((message,pixels)=>{server.send({id:message.id,length:pixels.length});},()=>{});
+ let peer;
+ try{
+  await expect(connectCompositor({...server.endpoint,token:'wrong'},()=>{},()=>{})).rejects.toThrow();
+  peer=await connectCompositor(server.endpoint,message=>reply(message),()=>{});
+  peer.send({id:8},new Uint8Array(1024));expect(await got).toEqual({id:8,length:1024});
+ }finally{peer?.close();server.close();}
+});
+
+test('raw file owner rejects malformed input and bounds unconsumed frames',()=>{
+ const store=new RawFrames();let path;
+ try{
+  expect(()=>store.write(new Uint8Array(3),1,1,'rgba')).toThrow('Invalid');
+  for(let i=0;i<16;i++)path=JSON.parse(store.write(new Uint8Array(4),1,1,'rgba')).path;
+  expect(()=>store.write(new Uint8Array(4),1,1,'rgba')).toThrow('stalled');
+ }finally{store.close();}
+ expect(existsSync(dirname(path))).toBe(false);
+});
+
+for(const compositor of [true,false])test(`raw screenshots match PNG and stay fresh after consumer deletion (compositor=${compositor})`,async()=>{
+ const host=new RendererHost({compositor});let directory;
+ try{
+  await host.start();await host.call('resize',32,24,1);
+  await host.call('loadDocument',{url:'https://page.test/',source:'<body style="margin:0;background:rgb(211,73,19)">',contentType:'text/html'});
+  await host.call('whenLoaded');
+  const png=await host.composite('screenshot',{format:'png'});
+  const CK=await kit;const image=CK.MakeImageFromEncoded(Buffer.from(png,'base64'));
+  const reference=image.readPixels(0,0,{width:32,height:24,colorType:CK.ColorType.RGBA_8888,alphaType:CK.AlphaType.Unpremul,colorSpace:CK.ColorSpace.SRGB});image.delete();
+  for(const format of ['rgba','bgra']){
+   const frame=JSON.parse(await host.composite('screenshot',{format}));directory=dirname(frame.path);
+   const pixels=readFileSync(frame.path);expect(pixels.length).toBe(32*24*4);
+   if(format==='bgra')for(let i=0;i<pixels.length;i+=4){const r=pixels[i];pixels[i]=pixels[i+2];pixels[i+2]=r;}
+   expect([...pixels]).toEqual([...reference]);unlinkSync(frame.path);
+   const next=JSON.parse(await host.composite('screenshot',{format}));expect(next.path).not.toBe(frame.path);expect(existsSync(next.path)).toBe(true);unlinkSync(next.path);
+  }
+  if(compositor){
+   const busy=host.call('evaluate',"(()=>{const end=Date.now()+1800;while(Date.now()<end);return 1})()");await Bun.sleep(150);
+   const start=performance.now();const raw=JSON.parse(await host.composite('screenshot',{format:'bgra'}));
+   expect(performance.now()-start).toBeLessThan(1400);unlinkSync(raw.path);await busy;
+  }
+ }finally{host.close();}
+ expect(existsSync(directory)).toBe(false);
+},20000);
+
+test('normal CDP routes raw requests to the controller without changing standard screenshots',async()=>{
+ const {createBrowser}=await import('../lib/headless-shell.js');
+ const {CdpServer}=await import('../lib/cdp-server.js');
+ const {CDP}=await import('../tools/browser-lab.js');
+ const browser=await createBrowser({spareRenderer:false});
+ const server=CdpServer.create(browser.context).listen(0,'127.0.0.1');
+ const cdp=new CDP(`ws://127.0.0.1:${server.port}/devtools/browser/cdp-server`);
+ let directory;
+ try{
+  await cdp.ready;const {targetId}=await cdp.send('Target.createTarget',{url:'about:blank'});
+  const {sessionId}=await cdp.send('Target.attachToTarget',{targetId,flatten:true});cdp.sessionId=sessionId;
+  await cdp.send('Emulation.setDeviceMetricsOverride',{width:16,height:9,deviceScaleFactor:1.75,mobile:false});
+  const metrics=await cdp.send('Page.getLayoutMetrics');
+  expect(metrics.cssVisualViewport).toMatchObject({pageX:0,pageY:0});
+  const {data}=await cdp.send('Page.captureScreenshot',{format:'bgra',clip:{x:0,y:0,width:16,height:15/1.75,scale:1}});
+  const frame=JSON.parse(data);directory=dirname(frame.path);
+  expect(frame).toMatchObject({version:1,transport:'file',format:'bgra',width:28,height:15});expect(existsSync(frame.path)).toBe(true);
+  cdp.events.length=0;
+  await cdp.send('Page.startScreencast',{format:'png',maxWidth:4,maxHeight:2,clip:{x:0,y:0,width:4,height:2,scale:1},everyNthFrame:1});
+  let event;for(let i=0;i<100;i++){event=cdp.events.find(e=>e.method==='Page.screencastFrame');if(event)break;await Bun.sleep(20);}
+  expect(event).toBeDefined();
+  const crop=Buffer.from(event.params.data,'base64');
+  // Native 1.75 density is preserved, rather than rescaling to maxWidth/maxHeight.
+  expect([crop.readUInt32BE(16),crop.readUInt32BE(20)]).toEqual([7,4]);
+  await cdp.send('Page.screencastFrameAck',{sessionId:event.params.sessionId});
+  await cdp.send('Page.stopScreencast');
+  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();
+ await expect(pending).rejects.toThrow('closed');
+ try{await host.start();expect(host.pid).toBeGreaterThan(0);}finally{host.close();}
+},15000);
+
+for(const compositor of [true,false])test(`fractional CDP clips preserve exact physical dimensions and raw pixels (compositor=${compositor})`,async()=>{
+ const host=new RendererHost({compositor});
+ try {
+  await host.start();await host.call('resize',16,9,1.75);
+  await host.call('loadDocument',{url:'https://clip.test/',contentType:'text/html',source:'<body style="margin:0;background:red"><div style="height:3px;background:blue"></div><div style="height:100px"></div>'});
+  await host.call('whenLoaded');
+  const full=JSON.parse(await host.composite('screenshot',{format:'rgba'}));
+  expect([full.width,full.height]).toEqual([28,16]);
+  const clip={x:0,y:0,width:16,height:15/1.75,scale:1};
+  const cropped=JSON.parse(await host.composite('screenshot',{format:'rgba',clip}));
+  expect([cropped.width,cropped.height]).toEqual([28,15]);
+  expect(readFileSync(cropped.path)).toEqual(readFileSync(full.path).subarray(0,28*15*4));
+  const CK=await kit;const png=CK.MakeImageFromEncoded(Buffer.from(await host.composite('screenshot',{format:'png',clip}),'base64'));
+  expect([png.width(),png.height()]).toEqual([28,15]);png.delete();
+  await host.composite('scroll',0,4);
+  const offset=await host.composite('scrollOffset');
+  const scrolled=JSON.parse(await host.composite('screenshot',{format:'bgra',clip:{...clip,y:offset.y}}));
+  expect([...readFileSync(scrolled.path).subarray(0,4)]).toEqual([0,0,255,255]);
+  await expect(host.composite('screenshot',{format:'rgba',clip:{...clip,width:Infinity}})).rejects.toThrow();
+ }finally{host.close();}
+},20000);
+
+test('scale-one full-width fractional clip borrows contiguous raster bytes',async()=>{
+ const {captureViewport}=await import('../lib/paint/frame.js');
+ const tile={x:0,y:0,scale:1.75,pixelWidth:28,pixelHeight:16,pixels:new Uint8Array(28*16*4)};
+ const frame=captureViewport(tile,0,0,16,9,{x:0,y:0,width:16,height:15/1.75,scale:1});
+ expect(frame.pixels.buffer).toBe(tile.pixels.buffer);
+ expect(frame.pixels.byteLength).toBe(28*15*4);
+});
+
+test('in-flight raw capture follows an origin renderer swap without exposing compositor closed',async()=>{
+ const {createBrowser}=await import('../lib/headless-shell.js');
+ const server=Bun.serve({port:0,fetch:()=>new Response('<body style="margin:0;background:rgb(211,73,19)">',{headers:{'content-type':'text/html'}})});
+ const browser=await createBrowser({spareRenderer:false});
+ const original=RendererHost.prototype.composite;let rejectCapture,armed=true;
+ const reached=Promise.withResolvers();
+ RendererHost.prototype.composite=function(method,...params){
+  if(armed&&method==='screenshot'){
+   armed=false;reached.resolve();return new Promise((_,reject)=>rejectCapture=reject);
+  }
+  return original.call(this,method,...params);
+ };
+ try{
+  const pending=browser.context.screenshot({format:'bgra'});
+  await reached.promise;
+  await browser.context.navigate(`http://127.0.0.1:${server.port}/`);
+  rejectCapture(Error('compositor closed'));
+  const frame=JSON.parse(await pending);const bytes=readFileSync(frame.path);
+  expect(frame.format).toBe('bgra');expect([...bytes.subarray(0,4)]).toEqual([19,73,211,255]);
+  unlinkSync(frame.path);
+ }finally{RendererHost.prototype.composite=original;browser.close();server.stop(true);}
+},20000);

package/test/window-resize.test.js

@@ -0,0 +1,36 @@
+import {test, expect} from 'bun:test';
+import {RendererHost} from '../lib/renderer/host.js';
+
+test('viewport resize notifies window listeners with fresh geometry and repaints their changes',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try {
+  await host.start();
+  await host.call('resize',320,240,1);
+  await host.call('loadDocument',{url:'https://resize.test/',contentType:'text/html',
+   source:'<body style="margin:0"><div id="box" style="width:100%;height:10px"></div><canvas id="canvas"></canvas></body>'});
+  await host.call('whenLoaded');
+  await host.call('evaluate',`window.events=[];window.propertyEvents=0;
+   window.onresize=()=>window.propertyEvents++;
+   window.addEventListener('resize',e=>{
+    const c=document.getElementById('canvas');
+    c.width=innerWidth;c.height=innerHeight;
+    events.push([innerWidth,innerHeight,devicePixelRatio,
+      document.getElementById('box').getBoundingClientRect().width,
+      e.target===window,e.bubbles,e.cancelable]);
+    document.body.style.backgroundColor='rgb(17,34,51)';
+   });`);
+  await host.call('resize',400,300,1.5);
+  expect(await host.call('evaluate','JSON.stringify(events)')).toBe('[[400,300,1.5,400,true,false,false]]');
+  expect(await host.call('evaluate','propertyEvents')).toBe(1);
+  expect(await host.call('evaluate',`[document.getElementById('canvas').width,document.getElementById('canvas').height].join(',')`)).toBe('400,300');
+  const png=Buffer.from(await host.composite('screenshot',{format:'png'}),'base64');
+  expect([png.readUInt32BE(16),png.readUInt32BE(20)]).toEqual([600,450]);
+  expect(await host.call('evaluate',"getComputedStyle(document.body).backgroundColor")).toBe('rgba(17, 34, 51, 1)');
+  await host.call('resize',400,300,1.5);
+  await host.call('resize',400,300,2);
+  expect(await host.call('evaluate','events.length')).toBe(1);
+  await host.call('resize',400,200,2);
+  expect(await host.call('evaluate','JSON.stringify(events[1])')).toBe('[400,200,2,400,true,false,false]');
+  expect(await host.call('evaluate','propertyEvents')).toBe(2);
+ }finally{host.close();}
+},30000);

package/tools/bench-raw-capture.js

@@ -0,0 +1,32 @@
+// Run with Bun on the host to measure capture delivery, not terminal FPS.
+// Uses a local synthetic page, the normal renderer sandbox and changing crops.
+import {RendererHost} from '../lib/renderer/host.js';
+import {statSync,unlinkSync} from 'node:fs';
+const count=Number(process.argv.find(a=>a.startsWith('--samples='))?.split('=')[1] ?? 30);
+if(!Number.isInteger(count)||count<1||count>1000)throw Error('Invalid sample count');
+const host=new RendererHost();
+const reports=[];
+try{
+ await host.start();await host.call('resize',1280,690,1.5);
+ await host.call('loadDocument',{url:'https://benchmark.test/',contentType:'text/html',source:'<body style="margin:0">'+Array.from({length:80},(_,i)=>`<div style="height:44px;background:rgb(${i*17%256},${i*37%256},${i*71%256})">Frame ${i} 中文 ABCDEFG 0123456789</div>`).join('')});
+ await host.call('whenLoaded');await Bun.sleep(500);
+ const formats=process.argv.find(a=>a.startsWith('--formats='))?.slice('--formats='.length).split(',') ?? ['png','jpeg','rgba','bgra','bgra','rgba','jpeg','png'];
+ for(const format of formats){
+  if(!['png','jpeg','rgba','bgra'].includes(format))throw Error('Invalid format');
+  const samples=[];let bytes=0;
+  for(let i=0;i<count+3;i++){
+   await host.composite('scroll',0,i%2?17:-17);
+   const start=performance.now();
+   const data=await host.composite('screenshot',{format,quality:85,optimizeForSpeed:true});
+   const ms=performance.now()-start;
+   if(format==='rgba'||format==='bgra'){
+    const f=JSON.parse(data);bytes=statSync(f.path).size;unlinkSync(f.path);
+   }else bytes=Buffer.byteLength(data,'base64');
+   if(i>=3)samples.push(ms);
+  }
+  samples.sort((a,b)=>a-b);
+  const report={format,count,meanMs:samples.reduce((a,b)=>a+b,0)/count,medianMs:samples[Math.floor(count/2)],bytes};
+  reports.push(report);console.log(JSON.stringify(report));
+ }
+ console.log(JSON.stringify({sandbox:host.sandbox,capture:[1920,1035],reports}));
+}finally{host.close();}