buninu-browser 0.5.1 → 0.7.0

package/test/fixtures/media-resource-reselection.js

@@ -0,0 +1,94 @@
+// Host scripting installs browser globals; isolate each explicit selection.
+import {strict as assert} from 'node:assert';
+import {createPageRenderer} from '../../lib/renderer/page-renderer.js';
+
+const action=process.argv[2],fetches=[],errors=[];
+let finishProbe,holdProbe=true,probes=0;
+const renderer=await createPageRenderer({
+  fetchResource:async url=>{
+    fetches.push(url);
+    if(url.startsWith('blob:'))throw Error('expired object URL');
+    return {ok:true,contentType:'video/mp4',body:new Uint8Array(1024)};
+  },
+  videoDecoder:{
+    async probe(){
+      probes++;
+      if(holdProbe)await new Promise(resolve=>{finishProbe=resolve;});
+      return {duration:10,video:{width:20,height:12}};
+    },
+    async decode(){return {width:20,height:12,fps:10,close(){},seek(){},nextFrame:()=>new Uint8Array(20*12*4)};},
+  },
+  reportError:error=>errors.push(String(error)),
+});
+const evaluate=source=>renderer.evaluate(source);
+const waitFor=async condition=>{
+  for(let n=0;n<200;n++){if(await condition())return;await Bun.sleep(5);}
+  assert.fail(`timed out: ${condition}; fetches=${fetches}, errors=${errors}`);
+};
+try{
+  renderer.resize(200,120,1);renderer.setScripting('host');
+  await renderer.loadDocument({url:'https://selection.test/',contentType:'text/html',source:
+    '<base href="https://selection.test/first/"><video id=v></video>'});
+  await renderer.whenLoaded();
+  await evaluate(`globalThis.v=document.getElementById('v');v.src='clip.mp4';void v.play();`);
+  await waitFor(()=>Boolean(finishProbe));
+  await evaluate(`document.querySelector('base').href='https://selection.test/second/';`);
+  finishProbe();
+  await waitFor(()=>evaluate('v.duration===10'));
+  assert.deepEqual(fetches,['https://selection.test/first/clip.mp4'],
+    'base alone must preserve the resource chosen before the pending probe');
+  await evaluate('v.pause();void v.play();');
+  assert.equal(fetches.length,1,'ordinary play must not reselect because base changed');
+
+  finishProbe=null;
+  await evaluate('v.pause()');
+  if(action==='src')await evaluate(`v.src='clip.mp4';`);
+  else if(action==='attribute')await evaluate(`v.setAttribute('src','clip.mp4');`);
+  else if(action==='load')await evaluate('v.load()');
+  else assert.fail(`unknown action ${action}`);
+  assert.equal(await evaluate('v.paused'),true);
+  if(action!=='load')await evaluate('void v.play()');
+  await waitFor(()=>Boolean(finishProbe));
+  assert.deepEqual(fetches,['https://selection.test/first/clip.mp4','https://selection.test/second/clip.mp4']);
+  finishProbe();
+  await waitFor(()=>evaluate('v.duration===10'));
+
+  if(action==='load'){
+    assert.equal(await evaluate('v.paused'),true,'load must not start playback');
+    finishProbe=null;
+    await evaluate('v.load()');
+    await waitFor(()=>Boolean(finishProbe));
+    assert.equal(fetches.length,3,'load explicitly reloads even an unchanged resolved URL');
+    finishProbe();await waitFor(()=>evaluate('v.duration===10'));
+    holdProbe=false;
+
+    // srcObject wins over both the property and attribute setters, including
+    // explicit load. A real object never needs its object URL registry entry.
+    await evaluate(`globalThis.ms=new MediaSource();v.srcObject=ms;
+      globalThis.append=source=>{const sb=source.addSourceBuffer('video/mp4; codecs="avc1.4d401e"');
+        const bytes=new Uint8Array(1024);new DataView(bytes.buffer).setUint32(0,1024);bytes.set([109,100,97,116],4);sb.appendBuffer(bytes);};
+      append(ms);`);
+    await waitFor(()=>evaluate('v.duration===10'));
+    await evaluate(`v.src='ignored.mp4';v.setAttribute('src','also-ignored.mp4');v.load();`);
+    await waitFor(()=>evaluate('v.readyState>=3'));
+    assert.equal(fetches.length,3);
+    assert.equal(await evaluate('v.srcObject===ms'),true);
+
+    // Revocation is harmless until an explicit load starts a new selection.
+    await evaluate(`v.srcObject=null;globalThis.other=new MediaSource();v.src=URL.createObjectURL(other);append(other);`);
+    await waitFor(()=>evaluate('v.duration===10'));
+    await evaluate('URL.revokeObjectURL(v.src);other.duration=20');
+    assert.equal(await evaluate('v.duration'),20);
+    await evaluate('v.load()');
+    await waitFor(()=>errors.length===1);
+    assert.equal(fetches.length,4);
+    assert.match(fetches[3],/^blob:/);
+    const before=probes;
+    await evaluate('other.duration=30;append(other)');
+    await Bun.sleep(30);
+    assert.equal(probes,before,'a revoked source cannot reattach through a late append');
+    assert.equal(await evaluate('Number.isNaN(v.duration)'),true);
+    assert.match(errors[0],/expired object URL/);
+  }else assert.deepEqual(errors,[]);
+  process.stdout.write(`Media resource reselection ${action} passed\n`);
+}finally{renderer.dispose();}

package/test/fixtures/media-source-attachment.js

@@ -0,0 +1,136 @@
+// Host scripting installs browser globals; keep this fixture isolated.
+import {strict as assert} from 'node:assert';
+import {createPageRenderer} from '../../lib/renderer/page-renderer.js';
+
+const sleep=Bun.sleep, probes=[],errors=[],fetches=[];
+let finishProbe;
+const renderer=await createPageRenderer({
+  fetchResource:async url=>{
+    fetches.push(url);const body=new Uint8Array(1024);body[8]=10;
+    return {ok:true,contentType:'video/mp4',body};
+  },
+  videoDecoder:{
+    async probe(bytes) {
+      probes.push(bytes[8]);
+      if(bytes[8]===8||bytes[8]===10)await new Promise(resolve=>{finishProbe=resolve;});
+      return {duration:bytes[8]*100,video:{width:20,height:12}};
+    },
+    async decode() {return {width:20,height:12,fps:10,close(){},seek(){},nextFrame:()=>new Uint8Array(20*12*4)};},
+  },
+  reportError:error=>errors.push(String(error)),
+});
+const evaluate=source=>renderer.evaluate(source);
+const duration=()=>evaluate('document.getElementById("v").duration');
+const waitFor=async condition=>{
+  for(let n=0;n<200;n++){if(await condition())return;await sleep(5);}
+  assert.fail(`timed out: ${condition}; probes=${probes}, errors=${errors}`);
+};
+try {
+  renderer.resize(200,120,1);renderer.setScripting('host');
+  await renderer.loadDocument({url:'https://attachment.test/',contentType:'text/html',source:'<video id=v></video>'});
+  await renderer.whenLoaded();
+  await evaluate(`
+    globalThis.sources=[];globalThis.buffers=[];
+    globalThis.makeSource=()=>{const source=new MediaSource();sources.push(source);return source;};
+    globalThis.append=(source,marker)=>{
+      let buffer=buffers.find(entry=>entry.source===source)?.buffer;
+      if(!buffer){buffer=source.addSourceBuffer('video/mp4; codecs="avc1.4d401e"');buffers.push({source,buffer});}
+      const bytes=new Uint8Array(1024);new DataView(bytes.buffer).setUint32(0,bytes.length);
+      bytes.set([109,100,97,116],4);bytes[8]=marker;buffer.appendBuffer(bytes);
+    };
+    globalThis.a=makeSource();globalThis.b=makeSource();
+    document.getElementById('v').src=URL.createObjectURL(a);a.duration=59.201;
+    append(a,1);
+  `);
+  await waitFor(()=>probes.length===1);
+  assert.equal(await duration(),59.201);
+  await evaluate(`document.getElementById('v').src=URL.createObjectURL(b);b.duration=1000;append(b,2);`);
+  await waitFor(()=>probes.length===2);
+  assert.equal(await duration(),1000);
+
+  // Regression: the former source still exists in JS and can finish work,
+  // but it no longer owns this media element's current state.
+  await evaluate('a.duration=59.201');
+  assert.equal(await duration(),1000,'old source duration must not overwrite the current source');
+  await evaluate('append(a,3)');
+  await sleep(40);
+  assert.equal(probes.length,2,'old append must not probe or rebind the current track pipes');
+  await evaluate('a.endOfStream()');
+  assert.equal(await duration(),1000,'old source end must not restore its shorter duration');
+  await evaluate('b.duration=1100');
+  assert.equal(await duration(),1100);
+
+  // A new source with unknown duration starts a new state: the previous
+  // explicit-duration override cannot suppress its own metadata probe.
+  await evaluate(`globalThis.c=makeSource();document.getElementById('v').src=URL.createObjectURL(c);append(c,7);`);
+  await waitFor(()=>probes.length===3);
+  assert.equal(await duration(),700,'new source metadata must replace the old duration override');
+  await evaluate('b.duration=17');
+  assert.equal(await duration(),700);
+
+  // srcObject takes precedence over the src attribute; replacing an object
+  // must also replace state even though that attribute's URL has not changed.
+  await evaluate(`globalThis.d=makeSource();document.getElementById('v').srcObject=d;d.duration=800;`);
+  assert.equal(await duration(),800);
+  await evaluate(`globalThis.e=makeSource();document.getElementById('v').src=URL.createObjectURL(e);`);
+  assert.equal(await duration(),800,'changing src must not displace an active srcObject');
+  assert.equal(await evaluate('e.readyState'),'closed');
+  await evaluate('c.duration=11');
+  assert.equal(await duration(),800);
+  await evaluate('document.getElementById("v").srcObject=null;e.duration=900;');
+  assert.equal(await duration(),900,'clearing srcObject activates the src attribute');
+  await evaluate('d.duration=12');
+  assert.equal(await duration(),900);
+  await evaluate(`globalThis.f=makeSource();document.getElementById('v').srcObject=f;append(f,6);`);
+  await waitFor(()=>probes.length===4);
+  assert.equal(await duration(),600,'new srcObject must not inherit a previous duration override');
+  await evaluate('e.duration=13');
+  assert.equal(await duration(),600);
+  await evaluate(`URL.createObjectURL(f);document.getElementById('v').src='unused.mp4';`);
+  assert.equal(await duration(),600,'an alias and an inactive src must not reset a live srcObject');
+
+  // Revocation prevents a future URL lookup; it does not detach the source
+  // already selected by the media element. Both callbacks still work.
+  await evaluate(`document.getElementById('v').src=URL.createObjectURL(e);document.getElementById('v').srcObject=null;URL.revokeObjectURL(document.getElementById('v').src);e.duration=1200;append(e,4);`);
+  await waitFor(()=>probes.length===5);
+  assert.equal(await duration(),1200);
+  await evaluate('e.duration=1300');
+  assert.equal(await duration(),1300);
+
+  // A probe already in flight for an old attachment cannot commit metadata
+  // to the replacement resource or emit its loadedmetadata on the new src.
+  await evaluate(`globalThis.g=makeSource();document.getElementById('v').src=URL.createObjectURL(g);append(g,8);`);
+  await waitFor(()=>Boolean(finishProbe));
+  await evaluate(`globalThis.h=makeSource();document.getElementById('v').src=URL.createObjectURL(h);h.duration=1400;
+    globalThis.metadataEvents=0;document.getElementById('v').addEventListener('loadedmetadata',()=>metadataEvents++);`);
+  finishProbe();await sleep(40);
+  assert.equal(await duration(),1400);
+  assert.equal(await evaluate('metadataEvents'),0);
+
+  // A base-URL change alone must not cancel an already selected relative
+  // resource while its metadata probe is pending.
+  finishProbe=null;
+  await evaluate(`const base=document.createElement('base');base.href='https://attachment.test/first/';document.head.appendChild(base);
+    document.getElementById('v').src='clip.mp4';void document.getElementById('v').play();`);
+  await waitFor(()=>Boolean(finishProbe));
+  await evaluate(`document.querySelector('base').href='https://attachment.test/second/';`);
+  finishProbe();
+  await waitFor(async()=>await duration()===1000);
+  assert.deepEqual(fetches,['https://attachment.test/first/clip.mp4']);
+  assert.equal(await evaluate('document.getElementById("v").paused'),false);
+
+  // Old document callbacks must not create a new hidden media state in the
+  // replacement document. Keep only the original source/append closures.
+  const old={source:globalThis.h,append:globalThis.append};
+  // Host mode installs globals process-wide and permits just one realm here.
+  // The destination is static; stale callbacks must still be harmless.
+  renderer.setScripting('off');
+  await renderer.loadDocument({url:'https://attachment.test/next',contentType:'text/html',source:'<video id=v></video>'});
+  await renderer.whenLoaded();
+  const before=probes.length;
+  old.source.duration=3;old.append(old.source,9);
+  await sleep(40);
+  assert.equal(probes.length,before,'old document append must not start a probe');
+  assert.deepEqual(errors,[]);
+  process.stdout.write('MediaSource attachment isolation passed\n');
+} finally {renderer.dispose();}

package/test/fixtures/media-source-no-decoder.js

@@ -0,0 +1,17 @@
+// MSE attachment and sourceopen do not require a playback decoder.
+import {strict as assert} from 'node:assert';
+import {createPageRenderer} from '../../lib/renderer/page-renderer.js';
+
+const renderer=await createPageRenderer({});
+try {
+  renderer.resize(200,120,1);renderer.setScripting('host');
+  await renderer.loadDocument({url:'https://attachment.test/',contentType:'text/html',source:'<video id=v></video>'});
+  await renderer.whenLoaded();
+  await renderer.evaluate(`globalThis.source=new MediaSource();globalThis.opened=0;
+    source.addEventListener('sourceopen',()=>opened++);
+    document.getElementById('v').src=URL.createObjectURL(source);`);
+  assert.equal(await renderer.evaluate('source.readyState'),'open');
+  for(let n=0;n<100 && !await renderer.evaluate('opened');n++)await Bun.sleep(5);
+  assert.equal(await renderer.evaluate('opened'),1);
+  process.stdout.write('Decoder-less MediaSource attachment passed\n');
+} finally {renderer.dispose();}

package/test/fixtures/media-track-refill.js

@@ -0,0 +1,132 @@
+// Host scripting globals are isolated from the test runner.
+import {strict as assert} from 'node:assert';
+import {createPageRenderer} from '../../lib/renderer/page-renderer.js';
+import {createBytePipe} from '../../lib/media/byte-pipe.js';
+
+const sleep = Bun.sleep, pipe = createBytePipe();
+pipe.append(new Uint8Array(1024));
+// A shared pipe with MSE-like epochs. Epoch 0's decoder may have more
+// frames than its boundary; the renderer must stop it exactly at 3 seconds.
+let thirdEpoch = false;
+pipe.snapshotAt = time => {
+  const id = time < 3 ? 1 : time < 6 || !thirdEpoch ? 2 : 3;
+  return {id, startTime:(id-1)*3, endTime:id < 3 ? id*3 : Infinity,
+    bytes:new Uint8Array([id, pipe.size / 1024])};
+};
+const outputs = [], messages = [], audioDecoders = [], errors = [];
+let finishVideoOpen, holdVideo = false, failAudio = false;
+const renderer = await createPageRenderer({
+  onFrame() {}, onVideo:message => messages.push(message),
+  fetchResource:async () => ({ok:true, contentType:'video/mp4', body:pipe}),
+  reportError:error => errors.push(String(error)),
+  videoDecoder:{
+    probe:async () => ({duration:30, video:{width:20,height:12}, audio:{sampleRate:1000}}),
+    async decode() {
+      if (holdVideo) {holdVideo=false; await new Promise(resolve => {finishVideoOpen=resolve;});}
+      return {width:20,height:12,fps:10, seek() {}, close() {},
+        nextFrame:(w,h) => new Uint8Array(w*h*4)};
+    },
+    async decodeAudio(bytes) {
+      if (failAudio) throw Error('decoder failure after the completed input');
+      const start = (bytes[0]-1)*3000;
+      const record = {position:start, end:start+bytes[1]*2000, closed:false};
+      audioDecoders.push(record);
+      return {sampleRate:1000,channels:1, close() {record.closed=true;},
+        nextSamples() {
+          if (record.position >= record.end) return null;
+          return Float32Array.from({length:Math.min(100,record.end-record.position)},
+            () => (record.position++ % 1000) / 1024);
+        }};
+    },
+  },
+  audio:{
+    open(options, listener) {outputs.push({listener,pcm:[]});return outputs.length;},
+    write(id, bytes) {outputs[id-1].pcm.push(...new Int16Array(bytes.buffer,bytes.byteOffset,bytes.byteLength/2));},
+    close(id) {return Promise.resolve(outputs[id-1].pcm.length*2);}, finish() {},
+  },
+});
+const current = () => messages.filter(message => message.type === 'video-open').at(-1);
+const waitFor = async condition => {
+  for(let n=0;n<200;n++) {if(condition())return;await sleep(5);}
+  assert.fail(`timed out: ${condition}; ${JSON.stringify({audioDecoders,errors})}`);
+};
+const clock = seconds => outputs[0].listener({event:'timing',seconds,sentSeconds:10});
+const request = samples => outputs[0].listener({event:'request',bytes:samples*2});
+const startRefill = time => {
+  pipe.append(new Uint8Array(1024));
+  holdVideo=true;finishVideoOpen=null;
+  clock(time);
+  renderer.videoReport({id:current().id,end:time});
+};
+try {
+  renderer.resize(240,180,1);renderer.setScripting('host');
+  await renderer.loadDocument({url:'https://track-refill.test/',contentType:'text/html',source:
+    '<style>video{width:100px;height:60px;display:block}</style><video id=v src="clip.mp4"></video>'});
+  await renderer.whenLoaded();
+  await renderer.evaluate('document.getElementById("v").play()');
+  request(500);
+  await waitFor(() => Boolean(current()));
+  assert.equal(audioDecoders.length,1);
+  const first = audioDecoders[0], firstId = current().id;
+
+  // Appending shared bytes does not make the sound decoder unusable. A small
+  // request queued behind video's async open must consume that SAME decoder.
+  startRefill(0.4);
+  await waitFor(() => Boolean(finishVideoOpen));
+  request(500);
+  finishVideoOpen();
+  await waitFor(() => current().id !== firstId && outputs[0].pcm.length === 1000);
+  assert.equal(audioDecoders.length,1,'video EOF does not reopen usable audio');
+  assert.equal(first.closed,false);
+  assert.equal(await renderer.evaluate('document.getElementById("v").currentTime'),0.4);
+
+  // Audio reaches its own old snapshot's EOF while draining a request held
+  // during another video refill. It must reopen once and continue at sample
+  // 2000, preserving both the in-flight request and the output stream.
+  const secondId = current().id;
+  startRefill(0.5);
+  await waitFor(() => Boolean(finishVideoOpen));
+  request(1500);
+  finishVideoOpen();
+  await waitFor(() => current().id !== secondId && outputs[0].pcm.length === 2500);
+  assert.equal(audioDecoders.length,2,'audio itself still refills at EOF');
+  assert.equal(first.closed,true);
+  assert.equal(outputs.length,1,'decoder refill keeps its sample clock/output stream');
+  assert.equal(await renderer.evaluate('document.getElementById("v").currentTime'),0.5);
+
+  // An epoch boundary must trigger a new configuration even when the old
+  // decoder still has PCM and no new append occurred since its last reopen.
+  request(1000);
+  await waitFor(() => outputs[0].pcm.length === 3500);
+  assert.equal(audioDecoders.length,3);
+  assert.equal(audioDecoders[1].closed,true);
+  assert.equal(audioDecoders[2].position,3500);
+  assert.equal(outputs.length,1);
+  for(let i=0;i<3500;i++) assert.equal(outputs[0].pcm[i],Math.round((i%1000)/1024*32767),`sample ${i}`);
+  assert.deepEqual(errors,[]);
+
+  // An exhausted range with no different snapshot must wait for an append,
+  // without reopening that same epoch in a loop. Then resume at its exact
+  // next sample when a genuinely different epoch arrives.
+  request(3000);
+  await sleep(80);
+  assert.equal(outputs[0].pcm.length,6000);
+  assert.equal(audioDecoders.length,3);
+  thirdEpoch=true;
+  pipe.append(new Uint8Array(1024));
+  await waitFor(() => outputs[0].pcm.length === 6500);
+  assert.equal(audioDecoders.length,4);
+  assert.equal(outputs.length,1);
+  for(let i=3500;i<6500;i++) assert.equal(outputs[0].pcm[i],Math.round((i%1000)/1024*32767),`sample ${i}`);
+
+  // Exhausting a finished input must surface a subsequent decoder failure,
+  // rather than treating it as another append or swallowing the error.
+  pipe.finish(); failAudio=true;
+  request(9000);
+  await waitFor(() => errors.length > 0);
+  assert.match(errors[0],/decoder failure after the completed input/);
+  await sleep(80);
+  assert.equal(errors.length,1,'fatal refill is reported once instead of restarting an EOF loop');
+  assert.equal(await renderer.evaluate('document.getElementById("v").paused'),true);
+  process.stdout.write('track-independent refill integration passed\n');
+} finally {renderer.dispose();}

package/test/fixtures/media-webm-seek.js

@@ -0,0 +1,51 @@
+import {strict as assert} from 'node:assert';
+import {createPageRenderer} from '../../lib/renderer/page-renderer.js';
+import {createMediaSourceScope} from '../../lib/renderer/media-source.js';
+import {createWebMStream} from '../../lib/media/webm-stream.js';
+import {floatToS16} from '../../lib/audio/pcm.js';
+import wasmpeg from '../../vendor/wasmpeg/src/js/index.js';
+
+const sleep=Bun.sleep, tasks=[];
+await wasmpeg.load();
+const fixture=await Bun.file(new URL('./mse-audio-chirp.webm',import.meta.url)).bytes();
+const elements=createWebMStream().append(fixture),clusters=elements.filter(e=>e.id===0x1f43b675);
+const scope=createMediaSourceScope({origin:'https://gap.test',DOMException,schedule:fn=>tasks.push(fn)});
+const flush=()=>{while(tasks.length)tasks.shift()()};
+const source=new scope.MediaSource();source.attach('blob:https://gap.test/audio');flush();
+const buffer=source.addSourceBuffer('audio/webm; codecs="opus"');
+for(const e of [...elements.slice(0,elements.indexOf(clusters[0])),clusters[0],clusters[3]]){buffer.appendBuffer(e.bytes);flush();}
+const pipe=buffer._pipe, selected=pipe.snapshotAt(7);
+const reference=await wasmpeg.decodeAudio(selected.bytes,{format:'webm'});
+let skip=Math.round((7-selected.startTime)*reference.sampleRate),expected;
+try {for(let samples;samples=reference.nextSamples();){if(skip>=samples.length){skip-=samples.length;continue;}expected=floatToS16(samples.subarray(skip,skip+100));break;}}
+finally{reference.close();}
+const outputs=[],errors=[];
+const renderer=await createPageRenderer({
+  fetchResource:async()=>({ok:true,body:pipe,contentType:'audio/webm'}),videoDecoder:wasmpeg,
+  reportError:error=>errors.push(String(error)),
+  audio:{open(options,listener){outputs.push({listener,pcm:[]});return outputs.length;},
+    write(id,bytes){outputs[id-1].pcm.push(bytes.slice());},finish(){},close(){return Promise.resolve(0);}},
+});
+const wait=async condition=>{for(let i=0;i<200;i++){if(await condition())return;await sleep(5);}assert.fail(`timed out; ${errors}`);};
+try{
+  renderer.setScripting('host');
+  await renderer.loadDocument({url:'https://gap.test/',contentType:'text/html',source:'<audio id=a src="sparse.webm"></audio>'});
+  await renderer.evaluate('document.getElementById("a").play()');
+  assert.equal(outputs.length,1);outputs[0].listener({event:'request',bytes:4800});
+  outputs[0].listener({event:'timing',seconds:.025,sentSeconds:.05});
+  await renderer.evaluate('globalThis.seekDone=0;const a=document.getElementById("a");a.addEventListener("seeked",()=>seekDone++);a.currentTime=7');
+  await wait(()=>outputs.length===2);
+  assert.equal(await renderer.evaluate('seekDone'),1,'the sparse seek completed');
+  outputs[1].listener({event:'request',bytes:200});
+  assert.deepEqual(outputs[1].pcm[0],expected,'resumed stream begins at the original timeline sample');
+  outputs[1].listener({event:'timing',seconds:.001,sentSeconds:.002});
+  assert.equal(await renderer.evaluate('document.getElementById("a").currentTime'),7.001);
+  await renderer.evaluate('document.getElementById("a").pause();document.getElementById("a").currentTime=.5');
+  await wait(async()=>await renderer.evaluate('seekDone')===2);
+  assert.equal(await renderer.evaluate('document.getElementById("a").currentTime'),.5);
+  assert.equal(outputs.length,2,'paused backwards seek does not open output');
+  await renderer.evaluate('document.getElementById("a").play()');
+  assert.equal(outputs.length,3,'play after backwards seek reopens audio normally');
+  assert.deepEqual(errors,[]);
+  process.stdout.write('sparse WebM seek and playback passed\n');
+}finally{pipe.finish();renderer.dispose();}

package/test/fixtures/mutation-observer.js

@@ -0,0 +1,201 @@
+import assert from 'node:assert/strict';
+import { createPageRenderer } from '../../lib/renderer/page-renderer.js';
+
+async function mutationObserverCases() {
+  const results = {};
+  const tick = () => new Promise(resolve => setTimeout(resolve, 0));
+  const describe = records => records.map(r => [r.type, r.target.id, r.attributeName, r.oldValue,
+    Array.from(r.addedNodes, n => n.id || n.nodeName), Array.from(r.removedNodes, n => n.id || n.nodeName)]);
+  async function run(name, fn) {
+    const root = document.createElement('div');root.id='root';
+    root.innerHTML='<div id="a"><span id="child"></span></div><div id="b"></div>';
+    document.body.appendChild(root);
+    const observers=[];
+    const make = callback => {const o=new MutationObserver(callback);observers.push(o);return o;};
+    try { results[name]=await fn(root,make); }
+    finally {for(const observer of observers)observer.disconnect();root.remove();await tick();}
+  }
+  await run('multipleTargets',async(root,make)=>{
+    const [a,b]=root.children,batches=[];const o=make(r=>batches.push(describe(r)));
+    o.observe(a,{attributes:true});o.observe(b,{attributes:true});
+    b.setAttribute('x','1');a.setAttribute('y','2');b.setAttribute('z','3');await tick();return batches;
+  });
+  await run('takeRecords',async(root,make)=>{
+    const [a,b]=root.children,batches=[];const o=make(r=>batches.push(describe(r)));
+    o.observe(a,{attributes:true});o.observe(b,{attributes:true});
+    b.setAttribute('x','1');a.setAttribute('y','2');b.setAttribute('z','3');
+    const records=describe(o.takeRecords());await tick();return {records,batches,empty:o.takeRecords().length};
+  });
+  await run('overlappingTargets',async(root,make)=>{
+    const child=root.querySelector('#child'),batches=[];child.setAttribute('value','old');
+    const o=make(r=>batches.push(describe(r)));
+    o.observe(root,{subtree:true,attributes:true,attributeOldValue:true});o.observe(child,{attributes:true});
+    child.setAttribute('value','new');await tick();return batches;
+  });
+  await run('creationAndPromiseOrder',async(root,make)=>{
+    const [a,b]=root.children,events=[];
+    const older=make(()=>events.push('older')),newer=make(()=>events.push('newer'));
+    newer.observe(b,{attributes:true});older.observe(a,{attributes:true});
+    b.setAttribute('x','1');Promise.resolve().then(()=>events.push('promise'));a.setAttribute('x','1');
+    await tick();return events;
+  });
+  await run('callbackMutation',async(root,make)=>{
+    const [a,b]=root.children,events=[];let calls=0;
+    const o=make(r=>{events.push(describe(r));if(++calls===1){a.setAttribute('second','a');b.setAttribute('second','b');}});
+    o.observe(a,{attributes:true});o.observe(b,{attributes:true});
+    a.setAttribute('first','1');Promise.resolve().then(()=>events.push('promise'));
+    await tick();return events;
+  });
+  await run('callbackMutatesLaterObserver',async(root,make)=>{
+    const [a,b]=root.children,events=[];
+    const first=make(r=>{events.push(['first',describe(r)]);b.setAttribute('later','2');});
+    const second=make(r=>events.push(['second',describe(r)]));
+    first.observe(a,{attributes:true});second.observe(b,{attributes:true});
+    b.setAttribute('initial','1');a.setAttribute('initial','1');await tick();return events;
+  });
+  await run('disconnectReobserve',async(root,make)=>{
+    const [a,b]=root.children,batches=[];const o=make(r=>batches.push(describe(r)));
+    o.observe(a,{attributes:true});a.setAttribute('discard','1');o.disconnect();
+    o.observe(b,{attributes:true});b.setAttribute('keep','2');await tick();return batches;
+  });
+  await run('drainOtherObserver',async(root,make)=>{
+    const [a,b]=root.children,events=[];let second;
+    const first=make(()=>events.push(['drained',describe(second.takeRecords())]));
+    second=make(r=>events.push(['second',describe(r)]));
+    first.observe(a,{attributes:true});second.observe(b,{attributes:true});
+    b.setAttribute('x','1');a.setAttribute('x','1');await tick();return events;
+  });
+  await run('reobserveOptions',async(root,make)=>{
+    const a=root.firstElementChild,batches=[];const o=make(r=>batches.push(describe(r)));
+    o.observe(a,{attributes:true,attributeFilter:['x']});a.setAttribute('x','first');
+    o.observe(a,{attributes:true,attributeFilter:['y']});a.setAttribute('x','ignored');a.setAttribute('y','kept');
+    await tick();return batches;
+  });
+  for(const childList of [false,true])await run('detachedSubtree'+childList,async(root,make)=>{
+    const a=root.firstElementChild,child=a.firstElementChild,batches=[];
+    const o=make(r=>batches.push(describe(r)));o.observe(root,{subtree:true,childList,attributes:true});
+    a.remove();child.setAttribute('before','1');await tick();child.setAttribute('after','2');await tick();return batches;
+  });
+  await run('moveAndEmpty',async(root,make)=>{
+    const [a,b]=root.children,child=a.firstElementChild,batches=[];
+    const o=make(r=>batches.push(describe(r)));o.observe(root,{subtree:true,childList:true,attributes:true});
+    a.remove();a.removeChild(child);b.appendChild(child);child.setAttribute('before','1');
+    await tick();child.setAttribute('after','2');await tick();return batches;
+  });
+  await run('detachedTarget',async(root,make)=>{
+    const a=root.firstElementChild,batches=[];a.remove();
+    const o=make(r=>batches.push(describe(r)));o.observe(a,{attributes:true});a.setAttribute('x','1');await tick();return batches;
+  });
+  await run('exceptionIsolation',async(root,make)=>{
+    const [a,b]=root.children,events=[];
+    const handler=e=>e.preventDefault();window.addEventListener('error',handler);
+    const first=make(()=>{events.push('first');throw new Error('observer-fixture-expected');});
+    const second=make(()=>events.push('second'));first.observe(a,{attributes:true});second.observe(b,{attributes:true});
+    a.setAttribute('x','1');b.setAttribute('x','1');await tick();window.removeEventListener('error',handler);return events;
+  });
+  await run('omittedAttributeOptions',async(root,make)=>{
+    const a=root.firstElementChild,events=[];
+    const o=make(r=>events.push(describe(r)));o.observe(a,{attributeOldValue:false});
+    a.setAttribute('x','first');a.setAttribute('x','second');await tick();return events;
+  });
+  await run('omittedCharacterOptions',async(root,make)=>{
+    const a=root.firstElementChild,text=document.createTextNode('old'),events=[];a.appendChild(text);
+    const o=make(r=>events.push(r.map(x=>[x.type,x.oldValue])));o.observe(text,{characterDataOldValue:false});
+    text.data='new';await tick();return events;
+  });
+  await run('invalidCallback',async()=>[null,undefined,{},1,'x'].map(value=>{
+    try {new MutationObserver(value);return false;} catch(error){return error.name;}
+  }));
+  await run('filterCase',async(root,make)=>{
+    const a=root.firstElementChild,events=[];const o=make(r=>events.push(describe(r)));
+    o.observe(a,{attributes:true,attributeFilter:['UPPER']});a.setAttribute('UPPER','1');
+    await tick();return events;
+  });
+  await run('reobserveSubtree',async(root,make)=>{
+    const a=root.firstElementChild,child=a.firstElementChild,events=[];const o=make(r=>events.push(describe(r)));
+    o.observe(root,{attributes:true,subtree:true});a.remove();
+    o.observe(root,{attributes:true,subtree:false});child.setAttribute('ignored','1');root.setAttribute('yes','1');
+    root.appendChild(a);child.setAttribute('also-ignored','1');await tick();
+    o.observe(root,{attributes:true,subtree:true});child.setAttribute('kept','1');await tick();return events;
+  });
+  await run('transientDuringCallback',async(root,make)=>{
+    const a=root.firstElementChild,child=a.firstElementChild,events=[];
+    const o=make(r=>{events.push(describe(r));child.setAttribute('callback','ignored');});
+    o.observe(root,{attributes:true,subtree:true,childList:true});a.remove();await tick();return events;
+  });
+  await run('takeRecordsKeepsTransient',async(root,make)=>{
+    const a=root.firstElementChild,child=a.firstElementChild,events=[];const o=make(r=>events.push(describe(r)));
+    o.observe(root,{attributes:true,subtree:true,childList:true});a.remove();const drained=describe(o.takeRecords());
+    child.setAttribute('before','yes');await tick();child.setAttribute('after','ignored');await tick();return {drained,events};
+  });
+  await run('optionValidation',async(root,make)=>{
+    const a=root.firstElementChild,callable=function(){};
+    callable[Symbol.iterator]=function*(){yield 'x'};
+    const options=[{}, {attributes:false,attributeOldValue:false},
+      {childList:true,attributes:false,attributeFilter:[]}, {characterData:false,characterDataOldValue:true},
+      {attributeFilter:[]}, {attributeFilter:new Set(['x'])}, {attributeFilter:callable},
+      {attributeFilter:'x'}, {attributeFilter:{length:1,0:'x'}}, {attributeFilter:null},
+      {attributeOldValue:undefined}, {characterDataOldValue:undefined},
+      {childList:true,attributes:false,attributeOldValue:false}, {attributeFilter:[Symbol('x')]}];
+    return options.map((option,i)=>{const observer=make(()=>{});try{
+      observer.observe(a,option);a.setAttribute('x',String(i));const records=observer.takeRecords();
+      observer.disconnect();return ['ok',records.map(record=>record.attributeName)];
+    }catch(error){return error.name;}});
+  });
+  await run('optionConversionOrder',async(root,make)=>{
+    const events=[],options={},filter={get [Symbol.iterator](){events.push('iterator');return function*(){
+      events.push('first');yield {toString(){events.push('string');return 'x'}};events.push('end');
+    }}};
+    for(const key of ['attributeFilter','attributeOldValue','attributes','characterData','characterDataOldValue','childList','subtree']){
+      Object.defineProperty(options,key,{get(){events.push(key);return key==='attributeFilter'?filter:undefined}});
+    }
+    make(()=>{}).observe(root,options);return events;
+  });
+  return results;
+}
+
+const expected = {
+  "multipleTargets": [[["attributes","b","x",null,[],[]],["attributes","a","y",null,[],[]],["attributes","b","z",null,[],[]]]],
+  "takeRecords": {"records":[["attributes","b","x",null,[],[]],["attributes","a","y",null,[],[]],["attributes","b","z",null,[],[]]],"batches":[],"empty":0},
+  "overlappingTargets": [[["attributes","child","value","old",[],[]]]],
+  "creationAndPromiseOrder": ["older","newer","promise"],
+  "callbackMutation": [[["attributes","a","first",null,[],[]]],"promise",[["attributes","a","second",null,[],[]],["attributes","b","second",null,[],[]]]],
+  "callbackMutatesLaterObserver": [["first",[["attributes","a","initial",null,[],[]]]],["second",[["attributes","b","initial",null,[],[]],["attributes","b","later",null,[],[]]]]],
+  "disconnectReobserve": [[["attributes","b","keep",null,[],[]]]],
+  "drainOtherObserver": [["drained",[["attributes","b","x",null,[],[]]]]],
+  "reobserveOptions": [[["attributes","a","x",null,[],[]],["attributes","a","y",null,[],[]]]],
+  "detachedSubtreefalse": [[["attributes","child","before",null,[],[]]]],
+  "detachedSubtreetrue": [[["childList","root",null,null,[],["a"]],["attributes","child","before",null,[],[]]]],
+  "moveAndEmpty": [[["childList","root",null,null,[],["a"]],["childList","a",null,null,[],["child"]],["childList","b",null,null,["child"],[]],["attributes","child","before",null,[],[]]],[["attributes","child","after",null,[],[]]]],
+  "detachedTarget": [[["attributes","a","x",null,[],[]]]],
+  "exceptionIsolation": ["first","second"],
+  "omittedAttributeOptions": [[["attributes","a","x",null,[],[]],["attributes","a","x",null,[],[]]]],
+  "omittedCharacterOptions": [[["characterData",null]]],
+  "invalidCallback": ["TypeError","TypeError","TypeError","TypeError","TypeError"],
+  "filterCase": [],
+  "reobserveSubtree": [[["attributes","root","yes",null,[],[]]],[["attributes","child","kept",null,[],[]]]],
+  "transientDuringCallback": [[["childList","root",null,null,[],["a"]]]],
+  "takeRecordsKeepsTransient": {"drained":[["childList","root",null,null,[],["a"]]],"events":[[["attributes","child","before",null,[],[]]]]},
+  "optionValidation": ["TypeError","TypeError","TypeError","TypeError",["ok",[]],["ok",["x"]],["ok",["x"]],"TypeError","TypeError","TypeError","TypeError","TypeError",["ok",[]],"TypeError"],
+  "optionConversionOrder": ["attributeFilter","iterator","first","string","end","attributeOldValue","attributes","characterData","characterDataOldValue","childList","subtree"]
+};
+
+const errors=[];
+const renderer=await createPageRenderer({reportError:error=>errors.push(String(error))});
+await import('../../vendor/ses/dist/ses.mjs');
+lockdown({errorTaming:'safe',overrideTaming:'severe',consoleTaming:'unsafe',localeTaming:'unsafe',stackFiltering:'concise',reporting:'none'});
+try {
+  renderer.setScripting('ses'); renderer.resize(400,300,1);
+  await renderer.loadDocument({url:'https://mutation.test/',contentType:'text/html',source:'<!doctype html><body></body>'});
+  await renderer.whenLoaded();
+  const result=JSON.parse(await renderer.evaluate('('+mutationObserverCases.toString()+')().then(JSON.stringify)'));
+  for (const [name,value] of Object.entries(expected)) assert.deepEqual(result[name],value,name);
+  assert.equal(errors.length,1); assert.match(errors[0],/observer-fixture-expected/);
+  // Navigation gives the next realm a fresh observer constructor and delivery.
+  await renderer.loadDocument({url:'https://mutation.test/next',contentType:'text/html',source:'<!doctype html><body></body>'});
+  await renderer.whenLoaded();
+  assert.equal(await renderer.evaluate(`new Promise(resolve=>{
+    const observer=new MutationObserver(records=>{observer.disconnect();resolve(records.length)});
+    observer.observe(document.body,{attributes:true});document.body.setAttribute('next','1');
+  })`),1);
+} finally { renderer.dispose(); }