buninu-browser 0.5.1 → 0.6.0

package/test/video-channel.test.js

@@ -0,0 +1,253 @@
+import {test,expect} from 'bun:test';
+import {mkdtempSync,writeFileSync,rmSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import {VideoChannel,startVideoChannel} from '../lib/renderer/video-channel.js';
+
+test('video channel rejects late frames and reports from stopped/replaced presentations',()=>{
+  let listener,changed=0;const reports=[],sent=[];
+  const channel=new VideoChannel({addEventListener(type,f){if(type==='message')listener=f;},postMessage(m){sent.push(m);}},()=>changed++,r=>reports.push(r));
+  channel.open({id:1});channel.open({id:2});
+  listener({data:{type:'frame',id:1,delivery:1,frame:{time:1}}});
+  listener({data:{type:'report',report:{id:1,end:2}}});
+  expect(changed).toBe(0);expect(reports).toHaveLength(0);
+  listener({data:{type:'frame',id:2,delivery:2,frame:{time:3}}});
+  expect(channel.frame.time).toBe(3);expect(changed).toBe(1);
+  channel.stop(1);expect(channel.config.id).toBe(2);
+  channel.stop(2);listener({data:{type:'frame',id:2,delivery:3,frame:{time:4}}});
+  expect(channel.frame).toBeNull();expect(changed).toBe(1);
+  expect(sent.filter(m=>m.type==='frame-ack')).toEqual([
+    {type:'frame-ack',id:1,delivery:1},
+    {type:'frame-ack',id:2,delivery:2},
+    {type:'frame-ack',id:2,delivery:3},
+  ]);
+});
+
+test('frame notification failures still ACK and a failed transport reports fallback without more sends',()=>{
+  let listener,failed=false,terminated=0;const sent=[],reports=[];
+  const worker={addEventListener(type,f){if(type==='message')listener=f;},postMessage(m){
+    if(failed)throw Error('worker unavailable');
+    sent.push(m);
+  },terminate(){terminated++;}};
+  const channel=new VideoChannel(worker,()=>{throw Error('presentation callback');},r=>reports.push(r));
+  channel.open({id:7});
+  expect(()=>listener({data:{type:'frame',id:7,delivery:1,frame:{time:0}}})).toThrow('presentation callback');
+  expect(sent.at(-1)).toEqual({type:'frame-ack',id:7,delivery:1});
+  failed=true;channel.timing(9,.5);
+  expect(reports).toEqual([{id:7,error:'worker unavailable'}]);
+  expect(channel.frame).toBeNull();expect(channel.config).toBeNull();
+  channel.open({id:8});channel.bind(8,9,0,0);channel.stop();channel.timing(9,1);
+  listener({data:{type:'frame',id:8,delivery:2,frame:{time:1}}});
+  expect(reports.at(-1)).toEqual({id:8,error:'worker unavailable'});
+  expect(channel.frame).toBeNull();expect(terminated).toBe(1);
+  expect(sent).toHaveLength(2);
+});
+
+test('worker failure is latched before terminate synchronously emits close',()=>{
+  const listeners=new Map(),reports=[];let terminated=0;
+  const worker={addEventListener(type,listener){listeners.set(type,listener);},postMessage(){},
+    terminate(){terminated++;listeners.get('close')({code:0});}};
+  const channel=new VideoChannel(worker,()=>{},report=>reports.push(report));
+  channel.open({id:9});
+  listeners.get('error')(new Error(''));
+  listeners.get('close')({code:0});
+  listeners.get('error')(new Error('later'));
+  expect(reports).toEqual([{id:9,error:'Video worker failed'}]);
+  expect(terminated).toBe(1);
+  expect(channel.config).toBeNull();expect(channel.frame).toBeNull();
+});
+
+// Use the real Bun Worker lifecycle with a tiny file, avoiding decoder/WASM
+// startup and page realms' scoped Blob URL hooks. Restore the constructor
+// before the first async continuation; each caller removes its own directory.
+function startLifecycleWorker(source,changed,report) {
+  const Original=globalThis.Worker;
+  const directory=mkdtempSync(join(tmpdir(),'buninu-video-lifecycle-'));
+  const path=join(directory,'worker.js');
+  let worker,starting;
+  const dispose=()=>{worker?.terminate();rmSync(directory,{recursive:true,force:true});};
+  try {
+    writeFileSync(path,source);
+    globalThis.Worker=class extends Original {constructor(){super(path);worker=this;}};
+    try {starting=startVideoChannel(changed,report);}
+    finally {globalThis.Worker=Original;}
+    return {worker,starting,dispose};
+  } catch(error) {dispose();throw error;}
+}
+
+test('closing before ready rejects promptly without a startup timeout',async()=>{
+  const reports=[];
+  const fixture=startLifecycleWorker('process.exit(7)',()=>{},report=>reports.push(report));
+  let timer;
+  try {
+    const result=await Promise.race([
+      fixture.starting.then(()=>null,error=>error.message),
+      new Promise(resolve=>{timer=setTimeout(()=>resolve('startup was not rejected'),2000);}),
+    ]);
+    expect(result).toBe('Video worker closed (7)');
+    expect(reports).toEqual([]);
+  }finally{clearTimeout(timer);fixture.dispose();}
+},5000);
+
+test('closing after ready clears stale pixels and reports fallback exactly once',async()=>{
+  const reports=[];let changed=0;
+  const fixture=startLifecycleWorker(`self.onmessage=({data})=>{
+    if(data.type==='open'){
+      postMessage({type:'frame',id:data.config.id,delivery:1,
+        frame:{time:0,width:1,height:1,pixels:new Uint8Array([1,2,3,255])}});
+      setTimeout(()=>process.exit(0),5);
+    }
+  };postMessage({type:'ready'});`,()=>changed++,report=>reports.push(report));
+  try {
+    const channel=await fixture.starting;
+    channel.open({id:10});
+    for(let i=0;i<100&&!reports.length;i++)await Bun.sleep(10);
+    expect(changed).toBe(1);
+    expect(reports).toEqual([{id:10,error:'Video worker closed (0)'}]);
+    expect(channel.config).toBeNull();expect(channel.frame).toBeNull();
+    channel.timing(1,1);channel.fail(new Error('later'));fixture.worker.terminate();
+    await Bun.sleep(10);
+    expect(reports).toHaveLength(1);
+  }finally{fixture.dispose();}
+},5000);
+
+test('independent decoder transfers live pixels and retains measured-audio gating',async()=>{
+  const reports=[];const channel=await startVideoChannel(()=>{},r=>reports.push(r));
+  try {
+    const bytes=await Bun.file(new URL('./fixtures/long-video.mp4',import.meta.url)).bytes();
+    channel.timing(4,0);
+    channel.open({id:10,bytes,time:0,hasAudio:true,audioId:4,audioStart:0});
+    for(let i=0;i<100&&!channel.frame;i++)await Bun.sleep(20);
+    expect(channel.frame?.pixels.byteLength).toBeGreaterThan(0);
+    expect(channel.frame.time).toBe(0);
+    const first=channel.frame;
+    await Bun.sleep(100);expect(channel.frame).toBe(first);
+    channel.timing(4,.5);
+    for(let i=0;i<100&&(channel.frame?.time??0)<.4;i++)await Bun.sleep(20);
+    expect(channel.frame.time).toBeGreaterThanOrEqual(.4);
+    expect(channel.frame.pixels.byteLength).toBe(channel.frame.width*channel.frame.height*4);
+    expect(first.pixels.byteLength).toBe(first.width*first.height*4);
+    expect(reports.some(r=>r.error)).toBe(false);
+  }finally{channel.stop();channel.worker.terminate();}
+},15000);
+
+test('decoder sends only its latest pending frame and validates ACKs across stop and reopen',async()=>{
+  const worker=new Worker(new URL('../lib/renderer/video-worker.js',import.meta.url).href);
+  const frames=[],reports=[];let ready=false,error=null;
+  worker.addEventListener('message',({data})=>{
+    if(data.type==='ready')ready=true;
+    else if(data.type==='frame')frames.push(data);
+    else if(data.type==='report')reports.push(data.report);
+  });
+  worker.addEventListener('error',event=>{error=event;});
+  async function until(predicate){
+    for(let i=0;i<200&&!predicate()&&!error;i++)await Bun.sleep(10);
+    if(error)throw error;
+    expect(predicate()).toBe(true);
+  }
+  const ack=frame=>worker.postMessage({type:'frame-ack',id:frame.id,delivery:frame.delivery});
+  try {
+    await until(()=>ready);
+    const bytes=await Bun.file(new URL('./fixtures/long-video.mp4',import.meta.url)).bytes();
+    const open=(id,audioId)=>{
+      worker.postMessage({type:'timing',id:audioId,seconds:0});
+      worker.postMessage({type:'open',config:{id,bytes,time:0,hasAudio:true,audioId,audioStart:0}});
+    };
+    open(1,11);
+    await until(()=>frames.length===1);
+    worker.postMessage({type:'timing',id:11,seconds:1});
+    await until(()=>reports.some(r=>r.id===1&&r.time>=1));
+    expect(frames).toHaveLength(1);
+    ack({...frames[0],id:99});ack({...frames[0],delivery:99});
+    await Bun.sleep(30);expect(frames).toHaveLength(1);
+    ack(frames[0]);await until(()=>frames.length===2);
+    expect(frames[1].frame.time).toBeGreaterThanOrEqual(1);
+    // Reopening retains the outstanding delivery, while discarding pending
+    // pixels from the previous generation. Its valid ACK unlocks the new one.
+    open(2,12);
+    await until(()=>reports.some(r=>r.id===2&&r.time===0));
+    ack(frames[0]);await Bun.sleep(30);expect(frames).toHaveLength(2);
+    ack(frames[1]);await until(()=>frames.length===3);
+    expect(frames[2].id).toBe(2);expect(frames[2].frame.time).toBe(0);
+    worker.postMessage({type:'timing',id:12,seconds:1});
+    await until(()=>reports.some(r=>r.id===2&&r.time>=1));
+    worker.postMessage({type:'stop',id:2});open(3,13);
+    await until(()=>reports.some(r=>r.id===3&&r.time===0));
+    ack(frames[1]);await Bun.sleep(30);expect(frames).toHaveLength(3);
+    ack(frames[2]);await until(()=>frames.length===4);
+    expect(frames[3].id).toBe(3);expect(frames[3].frame.time).toBe(0);
+    expect(frames[3].delivery).toBeGreaterThan(frames[2].delivery);
+    expect(reports.some(r=>r.error)).toBe(false);
+    for(const {frame}of frames)expect(frame.pixels.byteLength).toBe(frame.width*frame.height*4);
+  }finally{worker.terminate();}
+},15000);
+
+test('same-presentation extension preserves the last frame and filters replaced sessions', () => {
+  const sent = [];
+  const channel = new VideoChannel({ addEventListener() {}, postMessage(message) { sent.push(message); } }, () => {}, () => {});
+  channel.open({ id: 7 });
+  const frame = channel.frame = { time: 2 };
+  channel.extend({ id: 6, revision: 0, generation: 2 });
+  expect(sent).toHaveLength(1);
+  channel.extend({ id: 7, revision: 0, generation: 2 });
+  expect(sent.at(-1)).toEqual({ type: 'extend', id: 7, revision: 0, generation: 2 });
+  expect(channel.frame).toBe(frame);
+  channel.stop();
+});
+
+test('real fMP4 snapshot extension preserves transfer ownership and sequential pixels across EOF', async () => {
+  const { default: wasmpeg } = await import('../vendor/wasmpeg/src/js/index.js');
+  await wasmpeg.load();
+  const bytes = await Bun.file(new URL('./fixtures/mse-switch-large.mp4', import.meta.url)).bytes();
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let end = 0;
+  while (end < bytes.length) {
+    const size = view.getUint32(end);
+    const type = String.fromCharCode(...bytes.subarray(end + 4, end + 8));
+    end += size;
+    if (type === 'mdat') break;
+  }
+  const oracle = await wasmpeg.decode(bytes);
+  const expected = [];
+  try {
+    let pixels;
+    while ((pixels = oracle.nextFrame(oracle.width, oracle.height))) expected.push(Bun.hash(pixels));
+  } finally { oracle.close(); }
+  const reports = [], frames = [];
+  const channel = await startVideoChannel(() => {
+    const { time, pixels } = channel.frame;
+    frames.push({ time, pixels, hash: Bun.hash(pixels) });
+  }, report => reports.push(report));
+  const until = async predicate => {
+    for (let i = 0; i < 200 && !predicate(); i++) await Bun.sleep(10);
+    expect(predicate()).toBe(true);
+  };
+  try {
+    channel.timing(9, 0);
+    channel.open({ id: 30, bytes: bytes.slice(0, end), snapshotId: 'video-epoch', generation: 1,
+      time: 0, hasAudio: true, audioId: 9, audioStart: 0 });
+    await until(() => frames.length > 0);
+    channel.timing(9, 1.3);
+    await until(() => reports.some(report => Number.isFinite(report.exhaustedAt)));
+    const exhausted = reports.find(report => Number.isFinite(report.exhaustedAt));
+    expect(exhausted.exhaustedAt).toBeCloseTo(2, 6);
+    const previous = channel.frame;
+    channel.extend({ id: 30, revision: 0, generation: 2, snapshotId: 'video-epoch',
+      bytes, boundary: exhausted.exhaustedAt });
+    expect(channel.frame).toBe(previous);
+    await until(() => reports.some(report => report.continued === 2));
+    for (let i = 14; i <= 60; i++) {
+      channel.timing(9, i / 10);
+      await Bun.sleep(15);
+    }
+    await until(() => reports.some(report => report.end >= 5.9));
+    expect(reports.some(report => report.error || report.continuationError)).toBe(false);
+    expect(reports.filter(report => report.continued).map(report => report.revision)).toEqual([1]);
+    expect(new Set(frames.map(frame => Math.round(frame.time * 10))).size).toBe(frames.length);
+    expect(frames.some(frame => Math.abs(frame.time - 2) < 1e-6)).toBe(true);
+    for (const frame of frames) {
+      expect(frame.pixels.byteLength).toBe(128 * 96 * 4);
+      expect(frame.hash).toBe(expected[Math.round(frame.time * 10)]);
+    }
+  } finally { channel.stop(); channel.worker.terminate(); }
+}, 15000);

package/test/video-continuation.test.js

@@ -0,0 +1,57 @@
+import {test,expect} from 'bun:test';
+import {VideoPresentation} from '../lib/renderer/video-presentation.js';
+const sleep=Bun.sleep;
+const wait=async fn=>{for(let i=0;i<100;i++){if(fn())return;await sleep(2);}throw Error('timeout');};
+function fixture({hold=false,changedFormat=false}={}){
+ const reports=[],shown=[],decoders=[];let release,decodeCalls=0;
+ const engine={async decode(bytes){
+  const d={width:4,height:changedFormat&&bytes[0]>1?4:3,fps:10,at:0,calls:0,closed:0,
+   seek(ms){this.at=Math.floor(ms/1000)*10;},
+   nextFrame(w,h){this.calls++;if(this.at>=bytes[0]*10)return null;return new Uint8Array(w*h*4).fill(++this.at);},
+   close(){this.closed++;}};
+  decoders.push(d);decodeCalls++;if(hold&&bytes[0]>1)await new Promise(r=>release=r);return d;
+ }};
+ const v=new VideoPresentation(engine,()=>{shown.push({time:v.frame.time,value:v.frame.pixels[0]});v.frame.pixels.buffer.transfer(0);},r=>reports.push(r));
+ const config={id:3,bytes:new Uint8Array([1]),options:{},time:0,audioId:4,audioStart:0,hasAudio:true,snapshotId:'a',generation:1,shared:new SharedArrayBuffer(16+480*480*4)};
+ const start=async()=>{v.timing(4,0);await v.open(config);v.timing(4,.4);await wait(()=>reports.some(x=>x.exhaustedAt));};
+ const request=()=>({id:3,revision:0,snapshotId:'a',generation:2,boundary:1,bytes:new Uint8Array([2,0])});
+ return {v,reports,shown,decoders,start,request,release:()=>release(),calls:()=>decodeCalls};
+}
+test('continuation retains queued pixels, transfers once, and resumes at decoded boundary',async()=>{
+ const f=fixture({hold:true});try{
+ await f.start();const exhausted=f.reports.find(x=>x.exhaustedAt);
+ expect(exhausted.exhaustedAt).toBeCloseTo(1,9);expect(f.v.queue.length).toBeGreaterThan(0);
+ const pending=f.v.extend(f.request());await wait(()=>f.calls()===2);
+ const before=f.shown.length;f.v.timing(4,.7);expect(f.shown.length).toBe(before+1);expect(f.shown.at(-1).time).toBeCloseTo(.7,9);
+ expect(f.v.queue.length).toBeGreaterThan(0);f.release();expect(await pending).toBe(true);
+ for(let i=8;i<=21;i++){f.v.timing(4,i/10);await sleep(12);expect(f.v.queue.length).toBeLessThanOrEqual(f.v.limit);}
+ expect(new Set(f.shown.map(x=>x.value)).size).toBe(f.shown.length);
+ expect(f.shown.every((x,i,a)=>i===0||x.time>a[i-1].time)).toBe(true);
+ expect(f.shown.some(x=>x.value===11)).toBe(true);
+ expect(f.v.config.audioId).toBe(4);expect(f.v.config.generation).toBe(2);
+ expect(f.reports.filter(x=>x.end!==undefined)).toHaveLength(1);
+ const calls=f.decoders.at(-1).calls;await sleep(35);expect(f.v.timer).toBeNull();expect(f.decoders.at(-1).calls).toBe(calls);
+ }finally{f.v.stop();}
+});
+test('old id/revision/generation/configuration epoch requests cannot replace decoder',async()=>{
+ const f=fixture();try{await f.start();for(const change of [{id:9},{revision:8},{generation:1},{snapshotId:'other'}])expect(await f.v.extend({...f.request(),...change})).toBe(false);expect(f.calls()).toBe(1);}finally{f.v.stop();}
+});
+test('pause or seek cancels a decoder opening without resurrecting old frames',async()=>{
+ for(const openNew of [false,true]){const f=fixture({hold:true});try{
+ await f.start();const pending=f.v.extend(f.request());await wait(()=>f.calls()===2);const staged=f.decoders[1];
+ f.v.stop();if(openNew)await f.v.open({id:7,bytes:new Uint8Array([1]),options:{},time:0,audioId:8,audioStart:0,snapshotId:'b',generation:1});
+ const before=f.shown.length;f.release();expect(await pending).toBe(false);expect(staged.closed).toBe(1);expect(f.shown.length).toBe(before);expect(f.v.config?.id??null).toBe(openNew?7:null);
+ }finally{f.v.stop();}}
+});
+test('one in-progress continuation is bounded and changed codec geometry rejects safely',async()=>{
+ const f=fixture({hold:true,changedFormat:true});try{await f.start();const pending=f.v.extend(f.request());await wait(()=>f.calls()===2);expect(await f.v.extend({...f.request(),generation:3})).toBe(false);expect(f.calls()).toBe(2);f.release();expect(await pending).toBe(false);expect(f.reports.some(x=>x.continuationError)).toBe(true);expect(f.v.config.generation).toBe(1);f.v.timing(4,1.1);await sleep(15);expect(f.reports.filter(x=>x.end!==undefined)).toHaveLength(1);}finally{f.v.stop();}
+});
+test('EOF without new bytes is reported once and does not poll/decode forever',async()=>{
+ const f=fixture();try{await f.start();f.v.timing(4,1.1);await sleep(15);expect(f.reports.filter(x=>x.exhaustedAt!==undefined)).toHaveLength(1);expect(f.reports.filter(x=>x.end!==undefined)).toHaveLength(1);const count=f.decoders[0].calls;await sleep(35);expect(f.decoders[0].calls).toBe(count);expect(f.v.timer).toBeNull();}finally{f.v.stop();}
+});
+test('updated track boundary cancels pending continuation and never shows next epoch pixels',async()=>{
+ const f=fixture({hold:true});try{await f.start();const pending=f.v.extend(f.request());await wait(()=>f.calls()===2);f.v.bind(3,undefined,undefined,undefined,.8);f.release();expect(await pending).toBe(false);f.v.timing(4,1.1);await sleep(15);expect(f.shown.every(x=>x.time<.8)).toBe(true);expect(f.reports.filter(x=>x.end!==undefined).map(x=>x.end)).toEqual([.8]);expect(f.v.config.generation).toBe(1);}finally{f.v.stop();}
+});
+test('clock binding updates survive continuation without resetting or extrapolating audio time',async()=>{
+ const f=fixture({hold:true});try{await f.start();const pending=f.v.extend(f.request());await wait(()=>f.calls()===2);f.v.bind(3,8,.5);const before=f.shown.length;f.v.timing(4,9);expect(f.shown.length).toBe(before);f.v.timing(8,.2);expect(f.v.time()).toBe(.7);f.release();expect(await pending).toBe(true);expect(f.v.config.audioId).toBe(8);expect(f.v.config.audioStart).toBe(.5);expect(f.v.time()).toBe(.7);expect(f.v.config.time).toBe(0);}finally{f.v.stop();}
+});

package/test/video-controls-invalidation.test.js

@@ -0,0 +1,12 @@
+import { expect, test } from "bun:test";
+
+test("video controls mutations refresh paint while retaining unchanged geometry", async () => {
+  const child = Bun.spawn([process.execPath, new URL("./fixtures/video-controls-invalidation.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("video controls paint invalidation passed");
+}, 15000);

package/test/video-keyframe.test.js

@@ -1,6 +1,28 @@
 import { expect, test } from 'bun:test';
 import wasmpeg from '../vendor/wasmpeg/src/js/index.js';
 import { seekVideoKeyframe } from '../lib/media/video-keyframe.js';
+import { mp4KeyframeBefore } from '../lib/media/mp4-keyframes.js';
+
+function withEditList(bytes, rate = 0x00010000) {
+  const view=new DataView(bytes.buffer,bytes.byteOffset,bytes.byteLength);
+  const find=(from,end,type)=>{
+    for(let at=from;at+8<=end;at+=view.getUint32(at)){
+      const size=view.getUint32(at);
+      if(size<8||at+size>end)break;
+      if(String.fromCharCode(...bytes.subarray(at+4,at+8))===type)return {at,end:at+size};
+    }
+    throw Error(`missing ${type}`);
+  };
+  const moov=find(0,bytes.length,'moov'),trak=find(moov.at+8,moov.end,'trak');
+  const edit=new Uint8Array(36),ev=new DataView(edit.buffer);
+  ev.setUint32(0,36);edit.set([101,100,116,115],4); // edts
+  ev.setUint32(8,28);edit.set([101,108,115,116],12); // elst
+  ev.setUint32(20,1);ev.setUint32(24,6000);ev.setInt32(28,2048);ev.setUint32(32,rate);
+  const out=new Uint8Array(bytes.length+edit.length),ov=new DataView(out.buffer);
+  out.set(bytes.subarray(0,trak.end));out.set(edit,trak.end);out.set(bytes.subarray(trak.end),trak.end+edit.length);
+  ov.setUint32(moov.at,view.getUint32(moov.at)+edit.length);ov.setUint32(trak.at,view.getUint32(trak.at)+edit.length);
+  return out;
+}
 
 test('seeking within a GOP longer than ten seconds preserves the decoded frame timestamp', async () => {
   await wasmpeg.load();
@@ -52,10 +74,88 @@ test('a later MP4 initialization keeps absolute seek times, including seeks back
     // The fixture's keyframes are 2s apart. After moving tfdt by six seconds,
     // seek(8s) must return frame 20, not frame 0 or an offset-relative frame.
     for (const [target, frame, expectedTime] of [[6, 0, 6], [7.9, 0, 6], [8, 20, 8], [11, 40, 10], [6.2, 0, 6], [5, 0, 6]]) {
-      const timestamp = seekVideoKeyframe(decoder, target, 6);
-      expect(Bun.hash(decoder.nextFrame(32, 18))).toBe(hashes[frame]);
-      expect(timestamp).toBeGreaterThanOrEqual(expectedTime);
-      expect(timestamp).toBeLessThan(expectedTime + 1 / decoder.fps);
+      for(const index of [null,bytes]){
+        const timestamp = seekVideoKeyframe(decoder, target, 6,index);
+        expect(Bun.hash(decoder.nextFrame(32, 18))).toBe(hashes[frame]);
+        expect(timestamp).toBeGreaterThanOrEqual(expectedTime);
+        expect(timestamp).toBeLessThan(expectedTime + 1 / decoder.fps);
+      }
     }
   } finally { decoder.close(); }
 });
+
+test('verified fMP4 candidates reduce probes and preserve subsequent full-size frames',async()=>{
+  await wasmpeg.load();
+  for(const name of ['mse-switch-small.mp4','mse-switch-large.mp4']){
+    const bytes=new Uint8Array(await Bun.file(new URL(`./fixtures/${name}`,import.meta.url)).arrayBuffer());
+    const decoder=await wasmpeg.decode(bytes,{format:'mp4'});
+    let probes=0;
+    const counted={fps:decoder.fps,seek:time=>decoder.seek(time),nextFrame:(...args)=>{probes++;return decoder.nextFrame(...args);}};
+    try{
+      for(const [target,keyframe] of [[1.9,0],[2,2],[3.99,2],[4,4],[5.8,4]]){
+        probes=0;const baselineTime=seekVideoKeyframe(counted,target),baselineProbes=probes;
+        const expected=[];
+        for(let i=0;i<8;i++)expected.push(decoder.nextFrame());
+        probes=0;const indexedTime=seekVideoKeyframe(counted,target,0,bytes);
+        expect(indexedTime).toBe(keyframe);
+        expect(Math.abs(indexedTime-baselineTime)).toBeLessThan(1/decoder.fps);
+        expect(probes).toBeLessThanOrEqual(3);
+        if(keyframe)expect(probes).toBeLessThan(baselineProbes);
+        else expect(probes).toBeLessThanOrEqual(baselineProbes);
+        for(const pixels of expected)expect(decoder.nextFrame()).toEqual(pixels);
+      }
+    }finally{decoder.close();}
+  }
+});
+
+test('a mismatched candidate or indistinguishable pictures retain the original seek search',async()=>{
+  const bytes=new Uint8Array(await Bun.file(new URL('./fixtures/mse-switch-large.mp4',import.meta.url)).arrayBuffer());
+  for(const staticPicture of [false,true]){
+    let position=0;
+    const decoder={fps:10,seek(ms){position=Math.floor(ms/3000)*3;},nextFrame(){return new Uint8Array([staticPicture?1:position,9,7,255]);}};
+    const baseline=seekVideoKeyframe(decoder,3.9);
+    const indexed=seekVideoKeyframe(decoder,3.9,0,bytes);
+    expect(indexed).toBe(baseline);
+    expect(position).toBe(staticPicture?0:3);
+  }
+});
+
+test('failed optional candidate probes fall back, while original search errors still propagate',async()=>{
+  const bytes=new Uint8Array(await Bun.file(new URL('./fixtures/mse-switch-large.mp4',import.meta.url)).arrayBuffer());
+  const makeDecoder=(failAt,method)=>{
+    let time=0;
+    return {fps:10,seek(ms){time=ms;if(method==='seek'&&ms===failAt)throw Error('seek failure');},
+      nextFrame(){if(method==='nextFrame'&&time===failAt)throw Error('decode failure');return new Uint8Array([Math.floor(time/2000),9,7,255]);}};
+  };
+  const baseline=seekVideoKeyframe(makeDecoder(-1,'seek'),3.9);
+  for(const method of ['seek','nextFrame']){
+    expect(seekVideoKeyframe(makeDecoder(2000,method),3.9,0,bytes)).toBe(baseline);
+    expect(()=>seekVideoKeyframe(makeDecoder(3900,method),3.9,0,bytes)).toThrow();
+    expect(()=>seekVideoKeyframe(makeDecoder(1,method),3.9,0,null)).toThrow();
+  }
+});
+
+test('an unreadable preceding probe cannot verify a candidate boundary',async()=>{
+  const bytes=new Uint8Array(await Bun.file(new URL('./fixtures/mse-switch-large.mp4',import.meta.url)).arrayBuffer());
+  let time=0;
+  const decoder={fps:10,seek(ms){time=ms;},nextFrame(){return time===1900?null:new Uint8Array([Math.floor(time/2000),9,7,255]);}};
+  const baseline=seekVideoKeyframe(decoder,3.9);
+  expect(baseline).toBeGreaterThan(2);
+  expect(seekVideoKeyframe(decoder,3.9,0,bytes)).toBe(baseline);
+});
+
+test('a simple edit list is only a verified seek candidate, while rate-changing edits decline',async()=>{
+  await wasmpeg.load();
+  const original=new Uint8Array(await Bun.file(new URL('./fixtures/mse-switch-large.mp4',import.meta.url)).arrayBuffer());
+  expect(mp4KeyframeBefore(withEditList(original,0x00020000),3.5)).toBeNull();
+  const bytes=withEditList(original),decoder=await wasmpeg.decode(bytes,{format:'mp4'});
+  try{
+    for(const target of [2.8,4.7]){
+      const baseline=seekVideoKeyframe(decoder,target),expected=[];
+      for(let i=0;i<8;i++)expected.push(decoder.nextFrame());
+      const indexed=seekVideoKeyframe(decoder,target,0,bytes);
+      expect(Math.abs(indexed-baseline)).toBeLessThan(1/decoder.fps);
+      for(const pixels of expected)expect(decoder.nextFrame()).toEqual(pixels);
+    }
+  }finally{decoder.close();}
+});

package/test/video-mask.test.js

@@ -0,0 +1,94 @@
+import {test, expect} from 'bun:test';
+import {loadGraphics} from '../lib/renderer/page-renderer.js';
+import {visibleItems} from '../lib/paint/display-list.js';
+import {rasterVideoMask,videoMaskBounds,videoMaskItems} from '../lib/renderer/video-mask.js';
+const {CanvasKit:kit,builtinTypefaces}=await loadGraphics();
+const width=160,height=120;
+const info={width,height,colorType:kit.ColorType.RGBA_8888,alphaType:kit.AlphaType.Unpremul,colorSpace:kit.ColorSpace.SRGB};
+
+function scene({scale=1,rect={x:15.2,y:22.4,width:57.3,height:37.2},transform,opacity=1,clip=false,rounded=false,transparent=false,shadow=false}) {
+  const region={x:7.3,y:11.7,width:width/scale,height:height/scale};
+  const surface=kit.MakeSurface(width,height),canvas=surface.getCanvas();
+  const background=kit.Color(31,47,71,transparent?0.5:1);
+  const video={rect,transform,opacity,bounds:{...rect}};
+  if(transform)video.bounds={x:rect.x*transform.a+transform.e,y:rect.y*transform.d+transform.f,width:rect.width*transform.a,height:rect.height*transform.d};
+  const overlays=[
+    {rect:{x:18,y:29,width:26,height:12},color:kit.Color(240,33,80,0.5)},
+    {rect:{x:16,y:39,width:44,height:8},color:kit.Color(250,250,250,1),text:true},
+    {rect:{x:114,y:81,width:22,height:23},color:kit.Color(17,225,82,1)},
+  ].map(item=>({...item,bounds:item.rect}));
+  const shadowItem={op:'drawShadow',rect:{x:10,y:30,width:30,height:60},bounds:{x:-20,y:0,width:90,height:120},blur:30};
+  const items=[video,...(shadow?[shadowItem]:[]),...overlays];
+  let drawn=0;
+  function device(rect){return kit.XYWHRect(Math.round((rect.x-region.x)*scale),Math.round((rect.y-region.y)*scale),Math.round(rect.width*scale),Math.round(rect.height*scale));}
+  function paint(white,view=region){
+    for(const item of videoMaskItems({items},region,view)){
+      drawn++;
+      const saved=canvas.save();
+      const p=new kit.Paint();p.setAntiAlias(true);
+      if(item===video){
+        if(clip)canvas.clipRect(device({x:22.3,y:25.1,width:25.2,height:31.3}),kit.ClipOp.Intersect,true);
+        if(rounded)canvas.clipRRect(kit.RRectXY(device({x:14,y:21,width:48,height:35}),9,9),kit.ClipOp.Intersect,true);
+        if(transform){const {a,d,e,f}=transform;canvas.concat([a,0,((a-1)*region.x+e)*scale,0,d,((d-1)*region.y+f)*scale,0,0,1]);}
+        if(opacity<1){p.setAlphaf(opacity);canvas.saveLayer(p,device(item.bounds));}
+        canvas.clipRect(device(rect),kit.ClipOp.Intersect,true);
+        p.setColor(white===null?kit.Color(22,173,216,1):kit.Color(white?255:0,white?255:0,white?255:0,1));
+        canvas.drawRect(device(rect),p);
+      }else if(item===shadowItem){
+        const filter=kit.MaskFilter.MakeBlur(kit.BlurStyle.Normal,Math.round(item.blur*scale)/2,true);
+        p.setMaskFilter(filter);p.setColor(kit.Color(0,0,0,1));
+        canvas.clipRect(device(item.rect),kit.ClipOp.Difference,true);
+        canvas.drawRect(device(item.rect),p);filter.delete();
+      }else{
+        p.setColor(item.color);canvas.drawRect(device(item.rect),p);
+        if(item.text){
+          const font=new kit.Font(builtinTypefaces[0].typeface,7);
+          p.setColor(kit.Color(16,16,16,1));
+          canvas.drawText('Subtitles',(item.rect.x-region.x)*scale,(item.rect.y-region.y)*scale+7,p,font);
+          font.delete();
+        }
+      }
+      p.delete();canvas.restoreToCount(saved);
+    }
+  }
+  function normal(){canvas.clear(background);paint(null);surface.flush();const img=surface.makeImageSnapshot();try{return img.readPixels(0,0,info);}finally{img.delete();}}
+  return {video,region,surface,canvas,background,paint,normal,scale,items,get drawn(){return drawn;}};
+}
+
+for(const [label,options] of Object.entries({
+  shadowTail:{shadow:true,rect:{x:74,y:30,width:60,height:60}},
+  basic:{}, fractional:{scale:1.75}, opacity:{opacity:.4}, clipping:{clip:true}, rounded:{rounded:true},
+  partial:{rect:{x:-15,y:-6,width:58,height:65}}, transparent:{transparent:true},
+  transformed:{transform:{a:1.3,d:.8,e:3.3,f:4.4}},
+  transformedFractional:{scale:1.75,opacity:.6,clip:true,transform:{a:1.7,d:.7,e:-4,f:8}},
+}))test(`cropped video mask is pixel-identical to full black/white passes: ${label}`,()=>{
+  const s=scene(options);
+  try{
+    const pixels=s.normal();
+    const common={kit,canvas:s.canvas,surface:s.surface,width,height,pixels,region:s.region,scale:s.scale,background:s.background,paint:s.paint};
+    const reference=rasterVideoMask(common);
+    s.normal();const before=s.drawn;
+    const bounds=videoMaskBounds(s.video,s.region,s.scale,width,height);
+    if(label==='shadowTail') {
+      const dirty={x:s.region.x+(bounds.x-2)/s.scale,y:s.region.y+(bounds.y-2)/s.scale,
+        width:(bounds.width+4)/s.scale,height:(bounds.height+4)/s.scale};
+      expect(visibleItems({items:s.items},dirty).some(item=>item.op==='drawShadow')).toBe(false);
+    }
+    const actual=rasterVideoMask({...common,bounds,cullPadding:label==='shadowTail'?2:4});
+    expect([...actual.base]).toEqual([...reference.base]);
+    expect([...actual.mask]).toEqual([...reference.mask]);
+    expect(pixels).not.toBe(actual.base);
+    expect(bounds.width*bounds.height).toBeLessThan(width*height);
+    if(label==='basic')expect(s.drawn-before).toBeLessThan(8);
+  }finally{s.surface.dispose();}
+});
+
+test('unbounded transforms use the full pass; wholly offscreen video needs no extra raster',()=>{
+  const s=scene({rect:{x:500,y:500,width:10,height:10}});
+  try{
+    expect(videoMaskBounds({...s.video,transform:{a:1,d:1,e:0,f:0,b:1}},s.region,1,width,height)).toBeNull();
+    const pixels=s.normal(),before=s.drawn;
+    const result=rasterVideoMask({kit,canvas:s.canvas,surface:s.surface,width,height,pixels,region:s.region,scale:1,background:s.background,paint:s.paint,bounds:videoMaskBounds(s.video,s.region,1,width,height)});
+    expect(result.base).toEqual(pixels);expect(result.mask.some(Boolean)).toBe(false);expect(s.drawn).toBe(before);
+  }finally{s.surface.dispose();}
+});