buninu-browser 0.3.0 → 0.5.0

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/qml-worker.test.js

@@ -0,0 +1,69 @@
+import { test, expect } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { createBrowser } from '../lib/headless-shell.js';
+async function run(files, source, verify) {
+  const dir = mkdtempSync('/tmp/qml-worker-');
+  let browser;
+  try {
+    for (const [name, text] of Object.entries({ ...files, 'main.qml': source }))
+      await Bun.write(join(dir, name), text);
+    browser = await createBrowser({ spareRenderer: false });
+    await browser.context.navigate(
+      Bun.pathToFileURL(join(dir, 'main.qml')).href,
+    );
+    const read = () =>
+      browser.context.evaluate('document.getElementById("result").textContent');
+    let text;
+    for (let i = 0; i < 200; i++) {
+      text = await read();
+      if (text !== 'waiting') break;
+      await Bun.sleep(20);
+    }
+    await verify(text, browser);
+  } finally {
+    browser?.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+test('WorkerScript includes shared script scope, clones messages and keeps independent worker state', async () => {
+  await run(
+    {
+      'worker.js':
+        'Qt.include("helper.js");var count=0;WorkerScript.onMessage=function(m){m.answer=twice(m.n)+ ++count;WorkerScript.sendMessage(m);};',
+      'helper.js': '.pragma library\nfunction twice(n){return n*2;}',
+    },
+    `import QtQuick
+Text {id:result;text:"waiting";property var input:({n:4});property var replies:[]
+ WorkerScript {id:a;source:"worker.js";onMessage:function(m){result.replies=result.replies.concat([m.answer]);if(result.replies.length===2)result.text=JSON.stringify(result.replies)+":"+result.input.answer}}
+ WorkerScript {id:b;source:"worker.js";onMessage:function(m){result.replies=result.replies.concat([m.answer]);if(result.replies.length===2)result.text=JSON.stringify(result.replies)+":"+result.input.answer}}
+ Component.onCompleted:{a.sendMessage(input);b.sendMessage(input)}
+}`,
+    (text) => expect(text).toBe('[9,9]:undefined'),
+  );
+}, 30000);
+test.skipIf(!process.env.BUNINU_FLEA_ROOT)(
+  'unchanged Flea MarkdownWorker parses headings and paragraphs in a real worker',
+  async () => {
+    const url = Bun.pathToFileURL(
+      resolve(process.env.BUNINU_FLEA_ROOT, 'ui/MarkdownWorker.js'),
+    ).href;
+    await run(
+      {},
+      `import QtQuick
+Text {id:result;text:"waiting"
+ WorkerScript {id:worker;source:${JSON.stringify(url)};onMessage:function(m){result.text=JSON.stringify(m)}}
+ Component.onCompleted:worker.sendMessage({seq:12,source:"# Hello\\n\\nA **bold** paragraph.",dir:"/tmp",chrome:"#000000",ink:"#ffffff"})
+}`,
+      (text) => {
+        const result = JSON.parse(text);
+        expect(result.error).toBe('');
+        expect(result.seq).toBe(12);
+        expect(result.blocks.length).toBeGreaterThan(1);
+        expect(JSON.stringify(result.blocks)).toContain('Hello');
+        expect(JSON.stringify(result.blocks)).toContain('bold');
+      },
+    );
+  },
+  30000,
+);

package/test/qml.test.js

@@ -0,0 +1,83 @@
+import {test,expect} from 'bun:test';
+import {parseQml} from '../lib/qml/parser.js';
+import {createQmlDocument} from '../lib/qml/document.js';
+import {isQmlDocument} from '../lib/qml/format.js';
+import {displayDocument} from '../lib/document-types.js';
+import {RendererHost} from '../lib/renderer/host.js';
+const url='https://qml.test/hello.qml';
+const source=await Bun.file(new URL('./fixtures/qml/hello.qml',import.meta.url)).text();
+
+test('QML builds DOM directly, preserves source through response classification',()=>{
+ const response=displayDocument({url,contentType:'text/plain',body:new TextEncoder().encode(source)});
+ expect(response).toEqual({source,contentType:'text/x-qml'});
+ expect(isQmlDocument(url,'text/html')).toBe(false);
+ const {document}=createQmlDocument(source,url);
+ expect(document.querySelectorAll('[data-qml-node]').length).toBe(4);
+ expect(document.querySelector('#root')).not.toBeNull();
+ expect(document.querySelector('script').textContent).toContain('addEventListener');
+});
+test('unsupported imports/types are visible diagnostics and source is inert',()=>{
+ const {document}=createQmlDocument('import Evil\nRectangle { color: "<script>boom</script>" }',url);
+ expect(document.body.textContent).toContain('Unsupported QML import');
+ expect(document.querySelector('script')).toBeNull();
+ expect(()=>parseQml('Rectangle { width: }')).toThrow();
+ const disabled=createQmlDocument(source,url,{scripting:false}).document;
+ expect(disabled.querySelector('script')).toBeNull();
+ expect(disabled.body.textContent).toContain('requires page scripting');
+});
+test('Acorn handles modern JS expressions and braces inside strings',()=>{
+ const ast=parseQml('import QtQuick\nText { text: ({a: "}"})?.a ?? "fallback"; onClicked: { console.log("}"); } }');
+ expect(ast.root.properties.length).toBe(2);
+});
+test('QML uses normal realm, reactive DOM, input, viewport resize and navigation',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try{
+  await host.start(); await host.call('resize',640,360,1);
+  await host.call('loadDocument',{url,source,contentType:'text/x-qml'}); await host.call('whenLoaded');
+  expect(await host.call('evaluate','document.title')).toBe('QML DOM experiment');
+  expect(await host.call('evaluate','document.getElementById("button").style.width')).toBe('320px');
+  expect(await host.call('evaluate','document.body.textContent.includes("Hello World! Clicks: 0")')).toBe(true);
+  await host.call('evaluate',`document.querySelector('[data-qml-node="3"]').click()`);
+  expect(await host.call('evaluate',`document.querySelector('[data-qml-node="2"]').textContent`)).toBe('Hello World! Clicks: 1');
+  await host.call('resize',800,400,1);
+  expect(await host.call('evaluate','document.getElementById("button").style.width')).toBe('400px');
+  await host.call('loadDocument',{url,contentType:'text/x-qml',source:`import QtQuick
+Rectangle {
+ id: root
+ implicitWidth: 300
+ implicitHeight: 120
+ property int count: 1
+ Rectangle { id: child; anchors.fill: parent
+  Text { id: label; text: root.count + ":" + parent.width }
+ }
+ onClicked: { root.width = 222; root.implicitWidth = 500; root.count++; }
+}`}); await host.call('whenLoaded');
+  expect(await host.call('evaluate','document.getElementById("label").textContent')).toBe('1:300');
+  await host.call('evaluate','document.getElementById("root").click()');
+  expect(await host.call('evaluate','document.getElementById("label").textContent')).toBe('2:222');
+  await host.call('loadDocument',{url:'https://qml.test/plain' ,source:'<p>ordinary HTML</p>',contentType:'text/html'});await host.call('whenLoaded');
+  expect(await host.call('evaluate','document.body.textContent')).toBe('ordinary HTML');
+ }finally{host.close();}
+},30000);
+
+test('Quickshell multiply fixture uses editable DOM controls and click handlers',async()=>{
+ const host=new RendererHost({timeout:20000});
+ const source=await Bun.file(new URL('./fixtures/qml/multiply.qml',import.meta.url)).text();
+ try{
+  await host.start();await host.call('resize',640,480,1);
+  await host.call('loadDocument',{url:'https://qml.test/multiply.qml',source,contentType:'text/x-qml'});await host.call('whenLoaded');
+  expect(await host.call('evaluate',"document.querySelectorAll('input').length")).toBe(3);
+  const point=async selector=>JSON.parse(await host.call('evaluate',`JSON.stringify((()=>{const r=document.querySelector(${JSON.stringify(selector)}).getBoundingClientRect();return [r.x+r.width/2,r.y+r.height/2]})())`));
+  const click=async selector=>host.call('click',...await point(selector));
+  const value=()=>host.call('evaluate',"document.getElementById('result').value");
+  await click('button');expect(await value()).toBe('42');
+  await click('#first');await host.call('press','a',{modifiers:2});await host.call('type','-2.5');
+  await click('#second');await host.call('press','a',{modifiers:2});await host.call('type','4');
+  await click('button');expect(await value()).toBe('-10');
+  await click('#result');await host.call('type','999');expect(await value()).toBe('-10');
+  await click('#first');await host.call('press','a',{modifiers:2});await host.call('press','Backspace');
+  await click('button');expect(await value()).toBe('Please enter two valid numbers');
+  const rects=JSON.parse(await host.call('evaluate',"JSON.stringify([...document.querySelectorAll('input,button')].map(e=>{const r=e.getBoundingClientRect();return [r.x,r.y,r.width,r.height]}))"));
+  for(let i=1;i<rects.length;i++)expect(rects[i][1]).toBeGreaterThanOrEqual(rects[i-1][1]+rects[i-1][3]);
+ }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/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/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-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-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

@@ -0,0 +1,61 @@
+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();}
+});
+
+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()}
+});