buninu-browser 0.2.1 → 0.2.3

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/media/video-keyframe.js

@@ -0,0 +1,29 @@
+// 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) {
+  const seek = time => decoder.seek(Math.max(1, time * 1000));
+  const frame = 1 / (decoder.fps || 30);
+  if (!(seconds >= frame)) { seek(0); return 0; }
+  const probe = time => {
+    seek(time);
+    const pixels = decoder.nextFrame(32, 18);
+    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);
+  let keyframe = seconds;
+  if (target !== null) {
+    let earlier = Math.max(0, seconds - 10);
+    if (earlier > 0 && probe(earlier) !== target) {
+      while (keyframe - earlier > frame) {
+        const middle = (earlier + keyframe) / 2;
+        if (probe(middle) === target) keyframe = middle;
+        else earlier = middle;
+      }
+    } else keyframe = earlier;
+  }
+  seek(keyframe);
+  return keyframe;
+}

package/lib/network/network-service.js

@@ -34,7 +34,7 @@ const SAFELISTED_RESPONSE_HEADERS = new Set([
 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, stylesheet: 1, fetch: 1, script: 2, metadata: 2, image: 3, video: 3, audio: 3 };
+const PRIORITY = { document: 0, iframe: 1, stylesheet: 1, fetch: 1, script: 2, metadata: 2, image: 3, video: 3, audio: 3 };
 
 export class NetworkService {
   #fetch;
@@ -73,8 +73,31 @@ export class NetworkService {
   }
 
   /** 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, priority: PRIORITY.document });
   }
@@ -126,6 +149,60 @@ export class NetworkService {
     }
   }
 
+  /**
+   * 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,
+    }, {
+      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 };
+      },
+    });
+  }
+
   /**
    * A WebSocket opened by page script, using Bun's WebSocket: the handshake
    * carries the document's Origin, the target's cookies (as for an https/http
@@ -165,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();
@@ -181,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, priority: PRIORITY.fetch,
+        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, priority: PRIORITY.fetch });
+        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, priority: PRIORITY.fetch,
+      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";
@@ -255,14 +346,30 @@ export class NetworkService {
    * 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 } = {}) {
+  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,
@@ -271,13 +378,13 @@ export class NetworkService {
       }
       const release = await this.#hosts.acquire(url, priority);
       try {
-        const response = await this.#request(url, { method, headers, body, redirect: "manual" });
+        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 await this.#result(response, url, redirected, "opaqueredirect");
+          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")) {
@@ -289,7 +396,7 @@ export class NetworkService {
           continue;
         }
         if (onResponse) {
-          const handled = await onResponse(response, url);
+          const handled = await onResponse(response, url, redirected);
           if (handled) return handled;
         }
         return await this.#result(response, url, redirected, "basic");
@@ -318,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]) {
@@ -402,4 +550,3 @@ class HostThrottle {
     };
   }
 }
-