demuxe 0.3.0-beta.3

package/web/io-worker.js

@@ -0,0 +1,65 @@
+import {LocalFileReader} from './file-reader.js';
+import {RangeReader} from './range-reader.js';
+let reader,resources,header,bytes,view,extra,urlBytes,busy=false,timer,stopped=false;
+const refreshes=new Map();
+let nativeEpoch;
+function synchronizeEpoch(){const current=Atomics.load(header,3);if(current!==nativeEpoch){nativeEpoch=current;reader?.beginEpoch();resources?.beginEpoch();}}
+self.onmessage=async({data})=>{
+  try{
+    if(data.type==='init'){
+      header=new Int32Array(data.memory,data.pointer,16);bytes=new Uint8Array(data.memory,data.pointer+64,262144);view=new DataView(data.memory,data.pointer,64);
+      const refresh=data.canRefresh?(resource)=>new Promise((resolve,reject)=>{const id=crypto.randomUUID();const timeout=setTimeout(()=>{refreshes.delete(id);reject(Error('Authorization refresh timed out'));},5000);refreshes.set(id,{resolve,reject,timeout});postMessage({type:'refresh',id,resource});}):undefined;
+      if(!data.file&&data.options.format&&data.options.format!=='file'){
+        if(!['hls','dash'].includes(data.options.format))throw Error('Unknown remote source format');
+        const {ResourceLoader}=await import('./resource-loader.js');
+        if(stopped)return;
+        resources=new ResourceLoader(data.options,refresh);
+        extra=new DataView(data.memory,data.pointer+64+262144,24);
+        urlBytes=new Uint8Array(data.memory,data.pointer+64+262144+24,4096);
+        const info=await resources.open(data.options.url,{manifest:true});
+        postMessage({type:'ready',info:{...info,resource:info.id}});startPump();return;
+      }
+      reader=data.file?new LocalFileReader(data.file):new RangeReader(data.options,refresh);
+      const info=await reader.open();postMessage({type:'ready',info});startPump();
+    }else if(data.type==='epoch'){synchronizeEpoch();}
+    else if(data.type==='close'){stopped=true;if(header)Atomics.notify(header,0);reader?.close();resources?.close();clearInterval(timer);for(const r of refreshes.values()){clearTimeout(r.timeout);r.reject(Error('Closed'));}refreshes.clear();postMessage({type:'closed'});}
+    else if(data.type==='refreshed'){const r=refreshes.get(data.id);if(r){clearTimeout(r.timeout);refreshes.delete(data.id);data.error?r.reject(Error('Authorization refresh failed')):r.resolve(data.update);}}
+  }catch(error){postMessage({type:'error',message:'Source transport: '+error.message});}
+};
+async function pump(){
+  if(busy||(Atomics.load(header,0)&7)!==1)return;
+  synchronizeEpoch();busy=true;const requestState=Atomics.load(header,0);const serial=Atomics.load(header,1),epoch=Atomics.load(header,3);
+  try{
+    let output=new Uint8Array(),result=0,opened;
+    if(resources){
+      const operation=Atomics.load(header,15),id=extra.getInt32(0,true);
+      if(operation===1){
+        const zero=urlBytes.indexOf(0);if(zero<0)throw Error('Resource URL exceeds mailbox capacity');
+        const url=new TextDecoder('utf-8',{fatal:true}).decode(urlBytes.slice(0,zero));
+        const start=extra.getBigInt64(8,true),end=extra.getBigInt64(16,true);
+        opened=await resources.open(url,start<0?{}:{start,end});result=opened.id;
+      }else if(operation===2){output=resources.read(id,view.getBigUint64(32,true),Atomics.load(header,4));result=output.length;}
+      else if(operation===3)resources.closeHandle(id);
+      else throw Error('Invalid resource operation');
+    }else{output=await reader.read(view.getBigUint64(32,true),Atomics.load(header,4));result=output.length;}
+    if((Atomics.load(header,0)&7)!==1||Atomics.load(header,1)!==serial||Atomics.load(header,3)!==epoch){if(opened)resources.closeHandle(opened.id);return;}
+    if(opened)view.setBigInt64(40,BigInt(opened.size),true);
+    bytes.set(output);Atomics.store(header,5,result);if(Atomics.compareExchange(header,0,requestState,requestState+1)===requestState)Atomics.notify(header,0);
+  }catch(error){
+    if(Atomics.load(header,0)===requestState&&Atomics.load(header,1)===serial&&Atomics.load(header,3)===epoch){Atomics.store(header,5,-1);if(Atomics.compareExchange(header,0,requestState,requestState+2)===requestState)Atomics.notify(header,0);if(error.name!=='AbortError')postMessage({type:'error',message:'Source transport: '+error.message});}
+  }finally{busy=false;postMessage({type:'stats',stats:{...(resources??reader).stats,size:String(reader?.total??0),reads:Atomics.load(header,12),seeks:Atomics.load(header,13),interruptions:Atomics.load(header,14)}});}
+}
+
+function startPump(){
+  nativeEpoch=Atomics.load(header,3);
+  if(typeof Atomics.waitAsync!=='function'){timer=setInterval(pump,2);return;}
+  void (async()=>{
+    while(!stopped){
+      await pump();
+      if(stopped)break;
+      const state=Atomics.load(header,0);
+      if((state&7)===1)continue;
+      await Atomics.waitAsync(header,0,state,1000).value;
+    }
+  })();
+}

package/web/native-ass-worker.js

@@ -0,0 +1,26 @@
+// Owns one pinned libass instance. No transport, media decoder or independent clock.
+let engine;
+function bytesCall(name,bytes,extra=[]){
+ const p=engine._malloc(bytes.byteLength+1);if(!p)throw Error('Subtitle allocation failed');
+ try{engine.HEAPU8.set(bytes,p);engine.HEAPU8[p+bytes.byteLength]=0;return engine.ccall(name,'number',[...extra.map(()=> 'string'),'number','number'],[...extra,p,bytes.byteLength]);}finally{engine._free(p);}
+}
+let chain=Promise.resolve();
+onmessage=({data})=>{chain=chain.then(async()=>{
+ try{
+  if(data.type==='init'){
+   if(engine)throw Error('Subtitle worker already initialized');
+   const {default:create}=await import('./engine-ass/subtitles.mjs');engine=await create();
+   if(engine._subtitle_api_version?.()!==2)throw Error('Subtitle runtime interface mismatch; use matching worker and Wasm assets');
+   if(engine._subtitle_init()<0)throw Error('libass initialization failed');
+   if(data.fonts.length>17)throw Error('Font count exceeded');
+   for(const f of data.fonts)if(bytesCall('subtitle_font',new Uint8Array(f.bytes),[f.name])<0)throw Error('Font budget exceeded');
+  }else if(data.type==='load'){
+   if(bytesCall('subtitle_load',new Uint8Array(data.bytes))<0)throw Error('Invalid ASS or subtitle budget exceeded');
+  }else if(data.type==='render'){
+   const size=engine._subtitle_render(data.seconds,data.width,data.height,+data.force,data.sourceWidth,data.sourceHeight);if(size===-2){postMessage({id:data.id,unchanged:true,tiles:[],size:0});return;}if(size<0)throw Error('Subtitle render budget exceeded');
+   const tiles=engine.tiles;engine.tiles=[];
+   postMessage({id:data.id,tiles,size},tiles.map(t=>t.bytes.buffer));return;
+  }else throw Error('Unknown subtitle operation');
+  postMessage({id:data.id});
+ }catch(error){postMessage({id:data.id,error:String(error)});}
+});};

package/web/native-remux-player.js

@@ -0,0 +1,301 @@
+// Native execution plan. MSE stays in the window; demux/mux and
+// bounded source reads use separate workers, so synchronous Wasm AVIO cannot
+// block the event loop responsible for completing its reads.
+const byteLength=value=>Array.isArray(value)?value.reduce((n,b)=>n+b.byteLength,0):value?.byteLength||0;
+export function windowedBrowserSupported(ua=globalThis.navigator?.userAgent??''){return /Chrome\//.test(ua)&&!/Firefox|Edg\/|OPR\/|Android|Mobile/.test(ua);}
+export class RemuxPlayer {
+ constructor(video,{bufferedSeeks=false,audioAdaptation}={}){
+  this.audioAdaptation=audioAdaptation;
+  this.bufferedSeeks=bufferedSeeks&&typeof video.requestVideoFrameCallback==='function';
+  this.video=video;this.timelineBias=1;this.generation=0;this.stopped=false;this.stats={fragments:[],generatedBytes:0,discardedBytes:0,peakQueueDepth:0,bufferedBytesUpperBound:0,peakBufferedBytesUpperBound:0,peakBufferedSeconds:0,seeks:[],sessions:[],errors:[],workers:0,recoveries:[],gapSkips:[]};
+  this.segments=[];this.sourceStats={};this.remuxStats={};this.timer=setInterval(()=>this.pump(),50);
+ }
+ async open(source,target=0){
+  if(this.source&&(this.source.file!==source.file||this.source.options?.url!==source.options?.url)){this.identity=undefined;this.duration=undefined;}
+  this.recoveryAttempts=0;this.source=source;return this.restart(target);
+ }
+ async restart(target){
+  if(this.stopped)throw Error('Remux player is destroyed');
+  if(!Number.isFinite(target)||target<0||(this.duration!==undefined&&target>=this.duration))throw Error('Seek target out of range');
+  const serial=(this.restartSerial??0)+1;this.restartSerial=serial;this.starting=true;
+  const rejected=new Set();
+  try{
+   for(;;){
+    this.packagingFailure=false;
+    try{return await this.start(target,rejected);}catch(error){
+     if(serial!==this.restartSerial||this.stopped)throw error;
+     this.stopWorkers();
+     if(!this.packagingFailure||!this.mime||rejected.has(this.mime)||rejected.size>=1)throw error;
+     rejected.add(this.mime);
+    }
+   }
+  }finally{if(serial===this.restartSerial)this.starting=false;}
+ }
+ async start(target,rejected=new Set()){
+  if(this.stopped)throw Error('Remux player is destroyed');
+  const begun=performance.now(),generation=++this.generation;this.stopWorkers();
+  this.windowed=false;this.headerAccepted=false;this.presentationFloor=0;this.pulling=false;this.pullId=0;this.resumingWindow=false;this.primeVideo=false;this.sbs=[];this.receipts=new Map();this.pendingUpdates=new Set();this.lastEvictions=[];
+  this.failedGeneration=undefined;this.failureError=undefined;this.stats.errors=[];this.stats.seeks.push({target,started:begun});if(this.stats.seeks.length>64)this.stats.seeks.shift();this.target=target;this.targetReady=false;this.frames=[];this.muxedFrames=false;this.lastEviction=-Infinity;this.raps=[];this.busy=true;this.eof=false;this.pending=null;this.receipt=null;this.segments=[];this.sourceStats={};this.remuxStats={};
+  this.video.pause();this.video.removeAttribute('src');this.video.load();if(this.objectURL)URL.revokeObjectURL(this.objectURL);
+  this.media=new MediaSource();this.objectURL=URL.createObjectURL(this.media);this.video.src=this.objectURL;
+  await new Promise((resolve,reject)=>{
+   const media=this.media;
+   const finish=error=>{clearTimeout(timer);media.removeEventListener('sourceopen',opened);if(this.cancelWait===cancel)this.cancelWait=null;error?reject(error):resolve();};
+   const opened=()=>finish(),cancel=error=>finish(error);
+   const timer=setTimeout(()=>finish(Error('MSE sourceopen timeout')),10000);
+   this.cancelWait=cancel;media.addEventListener('sourceopen',opened,{once:true});
+  });
+  if(generation!==this.generation)throw new DOMException('Superseded','AbortError');
+  this.mailbox=new SharedArrayBuffer(64+262144);this.sourceWorker=new Worker(new URL('./native-remux-source-worker.js',import.meta.url),{type:'module'});this.stats.workers++;
+  const ready=await new Promise((resolve,reject)=>{
+   const timer=setTimeout(()=>finish(Error('Remux source initialization timed out')),10000);
+   let settled=false;
+   const finish=(error,data)=>{if(settled)return;settled=true;clearTimeout(timer);if(this.cancelWait===cancel)this.cancelWait=null;error?reject(error):resolve(data);};
+   const cancel=error=>finish(error);this.cancelWait=cancel;this.watchWorker(this.sourceWorker,generation,'source');this.sourceWorker.onmessage=({data})=>{if(generation!==this.generation||this.stopped||this.failedGeneration===generation)return;if(data.type==='refresh'){Promise.resolve().then(()=>{if(!this.source.refreshAuthorization)throw Error('Authorization refresh unavailable');return this.source.refreshAuthorization(data.resource);}).then(update=>{if(generation===this.generation)this.sourceWorker?.postMessage({type:'refreshed',update});},error=>{if(generation===this.generation)this.sourceWorker?.postMessage({type:'refreshed',error:String(error)});});}if(data.type==='ready')finish(null,data);if(data.type==='stats')this.sourceStats=data.stats;if(data.type==='error'){const message='Source transport: '+data.message;finish(Error(message));this.fail(message);}};
+   const {refreshAuthorization,...source}=this.source;this.sourceWorker.postMessage({type:'init',mailbox:this.mailbox,...source,identity:this.identity});
+  });
+  if(generation!==this.generation)throw new DOMException('Superseded','AbortError');
+  this.identity??=ready.identity;this.total=ready.size;this.worker=new Worker(new URL('./native-remux-worker.js',import.meta.url),{type:'module'});this.stats.workers++;this.watchWorker(this.worker,generation,'mux');
+  this.cancelWait=null;const session={generation,target,sourceSize:ready.size,firstPlayableMs:null,firstPlayableSourceBytes:null};this.stats.sessions.push(session);if(this.stats.sessions.length>64)this.stats.sessions.shift();
+  this.worker.onmessage=({data})=>{
+   if(generation!==this.generation||this.stopped||this.failedGeneration===generation){this.stats.discardedBytes+=byteLength(data.buffers??data.buffer);return;}
+   if(data.type==='error'){this.fail(data.message);return;}
+   if(data.type==='log'){(this.logs??=[]).push(data.message);if(this.logs.length>32)this.logs.shift();return;}
+   if(data.type==='fragment'&&(!this.pulling||data.id!==this.pullId)){this.fail('Unexpected remux fragment operation');return;}
+   if(data.type==='ready'){if(this.headerAccepted){this.fail('Duplicate remux initialization');return;}this.headerAccepted=true;}
+   if(data.presentationFrames){this.muxedFrames=true;this.frames.push(...data.presentationFrames.map(([pts,duration])=>[pts-this.timelineBias,duration]));}else if(data.frames)this.frames.push(...data.frames);if(this.frames.length>4096)this.frames.splice(0,this.frames.length-4096);
+   if(data.stats)this.remuxStats=data.stats;this.stats.generatedBytes+=byteLength(data.buffers??data.buffer);
+   if(data.type==='negotiate'){
+    if(data.windowed&&!windowedBrowserSupported()){this.fail('Long unequal-track Native adaptation is unsupported in this browser; use Hybrid','UNSUPPORTED_TIMELINE');return;}
+    session.packaging=[];
+    for(const candidate of data.candidates){
+     const attempt={...candidate};session.packaging.push(attempt);
+     if(rejected.has(candidate.mime)){attempt.rejected='Initialization append failed';continue;}
+     if(!MediaSource.isTypeSupported(candidate.mime)){attempt.rejected='MSE type unsupported';continue;}
+     try{
+      const mimes=data.windowed?data.lanes:[candidate.mime];
+      if(!mimes?.length||mimes.some(m=>!MediaSource.isTypeSupported(m)))throw Error('Unsupported selected track packaging');
+      this.sbs=[];for(const mime of mimes)this.sbs.push(this.media.addSourceBuffer(mime));this.sb=this.sbs[0];
+      this.windowed=!!data.windowed;this.trackBounds=data.trackBounds;this.presentationFloor=this.windowed&&target>=Math.min(this.trackBounds.videoEnd,this.trackBounds.audioEnd)?Math.max(0,target-.5):0;this.primeVideo=this.windowed&&target>=this.trackBounds.videoEnd&&this.trackBounds.videoEnd<this.trackBounds.audioEnd;
+     }catch(error){for(const sb of this.sbs)this.media.removeSourceBuffer(sb);this.sbs=[];attempt.rejected=String(error);continue;}
+     attempt.selected=true;this.mime=candidate.mime;
+     this.worker.postMessage({type:'select-container',container:candidate.container});return;
+    }
+    this.fail('Unsupported MSE packaging for selected codecs');return;
+   }
+   if(data.type==='ready'){
+    try{
+     if(target<0||target>=data.duration)throw Error('Seek target out of range');
+     if(!MediaSource.isTypeSupported(data.mime))throw Error(`Unsupported MSE ${data.mime}`);
+     this.duration=data.duration;this.tracks=data.tracks;this.mime=data.mime;this.media.duration=data.duration+this.timelineBias;
+     for(const sb of this.sbs){
+      sb.mode='segments';sb.timestampOffset=0;
+      sb.addEventListener('updateend',()=>this.updateFinished(sb,generation));
+      sb.addEventListener('error',()=>{if(generation===this.generation){this.packagingFailure=true;this.fail('MSE SourceBuffer error');}});
+     }
+     try{this.append(data.buffers??[data.buffer]);}catch(error){this.packagingFailure=error.name!=='QuotaExceededError';throw error;}
+    }catch(e){this.fail(String(e));}
+   }else if(data.type==='fragment'){
+    this.pulling=false;
+
+    this.raps.push(...data.raps);if(this.raps.length>256)this.raps.splice(0,this.raps.length-256);
+    this.pending=data.buffers??[data.buffer];this.eof=!data.more;this.busy=false;this.stats.peakQueueDepth=Math.max(this.stats.peakQueueDepth,1);this.pump();
+   }
+  };
+  this.worker.postMessage({type:'init',mailbox:this.mailbox,size:ready.size,target,audioAdaptation:this.audioAdaptation,videoTrack:this.source.videoTrack,audioTrack:this.source.audioTrack});
+  await new Promise((resolve,reject)=>{
+   const deadline=performance.now()+20000;const check=()=>{
+    if(generation!==this.generation){reject(new DOMException('Superseded','AbortError'));return;}
+    if(this.stats.errors.length){reject(this.failureError??Error(this.stats.errors.at(-1)));return;}
+    // Initial decoder preroll can leave a short leading gap in the playable range.
+    if(!this.primeVideo&&(!this.windowed||!this.busy&&!this.pulling&&!this.pending)&&this.hasStartupCoverage()){
+     this.acceptedSource=this.source;this.acceptedGeneration=generation;this.targetReady=true;this.video.currentTime=target+this.timelineBias;
+     session.firstPlayableMs=performance.now()-begun;session.firstPlayableSourceBytes=this.sourceStats.fetchedBytes;
+     session.generatedBytes=this.remuxStats.generatedBytes;session.fetchedBytesAtLeastSourceSize=(this.sourceStats.fetchedBytes>=ready.size);
+     resolve();return;
+    }
+    if(performance.now()>deadline){reject(Error('Remux target buffer timeout'));return;}setTimeout(check,20);
+   };check();
+  });
+  return session;
+ }
+ hasStartupCoverage(){
+  const target=this.target,margin=this.windowed?Math.min(.02,Math.max(0,this.duration-target)/2):.02;
+  return this.ranges().some(([a,b])=>a<=target+.5&&b>target+margin);
+ }
+ contains(t){t+=this.timelineBias;const b=this.sb?.buffered;if(!b)return false;for(let i=0;i<b.length;i++)if(t>=b.start(i)&&t<b.end(i))return true;return false;}
+ ranges(){const b=this.windowed?this.video.buffered:this.sb?.buffered;return b?Array.from({length:b.length},(_,i)=>[(this.windowed?Math.max(b.start(i)-this.timelineBias,this.presentationFloor??0):b.start(i)-this.timelineBias),b.end(i)-this.timelineBias]).filter(([a,b])=>b>a):[];}
+ updateFinished(sb,generation){
+       if(generation!==this.generation||!this.pendingUpdates.delete(sb))return;
+       const receipt=this.receipts.get(sb);if(receipt){receipt.end=sb.buffered.length?sb.buffered.end(sb.buffered.length-1)-this.timelineBias:Infinity;this.receipts.delete(sb);}
+       if(this.pendingUpdates.size||this.sbs.some(s=>s.updating))return;
+       this.busy=false;
+       if(this.windowed&&this.media.readyState==='open'&&this.sbs.every(s=>s.buffered.length)){
+        try{this.media.endOfStream();}catch(error){this.fail(String(error));return;}
+       }
+       if(this.primeVideo)this.primeLastVideo(generation);
+       this.resumeWindow();
+       this.pump();
+ }
+ append(buffers){
+  this.busy=false;
+  buffers.forEach((buffer,lane)=>{
+   if(!buffer.byteLength)return;
+   const sb=this.sbs[lane];if(!sb)throw Error('Unexpected fragment lane');
+   this.busy=true;const receipt={lane,bytes:buffer.byteLength,end:Infinity};this.segments.push(receipt);this.receipts.set(sb,receipt);this.pendingUpdates.add(sb);
+   this.stats.fragments.push({lane,bytes:buffer.byteLength,at:performance.now(),generation:this.generation});if(this.stats.fragments.length>256)this.stats.fragments.shift();sb.appendBuffer(buffer);
+  });
+  if(!this.busy)this.pump();
+ }
+ expectedVideoFrame(target){return this.frames?.filter(([pts])=>pts<=target+.000001).sort((a,b)=>a[0]-b[0]).at(-1)?.[0];}
+ matchesVideoFrame(target,mediaTime){
+  if(!this.muxedFrames)return undefined;
+  const epsilon=.000001;
+  return this.frames.some(([pts,duration])=>target>=pts-epsilon&&target<pts+duration+epsilon&&mediaTime>=pts+this.timelineBias-epsilon&&mediaTime<=target+this.timelineBias+epsilon);
+ }
+ primeLastVideo(generation){
+  if(this.primeFrame||!this.primeVideo||this.sbs.some(s=>s.updating))return;
+  const b=this.sb.buffered;
+  if(!b.length||b.end(b.length-1)-this.timelineBias<this.trackBounds.videoEnd-.002)return;
+  const target=b.end(b.length-1)-.001,expected=this.expectedVideoFrame(this.trackBounds.videoEnd);
+  if(expected===undefined)return;
+  const a=this.sbs[1].buffered;if(!Array.from({length:a.length},(_,i)=>[a.start(i),a.end(i)]).some(([start,end])=>target>=start&&target<end))return;
+  this.busy=true;if(this.media.readyState==='open')this.media.endOfStream();
+  let presented;
+  const clean=()=>{clearTimeout(this.primeTimeout);this.video.removeEventListener('seeked',complete);if(this.primeFrame)this.video.cancelVideoFrameCallback(this.primeFrame);this.primeFrame=0;this.cancelPrime=null;};
+  const complete=()=>{
+   if(generation!==this.generation||this.stopped||!presented||this.video.seeking||Math.abs(this.video.currentTime-target)>.002)return;
+   clean();this.primeVideo=false;
+   (this.stats.tailPrimes??=[]).push({generation,frame:presented.mediaTime-this.timelineBias,target:this.target});if(this.stats.tailPrimes.length>64)this.stats.tailPrimes.shift();
+   this.busy=false;this.pump();
+  };
+  const check=(_,metadata)=>{
+   if(generation!==this.generation||this.stopped)return;
+   if(metadata.mediaTime>=expected+this.timelineBias-.001&&metadata.mediaTime<=target+.001&&Math.abs(this.video.currentTime-target)<.002)presented=metadata;
+   complete();if(this.primeVideo)this.primeFrame=this.video.requestVideoFrameCallback(check);
+  };
+  this.cancelPrime=clean;this.video.addEventListener('seeked',complete);
+  this.primeTimeout=setTimeout(()=>{if(generation===this.generation)this.fail('Completed video preroll did not present a frame');},10000);
+  this.primeFrame=this.video.requestVideoFrameCallback(check);this.video.currentTime=target;
+ }
+ resumeWindow(){
+  if(!this.windowed||!this.recoveryPlaying||!this.video.paused||this.starting||this.stopped||this.video.seeking||this.resumingWindow)return;
+  if(this.video.ended){
+   if(this.playbackEnded)return;
+   const at=this.video.currentTime,b=this.video.buffered;
+   if(!b.length||b.end(b.length-1)<=at+.05)return;
+   // play() at an ended media element rewinds it. Clear the internal window-end
+   // state with a seek to the same position after new real coverage arrives.
+   this.video.currentTime=at;return;
+  }
+  const generation=this.generation;this.resumingWindow=true;
+  void this.video.play().catch(error=>{if(generation===this.generation&&this.recoveryPlaying&&!this.stopped)this.fail(String(error));}).finally(()=>{if(generation===this.generation)this.resumingWindow=false;});
+ }
+ pump(){
+  if(this.stopped||!this.sb||this.busy||this.pulling||(this.sbs??[this.sb]).some(s=>s.updating)||!['open',...(this.windowed?['ended']:[])].includes(this.media.readyState))return;
+  try{
+   if(this.windowed&&this.targetReady&&!this.recoveryPlaying)return;
+   this.resumeWindow();
+   const now=this.targetReady?Math.max(this.video.currentTime-this.timelineBias,this.target):this.target,ranges=this.ranges();
+   const seconds=ranges.reduce((s,[a,b])=>s+b-a,0);this.stats.peakBufferedSeconds=Math.max(this.stats.peakBufferedSeconds,seconds);
+   // Evict old complete intervals. Retain three seconds behind playback; browser
+   // codec dependencies may keep internal resources beyond the coded ranges.
+   // MSE removal can extend through dependent frames to the next RAP. Never
+   // remove through the GOP currently decoding; evict at known source RAPs.
+   if(this.windowed&&this.targetReady){
+    for(let lane=0;lane<this.sbs.length;lane++){
+     const sb=this.sbs[lane],end=lane?this.trackBounds.audioEnd:this.trackBounds.videoEnd;
+     const limit=Math.min(now-3,end-.5),cut=lane?limit:this.raps.filter(t=>t<=limit).at(-1);
+     if(cut!==undefined&&sb.buffered.length&&sb.buffered.start(0)-this.timelineBias<cut-.001&&cut>(this.lastEvictions[lane]??-Infinity)){
+      this.busy=true;this.lastEvictions[lane]=cut;this.pendingUpdates.add(sb);sb.remove(0,cut+this.timelineBias-.00001);this.segments=this.segments.filter(s=>s.lane!==lane||s.end>cut);return;
+     }
+    }
+   }
+   const cut=this.windowed?undefined:this.raps.filter(t=>t<=now-3).at(-1);
+   if(this.targetReady&&cut!==undefined&&ranges.length&&ranges[0][0]<cut-.001&&cut>this.lastEviction){this.busy=true;this.lastEviction=cut;this.pendingUpdates?.add(this.sb);this.sb.remove(0,cut+this.timelineBias-.00001);this.segments=this.segments.filter(s=>s.end>cut);return;}
+   const bufferedBytes=this.segments.reduce((s,v)=>s+v.bytes,0);this.stats.bufferedBytesUpperBound=bufferedBytes;this.stats.peakBufferedBytesUpperBound=Math.max(this.stats.peakBufferedBytesUpperBound,bufferedBytes);
+   if(this.pending){
+    const buffers=this.pending;this.pending=null;
+    if(byteLength(buffers)){this.append(buffers);return;}
+   }
+   // Account for the same short leading codec-preroll gap admitted by start().
+   // Otherwise a sub-millisecond gap can look like zero buffered data while paused
+   // and drain the entire source before the media element advances into the range.
+   // Some valid edits leave a short hole between MSE coded ranges. Advance
+   // only while playing at the end of a range, within a half-second budget.
+   const next=ranges.find(([a])=>a>now+.001);
+   if(this.targetReady&&!this.video.paused&&this.video.readyState<3&&next&&next[0]-now<=.5){
+    this.stats.gapSkips.push({from:now,to:next[0]});if(this.stats.gapSkips.length>64)this.stats.gapSkips.shift();
+    this.video.currentTime=next[0]+this.timelineBias;
+   }
+   const ahead=ranges.find(([a,b])=>a<=now+0.5&&now<=b)?.[1]-now||0;
+   if(ahead<5&&ranges.at(-1)?.[1]>now+12){this.fail('Remux timeline gap exceeds forward buffer budget');return;}
+   if(this.eof&&!this.pending){if(this.audioAdaptation&&this.remuxStats.adaptation?.sourceEnd>0){this.duration=this.remuxStats.adaptation.sourceEnd;if(!this.windowed)this.media.duration=this.duration+this.timelineBias;}if(this.media.readyState==='open')this.media.endOfStream();return;}
+   const preparedAhead=this.audioAdaptation?Math.max(0,(this.remuxStats.adaptation?.sourceEnd??now)-now):0;
+   // MSE exposes the intersection of selected tracks. Never encode an entire
+   // longer track merely to make a shorter track's buffered range advance.
+   if(!this.eof&&preparedAhead>=5&&ahead<.25&&!this.video.paused){this.fail('Adapted track timelines cannot progress within the preparation budget; use Hybrid');return;}
+   if(this.windowed&&!this.targetReady&&!this.primeVideo&&this.hasStartupCoverage())return;
+   if(!this.eof&&ahead<5&&preparedAhead<5&&bufferedBytes<12*1024*1024){this.busy=true;this.pulling=true;this.worker.postMessage({type:'next',id:this.pullId=(this.pullId??0)+1});}
+  }catch(e){this.fail(String(e));}
+ }
+ watchWorker(worker,generation,label){
+  const failed=event=>{if(generation!==this.generation||this.stopped)return;event.preventDefault?.();this.fail(`Remux ${label} worker failed: ${event.message||event.type}`);};
+  worker.onerror=failed;worker.onmessageerror=failed;
+ }
+ fail(message,code){
+  if(this.stopped||this.failedGeneration===this.generation)return;
+  this.failedGeneration=this.generation;this.failureError=Object.assign(Error(message),code?{code}:{});
+  const target=Math.max(0,this.video.currentTime-this.timelineBias),playing=this.windowed?!!this.recoveryPlaying:!this.video.paused;
+  this.stats.errors.push(message);this.cancelWait?.(this.failureError);this.cancelWait=null;this.stopWorkers();
+  if(this.starting)return;
+  // One transient worker/MSE restart per explicit open. Codec changes and
+  // source-identity failures go directly to the owner's compatibility fallback.
+  if((this.recoveryAttempts??0)<1&&/worker failed|MSE SourceBuffer error|QuotaExceededError/.test(message)){
+   this.recoveryAttempts=(this.recoveryAttempts??0)+1;
+   const recovery={target,reason:message,attempt:this.recoveryAttempts,restored:false};this.stats.recoveries.push(recovery);if(this.stats.recoveries.length>64)this.stats.recoveries.shift();
+   this.recoveryPlaying=playing;
+   void this.restart(target).then(async()=>{if(this.stopped)return;if(this.recoveryPlaying)await this.video.play();recovery.restored=true;},error=>{if(!this.stopped)this.onError?.(String(error));}).catch(error=>{if(!this.stopped)this.onError?.(String(error));});
+  }else this.onError?.(message);
+ }
+
+ stopWorkers(){
+  this.cancelPrime?.();clearTimeout(this.primeTimeout);if(this.primeFrame)this.video.cancelVideoFrameCallback(this.primeFrame);this.primeFrame=0;
+  if(this.worker){(this.stats.cancellations??=[]).push({adaptation:this.remuxStats.adaptation?{...this.remuxStats.adaptation}:undefined,generatedBytes:this.remuxStats.generatedBytes||0,pendingBytes:byteLength(this.pending),retainedCompressedBytesUpperBound:this.segments.reduce((n,s)=>n+s.bytes,0),sourceFetchedBytes:this.sourceStats.fetchedBytes||0,inFlightOutputUpperBound:(this.windowed?16:8)*1024*1024});if(this.stats.cancellations.length>64)this.stats.cancellations.shift();}
+  this.cancelWait?.(new DOMException('Superseded','AbortError'));this.cancelWait=null;
+  if(this.pending)this.stats.discardedBytes+=byteLength(this.pending);
+  if(this.mailbox){const h=new Int32Array(this.mailbox,0,16);Atomics.store(h,4,1);Atomics.store(h,0,3);Atomics.notify(h,0);}
+  this.sourceWorker?.postMessage({type:'close'});this.sourceWorker?.terminate();this.worker?.terminate();this.sourceWorker=this.worker=null;this.stats.workers=0;this.sb=null;this.sbs=[];
+ }
+ canSeekBuffered(t){
+  // A held final video frame produces no new compositor callback to verify a
+  // buffered seek. Regenerate its bounded real preroll instead.
+  if(this.windowed&&t>=this.trackBounds.videoEnd)return false;
+  if(!this.bufferedSeeks||!Number.isFinite(t)||t<0||this.stopped||this.starting||!this.targetReady||this.failedGeneration===this.generation||this.acceptedGeneration!==this.generation||this.acceptedSource!==this.source||!this.sb||this.sb.updating||!['open','ended'].includes(this.media?.readyState))return false;
+  // Appended history is not playable coverage. Check both the media element's
+  // intersection and the current SourceBuffer after browser eviction/removal.
+  const media=this.video.buffered;
+  const range=this.ranges().find(([a,b])=>t>=a&&t+.25<b);
+  if(!range)return false;
+  const rap=this.raps.filter(r=>r<=t&&r>=range[0]-.001).at(-1);
+  if(rap===undefined)return false;
+  for(let i=0;i<media.length;i++)if(rap+this.timelineBias>=media.start(i)-.001&&t+this.timelineBias+.25<media.end(i))return true;
+  return false;
+ }
+ async seek(t){
+  if(this.canSeekBuffered(t)){
+   // Keep the producer's forward position. Only consumption moves backwards;
+   // using the previous target here would evict media at the new playhead.
+   this.target=t;this.video.currentTime=t+this.timelineBias;
+   this.stats.bufferedSeeks=(this.stats.bufferedSeeks??0)+1;
+   return {kind:'buffered',generation:this.generation,target:t};
+  }
+  return this.restart(t);
+ }
+ get playbackPaused(){return this.windowed?!this.recoveryPlaying:this.video.paused;}
+ get playbackEnded(){return this.video.ended&&(!this.windowed||this.eof&&!this.pending&&!this.busy&&this.video.currentTime>=this.duration+this.timelineBias-.02);}
+ async play(){this.recoveryPlaying=true;if(this.starting)return;if(this.windowed){this.pump();if(this.video.ended&&!this.playbackEnded){this.resumeWindow();return;}}return this.video.play();}
+ pause(){this.recoveryPlaying=false;this.video.pause();}
+ snapshot(){return {stats:structuredClone(this.stats),source:{...this.sourceStats},remux:{...this.remuxStats},windowed:this.windowed,presentationFloor:this.presentationFloor,trackBounds:this.trackBounds,ranges:this.ranges(),timelineBias:this.timelineBias,position:Math.max(0,this.video.currentTime-this.timelineBias),quality:this.video.getVideoPlaybackQuality(),readyState:this.video.readyState,logs:this.logs,videoError:this.video.error?.message};}
+ async destroy(){if(this.stopped)return;this.stopped=true;++this.generation;clearInterval(this.timer);this.stopWorkers();this.video.pause();this.video.removeAttribute('src');this.video.load();if(this.objectURL)URL.revokeObjectURL(this.objectURL);this.objectURL=null;}
+}

package/web/native-remux-source-worker.js

@@ -0,0 +1,25 @@
+import {LocalFileReader} from './file-reader.js';
+import {RangeReader} from './range-reader.js';
+let reader,file,h,view,buffer,stopped=false;
+let refreshPending;
+self.onmessage=async({data})=>{
+ if(data.type==='refreshed'){const p=refreshPending;refreshPending=null;clearTimeout(p?.timer);if(p)data.error?p.reject(Error(data.error)):p.resolve(data.update);return;}
+ if(data.type==='close'){stopped=true;reader?.close();if(h){Atomics.store(h,4,1);Atomics.store(h,0,3);Atomics.notify(h,0);}return;}
+ if(data.type!=='init')return;
+ try{
+  h=new Int32Array(data.mailbox,0,16);view=new DataView(data.mailbox);buffer=new Uint8Array(data.mailbox,64);
+  file=data.file;
+  let size,identity;
+  if(file){reader=new LocalFileReader(file);size=Number((await reader.open()).size);}
+  else{reader=new RangeReader({...data.options,cacheBytes:2*1024*1024,blockBytes:65536},resource=>new Promise((resolve,reject)=>{const timer=setTimeout(()=>reject(Error('Authorization refresh timeout')),5000);refreshPending={resolve,reject,timer};postMessage({type:'refresh',resource});}));if(data.identity){reader.etag=data.identity.etag;reader.total=BigInt(data.identity.size);}
+   identity=await reader.open();size=Number(identity.size);}
+  postMessage({type:'ready',size,identity});
+  while(!stopped){
+   if(Atomics.load(h,0)!==1){if(Atomics.waitAsync)await Atomics.waitAsync(h,0,Atomics.load(h,0),100).value;else await new Promise(r=>setTimeout(r,4));continue;}
+   const offset=view.getFloat64(32,true),n=Atomics.load(h,2);let bytes;
+   bytes=await reader.read(BigInt(offset),n);
+   if(stopped)break;buffer.set(bytes);Atomics.store(h,3,bytes.length);Atomics.store(h,0,2);Atomics.notify(h,0);
+   postMessage({type:'stats',stats:reader.stats});
+  }
+ }catch(e){if(h){Atomics.store(h,3,-1);Atomics.store(h,0,3);Atomics.notify(h,0);}postMessage({type:'error',message:String(e)});}
+};

package/web/native-remux-worker.js

@@ -0,0 +1,46 @@
+import {videoCodecConfig,vp9RemuxConfig} from './video-codec-config.js';
+import {remuxPackaging} from './remux-packaging.js';
+let engine,chunks=[],bytes=0,emptyBatches=0,negotiation,splitter,timing;
+const stats={calls:0,remuxMs:0,generatedBytes:0,peakBatchBytes:0,heapBytes:0};
+const flush=()=>{const output=new Uint8Array(bytes);let at=0;for(const b of chunks){output.set(b,at);at+=b.length;}chunks=[];bytes=0;stats.generatedBytes+=output.length;stats.peakBatchBytes=Math.max(stats.peakBatchBytes,output.length);return output;};
+const adaptationABI=()=>{if(engine.preparationInterface!==2)throw Error('Audio preparation initialization interface mismatch; install matching runtime assets');};
+const check=n=>{if(n<0)throw Error(`FFmpeg error ${n}: ${engine.UTF8ToString(engine._rm_error())}`);return n;};
+self.onmessage=async({data})=>{
+ try{
+  const start=performance.now();
+  if(data.type==='init'||data.type==='probe'){
+   const {default:createRemux}=await import(data.audioAdaptation?'./engine-adaptation/remux.mjs':'./engine-remux/remux.mjs');
+   engine=await createRemux({printErr:message=>postMessage({type:'log',message})});engine.parseVP9=vp9RemuxConfig;engine.io=data.mailbox;engine.raps=[];engine.tracks=[];
+   if(data.type==='probe'){if(data.audioAdaptation){check(engine._rm_adapt_audio(1));adaptationABI();}check(engine._rm_probe(data.size));postMessage({type:'probed',tracks:engine.tracks,duration:engine._rm_duration(),format:engine.format});return;}
+   engine.emit=b=>{bytes+=b.length;if(bytes>8*1024*1024)throw Error('Fragment budget exceeded');chunks.push(b);};
+   if(data.audioAdaptation){if(!['flac','opus'].includes(data.audioAdaptation))throw Error('Unsupported adaptation profile');if(typeof engine._rm_adapt_audio!=='function')throw Error('Audio adaptation ABI unavailable');check(engine._rm_adapt_audio(data.audioAdaptation==='opus'?2:1));adaptationABI();}
+   check(engine._rm_open(data.size,data.videoTrack??-1,data.audioTrack??-1));let duration=engine._rm_duration();
+   const video=engine.videoConfig?videoCodecConfig({...engine.videoConfig,maxWidth:8192,maxHeight:8192}).configuration.codec:engine.UTF8ToString(engine._rm_video_codec());
+   const audio=engine.UTF8ToString(engine._rm_audio_codec());
+   const bounds=engine.trackBounds;
+   if(data.audioAdaptation&&bounds?.videoEnd>0&&bounds?.audioEnd>0)duration=Math.max(bounds.videoEnd,bounds.audioEnd);
+   if(data.audioAdaptation==='flac'&&bounds?.videoEnd>0&&bounds?.audioEnd>0&&Math.abs(bounds.videoEnd-bounds.audioEnd)>1){
+    if(!engine.tracks.some(t=>t.selected&&t.type==='audio'&&['pcm_s16le','pcm_s24le'].includes(t.codec))||!engine.tracks.some(t=>t.selected&&t.type==='video'&&t.codec==='h264'))throw Error('Unsupported unequal-tail Native configuration; qualified H264 and PCM16/24 are required');
+    const {SplitMP4}=await import('./split-mp4.js');splitter=new SplitMP4();engine.windowedTails=true;
+   }
+   const candidates=remuxPackaging(video,audio,engine.container);
+   if(!candidates.length)throw Error('Selected codecs have no common browser remux packaging');
+   negotiation={candidates,duration,target:data.target||0};stats.remuxMs+=performance.now()-start;
+   postMessage({type:'negotiate',candidates,duration,windowed:!!splitter,trackBounds:bounds,lanes:splitter?[`video/mp4; codecs="${video}"`,`audio/mp4; codecs="${audio}"`]:undefined});
+  }else if(data.type==='select-container'){
+   const selected=negotiation?.candidates.find(c=>c.container===data.container);
+   if(!selected)throw Error('Invalid remux container selection');
+   const {duration,target}=negotiation;negotiation=null;
+   if(engine.preparationInterface===2&&selected.container!=='webm'){const {MP4VideoTiming}=await import('./split-mp4.js');timing=new MP4VideoTiming();}
+   check(engine._rm_set_container(selected.container==='webm'?1:0));
+   check(engine._rm_start(target));const buffer=flush().buffer;stats.remuxMs+=performance.now()-start;stats.heapBytes=engine.HEAPU8.byteLength;
+   const presentationFrames=timing?.read(buffer),buffers=splitter?splitter.split(buffer):undefined;
+   postMessage({type:'ready',presentationFrames,duration,mime:selected.mime,tracks:engine.tracks,buffer:buffers?undefined:buffer,buffers,stats:{...stats}},buffers??[buffer]);
+  }else if(data.type==='next'){
+   const more=check(engine._rm_step()),buffer=flush().buffer;if(engine.adaptation)stats.adaptation={...engine.adaptation};stats.calls++;stats.remuxMs+=performance.now()-start;stats.heapBytes=engine.HEAPU8.byteLength;
+   emptyBatches=buffer.byteLength?0:emptyBatches+1;
+   if(more&&emptyBatches>24)throw Error('Remux random-access interval exceeds fragment production budget');
+   const frames=engine.videoFrames?.splice(0)??[],raps=engine.raps.splice(0),presentationFrames=timing?.read(buffer),buffers=splitter?splitter.split(buffer):undefined;postMessage({type:'fragment',id:data.id,more,frames,presentationFrames,buffer:buffers?undefined:buffer,buffers,raps,stats:{...stats}},buffers??[buffer]);
+  }else if(data.type==='close'){engine?._rm_close();postMessage({type:'closed'});close();}
+ }catch(e){postMessage({type:'error',message:`${e.message||e}\n${e.stack||''}`});}
+};

package/web/range-reader.js

@@ -0,0 +1,130 @@
+// Original bounded, single-flight VOD range reader. No decoder dependency.
+export class RangeReader {
+  constructor(options, refresh) {
+    this.options={credentials:'omit',cacheBytes:16*1024*1024,blockBytes:256*1024,immutable:false,...options};
+    this.allow=new Set(options.allowedOrigins || [new URL(options.url).origin]);
+    this.refresh=refresh;this.cache=new Map();this.epoch=0;this.closed=false;this.busy=false;
+    this.stats={fetchedBytes:0,requests:0,retries:0,aborts:0,cacheBytes:0,peakCacheBytes:0,activeBytes:0,peakActiveBytes:0};
+    if(options.identity){this.etag=options.identity.etag;this.total=BigInt(options.identity.size);}
+    this.checkURL(this.options.url);
+    if(!Number.isInteger(this.options.blockBytes)||this.options.blockBytes<1024||this.options.blockBytes>262144||!Number.isInteger(this.options.cacheBytes)||this.options.cacheBytes<this.options.blockBytes||this.options.cacheBytes>16777216)throw Error('Invalid range budgets');
+  }
+  checkURL(value){const u=new URL(value);if(!['http:','https:'].includes(u.protocol)||u.username||u.password||!this.allow.has(u.origin))throw Error('Media origin is not allowed');}
+  async open(){await this.read(0n,1);return {size:String(this.total),etag:this.etag};}
+  beginEpoch(){this.epoch++;this.operation?.abort(new DOMException('Superseded','AbortError'));this.controller?.abort();this.retryWake?.();this.stats.aborts++;}
+  close(){this.closed=true;this.beginEpoch();this.cache.clear();this.stats.cacheBytes=0;}
+  async read(offset,capacity){
+    if(this.closed)throw Error('Range reader closed');
+    if(this.busy)throw Error('Concurrent reads are not allowed');
+    if(typeof offset!=='bigint'||offset<0n||!Number.isInteger(capacity)||capacity<1||capacity>262144)throw Error('Invalid read');
+    if(this.total!==undefined&&offset>=this.total)return new Uint8Array();
+    this.busy=true;const epoch=this.epoch;
+    try{
+      // Anchor misses at the requested position, avoiding an unused prefix on
+      // distant index/seek reads. Cached windows can still satisfy inner reads.
+      let start=offset,key=String(start);
+      let bytes=this.cache.get(key);
+      if(!bytes)for(const [cachedKey,cachedBytes] of this.cache){
+        const cachedStart=BigInt(cachedKey);
+        if(offset>=cachedStart&&offset<cachedStart+BigInt(cachedBytes.length)){
+          start=cachedStart;key=cachedKey;bytes=cachedBytes;break;
+        }
+      }
+      if(bytes){this.cache.delete(key);this.cache.set(key,bytes);}
+      else{
+        bytes=await this.fetchBlock(start,epoch);
+        if(epoch!==this.epoch||this.closed)throw new DOMException('Superseded','AbortError');
+        while(this.stats.cacheBytes+bytes.buffer.byteLength>this.options.cacheBytes&&this.cache.size){const oldest=this.cache.keys().next().value;this.stats.cacheBytes-=this.cache.get(oldest).buffer.byteLength;this.cache.delete(oldest);}
+        this.cache.set(key,bytes);this.stats.cacheBytes+=bytes.buffer.byteLength;this.stats.peakCacheBytes=Math.max(this.stats.peakCacheBytes,this.stats.cacheBytes);
+      }
+      if(epoch!==this.epoch||this.closed)throw new DOMException('Superseded','AbortError');
+      const at=Number(offset-start);return bytes.subarray(at,Math.min(bytes.length,at+capacity));
+    }finally{this.busy=false;this.stats.activeBytes=0;}
+  }
+  async fetchBlock(start,epoch){
+    const buffer=new Uint8Array(this.options.blockBytes);let received=0,refreshed=false;
+    const deadline=performance.now()+15000;
+    const operation=this.operation=new AbortController();
+    const timeout=()=>operation.abort(Error('Media read retry deadline exceeded'));
+    // A separate, non-resetting deadline covers headers, successful body progress,
+    // backoff and credential refresh. Race pending work too: refresh callbacks do
+    // not receive a signal and need not settle when the transport is cancelled.
+    const deadlineTimer=setTimeout(timeout,15000);
+    operation.signal.addEventListener('abort',()=>{
+      this.controller?.abort();this.retryWake?.();
+    },{once:true});
+    const check=()=>{
+      if(this.closed||epoch!==this.epoch)operation.abort(new DOMException('Superseded','AbortError'));
+      if(performance.now()>=deadline)timeout();
+      if(operation.signal.aborted)throw operation.signal.reason;
+    };
+    const waitFor=promise=>new Promise((resolve,reject)=>{
+      const signal=operation.signal;
+      const cleanup=()=>signal.removeEventListener('abort',onAbort);
+      const onAbort=()=>{cleanup();reject(signal.reason);};
+      signal.addEventListener('abort',onAbort,{once:true});
+      Promise.resolve(promise).then(value=>{
+        cleanup();try{check();resolve(value);}catch(error){reject(error);}
+      },error=>{cleanup();reject(error);});
+      if(signal.aborted)onAbort();
+    });
+    try{
+    this.stats.activeBytes=buffer.length;this.stats.peakActiveBytes=Math.max(this.stats.peakActiveBytes,buffer.length);
+    for(let attempt=0;attempt<10;attempt++){
+      check();
+      const controller=this.controller=new AbortController();let timer,reader,response;
+      const touch=()=>{clearTimeout(timer);timer=setTimeout(()=>controller.abort(),1200);};
+      try{
+        const offset=start+BigInt(received);
+        let end=start+BigInt(buffer.length)-1n;if(this.total!==undefined&&end>=this.total)end=this.total-1n;
+        const headers=new Headers(this.options.headers);headers.set('Range',`bytes=${offset}-${end}`);if(this.etag)headers.set('If-Range',this.etag);
+        this.checkURL(this.options.url);touch();this.stats.requests++;
+        response=await waitFor(fetch(this.options.url,{headers,credentials:this.options.credentials,redirect:'error',cache:'no-store',signal:controller.signal}));
+        if(response.status===401&&!refreshed&&this.refresh){
+          await waitFor(response.body?.cancel());clearTimeout(timer);const update=await waitFor(this.refresh());
+          this.checkURL(update.url||this.options.url);this.options={...this.options,...update};refreshed=true;continue;
+        }
+        if([408,429,500,502,503,504].includes(response.status)){const e=Error(`Retryable HTTP ${response.status}`);e.retry=true;throw e;}
+        if(response.status===416){
+          const match=/^bytes \*\/(\d+)$/.exec(response.headers.get('Content-Range')||'');
+          if(match&&this.total!==undefined&&BigInt(match[1])===this.total&&offset>=this.total){await waitFor(response.body?.cancel());return buffer.subarray(0,received);}
+          throw Error('Unexpected range EOF');
+        }
+        if(response.status!==206)throw Error(`Expected HTTP 206; received ${response.status}`);
+        const match=/^bytes (\d+)-(\d+)\/(\d+)$/.exec(response.headers.get('Content-Range')||'');
+        if(!match)throw Error('Missing or invalid Content-Range');
+        const [lo,hi,total]=match.slice(1).map(BigInt),expectedEnd=end<total?end:total-1n;
+        if(lo!==offset||hi!==expectedEnd||hi<lo||total<=hi||this.total!==undefined&&total!==this.total)throw Error('Incoherent media range or changed length');
+        const encoding=response.headers.get('Content-Encoding');if(encoding&&encoding!=='identity')throw Error('Encoded range representation is unsupported');
+        const etag=response.headers.get('ETag');
+        if(this.etag&&etag!==this.etag)throw Error('Media representation changed');
+        if(!this.etag){if(etag&&/^"[^\r\n]*"$/.test(etag))this.etag=etag;else if(!this.options.immutable)throw Error('A strong ETag or explicit immutable contract is required');}
+        this.total=total;
+        const expected=Number(hi-lo+1n),length=response.headers.get('Content-Length');
+        if(length!==null&&BigInt(length)!==BigInt(expected))throw Error('Content-Length does not match range');
+        reader=response.body.getReader();let bodyBytes=0;
+        while(true){touch();const {done,value}=await waitFor(reader.read());if(done)break;
+          this.stats.fetchedBytes+=value.length;
+          if(bodyBytes+value.length>expected||received+value.length>buffer.length)throw Error('Range body exceeded its bound');
+          buffer.set(value,received);received+=value.length;bodyBytes+=value.length;
+        }
+        if(bodyBytes!==expected){const e=Error('Truncated range body');e.retry=true;throw e;}
+        if(epoch!==this.epoch||this.closed)throw new DOMException('Superseded','AbortError');
+        return buffer.subarray(0,received);
+      }catch(error){
+        controller.abort();void reader?.cancel().catch(()=>{});void response?.body?.cancel().catch(()=>{});
+        check();
+        if(epoch!==this.epoch||this.closed)throw new DOMException('Superseded','AbortError');
+        const retry=error.retry||error.name==='AbortError'||error instanceof TypeError;
+        if(!retry||attempt===9||performance.now()>=deadline)throw Error(retry?'Media read retry deadline exceeded':error.message);
+        this.stats.retries++;
+        const retryAfter=response?.headers.get('Retry-After');const serverWait=retryAfter ? (/^\d+$/.test(retryAfter)?Number(retryAfter)*1000:Math.max(0,Date.parse(retryAfter)-Date.now())) : 0;
+        const backoff=80*2**Math.min(attempt,3)*(0.75+Math.random()*0.5);
+        const wait=Math.min(Math.max(0,deadline-performance.now()),Math.max(Number.isFinite(serverWait)?serverWait:0,backoff));
+        await waitFor(new Promise(resolve=>{const timer=setTimeout(done,wait);const self=this;function done(){clearTimeout(timer);self.retryWake=null;resolve();}this.retryWake=done;}));
+      }finally{clearTimeout(timer);if(this.controller===controller)this.controller=null;}
+    }
+    throw Error('Media read failed');
+    }finally{clearTimeout(deadlineTimer);if(this.operation===operation)this.operation=null;}
+  }
+}

package/web/remux-packaging.js

@@ -0,0 +1,11 @@
+// Packet/container contracts, independent of browser admission. Selected codecs only.
+export function remuxPackaging(video, audio, preferred='mp4') {
+ const webmVideo=!video||/^(vp8|vp09\.|av01\.)/.test(video);
+ const webmAudio=!audio||['opus','vorbis'].includes(audio);
+ const mp4Video=!video||/^(avc1\.|hvc1\.|hev1\.|vp09\.|av01\.)/.test(video);
+ const mp4Audio=!audio||/^(mp4a\.|mp3$|opus$|flac$|ac-3$|ec-3$)/.test(audio);
+ if(!video&&!audio)return [];
+ return [preferred,...['mp4','webm'].filter(c=>c!==preferred)]
+  .filter(c=>c==='mp4'?mp4Video&&mp4Audio:c==='webm'&&webmVideo&&webmAudio)
+  .map(container=>({container,mime:`${video?'video':'audio'}/${container}; codecs="${[video,audio].filter(Boolean).join(',')}"`}));
+}