buninu-browser 0.4.0 → 0.5.1

package/test/qml-connections-timing.test.js

@@ -71,3 +71,25 @@ Rectangle {
   expect(await host.call('evaluate',"Number(document.getElementById('status').textContent)")).toBe(0);
  }finally{host.close()}
 },30000);
+
+test('property Changed.connect synchronizes menu state before same-handler validation',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try{
+  await host.start();
+  await host.call('loadDocument',{url:'data:text/x-qml,menu-validation',contentType:'text/x-qml',source:`import QtQuick
+Rectangle {
+ id:root;width:300;height:200;property int result:-1;property int changes:0
+ property bool preparing:false
+ readonly property bool live:root.preparing || menu.opened
+ Item {id:menu;property bool preparing:false;property bool opened:false;property int count:root.live ? 1 : 0}
+ Component.onCompleted:menu.preparingChanged.connect(function(){root.preparing=menu.preparing;root.changes++})
+ Text {id:status;text:root.result+":"+root.changes+":"+menu.count}
+ onClicked:{menu.preparing=true;root.result=menu.count;menu.preparing=false}
+}`});
+  await host.call('whenLoaded');
+  for(const changes of [2,4,6]){
+   await host.call('evaluate',"document.getElementById('root').click()");
+   expect(await host.call('evaluate',"document.getElementById('status').textContent")).toBe('1:'+changes+':0');
+  }
+ }finally{host.close()}
+},30000);

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

@@ -0,0 +1,182 @@
+import {test,expect} from 'bun:test';
+import {RendererHost} from '../lib/renderer/host.js';
+import {qmlWindowConstraints} from '../lib/qml/window-constraints.js';
+test('window constraints normalize and update Wayland size hints',async()=>{
+ const calls=[];let hints=['[360,240]','[200,0]'];
+ const sync=qmlWindowConstraints({request:(...args)=>calls.push(args)},{toplevel:8,surface:6},{url:'file:///test.qml',evaluate:async()=>hints});
+ await sync();await sync();
+ expect(calls).toEqual([[8,'set_min_size',360,240],[8,'set_max_size',360,0],[6,'commit']]);
+ hints=null;await sync();expect(calls.slice(3)).toEqual([[8,'set_min_size',0,0],[8,'set_max_size',0,0],[6,'commit']]);
+});
+test('FloatingWindow minimum size, attached window notifications and Button slots',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try{
+ await host.start();
+ await host.call('loadDocument',{url:'data:text/x-qml,controls',contentType:'text/x-qml',source:`import QtQuick
+import Quickshell
+ShellRoot {
+ FloatingWindow {id:a;minimumSize:Qt.size(1500,1200)
+  Button {id:b;width:100;height:40;padding:5;focusPolicy:Qt.NoFocus
+   contentItem:Text {id:label;text:"hello"}
+   background:Rectangle {id:bg;color:"red"}
+   Window.onWindowChanged:globalThis.changes=(globalThis.changes||0)+1
+  }
+ }
+ FloatingWindow{id:c}
+ Component.onCompleted:{globalThis.a=a;globalThis.b=b;globalThis.c=c;globalThis.label=label;globalThis.bg=bg;}
+}`});
+ await host.call('whenLoaded');
+ expect(await host.call('evaluate','[a.width,a.height]')).toEqual([1500,1200]);
+ expect(await host.call('evaluate','[label.x,label.y,label.width,label.height,bg.width,bg.height,b.activeFocusOnTab]')).toEqual([5,5,90,30,100,40,false]);
+ expect(await host.call('evaluate','b.Window.window===a')).toBe(true);
+ const before=await host.call('evaluate','globalThis.changes');
+ await host.call('evaluate','b.parent=c');await Bun.sleep(20);
+ expect(await host.call('evaluate','b.Window.window===c')).toBe(true);
+ expect(await host.call('evaluate','globalThis.changes')).toBe(before+1);
+ }finally{host.close();}
+},20000);
+
+test('ListModel roles populate required Repeater properties and remain reactive',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try{
+ await host.start();await host.call('loadDocument',{url:'data:text/x-qml,roles',contentType:'text/x-qml',source:`import QtQuick
+Item {
+ ListModel{id:model}
+ Repeater{id:rep;model:model;delegate:Text {required property string key;required property int amount;text:key+amount}}
+ Component.onCompleted:{globalThis.rep=rep;globalThis.rows=model;model.append({key:"a",amount:2});}
+}`});await host.call('whenLoaded');
+ expect(await host.call('evaluate','[rep.count,rep.itemAt(0).text]')).toEqual([1,'a2']);
+ await host.call('evaluate','rows.setProperty(0,"amount",3)');await Bun.sleep(20);
+ expect(await host.call('evaluate','rep.itemAt(0).text')).toBe('a3');
+ }finally{host.close();}
+},20000);
+
+test('nested Loader startup preserves outer property notifications',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try{
+ await host.start();await host.call('loadDocument',{url:'data:text/x-qml,nested-notifications',contentType:'text/x-qml',source:`import QtQuick
+Item {id:root
+ property int counter:0
+ onCounterChanged:globalThis.changes=(globalThis.changes||[]).concat([counter])
+ Loader {sourceComponent:Item {property size dimensions;property real side:dimensions.width;Component.onCompleted:globalThis.initialSide=side}}
+ Component.onCompleted:{globalThis.root=root;counter=1;}
+}`});await host.call('whenLoaded');
+ expect(await host.call('evaluate','globalThis.initialSide')).toBe(0);
+ expect(await host.call('evaluate','globalThis.changes')).toEqual([1]);
+ await host.call('evaluate','root.counter=2');await Bun.sleep(20);
+ expect(await host.call('evaluate','globalThis.changes')).toEqual([1,2]);
+ }finally{host.close();}
+},20000);
+
+import {createQt} from '../lib/qml/builtins.js';
+test('Qt date/time formatting uses local date fields and locale format order',()=>{
+ const qt=createQt(),date=new Date(2024,10,23,17,45,36);
+ expect(qt.formatTime(date,'HH:mm')).toBe('17:45');
+ expect(qt.formatTime(date,'h:mm AP')).toBe('5:45 PM');
+ expect(qt.formatDateTime(date,"yyyy-MM-dd 'at' HH:mm")).toBe('2024-11-23 at 17:45');
+ expect(qt.locale('en_US').measurementSystem).toBe(1);
+ expect(qt.locale('zh_TW').measurementSystem).toBe(0);
+ expect(qt.locale('en_US').dateFormat(1).indexOf('M')).toBeLessThan(qt.locale('en_US').dateFormat(1).indexOf('d'));
+});
+
+test('createObject does not make the owning binding depend on new child state',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try{
+ await host.start();await host.call('loadDocument',{url:'data:text/x-qml,factory-tracking',contentType:'text/x-qml',source:`import QtQuick
+Item {id:root
+ property var child:factory.createObject(root)
+ property Component factory:Component {Item {property int counter:0;property int derived:counter+1;Component.onCompleted:globalThis.created=(globalThis.created||0)+1}}
+ Component.onCompleted:{globalThis.root=root;globalThis.first=child;}
+}`});await host.call('whenLoaded');
+ expect(await host.call('evaluate','globalThis.created')).toBe(1);
+ await host.call('evaluate','first.counter=9');await Bun.sleep(20);
+ expect(await host.call('evaluate','[root.child===first,root.child.derived,globalThis.created]')).toEqual([true,10,1]);
+ }finally{host.close();}
+},20000);
+
+test('Button custom content sizes its RowLayout slot and reacts without a width cycle',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try {
+  await host.start();
+  await host.call('loadDocument',{url:'data:text/x-qml,button-size',contentType:'text/x-qml',source:`import QtQuick
+import QtQuick.Layouts
+import Quickshell
+FloatingWindow {
+ RowLayout { width:500; height:60; spacing:8
+  Button {id:button;padding:4
+   contentItem: RowLayout {spacing:6
+    Rectangle {id:first;implicitWidth:80;implicitHeight:20}
+    Rectangle {implicitWidth:100;implicitHeight:24}
+   }
+   background: Rectangle {implicitWidth:120;implicitHeight:30}
+  }
+  Rectangle {id:next;implicitWidth:30;implicitHeight:30}
+  Item {Layout.fillWidth:true}
+ }
+ Component.onCompleted:{globalThis.button=button;globalThis.first=first;globalThis.next=next;}
+}`});
+  await host.call('whenLoaded');
+  expect(await host.call('evaluate','[button.implicitWidth,button.implicitHeight,button.width,next.x]')).toEqual([194,32,194,202]);
+  await host.call('evaluate','first.implicitWidth=120');await Bun.sleep(20);
+  expect(await host.call('evaluate','[button.implicitWidth,button.width,next.x]')).toEqual([234,234,242]);
+ }finally{host.close();}
+},20000);
+
+test('Layouts retain explicit item dimensions for status dots and palette strips',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try {
+  await host.start();
+  await host.call('loadDocument',{url:'data:text/x-qml,layout-fallback',contentType:'text/x-qml',source:`import QtQuick
+import QtQuick.Layouts
+import Quickshell
+FloatingWindow {
+ RowLayout {id:row;width:300;height:30
+  Rectangle {id:dot;width:8;height:8;radius:4;color:"green"}
+  Item {Layout.fillWidth:true}
+ }
+ ColumnLayout {id:column;y:40;width:300;height:22;spacing:4
+  Rectangle {id:strip;Layout.fillWidth:true;height:6;color:"red"}
+  Item {implicitHeight:12;Layout.fillWidth:true}
+ }
+ GridLayout {y:80;columns:1
+  Rectangle {id:cell;width:11;height:7}
+ }
+ Component.onCompleted:{globalThis.dot=dot;globalThis.strip=strip;globalThis.cell=cell;globalThis.row=row;globalThis.column=column;}
+}`});
+  await host.call('whenLoaded');
+  expect(await host.call('evaluate','[dot.width,dot.height,strip.width,strip.height,cell.width,cell.height]')).toEqual([8,8,300,6,11,7]);
+  await host.call('evaluate','row.width=500;column.width=500');await Bun.sleep(20);
+  expect(await host.call('evaluate','[dot.width,dot.height,strip.width,strip.height]')).toEqual([8,8,500,6]);
+  await host.call('evaluate','row.width=300;column.width=300');await Bun.sleep(20);
+  expect(await host.call('evaluate','[dot.width,dot.height,strip.width,strip.height]')).toEqual([8,8,300,6]);
+ }finally{host.close();}
+},20000);
+
+test('Nested Layout receives explicit size bindings even when the dot starts hidden',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try {
+  await host.start();
+  await host.call('loadDocument',{url:'data:text/x-qml,late-dot',contentType:'text/x-qml',source:`import QtQuick
+import QtQuick.Layouts
+import Quickshell
+FloatingWindow {
+ property bool ready:false
+ id:root
+ ColumnLayout {anchors.fill:parent
+  RowLayout {Layout.fillWidth:true
+   Text {text:"TITLE"}
+   Item {Layout.fillWidth:true}
+   RowLayout {
+    spacing:8
+    Rectangle {id:dot;width:8;height:8;radius:4;visible:root.ready;Layout.alignment:Qt.AlignVCenter;color:"blue"}
+    Text {text:"LIVE"}
+   }
+  }
+ }
+ Component.onCompleted:{globalThis.root=root;globalThis.dot=dot;}
+}`});
+  await host.call('whenLoaded');
+  await host.call('evaluate','root.ready=true');await Bun.sleep(20);
+  expect(await host.call('evaluate','[dot.width,dot.height,dot.visible]')).toEqual([8,8,true]);
+ }finally{host.close();}
+},20000);

package/test/qml-fonts.test.js

@@ -0,0 +1,31 @@
+import {test,expect} from 'bun:test';
+import {mkdtemp,mkdir,copyFile,symlink,rm} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import {loadGraphics} from '../lib/renderer/page-renderer.js';
+import {qmlFontFiles,loadQmlFonts} from '../lib/qml/fonts.js';
+
+test('Qt font directory: recursive, symlink-safe, cached, isolated and invalid-font tolerant',async()=>{
+ const root=await mkdtemp(join(tmpdir(),'qml-fonts-'));
+ try {
+  await mkdir(join(root,'nested'));
+  await copyFile(new URL('../usr/share/fonts/DejaVuSansMono.ttf',import.meta.url),join(root,'nested','Regular.ttf'));
+  await symlink(root,join(root,'nested','cycle'));
+  await symlink(join(root,'nested','Regular.ttf'),join(root,'duplicate.ttf'));
+  await Bun.write(join(root,'invalid.otf'),'not a font');
+  await Bun.write(join(root,'ignored.txt'),'ignore');
+  expect((await qmlFontFiles(root)).length).toBe(2);
+  const base=await loadGraphics(),families=[...base.fontFamilies],warn=[];
+  const qml=await loadQmlFonts(base,m=>warn.push(m),root);
+  expect(qml).not.toBe(base);
+  expect(qml.fontFamilies.length).toBe(families.length+1);
+  expect(base.fontFamilies).toEqual(families);
+  const face=qml.builtinTypefaces.at(-1);
+  expect(face.typeface.getGlyphIDs('A')[0]).toBeGreaterThan(0);
+  expect(face.typeface.getGlyphIDs('\u{f040a}')[0]).toBe(0);
+  expect(warn.length).toBe(1);
+  expect(await loadQmlFonts(base,()=>{},root)).toBe(qml);
+  expect(await loadQmlFonts(base,()=>{},'')).toBe(base);
+  expect(await loadQmlFonts(base,()=>{},join(root,'missing'))).toBe(base);
+ }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/qml-grid-multiline.test.js

@@ -0,0 +1,48 @@
+import {test,expect} from 'bun:test';
+import {RendererHost} from '../lib/renderer/host.js';
+test('GridLayout fills columns and reflows; PathMultiline creates independent SVG subpaths',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try{
+  await host.start();
+  await host.call('loadDocument',{url:'data:text/x-qml,grid',contentType:'text/x-qml',source:`import QtQuick
+import QtQuick.Layouts
+import QtQuick.Shapes
+Item {width:200;height:100
+ GridLayout {id:g;width:200;columns:2;columnSpacing:20;rowSpacing:5
+ Rectangle {id:a;implicitWidth:30;implicitHeight:10;Layout.fillWidth:true}
+ Rectangle {id:b;implicitWidth:30;implicitHeight:20;Layout.fillWidth:true}
+ Rectangle {id:c;implicitWidth:30;implicitHeight:10;Layout.fillWidth:true}
+ }
+ Shape {ShapePath {strokeColor:"red";fillColor:"transparent";PathMultiline {id:p;paths:[[Qt.point(1,2),Qt.point(3,4)],[Qt.point(5,6),Qt.point(7,8)]]}}}
+ Component.onCompleted:{globalThis.g=g;globalThis.cells=[a,b,c];globalThis.pathObject=p;}
+}`});
+  await host.call('whenLoaded');
+  expect(await host.call('evaluate','cells.map(c=>[c.x,c.y,c.width,c.height])')).toEqual([[0,0,90,10],[110,0,90,20],[0,25,90,10]]);
+  expect(await host.call('evaluate','document.querySelector("path").getAttribute("d")')).toBe('M1 2 L3 4 M5 6 L7 8');
+  await host.call('evaluate','g.width=60');
+  await Bun.sleep(20);
+  expect(await host.call('evaluate','cells.map(c=>c.width)')).toEqual([20,20,20]);
+  await host.call('evaluate','g.width=200;g.columns=1;pathObject.paths=[[{x:9,y:10},{x:11,y:12}]]');
+  await Bun.sleep(20);
+  expect(await host.call('evaluate','cells.map(c=>[c.x,c.y,c.width])')).toEqual([[0,0,200],[0,15,200],[0,40,200]]);
+  expect(await host.call('evaluate','document.querySelector("path").getAttribute("d")')).toBe('M9 10 L11 12');
+ }finally{host.close();}
+},20000);
+
+test('nested fill layouts retain intrinsic widths when a parent resizes',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try{
+  await host.start();
+  await host.call('loadDocument',{url:'data:text/x-qml,nested-grid',contentType:'text/x-qml',source:`import QtQuick
+import QtQuick.Layouts
+GridLayout {id:g;width:200;columns:2;columnSpacing:20
+ ColumnLayout {id:a;Layout.fillWidth:true;Rectangle {implicitWidth:30;implicitHeight:10;Layout.fillWidth:true}}
+ ColumnLayout {id:b;Layout.fillWidth:true;Rectangle {implicitWidth:30;implicitHeight:10;Layout.fillWidth:true}}
+ Component.onCompleted:{globalThis.grid=g;globalThis.columns=[a,b]}
+}`});
+  await host.call('whenLoaded');
+  expect(await host.call('evaluate','columns.map(c=>[c.width,c.implicitWidth])')).toEqual([[90,30],[90,30]]);
+  await host.call('evaluate','grid.width=400');await Bun.sleep(20);
+  expect(await host.call('evaluate','columns.map(c=>[c.width,c.implicitWidth])')).toEqual([[190,30],[190,30]]);
+ }finally{host.close();}
+},20000);

package/test/qml-locale.test.js

@@ -0,0 +1,45 @@
+import {test,expect} from 'bun:test';
+import {createQt} from '../lib/qml/builtins.js';
+
+test('C/POSIX locale is metric and uses Qt date order and 24-hour time',()=>{
+ for(const name of ['C','C.UTF-8','POSIX']) {
+  const qt=createQt({LC_ALL:name,LANG:'en_US.UTF-8',LC_TIME:'en_US.UTF-8',LC_MEASUREMENT:'en_US.UTF-8'});
+  const l=qt.locale();
+  expect(l.name).toBe('C');expect(l.measurementSystem).toBe(0);
+  expect(l.dateFormat(1)).toBe('d MM yyyy');expect(l.timeFormat(1)).toBe('HH:mm');
+  expect(qt.locale('en_US.UTF-8').measurementSystem).toBe(1);
+ }
+});
+test('locale categories override LANG but explicit locale ignores environment',()=>{
+ const qt=createQt({LANG:'en_US.UTF-8',LC_TIME:'en_GB.UTF-8',LC_MEASUREMENT:'zh_TW.UTF-8'});
+ expect(qt.locale().name).toBe('en_US');expect(qt.locale().measurementSystem).toBe(0);
+ expect(qt.locale().timeFormat(1)).not.toContain('AP');
+ expect(qt.locale().dateFormat(1).indexOf('d')).toBeLessThan(qt.locale().dateFormat(1).indexOf('M'));
+ expect(qt.locale('en_US').timeFormat(1)).toContain('AP');
+ expect(qt.locale('en_GB').measurementSystem).toBe(2);
+ expect(qt.locale('C').timeFormat(1)).toBe('HH:mm');
+ expect(qt.locale('not_a_valid_locale').name).toBe('C');
+});
+test('empty overrides inherit LANG; unset system defaults to C',()=>{
+ const qt=createQt({LC_ALL:'',LC_TIME:'',LANG:'zh_TW.UTF-8'});
+ expect(qt.locale().name).toBe('zh_TW');expect(qt.locale().measurementSystem).toBe(0);
+ expect(qt.locale().dateFormat(1).indexOf('y')).toBeLessThan(qt.locale().dateFormat(1).indexOf('M'));
+ expect(createQt({}).locale().name).toBe('C');
+ const d=new Date(2024,10,23,17,45,36);
+ expect(createQt({LANG:'C.UTF-8'}).formatTime(d,'HH:mm')).toBe('17:45');
+ expect(createQt({LANG:'C.UTF-8'}).formatDate(d,'MMMM')).toBe('November');
+});
+
+test('local QML host receives locale categories through its host capability',async()=>{
+ for(const [env,expected] of [
+  [{LC_ALL:'C.UTF-8',LANG:'en_US.UTF-8'},{name:'C',measurement:0,date:'d MM yyyy',time:'HH:mm'}],
+  [{LC_ALL:'',LANG:'en_US.UTF-8',LC_MESSAGES:'',LC_TIME:'en_GB.UTF-8',LC_MEASUREMENT:'zh_TW.UTF-8'},null],
+ ]) {
+  const child=Bun.spawn([process.execPath,new URL('./fixtures/qml-locale/check.mjs',import.meta.url).pathname],{env:{...process.env,...env},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:''});
+  const result=JSON.parse(output.trim());
+  if(expected)expect(result).toEqual(expected);
+  else {expect(result.name).toBe('en_US');expect(result.measurement).toBe(0);expect(result.time).toBe('HH:mm');}
+ }
+},15000);

package/test/qml-nonvisual-visible.test.js

@@ -0,0 +1,19 @@
+import {test,expect} from 'bun:test';
+import {mkdtempSync,rmSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import {createBrowser} from '../lib/headless-shell.js';
+
+test('dynamic QtObject readonly visible does not abort singleton initialization',async()=>{
+ const dir=mkdtempSync(join(tmpdir(),'qml-nonvisual-'));let browser;
+ try{
+  await Bun.write(join(dir,'qmldir'),'singleton Sound 1.0 Sound.qml\n');
+  await Bun.write(join(dir,'Sound.qml'),'pragma Singleton\nimport QtQuick\nQtObject { property int held: -1; readonly property real gain: held < 0 ? 1 : 0 }');
+  await Bun.write(join(dir,'Panel.qml'),'import QtQuick\nimport "."\nItem { QtObject { id:meta; readonly property bool visible: true; readonly property real gain: Sound.gain } Text { text: "gain="+meta.gain+" visible="+meta.visible } }');
+  await Bun.write(join(dir,'main.qml'),'import QtQuick\nItem { width:200;height:80; Loader { id:loader;source:"Panel.qml" } }');
+  browser=await createBrowser({spareRenderer:false});
+  await browser.context.navigate(Bun.pathToFileURL(join(dir,'main.qml')).href);
+  expect(await browser.context.evaluate('Array.from(document.querySelectorAll("[data-qml-type=Text]")).map(e=>e.textContent).join(" ")')).toContain('gain=1 visible=true');
+  expect(await browser.context.evaluate('Array.from(document.querySelectorAll("[data-qml-type=QtObject]")).every(e=>e.style.display==="none")')).toBe(true);
+ }finally{browser?.close();rmSync(dir,{recursive:true,force:true});}
+},30000);

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

@@ -0,0 +1,6 @@
+import {test,expect} from 'bun:test';
+for(const mode of ['shader','grab','texture'])test('local QML software canvas: '+mode,async()=>{
+ const child=Bun.spawn([process.execPath,new URL('./fixtures/qml-shader-check.mjs',import.meta.url).pathname,mode],{stdout:'pipe',stderr:'pipe'});
+ const [exit,stdout,stderr]=await Promise.all([child.exited,new Response(child.stdout).text(),new Response(child.stderr).text()]);
+ expect({exit,stderr}).toEqual({exit:0,stderr:''});
+},30000);

package/test/qml-shortcuts.test.js

@@ -0,0 +1,39 @@
+import {test,expect} from 'bun:test';
+import {RendererHost} from '../lib/renderer/host.js';
+test('Instantiator owns Shortcut delegates and deactivation removes keyboard handlers',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try{
+  await host.start();
+  await host.call('loadDocument',{url:'data:text/x-qml,shortcuts',contentType:'text/x-qml',source:`import QtQuick
+import QtQml.Models
+Item {
+ property int hits:0
+ Instantiator {id:inst;model:["Ctrl+L", "Shift+N", "?", "Ctrl+K, Ctrl+C"]
+ delegate:Shortcut {autoRepeat:false;sequence:modelData;onActivated:globalThis.pressed.push(index)}
+ }
+ Shortcut {sequence:"X";onActivated:globalThis.bad=true;onActivatedAmbiguously:globalThis.amb=(globalThis.amb||0)+1}
+ Shortcut {sequence:"X";onActivated:globalThis.bad=true;onActivatedAmbiguously:globalThis.amb=(globalThis.amb||0)+1}
+ Shortcut {id:probe;enabled:false;sequence:"ctrl+l"}
+ Component.onCompleted:{globalThis.pressed=[];globalThis.inst=inst;globalThis.probe=probe;}
+}`});
+  await host.call('whenLoaded');
+  const key=async(key,mods={})=>host.call('evaluate',`document.body.dispatchEvent(new KeyboardEvent('keydown',{key:${JSON.stringify(key)},bubbles:true,cancelable:true,...${JSON.stringify(mods)}}))`);
+  expect(await host.call('evaluate','inst.count')).toBe(4);
+  expect(await host.call('evaluate','probe.portableText')).toBe('Ctrl+L');
+  expect(await host.call('evaluate','inst.objectAt(0).parent===inst')).toBe(true);
+  await key('l',{ctrlKey:true,repeat:true});
+  expect(await host.call('evaluate','pressed')).toEqual([]);
+  await key('x');
+  expect(await host.call('evaluate','[globalThis.amb,!!globalThis.bad]')).toEqual([2,false]);
+  await key('l',{ctrlKey:true});await key('N',{shiftKey:true});await key('?',{shiftKey:true});
+  await key('k',{ctrlKey:true});await key('c',{ctrlKey:true});
+  expect(await host.call('evaluate','pressed')).toEqual([0,1,2,3]);
+  await host.call('evaluate','inst.active=false');
+  await Bun.sleep(20);await key('l',{ctrlKey:true});
+  expect(await host.call('evaluate','inst.count')).toBe(0);
+  expect(await host.call('evaluate','inst.object')).toBe(null);
+  expect(await host.call('evaluate','pressed')).toEqual([0,1,2,3]);
+  await host.call('evaluate','inst.active=true');await Bun.sleep(20);await key('l',{ctrlKey:true});
+  expect(await host.call('evaluate','pressed')).toEqual([0,1,2,3,0]);
+ }finally{host.close();}
+},20000);

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/text-layout.test.js

@@ -675,3 +675,18 @@ test("an out-of-flow box keeps its static position when the block around its pla
   (document) => { document.getElementById("edit").textContent = "a longer paragraph that wraps onto two lines"; });
   expect(rankedLayout(retained)).toEqual(rankedLayout(clean));
 });
+
+test("anonymous flex text items do not reuse their parent's intrinsic width", () => {
+  const { document, window } = parseHTMLDocument(`<body style="margin:0"><div style="display:flex">
+    <span style="display:flex"><a>hash</a>·<time>Today</time>!</span><b>History</b>
+  </div></body>`);
+  const tree = new RenderTreeBuilder().build(document, new StyleEngine().compute(document));
+  const engine = new LayoutEngine({ measureText: text => text.length * 10 });
+  for (const width of [500, 180, 500]) {
+    const layout = engine.layout(tree, { x:0, y:0, width });
+    expect(layout.fragments.map(f => [f.text, f.x, f.width])).toEqual([
+      ["hash", 0, 40], ["·", 40, 10], ["Today", 50, 50], ["!", 100, 10], ["History", 110, 70],
+    ]);
+  }
+  window.happyDOM.abort();
+});

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