buninu-browser 0.5.0 → 0.6.0

package/lib/renderer/font-loading.js

@@ -3,6 +3,7 @@
 // every document and iframe.
 const encoder = new TextEncoder();
 const MAX_FONT_BYTES = 32 * 1024 * 1024;
+const MAX_RANKED_FONT_CHOICES = 128;
 
 export function registerTypeface(CanvasKit, provider, typeface, family) {
   const bytes = encoder.encode(`${family}\0`);
@@ -37,7 +38,13 @@ function weightRank(face, wanted) {
 }
 
 function covers(face, point) {
-  return (face.unicodeRanges ?? [[0, 0x10ffff]]).some(([from, to]) => from <= point && point <= to);
+  const ranges = face.unicodeRanges;
+  if (!ranges) return 0 <= point && point <= 0x10ffff;
+  for (let index = 0; index < ranges.length; index++) {
+    const range = ranges[index];
+    if (range[0] <= point && point <= range[1]) return true;
+  }
+  return false;
 }
 
 function stretchRank(face, wanted) {
@@ -61,20 +68,37 @@ export function neededFontFaces(faces, textRuns, availableFamilies = new Set())
     if (!families.has(key)) families.set(key, []);
     families.get(key).push(face);
   }
+  return neededFacesFromIndex(families, new Map(), textRuns, availableFamilies);
+}
+
+function orderedFontFaces(families, choices, name, weight, style, stretch) {
+  const definitions = families.get(name);
+  if (!definitions) return null;
+  const key = JSON.stringify([name, weight, style, stretch]);
+  let ordered = choices.get(key);
+  if (!ordered) {
+    // Ranking is independent of Unicode coverage; stable sorting preserves
+    // the CSS face order even when a character filters out other subsets.
+    ordered = ranked(definitions, weight, style, stretch);
+    if (choices.size >= MAX_RANKED_FONT_CHOICES) choices.clear();
+    choices.set(key, ordered);
+  }
+  return ordered;
+}
+
+function neededFacesFromIndex(families, choices, textRuns, availableFamilies) {
   const needed = new Set();
-  const choices = new Map();
   for (const { text, style } of textRuns) {
     if (!text || !style) continue;
     const points = new Set([...text].map(character => character.codePointAt(0)));
     for (const family of style.fontFamily ?? []) {
-      const definitions = families.get(family.toLowerCase());
-      if (!definitions) {
-        if (availableFamilies.has(family.toLowerCase())) break;
+      const name = family.toLowerCase();
+      const ordered = orderedFontFaces(families, choices, name,
+        style.fontWeight ?? 400, style.fontStyle ?? "normal", style.fontStretch ?? 100);
+      if (!ordered) {
+        if (availableFamilies.has(name)) break;
         continue;
       }
-      const key = `${family.toLowerCase()}\n${style.fontWeight ?? 400}/${style.fontStyle ?? "normal"}/${style.fontStretch ?? 100}`;
-      let ordered = choices.get(key);
-      if (!ordered) choices.set(key, ordered = ranked(definitions, style.fontWeight ?? 400, style.fontStyle ?? "normal", style.fontStretch ?? 100));
       for (const point of points) {
         const face = ordered.find(face => covers(face, point));
         if (face) { needed.add(face); points.delete(point); }
@@ -94,7 +118,9 @@ export class DocumentFonts {
   #error;
   #provider = null;
   #collection = null;
-  #faces = [];
+  #families = new Map();
+  #faceKeys = new WeakMap();
+  #rankedFaces = new Map();
   #records = new Map();
   #sources = new Map();
   #pending = new Set();
@@ -119,7 +145,16 @@ export class DocumentFonts {
   get hasUnicodeRanges() { return this.#hasUnicodeRanges; }
 
   setFaces(faces) {
-    this.#faces = faces;
+    this.#families.clear();
+    this.#faceKeys = new WeakMap();
+    this.#rankedFaces.clear();
+    for (const face of faces) {
+      const family = face.family.toLowerCase();
+      let definitions = this.#families.get(family);
+      if (!definitions) this.#families.set(family, definitions = []);
+      definitions.push(face);
+      this.#faceKeys.set(face, JSON.stringify(face));
+    }
     this.#hasUnicodeRanges = faces.some(face => face.unicodeRanges?.length
       && !(face.unicodeRanges.length === 1 && face.unicodeRanges[0][0] === 0 && face.unicodeRanges[0][1] === 0x10ffff));
   }
@@ -127,8 +162,8 @@ export class DocumentFonts {
   update(faces, textRuns) {
     if (this.#closed) return;
     this.setFaces(faces);
-    for (const face of neededFontFaces(faces, textRuns, this.#availableFamilies)) {
-      const key = JSON.stringify(face);
+    for (const face of neededFacesFromIndex(this.#families, this.#rankedFaces, textRuns, this.#availableFamilies)) {
+      const key = this.#faceKeys.get(face);
       if (this.#records.has(key)) continue;
       const record = { face, alias: null };
       this.#records.set(key, record);
@@ -141,9 +176,16 @@ export class DocumentFonts {
 
   /** Available faces in CSS fallback order; unicode-subset files share a family. */
   resolve(family, weight = 400, style = "normal", point = null, stretch = 100) {
-    const definitions = this.#faces.filter(face => face.family.toLowerCase() === family.toLowerCase()
-      && (point === null || covers(face, point)));
-    return ranked(definitions, weight, style, stretch).map(face => this.#records.get(JSON.stringify(face))?.alias).filter(Boolean);
+    const ordered = orderedFontFaces(this.#families, this.#rankedFaces, family.toLowerCase(), weight, style, stretch);
+    if (!ordered) return [];
+    const aliases = [];
+    for (const face of ordered) {
+      if (point !== null && !covers(face, point)) continue;
+      // Read the live record: a face may finish loading after it was ranked.
+      const alias = this.#records.get(this.#faceKeys.get(face))?.alias;
+      if (alias) aliases.push(alias);
+    }
+    return aliases;
   }
 
   async ready() {
@@ -222,6 +264,8 @@ export class DocumentFonts {
     for (const source of this.#sources.values()) source.then(typeface => typeface?.delete(), () => {});
     this.#sources.clear();
     this.#records.clear();
-    this.#faces = [];
+    this.#families.clear();
+    this.#faceKeys = new WeakMap();
+    this.#rankedFaces.clear();
   }
 }

package/lib/renderer/host.js

@@ -70,6 +70,8 @@ export class RendererHost {
   // The document this host asked its renderer to load: the trusted origin
   // for everything the renderer requests.
   #documentUrl = "about:blank";
+  #cookieSequence = 0;
+  #cookieRevision = 0;
   #child = null;
   #ready = null;
   #pending = new Map();
@@ -100,7 +102,7 @@ export class RendererHost {
    *   onNavigate?: (url: string, downloadName: string | null, fragmentFrom: { x: number, y: number } | null,
    *     post: { method: "POST", body: Uint8Array, contentType: string, referrer: string } | null) => void,
    *   onDownload?: (payload: { url: string, name: string, data: Uint8Array }) => void,
-   *   onFrame?: () => void,
+   *   onFrame?: (frame?: { scrollOffset: { x: number, y: number } }) => void,
    *   onLifecycle?: (name: "DOMContentLoaded" | "load", generation: number) => void,
    *   compositor?: boolean,
    *   fetch?: typeof fetch,
@@ -108,7 +110,7 @@ export class RendererHost {
    * }} options
    */
   constructor({
-    entry = DEFAULT_ENTRY, args = [], timeout = 30_000, onRestart = null, onNavigate = null, onDownload = null,
+    entry = DEFAULT_ENTRY, args = [], timeout = 0, onRestart = null, onNavigate = null, onDownload = null,
     fetch: fetchImpl = fetch,
     network = new NetworkService({ fetch: fetchImpl }), onFrame = null, onLifecycle = null,
     // A dedicated loopback socket works independently of the main thread on all platforms.
@@ -172,13 +174,11 @@ export class RendererHost {
           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);
@@ -194,9 +194,10 @@ export class RendererHost {
         },
       });
       this.#child = child;
-      const startupTimer = setTimeout(() => {
-        this.#closeChannel(channel); child.kill(9); rejectReady(Error('Renderer startup timed out'));
-      }, this.#timeout);
+      this.#cookieSequence = 0;
+      // Startup has no deadline: compiling WASM on a slow machine can take
+      // arbitrarily long. Exit and explicit close still reject the wait.
+      // Interactive method watchdogs start only after the renderer is ready.
       if (logging) {
         pipeToLog(child.stdout, `renderer ${child.pid}`, (chunk) => process.stdout.write(chunk));
         pipeToLog(child.stderr, `renderer ${child.pid}`, (chunk) => process.stderr.write(chunk));
@@ -270,16 +271,22 @@ export class RendererHost {
       catch(error) { channel.pending.get(id).reject(error); channel.pending.delete(id); }
     });
     if (channel.closed || this.#child !== child) throw Error("Renderer closed during capture");
-    const sanitized = this.#captureResult(method, result, params);
+    const sanitized = this.#captureResult(method, result, params, true);
     if (method === "scroll") this.#pendingScroll = sanitized;
     return sanitized;
   }
 
-  #captureResult(method,result,params) {
+  #captureResult(method,result,params,ownsPacket=false) {
     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);
+      try {
+        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);
+      } finally {
+        // PacketReader owns a standalone allocation; write() above is sync.
+        // Main-thread IPC fallback buffers have a different ownership contract.
+        if (ownsPacket && result?.pixels instanceof Uint8Array) result.pixels.buffer.transfer(0);
+      }
     }
     return sanitizeCompositorResult(method,result);
   }
@@ -287,7 +294,12 @@ export class RendererHost {
   #handleCompositorMessage(channel, message, pixels) {
     if (channel.closed || typeof message !== "object" || message === null) return;
     if (message.type === "frame") {
-      if (this.#channel === channel) this.#onFrame?.();
+      if (this.#channel === channel) {
+        const offset = message.scrollOffset;
+        const frame = Number.isFinite(offset?.x) && Number.isFinite(offset?.y)
+          ? { scrollOffset: { x: offset.x, y: offset.y } } : undefined;
+        this.#onFrame?.(frame);
+      }
     } else if (Number.isInteger(message.id) && channel.pending.has(message.id)) {
       const pending = channel.pending.get(message.id);
       channel.pending.delete(message.id);
@@ -329,9 +341,17 @@ export class RendererHost {
     const child = this.#child;
     if (method === 'click' || method === 'press') this.#clipboardUntil = Date.now()+5000;
     if (method === 'loadDocument') this.#clipboardUntil = 0;
+    if (method === 'loadDocument' && params[0]) {
+      params = [{ ...params[0], cookieState: this.#cookieState() }, ...params.slice(1)];
+    }
     const id = this.#nextId++;
     return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
+      // Navigation, including its final fragment positioning, can include
+      // expensive layout/script work. Close/exit cancels it, not a time limit.
+      const navigating = method === 'loadDocument' || method === 'showFragment';
+      // A watchdog is opt-in: elapsed time alone cannot distinguish a slow
+      // renderer from a hung one, including title queries during page loading.
+      const timer = navigating || !(timeout > 0) ? null : setTimeout(() => {
         this.#pending.delete(id);
         // Watchdog: a renderer that misses its deadline is killed outright.
         this.#child = null;
@@ -457,7 +477,12 @@ export class RendererHost {
     } else if (message.type === "lifecycle" && LIFECYCLE_NAMES.has(message.name) && Number.isInteger(message.generation)) {
       this.#onLifecycle?.(message.name, message.generation);
     } else if (message.type === "cookie" && typeof message.value === "string" && message.value.length <= 4096) {
-      this.#network.setDocumentCookie(this.#documentUrl, message.value);
+      const url = typeof message.url === "string" ? message.url : this.#documentUrl;
+      if (sameOrigin(url, this.#documentUrl)) this.#network.setDocumentCookie(url, message.value);
+      if (Number.isSafeInteger(message.sequence) && message.sequence > this.#cookieSequence) {
+        this.#cookieSequence = message.sequence;
+      }
+      child.send({ type: "cookie-state", state: this.#cookieState() });
     } else if (message.type === "navigate" && typeof message.url === "string") {
       // A page asked to navigate (location.href = ...): validate before obeying.
       let target;
@@ -652,7 +677,7 @@ export class RendererHost {
                 url: event.url || target.href,
                 contentType: event.contentType ?? "",
                 contentLength: event.contentLength ?? null,
-                documentCookie: this.#network.documentCookie(this.#documentUrl),
+                documentCookie: this.#network.documentCookie(this.#documentUrl), cookieState: this.#cookieState(),
               },
             });
           } else if (event.type === "chunk" && event.data instanceof Uint8Array) {
@@ -683,7 +708,7 @@ export class RendererHost {
           url: response.url || target.href,
           contentType: response.contentType,
           body: response.body,
-          documentCookie: this.#network.documentCookie(this.#documentUrl),
+          documentCookie: this.#network.documentCookie(this.#documentUrl), cookieState: this.#cookieState(),
         },
       });
     } catch (error) {
@@ -711,7 +736,7 @@ export class RendererHost {
           if (event.type === "head") {
             streamHead = true;
             child.send({ type: "page-fetch-head", id, result: {
-              ...event.result, documentCookie: this.#network.documentCookie(this.#documentUrl),
+              ...event.result, documentCookie: this.#network.documentCookie(this.#documentUrl), cookieState: this.#cookieState(),
             } });
           }
           else if (event.type === "chunk") child.send({ type: "page-fetch-chunk", id, data: event.data });
@@ -724,7 +749,7 @@ export class RendererHost {
       }
       const { rawHeaders, ...result } = response;
       logFetch(sanitized, `${response.status} ${response.body?.byteLength ?? 0}B`, started);
-      reply({ result: { ...result, documentCookie: this.#network.documentCookie(this.#documentUrl) } });
+      reply({ result: { ...result, documentCookie: this.#network.documentCookie(this.#documentUrl), cookieState: this.#cookieState() } });
     } catch (error) {
       logFetch(sanitized ?? request, `failed: ${error?.message ?? error}`, started);
       if (streamHead && this.#child === child) {
@@ -734,6 +759,10 @@ export class RendererHost {
       if (this.#pageFetches.get(id) === entry) this.#pageFetches.delete(id);
     }
   }
+  #cookieState() {
+    return { revision: ++this.#cookieRevision, acknowledged: this.#cookieSequence,
+      cookies: this.#network.cookies.scriptSnapshot(this.#documentUrl) };
+  }
 }
 
 /** With BUNINU_LOG, one line per page fetch()/XMLHttpRequest: method, URL (shortened), outcome, time. */

package/lib/renderer/idle-callbacks.js

@@ -0,0 +1,109 @@
+/**
+ * Cooperative idle work shares a short period, rather than granting every
+ * queued callback a fresh budget. Dispatch one callback per host task so
+ * ordinary timers and input can run between callbacks. A callback registered
+ * during a period joins the next one; positive timeouts have their own task.
+ * Clock/timer injection keeps the fairness and lifetime tests deterministic.
+ */
+export function createIdleCallbacks({ now, setTimer, clearTimer, invoke }) {
+  const callbacks = new Map();
+  let runnable = [], next = 0, deadline = 0, timer = null;
+  let running = false, disposed = false;
+
+  function queue() {
+    if (disposed) return;
+    if (!callbacks.size) {
+      if (timer !== null) clearTimer(timer);
+      timer = null;
+      runnable = []; next = 0;
+      return;
+    }
+    if (running || timer !== null) return;
+    // A nested request must not start a new period before this one ends.
+    const delay = next >= runnable.length ? Math.max(1, deadline - now()) : 1;
+    timer = setTimer(dispatch, delay);
+  }
+
+  function remove(record) {
+    if (callbacks.get(record.id) !== record) return false;
+    callbacks.delete(record.id);
+    if (record.timer !== null) clearTimer(record.timer);
+    record.timer = null;
+    return true;
+  }
+
+  function deliver(record, didTimeout, until) {
+    if (!remove(record)) return;
+    invoke(record.callback, {
+      get didTimeout() { return didTimeout; },
+      timeRemaining: () => Math.max(0, until - now()),
+    });
+  }
+
+  function queueTimeout(record) {
+    // Web IDL permits unsigned-long timeouts, while host timers only accept a
+    // signed 32-bit delay. Chunk longer waits instead of overflowing to 1ms.
+    record.timer = setTimer(() => {
+      record.timer = null;
+      if (disposed || callbacks.get(record.id) !== record) return;
+      if (now() < record.expires) { queueTimeout(record); return; }
+      running = true;
+      try { deliver(record, true, now()); }
+      finally {
+        running = false;
+        queue();
+      }
+    }, Math.min(2147483647, Math.max(1, record.expires - now())));
+  }
+
+  function dispatch() {
+    timer = null;
+    if (disposed || !callbacks.size) return;
+    running = true;
+    try {
+      const at = now();
+      if (at >= deadline) {
+        runnable = [...callbacks.values()];
+        next = 0;
+        deadline = at + 10;
+      }
+      while (next < runnable.length && callbacks.get(runnable[next].id) !== runnable[next]) next++;
+      if (next < runnable.length) {
+        const record = runnable[next++], at = now();
+        const didTimeout = at >= record.expires;
+        deliver(record, didTimeout, didTimeout ? at : deadline);
+      }
+    } finally {
+      running = false;
+      queue();
+    }
+  }
+
+  return {
+    request(id, callback, timeout) {
+      if (disposed) return id;
+      const record = { id, callback, expires: timeout > 0 ? now() + timeout : Infinity, timer: null };
+      callbacks.set(id, record);
+      if (timeout > 0) queueTimeout(record);
+      queue();
+      return id;
+    },
+    cancel(id) {
+      const record = callbacks.get(id);
+      if (record) remove(record);
+      if (!callbacks.size) {
+        if (timer !== null) clearTimer(timer);
+        timer = null;
+        runnable = []; next = 0;
+      }
+    },
+    dispose() {
+      disposed = true;
+      if (timer !== null) clearTimer(timer);
+      timer = null;
+      for (const record of callbacks.values()) if (record.timer !== null) clearTimer(record.timer);
+      callbacks.clear();
+      runnable = []; next = 0;
+    },
+  };
+}

package/lib/renderer/main.js

@@ -265,7 +265,7 @@ const renderer = await createPageRenderer({
   clipboardWriteInput:text=>clipboardWrite(text,'clipboard-write-input'),
   webSockets,
   audio,
-  setCookie: (value) => process.send({ type: "cookie", value }),
+  setCookie: (value, url, sequence) => process.send({ type: "cookie", value, url, sequence }),
   reportError: (message) => report(`buninu-browser: page error: ${logging ? message : String(message).split("\n")[0]}`),
   consoleMessage: logging ? (level, text) => report(`page console.${level}: ${text}`) : null,
   trace: logging ? (text) => report(`timing: ${text}`) : null,
@@ -352,6 +352,10 @@ async function warmUp() {
 }
 
 process.on("message", async (message) => {
+  if (message?.type === "cookie-state") {
+    renderer.updateCookies(message.state);
+    return;
+  }
   if(message?.type==='clipboard-result') {
     const pending=clipboardWrites.get(message.id);if(!pending)return;
     clipboardWrites.delete(message.id);clearTimeout(pending.timer);

package/lib/renderer/media-source.js

@@ -14,6 +14,7 @@
  */
 import { createBytePipe } from "../media/byte-pipe.js";
 import { createSourceSnapshots } from "../media/source-snapshots.js";
+import { createWebMAudioSnapshots } from "../media/webm-snapshots.js";
 import { createWebMStream, ebmlHeader } from "../media/webm-stream.js";
 
 const BRAND = Symbol("MediaSource");
@@ -444,6 +445,8 @@ export function createMediaSourceScope({ origin, schedule, DOMException, onAppen
       this._webm = {};
       this._webmCovered = new Map();
       this._webmStream = /^(video|audio)\/webm\b/i.test(this._mime) ? createWebMStream() : null;
+      this._webmSnapshots = /^audio\/webm\b/i.test(this._mime) ? createWebMAudioSnapshots() : null;
+      if (this._webmSnapshots) this._pipe.snapshotAt = time => this._webmSnapshots.at(time, () => this._pipe.bytes());
       this._hasSegmentTimeline = false;
       this._hasMediaSegment = false;
       this._appendWindowStart = 0;
@@ -589,6 +592,7 @@ export function createMediaSourceScope({ origin, schedule, DOMException, onAppen
             addCovered(this._covered, start, end);
           }
         }
+        this._webmSnapshots?.append({ id, bytes, cluster });
         if (cluster && this._webmCluster !== cluster.token) {
           for (const prefix of cluster.prefix) this._pipe.append(prefix);
           this._webmCluster = cluster.token;