buninu-browser 0.2.0 → 0.2.2

package/lib/log.js

@@ -34,9 +34,11 @@ export function installLog(path) {
   logPath = path;
   for (const level of ["log", "info", "warn", "error", "debug", "trace"]) {
     const original = console[level].bind(console);
+    // The file first: whoever sees a line on the console (and then stops
+    // this process) finds it in the log too.
     console[level] = (...args) => {
-      original(...args);
       writeLog(level, formatWithOptions({ colors: false }, ...args));
+      original(...args);
     };
   }
   writeLog("log", `started pid ${process.pid}, bun ${Bun.version}, cwd ${process.cwd()}, args ${JSON.stringify(Bun.argv.slice(2))}`);
@@ -69,13 +71,14 @@ export async function pipeToLog(stream, source, echo) {
   let pending = "";
   try {
     for await (const chunk of stream) {
-      echo(chunk);
       pending += decoder.decode(chunk, { stream: true });
       const end = pending.lastIndexOf("\n");
       if (end >= 0) {
         writeLog(source, pending.slice(0, end));
         pending = pending.slice(end + 1);
       }
+      // Echoed after the complete lines are in the log (see installLog).
+      echo(chunk);
     }
   } catch {
     // The child went away mid-read.

package/lib/media/byte-pipe.js

@@ -0,0 +1,82 @@
+/**
+ * A growing media buffer shared by a progressive download and by MSE appends.
+ *
+ * wasmpeg can only open a decoder on a complete snapshot, so playback keeps
+ * this concatenation, reopens when the decoder runs off the end of what it
+ * was opened on, and seeks back. `generation` changes on every append and
+ * on finish/fail, which is how a decoder knows its snapshot is stale.
+ * `waitFor` resolves when `size` reaches the mark or the pipe is finished.
+ */
+export function createBytePipe() {
+  const chunks = [];
+  let size = 0;
+  let generation = 0;
+  let done = false;
+  let error = null;
+  /** @type {Array<() => void>} */
+  const waiters = [];
+
+  const wake = () => {
+    for (const waiter of waiters.splice(0)) waiter();
+  };
+
+  return {
+    append(bytes) {
+      if (done || bytes == null) return;
+      const chunk = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+      if (!chunk.byteLength) return;
+      chunks.push(chunk);
+      size += chunk.byteLength;
+      generation += 1;
+      wake();
+    },
+    finish() {
+      if (done) return;
+      done = true;
+      generation += 1;
+      wake();
+    },
+    fail(reason) {
+      if (done) return;
+      error = reason instanceof Error ? reason : new Error(String(reason ?? "media fetch failed"));
+      done = true;
+      generation += 1;
+      wake();
+    },
+    /** One contiguous snapshot. Collapses chunks so the next call is cheap. */
+    bytes() {
+      if (chunks.length === 1) return chunks[0];
+      const out = new Uint8Array(size);
+      let offset = 0;
+      for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      chunks.length = 0;
+      if (out.byteLength) chunks.push(out);
+      return out;
+    },
+    get size() {
+      return size;
+    },
+    get generation() {
+      return generation;
+    },
+    get done() {
+      return done;
+    },
+    get error() {
+      return error;
+    },
+    waitFor(mark) {
+      if (size >= mark || done) return Promise.resolve();
+      return new Promise((resolve) => {
+        const check = () => {
+          if (size >= mark || done) resolve();
+          else waiters.push(check);
+        };
+        waiters.push(check);
+      });
+    },
+  };
+}

package/lib/media/position-audio.js

@@ -0,0 +1,42 @@
+/** Advance a PCM decoder to an exact sample cursor, never playing discarded PCM.
+ * Reopened snapshots start at sample zero, including their pending first chunk.
+ * The caller holds output requests until this transaction has completed.
+ */
+export async function advanceAudio(getSound, seconds, { reopen, needsMore, active = () => true }) {
+  while (active()) {
+    const sound = getSound();
+    const { sampleRate, channels } = sound.decoder;
+    const target = Math.max(0, Math.round(seconds * sampleRate));
+    if (sound.position === target) return true;
+    if (sound.position > target) {
+      if (!await reopen()) return false;
+      continue;
+    }
+    // This is also the first chunk of EVERY replacement decoder. Skipping it
+    // used to leave the opening sound queued at exact chunk boundaries.
+    let samples = sound.pending;
+    sound.pending = null;
+    if (!samples) {
+      try { samples = sound.decoder.nextSamples(); }
+      catch (error) {
+        if (!needsMore(sound)) throw error;
+      }
+    }
+    if (samples?.length) {
+      const take = Math.min(target - sound.position, samples.length / channels);
+      sound.position += take;
+      if (take * channels < samples.length) sound.pending = samples.subarray(take * channels);
+      continue;
+    }
+    if (!needsMore(sound)) return false;
+    const pipe = sound.pipe;
+    if (pipe.error) throw pipe.error;
+    // Data may already have arrived while this snapshot was being decoded.
+    if (pipe.generation === sound.openedGeneration) await pipe.waitFor(pipe.size + 1);
+    if (!active()) return false;
+    if (pipe.error) throw pipe.error;
+    if (pipe.generation === sound.openedGeneration) return false;
+    if (!await reopen()) return false;
+  }
+  return false;
+}

package/lib/network/network-service.js

@@ -15,6 +15,7 @@ import { fetchResolved, HostResolver } from "./resolver.js";
 
 const MAX_REDIRECTS = 20;
 const MAX_BODY_BYTES = 64 * 1024 * 1024;
+const MAX_CACHED_SUBRESOURCES = 256;
 const SIMPLE_METHODS = new Set(["GET", "HEAD", "POST"]);
 const FORBIDDEN_METHODS = new Set(["CONNECT", "TRACE", "TRACK"]);
 // Fetch §2.2.2 CORS-safelisted request headers (value checks simplified).
@@ -29,12 +30,23 @@ const FORBIDDEN_REQUEST_HEADERS = new Set([
 const SAFELISTED_RESPONSE_HEADERS = new Set([
   "cache-control", "content-language", "content-length", "content-type", "expires", "last-modified", "pragma",
 ]);
+// Requests in flight to one host at a time, as browsers allow over HTTP/1.1.
+const MAX_REQUESTS_PER_HOST = 6;
+// Which waiting request to a busy host goes next (lower first): documents,
+// then what blocks rendering or that a script waits for, then the rest.
+const PRIORITY = { document: 0, iframe: 1, stylesheet: 1, fetch: 1, script: 2, metadata: 2, image: 3, video: 3, audio: 3 };
 
 export class NetworkService {
   #fetch;
   #resolver;
   #cookies;
   #userAgent;
+  // Browser-process HTTP cache. Entries are partitioned by the request
+  // credentials that affect a subresource response; concurrent identical
+  // requests share one transfer.
+  #subresourceCache = new Map();
+  #subresourceInflight = new Map();
+  #hosts = new HostThrottle(MAX_REQUESTS_PER_HOST);
 
   /**
    * `resolver` looks host names up itself (see resolver.js); it is on for the
@@ -55,20 +67,139 @@ export class NetworkService {
   }
 
   set userAgent(value) {
-    this.#userAgent = typeof value === "string" && value ? value : null;
+    const next = typeof value === "string" && value ? value : null;
+    if (next !== this.#userAgent) this.#subresourceCache.clear();
+    this.#userAgent = next;
   }
 
   /** A top-level document load. */
-  async navigate(url, { onResponse } = {}) {
-    return this.#send({ url, method: "GET", headers: [], body: null }, {
+  /**
+   * Fetches a document to navigate to. A form POST (`post`) sends its body,
+   * with Origin and a Referer trimmed to the origin across origins
+   * (strict-origin-when-cross-origin); a redirect after it turns into a GET.
+   */
+  async navigate(url, { onResponse, post = null } = {}) {
+    const headers = [];
+    let method = "GET";
+    let body = null;
+    if (post) {
+      method = "POST";
+      body = post.body;
+      headers.push(["content-type", post.contentType]);
+      let from = null;
+      try { from = new URL(post.referrer); } catch {}
+      if (from && ["http:", "https:"].includes(from.protocol)) {
+        const target = new URL(url);
+        headers.push(["origin", from.origin]);
+        const downgrade = from.protocol === "https:" && target.protocol === "http:";
+        if (!downgrade) {
+          headers.push(["referer", from.origin === target.origin ? withoutFragment(from.href) : `${from.origin}/`]);
+        }
+      }
+    }
+    return this.#send({ url, method, headers, body }, {
       credentials: "include", site: null, topLevelNavigation: true,
-    }, { onResponse });
+    }, { onResponse, priority: PRIORITY.document });
   }
 
-  /** A subresource the renderer needs to render (no-cors, credentials included). */
-  async subresource(url, documentUrl) {
+  /**
+   * A subresource the renderer needs to render (no-cors, credentials included).
+   * `kind` ("stylesheet", "script", "image"...) decides its turn at a busy host.
+   */
+  async subresource(url, documentUrl, kind = "metadata") {
+    const site = siteOf(documentUrl);
+    const cookie = this.#cookies.header(url, { site });
+    const key = `${url}\n${site ?? ""}\n${cookie}\n${this.#userAgent ?? ""}`;
+    const cached = this.#subresourceCache.get(key);
+    if (cached && cached.expires > Date.now()) return cached.result;
+    const pending = this.#subresourceInflight.get(key);
+    if (pending) return pending;
+    const request = (async () => {
+      const headers = cached?.etag ? [["if-none-match", cached.etag]] : [];
+      let result = await this.#send({ url, method: "GET", headers, body: null }, {
+        credentials: "include", site,
+      }, { priority: PRIORITY[kind] ?? PRIORITY.metadata });
+      if (result.status === 304 && cached) {
+        const rawHeaders = [...new Map([...cached.result.rawHeaders, ...result.rawHeaders])];
+        result = {
+          ...cached.result,
+          rawHeaders,
+          headers: [...new Map([...cached.result.headers, ...result.headers])],
+        };
+        const policy = cachePolicy(rawHeaders);
+        cached.expires = policy.expires;
+        return result;
+      }
+      const policy = cachePolicy(result.rawHeaders);
+      if (result.ok && policy.cacheable) {
+        if (!this.#subresourceCache.has(key) && this.#subresourceCache.size >= MAX_CACHED_SUBRESOURCES) {
+          this.#subresourceCache.delete(this.#subresourceCache.keys().next().value);
+        }
+        this.#subresourceCache.set(key, { result, expires: policy.expires, etag: policy.etag });
+      } else {
+        this.#subresourceCache.delete(key);
+      }
+      return result;
+    })();
+    this.#subresourceInflight.set(key, request);
+    try {
+      return await request;
+    } finally {
+      if (this.#subresourceInflight.get(key) === request) this.#subresourceInflight.delete(key);
+    }
+  }
+
+  /**
+   * A video or audio subresource whose body is delivered as it arrives.
+   * `emit` is called with `{ type: "head", ... }`, then `{ type: "chunk", data }`,
+   * then `{ type: "end" }` or `{ type: "error", error }`. Nothing is cached:
+   * a growing body is not a reusable response. The host slot stays held until
+   * the body has been read, same as a buffered subresource.
+   */
+  streamSubresource(url, documentUrl, kind, emit) {
+    const site = siteOf(documentUrl);
     return this.#send({ url, method: "GET", headers: [], body: null }, {
-      credentials: "include", site: siteOf(documentUrl),
+      credentials: "include", site,
+    }, {
+      priority: PRIORITY[kind] ?? PRIORITY.metadata,
+      onResponse: async (response, finalUrl) => {
+        const contentLength = Number(response.headers.get("content-length"));
+        try {
+          emit({
+            type: "head",
+            ok: response.status >= 200 && response.status <= 299,
+            status: response.status,
+            statusText: response.statusText ?? "",
+            url: finalUrl,
+            contentType: response.headers.get("content-type") ?? "",
+            contentLength: Number.isFinite(contentLength) ? contentLength : null,
+          });
+          const reader = response.body?.getReader?.();
+          if (!reader) {
+            emit({ type: "end" });
+            return { streamed: true };
+          }
+          let total = 0;
+          for (;;) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            if (!value?.byteLength) continue;
+            total += value.byteLength;
+            if (total > MAX_BODY_BYTES) {
+              emit({ type: "error", error: "Response body too large" });
+              await reader.cancel().catch(() => {});
+              return { streamed: true };
+            }
+            const copy = new Uint8Array(value.byteLength);
+            copy.set(value);
+            emit({ type: "chunk", data: copy });
+          }
+          emit({ type: "end" });
+        } catch (error) {
+          emit({ type: "error", error: String(error?.message ?? error) });
+        }
+        return { streamed: true };
+      },
     });
   }
 
@@ -111,7 +242,7 @@ export class NetworkService {
    *   redirect?: "follow" | "error" | "manual" }} request
    * @param {string} documentUrl the requesting document (controller's record)
    */
-  async pageFetch(request, documentUrl) {
+  async pageFetch(request, documentUrl, { signal, onChunk = null } = {}) {
     const origin = new URL(documentUrl).origin;
     const url = new URL(request.url);
     const method = String(request.method ?? "GET").toUpperCase();
@@ -127,26 +258,40 @@ export class NetworkService {
     if (mode === "no-cors" && !SIMPLE_METHODS.has(method)) throw new TypeError(`${method} is not allowed in no-cors mode`);
 
     const sendCredentials = credentials === "include" || (credentials === "same-origin" && sameOrigin);
-    const context = { credentials: sendCredentials ? "include" : "omit", site: siteOf(documentUrl), origin };
+    const context = { credentials: sendCredentials ? "include" : "omit", site: siteOf(documentUrl), origin, referrer: documentUrl };
+    const stream = onChunk ? (response, finalUrl, redirected, type, responseHeaders = [...response.headers]) =>
+      this.#streamResult(response, finalUrl, redirected, type, responseHeaders, onChunk) : null;
 
     if (sameOrigin) {
       return this.#send({ url: url.href, method, headers, body: request.body ?? null }, context, {
-        redirect: request.redirect ?? "follow", corsOrigin: null,
+        redirect: request.redirect ?? "follow", corsOrigin: null, priority: PRIORITY.fetch, signal,
+        onResponse: stream ? (response, finalUrl, redirected) => stream(response, finalUrl, redirected, "basic") : null,
       });
     }
     if (mode === "no-cors") {
       const response = await this.#send({ url: url.href, method, headers: headers.filter(isSafelistedHeader), body: request.body ?? null },
-        context, { redirect: "follow", corsOrigin: null });
+        context, { redirect: "follow", corsOrigin: null, priority: PRIORITY.fetch, signal });
       return { ...response, type: "opaque", status: 0, statusText: "", url: "", headers: [], body: new Uint8Array(0), redirected: false };
     }
     // CORS: preflight unless the request is "simple" (Fetch §4.8).
     const needsPreflight = !SIMPLE_METHODS.has(method) || headers.some((header) => !isSafelistedHeader(header));
     if (needsPreflight) await this.#preflight(url, method, headers, origin, context);
     const response = await this.#send({ url: url.href, method, headers, body: request.body ?? null }, context, {
-      redirect: request.redirect ?? "follow", corsOrigin: origin,
+      redirect: request.redirect ?? "follow", corsOrigin: origin, priority: PRIORITY.fetch, signal,
+      onResponse: stream ? async (incoming, finalUrl, redirected) => {
+        const raw = [...incoming.headers];
+        if (!corsAllowed(raw, origin, context.credentials === "include")) return null;
+        const exposed = new Set((header(raw, "access-control-expose-headers") ?? "")
+          .split(",").map((name) => name.trim().toLowerCase()).filter(Boolean));
+        const exposeAll = exposed.has("*") && context.credentials !== "include";
+        const visible = raw.filter(([name]) => SAFELISTED_RESPONSE_HEADERS.has(name) || exposed.has(name) || exposeAll);
+        return stream(incoming, finalUrl, redirected, "cors", visible);
+      } : null,
     });
+    if (response.streaming) return response;
     const allowed = corsAllowed(response.rawHeaders, origin, context.credentials === "include");
     if (!allowed) throw new TypeError(`CORS: ${url.href} did not allow origin ${origin}`);
+    if (response.type === "opaqueredirect") return response;
     const exposed = new Set((header(response.rawHeaders, "access-control-expose-headers") ?? "")
       .split(",").map((name) => name.trim().toLowerCase()).filter(Boolean));
     const exposeAll = exposed.has("*") && context.credentials !== "include";
@@ -159,17 +304,23 @@ export class NetworkService {
 
   async #preflight(url, method, headers, origin, context) {
     const requestHeaders = headers.filter((entry) => !isSafelistedHeader(entry)).map(([name]) => name).sort();
-    const response = await this.#request(url.href, {
-      method: "OPTIONS",
-      redirect: "manual",
-      headers: {
-        origin,
-        "access-control-request-method": method,
-        ...(requestHeaders.length ? { "access-control-request-headers": requestHeaders.join(",") } : {}),
-        ...(this.#userAgent ? { "user-agent": this.#userAgent } : {}),
-      },
-    });
-    await response.arrayBuffer().catch(() => {});
+    const release = await this.#hosts.acquire(url.href, PRIORITY.fetch);
+    let response;
+    try {
+      response = await this.#request(url.href, {
+        method: "OPTIONS",
+        redirect: "manual",
+        headers: {
+          origin,
+          "access-control-request-method": method,
+          ...(requestHeaders.length ? { "access-control-request-headers": requestHeaders.join(",") } : {}),
+          ...(this.#userAgent ? { "user-agent": this.#userAgent } : {}),
+        },
+      });
+      await response.arrayBuffer().catch(() => {});
+    } finally {
+      release();
+    }
     const raw = [...response.headers];
     if (response.status < 200 || response.status > 299 || !corsAllowed(raw, origin, context.credentials === "include")) {
       throw new TypeError(`CORS preflight for ${url.href} was rejected`);
@@ -191,43 +342,67 @@ export class NetworkService {
     return this.#resolver ? fetchResolved(this.#fetch, this.#resolver, url, init) : this.#fetch(url, init);
   }
 
-  /** Sends a request, following redirects by hand so cookies apply to every hop. */
-  async #send(request, context, { redirect = "follow", corsOrigin = null, onResponse = null } = {}) {
+  /**
+   * Sends a request, following redirects by hand so cookies apply to every hop.
+   * Each hop holds one of its host's request slots until its body is read.
+   */
+  async #send(request, context, {
+    redirect = "follow", corsOrigin = null, onResponse = null, priority = PRIORITY.metadata, signal = undefined,
+  } = {}) {
     let { url, method, body } = request;
     const baseHeaders = request.headers;
     let redirected = false;
     for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
       const headers = new Headers(baseHeaders);
-      if (this.#userAgent) headers.set("user-agent", this.#userAgent);
+      if (this.#userAgent) {
+        headers.set("user-agent", this.#userAgent);
+        const chrome = /(?:Chrome|Chromium)\/(\d+)/.exec(this.#userAgent)?.[1];
+        if (chrome) {
+          headers.set("sec-ch-ua", `"Not:A-Brand";v="99", "Chromium";v="${chrome}", "Google Chrome";v="${chrome}"`);
+          headers.set("sec-ch-ua-mobile", /\bMobile\b/.test(this.#userAgent) ? "?1" : "?0");
+          headers.set("sec-ch-ua-platform", `"${/Android/.test(this.#userAgent) ? "Android" : /Windows/.test(this.#userAgent) ? "Windows" : /Macintosh/.test(this.#userAgent) ? "macOS" : "Linux"}"`);
+        }
+      }
       if (corsOrigin) headers.set("origin", corsOrigin);
+      if (context.referrer && !headers.has("referer")) {
+        const from = new URL(context.referrer);
+        const target = new URL(url);
+        const downgrade = from.protocol === "https:" && target.protocol === "http:";
+        if (!downgrade) headers.set("referer", from.origin === target.origin ? withoutFragment(from.href) : `${from.origin}/`);
+      }
       if (context.credentials === "include") {
         const cookie = this.#cookies.header(url, {
           site: context.site, topLevelNavigation: Boolean(context.topLevelNavigation), method,
         });
         if (cookie) headers.set("cookie", cookie);
       }
-      const response = await this.#request(url, { method, headers, body, redirect: "manual" });
-      if (context.credentials === "include") this.#cookies.store(url, response.headers.getSetCookie?.() ?? []);
-      const location = response.headers.get("location");
-      if ([301, 302, 303, 307, 308].includes(response.status) && location) {
-        await response.arrayBuffer().catch(() => {});
-        if (redirect === "error") throw new TypeError("Redirect was not allowed");
-        if (redirect === "manual") return this.#result(response, url, redirected, "opaqueredirect");
-        const next = new URL(location, url);
-        if (!["http:", "https:"].includes(next.protocol)) throw new TypeError(`Redirect to ${next.protocol} is not allowed`);
-        if (response.status === 303 || ((response.status === 301 || response.status === 302) && method === "POST")) {
-          method = method === "HEAD" ? "HEAD" : "GET";
-          body = null;
+      const release = await this.#hosts.acquire(url, priority);
+      try {
+        const response = await this.#request(url, { method, headers, body, redirect: "manual", signal });
+        if (context.credentials === "include") this.#cookies.store(url, response.headers.getSetCookie?.() ?? []);
+        const location = response.headers.get("location");
+        if ([301, 302, 303, 307, 308].includes(response.status) && location) {
+          await response.arrayBuffer().catch(() => {});
+          if (redirect === "error") throw new TypeError("Redirect was not allowed");
+          if (redirect === "manual") return opaqueRedirect(response);
+          const next = new URL(location, url);
+          if (!["http:", "https:"].includes(next.protocol)) throw new TypeError(`Redirect to ${next.protocol} is not allowed`);
+          if (response.status === 303 || ((response.status === 301 || response.status === 302) && method === "POST")) {
+            method = method === "HEAD" ? "HEAD" : "GET";
+            body = null;
+          }
+          url = next.href;
+          redirected = true;
+          continue;
         }
-        url = next.href;
-        redirected = true;
-        continue;
-      }
-      if (onResponse) {
-        const handled = await onResponse(response, url);
-        if (handled) return handled;
+        if (onResponse) {
+          const handled = await onResponse(response, url, redirected);
+          if (handled) return handled;
+        }
+        return await this.#result(response, url, redirected, "basic");
+      } finally {
+        release();
       }
-      return this.#result(response, url, redirected, "basic");
     }
     throw new TypeError("Too many redirects");
   }
@@ -250,6 +425,47 @@ export class NetworkService {
       body: buffer,
     };
   }
+
+  async #streamResult(response, url, redirected, type, visibleHeaders, onChunk) {
+    const rawHeaders = [...response.headers];
+    const result = {
+      ok: response.status >= 200 && response.status <= 299,
+      status: response.status, statusText: response.statusText, url, redirected, type,
+      headers: visibleHeaders.filter(([name]) => name !== "set-cookie" && name !== "set-cookie2"),
+      contentType: response.headers.get("content-type") ?? "",
+    };
+    onChunk({ type: "head", result });
+    const reader = response.body?.getReader?.();
+    if (reader) {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value?.byteLength) onChunk({ type: "chunk", data: new Uint8Array(value) });
+      }
+    }
+    onChunk({ type: "end" });
+    return { ...result, rawHeaders, body: new Uint8Array(0), streaming: true };
+  }
+}
+
+/**
+ * The opaque-redirect filtered response a `redirect: "manual"` fetch gets
+ * (Fetch §2.2.6): status 0 and no headers or body for the page. The redirect's
+ * body was already drained to free the connection; the raw headers stay for
+ * the CORS check.
+ */
+function opaqueRedirect(response) {
+  return {
+    ok: false, status: 0, statusText: "", url: "", redirected: false, type: "opaqueredirect",
+    rawHeaders: [...response.headers], headers: [], contentType: "", body: new Uint8Array(0),
+  };
+}
+
+/** A URL without its fragment, as a Referer carries it. */
+function withoutFragment(href) {
+  const url = new URL(href);
+  url.hash = "";
+  return url.href;
 }
 
 function isSafelistedHeader([name, value]) {
@@ -262,6 +478,20 @@ function header(rawHeaders, name) {
   return rawHeaders.find(([key]) => key === name)?.[1] ?? null;
 }
 
+/** Freshness and validator data used by the in-process HTTP cache. */
+function cachePolicy(rawHeaders, now = Date.now()) {
+  const control = (header(rawHeaders, "cache-control") ?? "").toLowerCase();
+  if (/(?:^|,)\s*no-store(?:\s|,|$)/.test(control)) return { cacheable: false, expires: 0, etag: null };
+  const age = control.match(/(?:^|,)\s*max-age\s*=\s*(\d+)/)?.[1];
+  const expiresHeader = header(rawHeaders, "expires");
+  const expires = age !== undefined
+    ? now + Number(age) * 1000
+    : expiresHeader && Number.isFinite(Date.parse(expiresHeader)) ? Date.parse(expiresHeader)
+      : /(?:^|,)\s*immutable(?:\s|,|$)/.test(control) ? now + 365 * 24 * 60 * 60 * 1000 : 0;
+  const etag = header(rawHeaders, "etag");
+  return { cacheable: expires > now || etag !== null, expires, etag };
+}
+
 /** Fetch §4.9 CORS check. */
 function corsAllowed(rawHeaders, origin, withCredentials) {
   const allowOrigin = header(rawHeaders, "access-control-allow-origin");
@@ -270,3 +500,53 @@ function corsAllowed(rawHeaders, origin, withCredentials) {
   if (allowOrigin !== origin) return false;
   return !withCredentials || header(rawHeaders, "access-control-allow-credentials") === "true";
 }
+
+/**
+ * Limits the requests in flight to each host (scheme, host and port). A burst
+ * of requests that each open a connection slows every transfer, and servers
+ * reset some; with a few connections kept alive and reused, a page's
+ * resources arrive sooner. Waiting requests go by priority, then in order.
+ */
+class HostThrottle {
+  #limit;
+  #hosts = new Map();
+
+  constructor(limit) {
+    this.#limit = limit;
+  }
+
+  /** Resolves with a function that gives the slot back (once) when the request is done. */
+  acquire(url, priority) {
+    let key;
+    try {
+      const target = new URL(url);
+      key = `${target.protocol}//${target.host}`;
+    } catch {
+      key = String(url);
+    }
+    let host = this.#hosts.get(key);
+    if (!host) this.#hosts.set(key, host = { active: 0, waiting: [] });
+    const release = this.#releaser(key, host);
+    if (host.active < this.#limit) {
+      host.active++;
+      return Promise.resolve(release);
+    }
+    return new Promise((resolve) => {
+      const entry = { priority, start: () => resolve(release) };
+      const index = host.waiting.findIndex((other) => other.priority > priority);
+      if (index === -1) host.waiting.push(entry);
+      else host.waiting.splice(index, 0, entry);
+    });
+  }
+
+  #releaser(key, host) {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      const next = host.waiting.shift();
+      if (next) next.start(); // the slot passes on
+      else if (--host.active === 0) this.#hosts.delete(key);
+    };
+  }
+}