buninu-browser 0.2.2 → 0.2.4

package/lib/audio/playback-buffer.js

@@ -0,0 +1,27 @@
+// Decoded PCM kept in the controller is independent of the device queue.
+// It can bridge renderer work without increasing pause/seek output latency.
+export class PlaybackBuffer {
+  constructor(bytesPerSecond, frameBytes, leadSeconds) {
+    this.bytesPerSecond = bytesPerSecond;
+    this.frameBytes = frameBytes;
+    this.reserve = leadSeconds <= 0.15 ? 0 : this.align(bytesPerSecond * 2);
+    this.threshold = this.reserve ? this.align(bytesPerSecond * 0.4) : 0;
+    this.buffering = Boolean(this.reserve);
+  }
+
+  align(bytes) {
+    return Math.max(0, Math.floor(bytes / this.frameBytes) * this.frameBytes);
+  }
+
+  ready(queued, inDevice, finishing) {
+    if (!this.reserve || finishing) return true;
+    if (queued < this.frameBytes && inDevice < this.frameBytes) this.buffering = true;
+    if (this.buffering && queued >= this.threshold) this.buffering = false;
+    return !this.buffering;
+  }
+
+  request(queued, outstanding, inDevice, immediateNeed) {
+    // Requests stay bounded even when the producer or network stops replying.
+    return this.align(Math.max(immediateNeed, this.reserve - inDevice) - queued - outstanding);
+  }
+}

package/lib/audio/pulse-client.js

@@ -13,6 +13,7 @@
  * other channels carry a stream's audio. Audio is sent as s16le.
  */
 import { connect } from "node:net";
+import { PlaybackBuffer } from "./playback-buffer.js";
 
 export { floatToS16 } from "./pcm.js";
 
@@ -332,9 +333,9 @@ export class PulseClient {
  * to LEAD_SECONDS ahead of the playback clock, whatever the server asks for.
  * Some servers ask for more at once and queue it themselves (jspulse's
  * OpenSL ES backend requests again as soon as it receives), and then a pause
- * would leave everything already sent still playing. `onRequest(bytes)` asks
- * the producer for about that much more; audio it has not been asked for is
- * never requested twice.
+ * would leave everything already sent still playing. The producer prepares a
+ * separate bounded PCM reserve here so renderer work cannot immediately starve
+ * the output. That reserve is discarded on close, not sent to the device.
  */
 const LEAD_SECONDS = 0.5;
 const PACE_MS = 50;
@@ -359,6 +360,7 @@ class PlaybackStream {
   #onTimingError;
   #timingPending = false;
   #playedBytes = 0;
+  #producerBuffer;
   killed = false;
 
   constructor(client, index, { rate, channels }, onRequest, leadSeconds, onTiming, onTimingError) {
@@ -371,6 +373,7 @@ class PlaybackStream {
     this.#bytesPerSecond = rate * this.#frameBytes;
     this.#onRequest = onRequest;
     this.#leadSeconds = leadSeconds;
+    this.#producerBuffer = new PlaybackBuffer(this.#bytesPerSecond, this.#frameBytes, leadSeconds);
     this.#onTiming = onTiming;
     this.#onTimingError = onTimingError;
     this.#timer = setInterval(() => { this.#pace(); void this.updateTiming(); }, PACE_MS);
@@ -388,7 +391,8 @@ class PlaybackStream {
       const played = Math.min(end, Math.max(0, Math.min(end, timing.readIndex) - timing.sinkSeconds * this.#bytesPerSecond));
       this.#playedBytes = Math.max(this.#playedBytes, this.#frameAligned(played));
       this.#onTiming({ seconds: this.#playedBytes / this.#bytesPerSecond,
-        sentSeconds: this.#offset / this.#bytesPerSecond, sinkSeconds: timing.sinkSeconds, playing: timing.playing });
+        sentSeconds: this.#offset / this.#bytesPerSecond, sinkSeconds: timing.sinkSeconds, playing: timing.playing,
+        bufferedSeconds: this.#queuedBytes / this.#bytesPerSecond });
       this.#pace();
     } catch (error) {
       if (!this.killed) this.#onTimingError?.(error);
@@ -436,7 +440,11 @@ class PlaybackStream {
     // (a few at a time), so small packets leave them little to play from.
     const minimum = this.#frameAligned(this.#bytesPerSecond * MIN_PACKET_SECONDS);
     const maximum = this.#frameAligned(this.#bytesPerSecond * MAX_PACKET_SECONDS);
-    while (this.#credit > 0 && this.#queuedBytes > 0 && this.#offset < allowed) {
+    const inDevice = this.#onTiming ? Math.max(0, this.#offset - this.#playedBytes)
+      : this.#started === null ? 0 : Math.max(0, this.#offset - (performance.now() - this.#started) / 1000 * this.#bytesPerSecond);
+    const ready = this.#producerBuffer.ready(this.#queuedBytes, inDevice, this.finishing);
+    const previousOffset = this.#offset;
+    while (ready && this.#credit > 0 && this.#queuedBytes > 0 && this.#offset < allowed) {
       const room = this.#frameAligned(Math.min(this.#credit, allowed - this.#offset, maximum, this.#queuedBytes));
       if (room < this.#frameBytes || (room < minimum && !this.finishing && this.#queuedBytes < minimum)) break;
       const packet = new Uint8Array(room);
@@ -454,9 +462,11 @@ class PlaybackStream {
       this.#credit -= room;
       this.#queuedBytes -= room;
     }
-    // Ask for what the clock will allow next that is neither queued nor already asked for.
-    const need = this.#frameAligned(Math.min(this.#offset + this.#credit, allowed + this.#bytesPerSecond * PACE_MS / 1000)
-      - this.#offset - this.#queuedBytes - this.#outstanding);
+    // Predecode independently of server credits; only transmission uses the
+    // small device budget above. Keep outstanding requests in that budget too.
+    const immediateNeed = Math.min(this.#credit, allowed + this.#bytesPerSecond * PACE_MS / 1000 - this.#offset);
+    const sentNow = inDevice + this.#offset - previousOffset;
+    const need = this.#producerBuffer.request(this.#queuedBytes, this.#outstanding, sentNow, immediateNeed);
     if (need >= this.#bytesPerSecond * MIN_REQUEST_SECONDS && !this.finishing) {
       this.#outstanding += need;
       this.#onRequest(need);

package/lib/cdp-server.js

@@ -44,9 +44,11 @@ export class CdpServer {
       for (const target of state.targets.values()) {
         if (target.screencast && target.screencastEmit) pushScreencastFrame(context, state, target);
       }
+      if (state.implicitTarget?.screencast) pushScreencastFrame(context, state, state.implicitTarget);
     });
     context.onLifecycle?.((name) => {
       for (const target of state.targets.values()) emitLifecycle(target, name);
+      if (state.implicitTarget) emitLifecycle(state.implicitTarget, name);
     });
 
     const server = Bun.serve({
@@ -178,6 +180,7 @@ export class CdpServer {
                 ...(sessionId ? { sessionId } : {}),
               });
             };
+            emit.owner = ws;
             const result = await dispatch(
               context,
               state,
@@ -206,6 +209,13 @@ export class CdpServer {
           }
         },
         close(ws) {
+          for (const target of state.targets.values()) {
+            if (target.screencastEmit?.owner === ws) stopScreencast(target);
+            if (target.lifecycleEmit?.owner === ws) target.lifecycleEmit = null;
+          }
+          const implicit = state.implicitTarget;
+          if (implicit?.screencastEmit?.owner === ws) stopScreencast(implicit);
+          if (implicit?.lifecycleEmit?.owner === ws) implicit.lifecycleEmit = null;
           serverLog("[CdpServer] client disconnected");
         },
       },
@@ -350,6 +360,7 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
       const target = state.targets.get(params.targetId);
       if (!target) return { success: false };
 
+      stopScreencast(target);
       await ctx.close?.();
       state.initialNavigations.get(params.targetId)?.navigated.resolve();
       state.initialNavigations.get(params.targetId)?.settled.resolve();
@@ -450,7 +461,7 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
       // A javascript: URL runs in the current document: no new loader or history entry.
       if (/^\s*javascript:/i.test(String(params.url))) {
         await ctx.navigate?.(String(params.url).trim());
-        if (target.screencast) await emitScreencastFrame(ctx, state, target, emit);
+        if (target.screencast) await pushScreencastFrame(ctx, state, target);
         return { frameId: target.frameId, loaderId: target.loaderId };
       }
       // Events of the next document belong to its new loader.
@@ -460,7 +471,7 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
       target.title = await getContextTitle(ctx, target);
       target.history[target.historyIndex].title = target.title;
       if (target.screencast) {
-        await emitScreencastFrame(ctx, state, target, emit);
+        await pushScreencastFrame(ctx, state, target);
       }
       state.initialNavigations.get(target.targetId)?.navigated.resolve();
 
@@ -512,6 +523,7 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
     }
     case "Page.startScreencast": {
       const target = getSessionTarget(state, sessionId);
+      stopScreencast(target);
       target.screencast = { ...params };
       target.screencastEmit = emit;
       // As in Chrome, the reply does not wait for the first frame (nor the
@@ -519,12 +531,14 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
       void pushScreencastFrame(ctx, state, target);
       return {};
     }
-    case "Page.screencastFrameAck":
+    case "Page.screencastFrameAck": {
+      const target = getSessionTarget(state, sessionId);
+      if (target.screencastFrames.delete(params.sessionId) && target.screencastPending) void pushScreencastFrame(ctx, state, target);
       return {};
+    }
     case "Page.stopScreencast": {
       const target = getSessionTarget(state, sessionId);
-      target.screencast = null;
-      target.screencastEmit = null;
+      stopScreencast(target);
       return {};
     }
     case "Page.reload": {
@@ -686,6 +700,10 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
       return {};
     case "Input.dispatchMouseEvent": {
       const target = getSessionTarget(state, sessionId);
+      if (params.type === "mouseMoved") {
+        await ctx.move?.(params.x, params.y);
+        return {};
+      }
       if (params.type === "mouseWheel") {
         await ctx.scroll?.(params.deltaX ?? 0, params.deltaY ?? 0, { x: params.x, y: params.y });
         return {};
@@ -703,7 +721,7 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
           navigateTarget(state, target, navigation.url, emit, { addHistory: true });
           target.title = navigation.title ?? await getContextTitle(ctx, target);
           target.history[target.historyIndex].title = target.title;
-          if (target.screencast) await emitScreencastFrame(ctx, state, target, emit);
+          if (target.screencast) await pushScreencastFrame(ctx, state, target);
         }
       }
       return {};
@@ -719,6 +737,7 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
             text: params.text ?? "",
             code: params.code ?? "",
             repeat: !!params.autoRepeat,
+            windowsVirtualKeyCode: params.windowsVirtualKeyCode,
           });
           target.cdpKeyDown = signature;
         }
@@ -729,6 +748,7 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
             text: params.text ?? "",
             code: params.code ?? "",
             repeat: !!params.autoRepeat,
+            windowsVirtualKeyCode: params.windowsVirtualKeyCode,
           });
         }
       } else if (params.type === "keyUp") {
@@ -811,6 +831,7 @@ function createTarget(state, url = "about:blank", options = {}) {
       deviceScaleFactor: 1,
     },
     screencast: null,
+    screencastFrames: new Set(),
   };
   state.targets.set(targetId, target);
   state.initialNavigations.set(targetId, {
@@ -851,9 +872,20 @@ function emitLifecycle(target, name) {
   emit("Page.lifecycleEvent", { frameId: target.frameId, loaderId: target.loaderId, name, timestamp });
 }
 
-/** One screencast frame at a time; changes during a capture coalesce into one more. */
+// Bound the amount of image data queued to a slow CDP client. Two outstanding
+// frames keep the pipe moving while acknowledging one; later updates coalesce.
+const MAX_SCREENCAST_FRAMES = 2;
+function stopScreencast(target) {
+  target.screencast = null;
+  target.screencastEmit = null;
+  target.screencastPending = false;
+  target.screencastFrames.clear();
+}
+
+/** One capture at a time, with bounded unacknowledged frames. */
 async function pushScreencastFrame(ctx, state, target) {
-  if (target.screencastBusy) {
+  if (!target.screencast || !target.screencastEmit) return;
+  if (target.screencastBusy || target.screencastFrames.size >= MAX_SCREENCAST_FRAMES) {
     target.screencastPending = true;
     return;
   }
@@ -861,8 +893,9 @@ async function pushScreencastFrame(ctx, state, target) {
   try {
     do {
       target.screencastPending = false;
-      await emitScreencastFrame(ctx, state, target, target.screencastEmit);
-    } while (target.screencastPending && target.screencast && target.screencastEmit);
+      await emitScreencastFrame(ctx, state, target);
+    } while (target.screencastPending && target.screencast && target.screencastEmit
+      && target.screencastFrames.size < MAX_SCREENCAST_FRAMES);
   } catch (error) {
     serverError(`[CdpServer] screencast frame failed: ${error?.message ?? error}`);
   } finally {
@@ -870,10 +903,14 @@ async function pushScreencastFrame(ctx, state, target) {
   }
 }
 
-async function emitScreencastFrame(ctx, state, target, emit) {
-  const data = await screenshotData(ctx, target, target.screencast ?? {});
-  if (!data) return;
+async function emitScreencastFrame(ctx, state, target) {
+  const stream = target.screencast, emit = target.screencastEmit;
+  const data = await screenshotData(ctx, target, stream);
+  if (!data || stream !== target.screencast || emit !== target.screencastEmit) return;
   const scrollOffset = await ctx.scrollOffset?.() ?? { x: 0, y: 0 };
+  if (stream !== target.screencast || emit !== target.screencastEmit) return;
+  const sessionId = state.nextScreencastFrameId++;
+  target.screencastFrames.add(sessionId);
   emit("Page.screencastFrame", {
     data,
     metadata: {
@@ -885,7 +922,7 @@ async function emitScreencastFrame(ctx, state, target, emit) {
       scrollOffsetY: scrollOffset.y,
       timestamp: performance.now() / 1000,
     },
-    sessionId: state.nextScreencastFrameId++,
+    sessionId,
   });
 }
 
@@ -994,6 +1031,8 @@ function getImplicitTarget(state) {
 
   state.implicitTarget = {
     targetId: "implicit-target",
+    screencast: null,
+    screencastFrames: new Set(),
     frameId: "implicit-target",
     loaderId: "implicit-loader",
     type: "page",

package/lib/happy-dom/document-base.js

@@ -0,0 +1,33 @@
+import Node from "../../vendor/happy-dom/packages/happy-dom/src/nodes/node/Node.ts";
+import Document from "../../vendor/happy-dom/packages/happy-dom/src/nodes/document/Document.ts";
+import HTMLHyperlinkElementUtility from "../../vendor/happy-dom/packages/happy-dom/src/nodes/html-hyperlink-element/HTMLHyperlinkElementUtility.ts";
+
+/** HTML document base URL, shared by the inert DOM and its page bindings. */
+export function documentBaseURL(node) {
+  const document = node?.nodeType === 9 ? node : node?.ownerDocument;
+  const fallback = document?.URL ?? "about:blank";
+  const base = document?.querySelector?.("base[href]");
+  if (!base) return fallback;
+  try {
+    const url = new URL(base.getAttribute("href"), fallback);
+    return url.protocol === "data:" || url.protocol === "javascript:" ? fallback : url.href;
+  } catch { return fallback; }
+}
+
+// Happy DOM selects the first <base>, including ones with only a target.
+// Correcting both accessors keeps native URL attributes and renderer loads
+// on the same base, without modifying the vendored implementation.
+for (const prototype of [Node.prototype, Document.prototype]) {
+  Object.defineProperty(prototype, "baseURI", {
+    configurable: true, get() { return documentBaseURL(this); },
+  });
+}
+
+// Hyperlink component accessors use this shared method, so pathname/search
+// setters and origin/hash getters resolve consistently with href itself.
+HTMLHyperlinkElementUtility.prototype.getHref = function () {
+  const value = this.element.getAttribute("href");
+  if (value === null) return "";
+  try { return new URL(value, documentBaseURL(this.element)).href; }
+  catch { return value; }
+};

package/lib/happy-dom/parser.js

@@ -1,5 +1,9 @@
 import HTMLParser from "../../vendor/happy-dom/packages/happy-dom/src/html-parser/HTMLParser.ts";
 import Window from "../../vendor/happy-dom/packages/happy-dom/src/window/Window.ts";
+import * as PropertySymbol from "../../vendor/happy-dom/packages/happy-dom/src/PropertySymbol.ts";
+import "./selector-pseudo-adapter.js";
+import "./svg-attribute-adapter.js";
+import "./document-base.js";
 
 const IMPLICIT_HEAD_ELEMENTS = new Set([
   "BASE", "BASEFONT", "BGSOUND", "LINK", "META", "NOFRAMES", "SCRIPT", "STYLE", "TEMPLATE", "TITLE",
@@ -11,8 +15,18 @@ const IMPLICIT_HEAD_ELEMENTS = new Set([
  * Page JavaScript and subresource loading stay disabled here. They belong to
  * the renderer scheduler and network service rather than the tree builder.
  */
-export function parseHTMLDocument(html, url = "about:blank") {
-  const window = new Window({
+export function parseHTMLDocument(html, url = "about:blank", referrer = "") {
+  const window = createInertWindow(url);
+  window.document[PropertySymbol.referrer] = referrer;
+
+  new HTMLParser(window).parse(String(html), window.document);
+  normalizeImplicitHead(window.document, implicitHeadCount(String(html)));
+  return { window, document: window.document };
+}
+
+/** An isolated parser context: no script execution, resource loads or page custom elements. */
+export function createInertWindow(url = "about:blank") {
+  return new Window({
     url,
     settings: {
       disableJavaScriptEvaluation: true,
@@ -20,12 +34,12 @@ export function parseHTMLDocument(html, url = "about:blank") {
       disableCSSFileLoading: true,
       disableIframePageLoading: true,
       enableImageFileLoading: false,
+      // This DOM is only the tree builder. Link activation must not change
+      // its URL before our controller commits a navigation (downloads never
+      // commit). Otherwise later #links resolve against the download URL.
+      navigation: { disableFallbackToSetURL: true },
     },
   });
-
-  new HTMLParser(window).parse(String(html), window.document);
-  normalizeImplicitHead(window.document, implicitHeadCount(String(html)));
-  return { window, document: window.document };
 }
 
 /**

package/lib/happy-dom/selector-matcher.js

@@ -37,9 +37,9 @@ export function compileSelector(element, selector) {
 }
 
 /** Whether `element` matches a compiled selector, as element.matches(selector) would. */
-export function matchesCompiled(element, compiled) {
+export function matchesCompiled(element, compiled, scope = element) {
   for (const items of compiled) {
-    if (matchItems(element, element, items, 0, null)) return true;
+    if (matchItems(scope, element, items, 0, null)) return true;
   }
   return false;
 }

package/lib/happy-dom/selector-pseudo-adapter.js

@@ -0,0 +1,33 @@
+import SelectorItem from "../../vendor/happy-dom/packages/happy-dom/src/query-selector/SelectorItem.ts";
+import { compileSelector, matchesCompiled } from "./selector-matcher.js";
+
+// Happy DOM's :empty checks only element children. CSS also excludes elements
+// with nonempty text nodes (including whitespace); comments do not count.
+const original = SelectorItem.prototype.matchPseudoItem;
+const selectorLists = new WeakMap();
+SelectorItem.prototype.matchPseudoItem = function (scope, element, siblings, pseudo, ignoreErrors) {
+  if (pseudo.name === "focus-within") {
+    const focused = element.ownerDocument?.activeElement;
+    return focused && (focused === element || element.contains(focused)) ? {priorityWeight:10} : null;
+  }
+  // Functional selector lists match their complete complex selectors. The
+  // upstream per-item path tests only a group's first compound, so e.g.
+  // :where(h2 code) incorrectly matches the h2 instead of its code child.
+  if (["is", "where", "not"].includes(pseudo.name) && pseudo.arguments) {
+    let compiled = selectorLists.get(pseudo);
+    if (compiled === undefined) {
+      compiled = compileSelector(element, pseudo.arguments) ?? null;
+      selectorLists.set(pseudo, compiled);
+    }
+    const matches = compiled && matchesCompiled(element, compiled, scope);
+    return (pseudo.name === "not" ? !matches : matches)
+      ? { priorityWeight: pseudo.name === "where" ? 0 : 10 } : null;
+  }
+  if (pseudo.name === "empty") {
+    for (const child of element.childNodes) {
+      if (child.nodeType === 1 || (child.nodeType === 3 || child.nodeType === 4) && child.data.length) return null;
+    }
+    return { priorityWeight: 10 };
+  }
+  return original.call(this, scope, element, siblings, pseudo, ignoreErrors);
+};

package/lib/happy-dom/svg-attribute-adapter.js

@@ -0,0 +1,50 @@
+import HTMLParser from "../../vendor/happy-dom/packages/happy-dom/src/html-parser/HTMLParser.ts";
+
+// HTML tokenization ASCII-lowercases every attribute, including foreign
+// content. Tree construction then restores the standard SVG spellings.
+// https://html.spec.whatwg.org/multipage/parsing.html#adjust-svg-attributes
+const adjustedNames = new Map(`attributeName attributeType baseFrequency baseProfile calcMode clipPathUnits
+  diffuseConstant edgeMode filterUnits glyphRef gradientTransform gradientUnits kernelMatrix kernelUnitLength
+  keyPoints keySplines keyTimes lengthAdjust limitingConeAngle markerHeight markerUnits markerWidth
+  maskContentUnits maskUnits numOctaves pathLength patternContentUnits patternTransform patternUnits
+  pointsAtX pointsAtY pointsAtZ preserveAlpha preserveAspectRatio primitiveUnits refX refY repeatCount repeatDur
+  requiredExtensions requiredFeatures specularConstant specularExponent spreadMethod startOffset stdDeviation
+  stitchTiles surfaceScale systemLanguage tableValues targetX targetY textLength viewBox viewTarget
+  xChannelSelector yChannelSelector zoomAndPan`.trim().split(/\s+/).map(name => [name.toLowerCase(), name]));
+const space = character => character === " " || character === "\t" || character === "\n" || character === "\r" || character === "\f";
+
+function adjustNames(source) {
+  let index = 0, copied = 0, output = "";
+  while (index < source.length) {
+    while (space(source[index]) || source[index] === "/") index++;
+    const start = index;
+    while (index < source.length && !space(source[index]) && source[index] !== "=" && source[index] !== "/" && source[index] !== ">") index++;
+    if (index === start) { index++; continue; }
+    const name = source.slice(start, index);
+    const lower = name.replace(/[A-Z]/g, character => character.toLowerCase());
+    const adjusted = adjustedNames.get(lower) ?? lower;
+    if (name !== adjusted) {
+      output += source.slice(copied, start) + adjusted;
+      copied = index;
+    }
+    while (space(source[index])) index++;
+    if (source[index] !== "=") continue;
+    index++;
+    while (space(source[index])) index++;
+    const quote = source[index];
+    if (quote === '"' || quote === "'") {
+      index++;
+      while (index < source.length && source[index] !== quote) index++;
+      if (index < source.length) index++;
+    } else {
+      while (index < source.length && !space(source[index]) && source[index] !== ">") index++;
+    }
+  }
+  return copied ? output + source.slice(copied) : source;
+}
+
+const parseAttributes = HTMLParser.prototype.parseEndOfStartTag;
+HTMLParser.prototype.parseEndOfStartTag = function (source, selfClosing) {
+  if (source && this.nextElement?.namespaceURI === "http://www.w3.org/2000/svg") source = adjustNames(source);
+  return parseAttributes.call(this, source, selfClosing);
+};

package/lib/headless-shell.js

@@ -173,7 +173,7 @@ export async function createBrowser({
           recordFragment(url, fragmentFrom);
           return;
         }
-        navigate(url, { downloadName, post }).catch((error) => console.error(`buninu-browser: navigation failed: ${error.message}`));
+        navigate(url, { downloadName, post, referrer: host.documentUrl }).catch((error) => console.error(`buninu-browser: navigation failed: ${error.message}`));
       },
       onDownload: ({ url, name, data }) => {
         if (host !== current) return;
@@ -259,7 +259,7 @@ export async function createBrowser({
    * final origin. `invoke` pins the renderer (used when restoring a
    * restarted renderer).
    */
-  async function load(url, invoke = null, downloadName = null, post = null) {
+  async function load(url, invoke = null, downloadName = null, post = null, referrer = null) {
     const started = performance.now();
     if (downloadName !== null && resource && withoutHash(url) === withoutHash(resource.url)) {
       return download({ url: resource.url, body: resource.body, attributeName: downloadName, totalBytes: resource.body.byteLength });
@@ -273,7 +273,7 @@ export async function createBrowser({
       try {
         const target = new URL(url);
         const response = ["http:", "https:"].includes(target.protocol)
-          ? await network.navigate(target.href, { post, onResponse: (raw, finalUrl) => {
+          ? await network.navigate(target.href, { post, referrer: referrer ?? post?.referrer ?? null, onResponse: (raw, finalUrl) => {
             if (!raw.ok || (downloadName === null && !isAttachment(raw.headers.get("content-disposition")))) return null;
             return download({ url: finalUrl, body: raw.body, disposition: raw.headers.get("content-disposition") ?? "",
               attributeName: downloadName ?? "", totalBytes: Number(raw.headers.get("content-length")) || 0 });
@@ -292,6 +292,7 @@ export async function createBrowser({
           status: response.status,
           statusText: response.statusText,
           cookie: network.documentCookie(response.url),
+          referrer: response.referrer ?? "",
         };
       } catch (error) {
         document = { url, error: String(error) };
@@ -324,7 +325,7 @@ export async function createBrowser({
     Object.assign(history[historyIndex], { x: offset.x, y: offset.y });
   }
 
-  async function navigate(url, { downloadName = null, post = null } = {}) {
+  async function navigate(url, { downloadName = null, post = null, referrer = null } = {}) {
     const resolved = new URL(url, currentUrl).href;
     // A javascript: URL runs in the current document; history does not change.
     if (resolved.startsWith("javascript:")) {
@@ -336,7 +337,7 @@ export async function createBrowser({
     if (!post && downloadName === null && withoutHash(resolved) === withoutHash(currentUrl)) {
       currentUrl = resolved;
     } else {
-      const result = await load(resolved, null, downloadName, post);
+      const result = await load(resolved, null, downloadName, post, referrer);
       if (result?.downloaded) return null;
       // The document is at the URL redirects ended on; the request's fragment
       // carries over to it unless it has its own (Fetch §4.4, HTML §7.4.6).
@@ -406,6 +407,7 @@ export async function createBrowser({
     screenshot: (options = {}) => composite("screenshot", {
       format: options.format === "jpeg" || options.format === "webp" ? options.format : "png",
       quality: Number.isFinite(options.quality) ? options.quality : 80,
+      optimizeForSpeed: options.optimizeForSpeed === true,
     }),
     title: () => call("title"),
     /**
@@ -455,6 +457,9 @@ export async function createBrowser({
     lifecycleState() {
       return [...reachedLifecycle(committed.host, committed.generation)];
     },
+    move(x, y) {
+      return call("move", x / pageScale(), y / pageScale());
+    },
     async click(x, y) {
       const clicked = await call("click", x / pageScale(), y / pageScale());
       const href = typeof clicked === "string" ? clicked : clicked?.url;
@@ -463,7 +468,8 @@ export async function createBrowser({
         recordFragment(href, clicked.fragmentFrom);
         return { url: href, title: await call("title") };
       }
-      const result = await navigate(href, { downloadName: typeof clicked === "object" ? clicked.download ?? null : null });
+      const result = await navigate(href, { downloadName: typeof clicked === "object" ? clicked.download ?? null : null,
+        referrer: current.documentUrl });
       return result === null ? null : { url: href, title: await call("title") };
     },
     evaluate: (expression) => call("evaluate", String(expression)),