buninu-browser 0.3.0 → 0.5.0

package/frontends/wayland/transport.js

@@ -0,0 +1,120 @@
+// Adapted from buninu-land/lib/transport.js (MIT; LICENSE-land).
+// Linux 64-bit ABI. Only libc is loaded. recvmsg is required for SCM_RIGHTS;
+// Bun's stream sockets do not expose ancillary file descriptors.
+import { dlopen, ptr } from 'bun:ffi';
+
+if (!['arm64', 'x64'].includes(process.arch) || !['linux', 'android'].includes(process.platform)) throw Error('Requires 64-bit Linux or Android');
+const signature = (args, returns = 'i32') => ({ args, returns });
+let library;
+let errnoSymbol;
+// Same architecture-specific libc names as buninu-linux's /lib/dlopen.js.
+const muslLibc = `libc.musl-${process.arch === 'arm64' ? 'aarch64' : 'x86_64'}.so.1`;
+const candidates = process.platform === 'android'
+  ? [['libc.so', '__errno']]
+  : [
+      ['libc.so.6', '__errno_location'],
+      [muslLibc, '__errno_location'],
+      [`/lib/${muslLibc}`, '__errno_location'],
+      ['libc.so', '__errno_location'],
+      ['libc.so', '__errno'],
+    ];
+const failures = [];
+for (const [name, symbol] of candidates) {
+  try { library = dlopen(name, {
+    connect: signature(['i32','ptr','u32']), socket: signature(['i32','i32','i32']),
+    recvmsg: signature(['i32','ptr','i32'], 'i64'), sendmsg: signature(['i32','ptr','i32'], 'i64'),
+    dup: signature(['i32']), send: signature(['i32','ptr','u64','i32'], 'i64'), close: signature(['i32']),
+
+    // Standard Wayland clipboard FD transfer.
+    pipe2: signature(['ptr','i32']), fcntl: signature(['i32','i32','i32']),
+
+    [symbol]: signature([], 'ptr'),
+  }); errnoSymbol = symbol; break; }
+  catch (error) { failures.push(`${name} (${symbol}): ${error.message}`); }
+}
+if (!library) throw Error(`Cannot load libc on ${process.platform}:\n${failures.join('\n')}`);
+export const libc = library.symbols;
+import { toArrayBuffer } from 'bun:ffi';
+export const errno = () => new Int32Array(toArrayBuffer(libc[errnoSymbol](), 0, 4))[0];
+const retry = () => [4,11].includes(errno());
+export class Connection {
+  constructor(fd, removed) {
+    this.fd = fd; this.removed = removed; this.fds = []; this.input = Buffer.alloc(0); this.output = []; this.queuedBytes = 0;
+    this.data = Buffer.alloc(65536); this.control = Buffer.alloc(4096); this.iov = Buffer.alloc(16); this.msg = Buffer.alloc(56);
+    this.iov.writeBigUInt64LE(BigInt(ptr(this.data))); this.iov.writeBigUInt64LE(BigInt(this.data.length), 8);
+    this.msg.writeBigUInt64LE(BigInt(ptr(this.iov)), 16); this.msg.writeBigUInt64LE(1n, 24);
+    this.msg.writeBigUInt64LE(BigInt(ptr(this.control)), 32);
+  }
+  send(bytes, fds = []) {
+    if (this.closed) return;
+    const owned = [];
+    try { for (const fd of fds) { const copy = libc.dup(fd); if (copy < 0) throw Error('Cannot duplicate outgoing FD'); owned.push(copy); } }
+    catch (e) { for (const fd of owned) libc.close(fd); throw e; }
+    this.output.push({ bytes, fds: owned }); this.queuedBytes += bytes.length;
+    if (this.queuedBytes > 4*1024*1024) this.close();
+  }
+  flush() {
+    for (let round = 0; round < 64 && this.output.length; round++) {
+      const item = this.output[0];
+      let n;
+      if (item.fds.length) {
+        const iov = Buffer.alloc(16), msg = Buffer.alloc(56);
+        const size = 16 + item.fds.length * 4, control = Buffer.alloc(Math.ceil(size / 8) * 8);
+        iov.writeBigUInt64LE(BigInt(ptr(item.bytes))); iov.writeBigUInt64LE(BigInt(item.bytes.length), 8);
+        control.writeBigUInt64LE(BigInt(size)); control.writeInt32LE(1,8); control.writeInt32LE(1,12);
+        item.fds.forEach((fd,i) => control.writeInt32LE(fd,16+i*4));
+        msg.writeBigUInt64LE(BigInt(ptr(iov)),16); msg.writeBigUInt64LE(1n,24);
+        msg.writeBigUInt64LE(BigInt(ptr(control)),32); msg.writeBigUInt64LE(BigInt(control.length),40);
+        n = Number(libc.sendmsg(this.fd,msg,0x4000));
+      } else n = Number(libc.send(this.fd,item.bytes,item.bytes.length,0x4000));
+      if (n < 0) { if (!retry()) this.close(); return; }
+      if (!n) return this.close();
+      // SCM_RIGHTS is delivered with the first successfully sent byte, even on partial writes.
+      for (const fd of item.fds) libc.close(fd); item.fds = [];
+      this.queuedBytes -= n;
+      if (n === item.bytes.length) this.output.shift(); else item.bytes = item.bytes.subarray(n);
+    }
+  }
+  poll() {
+    if (this.closed) return;
+    try {
+      for (let round = 0; round < 16; round++) {
+        this.msg.writeBigUInt64LE(BigInt(this.control.length), 40); this.msg.writeUInt32LE(0, 48);
+        const n = Number(libc.recvmsg(this.fd, this.msg, 0x40000000));
+        if (n < 0) { if (retry()) break; return this.close(); }
+        if (!n) return this.close();
+        const end = Number(this.msg.readBigUInt64LE(40));
+        for (let p = 0; p + 16 <= end;) {
+          const size = Number(this.control.readBigUInt64LE(p)); if (size < 16 || p + size > end) throw Error('Invalid ancillary data');
+          if (this.control.readInt32LE(p+8) === 1 && this.control.readInt32LE(p+12) === 1)
+            for (let q = p + 16; q + 4 <= p + size; q += 4) this.fds.push(this.control.readInt32LE(q));
+          p += Math.ceil(size / 8) * 8;
+        }
+        if (this.msg.readUInt32LE(48) & 8) throw Error('Truncated ancillary data');
+        this.input = Buffer.concat([this.input, this.data.subarray(0,n)]);
+        if (this.input.length > 1024*1024 || this.fds.length > 256) throw Error('Client queue limit');
+        this.onData();
+        if (this.closed) return;
+      }
+      this.flush();
+    } catch (e) { console.error(`Wayland client: ${e.message}`);
+      // Flush queued requests before disconnecting.
+      this.flush();
+      this.close(); }
+  }
+  close() {
+    if (this.closed) return; this.closed = true; libc.close(this.fd);
+    for (const item of this.output) for (const fd of item.fds) libc.close(fd);
+    this.output = []; this.queuedBytes = 0;
+    for (const fd of this.fds) libc.close(fd); this.fds = []; this.onClose?.(); this.removed();
+  }
+}
+
+export function connectUnix(path) {
+  if (Buffer.byteLength(path)>107 || path.includes('\0')) throw Error('Invalid Wayland socket path');
+  const fd=libc.socket(1,1|0x800|0x80000,0);
+  if(fd<0)throw Error(`socket: errno ${errno()}`);
+  const address=Buffer.alloc(110); address.writeUInt16LE(1);address.write(path,2);
+  if(libc.connect(fd,address,Buffer.byteLength(path)+3)<0){const code=errno();libc.close(fd);throw Error(`connect ${path}: errno ${code}`);}
+  return new Connection(fd,()=>{});
+}

package/frontends/wayland/urlbar.js

@@ -0,0 +1,162 @@
+// Casty's editor is vendored beside this adapter. Only rendering and browser
+// actions live here; selection, history, dragging and double clicks stay there.
+import {UrlBar,PromptHistory,toURL} from './casty/urlbar.js';
+import {COMMANDS,parseCommand,parseZoom} from './casty/commands.js';
+import {loadKeyBindings,toKeyName} from './casty/keys.js';
+import {loadConfig} from './casty/config.js';
+import {searchBookmarks} from './casty/bookmarks.js';
+import {displayWidth,fitWidth} from './casty/prompt-width.js';
+import {downloadPage} from './casty/download.js';
+import {HintMode} from './casty/hints.js';
+import {findInPage,toggleEruda} from './casty/page-commands.js';
+import {readClipboard,writeClipboard} from '../../lib/clipboard.js';
+
+export const BAR_HEIGHT=32;
+export const WAYLAND_COMMANDS=COMMANDS.filter(c=>!['cdp','kitty','pixelmouse'].includes(c.name));
+export function editorKey(key,modifiers=0) {
+  const letters={ArrowUp:'A',ArrowDown:'B',ArrowRight:'C',ArrowLeft:'D',Home:'H',End:'F'};
+  if(letters[key])return `\x1b[${modifiers?`1;${1+(modifiers&8?1:0)+(modifiers&1?2:0)+(modifiers&2?4:0)}`:''}${letters[key]}`;
+  if(key==='Delete')return '\x1b[3~';
+  if(key==='Backspace')return '\x7f';
+  if(key==='Enter')return '\r';if(key==='Escape')return '\x1b';if(key==='Tab')return '\t';
+  if(modifiers&2&&/^[a-z]$/i.test(key))return String.fromCharCode(key.toLowerCase().charCodeAt(0)-96);
+  return key.length===1||[...key].length===1?key:'';
+}
+class PixelEditor extends UrlBar {
+  constructor(onChange,history) {super({history,commandEntry:true});this.changed=onChange;this.columns=80;}
+  render(){this._dirty=false;this.changed?.();}
+}
+export class WaylandUrlBar {
+  constructor(context,{changed=()=>{},close=()=>{},clipboard=null,history=new PromptHistory()}={}) {
+    this.context=context;this.changed=changed;this.quit=close;this.height=BAR_HEIGHT;
+    this.clipboard=clipboard||{read:readClipboard,write:writeClipboard};
+    this.editor=new PixelEditor(()=>{this.dirty=true;this.caret=true;changed();},history);
+    this.bindings=loadKeyBindings();this.zoom=1;this.width=0;this.cellWidth=10;this.cache=new Map();
+    this.client={send:(method,params)=>this.send(method,params)};
+    this.hints=new HintMode(changed);
+    this.timer=setInterval(()=>{if(this.editor.editing){this.caret=!this.caret;this.dirty=true;changed();}},500);
+    this.timer.unref?.();this.dirty=true;
+  }
+  async initialize() {
+    const {loadGraphics}=await import('../../lib/renderer/page-renderer.js');
+    this.graphics=await loadGraphics();
+    const paragraph=this.paragraph('M','#ffffff');this.cellWidth=paragraph.getMaxIntrinsicWidth();
+    return this;
+  }
+  updateURL(url){if(url!==this.editor.currentUrl)this.editor.setUrl(url||'about:blank');}
+  flash(text){clearTimeout(this.statusTimer);this.editor.setStatus(String(text));this.editor.render();this.statusTimer=setTimeout(()=>{this.editor.clearStatus();this.editor.render();},5000);}
+  open(command=false,text=null){if(this.editor.editing)this.editor.cancelEditing();this.editor.startEditing({command,text}).then(result=>{
+    if(result?.mode==='cmd')return this.command(result.line);
+    if(result?.url)return this.navigate(result.url);
+  }).catch(error=>this.flash(error.message));}
+  async navigate(url){this.editor.loading=true;this.editor.render();try{await this.context.navigate(url);this.updateURL(this.context.url);}finally{this.editor.loading=false;this.editor.render();this.changed();}}
+  async press(key,options={}) {
+    const m=options.modifiers||0,name=toKeyName({key,modifiers:m});
+    if(this.editor.editing) {
+      if(name==='ctrl+c'||name==='alt+c')await this.clipboard.write(this.editor.selectedText||this.editor.text);
+      else if(name==='ctrl+x') {if(this.editor.selectedText){await this.clipboard.write(this.editor.selectedText);this.editor._clearIfSelected();this.editor.render();}}
+      else if(name==='ctrl+v')this.editor.insertText((await this.clipboard.read()).replace(/[\r\n]+/g,' '));
+      else this.editor.handleInput(editorKey(key,m));
+      return;
+    }
+    if(this.hints.active){await this.hints.handleInput(editorKey(key,m));return;}
+    const action=this.bindings[name];
+    // Native page editing must receive Ctrl-V itself (including preventDefault,
+    // selection replacement and beforeinput), using the frontend clipboard.
+    if(action==='paste')return this.context.press(key,options);
+    if(action){await this.action(action);return;}
+    return this.context.press(key,options);
+  }
+  async pointerButton(x,y,button,state,options={}) {
+    if(button<272||button>274)return;
+    if((y<this.height&&!this.pageButtons)||this.editor.dragging) {
+      if(button!==272)return;
+      const col=Math.max(1,Math.floor(x/this.cellWidth)+1);
+      if(state) {
+        if(!this.editor.editing){this.open(col<=3);if(col>3)this.editor.armDrag(col);}
+        else this.editor.pointerDown(col);
+      }else this.editor.pointerUp();
+      return;
+    }
+    if(state&&this.editor.editing)this.editor.cancelEditing();
+    const mask=button===272?1:button===273?2:4;
+    this.pageButtons=state?(this.pageButtons||0)|mask:(this.pageButtons||0)&~mask;
+    if(this.context.pointerButton)return this.context.pointerButton(x/this.zoom,(y-this.height)/this.zoom,button,state,options);
+    if(!state)return this.context.click(x/this.zoom,(y-this.height)/this.zoom,button===272?options:{...options,button:button===273?"right":"middle"});
+  }
+  move(x,y,options={}){if(this.editor.dragging){this.editor.pointerMove(Math.max(1,Math.floor(x/this.cellWidth)+1));return;}if(y>=this.height||this.pageButtons)return this.context.move(x/this.zoom,(y-this.height)/this.zoom,options);}
+  scroll(dx,dy,at){if(at?.y<this.height){if(this.editor.editing){if(dy<0)this.editor.historyUp();else this.editor.historyDown();}return;}return this.context.scroll(dx/this.zoom,dy/this.zoom,at?{x:at.x/this.zoom,y:(at.y-this.height)/this.zoom}:null);}
+  async command(line) {
+    const {name,arg,error}=parseCommand(line);if(error){this.flash(error);return;}
+    if(!WAYLAND_COMMANDS.some(c=>c.name===name)){this.flash(`${name} is not used by the Wayland frontend`);return;}
+    if(name==='open'){const url=toURL(arg);if(url)await this.navigate(url);else this.flash('Bookmark not found');}
+    else if(name==='bookmark'){const match=searchBookmarks(arg)[0];if(match)await this.navigate(match.url);else this.flash('Bookmark not found');}
+    else if(name==='help')this.flash(WAYLAND_COMMANDS.map(c=>c.usage).join(' · '));
+    else if(name==='find'){const result=await findInPage(this.client,arg);this.flash(result.error||`${result.text}: ${result.total?result.index+1:0}/${result.total}`);}
+    else if(name==='zoom'){if(!arg)this.flash(`Zoom ${Math.round(this.zoom*100)}%`);else{const zoom=parseZoom(arg,this.zoom);if(zoom===null)this.flash('Invalid zoom');else{this.zoom=zoom;this.changed();}}}
+    else await this.action({links:'hints',copyurl:'copy_url',pasteurl:'paste_url'}[name]||name);
+  }
+  async action(action) {
+    if(action==='quit'){this.quit();return;}
+    if(action==='url_bar'){this.open();return;}
+    if(action==='command'){this.open(true);return;}
+    if(action==='paste_url'){this.open(false,(await this.clipboard.read()).replace(/[\r\n]+/g,' '));return;}
+    if(action==='back')await this.context.goBack();
+    else if(action==='forward')await this.context.goForward();
+    else if(action==='reload')await this.context.reload();
+    else if(action==='home')await this.navigate(toURL(loadConfig().homeUrl));
+    else if(action==='copy_url'){await this.clipboard.write(this.context.url);this.flash('Copied URL');}
+    else if(action==='copy'){
+      const text=await this.context.evaluate(`(()=>{const e=document.activeElement;return e&&typeof e.selectionStart==='number'?e.value.slice(e.selectionStart,e.selectionEnd):String(getSelection())})()`);
+      if(text)await this.clipboard.write(text);
+    }else if(action==='paste')await this.context.type(await this.clipboard.read());
+    else if(action==='download')this.flash('Saved: '+await downloadPage(this.client));
+    else if(action==='hints'){void this.hints.start(this.client).catch(e=>this.flash(e.message));}
+    else if(action==='eruda')this.flash(await toggleEruda(this.client));
+    else if(['zoom_in','zoom_out','zoom_reset'].includes(action))this.zoom=parseZoom({zoom_in:'+',zoom_out:'-',zoom_reset:'reset'}[action],this.zoom);
+    this.updateURL(this.context.url);this.changed();
+  }
+  // Existing Casty helpers expect send(); route their small subset directly to
+  // the engine. There is no CDP socket or extra remote debugging server here.
+  async send(method,p={}) {
+    if(method==='Runtime.evaluate')return {result:{value:await this.context.evaluate(p.expression)}};
+    if(method==='Input.dispatchMouseEvent'){if(p.type==='mouseReleased')await this.context.click(p.x,p.y);else if(p.type==='mouseMoved')await this.context.move(p.x,p.y);return {};}
+    if(method==='Input.insertText'){await this.context.type(p.text);return {};}
+    if(method==='Page.getFrameTree'){const r=this.context.resourceContent(this.context.url);return {frameTree:{frame:{id:'main',url:this.context.url,mimeType:r?.contentType||''}}};}
+    if(method==='Page.getResourceContent'){const r=this.context.resourceContent(p.url);if(!r)throw Error('Page source unavailable');return {content:Buffer.from(r.body).toString('base64'),base64Encoded:true};}
+    throw Error(`Unsupported frontend helper method: ${method}`);
+  }
+  paragraph(text,color) {
+    const key=color+'\n'+text;let p=this.cache.get(key);if(p)return p;
+    const {CanvasKit:k,fontCollection,monospaceFamily,fontFamilies}=this.graphics;
+    const builder=k.ParagraphBuilder.MakeFromFontCollection(new k.ParagraphStyle({textStyle:{color:k.parseColorString(color),fontSize:16,fontFamilies:[monospaceFamily,...fontFamilies]},maxLines:1}),fontCollection);
+    builder.addText(text);p=builder.build();builder.delete();p.layout(100000);
+    if(this.cache.size>=256){const first=this.cache.keys().next().value;this.cache.get(first).delete();this.cache.delete(first);}
+    this.cache.set(key,p);return p;
+  }
+  pixels(width) {
+    if(width!==this.width){this.width=width;this.dirty=true;this.editor.columns=Math.max(1,Math.floor(width/this.cellWidth));}
+    if(!this.dirty&&this.bytes)return this.bytes;
+    const {CanvasKit:k}=this.graphics;if(!this.surface||this.surface.width()!==width){this.surface?.delete();this.surface=k.MakeSurface(width,this.height);}
+    const canvas=this.surface.getCanvas(),paint=new k.Paint();
+    canvas.clear(k.parseColorString(this.editor.editing?'#005f87':'#303030'));
+    const cols=this.editor.columns;
+    const ansi=this.editor.editing?this.editor._editLine(cols):this.editor._displayLine(cols);
+    let inverse=false,x=0;
+    for(const part of ansi.split(/(\x1b\[[\d;]*m)/)) {
+      if(part.startsWith('\x1b')){if(part==='\x1b[7m')inverse=true;else if(part==='\x1b[27m')inverse=false;continue;}
+      for(const char of part){const w=displayWidth(char)*this.cellWidth;
+        if(inverse){paint.setColor(k.parseColorString('#f4f8ff'));canvas.drawRect(k.XYWHRect(x,0,w,this.height),paint);}
+        if(char.trim()){const p=this.paragraph(char,inverse?'#005f87':'#f4f8ff');canvas.drawParagraph(p,x,(this.height-p.getHeight())/2);}
+        x+=w;if(x>=width)break;
+      }
+    }
+    if(this.editor.editing&&!this.editor.selectionRange&&this.caret){const view=this.editor._editView(cols);paint.setColor(k.parseColorString('#72e0e8'));canvas.drawRect(k.XYWHRect(view.cursorCol*this.cellWidth,6,1,20),paint);}
+    paint.delete();this.surface.flush();const image=this.surface.makeImageSnapshot();
+    try{this.bytes=Buffer.from(image.readPixels(0,0,{width,height:this.height,colorType:k.ColorType.RGBA_8888,alphaType:k.AlphaType.Unpremul,colorSpace:k.ColorSpace.SRGB}));}finally{image.delete();}
+    // Only the small toolbar strip is converted; page BGRA bytes remain untouched.
+    for(let i=0;i<this.bytes.length;i+=4){const red=this.bytes[i];this.bytes[i]=this.bytes[i+2];this.bytes[i+2]=red;}
+    this.dirty=false;return this.bytes;
+  }
+  dispose(){clearInterval(this.timer);clearTimeout(this.statusTimer);clearInterval(this.editor._spinTimer);this.editor.cancelEditing();for(const p of this.cache.values())p.delete();this.cache.clear();this.surface?.delete();}
+}

package/index.js

@@ -43,6 +43,14 @@ const INFORMATION = new Map([
 /** Splits the command line into a frontend and the arguments it receives. */
 export function chooseFrontend(argv) {
   const [first, ...rest] = argv;
+
+  // wayland handle begin: independent native frontend
+  if (first === "--wayland") return { frontend: "wayland", args: rest };
+  // wayland handle end
+
+  if (["--quickshell-wayland", "--quickshell-headless", "--quickshell-casty"].includes(first))
+    return { frontend: first.slice(2), args: rest };
+
   if (first === "--casty") return { frontend: "casty", args: rest };
   if (first === "--headless") return { frontend: "headless", args: rest };
   if (RESERVED_FRONTENDS.has(first)) return { frontend: first.slice(2), args: rest, reserved: true };
@@ -66,13 +74,17 @@ export function castyCommand(args, which = Bun.which) {
 }
 
 export function usage(name = packageInfo.name) {
+  // wayland handle begin: frontend help
+  const waylandHelp = '  --wayland\n      Experimental standard Wayland SHM window; --wayland --help for options\n';
+  // wayland handle end
+
   return `Usage:
   ${name} [URL] [CASTY_OPTIONS...] [-- BROWSER_FLAGS...]
   ${name} --casty [CASTY_ARGS...]
   ${name} --headless [ENGINE_OPTIONS...]
 
 Frontends (first argument only):
-  --casty
+${typeof waylandHelp === "undefined" ? "" : waylandHelp}  --casty
       Browse in the terminal with casty (the default)
       Needs a terminal with the Kitty graphics protocol
       Any first argument not listed here also starts casty,
@@ -81,6 +93,9 @@ Frontends (first argument only):
   --headless
       Start the engine only, as a CDP endpoint
       The engine's options: ${name} --headless --help
+  --quickshell-wayland, --quickshell-headless, --quickshell-casty
+      Experimental Quickshell CLI (-p FILE_OR_DIRECTORY / -c CONFIG)
+      Use -- before backend arguments; each entry supports --help
   --win32, --gtk, --appkit, --qt
       Native windowed frontends (reserved, not implemented yet)
 
@@ -147,6 +162,18 @@ if (import.meta.main) {
     await printReadme();
     process.exit(0);
   }
+
+  if (frontend.startsWith("quickshell-")) {
+    const entry = join(import.meta.dir, "lib/qml/qs" + frontend.slice("quickshell-".length));
+    process.exit(await run([process.execPath, entry, ...args]) ?? 1);
+  }
+
+  // wayland handle begin: launch the isolated frontend
+  if (frontend === "wayland") {
+    process.exit(await run([process.execPath, join(import.meta.dir, "frontends/wayland/index.js"), ...args]) ?? 1);
+  }
+  // wayland handle end
+
   const code = frontend === "headless"
     ? await run([process.execPath, ENGINE, ...args])
     : await run(castyCommand(args), { ...process.env, CASTY_BROWSER: ENGINE });

package/lib/audio/shared-connection.js

@@ -0,0 +1,31 @@
+// Keep one connection while audio-owning renderer processes are alive. A
+// completed stream does not release its owner: the page may play again.
+export class SharedAudioConnection {
+  #connect;
+  #pending = null;
+  #owners = new Set();
+
+  constructor(connect) { this.#connect = connect; }
+
+  acquire(owner) {
+    this.#owners.add(owner);
+    if (!this.#pending) {
+      const pending = Promise.resolve().then(this.#connect).catch(error => {
+        if (this.#pending === pending) this.#pending = null;
+        throw error;
+      });
+      this.#pending = pending;
+    }
+    return this.#pending;
+  }
+
+  release(owner) {
+    this.#owners.delete(owner);
+    if (this.#owners.size || !this.#pending) return;
+    const pending = this.#pending;
+    this.#pending = null;
+    // Also close connections whose authentication is still in flight. A new
+    // owner gets a separate connection and cannot inherit this closing one.
+    void pending.then(client => client.close()).catch(() => {});
+  }
+}

package/lib/cdp-server.js

@@ -701,7 +701,7 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
     case "Input.dispatchMouseEvent": {
       const target = getSessionTarget(state, sessionId);
       if (params.type === "mouseMoved") {
-        await ctx.move?.(params.x, params.y);
+        await ctx.move?.(params.x, params.y, {modifiers:params.modifiers ?? 0});
         return {};
       }
       if (params.type === "mouseWheel") {
@@ -709,9 +709,22 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
         return {};
       }
 
+      if (ctx.pointerButton && (params.type === 'mousePressed' || params.type === 'mouseReleased')) {
+        const navigation = await ctx.pointerButton(params.x,params.y,
+          params.button==='right'?273:params.button==='middle'?274:272,
+          params.type==='mousePressed'?1:0,
+          {clickCount:params.clickCount,modifiers:params.modifiers});
+        if (navigation?.url) {
+          navigateTarget(state,target,navigation.url,emit,{addHistory:true});
+          target.title=navigation.title ?? await getContextTitle(ctx,target);
+          target.history[target.historyIndex].title=target.title;
+          if(target.screencast)await pushScreencastFrame(ctx,state,target);
+        }
+        return {};
+      }
       if (params.type === "mouseReleased") {
         target.focusedSelector = target.pendingSelector;
-        applyClick(target, target.pendingSelector);
+        if (!params.button || params.button === "left") applyClick(target, target.pendingSelector);
         const navigation = await ctx.click?.(params.x, params.y, {
           button: params.button,
           clickCount: params.clickCount,

package/lib/clipboard-command.js

@@ -0,0 +1,10 @@
+// Adapter for jsmdcui's unchanged PowerShell clipboard functions.
+export function runSync(command, options = {}) {
+  try {
+    const p = Bun.spawnSync(command, {
+      stdin: options.stdin == null ? 'ignore' : Buffer.from(options.stdin),
+      stdout: options.stdout ?? 'pipe', stderr: 'pipe', timeout: options.timeout ?? 2000,
+    });
+    return {ok:p.success, stdout:p.stdout?.toString() ?? '', stderr:p.stderr?.toString() ?? ''};
+  } catch (error) { return {ok:false, stdout:'', stderr:String(error)}; }
+}

package/lib/clipboard-powershell.js

@@ -0,0 +1,22 @@
+// Functions copied verbatim from jsmdcui/src/platform/clipboard.js (MIT).
+// Keep command spelling, quoting and trailing-newline handling unchanged.
+import { runSync } from "./clipboard-command.js";
+
+function powershellClipboard(shell) {
+  return {
+    name: "powershell",
+    // Get-Clipboard -Raw appends \r\n to stdout; strip exactly one trailing line ending.
+    read: () => outputOrThrow(runSync([shell, "-NoProfile", "-Command", "Get-Clipboard -Raw"], {})).replace(/\r?\n$/, ""),
+    write: (text) => {
+      text=(text+'').replaceAll("'","''") ;
+      return runSync([shell, "-NoProfile", "-Command", `Set-Clipboard '${text}'`], { stdout: "ignore" }).ok ;
+    },
+  };
+}
+
+function outputOrThrow(result) {
+  if (!result.ok) throw new Error(result.stderr || result.stdout || "clipboard command failed");
+  return result.stdout;
+}
+
+export { powershellClipboard };

package/lib/clipboard.js

@@ -1,9 +1,9 @@
+import {powershellClipboard} from './clipboard-powershell.js';
 // Host-side text clipboard. No shell interpolation; page bytes go only to stdin.
 export function clipboardCommands(platform = process.platform) {
   return [
     ['xclip','-selection','clipboard'],
-    ...(platform === 'win32' ? [['powershell.exe','-NoProfile','-NonInteractive','-Command',
-      '[Console]::InputEncoding = [System.Text.Encoding]::UTF8; Set-Clipboard -Value ([Console]::In.ReadToEnd())']]
+    ...(platform === 'win32' ? [['powershell.exe']]
       : platform === 'darwin' ? [['pbcopy']] : [['wl-copy'],['termux-clipboard-set']]),
   ];
 }
@@ -13,6 +13,10 @@ export async function writeClipboard(text, {which = Bun.which, spawn = Bun.spawn
     const executable=which(command[0]); if(!executable)continue;
     let child,timer;
     try {
+      if(command[0]==='powershell.exe') {
+        if(powershellClipboard(executable).write(text))return;
+        continue;
+      }
       child=spawn([executable,...command.slice(1)],{stdin:Buffer.from(text),stdout:'ignore',stderr:'ignore'});
       timer=setTimeout(()=>child.kill(9),3000);
       if(await child.exited === 0)return;
@@ -20,3 +24,34 @@ export async function writeClipboard(text, {which = Bun.which, spawn = Bun.spawn
   }
   throw Error('No working clipboard command (xclip preferred)');
 }
+
+// Read only on an explicit paste request; never poll the system clipboard.
+export async function readClipboard({which = Bun.which, spawn = Bun.spawn, platform = process.platform} = {}) {
+  const commands = [['xclip','-selection','clipboard','-o'],
+    ...(platform === 'win32' ? [['powershell.exe','-NoProfile','-Command','Get-Clipboard -Raw']]
+      : platform === 'darwin' ? [['pbpaste']] : [['wl-paste','--no-newline'],['termux-clipboard-get']])];
+  for (const command of commands) {
+    const executable = which(command[0]); if (!executable) continue;
+    let child, timer;
+    try {
+      if(command[0]==='powershell.exe') {
+        const text=powershellClipboard(executable).read();
+        if(Buffer.byteLength(text)>1024*1024)throw Error('Clipboard text exceeds limit');
+        return text;
+      }
+      child = spawn([executable,...command.slice(1)], {stdin:'ignore',stdout:'pipe',stderr:'ignore'});
+      timer = setTimeout(()=>child.kill(9),3000);
+      const chunks=[]; let size=0;
+      for await (const chunk of child.stdout) {
+        size += chunk.length;
+        if (size > 1024*1024) { child.kill(9); throw Error('Clipboard text exceeds limit'); }
+        chunks.push(Buffer.from(chunk));
+      }
+      if (await child.exited === 0) {
+        const text=Buffer.concat(chunks).toString();
+        return command[0]==='powershell.exe' ? text.replace(/\r?\n$/, '') : text;
+      }
+    } catch {} finally {clearTimeout(timer);}
+  }
+  throw Error('No working clipboard read command (xclip preferred)');
+}

package/lib/document-types.js

@@ -1,3 +1,7 @@
+// qml handle begin: response classification
+import {isQmlDocument, QML_MIME} from "./qml/format.js";
+// qml handle end
+
 /**
  * What a top-level response looks like in the viewport. HTML is shown as
  * itself; anything else gets a small generated HTML document, as browsers do
@@ -73,6 +77,13 @@ function previewKind(name, type) {
 export function displayDocument({ url, contentType = "", body }) {
   const { type, charset } = parseContentType(contentType);
   const name = fileName(url);
+
+  // qml handle begin: preserve QML source for the renderer
+  if (body.byteLength <= DISPLAY_LIMIT && isQmlDocument(url, contentType)) {
+    return {source: decode(body, charset), contentType: QML_MIME};
+  }
+  // qml handle end
+
   if (HTML_TYPES.has(type) || (type === "" && looksLikeHtml(body))) {
     return { source: decode(body, charset), contentType: contentType || "text/html" };
   }

package/lib/headless-shell.js

@@ -1,3 +1,8 @@
+// qml handle begin: select a dedicated local application renderer
+import {isQmlDocument} from './qml/format.js';
+// Local QML uses a dedicated host renderer.
+// qml handle end
+
 /**
  * Headless shell controller.
  *
@@ -7,8 +12,8 @@
  * runs page content itself.
  *
  * Sandbox flags: `--no-sandbox` is accepted for Chromium compatibility (casty
- * always passes it) but ignored. Only `--dangerously-allow-host-js` relaxes
- * the renderer sandbox, for every page.
+ * always passes it) but ignored. `--dangerously-allow-host-js` relaxes
+ * the renderer sandbox for every page.
  */
 import { CdpServer } from "./cdp-server.js";
 import { DEFAULT_DOWNLOAD_DIR, isAttachment, saveDownload, suggestedFilename } from "./download.js";
@@ -80,12 +85,14 @@ export async function runHeadlessShell(args = Bun.argv.slice(2)) {
  * anything that needs a renderer waits for it.
  *
  * @param {{ allowHostJs?: boolean, spareRenderer?: boolean, network?: NetworkService, rendererTimeout?: number,
- *   waitForRenderer?: boolean, mobile?: boolean, webkit?: boolean }} options
+ *   waitForRenderer?: boolean, mobile?: boolean, webkit?: boolean,
+ *   clipboard?: {read: Function, write: Function} }} options
  * WebKit identity defaults on; webkit: false selects Chromium. Mobile takes priority.
  */
 export async function createBrowser({
   allowHostJs = false, spareRenderer = true, network = new NetworkService(), rendererTimeout = 30_000, mobile = false,
   waitForRenderer = true, webkit = true,
+  clipboard = null,
 } = {}) {
   // Explicit presentation profiles fix the identity for requests and scripts.
   const initialUserAgent = mobile ? MOBILE_USER_AGENT : webkit ? WEBKIT_USER_AGENT : DESKTOP_USER_AGENT;
@@ -158,10 +165,18 @@ export async function createBrowser({
   }
 
   function createHost() {
+    let args = [...(allowHostJs ? [DANGEROUSLY_ALLOW_HOST_JS] : []), ...(mobile ? [MOBILE_FLAG] : [])];
+
+    // qml handle begin: internal options for a dedicated application renderer
+    if (arguments[0]?.qmlHost) args = ["--buninu-qml-host", ...args];
+    // qml handle end
+
     const host = new RendererHost({
+      // Native frontends supply one clipboard for page APIs and input defaults.
+      ...(clipboard?{clipboardRead:()=>clipboard.read(),clipboardWrite:text=>clipboard.write(text)}:{}),
       network,
       timeout: rendererTimeout,
-      args: [...(allowHostJs ? [DANGEROUSLY_ALLOW_HOST_JS] : []), ...(mobile ? [MOBILE_FLAG] : [])],
+      args,
       // A replacement renderer starts blank; bring the current page back.
       onRestart: async (invoke) => {
         await replayState(invoke);
@@ -225,10 +240,22 @@ export async function createBrowser({
 
   /** The renderer for a URL's origin, swapping processes on an origin change. */
   async function rendererFor(url) {
-    const key = originKey(url);
+    let key = originKey(url);
+    let acquireHost = () => {
+      const next = spare ?? createHost();
+      spare = null;
+      return next;
+    };
+
+    // qml handle begin: never reuse application realms or take an ordinary spare
+    if (arguments[1]?.qmlHost) {
+      key = Symbol("qml document");
+      acquireHost = () => createHost({ qmlHost: true });
+    }
+    // qml handle end
+
     if (current && key === currentKey) return current;
-    const next = spare ?? createHost();
-    spare = null;
+    const next = acquireHost();
     await next.start();
     await replayState((method, ...params) => next.call(method, ...params));
     const previous = current;
@@ -307,7 +334,18 @@ export async function createBrowser({
     writeLog("navigation", `${url}: ${document.error ?? `HTTP ${document.status ?? 200}`}`
       + `${document.url === url ? "" : ` -> ${document.url}`} in ${Math.round(fetched - started)}ms`);
     if (!invoke) await rendererReady;
-    const host = invoke ? current : await rendererFor(document.url);
+    let selectRenderer = rendererFor;
+
+    // qml handle begin: host privileges require a local top-level QML document
+    const qmlHost = !document.error && new URL(document.url).protocol === "file:"
+      && isQmlDocument(document.url, document.contentType);
+    // A restarted renderer may restore a response of a different type.
+    const restoreChangedType = invoke && (typeof currentKey === "symbol") !== qmlHost;
+    if (restoreChangedType) invoke = null;
+    selectRenderer = url => rendererFor(url, { qmlHost });
+    // qml handle end
+
+    const host = invoke ? current : await selectRenderer(document.url);
     let generation;
     try {
       generation = await (invoke ?? ((method, ...params) => host.call(method, ...params)))("loadDocument", document);
@@ -389,6 +427,7 @@ export async function createBrowser({
   }
 
   const context = {
+    get url() { return currentUrl; },
     navigate,
     get userAgent() { return userAgent ?? initialUserAgent; },
     setDownloadBehavior({ behavior = "allow", downloadPath = DEFAULT_DOWNLOAD_DIR, eventsEnabled = false } = {}) {
@@ -477,11 +516,14 @@ export async function createBrowser({
     lifecycleState() {
       return [...reachedLifecycle(committed.host, committed.generation)];
     },
-    move(x, y) {
-      return call("move", x / pageScale(), y / pageScale());
+    move(x, y, options = {}) {
+      return call("move", x / pageScale(), y / pageScale(), options);
+    },
+    pointerButton(x, y, button, state, options = {}) {
+      return this.click(x, y, {...options, button:button===273?'right':button===274?'middle':'left', phase:state?'down':'up'});
     },
-    async click(x, y) {
-      const clicked = await call("click", x / pageScale(), y / pageScale());
+    async click(x, y, options = {}) {
+      const clicked = await call("click", x / pageScale(), y / pageScale(), options);
       const href = typeof clicked === "string" ? clicked : clicked?.url;
       if (typeof href !== "string") return null;
       if (clicked.fragmentFrom) {