mediabunny 1.50.9 → 1.51.0

package/dist/bundles/mediabunny.cjs

@@ -29000,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);
@@ -29024,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'."
@@ -29045,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;
         }
@@ -30439,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;
         }
@@ -31288,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;
         }
@@ -31743,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;
         }
@@ -34567,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."
@@ -34580,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;
           }
@@ -34639,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);
@@ -36361,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 */
@@ -36368,8 +36372,6 @@ ${cue.notes ?? ""}`;
       /** @internal */
       this._rootWriterPromise = null;
       /** @internal */
-      this._tracks = [];
-      /** @internal */
       this._startPromise = null;
       /** @internal */
       this._cancelPromise = null;
@@ -36549,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
@@ -36564,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
@@ -36579,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
@@ -36607,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
       );
@@ -36618,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.`
         );
@@ -36657,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.
@@ -36670,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
         );
@@ -36682,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"}.`
         );
@@ -36699,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();
@@ -36734,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();
@@ -36762,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) {
@@ -36901,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 */
@@ -36916,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
@@ -36944,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.
@@ -36971,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)) {
@@ -37016,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) {
@@ -37132,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",
@@ -37140,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",
@@ -37171,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");
@@ -37272,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);
+        }
       }
     }
     /**
@@ -37332,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) {
@@ -37386,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;
@@ -37408,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) {
@@ -37507,15 +37623,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 +37641,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 +37651,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 +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);
@@ -37580,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;
@@ -37601,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) {
@@ -37669,8 +37783,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 +37791,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 +37813,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 +37849,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 +37869,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 +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();
@@ -37774,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 */
@@ -37803,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);
@@ -37816,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) {
@@ -37830,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) {