mediabunny 1.50.8 → 1.51.0

package/dist/bundles/mediabunny.cjs

@@ -4215,8 +4215,17 @@ var Mediabunny = (() => {
   ];
   var parseOpusTocByte = (packet) => {
     const config = packet[0] >> 3;
+    const code = packet[0] & 3;
+    let frameCount;
+    if (code === 0) {
+      frameCount = 1;
+    } else if (code === 1 || code === 2) {
+      frameCount = 2;
+    } else {
+      frameCount = packet[1] & 63;
+    }
     return {
-      durationInSamples: OPUS_FRAME_DURATION_TABLE[config]
+      durationInSamples: OPUS_FRAME_DURATION_TABLE[config] * frameCount
     };
   };
   var parseModesFromVorbisSetupPacket = (setupHeader) => {
@@ -12379,6 +12388,21 @@ var Mediabunny = (() => {
       if (formatTag === 7 /* MULAW */ || formatTag === 6 /* ALAW */) {
         bitsPerSample = 8;
       }
+      if (formatTag !== 1 /* PCM */ && formatTag !== 3 /* IEEE_FLOAT */ && formatTag !== 6 /* ALAW */ && formatTag !== 7 /* MULAW */) {
+        throw new Error(
+          `Unsupported WAVE codec (format tag ${formatTag}). Only integer/float PCM, A-law, and \u03BC-law are supported.`
+        );
+      }
+      if (formatTag === 1 /* PCM */ && ![8, 16, 24, 32].includes(bitsPerSample)) {
+        throw new Error(
+          `Unsupported WAVE PCM bit depth (${bitsPerSample}). Only 8, 16, 24, and 32 bits are supported.`
+        );
+      }
+      if (formatTag === 3 /* IEEE_FLOAT */ && ![32, 64].includes(bitsPerSample)) {
+        throw new Error(
+          `Unsupported WAVE float bit depth (${bitsPerSample}). Only 32 and 64 bits are supported.`
+        );
+      }
       this.audioInfo = {
         format: formatTag,
         numberOfChannels: numChannels,
@@ -12527,9 +12551,11 @@ var Mediabunny = (() => {
       if (this.audioInfo.format === 3 /* IEEE_FLOAT */) {
         if (this.audioInfo.sampleSizeInBytes === 4) {
           return "pcm-f32";
+        } else if (this.audioInfo.sampleSizeInBytes === 8) {
+          return "pcm-f64";
         }
       }
-      return null;
+      assert(false);
     }
     async getMimeType() {
       return "audio/wav";
@@ -28949,6 +28975,7 @@ var Mediabunny = (() => {
       this.isQuickTime = format instanceof MovOutputFormat;
       this.isCmaf = format instanceof CmafOutputFormat;
       this.minimumFragmentDuration = format._options.minimumFragmentDuration ?? (format instanceof CmafOutputFormat ? Infinity : 1);
+      this.auxWriter.start();
     }
     async start() {
       const release = await this.mutex.acquire();
@@ -28973,7 +29000,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);
@@ -28997,7 +29024,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'."
@@ -29018,7 +29045,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;
         }
@@ -30412,7 +30439,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;
         }
@@ -30750,7 +30777,8 @@ ${cue.notes ?? ""}`;
       view2.setUint8(0, 128 | trackData.track.id);
       view2.setInt16(1, relativeTimestamp, false);
       const msDuration = Math.round(1e3 * chunk.duration);
-      if (!chunk.additions) {
+      const needsBlockGroup = !!chunk.additions || trackData.type === "subtitle";
+      if (!needsBlockGroup) {
         view2.setUint8(3, Number(chunk.type === "key") << 7);
         const simpleBlock = { id: 163 /* SimpleBlock */, data: [
           prelude,
@@ -31260,7 +31288,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;
         }
@@ -31715,7 +31743,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;
         }
@@ -34539,8 +34567,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."
@@ -34552,12 +34580,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;
           }
@@ -34611,7 +34639,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);
@@ -35907,7 +35935,7 @@ ${cue.notes ?? ""}`;
     getSupportedCodecs() {
       return [
         ...PCM_AUDIO_CODECS.filter(
-          (codec) => ["pcm-s16", "pcm-s24", "pcm-s32", "pcm-f32", "pcm-u8", "ulaw", "alaw"].includes(codec)
+          (codec) => ["pcm-s16", "pcm-s24", "pcm-s32", "pcm-f32", "pcm-f64", "pcm-u8", "ulaw", "alaw"].includes(codec)
         )
       ];
     }
@@ -36333,6 +36361,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 */
@@ -36340,8 +36372,6 @@ ${cue.notes ?? ""}`;
       /** @internal */
       this._rootWriterPromise = null;
       /** @internal */
-      this._tracks = [];
-      /** @internal */
       this._startPromise = null;
       /** @internal */
       this._cancelPromise = null;
@@ -36521,7 +36551,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
@@ -36536,7 +36566,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
@@ -36551,7 +36581,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
@@ -36579,7 +36609,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
       );
@@ -36590,7 +36620,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.`
         );
@@ -36629,10 +36659,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.
@@ -36642,7 +36694,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
         );
@@ -36654,7 +36706,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"}.`
         );
@@ -36671,7 +36723,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();
@@ -36706,7 +36758,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();
@@ -36734,7 +36786,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) {
@@ -36873,14 +36925,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 */
@@ -36888,18 +36941,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
@@ -36916,7 +36973,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.
@@ -36943,8 +37001,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)) {
@@ -36988,11 +37061,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) {
@@ -37104,7 +37175,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",
@@ -37112,7 +37183,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",
@@ -37143,22 +37218,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");
@@ -37244,59 +37325,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.");
       }
-      this._executed = true;
-      for (const id of this._outputTrackIds) {
-        this._synchronizer.declareTrack(id);
+      if (this.state === "canceled") {
+        throw new ConversionCanceledError();
       }
-      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.state === "done") {
+        return;
+      }
+      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);
+        }
       }
     }
     /**
@@ -37304,15 +37442,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) {
@@ -37358,14 +37502,13 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       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;
@@ -37380,10 +37523,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) {
@@ -37423,32 +37567,39 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         assert(encodingConfig.transform);
         let needsRerender = width !== originalWidth || height !== originalHeight || totalRotation !== 0 && (!canUseRotationMetadata || trackOptions.process !== void 0) || !!crop || squarePixelWidth !== await track.getCodedWidth() || squarePixelHeight !== await track.getCodedHeight();
         if (!needsRerender) {
-          const tempOutput = new Output({
-            format: new Mp4OutputFormat(),
-            // Supports all video codecs
-            target: new NullTarget()
-          });
-          const tempSource = new VideoSampleSource(encodingConfig);
-          tempOutput.addVideoTrack(tempSource);
-          await tempOutput.start();
-          const sink = new VideoSampleSink(track);
-          const firstSample = await sink.getSample(firstTimestamp);
-          if (firstSample) {
-            try {
-              await tempSource.add(firstSample);
-              firstSample.close();
-              await tempOutput.finalize();
-            } catch (error) {
-              Logging._warn(
-                "An error occurred when probing encoder support. Falling back to rerender path.",
-                error
-              );
-              void tempOutput.cancel();
-              needsRerender = true;
-              encodingConfig.transform.force = true;
+          var _stack = [];
+          try {
+            const tempOutput = new Output({
+              format: new Mp4OutputFormat(),
+              // Supports all video codecs
+              target: new NullTarget()
+            });
+            const tempSource = new VideoSampleSource(encodingConfig);
+            tempOutput.addVideoTrack(tempSource);
+            await tempOutput.start();
+            const sink = new VideoSampleSink(track);
+            const firstSample = __using(_stack, await sink.getSample(firstTimestamp));
+            if (firstSample) {
+              try {
+                await tempSource.add(firstSample);
+                firstSample.close();
+                await tempOutput.finalize();
+              } catch (error) {
+                Logging._warn(
+                  "An error occurred when probing encoder support. Falling back to rerender path.",
+                  error
+                );
+                void tempOutput.cancel();
+                needsRerender = true;
+                encodingConfig.transform.force = true;
+              }
+            } else {
+              await tempOutput.cancel();
             }
-          } else {
-            await tempOutput.cancel();
+          } catch (_) {
+            var _error = _, _hasError = true;
+          } finally {
+            __callDispose(_stack, _error, _hasError);
           }
         }
         if (trackOptions.frameRate) {
@@ -37472,31 +37623,38 @@ 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 (const sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
-            if (this._canceled) {
+          for await (var _sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
+            var _stack2 = [];
+            try {
+              const sample = __using(_stack2, _sample);
+              if (this.state === "canceled") {
+                break;
+              }
+              const adjustedSampleTimestamp = Math.max(sample.timestamp - this._startTimestamp, 0);
+              sample.setTimestamp(adjustedSampleTimestamp);
+              this._reportProgress(outputTrackId, sample.timestamp + sample.duration);
+              await source.add(sample);
               sample.close();
-              return;
-            }
-            const adjustedSampleTimestamp = Math.max(sample.timestamp - this._startTimestamp, 0);
-            sample.setTimestamp(adjustedSampleTimestamp);
-            this._reportProgress(outputTrackId, sample.timestamp + sample.duration);
-            await source.add(sample);
-            if (lastSampleTimestamp !== null) {
-              if (this._synchronizer.shouldWait(outputTrackId, lastSampleTimestamp)) {
-                await this._synchronizer.wait(lastSampleTimestamp);
+              if (lastSampleTimestamp !== null) {
+                if (this._synchronizer.shouldWait(outputTrackId, lastSampleTimestamp)) {
+                  await this._synchronizer.wait(lastSampleTimestamp);
+                }
+                await this._checkpoint(pump, lastSampleTimestamp);
               }
+            } catch (_2) {
+              var _error2 = _2, _hasError2 = true;
+            } finally {
+              __callDispose(_stack2, _error2, _hasError2);
             }
-            sample.close();
           }
           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();
@@ -37509,8 +37667,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);
@@ -37538,14 +37694,13 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       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) {
         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;
@@ -37559,10 +37714,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) {
@@ -37627,60 +37783,96 @@ 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 (let sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
-            if (this._canceled) {
-              sample.close();
-              return;
-            }
-            if (needsPadding) {
-              const paddingLength = firstTimestamp - this._startTimestamp;
-              const paddingLengthSamples = Math.round(paddingLength * originalSampleRate);
-              const bytesPerSample = getBytesPerSample(sample.format);
-              const data = new Uint8Array(bytesPerSample * paddingLengthSamples * originalNumberOfChannels);
-              if (sample.format === "u8" || sample.format === "u8-planar") {
-                data.fill(2 ** 7);
-              }
-              const silentSample = new AudioSample({
-                data,
-                // Use the same format the decoder is spitting out. This avoids feeding changing sample
-                // formats to the audio encoder.
-                format: sample.format,
-                numberOfChannels: originalNumberOfChannels,
-                sampleRate: originalSampleRate,
-                timestamp: 0
-              });
-              await this._registerAudioSample(silentSample, source, outputTrackId, () => lastSampleTimestamp);
-              needsPadding = false;
-            }
-            let startFrame = 0;
-            let endFrame = sample.numberOfFrames;
-            if (sample.timestamp < this._startTimestamp) {
-              startFrame = Math.round((this._startTimestamp - sample.timestamp) * sample.sampleRate);
-            }
-            if (sample.timestamp + sample.duration > this._endTimestamp) {
-              endFrame = Math.round((this._endTimestamp - sample.timestamp) * sample.sampleRate);
-            }
-            if (startFrame > 0 || endFrame < sample.numberOfFrames) {
-              const trimmedSample = sample.trim(startFrame, endFrame);
-              sample.close();
-              sample = trimmedSample;
-              if (sample.numberOfFrames === 0) {
-                sample.close();
-                continue;
+          for await (var _sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
+            var _stack3 = [];
+            try {
+              const sample = __using(_stack3, _sample);
+              var _stack2 = [];
+              try {
+                if (this.state === "canceled") {
+                  break;
+                }
+                if (needsPadding) {
+                  var _stack = [];
+                  try {
+                    const paddingLength = firstTimestamp - this._startTimestamp;
+                    const paddingLengthSamples = Math.round(paddingLength * originalSampleRate);
+                    const bytesPerSample = getBytesPerSample(sample.format);
+                    const data = new Uint8Array(bytesPerSample * paddingLengthSamples * originalNumberOfChannels);
+                    if (sample.format === "u8" || sample.format === "u8-planar") {
+                      data.fill(2 ** 7);
+                    }
+                    const silentSample = __using(_stack, new AudioSample({
+                      data,
+                      // Use the same format the decoder is spitting out. This avoids feeding changing sample
+                      // formats to the audio encoder.
+                      format: sample.format,
+                      numberOfChannels: originalNumberOfChannels,
+                      sampleRate: originalSampleRate,
+                      timestamp: 0
+                    }));
+                    await this._registerAudioSample(
+                      pump,
+                      silentSample,
+                      source,
+                      outputTrackId,
+                      () => lastSampleTimestamp
+                    );
+                    needsPadding = false;
+                  } catch (_) {
+                    var _error = _, _hasError = true;
+                  } finally {
+                    __callDispose(_stack, _error, _hasError);
+                  }
+                }
+                let startFrame = 0;
+                let endFrame = sample.numberOfFrames;
+                if (sample.timestamp < this._startTimestamp) {
+                  startFrame = Math.round((this._startTimestamp - sample.timestamp) * sample.sampleRate);
+                }
+                if (sample.timestamp + sample.duration > this._endTimestamp) {
+                  endFrame = Math.round((this._endTimestamp - sample.timestamp) * sample.sampleRate);
+                }
+                let finalSampleLet;
+                if (startFrame > 0 || endFrame < sample.numberOfFrames) {
+                  const trimmedSample = sample.trim(startFrame, endFrame);
+                  sample.close();
+                  finalSampleLet = trimmedSample;
+                  if (trimmedSample.numberOfFrames === 0) {
+                    trimmedSample.close();
+                    continue;
+                  }
+                } else {
+                  finalSampleLet = sample;
+                }
+                const finalSample = __using(_stack2, finalSampleLet);
+                finalSample.setTimestamp(finalSample.timestamp - this._startTimestamp);
+                await this._registerAudioSample(
+                  pump,
+                  finalSample,
+                  source,
+                  outputTrackId,
+                  () => lastSampleTimestamp
+                );
+              } catch (_2) {
+                var _error2 = _2, _hasError2 = true;
+              } finally {
+                __callDispose(_stack2, _error2, _hasError2);
               }
+            } catch (_3) {
+              var _error3 = _3, _hasError3 = true;
+            } finally {
+              __callDispose(_stack3, _error3, _hasError3);
             }
-            sample.setTimestamp(sample.timestamp - this._startTimestamp);
-            await this._registerAudioSample(sample, source, outputTrackId, () => lastSampleTimestamp);
           }
           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();
@@ -37691,14 +37883,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();
@@ -37707,6 +37897,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 */
@@ -37736,10 +37953,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);
@@ -37749,6 +37967,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) {
@@ -37763,6 +37984,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) {