buninu-browser 0.2.4 → 0.4.0

package/lib/renderer/compositor-channel.js

@@ -0,0 +1,103 @@
+// Private loopback transport, connected before renderer seccomp. No inherited
+// numeric descriptors: node:net also supports Windows sockets.
+import {createServer, createConnection} from 'node:net';
+import {randomBytes} from 'node:crypto';
+const MAX_JSON = 96 * 1024 * 1024;
+const MAX_PIXELS = 64 * 1024 * 1024;
+const MAX_QUEUE = 128 * 1024 * 1024;
+
+// Length-prefixed JSON followed by optional binary pixels. Copy once into an
+// owned packet so a raster lease may be released before the socket drains.
+export function encodePacket(message, pixels = null) {
+  const json = Buffer.from(JSON.stringify(message));
+  const size = pixels?.byteLength ?? 0;
+  if (json.length > MAX_JSON || size > MAX_PIXELS || json.length + size > MAX_QUEUE) throw Error('Compositor packet too large');
+  const packet = Buffer.allocUnsafe(8 + json.length + size);
+  packet.writeUInt32LE(json.length, 0); packet.writeUInt32LE(size, 4);
+  packet.set(json, 8); if (size) packet.set(pixels, 8 + json.length);
+  return packet;
+}
+
+export class PacketReader {
+  constructor(receive, limit = MAX_QUEUE) { this.receive = receive; this.limit = limit; this.header = Buffer.alloc(8); this.used = 0; this.packet = null; }
+  push(chunk) {
+    let offset = 0;
+    while (offset < chunk.length) {
+      const target = this.packet ?? this.header;
+      const count = Math.min(target.length - this.used, chunk.length - offset);
+      target.set(chunk.subarray(offset, offset + count), this.used);
+      this.used += count; offset += count;
+      if (this.used !== target.length) continue;
+      this.used = 0;
+      if (!this.packet) {
+        this.jsonLength = this.header.readUInt32LE(0);
+        const binaryLength = this.header.readUInt32LE(4);
+        const total = this.jsonLength + binaryLength;
+        if (!this.jsonLength || this.jsonLength > MAX_JSON || binaryLength > MAX_PIXELS || total > this.limit) throw Error('Invalid compositor packet size');
+        this.packet = Buffer.allocUnsafe(total);
+      } else {
+        const packet = this.packet; this.packet = null;
+        const message = JSON.parse(packet.subarray(0, this.jsonLength).toString());
+        const pixels = packet.subarray(this.jsonLength);
+        this.receive(message, pixels);
+      }
+    }
+  }
+}
+
+function attach(socket, receive, closed, limit) {
+  socket.setNoDelay(true);
+  const reader = new PacketReader(receive, limit);
+  socket.on('data', chunk => { try { reader.push(chunk); } catch { socket.destroy(); } });
+  socket.on('error', () => {});
+  socket.once('close', closed);
+  return {
+    reader,
+    send(message, pixels) {
+      if (socket.destroyed) throw Error('Compositor channel closed');
+      const packet = encodePacket(message, pixels);
+      if (socket.writableLength + packet.length > MAX_QUEUE) { socket.destroy(); throw Error('Compositor channel backpressure limit'); }
+      socket.write(packet);
+    },
+    close() { socket.destroy(); },
+  };
+}
+
+export async function listenCompositor(receive, closed) {
+  const token = randomBytes(32).toString('hex');
+  const sockets = new Set(); let peer = null, ended = false;
+  const server = createServer(socket => {
+    if (ended || peer || sockets.size >= 4) { socket.destroy(); return; }
+    sockets.add(socket);
+    const timer = setTimeout(() => socket.destroy(), 3000);
+    const candidate = attach(socket, (message, pixels) => {
+      if (!peer) {
+        if (pixels.length || message?.type !== 'hello' || message.token !== token) { socket.destroy(); return; }
+        peer = candidate; clearTimeout(timer); candidate.reader.limit = MAX_QUEUE;
+        for (const other of sockets) if (other !== socket) other.destroy();
+        server.close(); candidate.send({type:'accepted'});
+      } else if (peer === candidate) receive(message, pixels);
+    }, () => { clearTimeout(timer); sockets.delete(socket); if (peer === candidate && !ended) closed(); }, 4096);
+  });
+  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolve); });
+  return {
+    endpoint: {port:server.address().port, token},
+    send(message) { if (!peer || ended) throw Error('Compositor not connected'); peer.send(message); },
+    close() { ended = true; server.close(); for (const socket of sockets) socket.destroy(); },
+  };
+}
+
+export function connectCompositor(endpoint, receive, closed) {
+  return new Promise((resolve, reject) => {
+    const socket = createConnection({host:'127.0.0.1', port:endpoint.port});
+    let accepted = false;
+    const timer = setTimeout(() => socket.destroy(), 5000);
+    const peer = attach(socket, (message, pixels) => {
+      if (!accepted) {
+        if (message?.type !== 'accepted' || pixels.length) { socket.destroy(); return; }
+        accepted = true; clearTimeout(timer); resolve(peer);
+      } else receive(message, pixels);
+    }, () => { clearTimeout(timer); if (!accepted) reject(Error('Compositor connection failed')); else closed(); });
+    socket.once('connect', () => peer.send({type:'hello', token:endpoint.token}));
+  });
+}

package/lib/renderer/compositor.js

@@ -6,8 +6,8 @@
  * screenshots and scrolling on its own channel, so the page stays visible and
  * scrollable while the main thread works.
  *
- * Channel to the controller: fd 3, a socket shared with the controller,
- * newline-delimited JSON (it does not go through the main thread's IPC):
+ * Channel to the controller: authenticated loopback socket, with length-prefixed
+ * JSON and optional binary pixels (does not go through main-thread IPC):
  *   controller -> compositor  { id, method: "screenshot" | "scroll" | "scrollOffset", params }
  *                             (screenshot params: [{ format?: "png" | "jpeg" | "webp", quality? }])
  *   compositor -> controller  { id, result } | { id, error }
@@ -22,14 +22,13 @@
  * a fragment link, a key press or a new document.
  */
 import { ScrollViewport } from "../layout/scroll-viewport.js";
-import { cropViewport, encodeImage, encodeImageBase64 } from "../paint/frame.js";
+import { rawFrame, captureViewport, encodeImage, encodeImageBase64 } from "../paint/frame.js";
 import { FrameCaptureCache } from "../paint/frame-cache.js";
 import { FrameLeaseTracker } from "../paint/shared-frame-pool.js";
 import wasmpeg from "../../vendor/wasmpeg/src/js/index.js";
 import { VideoPresentation, compositeVideo } from "./video-presentation.js";
 
-const CHANNEL_FD = 3;
-const MAX_LINE_BYTES = 1024 * 1024;
+import {connectCompositor} from './compositor-channel.js';
 
 const viewport = new ScrollViewport(800, 600);
 let tile = null;
@@ -42,12 +41,18 @@ const video = new VideoPresentation(wasmpeg, () => {
   send({ type: "frame" });
 }, report => postMessage({ type: "video-report", ...report }));
 
-const channel = Bun.file(CHANNEL_FD).writer();
-
+let channel;
 function send(message) {
-  channel.write(`${JSON.stringify(message)}\n`);
-  channel.flush();
+  const result = message.result;
+  if (result?.pixels instanceof Uint8Array) {
+    const {pixels,...metadata} = result;
+    channel.send({...message,result:metadata},pixels);
+  } else channel.send(message);
 }
+const endpoint = await new Promise(resolve => {
+  self.onmessage = ({data}) => { if (data?.type === 'connect') resolve(data.endpoint); };
+});
+channel = await connectCompositor(endpoint, request => { void handleRequest(request); }, () => process.exit(1));
 
 self.onmessage = ({ data }) => {
   if (data?.type === "video-open") { void video.open(data); return; }
@@ -77,12 +82,19 @@ self.onmessage = ({ data }) => {
 };
 
 const methods = {
-  async screenshot({ format = "png", quality = 80, optimizeForSpeed = false } = {}) {
+  async screenshot({ format = "png", quality = 80, optimizeForSpeed = false, clip } = {}) {
     if (!tile) return "";
-    const key = `${frameSerial}:${viewport.x}:${viewport.y}:${format}:${quality}:${optimizeForSpeed}`;
+    if (format === 'rgba' || format === 'bgra') {
+      return frameLeases.capture(frame => {
+        const composited = frame.videoLayer?.id === video.config?.id ? compositeVideo(frame, video.frame) : frame;
+        const {pixels,width,height} = captureViewport(composited,viewport.x,viewport.y,viewport.width,viewport.height,clip);
+        return rawFrame(pixels,width,height,format);
+      });
+    }
+    const key = `${frameSerial}:${viewport.x}:${viewport.y}:${format}:${quality}:${optimizeForSpeed}:${JSON.stringify(clip)}`;
     return captures.get(key, () => frameLeases.capture(frame => {
       const composited = frame.videoLayer?.id === video.config?.id ? compositeVideo(frame, video.frame) : frame;
-      const { pixels, width, height } = cropViewport(composited, viewport.x, viewport.y, viewport.width, viewport.height);
+      const { pixels, width, height } = captureViewport(composited, viewport.x, viewport.y, viewport.width, viewport.height,clip);
       return encodeImageBase64(pixels, width, height, { format, quality, optimizeForSpeed });
     }));
   },
@@ -98,13 +110,7 @@ const methods = {
   },
 };
 
-async function handleLine(line) {
-  let request;
-  try {
-    request = JSON.parse(line);
-  } catch {
-    return;
-  }
+async function handleRequest(request) {
   if (request?.type === "audio-timing" && Number.isInteger(request.audioId)) {
     video.timing(request.audioId, request.seconds);
     return;
@@ -118,20 +124,6 @@ async function handleLine(line) {
   }
 }
 
-(async () => {
-  const decoder = new TextDecoder();
-  let pending = "";
-  for await (const chunk of Bun.file(CHANNEL_FD).stream()) {
-    pending += decoder.decode(chunk, { stream: true });
-    let newline;
-    while ((newline = pending.indexOf("\n")) >= 0) {
-      handleLine(pending.slice(0, newline));
-      pending = pending.slice(newline + 1);
-    }
-    if (pending.length > MAX_LINE_BYTES) pending = "";
-  }
-})();
-
 // Bun.Image initialises its codecs on first use; do that before the
 // renderer installs seccomp, which forbids opening files.
 await encodeImage(new Uint8Array(4), 1, 1);

package/lib/renderer/flags.js

@@ -1,7 +1,7 @@
 /** Command-line flags the controller passes to renderer processes. */
 import { CHROMIUM_VERSION } from "../user-agent.js";
 
-/** fd 3 is the controller's compositor channel; start the compositor Worker. */
+/** Start the compositor Worker with its pre-sandbox loopback channel. */
 export const COMPOSITOR_FLAG = "--compositor";
 
 /** BUNINU_VERIFY_STYLE: check every incremental restyle against a full one (development). */

package/lib/renderer/host.js

@@ -1,3 +1,4 @@
+import {writeClipboard, readClipboard} from '../clipboard.js';
 /**
  * Controller-side handle for a renderer process.
  *
@@ -9,10 +10,11 @@
  * Everything the renderer sends is treated as untrusted input.
  *
  * Besides IPC with the renderer's main thread, each renderer gets a second
- * channel (fd 3) to its compositor thread, which answers screenshots and
+ * authenticated loopback channel to its compositor thread, which answers screenshots and
  * scrolling even while the main thread is busy (see compositor.js).
  */
-import { closeSync } from "node:fs";
+import {listenCompositor} from "./compositor-channel.js";
+import {RawFrames} from "../paint/raw-frames.js";
 import { PulseClient } from "../audio/pulse-client.js";
 import { logEnabled, pipeToLog, RENDERER_LOG_FLAG, writeLog } from "../log.js";
 import { NetworkService } from "../network/network-service.js";
@@ -47,13 +49,20 @@ const MAX_WEB_SOCKETS = 64;
 const MAX_WEB_SOCKET_MESSAGE = 16 * 1024 * 1024;
 const COMPOSITOR_METHODS = new Set(["screenshot", "scroll", "scrollOffset"]);
 const COMPOSITOR_TIMEOUT = 10_000;
-const MAX_CHANNEL_LINE = 96 * 1024 * 1024;
 const LIFECYCLE_NAMES = new Set(["DOMContentLoaded", "load"]);
 
 // A file path, not a URL's pathname ("/C:/..." on Windows).
 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;
   #timeout;
@@ -105,11 +114,13 @@ export class RendererHost {
     entry = DEFAULT_ENTRY, args = [], timeout = 30_000, onRestart = null, onNavigate = null, onDownload = null,
     fetch: fetchImpl = fetch,
     network = new NetworkService({ fetch: fetchImpl }), onFrame = null, onLifecycle = null,
-    // The compositor's channel is an extra stdio pipe used as fd 3, which
-    // Windows does not have (Bun hands out libuv pipes there, not file
-    // descriptors): there the main thread answers screenshots and scrolling.
-    compositor = entry === DEFAULT_ENTRY && process.platform !== "win32",
+    // 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;
     this.#compositor = compositor;
@@ -124,6 +135,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;
@@ -131,47 +143,67 @@ export class RendererHost {
       resolveReady = resolve;
       rejectReady = reject;
     });
+    this.#rejectStartup = rejectReady;
     const logging = logEnabled();
     const compositor = this.#compositor;
-    const child = Bun.spawn({
-      cmd: [process.execPath, this.#entry, ...this.#args,
-        ...(logging ? [RENDERER_LOG_FLAG] : []), ...(compositor ? [COMPOSITOR_FLAG] : []),
-        ...(process.env.BUNINU_VERIFY_STYLE ? [VERIFY_STYLE_FLAG] : []), ...(process.env.BUNINU_FULL_STYLE ? [FULL_STYLE_FLAG] : [])],
+    const epoch = ++this.#startEpoch;
+    void (async () => {
+      const channel = compositor ? {pending:new Map(),nextId:1,closed:false,transport:null} : null;
+      if (channel) channel.transport = await listenCompositor(
+        (message,pixels)=>this.#handleCompositorMessage(channel,message,pixels),
+        ()=>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.
-      env: process.platform === "win32" && process.env.SystemRoot ? { SystemRoot: process.env.SystemRoot } : {},
-      // With BUNINU_LOG, output goes through the controller into the log file.
-      // fd 3 is a socket to the renderer's compositor thread.
-      stdio: ["ignore", logging ? "pipe" : "inherit", logging ? "pipe" : "inherit", ...(compositor ? ["pipe"] : [])],
-      serialization: "advanced",
-      ipc: (message) => {
-        if (message?.type === "ready") {
-          this.#sandbox = sanitizeSandboxReport(message.sandbox);
-          resolveReady();
-        }
-        else this.#handleMessage(child, message);
-      },
-      onExit: (_process, exitCode, signalCode) => {
-        this.#closeChannel(channel);
-        this.#closeSockets(child);
-        this.#closeAudio(child);
-        this.#closePageFetches(child);
-        if (this.#child !== child) return;
-        console.error(`buninu-browser: renderer ${child.pid} exited unexpectedly (${signalCode ?? `code ${exitCode}`})`);
-        this.#child = null;
-        this.#ready = null;
-        rejectReady(new Error("renderer exited during startup"));
-        for (const { reject } of this.#pending.values()) reject(new Error("renderer exited"));
-        this.#pending.clear();
-      },
-    });
-    this.#child = child;
-    const channel = compositor && Number.isInteger(child.stdio[3]) ? this.#openChannel(child.stdio[3]) : null;
-    this.#channel = channel;
-    if (logging) {
-      pipeToLog(child.stdout, `renderer ${child.pid}`, (chunk) => process.stdout.write(chunk));
-      pipeToLog(child.stderr, `renderer ${child.pid}`, (chunk) => process.stderr.write(chunk));
-    }
+      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,
+          ...(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] : [])],
+        env,
+        // With BUNINU_LOG, output goes through the controller into the log file.
+        stdio: ["ignore", logging ? "pipe" : "inherit", logging ? "pipe" : "inherit"],
+        serialization: "advanced",
+        ipc: (message) => {
+          if (message?.type === "ready") {
+            this.#sandbox = sanitizeSandboxReport(message.sandbox);
+            this.#rejectStartup=null;
+            clearTimeout(startupTimer);
+            resolveReady();
+          }
+          else this.#handleMessage(child, message);
+        },
+        onExit: (_process, exitCode, signalCode) => {
+          clearTimeout(startupTimer);
+          this.#closeChannel(channel);
+          this.#closeSockets(child);
+          this.#closeAudio(child);
+          this.#closePageFetches(child);
+          rejectReady(new Error("renderer exited during startup"));
+          if (this.#child !== child) return;
+          console.error(`buninu-browser: renderer ${child.pid} exited unexpectedly (${signalCode ?? `code ${exitCode}`})`);
+          this.#child = null;
+          this.#ready = null;
+          this.#rawFrames?.close(); this.#rawFrames=null;
+          for (const { reject } of this.#pending.values()) reject(new Error("renderer exited"));
+          this.#pending.clear();
+        },
+      });
+      this.#child = child;
+      const startupTimer = setTimeout(() => {
+        this.#closeChannel(channel); child.kill(9); rejectReady(Error('Renderer startup timed out'));
+      }, this.#timeout);
+      if (logging) {
+        pipeToLog(child.stdout, `renderer ${child.pid}`, (chunk) => process.stdout.write(chunk));
+        pipeToLog(child.stderr, `renderer ${child.pid}`, (chunk) => process.stderr.write(chunk));
+      }
+    })().catch(error=>{ if(epoch===this.#startEpoch){this.#closeChannel(this.#channel);this.#ready=null;} rejectReady(error); });
     return this.#ready;
   }
 
@@ -213,12 +245,13 @@ export class RendererHost {
    * waiting for the renderer's main thread or its call queue.
    */
   async composite(method, ...params) {
-    if (!this.#compositor || !COMPOSITOR_METHODS.has(method)) return this.call(method, ...params);
+    if (!this.#compositor || !COMPOSITOR_METHODS.has(method)) return this.#captureResult(method, await this.call(method, ...params), params);
     // A dead renderer is restarted (and its page restored) through the call path.
     if (!this.#child) await this.call("url");
     await this.start();
     const channel = this.#channel;
-    if (!channel) return this.call(method, ...params);
+    if (!channel) return this.#captureResult(method, await this.call(method, ...params), params);
+    const child = this.#child;
     const result = await new Promise((resolve, reject) => {
       const id = channel.nextId++;
       const timer = setTimeout(() => {
@@ -235,56 +268,25 @@ export class RendererHost {
           reject(error);
         },
       });
-      channel.writer.write(`${JSON.stringify({ id, method, params })}\n`);
-      channel.writer.flush();
+      try { channel.transport.send({id,method,params}); }
+      catch(error) { channel.pending.get(id).reject(error); channel.pending.delete(id); }
     });
-    const sanitized = sanitizeCompositorResult(method, result);
+    if (channel.closed || this.#child !== child) throw Error("Renderer closed during capture");
+    const sanitized = this.#captureResult(method, result, params);
     if (method === "scroll") this.#pendingScroll = sanitized;
     return sanitized;
   }
 
-  #openChannel(fd) {
-    const channel = { writer: Bun.file(fd).writer(), pending: new Map(), nextId: 1, closed: false };
-    (async () => {
-      const decoder = new TextDecoder();
-      let buffer = "";
-      try {
-        for await (const chunk of Bun.file(fd).stream()) {
-          buffer += decoder.decode(chunk, { stream: true });
-          let newline;
-          while ((newline = buffer.indexOf("\n")) >= 0) {
-            this.#handleCompositorLine(channel, buffer.slice(0, newline));
-            buffer = buffer.slice(newline + 1);
-          }
-          if (buffer.length > MAX_CHANNEL_LINE) buffer = "";
-        }
-      } catch {
-        // The renderer went away.
-      }
-      this.#closeChannel(channel);
-      // Close everything that refers to the socket once, after end of
-      // stream, so no descriptor number can have been reused meanwhile.
-      try {
-        channel.writer.end();
-      } catch {
-        // Already closed.
-      }
-      try {
-        closeSync(fd);
-      } catch {
-        // Already closed.
-      }
-    })();
-    return channel;
+  #captureResult(method,result,params) {
+    if (method === 'screenshot' && ['rgba','bgra'].includes(params[0]?.format)) {
+      if (result?.format !== params[0].format) throw Error('Raw screenshot format mismatch');
+      this.#rawFrames ??= new RawFrames();
+      return this.#rawFrames.write(result.pixels,result.width,result.height,result.format);
+    }
+    return sanitizeCompositorResult(method,result);
   }
 
-  #handleCompositorLine(channel, line) {
-    let message;
-    try {
-      message = JSON.parse(line);
-    } catch {
-      return;
-    }
+  #handleCompositorMessage(channel, message, pixels) {
     if (channel.closed || typeof message !== "object" || message === null) return;
     if (message.type === "frame") {
       if (this.#channel === channel) this.#onFrame?.();
@@ -292,19 +294,24 @@ export class RendererHost {
       const pending = channel.pending.get(message.id);
       channel.pending.delete(message.id);
       if (Object.hasOwn(message, "error")) pending.reject(new Error(`compositor: ${String(message.error).slice(0, 200)}`));
-      else pending.resolve(message.result);
+      else pending.resolve(pixels.length ? {...message.result,pixels} : message.result);
     }
   }
 
   #closeChannel(channel) {
     if (!channel || channel.closed) return;
     channel.closed = true;
+    channel.transport?.close();
     for (const { reject } of channel.pending.values()) reject(new Error("compositor closed"));
     channel.pending.clear();
     if (this.#channel === channel) this.#channel = null;
   }
 
   close() {
+    this.#closed = true;
+    this.#startEpoch++;
+    this.#rejectStartup?.(Error("Renderer closed during startup")); this.#rejectStartup=null;
+    this.#rawFrames?.close(); this.#rawFrames=null;
     this.#closeChannel(this.#channel);
     const child = this.#child;
     this.#closeSockets(child);
@@ -312,13 +319,18 @@ export class RendererHost {
     this.#closePageFetches(child);
     this.#child = null;
     this.#ready = null;
+    for (const {reject} of this.#pending.values()) reject(Error("Renderer closed"));
+    this.#pending.clear();
     child?.kill();
   }
 
   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;
+    if (method === 'click' || method === 'press') this.#clipboardUntil = Date.now()+5000;
+    if (method === 'loadDocument') this.#clipboardUntil = 0;
     const id = this.#nextId++;
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
@@ -327,6 +339,7 @@ export class RendererHost {
         this.#child = null;
         this.#ready = null;
         console.error(`buninu-browser: renderer ${child.pid} missed the ${timeout}ms deadline for ${method}; killing it`);
+        this.#rawFrames?.close(); this.#rawFrames=null;
         child.kill(9);
         reject(new Error(`renderer ${method} timed out after ${timeout}ms`));
       }, timeout);
@@ -365,6 +378,30 @@ export class RendererHost {
         pending.reject(new Error(`renderer: ${String(message.error).split("\n")[0] || "unknown error"}`));
       }
       else pending.resolve(message.result);
+    } 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 && !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;
+      }
+      this.#clipboardUntil=0; this.#clipboardPending=true;
+      Promise.resolve().then(()=>this.#clipboardWrite(message.text))
+        .then(()=>reply(),()=>reply('Unable to write system clipboard'))
+        .finally(()=>{this.#clipboardPending=false;});
     } else if (message.type === "fetch" && Number.isInteger(message.id)) {
       this.#fetchForRenderer(child, message);
     } else if (message.type === "page-fetch" && Number.isInteger(message.id)) {
@@ -495,8 +532,7 @@ export class RendererHost {
         child.send({ type: "audio-event", id, ...payload });
         // The compositor's A/V clock must not wait behind page JavaScript.
         if (payload.event === "timing" && this.#channel && !this.#channel.closed) {
-          this.#channel.writer.write(`${JSON.stringify({ type: "audio-timing", audioId: id, seconds: payload.seconds })}\n`);
-          this.#channel.writer.flush();
+          this.#channel.transport.send({type:"audio-timing",audioId:id,seconds:payload.seconds});
         }
       }
     };

package/lib/renderer/main.js

@@ -28,7 +28,7 @@
  *                           closed with sentBytes: the PCM that reached the output before audio-close)
  *
  * With --compositor, a compositor Worker (compositor.js) answers screenshots
- * and scrolling on fd 3 while this thread is busy; frames go to it with
+ * and scrolling on a dedicated socket while this thread is busy; frames go to it with
  * postMessage.
  *
  * Startup order matters for the sandbox:
@@ -172,6 +172,8 @@ function compositorCaughtUp() {
 
 async function startCompositor() {
   const worker = new Worker(new URL("./compositor.js", import.meta.url).href);
+  const endpoint = JSON.parse(process.argv.find(arg=>arg.startsWith('--compositor-endpoint=')).slice('--compositor-endpoint='.length));
+  worker.postMessage({type:'connect',endpoint});
   await new Promise((resolve, reject) => {
     worker.addEventListener("message", resolve, { once: true });
     worker.addEventListener("error", reject, { once: true });
@@ -237,12 +239,28 @@ async function startScriptRewriter() {
   });
 }
 
+let nextClipboardId=1;
+const clipboardWrites=new Map();
+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,id,text});
+  });
+}
+
 const renderer = await createPageRenderer({
   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 }),
@@ -267,11 +285,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. */
@@ -323,6 +350,13 @@ async function warmUp() {
 }
 
 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(message.text);
+    return;
+  }
+
   if (message?.type === "page-fetch-head") {
     const pending = pendingFetches.get(message.id);
     if (!pending?.page || pending.head) return;