buninu-browser 0.5.1 → 0.7.0

package/lib/headless-shell.js

@@ -90,7 +90,7 @@ export async function runHeadlessShell(args = Bun.argv.slice(2)) {
  * 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,
+  allowHostJs = false, spareRenderer = true, network = new NetworkService(), rendererTimeout = 0, mobile = false,
   waitForRenderer = true, webkit = true,
   clipboard = null,
 } = {}) {
@@ -105,6 +105,7 @@ export async function createBrowser({
   let current = null;
   let currentKey = null;
   let spare = null;
+  let sparePreparation = null;
   let closed = false;
   // Settles when the first renderer shows about:blank (assigned below).
   let rendererReady = null;
@@ -195,8 +196,8 @@ export async function createBrowser({
         if (host !== current) return;
         void download({ url, body: data, attributeName: name, totalBytes: data.byteLength });
       },
-      onFrame: () => {
-        if (host === current) notify(frameListeners);
+      onFrame: (frame) => {
+        if (host === current) notify(frameListeners, frame);
       },
       onLifecycle: (name, generation) => {
         let generations = lifecycleSeen.get(host);
@@ -207,7 +208,11 @@ export async function createBrowser({
         generations.set(generation, names);
         if (names.has(name)) return;
         names.add(name);
-        if (committed.host === host && committed.generation === generation) notify(lifecycleListeners, name);
+        if (committed.host === host && committed.generation === generation) {
+          if (name === "load" && sparePreparation?.host === host && sparePreparation.generation === generation)
+            armSparePreparation(sparePreparation, 1_000);
+          notify(lifecycleListeners, name);
+        }
       },
     });
     return host;
@@ -232,12 +237,45 @@ export async function createBrowser({
 
   function prepareSpare() {
     if (!spareRenderer || closed || spare) return;
-    spare = createHost();
-    spare.start().catch(() => {
-      spare = null;
+    const preparing = createHost();
+    spare = preparing;
+    preparing.start().catch(() => {
+      // An acquired spare may fail after its successor has been scheduled.
+      // Only this host owns its slot; never clear a newer spare's reference.
+      if (spare === preparing) {
+        spare = null;
+        preparing.close();
+      }
     });
   }
 
+  function cancelSparePreparation() {
+    if (sparePreparation) clearTimeout(sparePreparation.timer);
+    sparePreparation = null;
+  }
+
+  function armSparePreparation(request, delay) {
+    clearTimeout(request.timer);
+    request.timer = setTimeout(() => {
+      if (sparePreparation !== request) return;
+      sparePreparation = null;
+      if (current === request.host && committed.host === request.host
+        && committed.generation === request.generation) prepareSpare();
+    }, delay);
+    request.timer.unref?.();
+  }
+
+  function scheduleSparePreparation(host, generation) {
+    cancelSparePreparation();
+    if (!spareRenderer || closed || spare || host !== current) return;
+    const request = { host, generation, timer: null };
+    sparePreparation = request;
+    // Delay after load, rather than competing with the new page's initial
+    // scripts/layout. This is not CPU-idle detection. A bounded fallback
+    // still warms a spare for pages whose load event never arrives.
+    armSparePreparation(request, reachedLifecycle(host, generation).has("load") ? 1_000 : 30_000);
+  }
+
   /** The renderer for a URL's origin, swapping processes on an origin change. */
   async function rendererFor(url) {
     let key = originKey(url);
@@ -264,7 +302,6 @@ export async function createBrowser({
     current = next;
     currentKey = key;
     previous?.close();
-    prepareSpare();
     return current;
   }
 
@@ -345,12 +382,14 @@ export async function createBrowser({
     selectRenderer = url => rendererFor(url, { qmlHost });
     // qml handle end
 
+    cancelSparePreparation();
     const host = invoke ? current : await selectRenderer(document.url);
     let generation;
     try {
       generation = await (invoke ?? ((method, ...params) => host.call(method, ...params)))("loadDocument", document);
     } finally { documentReady.get(host)?.resolve(); }
     committed = { host, generation };
+    scheduleSparePreparation(host, generation);
     for (const name of reachedLifecycle(host, generation)) notify(lifecycleListeners, name);
     writeLog("navigation", `${document.url}: first paint in ${Math.round(performance.now() - fetched)}ms`);
   }
@@ -502,7 +541,7 @@ export async function createBrowser({
     press: (key, options) => call("press", key, options),
     type: (text) => call("type", text),
     scrollOffset: () => composite("scrollOffset"),
-    /** Calls `listener()` whenever what the viewport shows changes; returns an unsubscribe function. */
+    /** Calls `listener(frame?)` when the viewport changes, with its measured scroll offset when available. */
     onFrame(listener) {
       frameListeners.add(listener);
       return () => frameListeners.delete(listener);
@@ -573,6 +612,7 @@ export async function createBrowser({
     },
     close() {
       closed = true;
+      cancelSparePreparation();
       current?.close();
       spare?.close();
       current = null;

package/lib/layout/repaint.js

@@ -0,0 +1,89 @@
+import { sameLayoutInput } from "../render-tree/index.js";
+
+// These properties change raster output, not box/text metrics. Inline
+// decoration boxes still need the guard below. Keep this list small.
+const PAINT_PROPERTIES = new Set([
+  "opacity", "backgroundColor",
+  "backgroundSize", "backgroundPosition", "backgroundRepeat", "backgroundOrigin", "backgroundClip",
+  "transformOrigin",
+]);
+
+/** Retain immutable geometry when paint changes preserve layout records. */
+export function repaintLayout(layout, previous, next) {
+  if (!sameLayoutInput(previous.root, next.root, { ignoreStyles: true })) return null;
+  const changes = new Map();
+  const styles = new Map();
+  for (const [id, node] of next.nodesById) {
+    const before = previous.nodesById.get(id)?.style, after = node.style;
+    // Anonymous fragments have no node ID and must be restyled by their old
+    // style identity. If that identity split into different new styles, only
+    // layout can determine which fragment belongs to which new owner.
+    if (styles.has(before) && !Bun.deepEquals(styles.get(before), after)) return null;
+    if (before === after) {
+      styles.set(before, before);
+      continue;
+    }
+    if (!before || !after) return null;
+    const paint = {};
+    for (const key of new Set([...Object.keys(before), ...Object.keys(after)])) {
+      if (Bun.deepEquals(before[key], after[key])) continue;
+      if (key === "transform") {
+        // Translation is currently baked into layout coordinates. Only scale
+        // changes within an existing transform can reuse those coordinates.
+        const a = before[key], b = after[key];
+        if (!a || !b || !Bun.deepEquals(a.x, b.x) || !Bun.deepEquals(a.y, b.y)
+          || Object.keys(a).some(k => !["x", "y", "scaleX", "scaleY"].includes(k))
+          || Object.keys(b).some(k => !["x", "y", "scaleX", "scaleY"].includes(k))) return null;
+      } else if (!PAINT_PROPERTIES.has(key)) return null;
+      paint[key] = after[key];
+    }
+    if (Object.keys(paint).length) {
+      // Layout only emits inline/replaced decoration boxes when a background
+      // or border is present. Adding/removing one requires those boxes to be
+      // regenerated, even though the text/image metrics have not changed.
+      if ((node.type === "inline" || node.type === "image")
+        && hasDecoration(before) !== hasDecoration(after)) return null;
+      changes.set(id, paint);
+      styles.set(before, after);
+    } else styles.set(before, before);
+  }
+  const restyle = record => {
+    const paint = changes.get(record.nodeId);
+    let style = styles.get(record.style);
+    // Some layout records contain resolved/adjusted styles (e.g. tables).
+    // Preserve all of those metrics instead of replacing the complete style.
+    if (!style && paint && record.style) {
+      style = Object.freeze({ ...record.style, ...paint });
+      styles.set(record.style, style);
+    }
+    // Boxes, runs and anonymous line fragments can share one computed style.
+    // Keep that identity: background-clip:text finds its gradient by style.
+    return style && style !== record.style ? Object.freeze({ ...record, style }) : record;
+  };
+  return Object.freeze({ ...layout, generation: next.generation,
+    boxes: mapChanged(layout.boxes, restyle),
+    fragments: mapChanged(layout.fragments, fragment => {
+      const updated = restyle(fragment);
+      const runs = fragment.runs && mapChanged(fragment.runs, restyle);
+      return runs === fragment.runs ? updated : Object.freeze({ ...updated, runs });
+    }),
+  });
+}
+
+// Keep in sync with the inline decoration predicate in text-layout.js.
+function hasDecoration(style) {
+  return Boolean((style.backgroundColor && style.backgroundColor !== "rgba(0, 0, 0, 0)")
+    || style.backgroundImage || style.borderWidths?.some(width => width > 0));
+}
+
+/** Copy immutable arrays only when a record actually changed. */
+function mapChanged(records, update) {
+  let changed = null;
+  for (let index = 0; index < records.length; index++) {
+    const record = records[index], next = update(record);
+    if (next === record) continue;
+    changed ??= records.slice();
+    changed[index] = next;
+  }
+  return changed ? Object.freeze(changed) : records;
+}

package/lib/media/mp4-keyframes.js

@@ -0,0 +1,144 @@
+// Fragmented MP4 sync-sample decode times are seek candidates, not decoded
+// presentation timestamps. The caller must verify them against its decoder.
+// Unsupported layouts return null and retain the ordinary seek search.
+const cache = new WeakMap();
+const MAX_BOXES = 32768, MAX_SAMPLES = 250000, MAX_KEYS = 16384;
+
+export function mp4KeyframeBefore(bytes, seconds) {
+  if (!(bytes instanceof Uint8Array) || !Number.isFinite(seconds)) return null;
+  let index = cache.get(bytes);
+  if (index === undefined) {
+    try { index = inspect(bytes); } catch { index = null; }
+    cache.set(bytes, index);
+  }
+  if (!index?.length) return null;
+  let low = 0, high = index.length;
+  while (low < high) {
+    const mid = (low + high) >>> 1;
+    if (index[mid] <= seconds) low = mid + 1;
+    else high = mid;
+  }
+  return low ? index[low - 1] : null;
+}
+
+function inspect(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let boxesSeen = 0, samplesSeen = 0;
+  const u32 = (at, end) => {
+    if (at < 0 || at + 4 > end) throw Error('short MP4 field');
+    return view.getUint32(at);
+  };
+  const u64 = (at, end) => {
+    const value = u32(at, end) * 0x100000000 + u32(at + 4, end);
+    if (!Number.isSafeInteger(value)) throw Error('large MP4 timestamp');
+    return value;
+  };
+  const boxes = (from, end) => {
+    const result = [];
+    for (let at = from; at < end;) {
+      if (++boxesSeen > MAX_BOXES) throw Error('too many MP4 boxes');
+      let size = u32(at, end), header = 8;
+      const type = String.fromCharCode(...bytes.subarray(at + 4, at + 8));
+      if (at + header > end) throw Error('short MP4 box');
+      if (size === 1) { size = u64(at + 8, end); header = 16; }
+      else if (size === 0) size = end - at;
+      if (size < header || size > end - at) throw Error('invalid MP4 box size');
+      result.push({ type, data: at + header, end: at + size });
+      at += size;
+    }
+    return result;
+  };
+  const children = box => boxes(box.data, box.end);
+  const one = (list, type) => {
+    const matches = list.filter(box => box.type === type);
+    if (matches.length !== 1) throw Error(`missing/duplicate ${type}`);
+    return matches[0];
+  };
+  const version = box => {
+    u32(box.data, box.end);
+    if (bytes[box.data] > 1) throw Error('unknown MP4 version');
+    return bytes[box.data];
+  };
+  const flags = box => u32(box.data, box.end) & 0xffffff;
+  const top = boxes(0, bytes.length), movie = children(one(top, 'moov'));
+  const defaults = new Map();
+  for (const box of children(one(movie, 'mvex'))) if (box.type === 'trex') {
+    if (version(box) !== 0 || defaults.size >= 32) return null;
+    const id = u32(box.data + 4, box.end);
+    if (defaults.has(id) || u32(box.data + 8, box.end) !== 1) return null;
+    defaults.set(id, { duration: u32(box.data + 12, box.end), flags: u32(box.data + 20, box.end) });
+  }
+  let track = null;
+  for (const box of movie) if (box.type === 'trak') {
+    const nodes = children(box), media = children(one(nodes, 'mdia'));
+    const handler = one(media, 'hdlr');
+    if (u32(handler.data + 8, handler.end) !== 0x76696465) continue; // vide
+    if (track) return null;
+    const edits = nodes.filter(box => box.type === 'edts');
+    if (edits.length > 1) return null;
+    if (edits.length) {
+      const edit = one(children(edits[0]), 'elst'), wide = version(edit) === 1;
+      if (u32(edit.data + 4, edit.end) !== 1) return null;
+      const mediaTimeAt = edit.data + (wide ? 16 : 12), rateAt = edit.data + (wide ? 24 : 16);
+      if (u32(mediaTimeAt, edit.end) & 0x80000000 || u32(rateAt, edit.end) !== 0x00010000) return null;
+      // Only a single forward unit-rate edit is considered. Its offset is
+      // deliberately not presented as a decoder timestamp: seek boundary
+      // verification must still succeed before this candidate can be used.
+    }
+    const header = one(nodes, 'tkhd'), timing = one(media, 'mdhd');
+    const id = u32(header.data + (version(header) ? 20 : 12), header.end);
+    const timescale = u32(timing.data + (version(timing) ? 20 : 12), timing.end);
+    if (!timescale || !defaults.has(id)) return null;
+    track = { id, timescale, ...defaults.get(id) };
+  }
+  if (!track) return null;
+  const keys = [];
+  let lastDecodeTime = -1;
+  for (const moof of top) if (moof.type === 'moof') {
+    for (const traf of children(moof)) if (traf.type === 'traf') {
+      const nodes = children(traf), header = one(nodes, 'tfhd');
+      if (u32(header.data + 4, header.end) !== track.id) continue;
+      if (version(header) !== 0 || nodes.some(box => box.type === 'sbgp' || box.type === 'sgpd')) return null;
+      const hf = flags(header);
+      if (hf & ~0x02003b) return null;
+      let cursor = header.data + 8, duration = track.duration, sampleFlags = track.flags;
+      if (hf & 1) cursor += 8;
+      if (hf & 2) { if (u32(cursor, header.end) !== 1) return null; cursor += 4; }
+      if (hf & 8) { duration = u32(cursor, header.end); cursor += 4; }
+      if (hf & 16) cursor += 4;
+      if (hf & 32) { sampleFlags = u32(cursor, header.end); cursor += 4; }
+      if (cursor > header.end) return null;
+      const timing = one(nodes, 'tfdt');
+      let time = version(timing) ? u64(timing.data + 4, timing.end) : u32(timing.data + 4, timing.end);
+      for (const run of nodes) if (run.type === 'trun') {
+        version(run);
+        const rf = flags(run), count = u32(run.data + 4, run.end);
+        if (rf & ~0xf05 || (rf & 4) && (rf & 0x400)) return null;
+        samplesSeen += count;
+        if (samplesSeen > MAX_SAMPLES) return null;
+        cursor = run.data + 8;
+        if (rf & 1) cursor += 4;
+        let firstFlags = sampleFlags;
+        if (rf & 4) { firstFlags = u32(cursor, run.end); cursor += 4; }
+        for (let i = 0; i < count; i++) {
+          let step = duration, sf = i === 0 ? firstFlags : sampleFlags;
+          if (rf & 0x100) { step = u32(cursor, run.end); cursor += 4; }
+          if (rf & 0x200) cursor += 4;
+          if (rf & 0x400) { sf = u32(cursor, run.end); cursor += 4; }
+          if (rf & 0x800) cursor += 4; // composition offset does not change decode time
+          if (cursor > run.end || !step || time < lastDecodeTime) return null;
+          const depends = (sf >>> 24) & 3;
+          if (depends === 3) return null;
+          if (!(sf & 0x10000) && depends !== 1) {
+            if (keys.length >= MAX_KEYS) return null;
+            keys.push(time / track.timescale);
+          }
+          lastDecodeTime = time;
+          time += step;
+          if (!Number.isSafeInteger(time)) return null;
+        }
+      }
+    }
+  }
+  return keys;
+}

package/lib/media/video-keyframe.js

@@ -1,20 +1,48 @@
 // wasmpeg seeks to a keyframe without returning its timestamp. Locate it by
 // comparing tiny decoded probes, then rewind before delivering full frames.
-export function seekVideoKeyframe(decoder, seconds, startTime = 0) {
+import { mp4KeyframeBefore } from './mp4-keyframes.js';
+
+export function seekVideoKeyframe(decoder, seconds, startTime = 0, bytes = null) {
   const start = Math.max(0, startTime);
   seconds = Math.max(start, seconds);
   const seek = time => decoder.seek(Math.max(1, time * 1000));
   const frame = 1 / (decoder.fps || 30);
   if (!(seconds >= start + frame)) { seek(start); return start; }
+  let lastPixels = null;
   const probe = time => {
     seek(time);
     const pixels = decoder.nextFrame(32, 18);
+    lastPixels = pixels;
     if (!pixels) return null;
     let hash = 0x811c9dc5;
     for (let i = 0; i < pixels.length; i += 3) hash = Math.imul(hash ^ pixels[i], 0x01000193);
     return hash >>> 0;
   };
   const target = probe(seconds);
+  const candidate = bytes && mp4KeyframeBefore(bytes, seconds);
+  if (target !== null && candidate !== null && candidate >= start && frame >= 0.001) {
+    // A container index narrows the search; it cannot establish what a
+    // decoder actually returned. Require the same complete tiny picture at
+    // the candidate and a different one just before its seek boundary.
+    // This preserves the existing decode-time convention, not guessed PTS.
+    const targetPixels = lastPixels.slice();
+    const samePicture = () => lastPixels?.length === targetPixels.length
+      && targetPixels.every((byte, i) => byte === lastPixels[i]);
+    // The decoder's seek API rounds to integer milliseconds; do not round
+    // a fractional keyframe time down into the preceding GOP.
+    const candidateSeek = Math.ceil(candidate * 1000) / 1000;
+    try {
+      probe(candidateSeek);
+      if (samePicture()) {
+        const atStart = candidate === start;
+        if (!atStart) probe(Math.max(start, candidate - frame));
+        if (atStart || (lastPixels && !samePicture())) { seek(candidateSeek); return candidate; }
+      }
+    } catch {
+      // An optional index hint must not turn a working decoder search into
+      // an open failure. Errors from the original search still propagate.
+    }
+  }
   let keyframe = seconds;
   if (target !== null) {
     let distance = 10;