buninu-browser 0.5.1 → 0.6.0

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

@@ -0,0 +1,113 @@
+// 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';
+import {createBytePipe} from '../../lib/media/byte-pipe.js';
+
+const sleep = Bun.sleep, pipe = createBytePipe();
+pipe.append(new Uint8Array(1024));
+const decoders = [], messages = [], errors = [], outputs = [];
+let holdNext = false, finishOpen;
+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() {
+      const record = {seeks:[], frames:0, at:0};
+      const decoder = {width:20,height:12,fps:10,
+        seek(ms) {record.seeks.push(ms); record.at=Math.floor(ms/1000);},
+        nextFrame(w,h) {record.frames++; const bytes=new Uint8Array(w*h*4).fill(20+Math.floor(record.at));record.at+=0.1;return bytes;},
+        close() {},
+      };
+      decoders.push(record);
+      if (holdNext) {holdNext=false; await new Promise(resolve => {finishOpen=resolve;});}
+      return decoder;
+    },
+    decodeAudio: async () => ({sampleRate:1000,channels:1,
+      nextSamples:()=>new Float32Array(100), close() {}}),
+  },
+  audio: {
+    open(options, listener) {outputs.push({listener,samples:0});return outputs.length;},
+    write(id, bytes) {outputs[id-1].samples+=bytes.length/2;},
+    close(id) {return Promise.resolve(outputs[id-1].samples*2);},
+    finish() {},
+  },
+});
+const currentPresentation = () => messages.filter(message=>message.type==='video-open').at(-1);
+const opens = () => messages.filter(message=>message.type==='video-open').length;
+const waitFor = async condition => {
+  for (let attempt=0;attempt<200;attempt++) {if(condition())return;await sleep(5);}
+  assert.fail(`timed out waiting for media transition: ${condition}; ${JSON.stringify({decoders, messages:messages.map(({type,id})=>({type,id})),errors})}`);
+};
+const clock = seconds => outputs.at(-1).listener({event:'timing',seconds,sentSeconds:10,sinkSeconds:10-seconds});
+const beginRefill = seconds => {
+  holdNext=true;finishOpen=null;
+  pipe.append(new Uint8Array(1024));
+  clock(seconds);
+  renderer.videoReport({id:currentPresentation().id,end:seconds});
+};
+try {
+  renderer.resize(240,180,1);renderer.setScripting('host');
+  await renderer.loadDocument({url:'https://refill.test/',contentType:'text/html',source:
+    '<style>body{margin:0}video{width:100px;height:60px;display:block}#second{display:none}</style><video id=v src="clip.mp4"></video><video id=second></video>'});
+  await renderer.whenLoaded();
+  await renderer.evaluate('document.getElementById("v").play()');
+  outputs.at(-1).listener({event:'request',bytes:20000});
+  await waitFor(()=>Boolean(currentPresentation()));
+  assert.equal(outputs.length,1);
+
+  // A real presentation refills without probing/decoding the same prefix on
+  // the page thread. Audio continues to own time and keeps its output stream.
+  const firstOpens=opens();
+  beginRefill(2);
+  await waitFor(()=>Boolean(finishOpen));
+  const resumed=decoders.at(-1);
+  finishOpen();
+  await waitFor(()=>opens()>firstOpens);
+  assert.deepEqual(resumed.seeks,[]);
+  assert.equal(resumed.frames,0);
+  assert.equal(currentPresentation().time,2);
+  assert.equal(await renderer.evaluate('document.getElementById("v").currentTime'),2);
+  assert.equal(outputs.length,1,'refilling does not reset the measured audio stream');
+
+  // Controls enabled during the async reopen prevent presentation: the lazy
+  // page decoder must seek before it can draw an ordinary local frame.
+  const controlOpens=opens();
+  beginRefill(3);
+  await waitFor(()=>Boolean(finishOpen));
+  await renderer.evaluate('document.getElementById("v").setAttribute("controls", "")');
+  const controls=decoders.at(-1);
+  finishOpen();
+  await waitFor(()=>controls.frames>0);
+  assert.ok(controls.seeks.length>0);
+  assert.equal(controls.seeks[0],3000);
+  assert.equal(opens(),controlOpens);
+  assert.equal(await renderer.evaluate('document.getElementById("v").currentTime'),3);
+
+  await renderer.evaluate('document.getElementById("v").removeAttribute("controls");document.getElementById("v").style.width="101px"');
+  await waitFor(()=>opens()>controlOpens);
+  const multipleOpens=opens();
+  beginRefill(4);
+  await waitFor(()=>Boolean(finishOpen));
+  await renderer.evaluate('document.getElementById("second").style.display="block"');
+  const multiple=decoders.at(-1);
+  finishOpen();
+  await waitFor(()=>multiple.frames>0);
+  assert.ok(multiple.seeks.length>0);
+  assert.equal(multiple.seeks[0],4000);
+  assert.equal(opens(),multipleOpens,'multiple visible videos retain local decoding');
+
+  await renderer.evaluate('document.getElementById("second").style.display="none"');
+  await waitFor(()=>opens()>multipleOpens);
+  const fallback=decoders.at(-1), beforeFallback=fallback.frames;
+  renderer.videoReport({id:currentPresentation().id,error:'simulated decoder failure'});
+  await waitFor(()=>fallback.frames>beforeFallback);
+  assert.ok(fallback.seeks.length>0,'failed presentation positions the page decoder');
+  await renderer.evaluate('document.getElementById("v").pause()');
+  const paused=await renderer.evaluate('document.getElementById("v").currentTime');
+  clock(5);
+  assert.equal(await renderer.evaluate('document.getElementById("v").currentTime'),paused);
+  assert.deepEqual(errors,[]);
+  process.stdout.write('presentation refill avoids duplicate page decode and preserves fallbacks\n');
+} finally {renderer.dispose();}

package/test/fixtures/media-probe.js

@@ -0,0 +1,148 @@
+// Isolated: the host realm installs browser globals in this process.
+import { strict as assert } from 'node:assert';
+import { createPageRenderer } from '../../lib/renderer/page-renderer.js';
+
+const scenario = process.argv[2], sleep = Bun.sleep;
+const probes = [], pending = [], errors = [];
+let hold = scenario.startsWith('initial') && scenario !== 'initial-rejected';
+let failNext = scenario === 'initial-rejected';
+const renderer = await createPageRenderer({
+  reportError: error => errors.push(String(error)),
+  fetchResource: async () => ({ ok: true, contentType: 'video/mp4', body: new Uint8Array(8) }),
+  videoDecoder: {
+    async probe(bytes) {
+      const input = { length: bytes.length, hash: Bun.hash(bytes).toString() };
+      probes.push(input);
+      if (failNext) { failNext = false; throw Error('temporary probe failure'); }
+      if (hold) return new Promise(resolve => pending.push(resolve));
+      return metadata(bytes.length);
+    },
+    decode: async () => ({ width: 20, height: 12, fps: 1, close() {}, seek() {},
+      nextFrame: (w, h) => new Uint8Array(w * h * 4) }),
+  },
+});
+const metadata = duration => ({ duration, video: { width: 20, height: 12 } });
+const evaluate = code => renderer.evaluate(code);
+const waitFor = async condition => {
+  for (let attempt = 0; attempt < 150; attempt++) { if (await condition()) return; await sleep(5); }
+  assert.fail(`probe transition timed out: ${scenario}; ${JSON.stringify({ probes, pending: pending.length, errors })}`);
+};
+const append = buffer => evaluate(`new Promise(resolve => {
+  ${buffer}.addEventListener('updateend', resolve, {once:true});
+  ${buffer}.appendBuffer(new Uint8Array([0,0,0,8,102,114,101,101]));
+})`);
+const count = () => evaluate('metadataEvents');
+const duration = () => evaluate('v.duration');
+const finishInitial = async () => {
+  await waitFor(async () => await count() === 1);
+  await evaluate('v.pause()');
+  await sleep(10);
+};
+try {
+  renderer.setScripting('host'); renderer.resize(240, 180, 1);
+  await renderer.loadDocument({ url: 'https://probe.test/', contentType: 'text/html',
+    source: '<!doctype html><video id="v"></video>' });
+  await renderer.whenLoaded();
+  await evaluate(`new Promise(resolve => {
+    globalThis.metadataEvents=0; globalThis.v=document.getElementById('v');
+    v.addEventListener('loadedmetadata',()=>metadataEvents++);
+    globalThis.ms=new MediaSource();
+    ms.addEventListener('sourceopen',()=>{
+      globalThis.vb=ms.addSourceBuffer('video/mp4');
+      globalThis.ab=ms.addSourceBuffer('audio/mp4');
+      globalThis.probeWaits=0;
+      { const pipe=ms.streamPipes().video, original=pipe.waitFor;
+        pipe.waitFor=mark=>{probeWaits++;return original(mark)}; }
+      ${scenario.startsWith('epoch') ? `const pipe=ms.streamPipes().video, original=pipe.snapshotAt;
+      pipe.snapshotAt=seconds=>({...original(seconds),id:seconds>=2?'late':'early'});` : ''}
+      ${scenario === 'moving-snapshot' ? `const pipe=ms.streamPipes().video, original=pipe.snapshotAt;
+      pipe.snapshotAt=seconds=>({...original(seconds),startTime:Math.floor(seconds/0.02)*0.02});` : ''}
+      void v.play(); resolve();
+    },{once:true});
+    v.src=URL.createObjectURL(ms);
+  })`);
+  await append('vb');
+  if (scenario === 'initial-rejected') {
+    await waitFor(() => probes.length === 1);
+    await sleep(10);
+    const waits = await evaluate('probeWaits');
+    for (let i = 0; i < 5; i++) await append('ab');
+    await sleep(15);
+    assert.equal(probes.length, 1, 'unchanged rejected initial bytes wait for video growth');
+    assert.equal(await evaluate('probeWaits'), waits, 'audio appends do not accumulate pending video waiters');
+    await append('vb'); await finishInitial();
+    assert.equal(probes.length, 2); assert.equal(await count(), 1);
+  } else if (scenario.startsWith('initial')) {
+    await waitFor(() => pending.length === 1);
+    await append('ab'); await append('ab'); await sleep(15);
+    assert.equal(probes.length, 1, 'loadMedia and first append share one initial probe');
+    if (scenario === 'initial-growth') {
+      await append('vb'); await append('vb');
+      pending.shift()(metadata(8));
+      await waitFor(() => pending.length === 1);
+      assert.equal(probes.length, 2, 'one latest-input recheck after coalesced appends');
+      assert.equal(await count(), 0, 'obsolete initial input cannot publish metadata');
+      hold = false; pending.shift()(metadata(24));
+      await finishInitial(); assert.equal(await duration(), 24);
+    } else if (scenario === 'initial-source') {
+      await evaluate('v.src="replacement.mp4";v.load()');
+      hold = false; pending.shift()(metadata(123));
+      await sleep(25); assert.equal(await count(), 1);
+      assert.equal(await duration(), 8, 'only the replacement source can publish metadata');
+    } else {
+      hold = false; pending.shift()(metadata(8));
+      await finishInitial(); assert.equal(await count(), 1);
+      await append('ab'); await sleep(15);
+      assert.equal(probes.length, 1, 'initial probe does not leave a blocked duplicate waiter');
+    }
+  } else {
+    await finishInitial(); assert.equal(probes.length, 1);
+    if (scenario === 'audio-only') {
+      await append('vb'); await waitFor(() => probes.length === 2);
+      for (let i = 0; i < 5; i++) await append('ab');
+      await sleep(20); assert.equal(probes.length, 2, 'audio appends reuse unchanged video metadata');
+      assert.equal(await count(), 1);
+    } else if (scenario === 'refresh-growth' || scenario === 'pipe-change') {
+      hold = true; await append('vb'); await waitFor(() => pending.length === 1);
+      if (scenario === 'pipe-change') await evaluate('ms.removeSourceBuffer(vb);globalThis.vb=ms.addSourceBuffer("video/mp4")');
+      await append('vb'); await append('vb');
+      assert.equal(probes.length, 2, 'no parallel refresh');
+      pending.shift()(metadata(20));
+      await waitFor(() => pending.length === 1);
+      assert.equal(probes.length, 3); assert.equal(await duration(), 8, 'stale pipe/generation cannot overwrite metadata');
+      hold = false; pending.shift()(metadata(40));
+      await waitFor(async () => await duration() === 40);
+      assert.equal(await count(), 1);
+    } else if (scenario === 'failed-retry') {
+      failNext = true; await append('vb'); await waitFor(() => probes.length === 2);
+      await append('ab'); await waitFor(() => probes.length === 3);
+      assert.deepEqual(probes[1], probes[2], 'same failed snapshot is retryable');
+      await append('ab'); await sleep(15); assert.equal(probes.length, 3);
+    } else if (scenario === 'mime-change') {
+      await evaluate('vb.changeType("video/webm")'); await append('ab');
+      await waitFor(() => probes.length === 2);
+      assert.deepEqual(probes[0], probes[1], 'MIME change invalidates identical byte input');
+    } else if (scenario === 'epoch-inflight') {
+      hold = true; await append('vb'); await waitFor(() => pending.length === 1);
+      await evaluate('v.currentTime=3'); pending.shift()(metadata(20));
+      await waitFor(() => pending.length === 1);
+      assert.equal(probes.length, 3);
+      assert.equal(await duration(), 8, 'seek to another epoch rejects old in-flight metadata');
+      hold = false; pending.shift()(metadata(40));
+      await waitFor(async () => await duration() === 40);
+    } else if (scenario === 'moving-snapshot') {
+      hold = true; await append('vb'); await waitFor(() => pending.length === 1);
+      await evaluate('v.currentTime=3');
+      hold = false; pending.shift()(metadata(20));
+      await waitFor(async () => await duration() === 20);
+      await sleep(20);
+      assert.equal(probes.length, 2, 'clock movement alone cannot restart an in-flight snapshot probe');
+    } else if (scenario === 'epoch') {
+      await evaluate('v.currentTime=3'); await sleep(20); await append('ab');
+      await waitFor(() => probes.length === 2);
+      assert.deepEqual(probes[0], probes[1], 'snapshot epoch invalidates identical bytes and generation');
+    }
+  }
+  assert.deepEqual(errors, []);
+  process.stdout.write(`media probe ${scenario} passed\n`);
+} finally { renderer.dispose(); }

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

@@ -0,0 +1,79 @@
+// 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 action = process.argv[2], sleep = Bun.sleep, pipe = createBytePipe();
+pipe.append(new Uint8Array(1024));
+let decodeCount = 0, rejectAudio;
+const outputs = [], errors = [];
+const renderer = await createPageRenderer({
+  onFrame() {}, onVideo() {}, reportError:error => errors.push(String(error)),
+  fetchResource:async () => ({ok:true, contentType:'video/mp4', body:pipe}),
+  videoDecoder:{
+    probe:async () => ({duration:30, video:{width:20,height:12}, audio:{sampleRate:1000}}),
+    decode:async () => ({width:20,height:12,fps:10, seek() {}, close() {},
+      nextFrame:(w,h) => new Uint8Array(w*h*4)}),
+    async decodeAudio() {
+      decodeCount++;
+      if (decodeCount === 2) await new Promise((resolve, reject) => {rejectAudio=reject;});
+      let position = 0;
+      return {sampleRate:1000,channels:1, close() {}, nextSamples() {
+        if (position >= 1000) return null;
+        position += 100;
+        return new Float32Array(100);
+      }};
+    },
+  },
+  audio:{
+    open(options, listener) {outputs.push({listener,bytes:0});return outputs.length;},
+    write(id, bytes) {outputs[id-1].bytes+=bytes.length;},
+    close(id) {return Promise.resolve(outputs[id-1].bytes);}, finish() {},
+  },
+});
+const waitFor = async condition => {
+  for(let n=0;n<200;n++) {if(condition())return;await sleep(5);}
+  assert.fail(`timed out: ${condition}`);
+};
+try {
+  renderer.resize(240,180,1);renderer.setScripting('host');
+  await renderer.loadDocument({url:'https://refill-cancel.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('globalThis.mediaEvents=[]; const v=document.getElementById("v"); v.addEventListener("error",()=>mediaEvents.push("error")); v.addEventListener("seeked",()=>mediaEvents.push("seeked")); v.play()');
+  // The old snapshot ends at sample 1000; the newer, now-complete input
+  // makes the replacement decoder's rejection a fatal error if still active.
+  pipe.finish();
+  outputs[0].listener({event:'request',bytes:3000});
+  await waitFor(() => Boolean(rejectAudio));
+
+  if (action === 'seek') await renderer.evaluate('document.getElementById("v").currentTime=0.2');
+  else if (action === 'pause') await renderer.evaluate('document.getElementById("v").pause()');
+  else if (action === 'navigate') {
+    // The replacement is a static page; it does not need another host realm.
+    renderer.setScripting('off');
+    await renderer.loadDocument({url:'https://refill-cancel.test/next',contentType:'text/html',source:'<p id=next>Next document</p>'});
+    await renderer.whenLoaded();
+  } else assert.fail(`unknown action: ${action}`);
+
+  rejectAudio(Error('obsolete failed audio refill'));
+  if (action === 'seek') {
+    for(let n=0;n<200;n++) {
+      if (await renderer.evaluate('mediaEvents.includes("seeked")')) break;
+      await sleep(5);
+    }
+    assert.equal(await renderer.evaluate('mediaEvents.includes("seeked")'),true);
+    assert.equal(await renderer.evaluate('document.getElementById("v").paused'),false);
+    assert.equal(await renderer.evaluate('document.getElementById("v").currentTime'),0.2);
+    assert.equal(await renderer.evaluate('mediaEvents.includes("error")'),false);
+  } else {
+    await sleep(80);
+    if (action === 'pause') {
+      assert.equal(await renderer.evaluate('document.getElementById("v").paused'),true);
+      assert.equal(await renderer.evaluate('mediaEvents.includes("error")'),false);
+    } else assert.equal(await renderer.evaluate('document.body.textContent'),'Next document');
+  }
+  assert.deepEqual(errors,[]);
+  assert.equal(decodeCount,2,'an obsolete rejection must not close and reopen the media');
+  process.stdout.write(`${action} ignores an obsolete refill rejection\n`);
+} finally {renderer.dispose();}

package/test/fixtures/media-repaint.js

@@ -0,0 +1,48 @@
+// 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, report=text=>process.stdout.write(text+'\n');
+const errors=[],frames=[],messages=[];
+let seeked=0;
+const renderer=await createPageRenderer({
+  renderMinInterval:80,
+  onFrame:frame=>frames.push(frame.tile),onVideo:message=>messages.push(message),
+  fetchResource:async url=>({ok:true,url,body:new Uint8Array([1]),contentType:'video/mp4'}),
+  reportError:error=>errors.push(String(error)),
+  videoDecoder:{
+    probe:async()=>({duration:10,video:{width:20,height:12}}),
+    decode:async()=>({width:20,height:12,fps:100,
+      nextFrame(w,h){const data=new Uint8Array(w*h*4);for(let i=0;i<data.length;i+=4)data.set([60+seeked,90,120,255],i);return data;},
+      seek(ms){seeked=Math.floor(ms/100);},close(){}}),
+  },
+});
+function pixel(tile,x,y){const at=(Math.round((y-tile.y)*tile.scale)*tile.pixelWidth+Math.round((x-tile.x)*tile.scale))*4;return [...tile.pixels.subarray(at,at+4)];}
+try{
+  renderer.resize(240,180,1);renderer.setScripting('host');
+  await renderer.loadDocument({url:'https://media.test/',contentType:'text/html',source:'<style>body{margin:0}video{display:block;width:200px;height:120px}#marker{width:20px;height:20px;background:red}</style><video id=v src="clip.mp4"></video><div id=marker></div><video id=native src="clip.mp4" controls style="display:none"></video>'});
+  await renderer.whenLoaded();
+  await renderer.evaluate('document.getElementById("v").play()');
+  await sleep(160);
+  assert.ok(messages.some(message=>message.type==='video-open'),'first metadata/play starts independent presentation');
+  assert.ok(frames.at(-1).videoLayer);
+  frames.length=0;
+  await renderer.evaluate('setTimeout(()=>{document.getElementById("marker").style.background="blue"},1)');
+  await sleep(180);
+  assert.ok(frames.length>0,'scheduled UI frame is still published');
+  assert.ok(frames.every(tile=>pixel(tile,5,125).join(',')==='0,0,255,255'),'media ticks must not publish stale red UI before the scheduled rebuild');
+  await renderer.evaluate('document.getElementById("v").pause()');
+  assert.ok(messages.some(message=>message.type==='video-stop'),'pause stops independent presentation');
+  assert.equal(frames.at(-1).videoLayer,null,'paused frame returns to normal raster');
+  await renderer.evaluate('document.getElementById("v").currentTime=3');
+  await sleep(80);
+  assert.ok(seeked>0,'paused seek positions the decoder');
+  assert.ok(pixel(frames.at(-1),5,5)[0]>60,'paused seek publishes its decoded picture');
+  await renderer.evaluate('document.getElementById("v").style.display="none";document.getElementById("native").style.display="block"');
+  await renderer.evaluate('document.getElementById("native").play()');
+  const before=frames.length;
+  await sleep(140);
+  assert.ok(frames.length>before,'native controls/local playback continue repainting');
+  assert.equal(frames.at(-1).videoLayer,null,'native controls retain the normal rendering path');
+  await renderer.evaluate('document.getElementById("native").pause()');
+  assert.deepEqual(errors,[]);report('media repaint integration passed');
+}finally{renderer.dispose();}

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();}