mediabunny 1.50.9 → 1.52.0

package/dist/bundles/mediabunny.cjs

@@ -558,6 +558,9 @@ var Mediabunny = (() => {
   var clamp = (value, min, max) => {
     return Math.max(min, Math.min(max, value));
   };
+  var lerp = (from, to, t) => {
+    return from + (to - from) * t;
+  };
   var UNDETERMINED_LANGUAGE = "und";
   var roundIfAlmostInteger = (value) => {
     const rounded = Math.round(value);
@@ -16837,6 +16840,9 @@ var Mediabunny = (() => {
     }
     /** @internal */
     _dispose() {
+      for (const pendingSlice of this._pendingSlices) {
+        pendingSlice.reject(new InputDisposedError());
+      }
       this._pendingSlices.length = 0;
       this._cache.length = 0;
       void this._reader?.cancel();
@@ -17288,7 +17294,9 @@ var Mediabunny = (() => {
     }
     signalWorkerStoppedRunning(worker) {
       worker.running = false;
-      worker.pendingSlices.length = 0;
+      if (!worker.aborted) {
+        worker.pendingSlices.length = 0;
+      }
     }
     /** Called when a worker reaches the end of the underlying data and must be cleaned up. */
     onWorkerFinished(worker) {
@@ -17371,10 +17379,20 @@ var Mediabunny = (() => {
     }
     dispose() {
       for (const worker of this.workers) {
+        for (const slice of worker.pendingSlices) {
+          slice.reject(new InputDisposedError());
+        }
+        worker.pendingSlices.length = 0;
         worker.aborted = true;
       }
+      for (const queuedRead of this.queuedReads) {
+        for (const slice of queuedRead.pendingSlices) {
+          slice.reject(new InputDisposedError());
+        }
+      }
       this.workers.length = 0;
       this.cache.length = 0;
+      this.queuedReads.length = 0;
       this.disposed = true;
     }
   };
@@ -21343,8 +21361,18 @@ var Mediabunny = (() => {
     if (!VIDEO_CODECS.includes(config.codec)) {
       throw new TypeError(`Invalid video codec '${config.codec}'. Must be one of: ${VIDEO_CODECS.join(", ")}.`);
     }
-    if (!(config.bitrate instanceof Quality) && (!Number.isInteger(config.bitrate) || config.bitrate <= 0)) {
-      throw new TypeError("config.bitrate must be a positive integer or a quality.");
+    const bitrate = config.bitrate;
+    if (config.quality === void 0 && bitrate === void 0) {
+      throw new TypeError("config.quality must be provided.");
+    }
+    if (config.quality !== void 0 && bitrate !== void 0) {
+      throw new TypeError("config.quality and config.bitrate cannot both be provided.");
+    }
+    if (config.quality !== void 0 && !(config.quality instanceof Quality)) {
+      throw new TypeError("config.quality, when provided, must be a Quality.");
+    }
+    if (bitrate !== void 0 && !(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
+      throw new TypeError("config.bitrate, when provided, must be a positive integer or a quality.");
     }
     if (config.keyFrameInterval !== void 0 && (!Number.isFinite(config.keyFrameInterval) || config.keyFrameInterval < 0)) {
       throw new TypeError("config.keyFrameInterval, when provided, must be a non-negative number.");
@@ -21411,7 +21439,8 @@ var Mediabunny = (() => {
     if (options.alpha !== void 0 && !["discard", "keep"].includes(options.alpha)) {
       throw new TypeError("options.alpha, when provided, must be 'discard' or 'keep'.");
     }
-    if (options.bitrateMode !== void 0 && !["constant", "variable"].includes(options.bitrateMode)) {
+    const bitrateMode = options.bitrateMode;
+    if (bitrateMode !== void 0 && !["constant", "variable"].includes(bitrateMode)) {
       throw new TypeError("bitrateMode, when provided, must be 'constant' or 'variable'.");
     }
     if (options.latencyMode !== void 0 && !["quality", "realtime"].includes(options.latencyMode)) {
@@ -21437,22 +21466,28 @@ var Mediabunny = (() => {
       throw new TypeError("contentHint, when provided, must be a string.");
     }
   };
-  var buildVideoEncoderConfig = (options) => {
-    const resolvedBitrate = options.bitrate instanceof Quality ? options.bitrate._toVideoBitrate(options.codec, options.width, options.height) : options.bitrate;
-    return {
+  var buildVideoEncoderConfigs = (options) => {
+    const fallbackBitrateMode = options.bitrateMode;
+    const rateControl = options.quality._toVideoRateControl(
+      options.codec,
+      options.width,
+      options.height,
+      fallbackBitrateMode
+    );
+    const buildConfig = (bitrate, bitrateMode, bitrateEstimate) => ({
       codec: options.fullCodecString ?? buildVideoCodecString(
         options.codec,
         options.width,
         options.height,
-        resolvedBitrate,
+        bitrateEstimate,
         options.alpha === "keep"
       ),
       width: options.width,
       height: options.height,
       displayWidth: options.squarePixelWidth,
       displayHeight: options.squarePixelHeight,
-      bitrate: resolvedBitrate,
-      bitrateMode: options.bitrateMode,
+      bitrate,
+      bitrateMode,
       alpha: options.alpha ?? "discard",
       framerate: options.framerate,
       latencyMode: options.latencyMode,
@@ -21460,7 +21495,22 @@ var Mediabunny = (() => {
       scalabilityMode: options.scalabilityMode,
       contentHint: options.contentHint,
       ...getVideoEncoderConfigExtension(options.codec)
-    };
+    });
+    const candidates = [];
+    if (rateControl.quantizer !== null) {
+      candidates.push({
+        config: buildConfig(void 0, "quantizer", rateControl.bitrate),
+        quantizer: rateControl.quantizer
+      });
+    }
+    if (rateControl.bitrateMode !== "quantizer") {
+      candidates.push({
+        config: buildConfig(rateControl.bitrate, rateControl.bitrateMode, rateControl.bitrate),
+        quantizer: null
+      });
+    }
+    assert(candidates.length > 0);
+    return candidates;
   };
   var validateAudioEncodingConfig = (config) => {
     if (!config || typeof config !== "object") {
@@ -21469,10 +21519,17 @@ var Mediabunny = (() => {
     if (!AUDIO_CODECS.includes(config.codec)) {
       throw new TypeError(`Invalid audio codec '${config.codec}'. Must be one of: ${AUDIO_CODECS.join(", ")}.`);
     }
-    if (config.bitrate === void 0 && !(PCM_AUDIO_CODECS.includes(config.codec) || config.codec === "flac")) {
-      throw new TypeError("config.bitrate must be provided for compressed audio codecs.");
+    const bitrate = config.bitrate;
+    if (config.quality === void 0 && bitrate === void 0 && !(PCM_AUDIO_CODECS.includes(config.codec) || config.codec === "flac")) {
+      throw new TypeError("config.quality must be provided for compressed audio codecs.");
+    }
+    if (config.quality !== void 0 && bitrate !== void 0) {
+      throw new TypeError("config.quality and config.bitrate cannot both be provided.");
+    }
+    if (config.quality !== void 0 && !(config.quality instanceof Quality)) {
+      throw new TypeError("config.quality, when provided, must be a Quality.");
     }
-    if (config.bitrate !== void 0 && !(config.bitrate instanceof Quality) && (!Number.isInteger(config.bitrate) || config.bitrate <= 0)) {
+    if (bitrate !== void 0 && !(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
       throw new TypeError("config.bitrate, when provided, must be a positive integer or a quality.");
     }
     if (config.transform !== void 0) {
@@ -21507,7 +21564,8 @@ var Mediabunny = (() => {
     if (!options || typeof options !== "object") {
       throw new TypeError("Encoding options must be an object.");
     }
-    if (options.bitrateMode !== void 0 && !["constant", "variable"].includes(options.bitrateMode)) {
+    const bitrateMode = options.bitrateMode;
+    if (bitrateMode !== void 0 && !["constant", "variable"].includes(bitrateMode)) {
       throw new TypeError("bitrateMode, when provided, must be 'constant' or 'variable'.");
     }
     if (options.fullCodecString !== void 0 && typeof options.fullCodecString !== "string") {
@@ -21520,7 +21578,7 @@ var Mediabunny = (() => {
     }
   };
   var buildAudioEncoderConfig = (options) => {
-    const resolvedBitrate = options.bitrate instanceof Quality ? options.bitrate._toAudioBitrate(options.codec) : options.bitrate;
+    const fallbackBitrateMode = options.bitrateMode;
     return {
       codec: options.fullCodecString ?? buildAudioCodecString(
         options.codec,
@@ -21529,46 +21587,132 @@ var Mediabunny = (() => {
       ),
       numberOfChannels: options.numberOfChannels,
       sampleRate: options.sampleRate,
-      bitrate: resolvedBitrate,
-      bitrateMode: options.bitrateMode,
+      bitrate: options.quality?._toAudioBitrate(options.codec),
+      bitrateMode: options.quality?._bitrateMode ?? fallbackBitrateMode,
       ...getAudioEncoderConfigExtension(options.codec)
     };
   };
   var Quality = class {
-    /** @internal */
-    constructor(factor) {
-      this._factor = factor;
+    constructor(options) {
+      if (typeof options === "number" || typeof options === "string") {
+        options = { quality: options };
+      }
+      if (!options || typeof options !== "object") {
+        throw new TypeError("options must be an object.");
+      }
+      if (options.bitrateMode !== void 0 && !["constant", "variable"].includes(options.bitrateMode)) {
+        throw new TypeError("options.bitrateMode, when provided, must be 'constant' or 'variable'.");
+      }
+      if ("quality" in options) {
+        if (typeof options.quality === "string" ? !(options.quality in QUALITY_LEVELS) : typeof options.quality !== "number" || Number.isNaN(options.quality)) {
+          throw new TypeError(
+            "options.quality must be a number, or one of 'very-low', 'low', 'medium', 'high' or 'very-high'."
+          );
+        }
+        if (options.preferBitrate !== void 0 && typeof options.preferBitrate !== "boolean") {
+          throw new TypeError("options.preferBitrate, when provided, must be a boolean.");
+        }
+        if ("bitrate" in options || "quantizer" in options) {
+          throw new TypeError("options.quality cannot be combined with options.bitrate or options.quantizer.");
+        }
+        this._quality = typeof options.quality === "string" ? QUALITY_LEVELS[options.quality] : options.quality;
+        this._preferBitrate = options.preferBitrate ?? false;
+        this._bitrate = void 0;
+        this._quantizer = void 0;
+      } else {
+        if (options.bitrate !== void 0 && (!Number.isInteger(options.bitrate) || options.bitrate <= 0)) {
+          throw new TypeError("options.bitrate, when provided, must be a positive integer.");
+        }
+        if (options.quantizer !== void 0 && (!Number.isInteger(options.quantizer) || options.quantizer < 0)) {
+          throw new TypeError("options.quantizer, when provided, must be a non-negative integer.");
+        }
+        if (options.bitrate === void 0 && options.quantizer === void 0) {
+          throw new TypeError("At least one of options.bitrate or options.quantizer must be set.");
+        }
+        if ("preferBitrate" in options) {
+          throw new TypeError("options.preferBitrate can only be combined with options.quality.");
+        }
+        this._quality = void 0;
+        this._preferBitrate = false;
+        this._bitrate = options.bitrate;
+        this._quantizer = options.quantizer;
+      }
+      this._bitrateMode = options.bitrateMode;
+    }
+    /**
+     * Determines the rate control methods usable for the given codec.
+     * @internal
+     */
+    _toVideoRateControl(codec, width, height, fallbackBitrateMode) {
+      const quantizerSupport = VIDEO_CODEC_QUANTIZER_SUPPORT[codec];
+      let quantizer = null;
+      let bitrateMode = this._bitrateMode ?? fallbackBitrateMode ?? "variable";
+      if (this._quantizer !== void 0) {
+        if (!quantizerSupport) {
+          if (this._bitrate === void 0) {
+            throw new Error(
+              `Codec '${codec}' does not support quantizer-based encoding. Provide a bitrate in the Quality to define a fallback.`
+            );
+          }
+        } else if (this._quantizer < quantizerSupport.min || this._quantizer > quantizerSupport.max) {
+          if (this._bitrate === void 0) {
+            throw new Error(
+              `Quantizer ${this._quantizer} is out of range for codec '${codec}'; must be between ${quantizerSupport.min} and ${quantizerSupport.max}.`
+            );
+          }
+        } else {
+          quantizer = this._quantizer;
+          if (this._bitrate === void 0) {
+            bitrateMode = "quantizer";
+          }
+        }
+      } else if (this._bitrate === void 0 && quantizerSupport && !this._preferBitrate) {
+        assert(this._quality !== void 0);
+        quantizer = clamp(
+          Math.round(lerp(quantizerSupport.worst, quantizerSupport.best, this._quality)),
+          quantizerSupport.min,
+          quantizerSupport.max
+        );
+      }
+      let bitrate;
+      if (this._bitrate !== void 0) {
+        bitrate = this._bitrate;
+      } else {
+        let quality = this._quality;
+        if (quality === void 0) {
+          assert(quantizer !== null && quantizerSupport);
+          quality = clamp(
+            (quantizer - quantizerSupport.worst) / (quantizerSupport.best - quantizerSupport.worst),
+            0,
+            1
+          );
+        }
+        bitrate = computeVideoBitrate(codec, width, height, qualityToBitrateFactor(quality));
+      }
+      return { quantizer, bitrate, bitrateMode };
     }
     /** @internal */
     _toVideoBitrate(codec, width, height) {
-      const pixels = width * height;
-      const referencePixels = 1920 * 1080;
-      const referenceBitrate = 3e6;
-      const scaleFactor = Math.pow(pixels / referencePixels, 0.95);
-      const baseBitrate = referenceBitrate * scaleFactor;
-      const codecEfficiencyFactors = {
-        avc: 1,
-        // H.264/AVC (baseline)
-        hevc: 0.6,
-        // H.265/HEVC (~40% more efficient than AVC)
-        vp9: 0.6,
-        // Similar to HEVC
-        av1: 0.4,
-        // ~60% more efficient than AVC
-        vp8: 1.2,
-        // Slightly less efficient than AVC
-        prores: 22e7 / referenceBitrate
-        // Apple ProRes white paper claims 220 Mbps for 1080p 422 HQ @30Hz
-      };
-      const codecAdjustedBitrate = baseBitrate * codecEfficiencyFactors[codec];
-      const finalBitrate = codecAdjustedBitrate * this._factor;
-      return Math.ceil(finalBitrate / 1e3) * 1e3;
+      if (this._bitrate !== void 0) {
+        return this._bitrate;
+      }
+      assert(this._quality !== void 0);
+      return computeVideoBitrate(codec, width, height, qualityToBitrateFactor(this._quality));
     }
     /** @internal */
     _toAudioBitrate(codec) {
       if (PCM_AUDIO_CODECS.includes(codec) || codec === "flac") {
         return void 0;
       }
+      if (this._bitrate !== void 0) {
+        return this._bitrate;
+      }
+      if (this._quality === void 0) {
+        throw new Error(
+          "This Quality defines neither a quality level nor a bitrate and therefore cannot be used for audio encoding."
+        );
+      }
+      const factor = qualityToBitrateFactor(this._quality);
       const baseRates = {
         aac: 128e3,
         // 128kbps base for AAC
@@ -21587,7 +21731,7 @@ var Mediabunny = (() => {
       if (!baseBitrate) {
         throw new Error(`Unhandled codec: ${codec}`);
       }
-      let finalBitrate = baseBitrate * this._factor;
+      let finalBitrate = baseBitrate * factor;
       if (codec === "aac") {
         const validRates = [96e3, 128e3, 16e4, 192e3];
         finalBitrate = validRates.reduce(
@@ -21621,11 +21765,61 @@ var Mediabunny = (() => {
       return Math.round(finalBitrate / 1e3) * 1e3;
     }
   };
-  var QUALITY_VERY_LOW = /* @__PURE__ */ new Quality(0.3);
-  var QUALITY_LOW = /* @__PURE__ */ new Quality(0.6);
-  var QUALITY_MEDIUM = /* @__PURE__ */ new Quality(1);
-  var QUALITY_HIGH = /* @__PURE__ */ new Quality(2);
-  var QUALITY_VERY_HIGH = /* @__PURE__ */ new Quality(4);
+  var QUALITY_LEVELS = {
+    "very-low": 0,
+    "low": 0.25,
+    "medium": 0.5,
+    "high": 0.75,
+    "very-high": 1
+  };
+  var VIDEO_CODEC_QUANTIZER_SUPPORT = {
+    avc: { min: 0, max: 51, worst: 41, best: 16 },
+    hevc: { min: 0, max: 51, worst: 41, best: 16 },
+    vp9: { min: 0, max: 63, worst: 52, best: 20 },
+    av1: { min: 0, max: 255, worst: 208, best: 80 }
+  };
+  var qualityToBitrateFactor = (quality) => 0.3 * Math.exp(2.5538 * quality);
+  var computeVideoBitrate = (codec, width, height, factor) => {
+    const pixels = width * height;
+    const referencePixels = 1920 * 1080;
+    const referenceBitrate = 3e6;
+    const scaleFactor = Math.pow(pixels / referencePixels, 0.95);
+    const baseBitrate = referenceBitrate * scaleFactor;
+    const codecEfficiencyFactors = {
+      avc: 1,
+      // H.264/AVC (baseline)
+      hevc: 0.6,
+      // H.265/HEVC (~40% more efficient than AVC)
+      vp9: 0.6,
+      // Similar to HEVC
+      av1: 0.4,
+      // ~60% more efficient than AVC
+      vp8: 1.2,
+      // Slightly less efficient than AVC
+      prores: 22e7 / referenceBitrate
+      // Apple ProRes white paper claims 220 Mbps for 1080p 422 HQ @30Hz
+    };
+    const codecAdjustedBitrate = baseBitrate * codecEfficiencyFactors[codec];
+    const finalBitrate = codecAdjustedBitrate * factor;
+    return Math.ceil(finalBitrate / 1e3) * 1e3;
+  };
+  var buildQuantizerEncodeOptions = (codec, quantizer) => {
+    if (codec === "avc") {
+      return { avc: { quantizer } };
+    } else if (codec === "hevc") {
+      return { hevc: { quantizer } };
+    } else if (codec === "vp9") {
+      return { vp9: { quantizer } };
+    } else if (codec === "av1") {
+      return { av1: { quantizer } };
+    }
+    assert(false);
+  };
+  var QUALITY_VERY_LOW = /* @__PURE__ */ new Quality("very-low");
+  var QUALITY_LOW = /* @__PURE__ */ new Quality("low");
+  var QUALITY_MEDIUM = /* @__PURE__ */ new Quality("medium");
+  var QUALITY_HIGH = /* @__PURE__ */ new Quality("high");
+  var QUALITY_VERY_HIGH = /* @__PURE__ */ new Quality("very-high");
   var canEncode = (codec) => {
     if (VIDEO_CODECS.includes(codec)) {
       return canEncodeVideo(codec);
@@ -21640,7 +21834,9 @@ var Mediabunny = (() => {
     const {
       width = 1280,
       height = 720,
-      bitrate = 1e6,
+      quality,
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      bitrate,
       ...restOptions
     } = options;
     if (!VIDEO_CODECS.includes(codec)) {
@@ -21652,28 +21848,42 @@ var Mediabunny = (() => {
     if (!Number.isInteger(height) || height <= 0) {
       throw new TypeError("height must be a positive integer.");
     }
-    if (!(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
+    if (quality !== void 0 && !(quality instanceof Quality)) {
+      throw new TypeError("quality, when provided, must be a Quality.");
+    }
+    if (quality !== void 0 && bitrate !== void 0) {
+      throw new TypeError("quality and bitrate cannot both be provided.");
+    }
+    if (bitrate !== void 0 && !(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
       throw new TypeError("bitrate must be a positive integer or a quality.");
     }
     validateVideoEncodingAdditionalOptions(codec, restOptions);
-    const encoderConfig = buildVideoEncoderConfig({
-      codec,
-      width,
-      height,
-      bitrate,
-      framerate: void 0,
-      ...restOptions,
-      alpha: "discard"
-      // Since we handle alpha ourselves
-    });
-    const key = JSON.stringify(encoderConfig);
+    const resolvedQuality = resolveQuality(quality, bitrate) ?? new Quality({ bitrate: 1e6 });
+    let candidates;
+    try {
+      candidates = buildVideoEncoderConfigs({
+        codec,
+        width,
+        height,
+        quality: resolvedQuality,
+        framerate: void 0,
+        ...restOptions,
+        alpha: "discard"
+        // Since we handle alpha ourselves
+      });
+    } catch {
+      return false;
+    }
+    const key = JSON.stringify(candidates);
     const memoized = canEncodeVideoMemo.get(key);
     if (memoized) {
       return memoized;
     }
     const promise = (async () => {
-      if (customVideoEncoders.some((x) => x.supports(codec, encoderConfig))) {
-        return true;
+      for (const { config } of candidates) {
+        if (customVideoEncoders.some((x) => x.supports(codec, config))) {
+          return true;
+        }
       }
       if (typeof VideoEncoder === "undefined") {
         return false;
@@ -21682,19 +21892,22 @@ var Mediabunny = (() => {
       if (hasOddDimension && (codec === "avc" || codec === "hevc")) {
         return false;
       }
-      const support = await VideoEncoder.isConfigSupported(encoderConfig);
-      if (!support.supported) {
-        return false;
-      }
-      if (isFirefox()) {
-        return new Promise(async (resolve) => {
+      for (const { config, quantizer } of candidates) {
+        const support = await VideoEncoder.isConfigSupported(config);
+        if (!support.supported) {
+          continue;
+        }
+        if (!isFirefox()) {
+          return true;
+        }
+        const success = await new Promise(async (resolve) => {
           try {
             const encoder = new VideoEncoder({
               output: () => {
               },
               error: () => resolve(false)
             });
-            encoder.configure(encoderConfig);
+            encoder.configure(config);
             const frameData = new Uint8Array(width * height * 4);
             const frame = new VideoFrame(frameData, {
               format: "RGBA",
@@ -21702,7 +21915,10 @@ var Mediabunny = (() => {
               codedHeight: height,
               timestamp: 0
             });
-            encoder.encode(frame);
+            encoder.encode(
+              frame,
+              quantizer !== null ? buildQuantizerEncodeOptions(codec, quantizer) : void 0
+            );
             frame.close();
             await encoder.flush();
             resolve(true);
@@ -21710,8 +21926,11 @@ var Mediabunny = (() => {
             resolve(false);
           }
         });
+        if (success) {
+          return true;
+        }
       }
-      return true;
+      return false;
     })();
     canEncodeVideoMemo.set(key, promise);
     return promise;
@@ -21720,7 +21939,9 @@ var Mediabunny = (() => {
     const {
       numberOfChannels = 2,
       sampleRate = 48e3,
-      bitrate = 128e3,
+      quality,
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      bitrate,
       ...restOptions
     } = options;
     if (!AUDIO_CODECS.includes(codec)) {
@@ -21732,15 +21953,22 @@ var Mediabunny = (() => {
     if (!Number.isInteger(sampleRate) || sampleRate <= 0) {
       throw new TypeError("sampleRate must be a positive integer.");
     }
-    if (!(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
+    if (quality !== void 0 && !(quality instanceof Quality)) {
+      throw new TypeError("quality, when provided, must be a Quality.");
+    }
+    if (quality !== void 0 && bitrate !== void 0) {
+      throw new TypeError("quality and bitrate cannot both be provided.");
+    }
+    if (bitrate !== void 0 && !(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
       throw new TypeError("bitrate must be a positive integer.");
     }
     validateAudioEncodingAdditionalOptions(codec, restOptions);
+    const resolvedQuality = resolveQuality(quality, bitrate) ?? new Quality({ bitrate: 128e3 });
     const encoderConfig = buildAudioEncoderConfig({
       codec,
       numberOfChannels,
       sampleRate,
-      bitrate,
+      quality: resolvedQuality,
       ...restOptions
     });
     const key = JSON.stringify(encoderConfig);
@@ -21764,6 +21992,15 @@ var Mediabunny = (() => {
     canEncodeAudioMemo.set(key, promise);
     return promise;
   };
+  var resolveQuality = (quality, bitrate) => {
+    if (quality !== void 0) {
+      return quality;
+    }
+    if (bitrate === void 0) {
+      return void 0;
+    }
+    return bitrate instanceof Quality ? bitrate : new Quality({ bitrate });
+  };
   var canEncodeSubtitles = async (codec) => {
     if (!SUBTITLE_CODECS.includes(codec)) {
       return false;
@@ -22241,6 +22478,7 @@ var Mediabunny = (() => {
       let decoderIsFlushed = false;
       let ended = false;
       let terminated = false;
+      let decoder = null;
       let outOfBandError = null;
       let hasOutOfBandError = false;
       const packetRetrievalOptions = {
@@ -22249,7 +22487,7 @@ var Mediabunny = (() => {
         metadataOnly: false
       };
       (async () => {
-        const decoder = await this._createDecoder((sample) => {
+        decoder = await this._createDecoder((sample) => {
           onQueueDequeue();
           if (sample.timestamp >= endTimestamp) {
             ended = true;
@@ -22306,7 +22544,6 @@ var Mediabunny = (() => {
         if (!terminated && !this._track.input._disposed) {
           await decoder.flush();
         }
-        decoder.close();
         if (!firstSampleQueued && lastSample) {
           sampleQueue.push(lastSample);
         }
@@ -22318,6 +22555,8 @@ var Mediabunny = (() => {
           hasOutOfBandError = true;
           onQueueNotEmpty();
         }
+      }).finally(() => {
+        decoder?.close();
       });
       const track = this._track;
       const closeSamples = () => {
@@ -22374,6 +22613,7 @@ var Mediabunny = (() => {
       let { promise: queueDequeue, resolve: onQueueDequeue } = promiseWithResolvers();
       let decoderIsFlushed = false;
       let terminated = false;
+      let decoder = null;
       let outOfBandError = null;
       let hasOutOfBandError = false;
       const pushToQueue = (sample) => {
@@ -22387,7 +22627,7 @@ var Mediabunny = (() => {
         metadataOnly: false
       };
       (async () => {
-        const decoder = await this._createDecoder((sample) => {
+        decoder = await this._createDecoder((sample) => {
           onQueueDequeue();
           if (terminated) {
             sample.close();
@@ -22418,6 +22658,7 @@ var Mediabunny = (() => {
         let maxSequenceNumber = -1;
         const decodePackets = async () => {
           assert(lastKeyPacket);
+          assert(decoder);
           let currentPacket = lastKeyPacket;
           decoder.decode(currentPacket);
           while (currentPacket.sequenceNumber < maxSequenceNumber) {
@@ -22437,6 +22678,7 @@ var Mediabunny = (() => {
           maxSequenceNumber = -1;
         };
         const flushDecoder = async () => {
+          assert(decoder);
           await decoder.flush();
           for (let i = 0; i < timestampsOfInterest.length; i++) {
             pushToQueue(null);
@@ -22474,7 +22716,6 @@ var Mediabunny = (() => {
           }
           await flushDecoder();
         }
-        decoder.close();
         decoderIsFlushed = true;
         onQueueNotEmpty();
       })().catch((error) => {
@@ -22483,6 +22724,8 @@ var Mediabunny = (() => {
           hasOutOfBandError = true;
           onQueueNotEmpty();
         }
+      }).finally(() => {
+        decoder?.close();
       });
       const track = this._track;
       const closeSamples = () => {
@@ -27156,9 +27399,10 @@ var Mediabunny = (() => {
     // Reserved
     u16(1),
     // Frame count
-    Array(32).fill(0),
     // Compressor name
-    u16(24),
+    ascii("Mediabunny"),
+    Array(32 - "Mediabunny".length).fill(0),
+    u16(trackData.info.hasAlphaChannel ? 32 : 24),
     // Depth
     i16(65535)
     // Pre-defined
@@ -29000,7 +29244,7 @@ var Mediabunny = (() => {
         this.initWriter = initWriter;
         this.initBoxWriter = new IsobmffBoxWriter(initWriter);
       }
-      const holdsAvc = this.output._tracks.some((x) => x.isVideoTrack() && x.source._codec === "avc");
+      const holdsAvc = this.output.tracks.some((x) => x.isVideoTrack() && x.source._codec === "avc");
       {
         const boxWriter = this.initBoxWriter ?? this.boxWriter;
         assert(boxWriter);
@@ -29024,7 +29268,7 @@ var Mediabunny = (() => {
       }
       if (this.fastStart === "in-memory") {
       } else if (this.fastStart === "reserve") {
-        for (const track of this.output._tracks) {
+        for (const track of this.output.tracks) {
           if (track.metadata.maximumPacketCount === void 0) {
             throw new Error(
               "All tracks must specify maximumPacketCount in their metadata when using fastStart: 'reserve'."
@@ -29045,7 +29289,7 @@ var Mediabunny = (() => {
       release();
     }
     allTracksAreKnown() {
-      for (const track of this.output._tracks) {
+      for (const track of this.output.tracks) {
         if (!track.source._closed && !this.trackDatas.some((x) => x.track === track)) {
           return false;
         }
@@ -29114,6 +29358,7 @@ var Mediabunny = (() => {
         num: displayAspectWidth * decoderConfig.codedHeight,
         den: displayAspectHeight * decoderConfig.codedWidth
       });
+      const hasAlphaChannel = decoderConfig.codec === "ap4h" || decoderConfig.codec === "ap4x";
       const newTrackData = {
         muxer: this,
         track,
@@ -29123,7 +29368,8 @@ var Mediabunny = (() => {
           height: decoderConfig.codedHeight,
           pixelAspectRatio,
           decoderConfig,
-          requiresAnnexBTransformation
+          requiresAnnexBTransformation,
+          hasAlphaChannel
         },
         timescale,
         samples: [],
@@ -30439,7 +30685,7 @@ var Mediabunny = (() => {
       return this.ebmlWriter.dataOffsets.get(this.segment);
     }
     allTracksAreKnown() {
-      for (const track of this.output._tracks) {
+      for (const track of this.output.tracks) {
         if (!track.source._closed && !this.trackDatas.some((x) => x.track === track)) {
           return false;
         }
@@ -31288,7 +31534,7 @@ ${cue.notes ?? ""}`;
       throw new Error("Subtitle tracks are not supported.");
     }
     allTracksAreKnown() {
-      for (const track of this.output._tracks) {
+      for (const track of this.output.tracks) {
         if (!track.source._closed && !this.trackDatas.some((x) => x.track === track)) {
           return false;
         }
@@ -31743,7 +31989,7 @@ ${cue.notes ?? ""}`;
       return result;
     }
     allTracksAreKnown() {
-      for (const track of this.output._tracks) {
+      for (const track of this.output.tracks) {
         if (!track.source._closed && !this.trackDatas.some((x) => x.track === track)) {
           return false;
         }
@@ -32654,6 +32900,8 @@ ${cue.notes ?? ""}`;
       this.customEncoder = null;
       this.customEncoderCallSerializer = new CallSerializer();
       this.customEncoderQueueSize = 0;
+      // Set when the encoder uses quantizer-based rate control; carries the quantizer value applied to each frame
+      this.defaultEncodeOptions = {};
       // Alpha stuff
       this.alphaEncoder = null;
       this.splitter = null;
@@ -32783,18 +33031,36 @@ ${cue.notes ?? ""}`;
         if (!Array.isArray(processed)) {
           processed = [processed];
         }
-        samplesToEncode = processed.map((x) => {
-          if (x instanceof VideoSample) {
-            return x;
+        const mappedSamples = [];
+        try {
+          for (const x of processed) {
+            if (x instanceof VideoSample) {
+              mappedSamples.push(x);
+            } else if (typeof VideoFrame !== "undefined" && x instanceof VideoFrame) {
+              mappedSamples.push(new VideoSample(x));
+            } else {
+              mappedSamples.push(new VideoSample(x, {
+                timestamp: videoSample.timestamp,
+                duration: videoSample.duration
+              }));
+            }
           }
-          if (typeof VideoFrame !== "undefined" && x instanceof VideoFrame) {
-            return new VideoSample(x);
+        } catch (error) {
+          for (const sample of mappedSamples) {
+            if (sample !== videoSample) {
+              sample.close();
+            }
           }
-          return new VideoSample(x, {
-            timestamp: videoSample.timestamp,
-            duration: videoSample.duration
-          });
-        });
+          for (const x of processed) {
+            if (x instanceof VideoSample && x !== videoSample) {
+              x.close();
+            } else if (typeof VideoFrame !== "undefined" && x instanceof VideoFrame) {
+              x.close();
+            }
+          }
+          throw error;
+        }
+        samplesToEncode = mappedSamples;
       } else {
         samplesToEncode = [videoSample];
       }
@@ -32814,7 +33080,11 @@ ${cue.notes ?? ""}`;
           }
           const keyFrameInterval = this.encodingConfig.keyFrameInterval ?? 2;
           const multipleOfKeyFrameInterval = Math.floor(sampleToEncode.timestamp / keyFrameInterval);
-          const mergedEncodeOptions = { ...sampleToEncode.encodeOptions, ...encodeOptions };
+          const mergedEncodeOptions = {
+            ...this.defaultEncodeOptions,
+            ...sampleToEncode.encodeOptions,
+            ...encodeOptions
+          };
           const finalEncodeOptions = {
             ...mergedEncodeOptions,
             keyFrame: mergedEncodeOptions.keyFrame !== void 0 ? mergedEncodeOptions.keyFrame : keyFrameInterval === 0 || multipleOfKeyFrameInterval !== this.lastMultipleOfKeyFrameInterval
@@ -32860,22 +33130,31 @@ ${cue.notes ?? ""}`;
               }
             }
             if (!this.alphaEncoder) {
-              this.encoder.encode(videoFrame, finalEncodeOptions);
-              videoFrame.close();
+              try {
+                this.encoder.encode(videoFrame, finalEncodeOptions);
+              } finally {
+                videoFrame.close();
+              }
             } else {
               const frameDefinitelyHasNoAlpha = !!videoFrame.format && !videoFrame.format.includes("A");
               if (frameDefinitelyHasNoAlpha || this.splitterCreationFailed) {
                 this.alphaFrameQueue.push(null);
-                this.encoder.encode(videoFrame, finalEncodeOptions);
-                videoFrame.close();
+                try {
+                  this.encoder.encode(videoFrame, finalEncodeOptions);
+                } finally {
+                  videoFrame.close();
+                }
               } else {
                 if (!this.splitter) {
                   this.splitter = new ColorAlphaSplitter();
                 }
                 const { colorFrame, alphaFrame } = await this.splitter.split(videoFrame);
                 this.alphaFrameQueue.push(alphaFrame);
-                this.encoder.encode(colorFrame, finalEncodeOptions);
-                colorFrame.close();
+                try {
+                  this.encoder.encode(colorFrame, finalEncodeOptions);
+                } finally {
+                  colorFrame.close();
+                }
               }
             }
             if (this.encoder.encodeQueueSize >= 4) {
@@ -32900,28 +33179,83 @@ ${cue.notes ?? ""}`;
       assert(this.frameRateLastSample);
       const frameDifference = Math.round((until - this.frameRateLastTimestamp) * frameRate);
       for (let i = 1; i < frameDifference; i++) {
-        const sample = this.frameRateLastSample.clone();
-        sample.setTimestamp(this.frameRateLastTimestamp + i / frameRate);
-        sample.setDuration(1 / frameRate);
-        await this.processAndEncode(sample, encodeOptions);
-        sample.close();
+        var _stack = [];
+        try {
+          const sample = __using(_stack, this.frameRateLastSample.clone());
+          sample.setTimestamp(this.frameRateLastTimestamp + i / frameRate);
+          sample.setDuration(1 / frameRate);
+          await this.processAndEncode(sample, encodeOptions);
+        } catch (_) {
+          var _error = _, _hasError = true;
+        } finally {
+          __callDispose(_stack, _error, _hasError);
+        }
       }
     }
     ensureEncoder(videoSample) {
       this.ensureEncoderPromise = (async () => {
-        const encoderConfig = buildVideoEncoderConfig({
+        const quality = resolveQuality(this.encodingConfig.quality, this.encodingConfig.bitrate);
+        assert(quality !== void 0);
+        const candidates = buildVideoEncoderConfigs({
           ...this.encodingConfig,
+          quality,
           width: videoSample.codedWidth,
           height: videoSample.codedHeight,
           squarePixelWidth: videoSample.squarePixelWidth,
           squarePixelHeight: videoSample.squarePixelHeight,
           framerate: this.source._connectedTrack?.metadata.frameRate
         });
-        this.encodingConfig.onEncoderConfig?.(encoderConfig);
-        const MatchingCustomEncoder = customVideoEncoders.find((x) => x.supports(
-          this.encodingConfig.codec,
-          encoderConfig
-        ));
+        let selected = null;
+        let MatchingCustomEncoder;
+        for (const candidate of candidates) {
+          const candidateConfig = candidate.config;
+          this.encodingConfig.onEncoderConfig?.(candidateConfig);
+          MatchingCustomEncoder = customVideoEncoders.find((x) => x.supports(
+            this.encodingConfig.codec,
+            candidateConfig
+          ));
+          if (MatchingCustomEncoder) {
+            selected = candidate;
+            break;
+          }
+          if (typeof VideoEncoder === "undefined") {
+            continue;
+          }
+          candidateConfig.alpha = "discard";
+          if (this.encodingConfig.alpha === "keep") {
+            candidateConfig.latencyMode = "quality";
+          }
+          const hasOddDimension = candidateConfig.width % 2 === 1 || candidateConfig.height % 2 === 1;
+          if (hasOddDimension && (this.encodingConfig.codec === "avc" || this.encodingConfig.codec === "hevc")) {
+            throw new Error(
+              `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;
+          }
+        }
+        if (!selected) {
+          if (typeof VideoEncoder === "undefined") {
+            throw new Error("VideoEncoder is not supported by this browser.");
+          }
+          const firstConfig = candidates[0].config;
+          const rateControls = candidates.map(
+            ({ config, quantizer }) => quantizer !== null ? `quantizer ${quantizer}` : `${config.bitrate} bps`
+          );
+          throw new Error(
+            `This specific encoder configuration (${firstConfig.codec}, ${rateControls.join(" / ")}, ${firstConfig.width}x${firstConfig.height}, hardware acceleration: ${firstConfig.hardwareAcceleration ?? "no-preference"}) is not supported by this browser. Consider using another codec or changing your video parameters.`
+          );
+        }
+        const encoderConfig = selected.config;
+        if (selected.quantizer !== null) {
+          this.defaultEncodeOptions = buildQuantizerEncodeOptions(
+            this.encodingConfig.codec,
+            selected.quantizer
+          );
+        }
         if (MatchingCustomEncoder) {
           this.customEncoder = new MatchingCustomEncoder();
           this.customEncoder.codec = this.encodingConfig.codec;
@@ -32944,25 +33278,6 @@ ${cue.notes ?? ""}`;
           };
           await this.customEncoder.init();
         } else {
-          if (typeof VideoEncoder === "undefined") {
-            throw new Error("VideoEncoder is not supported by this browser.");
-          }
-          encoderConfig.alpha = "discard";
-          if (this.encodingConfig.alpha === "keep") {
-            encoderConfig.latencyMode = "quality";
-          }
-          const hasOddDimension = encoderConfig.width % 2 === 1 || encoderConfig.height % 2 === 1;
-          if (hasOddDimension && (this.encodingConfig.codec === "avc" || this.encodingConfig.codec === "hevc")) {
-            throw new Error(
-              `The dimensions ${encoderConfig.width}x${encoderConfig.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(encoderConfig);
-          if (!support.supported) {
-            throw new Error(
-              `This specific encoder configuration (${encoderConfig.codec}, ${encoderConfig.bitrate} bps, ${encoderConfig.width}x${encoderConfig.height}, hardware acceleration: ${encoderConfig.hardwareAcceleration ?? "no-preference"}) is not supported by this browser. Consider using another codec or changing your video parameters.`
-            );
-          }
           const colorChunkQueue = [];
           const nullAlphaChunkQueue = [];
           let encodedAlphaChunkCount = 0;
@@ -33014,6 +33329,7 @@ ${cue.notes ?? ""}`;
               assert(alphaFrame !== void 0);
               if (alphaFrame) {
                 this.alphaEncoder.encode(alphaFrame, {
+                  ...this.defaultEncodeOptions,
                   // Crucial: The alpha frame is forced to be a key frame whenever the color frame
                   // also is. Without this, playback can glitch and even crash in some browsers.
                   // This is the reason why the two encoders are wired in series and not in parallel.
@@ -33069,36 +33385,42 @@ ${cue.notes ?? ""}`;
       })();
     }
     async flushAndClose(forceClose) {
-      if (!forceClose) {
-        this.checkForEncoderError();
-      }
-      if (!forceClose && this.frameRateLastSample) {
-        const frameRate = this.encodingConfig.transform.frameRate;
-        const alignedEnd = floorToDivisor(this.frameRateLastEndTimestamp, frameRate);
-        await this.padFrameRate(alignedEnd);
-      }
-      this.closed = true;
-      this.frameRateLastSample?.close();
-      this.frameRateLastSample = null;
-      if (this.customEncoder) {
+      try {
         if (!forceClose) {
-          void this.customEncoderCallSerializer.call(() => this.customEncoder.flush());
+          this.checkForEncoderError();
+          if (this.frameRateLastSample) {
+            const frameRate = this.encodingConfig.transform.frameRate;
+            const alignedEnd = floorToDivisor(this.frameRateLastEndTimestamp, frameRate);
+            await this.padFrameRate(alignedEnd);
+          }
         }
-        await this.customEncoderCallSerializer.call(() => this.customEncoder.close());
-      } else if (this.encoder) {
+        this.closed = true;
         if (!forceClose) {
-          await this.encoder.flush();
-          await this.alphaEncoder?.flush();
-          await wait(25);
-        }
-        if (this.encoder.state !== "closed") {
-          this.encoder.close();
+          if (this.customEncoder) {
+            void this.customEncoderCallSerializer.call(() => this.customEncoder.flush());
+          } else if (this.encoder) {
+            await this.encoder.flush();
+            await this.alphaEncoder?.flush();
+            await wait(25);
+          }
         }
-        if (this.alphaEncoder && this.alphaEncoder.state !== "closed") {
-          this.alphaEncoder.close();
+      } finally {
+        this.closed = true;
+        this.frameRateLastSample?.close();
+        this.frameRateLastSample = null;
+        if (this.customEncoder) {
+          await this.customEncoderCallSerializer.call(() => this.customEncoder.close()).catch((error) => this.setError(error));
+        } else if (this.encoder) {
+          if (this.encoder.state !== "closed") {
+            this.encoder.close();
+          }
+          if (this.alphaEncoder && this.alphaEncoder.state !== "closed") {
+            this.alphaEncoder.close();
+          }
+          this.alphaFrameQueue.forEach((x) => x?.close());
+          this.alphaFrameQueue.length = 0;
+          this.splitter?.close();
         }
-        this.alphaFrameQueue.forEach((x) => x?.close());
-        this.splitter?.close();
       }
       if (!forceClose) {
         this.checkForEncoderError();
@@ -33762,26 +34084,39 @@ ${cue.notes ?? ""}`;
         shouldClose = true;
       }
       if (config.transform?.process) {
-        let processed = config.transform.process(audioSample);
-        if (processed instanceof Promise) {
-          processed = await processed;
-        }
-        if (processed === null) {
-          return;
-        }
-        if (!Array.isArray(processed)) {
-          processed = [processed];
-        }
-        for (const sample of processed) {
-          if (!(sample instanceof AudioSample)) {
-            throw new TypeError(
-              "The audio process function must return an AudioSample, null, or an array of AudioSamples."
-            );
+        try {
+          let processed = config.transform.process(audioSample);
+          if (processed instanceof Promise) {
+            processed = await processed;
+          }
+          if (processed === null) {
+            return;
+          }
+          if (!Array.isArray(processed)) {
+            processed = [processed];
+          }
+          try {
+            for (const sample of processed) {
+              if (!(sample instanceof AudioSample)) {
+                throw new TypeError(
+                  "The audio process function must return an AudioSample, null, or an array of AudioSamples."
+                );
+              }
+            }
+            for (const sample of processed) {
+              await this.encodeSample(sample, true);
+            }
+          } finally {
+            for (const sample of processed) {
+              if (sample instanceof AudioSample) {
+                sample.close();
+              }
+            }
+          }
+        } finally {
+          if (shouldClose) {
+            audioSample.close();
           }
-          await this.encodeSample(sample, true);
-        }
-        if (shouldClose) {
-          audioSample.close();
         }
       } else {
         await this.encodeSample(audioSample, shouldClose);
@@ -33917,10 +34252,12 @@ ${cue.notes ?? ""}`;
     ensureEncoder(audioSample) {
       this.ensureEncoderPromise = (async () => {
         const { numberOfChannels, sampleRate } = audioSample;
+        const quality = resolveQuality(this.encodingConfig.quality, this.encodingConfig.bitrate);
         const encoderConfig = buildAudioEncoderConfig({
           numberOfChannels,
           sampleRate,
-          ...this.encodingConfig
+          ...this.encodingConfig,
+          quality
         });
         this.encodingConfig.onEncoderConfig?.(encoderConfig);
         const MatchingCustomEncoder = customAudioEncoders.find((x) => x.supports(
@@ -34099,24 +34436,27 @@ ${cue.notes ?? ""}`;
       }
     }
     async flushAndClose(forceClose) {
-      if (!forceClose) {
-        this.checkForEncoderError();
-      }
-      if (!forceClose && this.resampler) {
-        await this.resampler.finalize();
-      }
-      this.resampler = null;
-      this.closed = true;
-      if (this.customEncoder) {
+      try {
         if (!forceClose) {
-          void this.customEncoderCallSerializer.call(() => this.customEncoder.flush());
+          this.checkForEncoderError();
+          if (this.resampler) {
+            await this.resampler.finalize();
+          }
         }
-        await this.customEncoderCallSerializer.call(() => this.customEncoder.close());
-      } else if (this.encoder) {
+        this.closed = true;
         if (!forceClose) {
-          await this.encoder.flush();
+          if (this.customEncoder) {
+            void this.customEncoderCallSerializer.call(() => this.customEncoder.flush());
+          } else if (this.encoder) {
+            await this.encoder.flush();
+          }
         }
-        if (this.encoder.state !== "closed") {
+      } finally {
+        this.closed = true;
+        this.resampler = null;
+        if (this.customEncoder) {
+          await this.customEncoderCallSerializer.call(() => this.customEncoder.close()).catch((error) => this.setError(error));
+        } else if (this.encoder && this.encoder.state !== "closed") {
           this.encoder.close();
         }
       }
@@ -34567,8 +34907,8 @@ ${cue.notes ?? ""}`;
     }
     async start() {
       const release = await this.mutex.acquire();
-      const someRelative = this.output._tracks.some((t) => t.metadata.isRelativeToUnixEpoch);
-      const someNotRelative = this.output._tracks.some((t) => !t.metadata.isRelativeToUnixEpoch);
+      const someRelative = this.output.tracks.some((t) => t.metadata.isRelativeToUnixEpoch);
+      const someNotRelative = this.output.tracks.some((t) => !t.metadata.isRelativeToUnixEpoch);
       if (someRelative && someNotRelative) {
         throw new Error(
           "All tracks must agree on `relativeToUnixEpoch`: some tracks are relative to the Unix epoch and some are not."
@@ -34580,12 +34920,12 @@ ${cue.notes ?? ""}`;
       let hasVideo = false;
       let illegalPairingDetected = false;
       let keyPacketsOnlyPairingWarned = false;
-      for (const track of this.output._tracks) {
+      for (const track of this.output.tracks) {
         if (track.type === "video") {
           hasVideo = true;
         }
         const pairableGroups = /* @__PURE__ */ new Map();
-        for (const otherTrack of this.output._tracks) {
+        for (const otherTrack of this.output.tracks) {
           if (track === otherTrack) {
             continue;
           }
@@ -34639,7 +34979,7 @@ ${cue.notes ?? ""}`;
       const variantStreams = [];
       const unpairedVideoTracks = [];
       const unpairedAudioTracks = [];
-      for (const track of this.output._tracks) {
+      for (const track of this.output.tracks) {
         const assignedGroupKeys = groupAssignment.get(track);
         if (assignedGroupKeys) {
           assert(assignedGroupKeys.length > 0);
@@ -36361,6 +36701,10 @@ ${cue.notes ?? ""}`;
        * {@link BaseTrackMetadata.group}.
        */
       this.defaultTrackGroup = new OutputTrackGroup();
+      /**
+       * The tracks that have been added to this output. Treat it as a readonly field; to add tracks, use the methods.
+       */
+      this.tracks = [];
       /** @internal */
       this._onFinalize = null;
       /** @internal */
@@ -36368,8 +36712,6 @@ ${cue.notes ?? ""}`;
       /** @internal */
       this._rootWriterPromise = null;
       /** @internal */
-      this._tracks = [];
-      /** @internal */
       this._startPromise = null;
       /** @internal */
       this._cancelPromise = null;
@@ -36549,7 +36891,7 @@ ${cue.notes ?? ""}`;
       const metadataCopy = { ...metadata };
       metadataCopy.group ??= this.defaultTrackGroup;
       return this._addTrack(new OutputVideoTrack2(
-        this._tracks.length + 1,
+        this.tracks.length + 1,
         this,
         source,
         metadataCopy
@@ -36564,7 +36906,7 @@ ${cue.notes ?? ""}`;
       const metadataCopy = { ...metadata };
       metadataCopy.group ??= this.defaultTrackGroup;
       return this._addTrack(new OutputAudioTrack2(
-        this._tracks.length + 1,
+        this.tracks.length + 1,
         this,
         source,
         metadataCopy
@@ -36579,7 +36921,7 @@ ${cue.notes ?? ""}`;
       const metadataCopy = { ...metadata };
       metadataCopy.group ??= this.defaultTrackGroup;
       return this._addTrack(new OutputSubtitleTrack2(
-        this._tracks.length + 1,
+        this.tracks.length + 1,
         this,
         source,
         metadataCopy
@@ -36607,7 +36949,7 @@ ${cue.notes ?? ""}`;
         throw new Error("Source is already used for a track.");
       }
       const supportedTrackCounts = this.format.getSupportedTrackCounts();
-      const presentTracksOfThisType = this._tracks.reduce(
+      const presentTracksOfThisType = this.tracks.reduce(
         (count, t) => count + (t.type === track.type ? 1 : 0),
         0
       );
@@ -36618,7 +36960,7 @@ ${cue.notes ?? ""}`;
         );
       }
       const maxTotalCount = supportedTrackCounts.total.max;
-      if (this._tracks.length === maxTotalCount) {
+      if (this.tracks.length === maxTotalCount) {
         throw new Error(
           `${this.format._name} does not support more than ${maxTotalCount} tracks${maxTotalCount === 1 ? "" : "s"} in total.`
         );
@@ -36657,10 +36999,32 @@ ${cue.notes ?? ""}`;
           );
         }
       }
-      this._tracks.push(track);
+      this.tracks.push(track);
       track.source._connectedTrack = track;
       return track;
     }
+    /**
+     * Whether the output has enough tracks (of the correct type) to be started, based on the requirements of the output
+     * format.
+     */
+    hasEnoughTracks() {
+      const supportedTrackCounts = this.format.getSupportedTrackCounts();
+      for (const trackType of ALL_TRACK_TYPES) {
+        const presentTracksOfThisType = this.tracks.reduce(
+          (count, track) => count + (track.type === trackType ? 1 : 0),
+          0
+        );
+        const minCount = supportedTrackCounts[trackType].min;
+        if (presentTracksOfThisType < minCount) {
+          return false;
+        }
+      }
+      const totalMinCount = supportedTrackCounts.total.min;
+      if (this.tracks.length < totalMinCount) {
+        return false;
+      }
+      return true;
+    }
     /**
      * Starts the creation of the output file. This method should be called after all tracks have been added. Only after
      * the output has started can media samples be added to the tracks.
@@ -36670,7 +37034,7 @@ ${cue.notes ?? ""}`;
     async start() {
       const supportedTrackCounts = this.format.getSupportedTrackCounts();
       for (const trackType of ALL_TRACK_TYPES) {
-        const presentTracksOfThisType = this._tracks.reduce(
+        const presentTracksOfThisType = this.tracks.reduce(
           (count, track) => count + (track.type === trackType ? 1 : 0),
           0
         );
@@ -36682,7 +37046,7 @@ ${cue.notes ?? ""}`;
         }
       }
       const totalMinCount = supportedTrackCounts.total.min;
-      if (this._tracks.length < totalMinCount) {
+      if (this.tracks.length < totalMinCount) {
         throw new Error(
           totalMinCount === supportedTrackCounts.total.max ? `${this.format._name} requires exactly ${totalMinCount} track${totalMinCount === 1 ? "" : "s"}.` : `${this.format._name} requires at least ${totalMinCount} track${totalMinCount === 1 ? "" : "s"}.`
         );
@@ -36699,7 +37063,7 @@ ${cue.notes ?? ""}`;
         const release = await this._mutex.acquire();
         try {
           await this._muxer.start();
-          const promises = this._tracks.map((track) => track.source._start());
+          const promises = this.tracks.map((track) => track.source._start());
           await Promise.all(promises);
         } finally {
           release();
@@ -36734,7 +37098,7 @@ ${cue.notes ?? ""}`;
         this.state = "canceled";
         const release = await this._mutex.acquire();
         try {
-          const promises = this._tracks.map((x) => x.source._flushOrWaitForOngoingClose(true));
+          const promises = this.tracks.map((x) => x.source._flushOrWaitForOngoingClose(true));
           await Promise.all(promises);
           await Promise.all([...this._unfinalizedTargets].map((target) => target._close()));
           this._unfinalizedTargets.clear();
@@ -36762,7 +37126,7 @@ ${cue.notes ?? ""}`;
         this.state = "finalizing";
         const release = await this._mutex.acquire();
         try {
-          const promises = this._tracks.map((x) => x.source._flushOrWaitForOngoingClose(false));
+          const promises = this.tracks.map((x) => x.source._flushOrWaitForOngoingClose(false));
           await Promise.all(promises);
           await this._muxer.finalize();
           if (this._rootWriterPromise) {
@@ -36777,6 +37141,9 @@ ${cue.notes ?? ""}`;
           }
           this.state = "finalized";
         } finally {
+          await Promise.all([...this._unfinalizedTargets].map((target) => target._close().catch(() => {
+          })));
+          this._unfinalizedTargets.clear();
           release();
         }
       })();
@@ -36799,7 +37166,14 @@ ${cue.notes ?? ""}`;
         `options.video.codec, when provided, must be one of: ${VIDEO_CODECS.join(", ")}.`
       );
     }
-    if (videoOptions?.bitrate !== void 0 && !(videoOptions.bitrate instanceof Quality) && (!Number.isInteger(videoOptions.bitrate) || videoOptions.bitrate <= 0)) {
+    const bitrate = videoOptions?.bitrate;
+    if (videoOptions?.quality !== void 0 && !(videoOptions.quality instanceof Quality)) {
+      throw new TypeError("options.video.quality, when provided, must be a Quality.");
+    }
+    if (videoOptions?.quality !== void 0 && bitrate !== void 0) {
+      throw new TypeError("options.video.quality and options.video.bitrate cannot both be provided.");
+    }
+    if (bitrate !== void 0 && !(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
       throw new TypeError("options.video.bitrate, when provided, must be a positive integer or a quality.");
     }
     if (videoOptions?.width !== void 0 && (!Number.isInteger(videoOptions.width) || videoOptions.width <= 0)) {
@@ -36869,7 +37243,14 @@ ${cue.notes ?? ""}`;
         `options.audio.codec, when provided, must be one of: ${AUDIO_CODECS.join(", ")}.`
       );
     }
-    if (audioOptions?.bitrate !== void 0 && !(audioOptions.bitrate instanceof Quality) && (!Number.isInteger(audioOptions.bitrate) || audioOptions.bitrate <= 0)) {
+    const bitrate = audioOptions?.bitrate;
+    if (audioOptions?.quality !== void 0 && !(audioOptions.quality instanceof Quality)) {
+      throw new TypeError("options.audio.quality, when provided, must be a Quality.");
+    }
+    if (audioOptions?.quality !== void 0 && bitrate !== void 0) {
+      throw new TypeError("options.audio.quality and options.audio.bitrate cannot both be provided.");
+    }
+    if (bitrate !== void 0 && !(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
       throw new TypeError("options.audio.bitrate, when provided, must be a positive integer or a quality.");
     }
     if (audioOptions?.numberOfChannels !== void 0 && (!Number.isInteger(audioOptions.numberOfChannels) || audioOptions.numberOfChannels <= 0)) {
@@ -36901,14 +37282,15 @@ ${cue.notes ?? ""}`;
   var Conversion = class _Conversion {
     /** Creates a new Conversion instance (duh). */
     constructor(options) {
-      /** @internal */
-      this._addedCounts = {
-        video: 0,
-        audio: 0,
-        subtitle: 0
-      };
-      /** @internal */
-      this._totalTrackCount = 0;
+      /**
+       * The current state of the conversion.
+       *
+       * - `'idle'`: The conversion is not currently executing and isn't done; `execute` can be called.
+       * - `'executing'`: A call to `execute` is currently running.
+       * - `'canceled'`: The conversion has been canceled and can no longer be executed.
+       * - `'done'`: The conversion has run to completion. Subsequent calls to `execute` do nothing.
+       */
+      this.state = "idle";
       /** @internal */
       this._nextOutputTrackId = 0;
       /** @internal */
@@ -36916,18 +37298,22 @@ ${cue.notes ?? ""}`;
       /** @internal */
       this._outputOwnTrackGroups = [];
       /** @internal */
-      this._trackPromises = [];
+      this._trackPumps = [];
+      /** @internal */
+      this._composable = false;
       /** @internal */
       this._executed = false;
       /** @internal */
-      this._synchronizer = new TrackSynchronizer();
+      this._executionUntil = Infinity;
+      /** @internal */
+      this._pauseRequested = false;
+      /** @internal */
+      this._synchronizer = new TrackSynchronizer(this);
       /** @internal */
       this._totalDuration = null;
       /** @internal */
       this._maxTimestamps = /* @__PURE__ */ new Map();
       // Track ID -> timestamp
-      /** @internal */
-      this._canceled = false;
       /**
        * A callback that is fired whenever the conversion progresses. Gets passed as first argument a number between
        * 0 and 1, indicating the completion of the conversion. Note that a progress of 1 doesn't necessarily mean the
@@ -36944,7 +37330,8 @@ ${cue.notes ?? ""}`;
       this._lastProgress = 0;
       /**
        * Whether this conversion, as it has been configured, is valid and can be executed. If this field is `false`, check
-       * the `discardedTracks` field for reasons.
+       * the `discardedTracks` field for reasons. Composable conversions are always valid, even if they utilize
+       * zero tracks.
        *
        * Note: a conversion having discarded tracks does not automatically mean it is invalid; if the remaining, utilized
        * tracks make for a valid output file, the conversion is still allowed.
@@ -36971,8 +37358,23 @@ ${cue.notes ?? ""}`;
           "options.tracks, when provided, must be either 'all' or 'primary'."
         );
       }
-      if (options.output._tracks.length > 0 || Object.keys(options.output._metadataTags).length > 0 || options.output.state !== "pending") {
-        throw new TypeError("options.output must be fresh: no tracks or metadata tags added and not started.");
+      if (options.composable !== void 0 && typeof options.composable !== "boolean") {
+        throw new TypeError("options.composable, when provided, must be a boolean.");
+      }
+      const composable = options.composable ?? false;
+      if (!composable) {
+        if (options.output.tracks.length > 0 || Object.keys(options.output._metadataTags).length > 0 || options.output.state !== "pending") {
+          throw new TypeError("options.output must be fresh: no tracks or metadata tags added and not started.");
+        }
+      } else {
+        if (options.tags !== void 0) {
+          throw new TypeError(
+            "options.tags cannot be set by a composable conversion; set metadata directly on the output instead."
+          );
+        }
+        if (options.output.state !== "pending") {
+          throw new TypeError("options.output must not have been started yet.");
+        }
       }
       if (options.video !== void 0 && typeof options.video !== "function") {
         if (Array.isArray(options.video)) {
@@ -37016,11 +37418,9 @@ ${cue.notes ?? ""}`;
         throw new TypeError("options.showWarnings, when provided, must be a boolean.");
       }
       this._options = options;
+      this._composable = composable;
       this.input = options.input;
       this.output = options.output;
-      const { promise: started, resolve: start } = promiseWithResolvers();
-      this._started = started;
-      this._start = start;
     }
     /** Initializes a new conversion process without starting the conversion. */
     static async init(options) {
@@ -37132,7 +37532,7 @@ ${cue.notes ?? ""}`;
         const track = filteredTracks[i];
         const options = filteredTrackOptions[i];
         for (const option of options) {
-          if (this._totalTrackCount === outputTrackCounts.total.max) {
+          if (this.output.tracks.length === outputTrackCounts.total.max) {
             this.discardedTracks.push({
               track,
               reason: "max_track_count_reached",
@@ -37140,7 +37540,11 @@ ${cue.notes ?? ""}`;
             });
             continue;
           }
-          if (this._addedCounts[track.type] === outputTrackCounts[track.type].max) {
+          const addedCountOfType = this.output.tracks.reduce(
+            (count, t) => count + (t.type === track.type ? 1 : 0),
+            0
+          );
+          if (addedCountOfType === outputTrackCounts[track.type].max) {
             this.discardedTracks.push({
               track,
               reason: "max_track_count_of_type_reached",
@@ -37171,22 +37575,28 @@ ${cue.notes ?? ""}`;
           }
         }
       }
-      const inputTags = await this.input.getMetadataTags();
-      let outputTags;
-      if (this._options.tags) {
-        const result = typeof this._options.tags === "function" ? await this._options.tags(inputTags) : this._options.tags;
-        validateMetadataTags(result);
-        outputTags = result;
-      } else {
-        outputTags = inputTags;
+      if (!this._composable) {
+        const inputTags = await this.input.getMetadataTags();
+        let outputTags;
+        if (this._options.tags) {
+          const result = typeof this._options.tags === "function" ? await this._options.tags(inputTags) : this._options.tags;
+          validateMetadataTags(result);
+          outputTags = result;
+        } else {
+          outputTags = inputTags;
+        }
+        const inputAndOutputFormatMatch = inputFormat.mimeType === this.output.format.mimeType;
+        const rawTagsAreUnchanged = inputTags.raw === outputTags.raw;
+        if (inputTags.raw && rawTagsAreUnchanged && !inputAndOutputFormatMatch) {
+          delete outputTags.raw;
+        }
+        this.output.setMetadataTags(outputTags);
       }
-      const inputAndOutputFormatMatch = inputFormat.mimeType === this.output.format.mimeType;
-      const rawTagsAreUnchanged = inputTags.raw === outputTags.raw;
-      if (inputTags.raw && rawTagsAreUnchanged && !inputAndOutputFormatMatch) {
-        delete outputTags.raw;
+      if (!this._composable) {
+        this.isValid = this.output.hasEnoughTracks();
+      } else {
+        this.isValid = true;
       }
-      this.output.setMetadataTags(outputTags);
-      this.isValid = this._totalTrackCount >= outputTrackCounts.total.min && this._addedCounts.video >= outputTrackCounts.video.min && this._addedCounts.audio >= outputTrackCounts.audio.min && this._addedCounts.subtitle >= outputTrackCounts.subtitle.min;
       if (this._options.showWarnings ?? true) {
         const warnElements = [];
         const unintentionallyDiscardedTracks = this.discardedTracks.filter((x) => x.reason !== "discarded_by_user");
@@ -37224,24 +37634,26 @@ ${cue.notes ?? ""}`;
         if (encodabilityIsTheProblem) {
           const codecs = this.discardedTracks.flatMap((x) => {
             if (x.reason === "discarded_by_user") return [];
+            let supportedCodecs;
             if (x.track.type === "video") {
-              return this.output.format.getSupportedVideoCodecs();
+              supportedCodecs = this.output.format.getSupportedVideoCodecs();
             } else if (x.track.type === "audio") {
-              return this.output.format.getSupportedAudioCodecs();
+              supportedCodecs = this.output.format.getSupportedAudioCodecs();
             } else {
-              return this.output.format.getSupportedSubtitleCodecs();
+              supportedCodecs = this.output.format.getSupportedSubtitleCodecs();
             }
+            return supportedCodecs.filter((codec) => !x.trackOptions.codec || codec === x.trackOptions.codec);
           });
           const uniqueCodecs = [...new Set(codecs)];
           if (uniqueCodecs.length === 1) {
             elements.push(
               `
-Tracks were discarded because your environment is not able to encode '${uniqueCodecs[0]}'.`
+Tracks were discarded because your environment is not able to encode '${uniqueCodecs[0]}' with the provided parameters.`
             );
           } else {
             elements.push(
               `
-Tracks were discarded because your environment is not able to encode any of the following codecs: ${uniqueCodecs.map((x) => `'${x}'`).join(", ")}.`
+Tracks were discarded because your environment is not able to encode any of the codecs ${uniqueCodecs.map((x) => `'${x}'`).join(", ")} with the provided parameters.`
             );
           }
           if (uniqueCodecs.includes("mp3")) {
@@ -37272,59 +37684,116 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       return elements;
     }
     /**
-     * Executes the conversion process. Resolves once conversion is complete.
+     * Executes the conversion process and resolves when the conversion is complete. When
+     * {@link ConversionExecuteOptions.until} is provided, the conversion will be suspended once that output timestamp
+     * is reached and can be resumed with another call to `execute`. An ongoing execution may also be suspended via
+     * {@link ConversionExecuteOptions.pauseSignal}.
      *
-     * Will throw if `isValid` is `false`.
+     * Execution will throw if `isValid` is `false`.
      */
-    async execute() {
+    async execute(options = {}) {
+      if (!options || typeof options !== "object") {
+        throw new TypeError("options must be an object.");
+      }
+      if (options.until !== void 0 && (typeof options.until !== "number" || Number.isNaN(options.until))) {
+        throw new TypeError("options.until, when provided, must be a number.");
+      }
+      if (options.pauseSignal !== void 0 && !(options.pauseSignal instanceof AbortSignal)) {
+        throw new TypeError("options.pauseSignal, when provided, must be an AbortSignal.");
+      }
       if (!this.isValid) {
         throw new Error(
           "Cannot execute this conversion because its output configuration is invalid. Make sure to always check the isValid field before executing a conversion.\n" + this._getInvalidityExplanation().join("")
         );
       }
-      if (this._executed) {
-        throw new Error("Conversion cannot be executed twice.");
+      if (this.state === "executing") {
+        throw new Error("Cannot call execute() while a previous call to execute() is still running.");
+      }
+      if (this.state === "canceled") {
+        throw new ConversionCanceledError();
       }
-      this._executed = true;
-      for (const id of this._outputTrackIds) {
-        this._synchronizer.declareTrack(id);
+      if (this.state === "done") {
+        return;
       }
-      if (this.onProgress) {
-        const uniqueUtilizedTracks = new Set(this.utilizedTracks);
-        const durationPromises = [...uniqueUtilizedTracks].map(async (track) => {
-          if (await track.isLive()) {
-            return Infinity;
-          }
-          return await track.getDurationFromMetadata() ?? await track.computeDuration();
-        });
-        const duration = Math.max(0, ...await Promise.all(durationPromises));
-        this._computeProgress = true;
-        this._totalDuration = Math.min(
-          duration - this._startTimestamp,
-          this._endTimestamp - this._startTimestamp
+      if (this._composable && this.output.state === "pending") {
+        throw new Error(
+          "A composable conversion requires the output to be started. Call start() on the output before executing the conversion."
         );
+      }
+      this.state = "executing";
+      this._executionUntil = options.until ?? Infinity;
+      this._pauseRequested = options.pauseSignal?.aborted ?? false;
+      const onPause = () => {
+        if (this.state !== "executing") {
+          return;
+        }
+        this._pauseRequested = true;
+        this._synchronizer.resolveAll();
+      };
+      options.pauseSignal?.addEventListener("abort", onPause);
+      for (const pump of this._trackPumps) {
+        if (!pump.done) {
+          pump.resolvers = promiseWithResolvers();
+        }
+      }
+      if (!this._executed) {
+        this._executed = true;
         for (const id of this._outputTrackIds) {
-          this._maxTimestamps.set(id, 0);
+          this._synchronizer.declareTrack(id);
+        }
+        if (this.onProgress) {
+          const uniqueUtilizedTracks = new Set(this.utilizedTracks);
+          const durationPromises = [...uniqueUtilizedTracks].map(async (track) => {
+            if (await track.isLive()) {
+              return Infinity;
+            }
+            return await track.getDurationFromMetadata() ?? await track.computeDuration();
+          });
+          const duration = Math.max(0, ...await Promise.all(durationPromises));
+          this._computeProgress = true;
+          this._totalDuration = Math.min(
+            duration - this._startTimestamp,
+            this._endTimestamp - this._startTimestamp
+          );
+          for (const id of this._outputTrackIds) {
+            this._maxTimestamps.set(id, 0);
+          }
+          this.onProgress?.(0, 0);
+        }
+        if (!this._composable) {
+          await this.output.start();
+        }
+        for (const pump of this._trackPumps) {
+          pump.start();
+        }
+      } else {
+        for (const pump of this._trackPumps) {
+          pump.wake?.();
         }
-        this.onProgress?.(0, 0);
       }
-      await this.output.start();
-      this._start();
       try {
-        await Promise.all(this._trackPromises);
+        await Promise.all(this._trackPumps.map((x) => x.resolvers.promise));
       } catch (error) {
-        if (!this._canceled) {
+        if (this.state !== "canceled") {
           void this.cancel();
         }
         throw error;
+      } finally {
+        options.pauseSignal?.removeEventListener("abort", onPause);
       }
-      if (this._canceled) {
+      if (this.state === "canceled") {
         throw new ConversionCanceledError();
       }
-      await this.output.finalize();
-      if (this._computeProgress) {
-        const minTimestamp = Math.min(...this._maxTimestamps.values());
-        this.onProgress?.(1, minTimestamp);
+      const isDone = this._trackPumps.every((x) => x.done);
+      this.state = isDone ? "done" : "idle";
+      if (isDone) {
+        if (!this._composable) {
+          await this.output.finalize();
+        }
+        if (this._computeProgress) {
+          const minTimestamp = Math.min(...this._maxTimestamps.values());
+          this.onProgress?.(1, minTimestamp);
+        }
       }
     }
     /**
@@ -37332,15 +37801,21 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
      * Does nothing if the conversion is already complete.
      */
     async cancel() {
-      if (this.output.state === "finalizing" || this.output.state === "finalized") {
+      if (this.state === "done") {
         return;
       }
-      if (this._canceled) {
+      if (this.state === "canceled") {
         Logging._warn("Conversion already canceled.");
         return;
       }
-      this._canceled = true;
-      await this.output.cancel();
+      this.state = "canceled";
+      for (const pump of this._trackPumps) {
+        pump.wake?.();
+      }
+      this._synchronizer.resolveAll();
+      if (!this._composable) {
+        await this.output.cancel();
+      }
     }
     /** @internal */
     async _processVideoTrack(track, trackOptions, outputTrackId) {
@@ -37381,19 +37856,18 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       }
       const firstTimestamp = await track.getFirstTimestamp();
       let videoCodecs = this.output.format.getSupportedVideoCodecs();
-      const needsTranscode = !!trackOptions.forceTranscode || firstTimestamp < this._startTimestamp || !!trackOptions.frameRate || trackOptions.keyFrameInterval !== void 0 || trackOptions.process !== void 0 || trackOptions.bitrate !== void 0 || !videoCodecs.includes(sourceCodec) || trackOptions.codec && trackOptions.codec !== sourceCodec || width !== originalWidth || height !== originalHeight || totalRotation !== 0 && !canUseRotationMetadata || !!crop;
+      const needsTranscode = !!trackOptions.forceTranscode || firstTimestamp < this._startTimestamp || !!trackOptions.frameRate || trackOptions.keyFrameInterval !== void 0 || trackOptions.process !== void 0 || trackOptions.quality !== void 0 || trackOptions.bitrate !== void 0 || !videoCodecs.includes(sourceCodec) || trackOptions.codec && trackOptions.codec !== sourceCodec || width !== originalWidth || height !== originalHeight || totalRotation !== 0 && !canUseRotationMetadata || !!crop;
       const alpha = trackOptions.alpha ?? "discard";
       if (!needsTranscode) {
         const source = new EncodedVideoPacketSource(sourceCodec);
         videoSource = source;
-        this._trackPromises.push((async () => {
-          await this._started;
+        this._registerTrackPump(async (pump) => {
           const sink = new EncodedPacketSink(track);
           const decoderConfig = await track.getDecoderConfig();
           const meta = { decoderConfig: decoderConfig ?? void 0 };
           for await (const packet of sink.packets(void 0, void 0, { verifyKeyPackets: true })) {
-            if (this._canceled) {
-              return;
+            if (this.state === "canceled") {
+              break;
             }
             if (packet.timestamp >= this._endTimestamp) {
               break;
@@ -37408,10 +37882,11 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
             if (this._synchronizer.shouldWait(outputTrackId, modifiedPacket.timestamp)) {
               await this._synchronizer.wait(modifiedPacket.timestamp);
             }
+            await this._checkpoint(pump, modifiedPacket.timestamp);
           }
           source.close();
           this._synchronizer.closeTrack(outputTrackId);
-        })());
+        });
       } else {
         const canDecode2 = await track.canDecode();
         if (!canDecode2) {
@@ -37425,11 +37900,11 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         if (trackOptions.codec) {
           videoCodecs = videoCodecs.filter((codec) => codec === trackOptions.codec);
         }
-        const bitrate = trackOptions.bitrate ?? QUALITY_HIGH;
+        const quality = resolveQuality(trackOptions.quality, trackOptions.bitrate) ?? new Quality("high");
         const encodableCodec = await getFirstEncodableVideoCodec(videoCodecs, {
           width: trackOptions.process && trackOptions.processedWidth ? trackOptions.processedWidth : width,
           height: trackOptions.process && trackOptions.processedHeight ? trackOptions.processedHeight : height,
-          bitrate
+          quality
         });
         if (!encodableCodec) {
           this.discardedTracks.push({
@@ -37441,7 +37916,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         }
         const encodingConfig = {
           codec: encodableCodec,
-          bitrate,
+          quality,
           keyFrameInterval: trackOptions.keyFrameInterval,
           sizeChangeBehavior: trackOptions.fit ?? "passThrough",
           alpha,
@@ -37507,15 +37982,14 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         };
         const source = new VideoSampleSource(encodingConfig);
         videoSource = source;
-        this._trackPromises.push((async () => {
-          await this._started;
+        this._registerTrackPump(async (pump) => {
           const sink = new VideoSampleSink(track);
           for await (var _sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
             var _stack2 = [];
             try {
               const sample = __using(_stack2, _sample);
-              if (this._canceled) {
-                return;
+              if (this.state === "canceled") {
+                break;
               }
               const adjustedSampleTimestamp = Math.max(sample.timestamp - this._startTimestamp, 0);
               sample.setTimestamp(adjustedSampleTimestamp);
@@ -37526,6 +38000,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
                 if (this._synchronizer.shouldWait(outputTrackId, lastSampleTimestamp)) {
                   await this._synchronizer.wait(lastSampleTimestamp);
                 }
+                await this._checkpoint(pump, lastSampleTimestamp);
               }
             } catch (_2) {
               var _error2 = _2, _hasError2 = true;
@@ -37535,10 +38010,10 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
           }
           source.close();
           this._synchronizer.closeTrack(outputTrackId);
-        })());
+        });
       }
       let ownGroup = null;
-      if (!trackOptions.group) {
+      if (!trackOptions.group && !this._composable) {
         ownGroup = new OutputTrackGroup();
       }
       const videoTrackLanguageCode = await track.getLanguageCode();
@@ -37551,8 +38026,6 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         rotation: outputTrackRotation,
         group: ownGroup ?? trackOptions.group
       });
-      this._addedCounts.video++;
-      this._totalTrackCount++;
       this.utilizedTracks.push(track);
       this._outputTrackIds.push(outputTrackId);
       this._outputOwnTrackGroups.push(ownGroup);
@@ -37577,17 +38050,16 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       const needsTrimming = firstTimestamp < this._startTimestamp;
       let needsPadding = firstTimestamp > this._startTimestamp && !this.output.format.supportsTimestampedMediaData;
       let audioCodecs = this.output.format.getSupportedAudioCodecs();
-      if (!trackOptions.forceTranscode && !trackOptions.bitrate && numberOfChannels === originalNumberOfChannels && sampleRate === originalSampleRate && !needsTrimming && !needsPadding && audioCodecs.includes(sourceCodec) && (!trackOptions.codec || trackOptions.codec === sourceCodec) && !trackOptions.process && trackOptions.sampleFormat === void 0) {
+      if (!trackOptions.forceTranscode && !trackOptions.quality && !trackOptions.bitrate && numberOfChannels === originalNumberOfChannels && sampleRate === originalSampleRate && !needsTrimming && !needsPadding && audioCodecs.includes(sourceCodec) && (!trackOptions.codec || trackOptions.codec === sourceCodec) && !trackOptions.process && trackOptions.sampleFormat === void 0) {
         const source = new EncodedAudioPacketSource(sourceCodec);
         audioSource = source;
-        this._trackPromises.push((async () => {
-          await this._started;
+        this._registerTrackPump(async (pump) => {
           const sink = new EncodedPacketSink(track);
           const decoderConfig = await track.getDecoderConfig();
           const meta = { decoderConfig: decoderConfig ?? void 0 };
           for await (const packet of sink.packets()) {
-            if (this._canceled) {
-              return;
+            if (this.state === "canceled") {
+              break;
             }
             if (packet.timestamp >= this._endTimestamp) {
               break;
@@ -37601,10 +38073,11 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
             if (this._synchronizer.shouldWait(outputTrackId, modifiedPacket.timestamp)) {
               await this._synchronizer.wait(modifiedPacket.timestamp);
             }
+            await this._checkpoint(pump, modifiedPacket.timestamp);
           }
           source.close();
           this._synchronizer.closeTrack(outputTrackId);
-        })());
+        });
       } else {
         const canDecode2 = await track.canDecode();
         if (!canDecode2) {
@@ -37619,17 +38092,17 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         if (trackOptions.codec) {
           audioCodecs = audioCodecs.filter((codec) => codec === trackOptions.codec);
         }
-        const bitrate = trackOptions.bitrate ?? QUALITY_HIGH;
+        const quality = resolveQuality(trackOptions.quality, trackOptions.bitrate) ?? new Quality("high");
         const encodableCodecs = await getEncodableAudioCodecs(audioCodecs, {
           numberOfChannels: trackOptions.process && trackOptions.processedNumberOfChannels ? trackOptions.processedNumberOfChannels : numberOfChannels,
           sampleRate: trackOptions.process && trackOptions.processedSampleRate ? trackOptions.processedSampleRate : sampleRate,
-          bitrate
+          quality
         });
         if (!encodableCodecs.some((codec) => NON_PCM_AUDIO_CODECS.includes(codec)) && audioCodecs.some((codec) => NON_PCM_AUDIO_CODECS.includes(codec)) && (numberOfChannels !== FALLBACK_NUMBER_OF_CHANNELS || sampleRate !== FALLBACK_SAMPLE_RATE)) {
           const encodableCodecsWithDefaultParams = await getEncodableAudioCodecs(audioCodecs, {
             numberOfChannels: FALLBACK_NUMBER_OF_CHANNELS,
             sampleRate: FALLBACK_SAMPLE_RATE,
-            bitrate
+            quality
           });
           const nonPcmCodec = encodableCodecsWithDefaultParams.find((codec) => NON_PCM_AUDIO_CODECS.includes(codec));
           if (nonPcmCodec) {
@@ -37650,7 +38123,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         }
         const encodingConfig = {
           codec: codecOfChoice,
-          bitrate,
+          quality,
           transform: {
             sampleFormat: trackOptions.sampleFormat,
             process: trackOptions.process
@@ -37669,8 +38142,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         };
         const source = new AudioSampleSource(encodingConfig);
         audioSource = source;
-        this._trackPromises.push((async () => {
-          await this._started;
+        this._registerTrackPump(async (pump) => {
           const sink = new AudioSampleSink(track);
           for await (var _sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
             var _stack3 = [];
@@ -37678,8 +38150,8 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
               const sample = __using(_stack3, _sample);
               var _stack2 = [];
               try {
-                if (this._canceled) {
-                  return;
+                if (this.state === "canceled") {
+                  break;
                 }
                 if (needsPadding) {
                   var _stack = [];
@@ -37700,7 +38172,13 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
                       sampleRate: originalSampleRate,
                       timestamp: 0
                     }));
-                    await this._registerAudioSample(silentSample, source, outputTrackId, () => lastSampleTimestamp);
+                    await this._registerAudioSample(
+                      pump,
+                      silentSample,
+                      source,
+                      outputTrackId,
+                      () => lastSampleTimestamp
+                    );
                     needsPadding = false;
                   } catch (_) {
                     var _error = _, _hasError = true;
@@ -37730,7 +38208,13 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
                 }
                 const finalSample = __using(_stack2, finalSampleLet);
                 finalSample.setTimestamp(finalSample.timestamp - this._startTimestamp);
-                await this._registerAudioSample(finalSample, source, outputTrackId, () => lastSampleTimestamp);
+                await this._registerAudioSample(
+                  pump,
+                  finalSample,
+                  source,
+                  outputTrackId,
+                  () => lastSampleTimestamp
+                );
               } catch (_2) {
                 var _error2 = _2, _hasError2 = true;
               } finally {
@@ -37744,10 +38228,10 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
           }
           source.close();
           this._synchronizer.closeTrack(outputTrackId);
-        })());
+        });
       }
       let ownGroup = null;
-      if (!trackOptions.group) {
+      if (!trackOptions.group && !this._composable) {
         ownGroup = new OutputTrackGroup();
       }
       const audioTrackLanguageCode = await track.getLanguageCode();
@@ -37758,14 +38242,12 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         disposition: await track.getDisposition(),
         group: ownGroup ?? trackOptions.group
       });
-      this._addedCounts.audio++;
-      this._totalTrackCount++;
       this.utilizedTracks.push(track);
       this._outputTrackIds.push(outputTrackId);
       this._outputOwnTrackGroups.push(ownGroup);
     }
     /** @internal */
-    async _registerAudioSample(sample, source, outputTrackId, getLastSampleTimestamp) {
+    async _registerAudioSample(pump, sample, source, outputTrackId, getLastSampleTimestamp) {
       this._reportProgress(outputTrackId, sample.timestamp + sample.duration);
       await source.add(sample);
       sample.close();
@@ -37774,6 +38256,33 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         if (this._synchronizer.shouldWait(outputTrackId, lastSampleTimestamp)) {
           await this._synchronizer.wait(lastSampleTimestamp);
         }
+        await this._checkpoint(pump, lastSampleTimestamp);
+      }
+    }
+    /** @internal */
+    _registerTrackPump(fn) {
+      const pump = {
+        done: false,
+        resolvers: promiseWithResolvers(),
+        wake: null,
+        start: () => {
+          void fn(pump).then(() => {
+            pump.done = true;
+            pump.resolvers.resolve();
+          }, (error) => {
+            pump.resolvers.reject(error);
+          });
+        }
+      };
+      this._trackPumps.push(pump);
+    }
+    /** @internal */
+    async _checkpoint(pump, timestamp) {
+      while (this.state !== "canceled" && (timestamp >= this._executionUntil || this._pauseRequested)) {
+        pump.resolvers.resolve();
+        const { promise, resolve } = promiseWithResolvers();
+        pump.wake = resolve;
+        await promise;
       }
     }
     /** @internal */
@@ -37803,10 +38312,11 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
   };
   var MAX_TIMESTAMP_GAP = 1;
   var TrackSynchronizer = class {
-    constructor() {
+    constructor(conversion) {
       this.maxTimestamps = /* @__PURE__ */ new Map();
       // Track ID -> timestamp
       this.resolvers = [];
+      this.conversion = conversion;
     }
     declareTrack(trackId) {
       this.maxTimestamps.set(trackId, 0);
@@ -37816,6 +38326,9 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       assert(currentValue !== void 0);
       this.maxTimestamps.set(trackId, Math.max(timestamp, currentValue));
       const newMin = this.computeMinAndMaybeResolve();
+      if (this.conversion.state === "canceled" || this.conversion._pauseRequested || timestamp >= this.conversion._executionUntil) {
+        return false;
+      }
       return timestamp - newMin > MAX_TIMESTAMP_GAP;
     }
     wait(timestamp) {
@@ -37830,6 +38343,12 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       this.maxTimestamps.delete(trackId);
       this.computeMinAndMaybeResolve();
     }
+    resolveAll() {
+      for (const entry of this.resolvers) {
+        entry.resolve();
+      }
+      this.resolvers.length = 0;
+    }
     computeMinAndMaybeResolve() {
       let newMin = Infinity;
       for (const [, timestamp] of this.maxTimestamps) {