mediabunny 1.24.2 → 1.24.3

package/dist/bundles/mediabunny.cjs

@@ -15072,10 +15072,16 @@ var Mediabunny = (() => {
             }
             break;
           }
+          if (worker.aborted) {
+            break;
+          }
           this.onread?.(worker.currentPos, worker.currentPos + value.length);
           this._orchestrator.supplyWorkerData(worker, value);
         } else {
           const data = await this._blob.slice(worker.currentPos, worker.targetPos).arrayBuffer();
+          if (worker.aborted) {
+            break;
+          }
           this.onread?.(worker.currentPos, worker.currentPos + data.byteLength);
           this._orchestrator.supplyWorkerData(worker, new Uint8Array(data));
         }
@@ -15189,7 +15195,7 @@ var Mediabunny = (() => {
     }
     /** @internal */
     async _runWorker(worker) {
-      while (!worker.aborted) {
+      while (true) {
         const existing = this._existingResponses.get(worker);
         this._existingResponses.delete(worker);
         let abortController = existing?.abortController;
@@ -15249,6 +15255,9 @@ var Mediabunny = (() => {
               throw error;
             }
           }
+          if (worker.aborted) {
+            break;
+          }
           const { done, value } = readResult;
           if (done) {
             this._orchestrator.forgetWorker(worker);
@@ -15263,6 +15272,9 @@ var Mediabunny = (() => {
           this.onread?.(worker.currentPos, worker.currentPos + value.length);
           this._orchestrator.supplyWorkerData(worker, value);
         }
+        if (worker.aborted) {
+          break;
+        }
       }
       worker.running = false;
     }
@@ -15401,6 +15413,9 @@ var Mediabunny = (() => {
         const originalTargetPos = worker.targetPos;
         let data = this._options.read(worker.currentPos, originalTargetPos);
         if (data instanceof Promise) data = await data;
+        if (worker.aborted) {
+          break;
+        }
         if (data instanceof Uint8Array) {
           data = toUint8Array(data);
           if (data.length !== originalTargetPos - worker.currentPos) {
@@ -15425,6 +15440,9 @@ var Mediabunny = (() => {
             if (!(value instanceof Uint8Array)) {
               throw new TypeError("ReadableStream returned by options.read must yield Uint8Array chunks.");
             }
+            if (worker.aborted) {
+              break;
+            }
             const data2 = toUint8Array(value);
             this.onread?.(worker.currentPos, worker.currentPos + data2.length);
             this._orchestrator.supplyWorkerData(worker, data2);
@@ -15797,7 +15815,10 @@ var Mediabunny = (() => {
         currentPos: startPos,
         targetPos,
         running: false,
-        aborted: false,
+        // Due to async shenanigans, it can happen that workers are started after disposal. In this case, instead of
+        // simply not creating the worker, we allow it to run but immediately label it as aborted, so it can then
+        // shut itself down.
+        aborted: this.disposed,
         pendingSlices: [],
         age: this.nextAge++
       };
@@ -15837,9 +15858,7 @@ var Mediabunny = (() => {
     }
     /** Called by a worker when it has read some data. */
     supplyWorkerData(worker, bytes2) {
-      if (this.disposed) {
-        return;
-      }
+      assert(!worker.aborted);
       const start = worker.currentPos;
       const end = start + bytes2.length;
       this.insertIntoCache({
@@ -22840,7 +22859,7 @@ ${cue.notes ?? ""}`;
             type: "videoTrack",
             trackId: this._workerTrackId,
             track: this._track
-          }, [this._track]);
+          });
           this._workerListener = (event) => {
             const message = event.data;
             if (message.type === "videoFrame" && message.trackId === this._workerTrackId) {
@@ -23443,16 +23462,17 @@ ${cue.notes ?? ""}`;
       supported: typeof MediaStreamTrackProcessor !== "undefined"
     });
     const abortControllers = /* @__PURE__ */ new Map();
-    const stoppedTracks = /* @__PURE__ */ new Set();
+    const activeTracks = /* @__PURE__ */ new Map();
     self.addEventListener("message", (event) => {
       const message = event.data;
       switch (message.type) {
         case "videoTrack":
           {
+            activeTracks.set(message.trackId, message.track);
             const processor = new MediaStreamTrackProcessor({ track: message.track });
             const consumer = new WritableStream({
               write: (videoFrame) => {
-                if (stoppedTracks.has(message.trackId)) {
+                if (!activeTracks.has(message.trackId)) {
                   videoFrame.close();
                   return;
                 }
@@ -23485,7 +23505,9 @@ ${cue.notes ?? ""}`;
               abortController.abort();
               abortControllers.delete(message.trackId);
             }
-            stoppedTracks.add(message.trackId);
+            const track = activeTracks.get(message.trackId);
+            track?.stop();
+            activeTracks.delete(message.trackId);
             sendMessage({
               type: "trackStopped",
               trackId: message.trackId