buninu-browser 0.2.4 → 0.4.0

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/renderer-host.test.js

@@ -70,3 +70,14 @@ test("fetches only http(s)/data resources on the renderer's behalf", async () =>
     .toEqual({ error: "blocked script-with-cookies request for https:" });
   expect(requested).toEqual(["https://example.test/a.css"]);
 });
+
+
+test("explicit close prevents queued calls and captures from restarting the renderer", async () => {
+  const renderer = host();
+  const queued = renderer.call("title");
+  renderer.close();
+  await expect(queued).rejects.toThrow("Renderer is closed");
+  await expect(renderer.start()).rejects.toThrow("Renderer is closed");
+  await expect(renderer.composite("screenshot", { format: "bgra" })).rejects.toThrow("Renderer is closed");
+  expect(renderer.pid).toBeNull();
+});

package/test/text-input-pointer.test.js

@@ -0,0 +1,31 @@
+import {test,expect} from 'bun:test';
+import {createBrowser} from '../lib/headless-shell.js';
+test('pointer places the caret at shaped text, including selected and scrolled controls',async()=>{
+ const b=await createBrowser({spareRenderer:false});const run=s=>b.context.evaluate(s);
+ try{
+  await b.context.resize(500,400);
+  await b.context.navigate('data:text/html,'+encodeURIComponent(`<style>body{margin:0}input,textarea{display:block;margin:10px;padding:0;border:0;font:20px monospace;line-height:24px;width:160px}input{height:24px}textarea{height:72px}</style><input id="i" value="abcdefghij"><textarea id="t">abcde\nfghij\nklmno</textarea><input id="p" type="password" value="a😀bcd">`));
+  const pos=()=>run('({start:document.activeElement.selectionStart,end:document.activeElement.selectionEnd})');
+  // 20px monospace advances approximately 12px. Click the boundary after b.
+  await b.context.click(34,20);expect(await pos()).toEqual({start:2,end:2});
+  await b.context.press('a',{modifiers:2});await b.context.click(46,20);expect(await pos()).toEqual({start:3,end:3});
+  await b.context.type('X');expect(await run('document.getElementById("i").value')).toBe('abcXdefghij');
+  await run('document.getElementById("i").value="abcdefghijklmnopqrstuvwxyz"');
+  await b.context.press('End');
+  expect(await run('document.getElementById("i").scrollLeft')).toBeGreaterThan(0);
+  await b.context.click(45,20);const scrolled=await pos();expect(scrolled.start).toBeGreaterThan(10);expect(scrolled.start).toBeLessThan(26);
+  const top=await run('document.getElementById("t").getBoundingClientRect().top');
+  await b.context.click(34,top+36);expect(await pos()).toEqual({start:8,end:8});
+  await b.context.click(400,top+36); // outside must not reposition
+  expect(await pos()).toEqual({start:8,end:8});
+  await run('document.getElementById("t").value="abcde ".repeat(20);document.getElementById("t").focus();document.getElementById("t").setSelectionRange(0,0)');
+  await b.context.click(34,top+36);const wrapped=await pos();expect(wrapped.start).toBeGreaterThan(10);expect(wrapped.start).toBeLessThan(30);
+  await b.context.press('End',{modifiers:2});
+  expect(await run('document.getElementById("t").scrollTop')).toBeGreaterThan(0);
+  await b.context.click(34,top+12);expect((await pos()).start).toBeGreaterThan(60);expect((await pos()).start).toBeLessThan(120);
+  const passTop=await run('document.getElementById("p").getBoundingClientRect().top');
+  await b.context.click(34,passTop+12);expect(await pos()).toEqual({start:3,end:3});
+  await run('document.getElementById("i").onmousedown=e=>e.preventDefault();document.getElementById("i").focus();document.getElementById("i").setSelectionRange(5,5)');
+  await b.context.click(12,20);expect(await pos()).toEqual({start:5,end:5});
+ }finally{b.close();}
+},30000);

package/test/text-input-scroll.test.js

@@ -0,0 +1,29 @@
+import {test,expect} from 'bun:test';
+import {createBrowser} from '../lib/headless-shell.js';
+import {loadGraphics} from '../lib/renderer/page-renderer.js';
+test('text controls clip overflow, keep long inputs on one line and reveal the caret',async()=>{
+ const b=await createBrowser({spareRenderer:false});
+ const run=s=>b.context.evaluate(s);
+ try {
+  await b.context.resize(400,300);
+  await b.context.navigate('data:text/html,'+encodeURIComponent(`<style>body{margin:0;background:white}input,textarea{display:block;width:200px;box-sizing:border-box;border:1px solid black;padding:4px;font:18px monospace;margin:10px}input{height:36px}textarea{height:100px}</style><input id="i" value="${'abcdef'.repeat(20)}"><textarea id="t">${Array.from({length:12},(_,i)=>'第'+i+'行 abcdef').join('\n')}</textarea><button id="b">after</button>`));
+  const state=id=>run(`(()=>{const e=document.getElementById('${id}');return {x:e.scrollLeft,y:e.scrollTop,w:e.scrollWidth,h:e.scrollHeight,rect:e.getBoundingClientRect().toJSON()}})()`);
+  const initial=await state('i'),area=await state('t');
+  expect(area.rect.y).toBe(56);
+  expect((await run(`document.getElementById('b').getBoundingClientRect().top`))).toBeLessThan(180);
+  const {CanvasKit:k}=await loadGraphics();
+  const ink=async(x,y,w,h)=>{
+   const bytes=Buffer.from(await b.context.screenshot({format:'png'}),'base64'),im=k.MakeImageFromEncoded(bytes);
+   try{const p=im.readPixels(x,y,{width:w,height:h,colorType:k.ColorType.RGBA_8888,alphaType:k.AlphaType.Unpremul,colorSpace:k.ColorSpace.SRGB});let count=0;for(let i=0;i<p.length;i+=4)if(p[i]<180&&p[i+1]<180&&p[i+2]<180)count++;return count;}finally{im.delete();}
+  };
+  expect(await ink(212,10,180,145)).toBe(0);
+  for(const id of ['i','t']) {
+   await run(`document.getElementById('${id}').focus();document.getElementById('${id}').setSelectionRange(0,0)`);
+   await b.context.press('End',{modifiers:2});
+   const end=await state(id);expect(id==='i'?end.x:end.y).toBeGreaterThan(0);
+   if(id==='i'){expect(end.h).toBe(initial.h);expect(await ink(16,16,180,20)).toBeGreaterThan(100);}
+   await b.context.press('Home',{modifiers:2});const home=await state(id);expect(id==='i'?home.x:home.y).toBe(0);
+   await b.context.press('End',{modifiers:10});const selected=await state(id);expect(id==='i'?selected.x:selected.y).toBeGreaterThan(0);
+  }
+ }finally{b.close();}
+},30000);

package/test/text-input.test.js

@@ -0,0 +1,47 @@
+import {test,expect} from 'bun:test';
+import {RendererHost} from '../lib/renderer/host.js';
+
+test('HTML controls share selection, clipboard and blinking; API reads require user activation',async()=>{
+ let clipboard='貼上!',reads=0;
+ const host=new RendererHost({clipboardRead:async()=>{reads++;return clipboard;},clipboardWrite:async text=>{clipboard=text;}});
+ const run=s=>host.call('evaluate',s);
+ const wait=async predicate=>{for(let i=0;i<60;i++){if(await predicate())return;await Bun.sleep(25);}throw Error('Timed out');};
+ try {
+  await host.start();await host.call('resize',400,200,1);
+  await host.call('loadDocument',{url:'https://input.test/',contentType:'text/html',source:`<input id="i" value="abc😀xyz" style="width:300px;height:30px"><textarea id="t">abcd\nxy\n12345</textarea><button id="b">read</button><script>document.getElementById('b').onclick=async()=>{try{window.result=await navigator.clipboard.readText()}catch(e){window.result=e.name}}</script>`});
+  await host.call('whenLoaded');
+  await run(`document.getElementById('i').focus()`);
+  const state=()=>run(`(()=>{let e=document.getElementById('i');return [e.selectionStart,e.selectionEnd,e.value]})()`);
+  await host.call('press','a',{modifiers:2});expect((await state()).slice(0,2)).toEqual([0,8]);
+  await host.call('press','ArrowRight');expect((await state()).slice(0,2)).toEqual([8,8]);
+  await host.call('press','ArrowLeft',{modifiers:8});expect((await state()).slice(0,2)).toEqual([7,8]);
+  await host.call('press','c',{modifiers:2});await wait(()=>clipboard==='z');
+  await host.call('press','x',{modifiers:2});await wait(async()=>(await state())[2]==='abc😀xy');
+  clipboard='漢';await host.call('press','v',{modifiers:2});await wait(async()=>(await state())[2]==='abc😀xy漢');
+  await run(`document.getElementById('i').onkeydown=e=>{if(e.ctrlKey)e.preventDefault()}`);
+  await host.call('press','a',{modifiers:2});expect((await state()).slice(0,2)).toEqual([8,8]);
+  await run(`document.getElementById('t').focus();document.getElementById('t').setSelectionRange(3,3)`);
+  await host.call('press','ArrowDown',{modifiers:8});
+  expect(await run(`[document.getElementById('t').selectionStart,document.getElementById('t').selectionEnd]`)).toEqual([3,7]);
+  await host.call('press','ArrowDown',{modifiers:8});
+  expect(await run(`[document.getElementById('t').selectionStart,document.getElementById('t').selectionEnd]`)).toEqual([3,11]);
+  await run(`window.result='';document.getElementById('b').click()`);await wait(async()=>(await run('window.result'))!=='');
+  // The prior user action has already been consumed by paste, but arrow presses
+  // are also user activation. Consume once, then a synthetic click must fail.
+  await run(`window.result='';document.getElementById('b').click()`);await wait(async()=>(await run('window.result'))!=='');
+  expect(await run('window.result')).toBe('NotAllowedError');
+  const b=await run(`document.getElementById('b').getBoundingClientRect().toJSON()`);
+  await host.call('click',b.x+b.width/2,b.y+b.height/2);
+  await wait(async()=>(await run('window.result'))==='漢');
+  expect(reads).toBeGreaterThan(1);
+  await run(`document.getElementById('i').onkeydown=null;document.getElementById('i').focus();document.getElementById('i').select();document.getElementById('i').onbeforeinput=e=>e.preventDefault()`);
+  clipboard='blocked';await host.call('press','v',{modifiers:2});await Bun.sleep(100);
+  expect((await state())[2]).toBe('abc😀xy漢');
+  await run(`document.getElementById('i').type='password'`);
+  await host.call('press','c',{modifiers:2});await Bun.sleep(100);expect(clipboard).toBe('blocked');
+  await run(`document.getElementById('i').type='text'`);
+  await run(`document.getElementById('i').focus();document.getElementById('i').setSelectionRange(1,1)`);
+  const on=await host.call('screenshot',{format:'png'});await Bun.sleep(550);
+  const off=await host.call('screenshot',{format:'png'});expect(off).not.toBe(on);
+ } finally {host.close();}
+},30000);

package/test/wayland-frontend.test.js

@@ -0,0 +1,83 @@
+import {test,expect} from 'bun:test';
+import {encodeRequest,decode,interfaces} from '../frontends/wayland/protocol.js';
+import {parseKeymap,keysym} from '../frontends/wayland/input.js';
+import {chooseFrontend} from '../index.js';
+
+test('Wayland launcher remains opt-in',()=>{
+ expect(chooseFrontend(['--wayland','about:blank'])).toEqual({frontend:'wayland',args:['about:blank']});
+ expect(chooseFrontend(['about:blank']).frontend).toBe('casty');
+});
+test('registry bind encodes dynamic new_id and SHM fd stays out of payload',()=>{
+ const packet=encodeRequest(2,'wl_registry','bind',[7,'wl_compositor',4,3]);
+ expect(decode(interfaces.get('wl_registry').requests[0],packet.data,[])).toEqual([7,'wl_compositor',4,3]);
+ const pool=encodeRequest(4,'wl_shm','create_pool',[8,91,4096]);
+ expect(pool.fds).toEqual([91]);expect(pool.data.length).toBe(16);
+ expect(decode(interfaces.get('wl_shm').requests[0],pool.data,[91])).toEqual([8,91,4096]);
+ expect(decode(interfaces.get('wl_shm').requests[0],pool.data,[])).toBeNull();
+});
+test('bounded keymap subset understands named and Unicode keysyms',()=>{
+ const map=parseKeymap('<K30> = 38; key <K30> { type="ALPHABETIC", [ 0x61, 0x41 ] };');
+ expect(map.get(30).map(keysym)).toEqual(['a','A']);expect(keysym('0x01004e2d')).toBe('中');
+ expect(keysym('0xff0d')).toBe('Enter');expect(keysym('0xffe1')).toBeNull();expect(keysym('Left')).toBe('ArrowLeft');expect(keysym('dead_acute')).toBeNull();
+});
+
+// Optional sibling integration; never installs prerequisites or touches a running compositor.
+test.skipIf(process.env.BUNINU_TEST_WAYLAND!=='1')('Browser SHM, pointer, keyboard and resize in Land',async()=>{
+ const {mkdtempSync,rmSync}=await import('node:fs');
+ const {start}=await import('../../buninu-land/compositor.js');
+ const {launch}=await import('../frontends/wayland/index.js');
+ const dir=mkdtempSync('/tmp/buninu-wayland-test-'),old=process.env.XDG_RUNTIME_DIR;
+ process.env.XDG_RUNTIME_DIR=dir;let land,app;
+ const wait=async(fn)=>{for(let i=0;i<500;i++){if(await fn())return;await Bun.sleep(20);}throw Error('Timed out waiting for Wayland state');};
+ try{
+  land=await start(['--remote-debugging-port=0','--window-size=640,480']);
+  app=await launch({socket:dir+'/wayland-buninu',url:'data:text/html,'+encodeURIComponent('<title>Ready</title><body style="margin:0;background:rgb(255,0,255)"><input id="text" style="width:200px;height:60px" oninput="document.title=this.value"><button style="position:absolute;left:0;top:100px;width:200px;height:60px" onclick="document.title=\'Clicked\'">Click</button>')});
+  await wait(()=>land.compositor.wm.visible[0]?.surface.xdg.toplevel.title==='Ready');
+  const surface=()=>land.compositor.wm.renderSurfaces().find(s=>s.pixels);
+  await wait(()=>surface());expect(surface().pixels.width).toBe(app.window.width);
+  const click=async(x,y)=>{const o=land.compositor.wm.origin(surface());for(const type of ['mouseMoved','mousePressed','mouseReleased'])land.context.dispatchMouseEvent({type,x:o.x+x,y:o.y+y,button:'left'});};
+  await click(30,157);await wait(()=>land.compositor.wm.visible[0].surface.xdg.toplevel.title==='Clicked');
+  await click(30,57);land.context.type('hello');
+  await wait(()=>land.compositor.wm.visible[0].surface.xdg.toplevel.title==='hello');
+  // Editing browser chrome must not suspend page frames. Conversely, blinking
+  // chrome alone must reuse the last raw page frame rather than recapture it.
+  let captures=0,presents=0;
+  const screenshot=app.browser.context.screenshot.bind(app.browser.context);
+  app.browser.context.screenshot=(...args)=>{captures++;return screenshot(...args);};
+  const present=app.window.present.bind(app.window);
+  app.window.present=(...args)=>{presents++;return present(...args);};
+  await app.browser.context.evaluate('document.activeElement.blur()');
+  app.toolbar.open();
+  await Bun.sleep(800);
+  const idleCaptures=captures,idlePresents=presents;
+  await Bun.sleep(1100);
+  expect(captures).toBe(idleCaptures);
+  expect(presents).toBeGreaterThan(idlePresents);
+  await app.browser.context.evaluate(`globalThis.animationTick=0;globalThis.animationTimer=setInterval(()=>{document.body.style.background=++animationTick%2?'red':'blue'},80)`);
+  const animatedCaptures=captures,animatedPresents=presents;
+  await wait(()=>captures>=animatedCaptures+3&&presents>=animatedPresents+3);
+  expect(app.toolbar.editor.editing).toBe(true);
+  expect(Number(await app.browser.context.evaluate('animationTick'))).toBeGreaterThan(2);
+  await app.browser.context.evaluate('clearInterval(animationTimer)');
+  app.toolbar.editor.cancelEditing();
+  const before=app.window.width;land.context.resize(900,700,1);
+  await wait(()=>app.window.width!==before&&surface().pixels.width===app.window.width);
+  expect(JSON.parse(await app.browser.context.evaluate('JSON.stringify([innerWidth,innerHeight])'))).toEqual([app.window.width,app.window.height-32]);
+  for(const type of ['keyDown','keyUp'])land.context.dispatchKeyEvent({type,key:'w',code:'KeyW',modifiers:4});
+  await wait(()=>app.client.connection.closed&&land.compositor.wm.visible.length===0);
+  await app.done;
+  expect(app.window.closed).toBe(true);
+ }finally{app?.close();land?.close();if(old===undefined)delete process.env.XDG_RUNTIME_DIR;else process.env.XDG_RUNTIME_DIR=old;rmSync(dir,{recursive:true,force:true});}
+},30000);
+
+test('Wayland input queued around close never calls the disposed renderer',async()=>{
+ const {attachInput}=await import('../frontends/wayland/input.js');
+ let capabilities,pointer,calls=0,errors=0,reject;
+ const client={globals:new Map([['wl_seat',{}]]),connection:{closed:false},bind(_i,_v,fn){capabilities=fn;return 2;},object(iface,fn){if(iface==='wl_pointer')pointer=fn;return 3;},request(){}};
+ const window={surface:4,closed:false};
+ attachInput(client,window,{move(){calls++;return new Promise((_r,no)=>reject=no);}},()=>errors++);
+ capabilities('capabilities',[1]);pointer('enter',[1,4,0,0]);pointer('motion',[1,3,4]);
+ await Promise.resolve();expect(calls).toBe(1);
+ window.closed=true;reject(Error('Renderer closed'));pointer('motion',[2,4,5]);
+ await Bun.sleep(0);expect(calls).toBe(1);expect(errors).toBe(0);
+});

package/test/wayland-urlbar.test.js

@@ -0,0 +1,38 @@
+import {test,expect} from 'bun:test';
+import {WaylandUrlBar,WAYLAND_COMMANDS} from '../frontends/wayland/urlbar.js';
+const history={list:()=>[],add(){}};
+test('Wayland chrome retains Casty selection, insert-paste, mode switch and commands',async()=>{
+ let copied='',quit=false;const navigated=[];
+ const context={url:'https://example.com/',navigate:async url=>navigated.push(url)};
+ const bar=new WaylandUrlBar(context,{history,close:()=>quit=true,clipboard:{read:async()=>'/x',write:async text=>copied=text}});
+ try{
+  bar.updateURL(context.url);bar.open();
+  expect(bar.editor.selectedText).toBe(context.url);
+  await bar.press('ArrowRight');expect(bar.editor.selectedText).toBe('');
+  await bar.press('ArrowLeft',{modifiers:8});expect(bar.editor.selectedText).toBe('/');
+  await bar.press('c',{modifiers:2});expect(copied).toBe('/');
+  await bar.press('v',{modifiers:2});expect(bar.editor.text).toBe('https://example.com/x');
+  await bar.press('ArrowRight');await bar.press('v',{modifiers:2});
+  expect(bar.editor.text).toBe('https://example.com/x/x');
+  await bar.press('ArrowLeft',{modifiers:8});
+  await bar.press('c',{modifiers:1});expect(copied).toBe('x');
+  await bar.press('Tab');expect(bar.editor.mode).toBe('cmd');
+  await bar.press('Tab');expect(bar.editor.mode).toBe('url');
+  await bar.press('Escape');expect(bar.editor.editing).toBe(false);
+  await bar.command('open https://example.org/');expect(navigated).toEqual(['https://example.org/']);
+  expect(WAYLAND_COMMANDS.some(c=>c.name==='cdp')).toBe(false);
+  await bar.command('q');expect(quit).toBe(true);
+ }finally{bar.dispose();}
+});
+test('Toolbar raster cache and horizontal scrolling preserve page-independent rendering',async()=>{
+ const bar=await new WaylandUrlBar({},{history}).initialize();
+ try{
+  bar.updateURL('https://example.com/'+'long-path/'.repeat(20));
+  const pixels=bar.pixels(320);expect(pixels.length).toBe(320*32*4);expect(bar.pixels(320)).toBe(pixels);
+  bar.open();await bar.press('ArrowRight');bar.pixels(320);
+  expect(bar.editor._scrollX).toBeGreaterThan(0);
+  await bar.press('Home');bar.pixels(320);expect(bar.editor._scrollX).toBe(0);
+  bar.editor.pointerDown(5,1000);bar.editor.pointerMove(10);bar.editor.pointerUp();
+  expect(bar.editor.selectedText.length).toBeGreaterThan(0);
+ }finally{bar.dispose();}
+});

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