buninu-browser 0.2.2 → 0.2.3

package/test/piano-input.test.js

@@ -0,0 +1,44 @@
+import { test, expect } from "bun:test";
+import { handlePianoInput } from "../lib/renderer/piano-input.js";
+
+const input = { getAttribute: () => "buninu-piano-input" };
+
+test("CDP raw keydown uses the physical key even with an empty text field", () => {
+  const notes = [];
+  const play = n => notes.push(n);
+  for (let i = 0; i < 3; i++) {
+    expect(handlePianoInput(input, { key: " ", code: "Space", text: "", modifiers: 0, repeat: false }, play)).toBe(true);
+  }
+  expect(notes).toEqual([69, 69, 69]);
+  expect(handlePianoInput(input, { key: "F1", code: "F1", text: "" }, play)).toBe(true);
+  expect(notes.at(-1)).toBe(38);
+  expect(handlePianoInput(input, { key: " ", code: "Space", text: " ", repeat: true }, play)).toBe(true);
+  expect(notes).toHaveLength(4);
+  expect(handlePianoInput(input, { key: "Tab", code: "Tab", text: "" }, play)).toBe(false);
+});
+
+test("piano consumes batched terminal/IME text and plays every mapped note", () => {
+  const notes = [];
+  expect(handlePianoInput(input, { text: "jk L!中" }, n => notes.push(n))).toBe(true);
+  expect(notes).toEqual([71, 73, 69, 74, 45]);
+  expect(handlePianoInput(input, { text: "jk" }, null)).toBe(true);
+});
+
+test("piano consumes repeats without retriggering and supports shifted physical keys", () => {
+  const notes = [];
+  const play = n => notes.push(n);
+  expect(handlePianoInput(input, { key: "j", repeat: true }, play)).toBe(true);
+  expect(handlePianoInput(input, { key: " ", repeat: true }, play)).toBe(true);
+  expect(handlePianoInput(input, { key: "J", code: "KeyJ", modifiers: 8 }, play)).toBe(true);
+  expect(handlePianoInput(input, { key: "j", modifiers: 2 }, play)).toBe(true);
+  expect(notes).toEqual([71]);
+  expect(handlePianoInput(input, { key: "Tab" }, play)).toBe(false);
+  expect(handlePianoInput(input, { key: "Backspace" }, play)).toBe(false);
+});
+
+test("ordinary, disabled and readonly editors are unaffected", () => {
+  expect(handlePianoInput({ getAttribute: () => "editor" }, { text: "jk" })).toBe(false);
+  expect(handlePianoInput({ ...input, disabled: true }, { text: "jk" })).toBe(false);
+  expect(handlePianoInput({ ...input, readOnly: true }, { text: "jk" })).toBe(false);
+  expect(handlePianoInput(null, { text: "jk" })).toBe(false);
+});

package/test/playback-buffer.test.js

@@ -0,0 +1,31 @@
+import { expect, test } from "bun:test";
+import { PlaybackBuffer } from "../lib/audio/playback-buffer.js";
+
+test("media prepares a bounded reserve regardless of server credits", () => {
+  const buffer = new PlaybackBuffer(1000, 2, 0.5);
+  expect(buffer.request(0, 0, 0, 0)).toBe(2000);
+  expect(buffer.request(0, 2000, 0, 500)).toBe(0);
+  expect(buffer.request(1500, 0, 500, 0)).toBe(0);
+  expect(buffer.request(1100, 0, 500, 40)).toBe(400);
+  expect(buffer.request(1100, 400, 500, 40)).toBe(0);
+});
+
+test("startup and starvation recovery require playable PCM, not elapsed time", () => {
+  const buffer = new PlaybackBuffer(1000, 2, 0.5);
+  expect(buffer.ready(40, 0, false)).toBe(false);
+  expect(buffer.ready(398, 0, false)).toBe(false);
+  expect(buffer.ready(400, 0, false)).toBe(true);
+  expect(buffer.ready(40, 300, false)).toBe(true);
+  expect(buffer.ready(0, 0, false)).toBe(false);
+  expect(buffer.ready(40, 0, false)).toBe(false);
+  expect(buffer.ready(400, 0, false)).toBe(true);
+});
+
+test("short clips drain and piano stays interactive", () => {
+  const media = new PlaybackBuffer(1000, 2, 0.5);
+  expect(media.ready(40, 0, true)).toBe(true);
+  const piano = new PlaybackBuffer(1000, 2, 0.12);
+  expect(piano.ready(40, 0, false)).toBe(true);
+  expect(piano.request(0, 0, 0, 120)).toBe(120);
+  expect(piano.request(0, 120, 0, 120)).toBe(0);
+});

package/test/pulse-client.test.js

@@ -134,7 +134,7 @@ function header(length, channel) {
 test("measured device progress governs the media clock and bounded audio queue through starvation", async () => {
   const { createServer } = await import("node:net");
   let received = 0, played = 0, reports = 0;
-  const times = [], errors = [];
+  const times = [], errors = [], requests = [];
   const scalar64 = (tag, value) => {
     const bytes = Buffer.alloc(9);
     bytes[0] = tag;
@@ -171,11 +171,17 @@ test("measured device progress governs the media clock and bounded audio queue t
   const client = await PulseClient.connect({ port: server.address().port });
   try {
     const stream = await client.openPlayback({ rate: 500, channels: 1,
+      onRequest: bytes => requests.push(bytes),
       onTiming: timing => times.push(timing.seconds), onTimingError: error => errors.push(error) });
-    stream.write(new Uint8Array(2000));
+    expect(requests).toEqual([2000]); // controller reserve, not the device queue
+    stream.write(new Uint8Array(100));
+    await Bun.sleep(80);
+    expect(received).toBe(0); // a short prefix does not start/stop playback
+    stream.write(new Uint8Array(1900));
     await Bun.sleep(180);
     expect(reports).toBeGreaterThan(0);
     expect(received).toBe(500); // at most the 0.5 s queue budget, not 2 s
+    expect(stream.queued).toBe(1500); // survives a renderer busy spell in the controller
     expect(times.at(-1)).toBe(0); // server/device hasn't played anything
     played = 100;
     await Bun.sleep(120);
@@ -190,8 +196,17 @@ test("measured device progress governs the media clock and bounded audio queue t
     expect(times.at(-1)).toBeCloseTo(0.6, 5);
     expect(received).toBeGreaterThan(1000);
     expect(received).toBeLessThanOrEqual(1100);
+    // No more PCM is provided by the producer: continue from the local reserve.
+    for (let i = 0; i < 4; i++) {
+      played = received;
+      await Bun.sleep(150);
+    }
+    expect(received).toBeGreaterThan(1500);
+    expect(received).toBeLessThanOrEqual(2000);
+    expect(requests.reduce((sum, value) => sum + value, 0)).toBeLessThanOrEqual(4000);
     expect(errors).toEqual([]);
     await stream.close();
+    expect(stream.queued).toBe(0); // pause/seek discards reserve; no extra device tail
   } finally {
     client.close();
     await new Promise(resolve => server.close(resolve));

package/test/text-layout.test.js

@@ -8,6 +8,68 @@ function boxFor(tree, layout, tagName) {
   return layout.boxes.find((box) => tree.nodesById.get(box.nodeId)?.tagName === tagName);
 }
 
+test("percentage and calc padding reserve an aspect-ratio box and reflow on resize", () => {
+  const { document, window } = parseHTMLDocument(`<body style="margin:0">
+    <div id="ratio" style="position:relative;padding-bottom:calc(100% * 9 / 16)">
+      <div id="fill" style="position:absolute;inset:0"></div>
+    </div><div id="next" style="height:20px"></div>
+  </body>`);
+  const styles = new StyleEngine().compute(document);
+  const tree = new RenderTreeBuilder().build(document, styles);
+  for (const width of [320, 640]) {
+    const layout = layoutText(tree, { x:0, y:0, width });
+    const rect = id => layout.boxes.find(box => tree.nodesById.get(box.nodeId)?.domNode?.id === id);
+    expect(rect('ratio').height).toBe(width * 9 / 16);
+    expect(rect('fill').height).toBe(width * 9 / 16);
+    expect(rect('next').y).toBe(width * 9 / 16);
+  }
+  window.happyDOM.abort();
+});
+
+test("nested absolute percentage heights use their own containing block, including on resize", () => {
+  const { document, window } = parseHTMLDocument(`<body style="margin:0">
+    <div style="position:relative;height:500px"><div style="position:absolute;bottom:0;width:100%;height:60px">
+      <div id="track" style="position:absolute;bottom:56px;width:100%;height:6px">
+        <div id="fill" style="position:absolute;bottom:0;width:100%;height:100%"></div>
+      </div>
+    </div></div></body>`);
+  const tree = new RenderTreeBuilder().build(document, new StyleEngine().compute(document));
+  const engine = new LayoutEngine();
+  for (const width of [320, 640]) {
+    const layout = engine.layout(tree, { x:0, y:0, width });
+    const rect = id => layout.boxes.find(box => tree.nodesById.get(box.nodeId)?.domNode?.id === id);
+    expect(rect('fill').height).toBe(6);
+    expect(rect('fill').y).toBe(rect('track').y);
+    expect(rect('fill').width).toBe(width);
+  }
+  window.happyDOM.abort();
+});
+
+test("legacy vertical line clamping limits lines and adds an ellipsis without changing DOM text", () => {
+  for (const display of ["-webkit-box", "block"]) {
+    const { document, window } = parseHTMLDocument(`<body style="margin:0"><div style="display:${display};-webkit-box-orient:vertical;-webkit-line-clamp:2;font-size:10px;line-height:10px;width:40px;overflow:hidden;overflow-wrap:anywhere">abcdefghijklmnop</div></body>`);
+    const tree = new RenderTreeBuilder().build(document, new StyleEngine().compute(document));
+    const layout = layoutText(tree, { x:0, y:0, width:200, measureText:text=>text.length*10 });
+    expect(layout.fragments.length).toBe(display === "block" ? 4 : 2);
+    const painted = layout.fragments.flatMap(f=>f.runs).map(r=>r.text).join('');
+    expect(painted).toBe(display === "block" ? "abcdefghijklmnop" : "abcdefg…");
+    expect(document.querySelector('div').textContent).toBe("abcdefghijklmnop");
+    window.happyDOM.abort();
+  }
+});
+
+test("empty blocks do not add adjoining vertical margins twice", () => {
+  const { document, window } = parseHTMLDocument(`<body style="margin:0"><div style="padding-top:1px">
+    <div style="height:20px;margin-bottom:12px"></div>
+    <div style="margin-top:12px"></div><div></div>
+    <div id="next" style="height:20px;margin-top:12px"></div>
+  </div></body>`);
+  const tree = new RenderTreeBuilder().build(document, new StyleEngine().compute(document));
+  const layout = layoutText(tree, { x:0, y:0, width:200 });
+  expect(layout.boxes.find(box => tree.nodesById.get(box.nodeId)?.domNode?.id === 'next').y).toBe(33);
+  window.happyDOM.abort();
+});
+
 test("creates positioned immutable line fragments with fixed-column wrapping", () => {
   const { document, window } = parseHTMLDocument(
     `<body style="margin:0">1234567890ABCDEFGHIJ<br>中文😀abcdef</body>`,

package/test/video-presentation.test.js

@@ -0,0 +1,67 @@
+import { test, expect } from "bun:test";
+import { VideoPresentation, compositeVideo } from "../lib/renderer/video-presentation.js";
+
+test("video predecode is bounded and waits for measured audio, skipping stale frames", async () => {
+  let frames = 0, closed = 0;
+  const reports = [];
+  const engine = { decode: async () => ({ width: 2, height: 2, fps: 30,
+    nextFrame: () => { frames++; return new Uint8Array(16).fill(frames); }, close: () => closed++ }) };
+  const video = new VideoPresentation(engine, () => {}, r => reports.push(r));
+  try {
+    await video.open({ id: 1, time: 0, hasAudio: true, audioId: 4, audioStart: 0 });
+    await Bun.sleep(100);
+    expect(frames).toBeLessThanOrEqual(24);
+    expect(video.queue.length).toBeLessThanOrEqual(video.limit);
+    expect(video.frame.time).toBe(0);
+    const first = reports.length;
+    await Bun.sleep(80);
+    expect(reports).toHaveLength(first);
+    video.timing(4, 0.5);
+    await Bun.sleep(60);
+    expect(video.frame.time).toBeCloseTo(0.5);
+    expect(reports.filter(r => r.time > 0).length).toBe(1);
+    video.stop(1);
+    video.timing(4, 2);
+    await Bun.sleep(30);
+    expect(video.frame).toBeNull();
+    expect(closed).toBe(1);
+  } finally { video.stop(); }
+});
+
+test("a late decoder open cannot replace a newer playback generation", async () => {
+  let resolve, closed = 0;
+  const video = new VideoPresentation({ decode: () => new Promise(r => resolve = r) }, () => {}, () => {});
+  const opening = video.open({ id: 1, time: 0 });
+  video.stop();
+  resolve({ close: () => closed++ });
+  await opening;
+  expect(closed).toBe(1);
+  expect(video.config).toBeNull();
+});
+
+test("reopening at a keyframe does not show the prefix before the resume position", async () => {
+  let at = 0;
+  const reports = [];
+  const video = new VideoPresentation({ decode: async () => ({ width: 2, height: 2, fps: 10,
+    seek() { at = 0; }, nextFrame(w, h) { at++; return new Uint8Array(w * h * 4).fill(at); }, close() {} }) },
+    () => {}, report => reports.push(report));
+  try {
+    video.timing(9, 2);
+    await video.open({ id: 2, time: 2, hasAudio: true, audioId: 9, audioStart: 0 });
+    await Bun.sleep(100);
+    expect(reports.some(report => report.time >= 1.9)).toBe(true);
+    expect(reports.every(report => report.time === undefined || report.time >= 1.9)).toBe(true);
+  } finally { video.stop(); }
+});
+
+test("video layer preserves opaque controls, translucent overlays and clipped pixels", () => {
+  const base = new Uint8Array([0,0,0,255, 255,255,255,255, 0,0,128,255, 10,20,30,255]);
+  const mask = new Uint8Array([255,255,255,0, 0,0,0,0, 127,127,127,0, 0,0,0,0]);
+  const tile = { pixelWidth: 4, pixelHeight: 1, pixels: base,
+    videoLayer: { base, mask, rect: { x: 0, y: 0, width: 4, height: 1 } } };
+  const frame = { width: 1, height: 1, pixels: new Uint8Array([200,100,0,255]) };
+  expect([...compositeVideo(tile, frame).pixels]).toEqual([
+    200,100,0,255, 255,255,255,255, 100,50,128,255, 10,20,30,255,
+  ]);
+  expect(compositeVideo(tile, null)).toBe(tile);
+});