buninu-browser 0.3.0 → 0.5.0

package/lib/qml/textures.js

@@ -0,0 +1,126 @@
+// Serialized into the QML realm. Snapshot ownership stays in ordinary canvases.
+export function createQmlTextures(api) {
+  const { elements, state, effect, untrack, signal, cleanup } = api;
+  const entries = new WeakMap(), refs = new WeakMap(), pending = new Set();
+  const reference = value => {
+    let ref = refs.get(value);
+    if (!ref) refs.set(value, ref = state({ count: 0, hidden: 0 }));
+    return ref;
+  };
+  function attach(value, delta, hide) {
+    if (!value) return;
+    const ref = reference(value);
+    ref.count += delta;
+    if (hide) ref.hidden += delta;
+    const element = elements.get(value);
+    if (element) {
+      if (ref.count) element.setAttribute('data-qml-texture-source', '');
+      else element.removeAttribute('data-qml-texture-source');
+      if (ref.hidden || (!value.visible && ref.count)) element.setAttribute('data-qml-source-hidden', '');
+      else element.removeAttribute('data-qml-source-hidden');
+    }
+  }
+  function make(v, type, element) {
+    if (type !== 'ShaderEffectSource') return;
+    if (!api.host) throw Error('ShaderEffectSource requires a local QML host renderer');
+    Object.assign(v, { sourceItem: null, sourceRect: { x: 0, y: 0, width: 0, height: 0 },
+      mipmap:false, smooth:true, textureSize: { width: 0, height: 0 }, hideSource: false, live: true,
+      scheduledUpdateCompleted: signal() });
+    const canvas = document.createElement('canvas');
+    canvas.width = canvas.height = 1;
+    canvas.style.cssText = 'position:absolute;left:0;top:0;width:100%;height:100%;pointer-events:none';
+    canvas.setAttribute('data-qml-texture', '');
+    element.appendChild(canvas);
+    const entry = { canvas, revision: state({ value: 0 }), ready: false };
+    entries.set(v, entry);
+    let source = null, hiding = false, observer, frame, disposed = false, requested = true;
+    const queue = () => {
+      if (!disposed && frame === undefined) { pending.add(capture); frame = requestAnimationFrame(capture); }
+    };
+    const capture = () => {
+      if (frame !== undefined) cancelAnimationFrame(frame);
+      pending.delete(capture);
+      frame = undefined;
+      if (disposed || !source || !requested) return;
+      const input = elements.get(source);
+      if (!input?.isConnected || !(source.width > 0 && source.height > 0)) return;
+      const rect = v.sourceRect;
+      const sw = rect.width > 0 ? rect.width : source.width;
+      const sh = rect.height > 0 ? rect.height : source.height;
+      const w = Math.ceil(v.textureSize.width > 0 ? v.textureSize.width : sw);
+      const h = Math.ceil(v.textureSize.height > 0 ? v.textureSize.height : sh);
+      if (!(w > 0 && h > 0) || w > 8192 || h > 8192 || w * h > 16777216)
+        throw Error('QML texture exceeds snapshot size limit');
+      requested = false;
+      if (canvas.width !== w) canvas.width = w;
+      if (canvas.height !== h) canvas.height = h;
+      const ctx = canvas.getContext('2d');
+      ctx.imageSmoothingEnabled=v.smooth!==false;
+      ctx.clearRect(0, 0, w, h);
+      ctx.drawImage(input, rect.width > 0 ? rect.x : 0, rect.height > 0 ? rect.y : 0, sw, sh, 0, 0, w, h);
+      entry.ready = true;
+      entry.revision.value++;
+      // Only signal once pixels are actually in the destination canvas.
+      v.scheduledUpdateCompleted();
+    };
+    v.scheduleUpdate = () => { requested = true; queue(); };
+    effect(() => {
+      const next = v.sourceItem, hide = v.hideSource;
+      v.smooth;
+      if(v.mipmap)throw Error("ShaderEffectSource mipmaps are not implemented");
+      const live = v.live;
+      const size = v.textureSize, rect = v.sourceRect;
+      size.width; size.height; rect.x; rect.y; rect.width; rect.height;
+      if (next) { next.width; next.height; next.visible; }
+      untrack(() => {
+        if (next !== source || hide !== hiding) {
+          observer?.disconnect();
+          attach(source, -1, hiding);
+          source = next; hiding = hide;
+          attach(source, 1, hiding);
+          if (source) {
+            const input = elements.get(source);
+            if (!input) throw Error('ShaderEffectSource.sourceItem must be an Item');
+            observer = new MutationObserver(() => {
+              if (v.live) { requested = true; queue(); }
+            });
+            observer.observe(input, { subtree: true, attributes: true, childList: true, characterData: true });
+          } else {
+            entry.ready = false;
+            canvas.width = canvas.height = 1;
+            entry.revision.value++;
+          }
+        }
+        if (live || !entry.ready || requested) { requested = true; queue(); }
+      });
+    });
+    cleanup(() => {
+      disposed = true;
+      pending.delete(capture);
+      observer?.disconnect();
+      if (frame !== undefined) cancelAnimationFrame(frame);
+      untrack(() => attach(source, -1, hiding));
+      canvas.width = canvas.height = 1;
+      canvas.remove();
+      entries.delete(v);
+    });
+  }
+  function keepLayout(v) {
+    const ref = reference(v);
+    const keep = ref.count > 0;
+    const element = elements.get(v);
+    const hidden = ref.hidden > 0 || (keep && !v.visible);
+    if (element && element.hasAttribute('data-qml-source-hidden') !== hidden) {
+      if (hidden) element.setAttribute('data-qml-source-hidden', '');
+      else element.removeAttribute('data-qml-source-hidden');
+    }
+    return keep;
+  }
+  function image(v) {
+    const entry = entries.get(v);
+    if (!entry) throw Error('ShapePath.fillItem currently requires ShaderEffectSource');
+    entry.revision.value;
+    return entry.ready ? entry.canvas : null;
+  }
+  return { make, keepLayout, image, flush: () => { for (const capture of [...pending]) capture(); } };
+}

package/lib/qml/wayland-clipboard.js

@@ -0,0 +1,32 @@
+// Optional local-QML bridge to the frontend's standard Wayland clipboard.
+// Ordinary HTML never needs this HTTP endpoint. Create it lazily before the
+// first local QML navigation, including navigation after an about:blank launch.
+export async function attachQmlClipboard(client,browser,done) {
+  const clipboard=client.clipboard;
+  if(!clipboard)return;
+  const navigate=browser.context.navigate;
+  let server,setup,closed=false;
+  const prepare=()=>setup??=(async()=>{
+    const token=crypto.randomUUID();
+    server=Bun.serve({hostname:'127.0.0.1',port:0,maxRequestBodySize:1024*1024+1024,
+      async fetch(request) {
+        if(request.method!=='POST'||new URL(request.url).pathname!=='/'+token||request.headers.has('origin'))return new Response(null,{status:403});
+        try {
+          const {operation,text}=await request.json();
+          if(operation==='read')return Response.json({text:await clipboard.read()});
+          if(operation!=='write'||typeof text!=='string')return new Response(null,{status:400});
+          await clipboard.write(text);return Response.json({});
+        }catch{return new Response(null,{status:503});}
+      }});
+    await browser.context.addInitScript(`globalThis.__qmlHost?.setClipboardEndpoint(${JSON.stringify(`http://127.0.0.1:${server.port}/${token}`)});`);
+  })();
+  const wrapped=async function(url,...args) {
+    if(!closed&&/^file:.*\.qml(?:[?#]|$)/i.test(String(url)))await prepare();
+    return navigate.call(this,url,...args);
+  };
+  browser.context.navigate=wrapped;
+  done.finally(()=>{
+    closed=true;server?.stop(true);
+    if(browser.context.navigate===wrapped)browser.context.navigate=navigate;
+  });
+}

package/lib/qml/window-constraints.js

@@ -0,0 +1,16 @@
+// Optional frontend adapter; xdg_toplevel size hints, not an application check.
+export function qmlWindowConstraints(client,window,context) {
+  let previous='';
+  return async()=>{
+    if(!previous&&!/\.qml(?:[?#]|$)/i.test(context.url||''))return;
+    const hints=await context.evaluate(`(()=>{const elements=[...document.querySelectorAll('[data-qml-window-min]')];const e=elements.find(e=>e.style.display!=='none');return e?[e.getAttribute('data-qml-window-min'),e.getAttribute('data-qml-window-max')]:null;})()`);
+    const key=JSON.stringify(hints);if(previous===key)return;
+    const parse=value=>{try{return JSON.parse(value).map(n=>Number.isFinite(n)?Math.max(0,Math.min(8192,Math.ceil(n))):0);}catch{return [0,0];}};
+    const min=parse(hints?.[0]),max=parse(hints?.[1]);
+    for(let i=0;i<2;i++)if(max[i]&&max[i]<min[i])max[i]=min[i];
+    client.request(window.toplevel,'set_min_size',...min);
+    client.request(window.toplevel,'set_max_size',...max);
+    client.request(window.surface,'commit');
+    previous=key;
+  };
+}

package/lib/qml/worker-thread.js

@@ -0,0 +1,70 @@
+// Local WorkerScript application code executes on its own Bun worker thread.
+// Qt.include uses one script global scope; it is not the QML import resolver.
+import { parentPort, workerData } from 'node:worker_threads';
+import { readFileSync } from 'node:fs';
+import { createContext, Script } from 'node:vm';
+let current = workerData.url,
+  bytes = 0,
+  depth = 0;
+const context = createContext({
+  console,
+  WorkerScript: {
+    onMessage: null,
+    sendMessage: (message) =>
+      parentPort.postMessage({ kind: 'message', message }),
+  },
+});
+const run = (url) => {
+  if (new URL(url).protocol !== 'file:')
+    throw Error('WorkerScript imports must be local files');
+  if (++depth > 48) throw Error('WorkerScript include depth exceeded');
+  const previous = current;
+  current = url;
+  try {
+    const source = readFileSync(new URL(url), 'utf8');
+    bytes += Buffer.byteLength(source);
+    if (bytes > 4 * 1024 * 1024)
+      throw Error('WorkerScript source limit exceeded');
+    // Like Qt.include in a WorkerScript, directives supply no import aliases.
+    const code = source.replace(
+      /^\s*\.(?:pragma\s+library|import\s+[^\n]+)\s*$/gm,
+      '',
+    );
+    new Script(code, { filename: url }).runInContext(context);
+  } finally {
+    current = previous;
+    depth--;
+  }
+};
+context.Qt = {
+  include: (relative, callback) => {
+    let result;
+    try {
+      run(new URL(relative, current).href);
+      result = { status: 0 };
+    } catch (exception) {
+      result = { status: 3, exception };
+    }
+    callback?.(result);
+    return result;
+  },
+};
+try {
+  run(current);
+  parentPort.postMessage({ kind: 'ready' });
+  parentPort.on('message', (message) => {
+    try {
+      context.WorkerScript.onMessage?.(message);
+    } catch (error) {
+      parentPort.postMessage({
+        kind: 'error',
+        error: String(error.stack || error),
+      });
+    }
+  });
+} catch (error) {
+  parentPort.postMessage({
+    kind: 'error',
+    error: String(error.stack || error),
+  });
+}

package/lib/render-tree/index.js

@@ -1,6 +1,8 @@
 import { extractSvg } from "./svg.js";
 import { computeElementStyle, controlKind } from "../style/computed-style.js";
 
+import {textInputSelection} from '../renderer/text-input-paint.js';
+
 const PLACEHOLDER_COLOR = "rgba(117, 117, 117, 1)";
 const CHECKED_COLOR = "rgba(0, 117, 255, 1)";
 const DEFAULT_SUMMARY = Object.freeze({ tagName: "SUMMARY", getAttribute: () => null, hasAttribute: () => false });
@@ -99,6 +101,7 @@ export class RenderTreeBuilder {
     let keys = this.#pseudoKeys.get(element);
     if (!keys) this.#pseudoKeys.set(element, keys = { before: {}, after: {}, beforeText: {}, afterText: {} });
     keys.value ??= {};
+    const controlType=boxType(style)==="inline"?"inline-block":boxType(style);
     let boxStyle = style;
     let text = "";
     let textStyle = style;
@@ -134,10 +137,22 @@ export class RenderTreeBuilder {
         textStyle = Object.freeze({ ...style, color: PLACEHOLDER_COLOR });
       }
     }
+
+    if (control === "text" || control === "textarea") {
+      const selected = textInputSelection(element, text, textStyle, (part, type, properties, domNode) => {
+        keys.inputSelection ??= {};
+        keys.inputSelection[part] ??= {};
+        return this.#node(domNode, type, nodesById, properties, keys.inputSelection[part]);
+      });
+      if (selected) return this.#node(element, controlType, nodesById, {
+        tagName: element.tagName, style: boxStyle, children: Object.freeze(selected),
+      });
+    }
+
     const children = text
       ? [this.#node(element, "text", nodesById, { text, style: textStyle, pseudo: "value", children: Object.freeze([]) }, keys.value)]
       : [];
-    return this.#node(element, "inline-block", nodesById, {
+    return this.#node(element, controlType, nodesById, {
       tagName: element.tagName,
       style: boxStyle,
       children: Object.freeze(children),

package/lib/renderer/bindings.js

@@ -21,6 +21,7 @@ const isCanvasSizeAttribute = (node, name, namespace = null) => !namespace
   && node.namespaceURI === "http://www.w3.org/1999/xhtml" && node.tagName === "CANVAS"
   && (name === "width" || name === "height");
 const REFLECTED_PROPERTIES = [
+  "selectionStart", "selectionEnd", "selectionDirection", "maxLength",
   "value", "checked", "disabled", "type", "name", "href", "src", "alt", "title",
   "placeholder", "selected", "readOnly", "required", "min", "max", "step", "rel", "target",
   "htmlFor", "lang", "dir", "tabIndex", "hidden", "defaultValue", "action", "method",
@@ -204,6 +205,8 @@ export class BindingRealm {
   }
 
   /** The page's Range for an engine Range (one wrapper each). */
+  unwrapRange(range) { return RangeBinding.rangeOf(range); }
+
   wrapRange(range) {
     if (!range) return null;
     let wrapper = this.#ranges.get(range);
@@ -1097,6 +1100,16 @@ class ElementBinding extends ParentBinding {
 
   get validity() { return this.#validity ??= realmOf(this).wrapValidity(nodeOf(this).validity); }
 
+  setSelectionRange(start, end, direction = 'none') {
+    if(arguments.length<2)throw new TypeError('setSelectionRange requires start and end');
+    nodeOf(this).setSelectionRange(Number(start),Number(end),String(direction));touch(this);
+  }
+  setRangeText(replacement, ...args) {
+    if(!arguments.length)throw new TypeError('setRangeText requires replacement');
+    nodeOf(this).setRangeText(String(replacement),...args.map((v,i)=>i<2?Number(v):String(v)));touch(this);
+  }
+  select() {nodeOf(this).select();touch(this);}
+
   setCustomValidity(message) {
     if (!arguments.length) throw new TypeError("setCustomValidity requires a message");
     nodeOf(this).setCustomValidity(String(message));
@@ -1361,7 +1374,7 @@ function isMedia(wrapper) {
 
 /** on* event handler properties (element.onclick = fn, script.onload = fn). */
 export const EVENT_HANDLER_NAMES = Object.freeze([
-  "click", "dblclick", "mousedown", "mouseup", "mousemove", "mouseover", "mouseout", "mouseenter", "mouseleave",
+  "click", "auxclick", "dblclick", "mousedown", "mouseup", "mousemove", "mouseover", "mouseout", "mouseenter", "mouseleave",
   "keydown", "keyup", "keypress", "beforeinput", "input", "change", "submit", "reset", "focus", "blur", "load", "error",
   "abort", "scroll", "resize", "wheel", "contextmenu", "touchstart", "touchend", "touchmove",
   "pointerdown", "pointerup", "pointermove", "animationend", "transitionend", "readystatechange", "slotchange", "toggle", "invalid",
@@ -1685,6 +1698,8 @@ class DocumentBinding extends ParentBinding {
     return realmOf(this).wrap(nodeOf(this).createDocumentFragment());
   }
 
+  getSelection() { return realmOf(this).selection?.() ?? null; }
+
   createRange() {
     return realmOf(this).wrapRange(nodeOf(this).createRange());
   }

package/lib/renderer/canvas-2d.js

@@ -14,6 +14,10 @@
  * whole WASM heap. The copy handed back is only the requested rectangle.
  */
 
+// qml handle begin: consume local-QML DOM snapshots without exposing native images
+import { drawQmlDomImage } from "../qml/canvas-dom.js";
+// qml handle end
+
 let CanvasKit = null;
 
 /** The CanvasKit `loadGraphics` instantiated. Page canvases share it. */
@@ -225,6 +229,15 @@ function open(node) {
           if (property === "drawImage" && resolveImage) {
             source = resolveImage(args[0]);
             if (!source?.image) return;
+
+            // qml handle begin: temporary DOM images have synchronous ownership
+            if (drawQmlDomImage(source, state.node.deref(), context, args)) {
+              if (source.originClean === false) state.originClean = false;
+              changed(state);
+              return;
+            }
+            // qml handle end
+
             args[0] = source.image;
           }
           const result = context[property](...args);
@@ -333,3 +346,19 @@ function copyImageData(image) {
   }
   return { width: image.width, height: image.height, data, colorSpace: "srgb" };
 }
+
+// qml handle begin: software fragment effects draw into the existing canvas surface
+export function paintQmlCanvas(node, draw) {
+  if (!canvasContext(node, "2d")) throw Error('Canvas renderer is unavailable');
+  const state = surfaces.get(node).state;
+  if (!state.raster) throw Error('Canvas surface is unavailable');
+  const canvas = state.raster.getCanvas();
+  canvas.save();
+  try {
+    const inverse = CanvasKit.Matrix.invert(canvas.getTotalMatrix());
+    if (!inverse) throw Error("Noninvertible QML canvas transform");
+    canvas.concat(inverse); draw(canvas);
+  }
+  finally { canvas.restore(); changed(state); }
+}
+// qml handle end

package/lib/renderer/document-selection.js

@@ -0,0 +1,19 @@
+// Keep engine nodes/ranges behind the same DOM wrappers as the rest of the realm.
+export function selectionBinding(window, realm, nodeOf, changed) {
+  const native=()=>window.getSelection();
+  const api={};
+  for(const key of ['anchorOffset','focusOffset','isCollapsed','rangeCount','type'])Object.defineProperty(api,key,{get:()=>native()[key]});
+  for(const key of ['anchorNode','focusNode'])Object.defineProperty(api,key,{get:()=>realm.wrap(native()[key])});
+  api.toString=()=>native().toString();
+  api.getRangeAt=i=>realm.wrapRange(native().getRangeAt(i));
+  const mutate=(name,args)=>{const result=native()[name](...args);changed();return result;};
+  for(const name of ['removeAllRanges','empty','collapseToStart','collapseToEnd','deleteFromDocument'])api[name]=()=>mutate(name,[]);
+  api.collapse=api.setPosition=(node,offset=0)=>mutate('collapse',[nodeOf(node),offset]);
+  api.extend=(node,offset=0)=>mutate('extend',[nodeOf(node),offset]);
+  api.setBaseAndExtent=(a,ao,f,fo)=>mutate('setBaseAndExtent',[nodeOf(a),ao,nodeOf(f),fo]);
+  api.selectAllChildren=node=>mutate('selectAllChildren',[nodeOf(node)]);
+  api.containsNode=(node,partial=false)=>native().containsNode(nodeOf(node),partial);
+  api.addRange=range=>mutate('addRange',[realm.unwrapRange(range)]);
+  api.removeRange=range=>mutate('removeRange',[realm.unwrapRange(range)]);
+  return api;
+}

package/lib/renderer/host.js

@@ -1,4 +1,5 @@
-import {writeClipboard} from '../clipboard.js';
+import { RENDER_INTERVAL_FLAG, renderMinInterval } from "./render-interval.js";
+import {writeClipboard, readClipboard} from '../clipboard.js';
 /**
  * Controller-side handle for a renderer process.
  *
@@ -16,6 +17,7 @@ import {writeClipboard} from '../clipboard.js';
 import {listenCompositor} from "./compositor-channel.js";
 import {RawFrames} from "../paint/raw-frames.js";
 import { PulseClient } from "../audio/pulse-client.js";
+import { SharedAudioConnection } from "../audio/shared-connection.js";
 import { logEnabled, pipeToLog, RENDERER_LOG_FLAG, writeLog } from "../log.js";
 import { NetworkService } from "../network/network-service.js";
 import { COMPOSITOR_FLAG, FULL_STYLE_FLAG, VERIFY_STYLE_FLAG } from "./flags.js";
@@ -33,14 +35,9 @@ const MAX_RESOURCE_BYTES = 32 * 1024 * 1024;
 // Audio output: one PulseAudio native-protocol connection (jspulse or a
 // PulseAudio daemon on 127.0.0.1:4713) shared by every renderer, opened on
 // first use. Renderers cannot open sockets, so their audio comes through here.
-let pulse = null;
-function pulseClient() {
-  pulse ??= PulseClient.connect().catch((error) => {
-    pulse = null;
-    throw new Error(`no PulseAudio server at 127.0.0.1:4713 (start jspulse): ${error.message}`);
-  });
-  return pulse;
-}
+const pulse = new SharedAudioConnection(() => PulseClient.connect().catch((error) => {
+  throw new Error(`no PulseAudio server at 127.0.0.1:4713 (start jspulse): ${error.message}`);
+}));
 const MAX_AUDIO_STREAMS = 8;
 const MAX_AUDIO_CHUNK = 4 * 1024 * 1024;
 
@@ -55,11 +52,13 @@ const LIFECYCLE_NAMES = new Set(["DOMContentLoaded", "load"]);
 const DEFAULT_ENTRY = Bun.fileURLToPath(new URL("./main.js", import.meta.url));
 
 export class RendererHost {
+  #clipboardRead = readClipboard;
   #clipboardWrite = writeClipboard;
   #clipboardUntil = 0;
   #clipboardPending = false;
   #rawFrames = null;
   #startEpoch = 0;
+  #closed = false;
   #rejectStartup = null;
   #entry;
   #args;
@@ -114,8 +113,10 @@ export class RendererHost {
     network = new NetworkService({ fetch: fetchImpl }), onFrame = null, onLifecycle = null,
     // A dedicated loopback socket works independently of the main thread on all platforms.
     compositor = entry === DEFAULT_ENTRY,
+    clipboardRead = readClipboard,
     clipboardWrite = writeClipboard,
   } = {}) {
+    this.#clipboardRead = clipboardRead;
     this.#clipboardWrite = clipboardWrite;
     this.#onFrame = onFrame;
     this.#onLifecycle = onLifecycle;
@@ -131,6 +132,7 @@ export class RendererHost {
 
   /** Starts the renderer if it is not running and waits until it is ready. */
   start() {
+    if (this.#closed) return Promise.reject(Error("Renderer is closed"));
     if (this.#ready) return this.#ready;
     let resolveReady;
     let rejectReady;
@@ -149,13 +151,20 @@ export class RendererHost {
         ()=>this.#closeChannel(channel));
       if (epoch !== this.#startEpoch) { channel?.transport.close(); throw Error('Renderer startup cancelled'); }
       this.#channel = channel;
+      // No inherited environment: nothing from the controller leaks in.
+      // Windows programs need SystemRoot to load system libraries.
+      let env = process.platform === "win32" && process.env.SystemRoot ? { SystemRoot: process.env.SystemRoot } : {};
+
+      // qml handle begin: applications need HOME/PATH/runtime paths, web pages do not
+      if (this.#args.includes("--buninu-qml-host")) env = { ...process.env };
+      // qml handle end
+
       const child = Bun.spawn({
         cmd: [process.execPath, this.#entry, ...this.#args,
+          RENDER_INTERVAL_FLAG + renderMinInterval(process.env.BUNINU_RENDER_MIN_INTERVAL),
           ...(logging ? [RENDERER_LOG_FLAG] : []), ...(compositor ? [COMPOSITOR_FLAG, `--compositor-endpoint=${JSON.stringify(channel.transport.endpoint)}`] : []),
           ...(process.env.BUNINU_VERIFY_STYLE ? [VERIFY_STYLE_FLAG] : []), ...(process.env.BUNINU_FULL_STYLE ? [FULL_STYLE_FLAG] : [])],
-        // No inherited environment: nothing from the controller leaks in.
-        // Windows programs need SystemRoot to load system libraries.
-        env: process.platform === "win32" && process.env.SystemRoot ? { SystemRoot: process.env.SystemRoot } : {},
+        env,
         // With BUNINU_LOG, output goes through the controller into the log file.
         stdio: ["ignore", logging ? "pipe" : "inherit", logging ? "pipe" : "inherit"],
         serialization: "advanced",
@@ -297,6 +306,7 @@ export class RendererHost {
   }
 
   close() {
+    this.#closed = true;
     this.#startEpoch++;
     this.#rejectStartup?.(Error("Renderer closed during startup")); this.#rejectStartup=null;
     this.#rawFrames?.close(); this.#rawFrames=null;
@@ -313,6 +323,7 @@ export class RendererHost {
   }
 
   async #call(method, params, timeout = this.#timeout) {
+    if (this.#closed) throw Error("Renderer is closed");
     if (!this.#child) await this.#restart();
     await this.start();
     const child = this.#child;
@@ -365,11 +376,23 @@ export class RendererHost {
         pending.reject(new Error(`renderer: ${String(message.error).split("\n")[0] || "unknown error"}`));
       }
       else pending.resolve(message.result);
-    } else if (message.type === 'clipboard-write' && Number.isInteger(message.id)) {
+    } else if (['clipboard-read','clipboard-read-input'].includes(message.type) && Number.isInteger(message.id)) {
+      const reply = (text, error) => {if(this.#child===child) child.send({type:'clipboard-result',id:message.id,text,error});};
+      let secure=false;
+      try {const url=new URL(this.#documentUrl); secure=url.protocol==='https:' || (url.protocol==='http:' && ['localhost','127.0.0.1','[::1]'].includes(url.hostname));} catch {}
+      if ((!secure && !message.type.endsWith('-input')) || Date.now()>this.#clipboardUntil || this.#clipboardPending) {
+        reply(undefined,'Clipboard read requires a recent user action in a secure document'); return;
+      }
+      this.#clipboardUntil=0; this.#clipboardPending=true;
+      Promise.resolve().then(()=>this.#clipboardRead()).then(text=>{
+        if(typeof text!=='string'||Buffer.byteLength(text)>1024*1024)throw Error('Clipboard text exceeds limit');
+        reply(text);
+      }).catch(()=>reply(undefined,'Unable to read system clipboard')).finally(()=>{this.#clipboardPending=false;});
+    } else if (['clipboard-write','clipboard-write-input'].includes(message.type) && Number.isInteger(message.id)) {
       const reply = error => { if(this.#child===child)child.send({type:'clipboard-result',id:message.id,...(error?{error}: {})}); };
       let secure=false;
       try { const url=new URL(this.#documentUrl); secure=url.protocol==='https:' || (url.protocol==='http:' && ['localhost','127.0.0.1','[::1]'].includes(url.hostname)); } catch {}
-      if (!secure || Date.now()>this.#clipboardUntil || this.#clipboardPending
+      if ((!secure && !message.type.endsWith('-input')) || Date.now()>this.#clipboardUntil || this.#clipboardPending
           || typeof message.text!=='string' || Buffer.byteLength(message.text)>1024*1024) {
         reply('Clipboard write requires a recent user action in a secure document'); return;
       }
@@ -518,20 +541,24 @@ export class RendererHost {
       return;
     }
     const entry = { child, stream: null, early: [] };
-    entry.opened = pulseClient()
-      .then((client) => client.openPlayback({
+    entry.opened = pulse.acquire(child)
+      .then((client) => {
+        if (this.#audio.get(id) !== entry) throw Error("Audio owner closed");
+        return client.openPlayback({
         rate, channels, name: String(name ?? "audio").slice(0, 200),
         leadSeconds: name === "piano" ? 0.12 : undefined,
         onRequest: (bytes) => send({ event: "request", bytes }),
         onTiming: name === "piano" ? null : (timing) => send({ event: "timing", ...timing }),
         onTimingError: (error) => send({ event: "timing-error", message: String(error?.message ?? error) }),
-      }))
+      });
+      })
       .then((stream) => {
         if (this.#audio.get(id) !== entry) return stream.close();
         entry.stream = stream;
         for (const data of entry.early.splice(0)) stream.write(data);
         send({ event: "ready" });
       }, (error) => {
+        if (this.#audio.get(id) !== entry) return;
         this.#audio.delete(id);
         send({ event: "error", message: String(error?.message ?? error) });
       });
@@ -539,6 +566,7 @@ export class RendererHost {
   }
 
   #closeAudio(child) {
+    pulse.release(child);
     for (const [id, entry] of this.#audio) {
       if (entry.child !== child) continue;
       this.#audio.delete(id);

package/lib/renderer/main.js

@@ -1,3 +1,4 @@
+import { RENDER_INTERVAL_FLAG, renderMinInterval } from "./render-interval.js";
 /**
  * Renderer process entry point.
  *
@@ -241,22 +242,27 @@ async function startScriptRewriter() {
 
 let nextClipboardId=1;
 const clipboardWrites=new Map();
-function clipboardWrite(text) {
+function clipboardRead() { return clipboardWrite(undefined, 'clipboard-read'); }
+function clipboardWrite(text, type = 'clipboard-write') {
   const id=nextClipboardId++;
   return new Promise((resolve,reject)=>{
     const timer=setTimeout(()=>{clipboardWrites.delete(id);reject(Error('Clipboard timed out'));},5000);
     clipboardWrites.set(id,{resolve,reject,timer});
-    process.send({type:'clipboard-write',id,text});
+    process.send({type,id,text});
   });
 }
 
 const renderer = await createPageRenderer({
+  renderMinInterval: renderMinInterval(process.argv.find(arg => arg.startsWith(RENDER_INTERVAL_FLAG))?.slice(RENDER_INTERVAL_FLAG.length)),
   fetchResource,
   rewriteScript,
   requestNavigation: (url, download = null, fragmentFrom = null, post = null) => process.send({ type: "navigate", url, download, fragmentFrom, post }),
   requestDownload: ({ url, name, data }) => process.send({ type: "download-data", url, name, data }),
   pageFetch,
+  clipboardRead,
   clipboardWrite,
+  clipboardReadInput:()=>clipboardWrite(undefined,'clipboard-read-input'),
+  clipboardWriteInput:text=>clipboardWrite(text,'clipboard-write-input'),
   webSockets,
   audio,
   setCookie: (value) => process.send({ type: "cookie", value }),
@@ -281,11 +287,20 @@ const renderer = await createPageRenderer({
   videoDecoder: wasmpeg,
 });
 await warmUp();
-const allowHostJs = process.argv.includes(DANGEROUSLY_ALLOW_HOST_JS);
+let allowHostJs = process.argv.includes(DANGEROUSLY_ALLOW_HOST_JS);
+let hostReason = `disabled by ${DANGEROUSLY_ALLOW_HOST_JS}`;
+
+// qml handle begin: controller-selected local QML application process
+if (process.argv.includes("--buninu-qml-host")) {
+  allowHostJs = true;
+  hostReason = "local QML application renderer";
+}
+// qml handle end
+
 const seccomp = allowHostJs
-  ? { installed: false, reason: `disabled by ${DANGEROUSLY_ALLOW_HOST_JS}` }
+  ? { installed: false, reason: hostReason }
   : installSeccomp();
-const ses = allowHostJs ? { installed: false, reason: `disabled by ${DANGEROUSLY_ALLOW_HOST_JS}` } : lockdownRealm();
+const ses = allowHostJs ? { installed: false, reason: hostReason } : lockdownRealm();
 renderer.setScripting(allowHostJs ? "host" : ses.installed ? "ses" : "off");
 
 /** Hardens the JavaScript realm so page scripts can run in SES compartments. */
@@ -340,7 +355,7 @@ process.on("message", async (message) => {
   if(message?.type==='clipboard-result') {
     const pending=clipboardWrites.get(message.id);if(!pending)return;
     clipboardWrites.delete(message.id);clearTimeout(pending.timer);
-    if(message.error)pending.reject(Error(String(message.error)));else pending.resolve();
+    if(message.error)pending.reject(Error(String(message.error)));else pending.resolve(message.text);
     return;
   }