buninu-browser 0.4.0 → 0.5.0

package/test/qml-socket.test.js

@@ -0,0 +1,60 @@
+import {test,expect} from 'bun:test';
+import {mkdtemp,rm} from 'node:fs/promises';
+import {createServer} from 'node:net';
+import {createBrowser} from '../lib/headless-shell.js';
+
+test('local QML Socket connects, splits UTF-8 messages, writes and disconnects',async()=>{
+ const dir=await mkdtemp('/tmp/qml-socket-');
+ const peers=new Set(); let received='';
+ const server=createServer(socket=>{
+  peers.add(socket);socket.on('close',()=>peers.delete(socket));
+  socket.on('data',data=>{received+=data;});
+  const bytes=Buffer.from('你好\nsecond\n');
+  socket.write(bytes.subarray(0,2));setTimeout(()=>socket.write(bytes.subarray(2)),20);
+ });
+ await new Promise(r=>server.listen(dir+'/engine.sock',r));
+ const browser=await createBrowser({spareRenderer:false});
+ try{
+  await Bun.write(dir+'/main.qml',`import QtQuick\nimport QtQuick.Window\nimport Quickshell.Io
+Item { Socket { id: socket; path: ${JSON.stringify(dir+'/engine.sock')}; connected: true
+ parser: SplitParser { onRead: data => { globalThis.messages.push(data); socket.write(data + "!"); socket.flush(); } }
+ onConnectedChanged: (globalThis.states ??= []).push(connected)
+ Component.onCompleted: { globalThis.messages=[]; globalThis.states=[]; globalThis.sock=socket; }
+} }`);
+  await browser.context.navigate('file://'+dir+'/main.qml');
+  for(let i=0;i<100;i++){if(await browser.context.evaluate('globalThis.messages?.length===2'))break;await Bun.sleep(20);}
+  expect(await browser.context.evaluate('messages')).toEqual(['你好','second']);
+  expect(await browser.context.evaluate('sock.connected')).toBe(true);
+  for(let i=0;i<100&&!received.includes('second!');i++)await Bun.sleep(10);
+  expect(received).toBe('你好!second!');
+  await browser.context.evaluate('sock.connected=false');
+  for(let i=0;i<100&&peers.size;i++)await Bun.sleep(10);
+  expect(peers.size).toBe(0);
+  expect(await browser.context.evaluate('sock.connected')).toBe(false);
+ }finally{browser.close();for(const p of peers)p.destroy();await new Promise(r=>server.close(r));await rm(dir,{recursive:true,force:true});}
+},20000);
+
+test('Socket failure can reconnect and navigation closes the live connection',async()=>{
+ const dir=await mkdtemp('/tmp/qml-socket-retry-');
+ const peers=new Set();
+ const server=createServer(s=>{peers.add(s);s.on('close',()=>peers.delete(s));});
+ const browser=await createBrowser({spareRenderer:false});
+ try{
+  await Bun.write(dir+'/main.qml',`import QtQuick\nimport Quickshell.Io
+Item { Socket {id:s; path:${JSON.stringify(dir+'/retry.sock')};connected:true
+onError:error=>{globalThis.socketError=error;}
+Component.onCompleted:globalThis.socketObject=s
+} }`);
+  await browser.context.navigate('file://'+dir+'/main.qml');
+  for(let i=0;i<100;i++){if(await browser.context.evaluate('!!globalThis.socketError'))break;await Bun.sleep(10);}
+  expect(await browser.context.evaluate('socketObject.connected')).toBe(false);
+  expect(await browser.context.evaluate('socketError')).toBe('ENOENT');
+  await new Promise(r=>server.listen(dir+'/retry.sock',r));
+  await browser.context.evaluate('socketObject.connected=true');
+  for(let i=0;i<100;i++){if(await browser.context.evaluate('socketObject.connected'))break;await Bun.sleep(10);}
+  expect(await browser.context.evaluate('socketObject.connected')).toBe(true);
+  await browser.context.navigate('data:text/html,<p>ordinary page</p>');
+  for(let i=0;i<100&&peers.size;i++)await Bun.sleep(10);
+  expect(peers.size).toBe(0);
+ }finally{browser.close();for(const p of peers)p.destroy();await new Promise(r=>server.close(r));await rm(dir,{recursive:true,force:true});}
+},20000);

package/test/qml-software-shader.test.js

@@ -0,0 +1,55 @@
+import {test,expect,beforeAll} from 'bun:test';
+import init from '../usr/lib/canvaskit/canvaskit.js';
+import {compileFragment,makeFragmentShader,translateFragment} from '../lib/qml/shader/fragment.js';
+let kit;
+beforeAll(async()=>{kit=await init({wasmBinary:await Bun.file(new URL('../usr/lib/canvaskit/canvaskit.wasm',import.meta.url)).arrayBuffer()});});
+const header=`#version 440
+layout(location=0) in vec2 qt_TexCoord0;
+layout(location=0) out vec4 fragColor;
+layout(std140,binding=0) uniform buf {mat4 qt_Matrix;float qt_Opacity;};`;
+function pixel(compiled,options,x=0,y=0){
+ const surface=kit.MakeSurface(options.width,options.height),paint=new kit.Paint();
+ const shader=makeFragmentShader(compiled,options);
+ try{
+  paint.setShader(shader);surface.getCanvas().drawRect(kit.XYWHRect(0,0,options.width,options.height),paint);surface.flush();
+  const image=surface.makeImageSnapshot();
+  try{return Array.from(image.readPixels(x,y,{width:1,height:1,colorType:kit.ColorType.RGBA_8888,alphaType:kit.AlphaType.Unpremul,colorSpace:kit.ColorSpace.SRGB}));}finally{image.delete();}
+ }finally{paint.delete();shader.delete();surface.delete();}
+}
+test('Qt fragment uniform and coordinate mapping executes on CPU raster surface',()=>{
+ const c=compileFragment(kit,header+'uniform int mode; void main(){fragColor=mode==2?vec4(qt_TexCoord0,0,1):vec4(0);fragColor*=qt_Opacity;}');
+ try{const p=pixel(c,{width:16,height:16,uniforms:{mode:2}},8,8);expect(p).toEqual([135,135,0,255]);}finally{c.effect.delete();}
+});
+test('CPU child texture sampling and textureSize preserve source pixel dimensions',()=>{
+ const image=kit.MakeImage({width:2,height:1,colorType:kit.ColorType.RGBA_8888,alphaType:kit.AlphaType.Premul,colorSpace:kit.ColorSpace.SRGB},new Uint8Array([255,0,0,255,0,255,0,255]),8);
+ const child=image.makeShaderOptions(kit.TileMode.Clamp,kit.TileMode.Clamp,kit.FilterMode.Nearest,kit.MipmapMode.None);
+ const c=compileFragment(kit,header+'layout(binding=1) uniform sampler2D source;void main(){if(textureSize(source,0)!=ivec2(2,1)){fragColor=vec4(0,0,1,1);return;}fragColor=texture(source,qt_TexCoord0);}');
+ try{
+  const options={width:4,height:2,textures:{source:{shader:child,width:2,height:1}}};
+  expect(pixel(c,options,0,0)).toEqual([255,0,0,255]);
+  expect(pixel(c,options,3,0)).toEqual([0,255,0,255]);
+  expect(()=>makeFragmentShader(c,{width:1,height:1})).toThrow('Missing shader texture');
+ }finally{c.effect.delete();child.delete();image.delete();}
+});
+test('unsupported shader interfaces fail rather than rendering a success placeholder',()=>{
+ expect(()=>translateFragment('#include "missing"')).toThrow('preprocessor');
+ expect(()=>translateFragment(header+'void main(){discard;}')).toThrow('Unsupported');
+ expect(()=>compileFragment(kit,header+'void main(){fragColor=unknown();}')).toThrow('compilation failed');
+});
+
+import {deflateSync} from 'node:zlib';
+import {fragmentSource} from '../lib/qml/shader/qsb.js';
+function qsb(source){
+ const text=Buffer.from(source),head=Buffer.alloc(28),tail=Buffer.from([0,0,0,4,109,97,105,110]);
+ [9,4,1,150,0,0,text.length].forEach((n,i)=>head.writeUInt32BE(n,i*4));
+ const raw=Buffer.concat([head,text,tail]),size=Buffer.alloc(4);size.writeUInt32BE(raw.length);
+ return Buffer.concat([size,deflateSync(raw)]);
+}
+test('QSB source records are validated and generated struct uniforms compile',()=>{
+ const source='#version 150\nstruct buf {float gain;};uniform buf _12;out vec4 fragColor;void main(){fragColor=vec4(_12.gain,0,0,1);}';
+ expect(fragmentSource(qsb(source))).toBe(source);
+ const c=compileFragment(kit,fragmentSource(qsb(source)));
+ try{expect(pixel(c,{width:1,height:1,uniforms:{gain:1}})).toEqual([255,0,0,255]);}finally{c.effect.delete();}
+ expect(()=>fragmentSource(qsb(source).subarray(0,10))).toThrow();
+ expect(()=>fragmentSource(qsb(source.replace('#version 150','#version 100')))).toThrow('no supported');
+});

package/test/qml-window-update.test.js

@@ -0,0 +1,36 @@
+import {test,expect} from 'bun:test';
+import {RendererHost} from '../lib/renderer/host.js';
+
+test('Window.update coalesces requests and emits frame signals, including reentrant requests',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try {
+  await host.start();
+  await host.call('loadDocument',{url:'data:text/x-qml,window-update',contentType:'text/x-qml',source:`import QtQuick
+import Quickshell
+FloatingWindow {width:200;height:100
+ Item {id:child;Component.onCompleted:globalThis.testWindow=child.Window.window}
+}`});
+  await host.call('whenLoaded');
+  const result=await host.call('evaluate',`(()=>{
+   const original=requestAnimationFrame, cancel=cancelAnimationFrame;
+   const queue=new Map();let next=0,animated=0,synced=0;
+   globalThis.requestAnimationFrame=fn=>{queue.set(++next,fn);return next};
+   globalThis.cancelAnimationFrame=id=>queue.delete(id);
+   const w=testWindow;
+   const animate=()=>{animated++;if(animated===1)w.update()};
+   const sync=()=>synced++;
+   const step=()=>{const [id,fn]=queue.entries().next().value;queue.delete(id);fn(0)};
+   try {
+    w.update();w.update();const coalesced=queue.size;
+    w.afterAnimating.connect(animate);w.afterSynchronizing.connect(sync);
+    step();const reentrant=queue.size;
+    step();
+    w.afterAnimating.disconnect(animate);w.afterSynchronizing.disconnect(sync);
+    step();const idle=queue.size;
+    w.update();step();step();const idleAfterUnobserved=queue.size;
+    return {coalesced,reentrant,animated,synced,idle,idleAfterUnobserved};
+   }finally{globalThis.requestAnimationFrame=original;globalThis.cancelAnimationFrame=cancel}
+  })()`);
+  expect(result).toEqual({coalesced:1,reentrant:1,animated:2,synced:2,idle:0,idleAfterUnobserved:0});
+ }finally{host.close()}
+},30000);

package/test/render-interval.test.js

@@ -0,0 +1,33 @@
+import {test, expect} from "bun:test";
+import {renderMinInterval, RENDER_INTERVAL_FLAG} from "../lib/renderer/render-interval.js";
+import {RendererHost} from "../lib/renderer/host.js";
+
+test("render interval validates boundaries without silently accepting malformed values", () => {
+  for (const [value, expected] of [[undefined,16],["0",0],["8",8],["16",16],["60000",60000]]) {
+    const warnings=[];expect(renderMinInterval(value,s=>warnings.push(s))).toBe(expected);expect(warnings).toEqual([]);
+  }
+  for (const value of ["","-1","60001","1.5","8ms","Infinity","NaN"," 8 "]) {
+    const warnings=[];expect(renderMinInterval(value,s=>warnings.push(s))).toBe(16);expect(warnings.length).toBe(1);
+  }
+});
+
+test("renderer receives configured interval on launch without inheriting host environment", async () => {
+  const old=process.env.BUNINU_RENDER_MIN_INTERVAL, secret=process.env.BUNINU_TEST_PRIVATE_ENV;
+  let host;
+  try {
+    process.env.BUNINU_TEST_PRIVATE_ENV="must-not-leak";
+    for (const interval of ["8","0","60000"]) {
+      process.env.BUNINU_RENDER_MIN_INTERVAL=interval;
+      host=new RendererHost({entry:new URL("./fixtures/fake-renderer.js",import.meta.url).pathname});
+      await host.start();
+      const result=await host.call("configuration");
+      expect(result.args).toContain(RENDER_INTERVAL_FLAG+interval);
+      expect(result.secret).toBeUndefined();
+      host.close();
+    }
+  } finally {
+    host?.close();
+    if(old===undefined)delete process.env.BUNINU_RENDER_MIN_INTERVAL;else process.env.BUNINU_RENDER_MIN_INTERVAL=old;
+    if(secret===undefined)delete process.env.BUNINU_TEST_PRIVATE_ENV;else process.env.BUNINU_TEST_PRIVATE_ENV=secret;
+  }
+});

package/test/title-no-paint.test.js

@@ -0,0 +1,6 @@
+import {test,expect} from 'bun:test';
+test('live title reads do not flush pending layout and paint, including empty titles',async()=>{
+ const child=Bun.spawn([process.execPath,new URL('./fixtures/title-no-paint.js',import.meta.url).pathname],{stdout:'pipe',stderr:'pipe'});
+ const [exit,stderr]=await Promise.all([child.exited,new Response(child.stderr).text()]);
+ expect(stderr).toBe('');expect(exit).toBe(0);
+},15000);

package/test/wayland-scroll.test.js

@@ -0,0 +1,40 @@
+import {test,expect} from 'bun:test';
+import {mkdtempSync,rmSync} from 'node:fs';
+
+// Opt-in sibling integration, with its own socket; never touches the user's Land.
+test.skipIf(process.env.BUNINU_TEST_WAYLAND!=='1')('Casty SGR wheel -> Land -> browser scrolls both DOM axes',async()=>{
+ const {start}=await import('../../buninu-land/compositor.js');
+ const {mouseWheelEvent}=await import('../../casty/lib/input.js');
+ const {launch}=await import('../frontends/wayland/index.js');
+ const dir=mkdtempSync('/tmp/browser-wheel-'),old=process.env.XDG_RUNTIME_DIR;
+ process.env.XDG_RUNTIME_DIR=dir;let land,app;
+ const wait=async(fn)=>{for(let n=0;n<300;n++){if(await fn())return;await Bun.sleep(20)}throw Error('Scroll timed out')};
+ try{
+  land=await start(['--remote-debugging-port=0','--window-size=640,480']);
+  app=await launch({socket:dir+'/wayland-buninu',url:'data:text/html,'+encodeURIComponent('<style>body{margin:0}#box{width:400px;height:250px;overflow:auto}#content{width:1600px;height:1600px;background:linear-gradient(red,blue)}</style><div id="box"><div id="content"></div></div>')});
+  const state=async()=>JSON.parse(await app.browser.context.evaluate('JSON.stringify([document.getElementById("box").scrollLeft,document.getElementById("box").scrollTop])'));
+  await wait(()=>land.compositor.wm.renderSurfaces().some(s=>s.pixels));
+  const surface=land.compositor.wm.renderSurfaces().find(s=>s.pixels),origin=land.compositor.wm.origin(surface);
+  const wheel=code=>land.context.dispatchMouseEvent(mouseWheelEvent(code,origin.x+100,origin.y+130));
+  wheel(67);await wait(async()=>(await state())[0]>0);
+  const right=await state();expect(right).toEqual([100,0]);
+  wheel(65);await wait(async()=>(await state())[1]>0);
+  const down=await state();expect(down).toEqual([100,100]);
+  wheel(66);await wait(async()=>(await state())[0]<right[0]);
+  wheel(64);await wait(async()=>(await state())[1]<down[1]);
+  expect(await state()).toEqual([0,0]);
+  // Touchpad-like fractional deltas must not be rounded into wheel ticks.
+  land.context.dispatchMouseEvent({type:'mouseWheel',x:origin.x+100,y:origin.y+130,deltaX:12.5,deltaY:7.5});
+  await wait(async()=>(await state())[1]>0);
+  const fractional=await state();
+  expect(fractional[0]).toBeGreaterThan(0);expect(fractional[1]).toBeGreaterThan(0);
+  // Compare the same wheel input with the direct Browser/CDP scroll path.
+  await app.browser.context.scroll(-100,-100,{x:100,y:100});
+  expect(await state()).toEqual([0,0]);
+  await app.browser.context.scroll(12.5,7.5,{x:100,y:100});
+  expect(await state()).toEqual(fractional);
+  await app.browser.context.scroll(-100,-100,{x:100,y:100});
+  await app.browser.context.scroll(100,100,{x:100,y:100});
+  expect(await state()).toEqual(down);
+ }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);

package/test/wayland-urlbar.test.js

@@ -36,3 +36,26 @@ test('Toolbar raster cache and horizontal scrolling preserve page-independent re
   expect(bar.editor.selectedText.length).toBeGreaterThan(0);
  }finally{bar.dispose();}
 });
+
+test('Wayland chrome forwards page click counts through zoom and bar offset',async()=>{
+ const clicks=[];
+ const bar=new WaylandUrlBar({url:'about:blank',click:(...args)=>clicks.push(args)},{history,close(){},clipboard:{read:async()=>'',write:async()=>{}}});
+ try{
+  bar.zoom=2;
+  await bar.pointerButton(40,bar.height+60,272,1,{clickCount:2});
+  await bar.pointerButton(40,bar.height+60,272,0,{clickCount:2});
+  expect(clicks).toEqual([[20,30,{clickCount:2}]]);
+ }finally{bar.dispose()}
+});
+
+test('Wayland toolbar forwards right/middle page clicks but ignores them on chrome',async()=>{
+ const clicks=[];const bar=new WaylandUrlBar({click:(...a)=>clicks.push(a)},{history});
+ try{
+  for(const code of [273,274]){
+   await bar.pointerButton(40,bar.height+60,code,1);
+   await bar.pointerButton(40,bar.height+60,code,0);
+   await bar.pointerButton(40,5,code,0);
+  }
+  expect(clicks.map(c=>c[2].button)).toEqual(['right','middle']);
+ }finally{bar.dispose()}
+});