mediabunny 1.52.3 → 1.53.1

package/dist/bundles/mediabunny.cjs

@@ -2166,7 +2166,7 @@ var Mediabunny = (() => {
   var HEVC_CODEC_STRING_REGEX = /^(hev1|hvc1)\.(?:[ABC]?\d+)\.[0-9a-fA-F]{1,8}\.[LH]\d+(?:\.[0-9a-fA-F]{1,2}){0,6}$/;
   var VP9_CODEC_STRING_REGEX = /^vp09(?:\.\d{2}){3}(?:(?:\.\d{2}){5})?$/;
   var AV1_CODEC_STRING_REGEX = /^av01\.\d\.\d{2}[MH]\.\d{2}(?:\.\d\.\d{3}\.\d{2}\.\d{2}\.\d{2}\.\d)?$/;
-  var validateVideoChunkMetadata = (metadata) => {
+  var validateVideoChunkMetadata = (metadata, trackCodec) => {
     if (!metadata) {
       throw new TypeError("Video chunk metadata must be provided.");
     }
@@ -2285,6 +2285,11 @@ var Mediabunny = (() => {
         );
       }
     }
+    if (trackCodec !== null && inferCodecFromCodecString(metadata.decoderConfig.codec) !== trackCodec) {
+      throw new TypeError(
+        `Video chunk metadata decoder configuration codec string '${metadata.decoderConfig.codec}' does not fit to the track codec '${trackCodec}'.`
+      );
+    }
   };
   var VALID_AUDIO_CODEC_STRING_PREFIXES = [
     "mp4a",
@@ -2298,7 +2303,7 @@ var Mediabunny = (() => {
     "ac-3",
     "ec-3"
   ];
-  var validateAudioChunkMetadata = (metadata) => {
+  var validateAudioChunkMetadata = (metadata, trackCodec) => {
     if (!metadata) {
       throw new TypeError("Audio chunk metadata must be provided.");
     }
@@ -2392,6 +2397,11 @@ var Mediabunny = (() => {
         );
       }
     }
+    if (trackCodec !== null && inferCodecFromCodecString(metadata.decoderConfig.codec) !== trackCodec) {
+      throw new TypeError(
+        `Audio chunk metadata decoder configuration codec string '${metadata.decoderConfig.codec}' does not fit to the track codec '${trackCodec}'.`
+      );
+    }
   };
   var validateSubtitleMetadata = (metadata) => {
     if (!metadata) {
@@ -5579,6 +5589,7 @@ var Mediabunny = (() => {
       return this.metadataPromise ??= (async () => {
         let currentPos = 0;
         let lookForMfraBox = false;
+        let foundMovieBoxes = false;
         while (true) {
           let slice = this.reader.requestSliceRange(currentPos, MIN_BOX_HEADER_SIZE, MAX_BOX_HEADER_SIZE);
           if (slice instanceof Promise) slice = await slice;
@@ -5602,6 +5613,7 @@ var Mediabunny = (() => {
               track.editListOffset -= Math.round(previousSegmentDurationsInSeconds * track.timescale);
             }
             lookForMfraBox = this.isFragmented && this.reader.fileSize !== null && this.reader.fileSize > startPos + boxInfo.totalSize;
+            foundMovieBoxes = true;
             break;
           } else if (boxInfo.name === "moof") {
             if (!this.input._initInput) {
@@ -5609,61 +5621,16 @@ var Mediabunny = (() => {
                 '"moof" box encountered with no "moov" box present; this file is likely a Segment as described in ISO/IEC 14496-12 Section 8.16. A separate init file that contains a "moov" box is required to read this file, please provide it using InputOptions.initInput.'
               );
             }
-            const initDemuxer = await this.input._initInput._getDemuxer();
-            if (initDemuxer.constructor !== _IsobmffDemuxer) {
-              throw new Error("Init input must match the input's format.");
-            }
-            await initDemuxer.readMetadata();
-            this.movieTimescale = initDemuxer.movieTimescale;
-            this.movieDurationInTimescale = initDemuxer.movieDurationInTimescale;
-            this.metadataTags = initDemuxer.metadataTags;
-            this.isFragmented = true;
-            this.fragmentTrackDefaults = initDemuxer.fragmentTrackDefaults;
-            this.psshBoxes = initDemuxer.psshBoxes;
-            for (const foreignTrack of initDemuxer.tracks) {
-              const track = {
-                id: foreignTrack.id,
-                demuxer: this,
-                trackBacking: null,
-                disposition: foreignTrack.disposition,
-                timescale: foreignTrack.timescale,
-                durationInMediaTimescale: foreignTrack.durationInMediaTimescale,
-                durationInMovieTimescale: foreignTrack.durationInMovieTimescale,
-                rotation: foreignTrack.rotation,
-                internalCodecId: foreignTrack.internalCodecId,
-                name: foreignTrack.name,
-                languageCode: foreignTrack.languageCode,
-                sampleTableByteOffset: null,
-                sampleTable: null,
-                fragmentLookupTable: [],
-                currentFragmentState: null,
-                fragmentPositionCache: [],
-                editListPreviousSegmentDurations: foreignTrack.editListPreviousSegmentDurations,
-                editListOffset: foreignTrack.editListOffset,
-                encryptionInfo: foreignTrack.encryptionInfo,
-                encryptionAuxInfo: null,
-                frmaCodecString: null,
-                info: foreignTrack.info
-              };
-              if (foreignTrack.trackBacking) {
-                assert(track.info);
-                if (track.info.type === "video" && track.info.width !== -1) {
-                  const videoTrack = track;
-                  track.trackBacking = new IsobmffVideoTrackBacking(videoTrack);
-                  this.tracks.push(track);
-                } else if (track.info.type === "audio" && track.info.numberOfChannels !== -1) {
-                  const audioTrack = track;
-                  track.trackBacking = new IsobmffAudioTrackBacking(audioTrack);
-                  this.tracks.push(track);
-                }
-              } else {
-              }
-            }
+            await this.copyMetadataFromInitInput(this.input._initInput);
             lookForMfraBox = false;
+            foundMovieBoxes = true;
             break;
           }
           currentPos = startPos + boxInfo.totalSize;
         }
+        if (!foundMovieBoxes && this.input._initInput) {
+          await this.copyMetadataFromInitInput(this.input._initInput);
+        }
         if (lookForMfraBox) {
           assert(this.reader.fileSize !== null);
           let lastWordSlice = this.reader.requestSlice(this.reader.fileSize - 4, 4);
@@ -5692,6 +5659,58 @@ var Mediabunny = (() => {
         }
       })();
     }
+    async copyMetadataFromInitInput(initInput) {
+      const initDemuxer = await initInput._getDemuxer();
+      if (initDemuxer.constructor !== _IsobmffDemuxer) {
+        throw new Error("Init input must match the input's format.");
+      }
+      await initDemuxer.readMetadata();
+      this.movieTimescale = initDemuxer.movieTimescale;
+      this.movieDurationInTimescale = initDemuxer.movieDurationInTimescale;
+      this.metadataTags = initDemuxer.metadataTags;
+      this.isFragmented = true;
+      this.fragmentTrackDefaults = initDemuxer.fragmentTrackDefaults;
+      this.psshBoxes = initDemuxer.psshBoxes;
+      for (const foreignTrack of initDemuxer.tracks) {
+        const track = {
+          id: foreignTrack.id,
+          demuxer: this,
+          trackBacking: null,
+          disposition: foreignTrack.disposition,
+          timescale: foreignTrack.timescale,
+          durationInMediaTimescale: foreignTrack.durationInMediaTimescale,
+          durationInMovieTimescale: foreignTrack.durationInMovieTimescale,
+          rotation: foreignTrack.rotation,
+          internalCodecId: foreignTrack.internalCodecId,
+          name: foreignTrack.name,
+          languageCode: foreignTrack.languageCode,
+          sampleTableByteOffset: null,
+          sampleTable: null,
+          fragmentLookupTable: [],
+          currentFragmentState: null,
+          fragmentPositionCache: [],
+          editListPreviousSegmentDurations: foreignTrack.editListPreviousSegmentDurations,
+          editListOffset: foreignTrack.editListOffset,
+          encryptionInfo: foreignTrack.encryptionInfo,
+          encryptionAuxInfo: null,
+          frmaCodecString: null,
+          info: foreignTrack.info
+        };
+        if (foreignTrack.trackBacking) {
+          assert(track.info);
+          if (track.info.type === "video" && track.info.width !== -1) {
+            const videoTrack = track;
+            track.trackBacking = new IsobmffVideoTrackBacking(videoTrack);
+            this.tracks.push(track);
+          } else if (track.info.type === "audio" && track.info.numberOfChannels !== -1) {
+            const audioTrack = track;
+            track.trackBacking = new IsobmffAudioTrackBacking(audioTrack);
+            this.tracks.push(track);
+          }
+        } else {
+        }
+      }
+    }
     getSampleTableForTrack(internalTrack) {
       if (internalTrack.sampleTable) {
         return internalTrack.sampleTable;
@@ -11102,6 +11121,8 @@ var Mediabunny = (() => {
       this.metadataPromise = null;
       this.firstFrameHeader = null;
       this.firstFrameHeaderPos = null;
+      this.xingFrameHeader = null;
+      this.xingFrameHeaderPos = null;
       this.loadedSamples = [];
       // All samples from the start of the file to lastLoadedPos
       this.metadataTags = null;
@@ -11118,6 +11139,10 @@ var Mediabunny = (() => {
         while (!this.firstFrameHeader && !this.lastSampleLoaded) {
           await this.advanceReader();
         }
+        if (!this.firstFrameHeader && this.xingFrameHeader) {
+          this.firstFrameHeader = this.xingFrameHeader;
+          this.firstFrameHeaderPos = this.xingFrameHeaderPos;
+        }
         if (!this.firstFrameHeader) {
           throw new Error("No valid MP3 frame found.");
         }
@@ -11159,6 +11184,10 @@ var Mediabunny = (() => {
         const word = readU32Be(slice);
         const isXing = word === XING || word === INFO;
         if (isXing) {
+          if (!this.xingFrameHeader) {
+            this.xingFrameHeader = header;
+            this.xingFrameHeaderPos = result.startPos;
+          }
           if (!this.xingData) {
             let xingDataSlice = this.reader.requestSlice(result.startPos + xingOffset + 4, 12);
             if (xingDataSlice instanceof Promise) xingDataSlice = await xingDataSlice;
@@ -14157,6 +14186,9 @@ var Mediabunny = (() => {
           throw new Error("No Program Map Table found in the file.");
         }
         for (const stream of this.elementaryStreams) {
+          if (!stream.initialized) {
+            continue;
+          }
           if (stream.info.type === "video") {
             this.trackBackingEntries.push(
               new MpegTsVideoTrackBacking(stream)
@@ -15619,6 +15651,7 @@ var Mediabunny = (() => {
       this.packetInfos = /* @__PURE__ */ new WeakMap();
       this.hydrationPromise = null;
       this.firstInputTrack = null;
+      this.firstSegment = null;
       this.segmentedInput = segmentedInput;
       this.decl = decl;
       this.number = number;
@@ -15629,13 +15662,22 @@ var Mediabunny = (() => {
         if (!this.segmentedInput.firstSegment) {
           throw new Error("Missing first segment, can't retrieve track.");
         }
-        const input = this.segmentedInput.getInputForSegment(this.segmentedInput.firstSegment);
-        const inputTracks = await input.getTracks();
-        const track = inputTracks.find((x) => x.type === this.decl.type && x.number === this.number);
+        let currentSegment = this.segmentedInput.firstSegment;
+        let track = null;
+        while (currentSegment) {
+          const input = this.segmentedInput.getInputForSegment(currentSegment);
+          const inputTracks = await input.getTracks();
+          track = inputTracks.find((x) => x.type === this.decl.type && x.number === this.number) ?? null;
+          if (track) {
+            break;
+          }
+          currentSegment = await this.segmentedInput.getNextSegment(currentSegment, {});
+        }
         if (!track) {
           throw new Error("No matching track found in underlying media data.");
         }
         this.firstInputTrack = track;
+        this.firstSegment = currentSegment;
       })();
     }
     getId() {
@@ -15724,13 +15766,28 @@ var Mediabunny = (() => {
     }
     async getFirstPacket(options) {
       await this.hydrate();
-      assert(this.segmentedInput.firstSegment);
       assert(this.firstInputTrack);
-      const packet = await this.firstInputTrack._backing.getFirstPacket(options);
-      if (!packet) {
-        return null;
+      assert(this.firstSegment);
+      let currentTrack = this.firstInputTrack;
+      let currentSegment = this.firstSegment;
+      while (true) {
+        if (currentTrack) {
+          const packet = await currentTrack._backing.getFirstPacket(options);
+          if (packet) {
+            return this.createAdjustedPacket(packet, currentSegment, currentTrack);
+          }
+        }
+        currentSegment = await this.segmentedInput.getNextSegment(currentSegment, {
+          skipLiveWait: options.skipLiveWait
+        });
+        if (!currentSegment) {
+          break;
+        }
+        const nextInput = this.segmentedInput.getInputForSegment(currentSegment);
+        const nextTracks = await nextInput.getTracks();
+        currentTrack = nextTracks.find((t) => t.type === this.firstInputTrack.type && t.number === this.firstInputTrack.number) ?? null;
       }
-      return this.createAdjustedPacket(packet, this.segmentedInput.firstSegment, this.firstInputTrack);
+      return null;
     }
     getNextPacket(packet, options) {
       return this._getNextInternal(packet, options, false);
@@ -16291,6 +16348,12 @@ var Mediabunny = (() => {
        * @internal
        */
       this._fileSizeDetermined = false;
+      /**
+       * When the server doesn't support range requests, we abandon the orchestrator and instead defer to an internal
+       * ReadableStreamSource wrapping the response body, which pulls new data only when reads demand it.
+       * @internal
+       */
+      this._sequentialBacking = null;
       this._url = url2;
       this._options = options;
       this._getRetryDelay = options.getRetryDelay ?? DEFAULT_RETRY_DELAY;
@@ -16334,7 +16397,7 @@ var Mediabunny = (() => {
       if (!this._fileSizeDetermined) {
         return this._length !== null ? this._length : void 0;
       }
-      const baseSize = this._orchestrator.fileSize;
+      const baseSize = this._sequentialBacking ? this._sequentialBacking._endIndex : this._orchestrator.fileSize;
       if (baseSize === null) {
         return this._length !== null ? this._length : null;
       }
@@ -16346,7 +16409,7 @@ var Mediabunny = (() => {
         return null;
       }
       const offset = this._offset;
-      const result = this._orchestrator.read(
+      const result = this._sequentialBacking ? this._sequentialBacking._read(offset + start, offset + end) : this._orchestrator.read(
         offset + start,
         offset + end,
         Math.max(offset + minReadPosition, offset),
@@ -16400,11 +16463,21 @@ var Mediabunny = (() => {
             }
             const contentLength = response.headers.get("Content-Length");
             if (contentLength) {
-              this._orchestrator.supplyFileSize(worker.currentPos + Number(contentLength));
+              const basePos = response.status === 206 ? worker.currentPos : 0;
+              this._orchestrator.supplyFileSize(basePos + Number(contentLength));
             }
           }
         this._fileSizeDetermined = true;
+        if (!response.body) {
+          throw new Error(
+            "Missing HTTP response body stream. The used fetch function must provide the response body as a ReadableStream."
+          );
+        }
         if (response.status !== 206) {
+          if (this._sequentialBacking) {
+            void response.body.cancel();
+            return;
+          }
           if (!this._usedForHls) {
             const url2 = new URL(
               this._url instanceof Request ? this._url.url : this._url,
@@ -16413,26 +16486,14 @@ var Mediabunny = (() => {
             if (url2.origin !== "null" && !(url2.pathname.endsWith(".m3u8") || url2.pathname.endsWith(".m3u"))) {
               if (!warnedOrigins.has(url2.origin)) {
                 Logging._warn(
-                  `HTTP server (origin ${url2.origin}) did not respond to a range request with 206 Partial Content, meaning the entire resource will now be downloaded. To enable efficient media file streaming across a network, please make sure your server supports range requests.`
+                  `HTTP server (origin ${url2.origin}) did not respond to a range request with 206 Partial Content, meaning the resource will now be streamed sequentially, with old data being evicted from the cache. Reads into evicted regions will throw. To enable efficient media file streaming across a network, please make sure your server supports range requests. Alternatively, set maxCacheSize to Infinity in the UrlSource options to keep the entire resource in memory.`
                 );
                 warnedOrigins.add(url2.origin);
               }
             }
           }
-          worker.currentPos = 0;
-          this._orchestrator.options.maxCacheSize = Infinity;
-          if (this._orchestrator.fileSize !== null) {
-            worker.targetPos = this._orchestrator.fileSize;
-          } else {
-            worker.targetPos = Infinity;
-            worker.strictTarget = false;
-          }
-          this._orchestrator.consolidateEverythingIntoOneWorker(worker);
-        }
-        if (!response.body) {
-          throw new Error(
-            "Missing HTTP response body stream. The used fetch function must provide the response body as a ReadableStream."
-          );
+          this._transitionToSequentialMode(response.body);
+          return;
         }
         const reader = response.body.getReader();
         while (true) {
@@ -16479,8 +16540,119 @@ var Mediabunny = (() => {
       }
     }
     /** @internal */
+    _transitionToSequentialMode(body) {
+      let currentReader = body.getReader();
+      let streamPosition = 0;
+      let skipRemaining = 0;
+      const wrappedStream = new ReadableStream({
+        pull: async (controller) => {
+          while (true) {
+            let readResult;
+            try {
+              readResult = await currentReader.read();
+            } catch (error) {
+              if (this._disposed) {
+                throw error;
+              }
+              const retryDelayInSeconds = this._getRetryDelay(1, error, this._url);
+              if (retryDelayInSeconds === null) {
+                throw error;
+              }
+              Logging._error("Error while reading response stream. Attempting to resume.", error);
+              await wait(1e3 * retryDelayInSeconds);
+              const newResponse = await retriedFetch(
+                this._options.fetchFn ?? fetch,
+                this._url,
+                mergeRequestInit(this._requestInit, {
+                  headers: {
+                    // Who knows, maybe the server honors range requests this time
+                    Range: `bytes=${streamPosition}-`
+                  }
+                }),
+                this._getRetryDelay,
+                () => this._disposed
+              );
+              if (!newResponse.ok) {
+                throw new Error(
+                  // eslint-disable-next-line @typescript-eslint/no-base-to-string
+                  `Error fetching ${String(this._url)}: ${newResponse.status} ${newResponse.statusText}`
+                );
+              }
+              if (!newResponse.body) {
+                throw new Error(
+                  "Missing HTTP response body stream. The used fetch function must provide the response body as a ReadableStream."
+                );
+              }
+              currentReader = newResponse.body.getReader();
+              skipRemaining = newResponse.status === 206 ? 0 : streamPosition;
+              continue;
+            }
+            if (readResult.done) {
+              controller.close();
+              return;
+            }
+            let chunk = readResult.value;
+            if (skipRemaining > 0) {
+              const skippedAmount = Math.min(skipRemaining, chunk.length);
+              skipRemaining -= skippedAmount;
+              chunk = chunk.subarray(skippedAmount);
+            }
+            if (chunk.length === 0) {
+              continue;
+            }
+            streamPosition += chunk.length;
+            controller.enqueue(chunk);
+            return;
+          }
+        },
+        cancel: () => currentReader.cancel()
+      });
+      const backing = new ReadableStreamSource(wrappedStream, {
+        maxCacheSize: this._orchestrator.options.maxCacheSize
+      });
+      backing._endIndex = this._orchestrator.fileSize;
+      backing._cacheMissErrorMessage = "Attempted to read data from an already-evicted part of the cache. Because the HTTP server did not honor the range request, data can only be read sequentially, with old data being evicted from the cache. To fix this issue, either ensure your server responds to range requests with 206 Partial Content, or set maxCacheSize to Infinity in the UrlSource options. Note that the latter will store the entire file in the cache if needed, no matter how large.";
+      backing.on("read", ({ start, end }) => this._dispatchRead(start, end));
+      this._sequentialBacking = backing;
+      const uniqueSlices = /* @__PURE__ */ new Set();
+      for (const otherWorker of this._orchestrator.workers) {
+        for (const slice of otherWorker.pendingSlices) {
+          uniqueSlices.add(slice);
+        }
+        otherWorker.aborted = true;
+        otherWorker.pendingSlices.length = 0;
+      }
+      for (const queuedRead of this._orchestrator.queuedReads) {
+        for (const slice of queuedRead.pendingSlices) {
+          uniqueSlices.add(slice);
+        }
+      }
+      this._orchestrator.workers.length = 0;
+      this._orchestrator.queuedReads.length = 0;
+      for (const slice of uniqueSlices) {
+        const result = backing._read(slice.start, slice.start + slice.bytes.length);
+        if (result instanceof Promise) {
+          result.then((readResult) => {
+            if (readResult) {
+              assert(readResult.offset === slice.start);
+              slice.resolve(readResult.bytes);
+            } else {
+              slice.resolve(null);
+            }
+          }, (error) => slice.reject(error));
+        } else {
+          assert(result === null);
+          slice.resolve(null);
+        }
+      }
+    }
+    /** @internal */
     _dispose() {
       this._orchestrator.dispose();
+      if (this._sequentialBacking) {
+        this._sequentialBacking._disposed = true;
+        this._sequentialBacking._dispose();
+      }
     }
   };
   var BYTE_RANGE_REGEX = /^bytes=(\d+)-(\d*)$/;
@@ -16699,6 +16871,11 @@ var Mediabunny = (() => {
       this._endIndex = null;
       /** @internal */
       this._pulling = false;
+      /**
+       * Overridable for internal use.
+       * @internal
+       */
+      this._cacheMissErrorMessage = "Attempted to read data from an already-evicted part of the cache. With ReadableStreamSource, you must access the data more sequentially or increase the size of its cache.";
       this._stream = stream;
       this._maxCacheSize = options.maxCacheSize ?? 32 * 2 ** 20;
     }
@@ -16778,9 +16955,7 @@ var Mediabunny = (() => {
     }
     /** @internal */
     _throwDueToCacheMiss() {
-      throw new Error(
-        "Read is before the cached region. With ReadableStreamSource, you must access the data more sequentially or increase the size of its cache."
-      );
+      throw new Error(this._cacheMissErrorMessage);
     }
     /** @internal */
     async _pull() {
@@ -17170,30 +17345,6 @@ var Mediabunny = (() => {
         }
       });
     }
-    consolidateEverythingIntoOneWorker(worker) {
-      const uniqueSlices = new Set(worker.pendingSlices);
-      for (let i = 0; i < this.workers.length; i++) {
-        const otherWorker = this.workers[i];
-        if (otherWorker === worker) {
-          continue;
-        }
-        for (const slice of otherWorker.pendingSlices) {
-          uniqueSlices.add(slice);
-        }
-        otherWorker.aborted = true;
-        otherWorker.pendingSlices.length = 0;
-        this.workers.splice(i, 1);
-        i--;
-      }
-      for (let i = 0; i < this.queuedReads.length; i++) {
-        const queuedRead = this.queuedReads[i];
-        for (const slice of queuedRead.pendingSlices) {
-          uniqueSlices.add(slice);
-        }
-      }
-      worker.pendingSlices = [...uniqueSlices];
-      this.queuedReads.length = 0;
-    }
     /** Called by a worker when it has read some data. */
     supplyWorkerData(worker, bytes2) {
       assert(!worker.aborted);
@@ -19504,12 +19655,22 @@ var Mediabunny = (() => {
         if (init.duration !== void 0 && (!Number.isFinite(init.duration) || init.duration < 0)) {
           throw new TypeError("init.duration, when provided, must be a non-negative number.");
         }
+        if (init.visibleRect !== void 0) {
+          validateRectangle(init.visibleRect, "init.visibleRect");
+        }
         if (typeof VideoFrame !== "undefined") {
           return new _VideoSample(
             new VideoFrame(data, {
               timestamp: Math.trunc(init.timestamp * SECOND_TO_MICROSECOND_FACTOR),
               // Drag 0 to undefined
-              duration: Math.trunc((init.duration ?? 0) * SECOND_TO_MICROSECOND_FACTOR) || void 0
+              duration: Math.trunc((init.duration ?? 0) * SECOND_TO_MICROSECOND_FACTOR) || void 0,
+              // WebCodecs wants DOMRectInit
+              visibleRect: init.visibleRect && {
+                x: init.visibleRect.left,
+                y: init.visibleRect.top,
+                width: init.visibleRect.width,
+                height: init.visibleRect.height
+              }
             }),
             init
           );
@@ -19529,7 +19690,8 @@ var Mediabunny = (() => {
         if (!width || !height) {
           throw new TypeError("Could not determine dimensions.");
         }
-        const canvas = new OffscreenCanvas(width, height);
+        const visibleRect = init.visibleRect ?? { left: 0, top: 0, width, height };
+        const canvas = new OffscreenCanvas(visibleRect.width, visibleRect.height);
         const context = canvas.getContext("2d", {
           alpha: isFirefox(),
           // Firefox has VideoFrame glitches with opaque canvases
@@ -19540,13 +19702,13 @@ var Mediabunny = (() => {
             "OffscreenCanvas must have support for the '2d' context in order to create a VideoSample from this data."
           );
         }
-        context.drawImage(data, 0, 0);
+        context.drawImage(data, -visibleRect.left, -visibleRect.top);
         this._data = canvas;
         this._layout = null;
         this.format = "RGBX";
-        this.visibleRect = { left: 0, top: 0, width, height };
-        this.squarePixelWidth = width;
-        this.squarePixelHeight = height;
+        this.visibleRect = { left: 0, top: 0, width: visibleRect.width, height: visibleRect.height };
+        this.squarePixelWidth = visibleRect.width;
+        this.squarePixelHeight = visibleRect.height;
         this.rotation = init.rotation ?? 0;
         this.timestamp = init.timestamp;
         this.duration = init.duration ?? 0;
@@ -20123,6 +20285,61 @@ var Mediabunny = (() => {
       }
       return { sx, sy, sWidth, sHeight };
     }
+    /**
+     * Draws the sample onto the target canvas with fit behavior, manually mipmapping on strong downscales for quality.
+     * @internal
+     */
+    _drawWithFitAndMipmapping(targetCanvas, targetContext, options) {
+      const targetWidth = targetCanvas.width;
+      const targetHeight = targetCanvas.height;
+      const [rotatedWidth, rotatedHeight] = options.rotation % 180 === 0 ? [this.squarePixelWidth, this.squarePixelHeight] : [this.squarePixelHeight, this.squarePixelWidth];
+      const sourceWidth = options.crop ? options.crop.width : rotatedWidth;
+      const sourceHeight = options.crop ? options.crop.height : rotatedHeight;
+      let mipLevels = 0;
+      if (2 * targetWidth < sourceWidth && 2 * targetHeight < sourceHeight) {
+        mipLevels = Math.floor(Math.log2(
+          Math.min(sourceWidth / targetWidth, sourceHeight / targetHeight)
+        ));
+      }
+      const drawWidth = targetWidth * 2 ** mipLevels;
+      const drawHeight = targetHeight * 2 ** mipLevels;
+      const { canvas, context, isNew } = mipLevels > 0 ? getTransformationCanvas(drawWidth, drawHeight) : { canvas: targetCanvas, context: targetContext, isNew: options.targetIsFresh };
+      context.imageSmoothingQuality = "high";
+      if (options.fillBlack) {
+        context.fillStyle = "black";
+        context.fillRect(0, 0, drawWidth, drawHeight);
+      } else if (!isNew) {
+        context.clearRect(0, 0, drawWidth, drawHeight);
+      }
+      this.drawWithFit(context, {
+        fit: options.fit,
+        rotation: options.rotation,
+        crop: options.crop
+      });
+      context.globalCompositeOperation = "copy";
+      for (let i = mipLevels; i > 1; i--) {
+        const levelWidth = targetWidth * 2 ** i;
+        const levelHeight = targetHeight * 2 ** i;
+        context.drawImage(canvas, 0, 0, levelWidth, levelHeight, 0, 0, levelWidth / 2, levelHeight / 2);
+      }
+      context.globalCompositeOperation = "source-over";
+      if (mipLevels > 0) {
+        targetContext.imageSmoothingQuality = "high";
+        targetContext.globalCompositeOperation = "copy";
+        targetContext.drawImage(
+          canvas,
+          0,
+          0,
+          2 * targetWidth,
+          2 * targetHeight,
+          0,
+          0,
+          targetWidth,
+          targetHeight
+        );
+        targetContext.globalCompositeOperation = "source-over";
+      }
+    }
     /**
      * Converts this video sample to a
      * [`CanvasImageSource`](https://udn.realityripple.com/docs/Web/API/CanvasImageSource) for drawing to a canvas.
@@ -20226,56 +20443,13 @@ var Mediabunny = (() => {
           return result;
         }
       }
-      let canvas = null;
-      let canvasIsNew = false;
-      for (const entry of transformationCanvasCache) {
-        if (entry.canvas.width === description.width && entry.canvas.height === description.height) {
-          canvas = entry.canvas;
-          entry.age = transformationCanvasCacheNextAge++;
-          break;
-        }
-      }
-      if (canvas === null) {
-        if (typeof OffscreenCanvas !== "undefined") {
-          canvas = new OffscreenCanvas(description.width, description.height);
-        } else {
-          if (typeof window === "undefined" || typeof document === "undefined") {
-            throw new Error(
-              "Cannot transform VideoSamples in this environment. Either run in an environment with OffscreenCanvas or HTMLCanvasElement, or supply a custom VideoSample transformer using registerVideoSampleTransformer()."
-            );
-          }
-          canvas = document.createElement("canvas");
-          canvas.width = description.width;
-          canvas.height = description.height;
-        }
-        canvasIsNew = true;
-        if (transformationCanvasCache.length >= TRANSFORMATION_CANVAS_CACHE_MAX_SIZE) {
-          transformationCanvasCache.splice(arrayArgmin(transformationCanvasCache, (x) => x.age), 1);
-        }
-        transformationCanvasCache.push({
-          canvas,
-          age: transformationCanvasCacheNextAge++
-        });
-      }
-      const context = canvas.getContext("2d", {
-        alpha: true
-      });
-      if (!context) {
-        throw new Error(
-          "The '2d' canvas context is required to transform VideoSamples. Register a custom transformer using registerVideoSampleTransformer to work around this limitation."
-        );
-      }
-      context.imageSmoothingQuality = "high";
-      if (description.alpha === "discard") {
-        context.fillStyle = "black";
-        context.fillRect(0, 0, description.width, description.height);
-      } else if (!canvasIsNew) {
-        context.clearRect(0, 0, description.width, description.height);
-      }
-      this.drawWithFit(context, {
+      const { canvas, context, isNew } = getTransformationCanvas(description.width, description.height);
+      this._drawWithFitAndMipmapping(canvas, context, {
         fit: description.fit,
         rotation: description.rotation,
-        crop: description.crop
+        crop: description.crop,
+        targetIsFresh: isNew,
+        fillBlack: description.alpha === "discard"
       });
       return new _VideoSample(canvas, {
         timestamp: this.timestamp,
@@ -20327,6 +20501,45 @@ var Mediabunny = (() => {
   var TRANSFORMATION_CANVAS_CACHE_MAX_SIZE = 3;
   var transformationCanvasCache = [];
   var transformationCanvasCacheNextAge = 0;
+  var getTransformationCanvas = (width, height) => {
+    for (const entry of transformationCanvasCache) {
+      if (entry.canvas.width === width && entry.canvas.height === height) {
+        entry.age = transformationCanvasCacheNextAge++;
+        return { canvas: entry.canvas, context: entry.context, isNew: false };
+      }
+    }
+    let canvas;
+    if (typeof OffscreenCanvas !== "undefined") {
+      canvas = new OffscreenCanvas(width, height);
+    } else {
+      if (typeof window === "undefined" || typeof document === "undefined") {
+        throw new Error(
+          "Cannot transform VideoSamples in this environment. Either run in an environment with OffscreenCanvas or HTMLCanvasElement, or supply a custom VideoSample transformer using registerVideoSampleTransformer()."
+        );
+      }
+      canvas = document.createElement("canvas");
+      canvas.width = width;
+      canvas.height = height;
+    }
+    const context = canvas.getContext("2d", {
+      alpha: true,
+      willReadFrequently: false
+    });
+    if (!context) {
+      throw new Error(
+        "The '2d' canvas context is required to transform VideoSamples. Register a custom transformer using registerVideoSampleTransformer to work around this limitation."
+      );
+    }
+    if (transformationCanvasCache.length >= TRANSFORMATION_CANVAS_CACHE_MAX_SIZE) {
+      transformationCanvasCache.splice(arrayArgmin(transformationCanvasCache, (x) => x.age), 1);
+    }
+    transformationCanvasCache.push({
+      canvas,
+      context,
+      age: transformationCanvasCacheNextAge++
+    });
+    return { canvas, context, isNew: true };
+  };
   var VideoSampleColorSpace = class {
     /** Creates a new VideoSampleColorSpace. */
     constructor(init) {
@@ -21894,8 +22107,12 @@ var Mediabunny = (() => {
         return false;
       }
       for (const { config, quantizer } of candidates) {
-        const support = await VideoEncoder.isConfigSupported(config);
-        if (!support.supported) {
+        try {
+          const support = await VideoEncoder.isConfigSupported(config);
+          if (!support.supported) {
+            continue;
+          }
+        } catch {
           continue;
         }
         if (!isFirefox()) {
@@ -21987,8 +22204,12 @@ var Mediabunny = (() => {
       if (typeof AudioEncoder === "undefined") {
         return false;
       }
-      const support = await AudioEncoder.isConfigSupported(encoderConfig);
-      return support.supported === true;
+      try {
+        const support = await AudioEncoder.isConfigSupported(encoderConfig);
+        return support.supported === true;
+      } catch {
+        return false;
+      }
     })();
     canEncodeAudioMemo.set(key, promise);
     return promise;
@@ -23521,19 +23742,12 @@ var Mediabunny = (() => {
         // Firefox has VideoFrame glitches with opaque canvases
       });
       assert(context);
-      context.imageSmoothingQuality = "high";
-      if (!canvasIsNew) {
-        if (!this._alpha && isFirefox()) {
-          context.fillStyle = "black";
-          context.fillRect(0, 0, width, height);
-        } else {
-          context.clearRect(0, 0, width, height);
-        }
-      }
-      sample.drawWithFit(context, {
+      sample._drawWithFitAndMipmapping(canvas, context, {
         fit: this._fit,
         rotation: this._rotation,
-        crop: this._crop
+        crop: this._crop,
+        targetIsFresh: canvasIsNew,
+        fillBlack: !this._alpha && isFirefox()
       });
       const result = {
         canvas,
@@ -24971,8 +25185,9 @@ var Mediabunny = (() => {
       if (filtered.length === 0) {
         return 0;
       }
-      const firstTimestamps = await Promise.all(filtered.map((x) => x.getFirstTimestamp()));
-      return Math.min(...firstTimestamps);
+      const firstPackets = await Promise.all(filtered.map((x) => x._backing.getFirstPacket({ metadataOnly: true })));
+      const result = Math.min(...firstPackets.map((x) => x?.timestamp ?? Infinity));
+      return result === Infinity ? 0 : result;
     }
     /**
      * Computes the duration of the input file, in seconds. More precisely, returns the largest end timestamp among
@@ -26478,7 +26693,7 @@ var Mediabunny = (() => {
       try {
         this.validateTimestamp(track, packet.timestamp, packet.type === "key");
         if (this.inputIsAdts === null) {
-          validateAudioChunkMetadata(meta);
+          validateAudioChunkMetadata(meta, track.source._codec);
           const description = meta?.decoderConfig?.description;
           this.inputIsAdts = !description;
           if (!this.inputIsAdts) {
@@ -26518,6 +26733,9 @@ var Mediabunny = (() => {
     }
     async finalize() {
       const release = await this.mutex.acquire();
+      if (this.inputIsAdts === null) {
+        throw new Error("Cannot finalize an empty ADTS file: not a single packet was added.");
+      }
       release();
     }
   };
@@ -26541,8 +26759,46 @@ var Mediabunny = (() => {
       const release = await this.mutex.acquire();
       this.writer = await this.output._getRootWriter(!!this.format._options.appendOnly);
       this.writer.write(FLAC_HEADER);
+      const track = this.output.tracks[0];
+      assert(track?.isAudioTrack());
+      if (track.metadata.decoderConfig) {
+        validateAudioChunkMetadata({ decoderConfig: track.metadata.decoderConfig }, track.source._codec);
+        this.applyDecoderConfig(track.metadata.decoderConfig);
+      }
       release();
     }
+    applyDecoderConfig(decoderConfig) {
+      assert(decoderConfig.description);
+      this.sampleRate = decoderConfig.sampleRate;
+      this.channels = decoderConfig.numberOfChannels;
+      const descriptionBitstream = new Bitstream(
+        toUint8Array(decoderConfig.description)
+      );
+      descriptionBitstream.skipBits(103 + 64);
+      this.bitsPerSample = descriptionBitstream.readBits(5) + 1;
+      if (this.format._options.appendOnly) {
+        this.writeHeader({
+          // https://www.rfc-editor.org/rfc/rfc9639.html#name-streaminfo
+          // Per RFC 9639, min/max block sizes can be looser than
+          // actual values, so we use the full valid range (16–65535).
+          // "The actual max block size MAY be smaller than what's
+          // listed, and the actual min (excluding last block) MAY be
+          // larger. This is because the encoder has to write these
+          // fields before receiving any input audio data and cannot
+          // know beforehand what block sizes it will use."
+          minimumBlockSize: 16,
+          maximumBlockSize: 65535,
+          // https://www.rfc-editor.org/rfc/rfc9639.html#name-streaminfo
+          // "A value of 0 signifies that the value is not known."
+          minimumFrameSize: 0,
+          maximumFrameSize: 0,
+          sampleRate: this.sampleRate,
+          channels: this.channels,
+          bitsPerSample: this.bitsPerSample,
+          totalSamples: 0
+        });
+      }
+    }
     writeHeader({
       bitsPerSample,
       minimumBlockSize,
@@ -26647,40 +26903,10 @@ var Mediabunny = (() => {
           packet.type === "key"
         );
         if (this.sampleRate === null) {
-          validateAudioChunkMetadata(meta);
+          validateAudioChunkMetadata(meta, track.source._codec);
           assert(meta);
           assert(meta.decoderConfig);
-          assert(meta.decoderConfig.description);
-          this.sampleRate = meta.decoderConfig.sampleRate;
-          this.channels = meta.decoderConfig.numberOfChannels;
-          const descriptionBitstream = new Bitstream(
-            toUint8Array(meta.decoderConfig.description)
-          );
-          descriptionBitstream.skipBits(103 + 64);
-          const bitsPerSample = descriptionBitstream.readBits(5) + 1;
-          this.bitsPerSample = bitsPerSample;
-          if (this.format._options.appendOnly) {
-            this.writeHeader({
-              // https://www.rfc-editor.org/rfc/rfc9639.html#name-streaminfo
-              // Per RFC 9639, min/max block sizes can be looser than
-              // actual values, so we use the full valid range (16–65535).
-              // "The actual max block size MAY be smaller than what's
-              // listed, and the actual min (excluding last block) MAY be
-              // larger. This is because the encoder has to write these
-              // fields before receiving any input audio data and cannot
-              // know beforehand what block sizes it will use."
-              minimumBlockSize: 16,
-              maximumBlockSize: 65535,
-              // https://www.rfc-editor.org/rfc/rfc9639.html#name-streaminfo
-              // "A value of 0 signifies that the value is not known."
-              minimumFrameSize: 0,
-              maximumFrameSize: 0,
-              sampleRate: this.sampleRate,
-              channels: this.channels,
-              bitsPerSample: this.bitsPerSample,
-              totalSamples: 0
-            });
-          }
+          this.applyDecoderConfig(meta.decoderConfig);
         }
         if (!this.metadataWritten) {
           this.writeVorbisCommentAndPictureBlock();
@@ -26714,6 +26940,14 @@ var Mediabunny = (() => {
     }
     async finalize() {
       const release = await this.mutex.acquire();
+      if (this.sampleRate === null) {
+        throw new Error(
+          "Cannot finalize an empty FLAC file: no packets were added and the track specified no decoderConfig in its metadata, so there's no telling what the file should look like."
+        );
+      }
+      if (!this.metadataWritten) {
+        this.writeVorbisCommentAndPictureBlock();
+      }
       if (!this.format._options.appendOnly) {
         let minimumBlockSize = Infinity;
         let maximumBlockSize = 0;
@@ -26731,7 +26965,12 @@ var Mediabunny = (() => {
           }
           minimumBlockSize = Math.min(minimumBlockSize, this.blockSizes[i]);
         }
-        assert(this.sampleRate !== null);
+        if (this.blockSizes.length === 0) {
+          minimumBlockSize = 16;
+          maximumBlockSize = 65535;
+          minimumFrameSize = 0;
+          maximumFrameSize = 0;
+        }
         assert(this.channels !== null);
         assert(this.bitsPerSample !== null);
         this.writer.seek(4);
@@ -27711,7 +27950,8 @@ var Mediabunny = (() => {
     ]);
   };
   var dac3 = (trackData) => {
-    const frameInfo = parseAc3SyncFrame(trackData.info.firstPacket.data);
+    assert(trackData.info.primingPacket);
+    const frameInfo = parseAc3SyncFrame(trackData.info.primingPacket.data);
     if (!frameInfo) {
       throw new Error(
         "Couldn't extract AC-3 frame info from the audio packet. Ensure the packets contain valid AC-3 sync frames (as specified in ETSI TS 102 366)."
@@ -27729,7 +27969,8 @@ var Mediabunny = (() => {
     return box("dac3", [...bytes2]);
   };
   var dec3 = (trackData) => {
-    const frameInfo = parseEac3SyncFrame(trackData.info.firstPacket.data);
+    assert(trackData.info.primingPacket);
+    const frameInfo = parseEac3SyncFrame(trackData.info.primingPacket.data);
     if (!frameInfo) {
       throw new Error(
         "Couldn't extract E-AC-3 frame info from the audio packet. Ensure the packets contain valid E-AC-3 sync frames (as specified in ETSI TS 102 366)."
@@ -28030,7 +28271,7 @@ var Mediabunny = (() => {
       mfro()
     ]);
   };
-  var tfra = (trackData, trackIndex) => {
+  var tfra = (trackData) => {
     const version = 1;
     return fullBox("tfra", version, 0, [
       u32(trackData.track.id),
@@ -28044,7 +28285,7 @@ var Mediabunny = (() => {
         // Time (in presentation time)
         u64(chunk.moofOffset),
         // moof offset
-        u32(trackIndex + 1),
+        u32(chunk.trafIndex + 1),
         // traf number
         u32(1),
         // trun number
@@ -28968,9 +29209,16 @@ var Mediabunny = (() => {
           if (this._monotonicity === true && position !== this._lastFlushEnd) {
             throw new Error("Internal error: Monotonicity violation.");
           }
+          const isPartialView = section.start !== 0 || section.end !== chunk.data.byteLength;
+          let data;
+          if (isPartialView && isWebKit()) {
+            data = chunk.data.slice(section.start, section.end);
+          } else {
+            data = chunk.data.subarray(section.start, section.end);
+          }
           void this._streamWriter.write({
             type: "write",
-            data: chunk.data.subarray(section.start, section.end),
+            data,
             position
           }).catch((error) => {
             this._writeError ??= error;
@@ -29213,6 +29461,7 @@ var Mediabunny = (() => {
       this.allTracksKnown = promiseWithResolvers();
       this.creationTime = Math.floor(Date.now() / 1e3) + TIMESTAMP_OFFSET;
       this.finalizedChunks = [];
+      this.wroteFragmentedHeader = false;
       this.nextFragmentNumber = 1;
       // Only relevant for fragmented files, to make sure new fragments start with the highest timestamp seen so far
       this.maxWrittenTimestamp = -Infinity;
@@ -29220,17 +29469,18 @@ var Mediabunny = (() => {
       this.maxWrittenEndTimestamp = -Infinity;
       this.segmentHeaderSize = null;
       this.format = format;
+      this.formatOptions = { ...format._options };
       this.isQuickTime = format instanceof MovOutputFormat;
       this.isCmaf = format instanceof CmafOutputFormat;
-      this.minimumFragmentDuration = format._options.minimumFragmentDuration ?? (format instanceof CmafOutputFormat ? Infinity : 1);
+      this.minimumFragmentDuration = this.formatOptions.minimumFragmentDuration ?? (format instanceof CmafOutputFormat ? Infinity : 1);
       this.auxWriter.start();
     }
     async start() {
       const release = await this.mutex.acquire();
       if (!this.isCmaf) {
-        this.writer = await this.output._getRootWriter((target) => this.format._options.fastStart !== void 0 ? this.format._options.fastStart === "fragmented" : target instanceof BufferTarget);
+        this.writer = await this.output._getRootWriter((target) => this.formatOptions.fastStart !== void 0 ? this.formatOptions.fastStart === "fragmented" : target instanceof BufferTarget);
         this.boxWriter = new IsobmffBoxWriter(this.writer);
-        this.fastStart = this.format._options.fastStart ?? (this.writer.target instanceof BufferTarget ? "in-memory" : false);
+        this.fastStart = this.formatOptions.fastStart ?? (this.writer.target instanceof BufferTarget ? "in-memory" : false);
         this.isFragmented = this.fastStart === "fragmented";
       } else {
         this.fastStart = "fragmented";
@@ -29252,7 +29502,7 @@ var Mediabunny = (() => {
       {
         const boxWriter = this.initBoxWriter ?? this.boxWriter;
         assert(boxWriter);
-        if (this.format._options.onFtyp) {
+        if (this.formatOptions.onFtyp) {
           boxWriter.writer.startTrackingWrites();
         }
         boxWriter.writeBox(ftyp({
@@ -29261,9 +29511,9 @@ var Mediabunny = (() => {
           fragmented: this.isFragmented,
           cmaf: this.isCmaf
         }));
-        if (this.format._options.onFtyp) {
+        if (this.formatOptions.onFtyp) {
           const { data, start } = boxWriter.writer.stopTrackingWrites();
-          this.format._options.onFtyp(data, start);
+          this.formatOptions.onFtyp(data, start);
         }
         this.ftypSize = boxWriter.writer.getPos();
         if (this.isCmaf) {
@@ -29283,13 +29533,28 @@ var Mediabunny = (() => {
       } else {
         assert(this.writer);
         assert(this.boxWriter);
-        if (this.format._options.onMdat) {
+        if (this.formatOptions.onMdat) {
           this.writer.startTrackingWrites();
         }
         this.mdat = mdat(true);
         this.boxWriter.writeBox(this.mdat);
       }
       await this.writer?.flush();
+      for (const track of this.output.tracks) {
+        if (track.isVideoTrack() && track.metadata.decoderConfig) {
+          this.getVideoTrackData(
+            track,
+            track.metadata.primingPacket ?? null,
+            { decoderConfig: track.metadata.decoderConfig }
+          );
+        } else if (track.isAudioTrack() && track.metadata.decoderConfig) {
+          this.getAudioTrackData(
+            track,
+            track.metadata.primingPacket ?? null,
+            { decoderConfig: track.metadata.decoderConfig }
+          );
+        }
+      }
       release();
     }
     allTracksAreKnown() {
@@ -29326,7 +29591,7 @@ var Mediabunny = (() => {
       if (existingTrackData) {
         return existingTrackData;
       }
-      validateVideoChunkMetadata(meta);
+      validateVideoChunkMetadata(meta, track.source._codec);
       assert(meta);
       assert(meta.decoderConfig);
       const decoderConfig = { ...meta.decoderConfig };
@@ -29334,6 +29599,9 @@ var Mediabunny = (() => {
       assert(decoderConfig.codedHeight !== void 0);
       let requiresAnnexBTransformation = false;
       if (track.source._codec === "avc" && !decoderConfig.description) {
+        if (!packet) {
+          throw new Error("No AVC description provided; you must therefore provide a priming packet.");
+        }
         const decoderConfigurationRecord = extractAvcDecoderConfigurationRecord(packet.data);
         if (!decoderConfigurationRecord) {
           throw new Error(
@@ -29343,6 +29611,9 @@ var Mediabunny = (() => {
         decoderConfig.description = serializeAvcDecoderConfigurationRecord(decoderConfigurationRecord);
         requiresAnnexBTransformation = true;
       } else if (track.source._codec === "hevc" && !decoderConfig.description) {
+        if (!packet) {
+          throw new Error("No HEVC description provided; you must therefore provide a priming packet.");
+        }
         const decoderConfigurationRecord = extractHevcDecoderConfigurationRecord(packet.data);
         if (!decoderConfigurationRecord) {
           throw new Error(
@@ -29401,12 +29672,15 @@ var Mediabunny = (() => {
       if (existingTrackData) {
         return existingTrackData;
       }
-      validateAudioChunkMetadata(meta);
+      validateAudioChunkMetadata(meta, track.source._codec);
       assert(meta);
       assert(meta.decoderConfig);
       const decoderConfig = { ...meta.decoderConfig };
       let requiresAdtsStripping = false;
       if (track.source._codec === "aac" && !decoderConfig.description) {
+        if (!packet) {
+          throw new Error("No AAC description provided; you must therefore provide a priming packet.");
+        }
         const adtsFrame = readAdtsFrameHeader(FileSlice4.tempFromBytes(packet.data));
         if (!adtsFrame) {
           throw new Error(
@@ -29425,6 +29699,11 @@ var Mediabunny = (() => {
         });
         requiresAdtsStripping = true;
       }
+      if (track.source._codec === "ac3" || track.source._codec === "eac3") {
+        if (!packet) {
+          throw new Error("AC-3/E-AC-3 require a priming packet.");
+        }
+      }
       const newTrackData = {
         muxer: this,
         track,
@@ -29436,7 +29715,7 @@ var Mediabunny = (() => {
           requiresPcmTransformation: !this.isFragmented && PCM_AUDIO_CODECS.includes(track.source._codec),
           expectedNextPcmPacketTimestamp: null,
           requiresAdtsStripping,
-          firstPacket: packet
+          primingPacket: packet
         },
         timescale: decoderConfig.sampleRate,
         samples: [],
@@ -29865,7 +30144,8 @@ var Mediabunny = (() => {
           startTimestamp: sample.timestamp,
           samples: [],
           offset: null,
-          moofOffset: null
+          moofOffset: null,
+          trafIndex: null
         };
       }
       assert(trackData.currentChunk);
@@ -29932,19 +30212,19 @@ var Mediabunny = (() => {
     }
     async finalizeFragment(flushWriter = !this.isCmaf) {
       assert(this.isFragmented);
-      const fragmentNumber = this.nextFragmentNumber++;
-      if (fragmentNumber === 1) {
+      if (!this.wroteFragmentedHeader) {
+        this.wroteFragmentedHeader = true;
         const boxWriter = this.initBoxWriter ?? this.boxWriter;
         assert(boxWriter);
-        if (this.format._options.onMoov) {
+        if (this.formatOptions.onMoov) {
           boxWriter.writer.startTrackingWrites();
         }
         this.ensureOneEnabledTrack();
         const movieBox = moov(this);
         boxWriter.writeBox(movieBox);
-        if (this.format._options.onMoov) {
+        if (this.formatOptions.onMoov) {
           const { data, start } = boxWriter.writer.stopTrackingWrites();
-          this.format._options.onMoov(data, start);
+          this.formatOptions.onMoov(data, start);
         }
         if (this.isCmaf) {
           assert(this.initWriter);
@@ -29961,14 +30241,23 @@ var Mediabunny = (() => {
       assert(this.writer);
       assert(this.boxWriter);
       const tracksInFragment = this.trackDatas.filter((x) => x.currentChunk);
+      if (tracksInFragment.length === 0) {
+        if (flushWriter) {
+          await this.writer.flush();
+        }
+        return;
+      }
+      const fragmentNumber = this.nextFragmentNumber++;
       const moofBox = moof(fragmentNumber, tracksInFragment);
       const moofOffset = this.writer.getPos();
       const mdatStartPos = moofOffset + this.boxWriter.measureBox(moofBox);
       let currentPos = mdatStartPos + MIN_BOX_HEADER_SIZE;
       let fragmentStartTimestamp = Infinity;
-      for (const trackData of tracksInFragment) {
+      for (let i = 0; i < tracksInFragment.length; i++) {
+        const trackData = tracksInFragment[i];
         trackData.currentChunk.offset = currentPos;
         trackData.currentChunk.moofOffset = moofOffset;
+        trackData.currentChunk.trafIndex = i;
         for (const sample of trackData.currentChunk.samples) {
           currentPos += sample.size;
         }
@@ -29981,17 +30270,17 @@ var Mediabunny = (() => {
           trackData.currentChunk.offset += MAX_BOX_HEADER_SIZE - MIN_BOX_HEADER_SIZE;
         }
       }
-      if (this.format._options.onMoof) {
+      if (this.formatOptions.onMoof) {
         this.writer.startTrackingWrites();
       }
       const newMoofBox = moof(fragmentNumber, tracksInFragment);
       this.boxWriter.writeBox(newMoofBox);
-      if (this.format._options.onMoof) {
+      if (this.formatOptions.onMoof) {
         const { data, start } = this.writer.stopTrackingWrites();
-        this.format._options.onMoof(data, start, fragmentStartTimestamp);
+        this.formatOptions.onMoof(data, start, fragmentStartTimestamp);
       }
       assert(this.writer.getPos() === mdatStartPos);
-      if (this.format._options.onMdat) {
+      if (this.formatOptions.onMdat) {
         this.writer.startTrackingWrites();
       }
       const mdatBox = mdat(needsLargeMdatSize);
@@ -30004,9 +30293,9 @@ var Mediabunny = (() => {
           sample.data = null;
         }
       }
-      if (this.format._options.onMdat) {
+      if (this.formatOptions.onMdat) {
         const { data, start } = this.writer.stopTrackingWrites();
-        this.format._options.onMdat(data, start);
+        this.formatOptions.onMdat(data, start);
       }
       for (const trackData of tracksInFragment) {
         trackData.finalizedChunks.push(trackData.currentChunk);
@@ -30018,33 +30307,36 @@ var Mediabunny = (() => {
       }
     }
     async registerSampleFastStartReserve(trackData, sample) {
-      assert(this.writer);
-      assert(this.boxWriter);
       if (this.allTracksAreKnown()) {
         if (!this.mdat) {
-          this.ensureOneEnabledTrack();
-          const moovBox = moov(this);
-          const moovSize = this.boxWriter.measureBox(moovBox);
-          const reservedSize = moovSize + this.computeSampleTableSizeUpperBound() + 4096;
-          assert(this.ftypSize !== null);
-          this.writer.seek(this.ftypSize + reservedSize);
-          if (this.format._options.onMdat) {
-            this.writer.startTrackingWrites();
-          }
-          this.mdat = mdat(true);
-          this.boxWriter.writeBox(this.mdat);
-          for (const trackData2 of this.trackDatas) {
-            for (const sample2 of trackData2.sampleQueue) {
-              await this.addSampleToTrack(trackData2, sample2);
-            }
-            trackData2.sampleQueue.length = 0;
-          }
+          await this.createFastStartReserveMdat();
         }
         await this.addSampleToTrack(trackData, sample);
       } else {
         trackData.sampleQueue.push(sample);
       }
     }
+    async createFastStartReserveMdat() {
+      assert(this.writer);
+      assert(this.boxWriter);
+      this.ensureOneEnabledTrack();
+      const moovBox = moov(this);
+      const moovSize = this.boxWriter.measureBox(moovBox);
+      const reservedSize = moovSize + this.computeSampleTableSizeUpperBound() + 4096;
+      assert(this.ftypSize !== null);
+      this.writer.seek(this.ftypSize + reservedSize);
+      if (this.formatOptions.onMdat) {
+        this.writer.startTrackingWrites();
+      }
+      this.mdat = mdat(true);
+      this.boxWriter.writeBox(this.mdat);
+      for (const trackData of this.trackDatas) {
+        for (const sample of trackData.sampleQueue) {
+          await this.addSampleToTrack(trackData, sample);
+        }
+        trackData.sampleQueue.length = 0;
+      }
+    }
     computeSampleTableSizeUpperBound() {
       assert(this.fastStart === "reserve");
       let upperBound = 0;
@@ -30095,11 +30387,31 @@ var Mediabunny = (() => {
         }
       }
     }
+    /** Internal function for external callers who want to full control fragment boundaries. */
+    async forceFragmentFinalization() {
+      assert(this.isFragmented);
+      const release = await this.mutex.acquire();
+      try {
+        for (const trackData of this.trackDatas) {
+          if (trackData.type === "subtitle" && trackData.track.source._codec === "webvtt") {
+            await this.processWebVTTCues(trackData, Infinity);
+          }
+          this.processTimestamps(trackData);
+        }
+        await this.interleaveSamples(true);
+        await this.finalizeFragment();
+      } finally {
+        release();
+      }
+    }
     /** Finalizes the file, making it ready for use. Must be called after all video and audio chunks have been added. */
     async finalize() {
       const release = await this.mutex.acquire();
       this.allTracksKnown.resolve();
       this.ensureOneEnabledTrack();
+      if (!this.mdat && this.fastStart === "reserve") {
+        await this.createFastStartReserveMdat();
+      }
       for (const trackData of this.trackDatas) {
         trackData.closed = true;
         if (trackData.type === "subtitle" && trackData.track.source._codec === "webvtt") {
@@ -30113,11 +30425,12 @@ var Mediabunny = (() => {
       } else {
         for (const trackData of this.trackDatas) {
           await this.finalizeCurrentChunk(trackData);
-          assert(trackData.startTimestampOffset !== null);
-          for (let i = 0; i < trackData.samples.length; i++) {
-            const sample = trackData.samples[i];
-            sample.timestamp -= trackData.startTimestampOffset;
-            sample.decodeTimestamp -= trackData.startTimestampOffset;
+          if (trackData.startTimestampOffset !== null) {
+            for (let i = 0; i < trackData.samples.length; i++) {
+              const sample = trackData.samples[i];
+              sample.timestamp -= trackData.startTimestampOffset;
+              sample.decodeTimestamp -= trackData.startTimestampOffset;
+            }
           }
         }
       }
@@ -30142,16 +30455,16 @@ var Mediabunny = (() => {
           if (currentChunkPos < 2 ** 32) break;
           if (mdatSize >= 2 ** 32) this.mdat.largeSize = true;
         }
-        if (this.format._options.onMoov) {
+        if (this.formatOptions.onMoov) {
           this.writer.startTrackingWrites();
         }
         const movieBox = moov(this);
         this.boxWriter.writeBox(movieBox);
-        if (this.format._options.onMoov) {
+        if (this.formatOptions.onMoov) {
           const { data, start } = this.writer.stopTrackingWrites();
-          this.format._options.onMoov(data, start);
+          this.formatOptions.onMoov(data, start);
         }
-        if (this.format._options.onMdat) {
+        if (this.formatOptions.onMdat) {
           this.writer.startTrackingWrites();
         }
         this.mdat.size = mdatSize;
@@ -30163,9 +30476,9 @@ var Mediabunny = (() => {
             sample.data = null;
           }
         }
-        if (this.format._options.onMdat) {
+        if (this.formatOptions.onMdat) {
           const { data, start } = this.writer.stopTrackingWrites();
-          this.format._options.onMdat(data, start);
+          this.formatOptions.onMdat(data, start);
         }
       } else if (this.isFragmented) {
         if (this.isCmaf) {
@@ -30189,29 +30502,29 @@ var Mediabunny = (() => {
         this.mdat.size = mdatSize;
         this.mdat.largeSize = mdatSize >= 2 ** 32;
         this.boxWriter.patchBox(this.mdat);
-        if (this.format._options.onMdat) {
+        if (this.formatOptions.onMdat) {
           const { data, start } = this.writer.stopTrackingWrites();
-          this.format._options.onMdat(data, start);
+          this.formatOptions.onMdat(data, start);
         }
         const movieBox = moov(this);
         if (this.fastStart === "reserve") {
           assert(this.ftypSize !== null);
           this.writer.seek(this.ftypSize);
-          if (this.format._options.onMoov) {
+          if (this.formatOptions.onMoov) {
             this.writer.startTrackingWrites();
           }
           this.boxWriter.writeBox(movieBox);
           const remainingSpace = this.boxWriter.offsets.get(this.mdat) - this.writer.getPos();
           this.boxWriter.writeBox(free(remainingSpace));
         } else {
-          if (this.format._options.onMoov) {
+          if (this.formatOptions.onMoov) {
             this.writer.startTrackingWrites();
           }
           this.boxWriter.writeBox(movieBox);
         }
-        if (this.format._options.onMoov) {
+        if (this.formatOptions.onMoov) {
           const { data, start } = this.writer.stopTrackingWrites();
-          this.format._options.onMoov(data, start);
+          this.formatOptions.onMoov(data, start);
         }
       }
       release();
@@ -30258,6 +30571,21 @@ var Mediabunny = (() => {
       this.createSegmentInfo();
       this.createCues();
       await this.writer.flush();
+      for (const track of this.output.tracks) {
+        if (track.isVideoTrack() && track.metadata.decoderConfig) {
+          this.getVideoTrackData(
+            track,
+            track.metadata.primingPacket ?? null,
+            { decoderConfig: track.metadata.decoderConfig }
+          );
+        } else if (track.isAudioTrack() && track.metadata.decoderConfig) {
+          this.getAudioTrackData(
+            track,
+            track.metadata.primingPacket ?? null,
+            { decoderConfig: track.metadata.decoderConfig }
+          );
+        }
+      }
       release();
     }
     writeEBMLHeader() {
@@ -30722,7 +31050,7 @@ var Mediabunny = (() => {
       if (existingTrackData) {
         return existingTrackData;
       }
-      validateVideoChunkMetadata(meta);
+      validateVideoChunkMetadata(meta, track.source._codec);
       assert(meta);
       assert(meta.decoderConfig);
       assert(meta.decoderConfig.codedWidth !== void 0);
@@ -30741,8 +31069,7 @@ var Mediabunny = (() => {
           height: meta.decoderConfig.codedHeight,
           aspectRatio,
           decoderConfig: meta.decoderConfig,
-          alphaMode: !!packet.sideData.alpha
-          // The first packet determines if this track has alpha or not
+          alphaMode: packet ? !!packet.sideData.alpha : null
         },
         chunkQueue: [],
         lastWrittenMsTimestamp: null,
@@ -30772,12 +31099,15 @@ var Mediabunny = (() => {
       if (existingTrackData) {
         return existingTrackData;
       }
-      validateAudioChunkMetadata(meta);
+      validateAudioChunkMetadata(meta, track.source._codec);
       assert(meta);
       assert(meta.decoderConfig);
       const decoderConfig = { ...meta.decoderConfig };
       let requiresAdtsStripping = false;
       if (track.source._codec === "aac" && !decoderConfig.description) {
+        if (!packet) {
+          throw new Error("No AAC description provided; you must therefore provide a priming packet.");
+        }
         const adtsFrame = readAdtsFrameHeader(FileSlice4.tempFromBytes(packet.data));
         if (!adtsFrame) {
           throw new Error(
@@ -30847,6 +31177,7 @@ var Mediabunny = (() => {
       const release = await this.mutex.acquire();
       try {
         const trackData = this.getVideoTrackData(track, packet, meta);
+        trackData.info.alphaMode ??= !!packet.sideData.alpha;
         let packetData = packet.data;
         if (track.source._codec === "prores") {
           if (packetData.byteLength < 8) {
@@ -31237,7 +31568,7 @@ ${cue.notes ?? ""}`;
         data.sampleRate,
         padding
       );
-      this.writer.seek(startPos + frameSize);
+      this.writer.write(new Uint8Array(startPos + frameSize - this.writer.getPos()));
     }
   };
 
@@ -31322,22 +31653,95 @@ ${cue.notes ?? ""}`;
       throw new Error("MP3 does not support subtitles.");
     }
     async finalize() {
-      if (!this.xingFrameData || this.xingFramePos === null) {
-        return;
-      }
       const release = await this.mutex.acquire();
+      if (!this.xingFrameData && this.format._options.xingHeader === false) {
+        throw new Error(
+          "Cannot finalize an empty MP3 file: not a single packet was added and the Xing header is disabled, so there's no frame we could write."
+        );
+      }
+      if (!this.xingFrameData) {
+        const track = this.output.tracks[0];
+        assert(track?.isAudioTrack());
+        const primingPacket = track.metadata.primingPacket;
+        if (primingPacket) {
+          const view2 = toDataView(primingPacket.data);
+          if (view2.byteLength < 4) {
+            throw new Error("Invalid MP3 header in priming packet.");
+          }
+          const word = view2.getUint32(0, false);
+          const header = readMp3FrameHeader(word, null).header;
+          if (!header) {
+            throw new Error("Invalid MP3 header in priming packet.");
+          }
+          this.xingFrameData = {
+            mpegVersionId: header.mpegVersionId,
+            layer: header.layer,
+            frequencyIndex: header.frequencyIndex,
+            sampleRate: header.sampleRate,
+            channel: header.channel,
+            modeExtension: header.modeExtension,
+            copyright: header.copyright,
+            original: header.original,
+            emphasis: header.emphasis,
+            frameCount: null,
+            fileSize: null,
+            toc: null
+          };
+        } else if (track.metadata.decoderConfig) {
+          const { sampleRate, numberOfChannels } = track.metadata.decoderConfig;
+          const mpegVersionIds = [3, 2, 0];
+          let mpegVersionId = null;
+          let frequencyIndex = -1;
+          for (let i = 0; i < mpegVersionIds.length; i++) {
+            frequencyIndex = SAMPLING_RATES.indexOf(sampleRate << i);
+            if (frequencyIndex !== -1) {
+              mpegVersionId = mpegVersionIds[i];
+              break;
+            }
+          }
+          if (mpegVersionId === null) {
+            throw new Error(`${sampleRate} Hz is not a valid MP3 sample rate.`);
+          }
+          this.xingFrameData = {
+            mpegVersionId,
+            layer: 1,
+            // Layer III
+            frequencyIndex,
+            sampleRate,
+            channel: numberOfChannels === 1 ? 3 : 0,
+            // 3 = single channel, 0 = stereo
+            modeExtension: 0,
+            copyright: 0,
+            original: 0,
+            emphasis: 0,
+            frameCount: null,
+            fileSize: null,
+            toc: null
+          };
+        } else {
+          throw new Error(
+            "Cannot finalize an empty MP3 file: no packets were added and the track specified neither a decoderConfig nor a primingPacket in its metadata, so there's no telling what the file should look like."
+          );
+        }
+        this.xingFramePos = this.writer.getPos();
+        this.mp3Writer.writeXingFrame(this.xingFrameData);
+        this.frameCount++;
+      }
+      assert(this.xingFramePos !== null);
       const endPos = this.writer.getPos();
       const audioDataEndPos = endPos - this.xingFramePos;
       this.writer.seek(this.xingFramePos);
-      const toc = new Uint8Array(100);
-      for (let i = 0; i < 100; i++) {
-        const index = Math.floor(this.framePositions.length * (i / 100));
-        const byteOffset = this.framePositions[index] - this.xingFramePos;
-        toc[i] = 256 * (byteOffset / audioDataEndPos);
+      if (this.framePositions.length > 0) {
+        const toc = new Uint8Array(100);
+        for (let i = 0; i < 100; i++) {
+          const index = Math.floor(this.framePositions.length * (i / 100));
+          const byteOffset = this.framePositions[index] - this.xingFramePos;
+          toc[i] = 256 * (byteOffset / audioDataEndPos);
+        }
+        this.xingFrameData.toc = toc;
       }
       this.xingFrameData.frameCount = this.frameCount;
       this.xingFrameData.fileSize = audioDataEndPos;
-      this.xingFrameData.toc = toc;
       if (this.format._options.onXingFrame) {
         this.writer.startTrackingWrites();
       }
@@ -31365,6 +31769,12 @@ ${cue.notes ?? ""}`;
     async start() {
       const release = await this.mutex.acquire();
       this.writer = await this.output._getRootWriter(true);
+      for (const track of this.output.tracks) {
+        assert(track.isAudioTrack());
+        if (track.metadata.decoderConfig) {
+          this.getTrackData(track, { decoderConfig: track.metadata.decoderConfig });
+        }
+      }
       release();
     }
     async getMimeType() {
@@ -31386,7 +31796,7 @@ ${cue.notes ?? ""}`;
         serialNumber = Math.floor(2 ** 32 * Math.random());
       } while (this.trackDatas.some((td) => td.serialNumber === serialNumber));
       assert(track.source._codec === "vorbis" || track.source._codec === "opus");
-      validateAudioChunkMetadata(meta);
+      validateAudioChunkMetadata(meta, track.source._codec);
       assert(meta);
       assert(meta.decoderConfig);
       const newTrackData = {
@@ -31738,7 +32148,7 @@ ${cue.notes ?? ""}`;
       if (existingTrackData) {
         return existingTrackData;
       }
-      validateVideoChunkMetadata(meta);
+      validateVideoChunkMetadata(meta, track.source._codec);
       assert(meta?.decoderConfig);
       const codec = track.source._codec;
       assert(codec === "avc" || codec === "hevc");
@@ -31773,7 +32183,7 @@ ${cue.notes ?? ""}`;
       if (existingTrackData) {
         return existingTrackData;
       }
-      validateAudioChunkMetadata(meta);
+      validateAudioChunkMetadata(meta, track.source._codec);
       assert(meta?.decoderConfig);
       const codec = track.source._codec;
       assert(codec === "aac" || codec === "mp3" || codec === "ac3" || codec === "eac3");
@@ -32325,6 +32735,14 @@ ${cue.notes ?? ""}`;
       const release = await this.mutex.acquire();
       this.writer = await this.output._getRootWriter(false);
       this.riffWriter = new RiffWriter(this.writer);
+      const track = this.output.tracks[0];
+      assert(track?.isAudioTrack());
+      if (track.metadata.decoderConfig) {
+        validateAudioChunkMetadata({ decoderConfig: track.metadata.decoderConfig }, track.source._codec);
+        this.writeHeader(track, track.metadata.decoderConfig);
+        this.sampleRate = track.metadata.decoderConfig.sampleRate;
+        this.headerWritten = true;
+      }
       release();
     }
     async getMimeType() {
@@ -32337,7 +32755,7 @@ ${cue.notes ?? ""}`;
       const release = await this.mutex.acquire();
       try {
         if (!this.headerWritten) {
-          validateAudioChunkMetadata(meta);
+          validateAudioChunkMetadata(meta, track.source._codec);
           assert(meta);
           assert(meta.decoderConfig);
           this.writeHeader(track, meta.decoderConfig);
@@ -32561,6 +32979,11 @@ ${cue.notes ?? ""}`;
     }
     async finalize() {
       const release = await this.mutex.acquire();
+      if (!this.headerWritten) {
+        throw new Error(
+          "Cannot finalize an empty WAVE file: no packets were added and the track specified no decoderConfig in its metadata, so there's no telling what the file should look like."
+        );
+      }
       const endPos = this.writer.getPos();
       if (this.isRf64) {
         assert(this.ds64RiffSizePos !== null);
@@ -33235,10 +33658,13 @@ ${cue.notes ?? ""}`;
               `The dimensions ${candidateConfig.width}x${candidateConfig.height} are not supported for codec '${this.encodingConfig.codec}'; both width and height must be even numbers. Make sure to round your dimensions to the nearest even number.`
             );
           }
-          const support = await VideoEncoder.isConfigSupported(candidateConfig);
-          if (support.supported) {
-            selected = candidate;
-            break;
+          try {
+            const support = await VideoEncoder.isConfigSupported(candidateConfig);
+            if (support.supported) {
+              selected = candidate;
+              break;
+            }
+          } catch {
           }
         }
         if (!selected) {
@@ -34294,8 +34720,14 @@ ${cue.notes ?? ""}`;
           if (typeof AudioEncoder === "undefined") {
             throw new Error("AudioEncoder is not supported by this browser.");
           }
-          const support = await AudioEncoder.isConfigSupported(encoderConfig);
-          if (!support.supported) {
+          let supported;
+          try {
+            const support = await AudioEncoder.isConfigSupported(encoderConfig);
+            supported = support.supported ?? false;
+          } catch {
+            supported = false;
+          }
+          if (!supported) {
             throw new Error(
               `This specific encoder configuration (${encoderConfig.codec}, ${encoderConfig.bitrate} bps, ${encoderConfig.numberOfChannels} channels, ${encoderConfig.sampleRate} Hz) is not supported by this browser. Consider using another codec or changing your audio parameters.`
             );
@@ -35177,6 +35609,21 @@ ${cue.notes ?? ""}`;
           references: variant.linkedGroup ? this.playlistDeclarations.filter((x) => x.groupId === variant.linkedGroup.name) : []
         });
       }
+      for (const track of this.output.tracks) {
+        if (track.isVideoTrack() && track.metadata.decoderConfig) {
+          this.getVideoTrackData(
+            track,
+            track.metadata.primingPacket ?? null,
+            { decoderConfig: track.metadata.decoderConfig }
+          );
+        } else if (track.isAudioTrack() && track.metadata.decoderConfig) {
+          this.getAudioTrackData(
+            track,
+            track.metadata.primingPacket ?? null,
+            { decoderConfig: track.metadata.decoderConfig }
+          );
+        }
+      }
       release();
     }
     async getMimeType() {
@@ -35205,12 +35652,12 @@ ${cue.notes ?? ""}`;
         release();
       }
     }
-    getVideoTrackData(track, meta) {
+    getVideoTrackData(track, packet, meta) {
       let trackData = this.trackDatas.find((x) => x.track === track);
       if (trackData) {
         return trackData;
       }
-      validateVideoChunkMetadata(meta);
+      validateVideoChunkMetadata(meta, track.source._codec);
       assert(meta);
       assert(meta?.decoderConfig);
       const playlists = this.playlists.filter((x) => x.tracks.includes(track));
@@ -35222,18 +35669,19 @@ ${cue.notes ?? ""}`;
         closed: false,
         info: {
           type: "video",
-          decoderConfig: meta.decoderConfig
+          decoderConfig: meta.decoderConfig,
+          primingPacket: packet
         }
       };
       this.trackDatas.push(trackData);
       return trackData;
     }
-    getAudioTrackData(track, meta) {
+    getAudioTrackData(track, packet, meta) {
       let trackData = this.trackDatas.find((x) => x.track === track);
       if (trackData) {
         return trackData;
       }
-      validateAudioChunkMetadata(meta);
+      validateAudioChunkMetadata(meta, track.source._codec);
       assert(meta);
       assert(meta?.decoderConfig);
       const playlists = this.playlists.filter((x) => x.tracks.includes(track));
@@ -35245,14 +35693,15 @@ ${cue.notes ?? ""}`;
         closed: false,
         info: {
           type: "audio",
-          decoderConfig: meta.decoderConfig
+          decoderConfig: meta.decoderConfig,
+          primingPacket: packet
         }
       };
       this.trackDatas.push(trackData);
       return trackData;
     }
     async addEncodedVideoPacket(track, packet, meta) {
-      const trackData = this.getVideoTrackData(track, meta);
+      const trackData = this.getVideoTrackData(track, packet, meta);
       const playlist = trackData.playlist;
       const release = await playlist.mutex.acquire();
       try {
@@ -35272,7 +35721,7 @@ ${cue.notes ?? ""}`;
       }
     }
     async addEncodedAudioPacket(track, packet, meta) {
-      const trackData = this.getAudioTrackData(track, meta);
+      const trackData = this.getAudioTrackData(track, packet, meta);
       const playlist = trackData.playlist;
       const release = await playlist.mutex.acquire();
       try {
@@ -35299,11 +35748,13 @@ ${cue.notes ?? ""}`;
       if (!this.allTracksAreKnown(playlist)) {
         return;
       }
+      const trackDatas = this.trackDatas.filter((x) => playlist.tracks.includes(x.track));
       if (playlist.currentSegmentStartTimestamp === null) {
-        await this.onPlaylistDone(playlist);
+        if (trackDatas.every((x) => x.closed)) {
+          await this.onPlaylistDone(playlist);
+        }
         return;
       }
-      const trackDatas = this.trackDatas.filter((x) => playlist.tracks.includes(x.track));
       const videoTrack = trackDatas.find((x) => x.info.type === "video");
       const audioTrack = trackDatas.find((x) => x.info.type === "audio");
       while (true) {
@@ -35422,12 +35873,68 @@ ${cue.notes ?? ""}`;
               isRoot: false,
               mimeType: playlist.segmentFormat.mimeType
             });
-            target._start();
+            let fragmentedIsobmffOutput = null;
+            if (playlist.segmentFormat._isFragmentedIsobmff()) {
+              fragmentedIsobmffOutput = {
+                output: new Output({
+                  format: playlist.segmentFormat,
+                  target
+                }),
+                videoSource: null,
+                audioSource: null,
+                firstMoofPosition: null,
+                currentFileSize: 0
+              };
+              target.on("write", ({ end }) => {
+                fragmentedIsobmffOutput.currentFileSize = Math.max(
+                  fragmentedIsobmffOutput.currentFileSize,
+                  end
+                );
+              });
+              const muxer = fragmentedIsobmffOutput.output._muxer;
+              muxer.minimumFragmentDuration = Infinity;
+              const originalOnMoof = muxer.formatOptions.onMoof;
+              muxer.formatOptions.onMoof = (data, position, timestamp) => {
+                fragmentedIsobmffOutput.firstMoofPosition = position;
+                originalOnMoof?.(data, position, timestamp);
+                muxer.formatOptions.onMoof = originalOnMoof;
+              };
+              if (videoTrack) {
+                fragmentedIsobmffOutput.videoSource = new EncodedVideoPacketSource(
+                  videoTrack.track.source._codec
+                );
+                fragmentedIsobmffOutput.output.addVideoTrack(
+                  fragmentedIsobmffOutput.videoSource,
+                  {
+                    ...videoTrack.track.metadata,
+                    decoderConfig: videoTrack.info.decoderConfig,
+                    primingPacket: videoTrack.info.primingPacket ?? void 0
+                  }
+                );
+              }
+              if (audioTrack) {
+                fragmentedIsobmffOutput.audioSource = new EncodedAudioPacketSource(
+                  audioTrack.track.source._codec
+                );
+                fragmentedIsobmffOutput.output.addAudioTrack(
+                  fragmentedIsobmffOutput.audioSource,
+                  {
+                    ...audioTrack.track.metadata,
+                    decoderConfig: audioTrack.info.decoderConfig,
+                    primingPacket: audioTrack.info.primingPacket ?? void 0
+                  }
+                );
+              }
+              await fragmentedIsobmffOutput.output.start();
+            } else {
+              target._start();
+            }
             playlist.singleFile = {
               target,
               path: relativeSegmentPath,
               nextOffset: 0,
-              info: segmentInfo2
+              info: segmentInfo2,
+              fragmentedIsobmffOutput
             };
           } else {
             relativeSegmentPath = playlist.singleFile.path;
@@ -35450,95 +35957,114 @@ ${cue.notes ?? ""}`;
         }
         let segmentSize = 0;
         let outputTarget = null;
-        const output = new Output({
-          format: playlist.segmentFormat,
-          target: new PathedTarget(
-            fullSegmentPath,
-            async (request) => {
-              const proxiedRequest = {
-                ...request,
-                isRoot: false
-              };
-              if (request.isRoot) {
+        let maxEndTimestamp = -Infinity;
+        let output = null;
+        let videoSource = null;
+        let audioSource = null;
+        try {
+          if (playlist.singleFile?.fragmentedIsobmffOutput) {
+            output = playlist.singleFile.fragmentedIsobmffOutput.output;
+            videoSource = playlist.singleFile.fragmentedIsobmffOutput.videoSource;
+            audioSource = playlist.singleFile.fragmentedIsobmffOutput.audioSource;
+          } else {
+            output = new Output({
+              format: playlist.segmentFormat,
+              target: new PathedTarget(
+                fullSegmentPath,
+                async (request) => {
+                  const proxiedRequest = {
+                    ...request,
+                    isRoot: false
+                  };
+                  if (request.isRoot) {
+                    if (playlist.singleFile) {
+                      const slice = playlist.singleFile.target.slice(playlist.singleFile.nextOffset);
+                      slice.on("write", ({ end }) => segmentSize = Math.max(segmentSize, end));
+                      return slice;
+                    } else {
+                      const target = await this.output._getTarget(proxiedRequest);
+                      outputTarget = target;
+                      target.on("write", ({ end }) => segmentSize = Math.max(segmentSize, end));
+                      return target;
+                    }
+                  }
+                  return this.output._getTarget(proxiedRequest);
+                }
+              ),
+              initTarget: async () => {
+                if (playlist.initSegment) {
+                  return new NullTarget();
+                }
                 if (playlist.singleFile) {
+                  playlist.initSegment = {
+                    path: playlist.singleFile.path,
+                    duration: 0,
+                    timestamp: 0,
+                    byteSize: 0,
+                    byteOffset: 0,
+                    info: null
+                  };
                   const slice = playlist.singleFile.target.slice(playlist.singleFile.nextOffset);
-                  slice.on("write", ({ end }) => segmentSize = Math.max(segmentSize, end));
+                  slice.on("write", ({ end }) => {
+                    playlist.initSegment.byteSize = Math.max(playlist.initSegment.byteSize, end);
+                  });
+                  slice.on("finalized", () => {
+                    playlist.singleFile.nextOffset = playlist.initSegment.byteSize;
+                  });
                   return slice;
                 } else {
-                  const target = await this.output._getTarget(proxiedRequest);
-                  outputTarget = target;
-                  target.on("write", ({ end }) => segmentSize = Math.max(segmentSize, end));
+                  const playlistInfo = toPlaylistInfo(playlist);
+                  const initPath = await this.getInitPath(playlistInfo);
+                  validateInitPath(initPath);
+                  playlist.initSegment = {
+                    path: initPath,
+                    duration: 0,
+                    timestamp: 0,
+                    byteSize: 0,
+                    byteOffset: null,
+                    info: null
+                  };
+                  const fullInitPath = joinPaths(
+                    joinPaths(pathedTarget.rootPath, playlist.path),
+                    initPath
+                  );
+                  const target = await this.output._getTarget({
+                    path: fullInitPath,
+                    isRoot: false,
+                    mimeType: playlist.segmentFormat.mimeType
+                  });
+                  target.on("write", ({ end }) => {
+                    playlist.initSegment.byteSize = Math.max(playlist.initSegment.byteSize, end);
+                  });
+                  target.on("finalized", () => {
+                    this.format._options.onInit?.(target, playlistInfo);
+                  });
                   return target;
                 }
               }
-              return this.output._getTarget(proxiedRequest);
-            }
-          ),
-          initTarget: async () => {
-            if (playlist.initSegment) {
-              return new NullTarget();
-            }
-            if (playlist.singleFile) {
-              playlist.initSegment = {
-                path: playlist.singleFile.path,
-                duration: 0,
-                timestamp: 0,
-                byteSize: 0,
-                byteOffset: 0,
-                info: null
-              };
-              const slice = playlist.singleFile.target.slice(playlist.singleFile.nextOffset);
-              slice.on("write", ({ end }) => {
-                playlist.initSegment.byteSize = Math.max(playlist.initSegment.byteSize, end);
-              });
-              slice.on("finalized", () => {
-                playlist.singleFile.nextOffset = playlist.initSegment.byteSize;
-              });
-              return slice;
-            } else {
-              const playlistInfo = toPlaylistInfo(playlist);
-              const initPath = await this.getInitPath(playlistInfo);
-              validateInitPath(initPath);
-              playlist.initSegment = {
-                path: initPath,
-                duration: 0,
-                timestamp: 0,
-                byteSize: 0,
-                byteOffset: null,
-                info: null
-              };
-              const fullInitPath = joinPaths(
-                joinPaths(pathedTarget.rootPath, playlist.path),
-                initPath
+            });
+            if (videoTrack) {
+              videoSource = new EncodedVideoPacketSource(
+                videoTrack.track.source._codec
               );
-              const target = await this.output._getTarget({
-                path: fullInitPath,
-                isRoot: false,
-                mimeType: playlist.segmentFormat.mimeType
-              });
-              target.on("write", ({ end }) => {
-                playlist.initSegment.byteSize = Math.max(playlist.initSegment.byteSize, end);
+              output.addVideoTrack(videoSource, {
+                ...videoTrack.track.metadata,
+                decoderConfig: videoTrack.info.decoderConfig,
+                primingPacket: videoTrack.info.primingPacket ?? void 0
               });
-              target.on("finalized", () => {
-                this.format._options.onInit?.(target, playlistInfo);
+            }
+            if (audioTrack) {
+              audioSource = new EncodedAudioPacketSource(
+                audioTrack.track.source._codec
+              );
+              output.addAudioTrack(audioSource, {
+                ...audioTrack.track.metadata,
+                decoderConfig: audioTrack.info.decoderConfig,
+                primingPacket: audioTrack.info.primingPacket ?? void 0
               });
-              return target;
             }
+            await output.start();
           }
-        });
-        let maxEndTimestamp = -Infinity;
-        try {
-          let videoSource = null;
-          let audioSource = null;
-          if (videoTrack) {
-            videoSource = new EncodedVideoPacketSource(videoTrack.track.source._codec);
-            output.addVideoTrack(videoSource, videoTrack.track.metadata);
-          }
-          if (audioTrack) {
-            audioSource = new EncodedAudioPacketSource(audioTrack.track.source._codec);
-            output.addAudioTrack(audioSource, audioTrack.track.metadata);
-          }
-          await output.start();
           if (videoTrack) {
             assert(videoSource);
             const meta = { decoderConfig: videoTrack.info.decoderConfig };
@@ -35557,9 +36083,26 @@ ${cue.notes ?? ""}`;
               maxEndTimestamp = Math.max(maxEndTimestamp, packet.timestamp + packet.duration);
             }
           }
-          await output.finalize();
+          if (playlist.singleFile?.fragmentedIsobmffOutput) {
+            const muxer = playlist.singleFile.fragmentedIsobmffOutput.output._muxer;
+            await muxer.forceFragmentFinalization();
+            if (playlist.singleFile.fragmentedIsobmffOutput.firstMoofPosition !== null && !playlist.initSegment) {
+              playlist.initSegment = {
+                path: playlist.singleFile.path,
+                duration: 0,
+                timestamp: 0,
+                byteSize: playlist.singleFile.fragmentedIsobmffOutput.firstMoofPosition,
+                byteOffset: 0,
+                info: null
+              };
+              playlist.singleFile.nextOffset = playlist.singleFile.fragmentedIsobmffOutput.firstMoofPosition;
+            }
+            segmentSize = playlist.singleFile.fragmentedIsobmffOutput.currentFileSize - playlist.singleFile.nextOffset;
+          } else {
+            await output.finalize();
+          }
         } catch (e) {
-          await output.cancel();
+          await output?.cancel();
           throw e;
         }
         if (segmentInfo) {
@@ -35617,8 +36160,12 @@ ${cue.notes ?? ""}`;
       assert(!playlist.done);
       playlist.done = true;
       if (playlist.singleFile) {
-        await playlist.singleFile.target._flush();
-        await playlist.singleFile.target._finalize();
+        if (playlist.singleFile.fragmentedIsobmffOutput) {
+          await playlist.singleFile.fragmentedIsobmffOutput.output.finalize();
+        } else {
+          await playlist.singleFile.target._flush();
+          await playlist.singleFile.target._finalize();
+        }
         this.format._options.onSegment?.(playlist.singleFile.target, playlist.singleFile.info);
       }
       await this.writePlaylist(playlist);
@@ -35938,6 +36485,10 @@ ${cue.notes ?? ""}`;
     _codecUnsupportedHint(codec) {
       return "";
     }
+    /** @internal */
+    _isFragmentedIsobmff() {
+      return false;
+    }
   };
   var IsobmffOutputFormat2 = class extends OutputFormat {
     /** Internal constructor. */
@@ -35979,7 +36530,7 @@ ${cue.notes ?? ""}`;
         video: { min: 0, max },
         audio: { min: 0, max },
         subtitle: { min: 0, max },
-        total: { min: 1, max }
+        total: { min: 0, max }
       };
     }
     get supportsVideoRotationMetadata() {
@@ -35992,6 +36543,10 @@ ${cue.notes ?? ""}`;
     _createMuxer(output) {
       return new IsobmffMuxer2(output, this);
     }
+    /** @internal */
+    _isFragmentedIsobmff() {
+      return this._options.fastStart === "fragmented";
+    }
   };
   var Mp4OutputFormat = class extends IsobmffOutputFormat2 {
     /** Creates a new {@link Mp4OutputFormat} configured with the specified `options`. */
@@ -36135,7 +36690,7 @@ ${cue.notes ?? ""}`;
         video: { min: 0, max },
         audio: { min: 0, max },
         subtitle: { min: 0, max },
-        total: { min: 1, max }
+        total: { min: 0, max }
       };
     }
     get fileExtension() {
@@ -36319,7 +36874,7 @@ ${cue.notes ?? ""}`;
         video: { min: 0, max: 0 },
         audio: { min: 0, max },
         subtitle: { min: 0, max: 0 },
-        total: { min: 1, max }
+        total: { min: 0, max }
       };
     }
     get fileExtension() {
@@ -36456,7 +37011,7 @@ ${cue.notes ?? ""}`;
         video: { min: 0, max: maxVideo },
         audio: { min: 0, max: maxAudio },
         subtitle: { min: 0, max: 0 },
-        total: { min: 1, max: maxTotal }
+        total: { min: 0, max: maxTotal }
       };
     }
     get fileExtension() {
@@ -36561,7 +37116,7 @@ ${cue.notes ?? ""}`;
         audio: { min: 0, max: supportsAudio ? Infinity : 0 },
         subtitle: { min: 0, max: 0 },
         // Currently disabled
-        total: { min: 1, max: Infinity }
+        total: { min: 0, max: Infinity }
       };
     }
     get supportsVideoRotationMetadata() {
@@ -36892,6 +37447,17 @@ ${cue.notes ?? ""}`;
           `Invalid video frame rate: ${metadata.frameRate}. Must be a positive number.`
         );
       }
+      if (metadata.decoderConfig !== void 0) {
+        validateVideoChunkMetadata({ decoderConfig: metadata.decoderConfig }, source._codec);
+      }
+      if (metadata.primingPacket !== void 0) {
+        if (!(metadata.primingPacket instanceof EncodedPacket)) {
+          throw new TypeError("metadata.primingPacket, when provided, must be an EncodedPacket.");
+        }
+        if (metadata.decoderConfig === void 0) {
+          throw new TypeError("metadata.primingPacket can only be provided alongside metadata.decoderConfig.");
+        }
+      }
       const metadataCopy = { ...metadata };
       metadataCopy.group ??= this.defaultTrackGroup;
       return this._addTrack(new OutputVideoTrack2(
@@ -36907,6 +37473,17 @@ ${cue.notes ?? ""}`;
         throw new TypeError("source must be an AudioSource.");
       }
       validateBaseTrackMetadata(metadata);
+      if (metadata.decoderConfig !== void 0) {
+        validateAudioChunkMetadata({ decoderConfig: metadata.decoderConfig }, source._codec);
+      }
+      if (metadata.primingPacket !== void 0) {
+        if (!(metadata.primingPacket instanceof EncodedPacket)) {
+          throw new TypeError("metadata.primingPacket, when provided, must be an EncodedPacket.");
+        }
+        if (metadata.decoderConfig === void 0) {
+          throw new TypeError("metadata.primingPacket can only be provided alongside metadata.decoderConfig.");
+        }
+      }
       const metadataCopy = { ...metadata };
       metadataCopy.group ??= this.defaultTrackGroup;
       return this._addTrack(new OutputAudioTrack2(
@@ -37597,7 +38174,7 @@ ${cue.notes ?? ""}`;
         this.output.setMetadataTags(outputTags);
       }
       if (!this._composable) {
-        this.isValid = this.output.hasEnoughTracks();
+        this.isValid = this.output.hasEnoughTracks() && this.output.tracks.length > 0;
       } else {
         this.isValid = true;
       }