buninu-browser 0.2.1 → 0.2.3

package/test/download.test.js

@@ -19,6 +19,8 @@ beforeAll(() => {
         + '<a id="attachment" href="/attachment">attachment</a>'
         + '<a id="data" href="data:text/plain,hello%20data" download="data.txt">data</a>'
         + '<a id="blob" download="blob.txt">blob</a>'
+        + '<a id="toc" href="#contents">contents</a><h2 id="contents">Contents</h2>'
+        + '<script>document.getElementById("toc").addEventListener("click", event => { event.preventDefault(); location.href = event.currentTarget.href; });</script>'
         + '<script>document.getElementById("blob").href = URL.createObjectURL(new Blob(["blob bytes"]));</script>',
       { headers: { "content-type": "text/html" } });
       if (path === "/plain") return new Response("original bytes", { headers: { "content-type": "text/plain" } });
@@ -74,6 +76,12 @@ test("clicked downloads save files and leave the current page in place", async (
     await click("#attachment");
     expect(readFileSync(join(dir, "photo.jpg"), "utf8")).toBe("photo bytes");
     expect(browser.context.resourceContent()?.url).toBe(`${origin}/links`);
+    expect(await browser.context.evaluate("[location.href, document.URL, document.baseURI, document.getElementById('toc').href]"))
+      .toEqual([`${origin}/links`, `${origin}/links`, `${origin}/links`, `${origin}/links#contents`]);
+    await click("#toc");
+    expect(await browser.context.evaluate("[location.href, document.URL]"))
+      .toEqual([`${origin}/links#contents`, `${origin}/links#contents`]);
+    expect(events.filter((item) => item.event === "willBegin")).toHaveLength(4);
     await click("#data");
     expect(readFileSync(join(dir, "data.txt"), "utf8")).toBe("hello data");
     await browser.context.evaluate("document.getElementById('blob').click()");
@@ -151,6 +159,41 @@ test("CDP Page.getResourceContent returns the bytes base64-encoded", async () =>
   }
 });
 
+test("CDP downloads the committed document after a navigation outside CDP", async () => {
+  const { CdpServer } = await import("../lib/cdp-server.js");
+  const browser = await createBrowser({ spareRenderer: false });
+  const cdp = CdpServer.create(browser.context).listen(0, "127.0.0.1");
+  let socket;
+  try {
+    const target = await (await fetch(`http://127.0.0.1:${cdp.port}/json/new?about:blank`, { method: "PUT" })).json();
+    socket = new WebSocket(target.webSocketDebuggerUrl);
+    await new Promise(resolve => socket.addEventListener("open", resolve, { once: true }));
+    let nextId = 0;
+    const call = (method, params = {}) => new Promise(resolve => {
+      const id = ++nextId;
+      const listener = ({ data }) => {
+        const message = JSON.parse(data);
+        if (message.id !== id) return;
+        socket.removeEventListener("message", listener);
+        resolve(message);
+      };
+      socket.addEventListener("message", listener);
+      socket.send(JSON.stringify({ id, method, params }));
+    });
+    await browser.context.navigate(`http://127.0.0.1:${server.port}/start`);
+    const { result: { frameTree } } = await call("Page.getFrameTree");
+    expect(frameTree.frame.url).toBe(`http://127.0.0.1:${server.port}/page`);
+    expect(frameTree.frame.mimeType).toBe("text/html");
+    const result = await call("Page.getResourceContent", { frameId: frameTree.frame.id, url: frameTree.frame.url });
+    expect(result.error).toBeUndefined();
+    expect(Buffer.from(result.result.content, "base64")).toEqual(Buffer.from(BIG5));
+  } finally {
+    socket?.close();
+    cdp.stop(true);
+    browser.close();
+  }
+});
+
 test("CDP download behavior controls the directory and emits completion events", async () => {
   const { CdpServer } = await import("../lib/cdp-server.js");
   const dir = mkdtempSync(join(tmpdir(), "buninu-cdp-download-"));

package/test/fixtures/media-sync.js

@@ -0,0 +1,57 @@
+// Isolated because host scripting installs browser globals in this process.
+import { strict as assert } from "node:assert";
+import { createPageRenderer } from "../../lib/renderer/page-renderer.js";
+
+const sleep = Bun.sleep;
+const success = () => process.stdout.write("media clock integration passed\n");
+let output, frames = 0, samples = 0;
+const errors = [];
+const renderer = await createPageRenderer({
+  fetchResource: async () => ({ ok: true, body: new Uint8Array([1]), contentType: "video/mp4" }),
+  reportError: error => errors.push(String(error)),
+  videoDecoder: {
+    probe: async () => ({ duration: 10, video: { width: 2, height: 2 }, audio: { sampleRate: 1000 } }),
+    decode: async () => ({ width: 2, height: 2, fps: 10,
+      nextFrame(w, h) { frames++; return new Uint8Array(w * h * 4); }, seek() {}, close() {} }),
+    decodeAudio: async () => ({ sampleRate: 1000, channels: 1,
+      nextSamples() { return new Float32Array(100); }, close() {} }),
+  },
+  audio: {
+    open(options, listener) { output = listener; return 1; },
+    write(id, bytes) { samples += bytes.length / 2; },
+    close() { return Promise.resolve(samples * 2); },
+    finish() {},
+  },
+});
+try {
+  renderer.setScripting("host");
+  await renderer.loadDocument({ url: "https://media.test/", source: '<video id="v" src="clip.mp4"></video>', contentType: "text/html" });
+  await renderer.evaluate("document.getElementById('v').play()");
+  output({ event: "request", bytes: 1000 });
+  assert.equal(samples, 500);
+  await sleep(180);
+  assert.equal(await renderer.evaluate("document.getElementById('v').currentTime"), 0,
+    "queued samples are not played samples");
+  const firstFrames = frames;
+  await sleep(180);
+  assert.equal(frames, firstFrames, "video cannot outrun an audio device which hasn't started");
+  output({ event: "timing", seconds: 0.2, sentSeconds: 0.5, sinkSeconds: 0.3 });
+  await sleep(160);
+  assert.equal(await renderer.evaluate("document.getElementById('v').currentTime"), 0.2);
+  const stalledFrames = frames;
+  await sleep(300);
+  assert.equal(frames, stalledFrames, "no clock advance through missing feedback/network starvation");
+  assert.equal(await renderer.evaluate("document.getElementById('v').currentTime"), 0.2);
+  output({ event: "timing", seconds: 0.4, sentSeconds: 0.5, sinkSeconds: 0.1 });
+  await sleep(160);
+  assert.equal(await renderer.evaluate("document.getElementById('v').currentTime"), 0.4);
+  assert.ok(frames > stalledFrames, "frames resume only with measured audio progress");
+  await renderer.evaluate("document.getElementById('v').pause()");
+  output({ event: "timing", seconds: 0.5, sentSeconds: 0.5, sinkSeconds: 0 });
+  assert.equal(await renderer.evaluate("document.getElementById('v').currentTime"), 0.4,
+    "late feedback from a closed stream cannot move a paused element");
+  assert.deepEqual(errors, []);
+  success();
+} finally {
+  renderer.dispose();
+}

package/test/happy-dom-platform-adapters.test.js

@@ -1,12 +1,16 @@
 import { expect, test } from "bun:test";
 import imageSize from "../lib/happy-dom/image-size-adapter.js";
 import MIMEType from "../lib/happy-dom/mime-type-adapter.js";
+import { parseHTMLDocument } from "../lib/happy-dom/parser.js";
 
 const ONE_PIXEL_PNG = Buffer.from(
   "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M/wHwAF/gL+3MxZ5wAAAABJRU5ErkJggg==",
   "base64",
 );
 
+// A 2x3 PNG.
+const SMALL_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAIAAAADCAIAAAA2iEnWAAAAEElEQVR4nGP4z8AARAwoFABE0AX7pM/egAAAAABJRU5ErkJggg==";
+
 test("MIME adapter supplies the FileReader surface without whatwg-mimetype", () => {
   expect(String(MIMEType.parse("Text/Plain; charset=UTF-8"))).toBe("text/plain");
   expect(MIMEType.parse("not a mime type")).toBeNull();
@@ -16,3 +20,24 @@ test("image size adapter uses Bun.Image metadata", async () => {
   expect(await imageSize(ONE_PIXEL_PNG)).toEqual({ width: 1, height: 1 });
 });
 
+
+test("an image whose src changes while its size is read reports only the latest image", async () => {
+  const { document, window } = parseHTMLDocument("<img>");
+  const image = document.querySelector("img");
+  const events = [];
+  image.addEventListener("load", () => events.push(`load ${image.naturalWidth}x${image.naturalHeight}`));
+  image.addEventListener("error", () => events.push("error"));
+  image.setAttribute("src", `data:image/png;base64,${ONE_PIXEL_PNG.toString("base64")}`);
+  image.setAttribute("src", `data:image/png;base64,${SMALL_PNG}`);
+  // Not complete until its size is known.
+  expect(image.complete).toBeFalse();
+  await Bun.sleep(100);
+  expect(events).toEqual(["load 2x3"]);
+  expect(image.complete).toBeTrue();
+  // A removed src drops the image being read.
+  image.setAttribute("src", `data:image/png;base64,${ONE_PIXEL_PNG.toString("base64")}`);
+  image.removeAttribute("src");
+  await Bun.sleep(100);
+  expect([events.length, image.naturalWidth]).toEqual([1, 0]);
+  window.happyDOM.abort();
+});

package/test/headless-shell.test.js

@@ -126,6 +126,8 @@ test("top-level shell exposes the parsed document through Bun.WebView", async ()
     await view.cdp("Input.dispatchMouseEvent", { type: "mouseReleased", x: demoKey.x + demoKey.width / 2,
       y: demoKey.y + demoKey.height - 15, button: "left", clickCount: 1 });
     expect(await view.evaluate("document.activeElement.id")).toBe("buninu-piano-input");
+    await view.cdp("Input.insertText", { text: "jkl JKL!" });
+    expect(await view.evaluate("document.activeElement.value")).toBe("");
     await view.resize(480, 240);
     await view.navigate(`http://127.0.0.1:${fixture.port}/`);
 
@@ -198,12 +200,32 @@ test("top-level shell exposes the parsed document through Bun.WebView", async ()
     await view.cdp("Input.dispatchMouseEvent", { type: "mousePressed", x: pianoRect.x + 10, y: pianoRect.y + 10, button: "left", clickCount: 1 });
     await view.cdp("Input.dispatchMouseEvent", { type: "mouseReleased", x: pianoRect.x + 10, y: pianoRect.y + 10, button: "left", clickCount: 1 });
     await view.cdp("Input.insertText", { text: "j" });
+    await view.cdp("Input.insertText", { text: "jk lJK!中" });
+    for (const key of ["j", "k", " "]) {
+      await view.cdp("Input.dispatchKeyEvent", { type: "rawKeyDown", key, autoRepeat: true });
+      await view.cdp("Input.dispatchKeyEvent", { type: "keyUp", key });
+    }
     await view.cdp("Input.dispatchKeyEvent", { type: "rawKeyDown", key: "k", code: "KeyK" });
     await view.cdp("Input.dispatchKeyEvent", { type: "keyUp", key: "k", code: "KeyK" });
+    for (const type of ["rawKeyDown", "char", "keyUp"]) {
+      for (const key of ["j", "k", "l"]) {
+        await view.cdp("Input.dispatchKeyEvent", { type, key, code: `Key${key.toUpperCase()}`, text: type === "char" ? key : undefined });
+      }
+    }
     expect(await view.evaluate("document.getElementById('buninu-piano-input').value")).toBe("");
     await view.navigate(`http://127.0.0.1:${fixture.port}/`);
 
     expect(await view.evaluate("scrollY")).toBe(0);
+    await view.evaluate(`window.spaceKeys=[];document.addEventListener('keydown',event=>{
+      if(event.keyCode===32){event.preventDefault();spaceKeys.push([event.keyCode,event.which]);}
+    });`);
+    for(let i=0;i<6;i++) {
+      for(const type of ['rawKeyDown','char','keyUp']) {
+        await view.cdp('Input.dispatchKeyEvent', {type,key:' ',code:'Space',windowsVirtualKeyCode:32,text:type==='char'?' ':undefined});
+      }
+    }
+    expect(await view.evaluate('spaceKeys')).toEqual(Array.from({length:6},()=>[32,32]));
+    expect(await view.evaluate('scrollY')).toBe(0);
     await view.cdp("Input.dispatchMouseEvent", {
       type: "mouseWheel",
       x: 100,
@@ -351,7 +373,7 @@ test("a client may set up and navigate before the first renderer is up", async (
     fetched++;
     return new Response("<!doctype html><title>early</title><p>x</p>", { headers: { "content-type": "text/html" } });
   } });
-  const browser = await createBrowser({ spareRenderer: false, waitForRenderer: false });
+  const browser = await createBrowser({ spareRenderer: false, waitForRenderer: false, webkit: false });
   let ready = false;
   browser.ready.then(() => { ready = true; });
   try {

package/test/hit-test.test.js

@@ -1,6 +1,7 @@
 import { expect, test } from "bun:test";
 import { parseHTMLDocument } from "../lib/happy-dom/parser.js";
-import { elementBounds, hitTest, interactiveRegions } from "../lib/input/hit-test.js";
+import { elementAtPoint, elementBounds, hitTest, interactiveRegions } from "../lib/input/hit-test.js";
+import { buildDisplayList } from "../lib/paint/display-list.js";
 import { layoutText } from "../lib/layout/text-layout.js";
 import { RenderTreeBuilder } from "../lib/render-tree/index.js";
 import { StyleEngine } from "../lib/style/computed-style.js";
@@ -84,3 +85,26 @@ test("hidden and pointer-events: none boxes let clicks through, but their opted-
   expect(regions.map((region) => region.element.getAttribute("href") ?? region.element.tagName)).toEqual(["open", "shown", "plain"]);
   window.happyDOM.abort();
 });
+
+test("pointer events target the topmost element painted at a point, whatever its tag", () => {
+  const { document, window } = parseHTMLDocument(`<body style="margin:0">
+    <table><tr><td id="cell" style="width:100px;height:50px"><span id="label">tile</span></td></tr></table>
+    <div id="under" style="height:40px"></div>
+    <div id="over" style="position:absolute;top:60px;left:0;width:50px;height:20px"></div>
+    <div id="ghost" style="position:absolute;top:60px;left:50px;width:50px;height:20px;pointer-events:none"></div>
+  </body>`);
+  const styles = new StyleEngine().compute(document);
+  const tree = new RenderTreeBuilder().build(document, styles);
+  const layout = layoutText(tree, { x: 0, y: 0, width: 400, lineHeight: 20, measureText: (text) => text.length * 10, fontMetrics: () => ({ ascent: 16, height: 20 }) });
+  const displayList = buildDisplayList(layout, tree);
+  const at = (x, y) => elementAtPoint(tree, displayList, x, y, { x: 0, y: 0 })?.id ?? null;
+  const label = layout.fragments.flatMap((fragment) => fragment.runs.map((run) => ({ run, fragment })))
+    .find(({ run }) => tree.nodesById.get(run.nodeId)?.domNode?.parentElement?.id === "label");
+  // Text hits its element; the rest of the cell hits the cell.
+  expect(at(label.run.x + 1, label.fragment.y + 1)).toBe("label");
+  expect(at(label.run.x + label.run.width + 20, label.fragment.y + 1)).toBe("cell");
+  // A positioned box paints over the in-flow one; pointer-events:none passes through.
+  expect(at(10, 65)).toBe("over");
+  expect(at(60, 65)).toBe("under");
+  window.happyDOM.abort();
+});

package/test/media-playback-events.test.js

@@ -0,0 +1,22 @@
+import { expect, test } from 'bun:test';
+import { playbackEvent } from '../lib/renderer/media-playback-events.js';
+
+test('playback notifications distinguish unpaused, advancing and starved states', () => {
+  const state = {playing:true}, events=[];
+  const dispatch=(_state,type)=>events.push(type);
+  for(const phase of ['play','playing','playing','waiting','waiting','playing','playing','pause','play','playing']) {
+    playbackEvent(state,phase,dispatch);
+  }
+  expect(events).toEqual(['play','playing','waiting','canplay','playing','pause','play','playing']);
+});
+
+test('pausing in canplay does not report playback resumed', () => {
+  const state={playing:true}, events=[];
+  const dispatch=(_state,type)=>{
+    events.push(type);
+    if(type==='canplay') {state.playing=false;playbackEvent(state,'pause',dispatch);}
+  };
+  playbackEvent(state,'waiting',dispatch);
+  playbackEvent(state,'playing',dispatch);
+  expect(events).toEqual(['waiting','canplay','pause']);
+});

package/test/media-source.test.js

@@ -0,0 +1,156 @@
+import { expect, test } from "bun:test";
+import { createMediaSourceScope } from "../lib/renderer/media-source.js";
+
+function scope(options = {}) {
+  const tasks = [];
+  const media = createMediaSourceScope({
+    origin: "https://page.test",
+    schedule: (task) => tasks.push(task),
+    DOMException,
+    ...options,
+  });
+  const flush = () => {
+    while (tasks.length) tasks.shift()();
+  };
+  return { media, flush };
+}
+
+function openBuffer(context) {
+  const source = new context.media.MediaSource();
+  source.attach("blob:https://page.test/media");
+  context.flush();
+  return { source, buffer: source.addSourceBuffer('video/mp4; codecs="avc1.4d401e"') };
+}
+
+function box(type, ...parts) {
+  const size = 8 + parts.reduce((sum, part) => sum + part.byteLength, 0);
+  const bytes = new Uint8Array(size);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, size);
+  for (let index = 0; index < 4; index++) bytes[4 + index] = type.charCodeAt(index);
+  let offset = 8;
+  for (const part of parts) {
+    bytes.set(part, offset);
+    offset += part.byteLength;
+  }
+  return bytes;
+}
+
+function fragmentedMp4Pieces() {
+  const mdhd = new Uint8Array(20);
+  new DataView(mdhd.buffer).setUint32(12, 1000);
+  const init = box("moov", box("trak", box("mdia", box("mdhd", mdhd))));
+  const segment = (base) => {
+    const tfhd = new Uint8Array(12);
+    tfhd[3] = 8; // default_sample_duration_present
+    new DataView(tfhd.buffer).setUint32(4, 1);
+    new DataView(tfhd.buffer).setUint32(8, 1000);
+    const tfdt = new Uint8Array(8);
+    new DataView(tfdt.buffer).setUint32(4, base);
+    const trun = new Uint8Array(8);
+    new DataView(trun.buffer).setUint32(4, 5);
+    return box("moof", box("traf", box("tfhd", tfhd), box("tfdt", tfdt), box("trun", trun)));
+  };
+  return [init, segment(0), segment(5000)];
+}
+
+test("SourceBuffer.abort is harmless while idle and cancels a pending append", () => {
+  const context = scope();
+  const { buffer } = openBuffer(context);
+  expect(() => buffer.abort()).not.toThrow();
+
+  const events = [];
+  buffer.addEventListener("abort", () => events.push("abort"));
+  buffer.addEventListener("updateend", () => events.push("updateend"));
+  buffer.appendBuffer(new Uint8Array([1, 2, 3]));
+  buffer.abort();
+  context.flush();
+
+  expect(buffer.updating).toBe(false);
+  expect(buffer._pipe.size).toBe(0);
+  expect(events).toEqual(["abort", "updateend"]);
+});
+
+test("removing an old buffered prefix releases append quota", () => {
+  const context = scope({ appendQuota: 10 });
+  const { source, buffer } = openBuffer(context);
+  buffer.appendBuffer(box("mdat", new Uint8Array(2)));
+  context.flush();
+  source.noteBuffered(10);
+
+  expect(() => buffer.appendBuffer(new Uint8Array(1))).toThrow("SourceBuffer is full");
+  buffer.remove(0, 5);
+  context.flush();
+  expect(buffer.buffered.length).toBe(1);
+  expect(buffer.buffered.start(0)).toBe(5);
+  expect(buffer.buffered.end(0)).toBe(10);
+  expect(() => buffer.appendBuffer(new Uint8Array(5))).not.toThrow();
+  context.flush();
+  expect(buffer.updating).toBe(false);
+});
+
+test("fragmented MP4 buffered end follows appended segments, not presentation duration", () => {
+  const context = scope();
+  const { source, buffer } = openBuffer(context);
+  const [init, first, second] = fragmentedMp4Pieces();
+  buffer.appendBuffer(init);
+  context.flush();
+  // Probing an init segment can expose the full presentation duration before
+  // the first media fragment supplies the actual buffered timeline.
+  source.noteBuffered(700);
+  for (const bytes of [first, second]) {
+    buffer.appendBuffer(bytes);
+    context.flush();
+  }
+  expect(buffer.buffered.length).toBe(1);
+  expect(buffer.buffered.end(0)).toBe(10);
+});
+
+test("WebM buffered end follows Cluster timecodes, not presentation duration", () => {
+  const context = scope();
+  const source = new context.media.MediaSource();
+  source.attach("blob:https://page.test/audio");
+  context.flush();
+  const buffer = source.addSourceBuffer('audio/webm; codecs="opus"');
+  // Cluster timecode 0, one SimpleBlock at +1000 ms, with a dummy payload.
+  buffer.appendBuffer(Uint8Array.from([
+    0x1f, 0x43, 0xb6, 0x75, 0x8a,
+    0xe7, 0x81, 0x00,
+    0xa3, 0x85, 0x81, 0x03, 0xe8, 0x00, 0x00,
+  ]));
+  context.flush();
+  source.noteBuffered(700);
+  expect(buffer.buffered.end(0)).toBeCloseTo(1.02, 5);
+});
+
+test("a media element reports the intersection of separate audio and video buffers", () => {
+  const context = scope();
+  const { source, buffer: video } = openBuffer(context);
+  const audio = source.addSourceBuffer('audio/webm; codecs="opus"');
+  video.noteEnd(5);
+  audio.noteEnd(8);
+  expect(source.bufferedEnd()).toBe(5);
+});
+
+test("a media segment appended again is not concatenated twice, while gaps are still filled", () => {
+  const context = scope();
+  const { buffer } = openBuffer(context);
+  const [init, first, second] = fragmentedMp4Pieces();
+  let updates = 0;
+  buffer.addEventListener("updateend", () => updates++);
+  // The second segment arrives first; the first then fills the gap before it.
+  for (const bytes of [init, second, first]) {
+    buffer.appendBuffer(bytes);
+    context.flush();
+  }
+  const size = buffer._pipe.size;
+  expect(size).toBe(init.byteLength + second.byteLength + first.byteLength);
+  // A player retrying both segments on a slow network.
+  for (const bytes of [first, second]) {
+    buffer.appendBuffer(bytes);
+    context.flush();
+  }
+  expect(buffer._pipe.size).toBe(size);
+  expect(updates).toBe(5);
+  expect(buffer.buffered.end(0)).toBe(10);
+});

package/test/media-sync.test.js

@@ -0,0 +1,12 @@
+import { expect, test } from "bun:test";
+
+test("renderer follows output progress, not wall time or submitted audio", async () => {
+  const child = Bun.spawn([process.execPath, new URL("./fixtures/media-sync.js", import.meta.url).pathname], {
+    stdout: "pipe", stderr: "pipe",
+  });
+  const [out, error, code] = await Promise.all([
+    new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited,
+  ]);
+  expect({ code, error }).toEqual({ code: 0, error: "" });
+  expect(out).toContain("media clock integration passed");
+}, 30_000);

package/test/mobile.test.js

@@ -52,8 +52,8 @@ test("--mobile sends the mobile user agent, ignores overrides and applies touch
   });
 }, 30_000);
 
-test("without --mobile nothing changes: overrides apply and touch rules do not", async () => {
-  const state = await pageState({});
+test("Chromium desktop allows overrides and does not apply touch rules", async () => {
+  const state = await pageState({ webkit: false });
   expect(state).toMatchObject({
     requestUserAgent: "Desktop/1.0 (casty override)",
     navigatorUserAgent: "Desktop/1.0 (casty override)",

package/test/navigation.test.js

@@ -0,0 +1,61 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { createBrowser } from "../lib/headless-shell.js";
+
+let server;
+let browser;
+const posts = [];
+beforeAll(async () => {
+  server = Bun.serve({
+    port: 0,
+    async fetch(request) {
+      const { pathname } = new URL(request.url);
+      const html = (body, init = {}) => new Response(`<!doctype html>${body}`, { ...init, headers: { "content-type": "text/html" } });
+      if (pathname === "/start") return new Response(null, { status: 302, headers: { location: "/dir/form?step=1#top" } });
+      if (pathname === "/dir/form") {
+        // An error status with a page, as some challenge pages come.
+        return html(`<title>form</title><form id="f" action="submit" method="post">
+          <input name="q" value="a b&amp;c"><input type="hidden" name="continue" value="/next"></form>`, { status: 429 });
+      }
+      if (pathname === "/dir/submit") {
+        posts.push({
+          method: request.method,
+          body: await request.text(),
+          type: request.headers.get("content-type"),
+          origin: request.headers.get("origin"),
+          referer: request.headers.get("referer"),
+        });
+        return new Response(null, { status: 303, headers: { location: "/done" } });
+      }
+      if (pathname === "/done") return html(`<title>done ${request.method}</title>`);
+      return new Response("missing", { status: 404 });
+    },
+  });
+  browser = await createBrowser({ spareRenderer: false });
+});
+afterAll(() => {
+  browser?.close();
+  server?.stop(true);
+});
+
+test("a redirected document has the URL it ended on, and its POST form submits there", async () => {
+  const { context } = browser;
+  const origin = `http://127.0.0.1:${server.port}`;
+  await context.navigate(`${origin}/start`);
+  // The final URL, with the request's fragment carried over; relative URLs resolve against it.
+  expect(await context.evaluate(`[location.href, document.baseURI, document.getElementById("f").action]`))
+    .toEqual([`${origin}/dir/form?step=1#top`, `${origin}/dir/form?step=1#top`, `${origin}/dir/submit`]);
+
+  await context.evaluate(`document.getElementById("f").submit()`);
+  const deadline = Date.now() + 10_000;
+  while (await context.title() !== "done GET" && Date.now() < deadline) await Bun.sleep(50);
+  expect(await context.title()).toBe("done GET");
+  expect(posts).toEqual([{
+    method: "POST",
+    body: "q=a+b%26c&continue=%2Fnext",
+    type: "application/x-www-form-urlencoded",
+    origin,
+    referer: `${origin}/dir/form?step=1`,
+  }]);
+  // The 303 after it was followed with a GET, and the document is at its URL.
+  expect(await context.evaluate("location.href")).toBe(`${origin}/done`);
+});

package/test/network-service.test.js

@@ -26,6 +26,8 @@ beforeAll(() => {
           });
         case "/home":
           return new Response("home");
+        case "/moved":
+          return new Response("moved here", { status: 301, headers: { location: "/home", ...cors() } });
         case "/app/deep/set":
           return new Response("ok", { headers: [["set-cookie", "scoped=1"]] });
         case "/api/simple":
@@ -65,6 +67,18 @@ test("follows redirects by hand and stores cookies on every hop", async () => {
   expect(response.headers.some(([name]) => name === "set-cookie")).toBeFalse();
 });
 
+test("a manual redirect gives the page an opaque-redirect response", async () => {
+  seen = [];
+  const network = new NetworkService();
+  const same = await network.pageFetch({ url: local("/moved"), redirect: "manual" }, local("/"));
+  expect(same).toMatchObject({ type: "opaqueredirect", status: 0, url: "", headers: [] });
+  expect(same.body.byteLength).toBe(0);
+  // Cross-origin: the redirect still passes the CORS check.
+  const cross = await network.pageFetch({ url: local(`/moved?allow=${encodeURIComponent(loopback(""))}`), redirect: "manual" }, loopback("/"));
+  expect(cross).toMatchObject({ type: "opaqueredirect", status: 0 });
+  expect(seen.map((entry) => entry.path)).toEqual(["/moved", "/moved"]);
+});
+
 test("applies the default path and SameSite to cross-site requests", async () => {
   seen = [];
   const network = new NetworkService();