fix: AbortSignal now actually stops the running ffmpeg exec (#719)

Previously, aborting an exec() or ffprobe() only rejected the JS
Promise — the underlying WASM process kept running to completion.
This caused wasted CPU and made AbortController useless for long
transcoding operations.

Fix: when the abort signal fires for EXEC or FFPROBE, immediately
send a CANCEL message to the worker. The worker calls
ffmpeg.setTimeout(1), setting the WASM watchdog to fire after 1 ms.
This stops the running command as quickly as possible (exit code 1)
without terminating the entire worker — the FFmpeg instance stays
loaded and ready for the next command.

Also: fix a memory leak where Blob URLs created for coreData /
wasmData / workerData were never revoked. They are now tracked in
#blobURLs and revoked in terminate().

Changes:
- const.ts: add FFMessageType.CANCEL
- worker.ts: add cancel() handler calling ffmpeg.setTimeout(1)
- classes.ts: send CANCEL on exec/ffprobe abort; track blob URLs

Closes #719

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: JacobiusMakes

packages/ffmpeg/src/classes.ts

@@ -24,6 +24,9 @@ import { ERROR_TERMINATED, ERROR_NOT_LOADED } from "./errors.js";
 /**
  * Convert binary file data (ArrayBuffer, Uint8Array, or Blob) to a Blob URL
  * so the web worker can consume it as a regular URL string.
+ *
+ * The returned URL must eventually be passed to `URL.revokeObjectURL` to
+ * avoid a memory leak.  @see {@link FFmpeg.load} and {@link FFmpeg.terminate}.
  */
 const toBlobURL = (data: BinaryFileData, mimeType: string): string => {
   const blob =
@@ -55,6 +58,13 @@ export class FFmpeg {
   #logEventCallbacks: LogEventCallback[] = [];
   #progressEventCallbacks: ProgressEventCallback[] = [];
 
+  /**
+   * Blob URLs created during load() for coreData / wasmData / workerData.
+   * Tracked here so they can be revoked when the worker is terminated,
+   * preventing a memory leak.
+   */
+  #blobURLs: string[] = [];
+
   public loaded = false;
 
   /**
@@ -123,6 +133,20 @@ export class FFmpeg {
         "abort",
         () => {
           reject(new DOMException(`Message # ${id} was aborted`, "AbortError"));
+          // If we are aborting an exec or ffprobe, send a CANCEL message so
+          // the worker's ffmpeg timeout is set to 1 ms, causing the running
+          // command to stop as quickly as possible.  For other message types
+          // the cancel is a no-op on the worker side.
+          if (
+            (type === FFMessageType.EXEC ||
+              type === FFMessageType.FFPROBE) &&
+            this.#worker
+          ) {
+            this.#worker.postMessage({
+              id: getMessageID(),
+              type: FFMessageType.CANCEL,
+            });
+          }
         },
         { once: true }
       );
@@ -219,10 +243,19 @@ export class FFmpeg {
     }
     // Convert binary data to Blob URLs so the worker can load them as
     // regular URL strings. Binary data takes precedence over URL strings.
-    if (coreData) config.coreURL = toBlobURL(coreData, MIME_TYPE_JAVASCRIPT);
-    if (wasmData) config.wasmURL = toBlobURL(wasmData, MIME_TYPE_WASM);
-    if (workerData)
+    // The created URLs are stored in #blobURLs and revoked on terminate().
+    if (coreData) {
+      config.coreURL = toBlobURL(coreData, MIME_TYPE_JAVASCRIPT);
+      this.#blobURLs.push(config.coreURL);
+    }
+    if (wasmData) {
+      config.wasmURL = toBlobURL(wasmData, MIME_TYPE_WASM);
+      this.#blobURLs.push(config.wasmURL);
+    }
+    if (workerData) {
       config.workerURL = toBlobURL(workerData, MIME_TYPE_JAVASCRIPT);
+      this.#blobURLs.push(config.workerURL);
+    }
     return this.#send(
       {
         type: FFMessageType.LOAD,
@@ -329,6 +362,12 @@ export class FFmpeg {
       this.#worker = null;
       this.loaded = false;
     }
+
+    // Revoke any Blob URLs that were created during load() to free memory.
+    for (const url of this.#blobURLs) {
+      URL.revokeObjectURL(url);
+    }
+    this.#blobURLs = [];
   };
 
   /**

packages/ffmpeg/src/const.ts

@@ -17,6 +17,7 @@ export enum FFMessageType {
   DELETE_DIR = "DELETE_DIR",
   ERROR = "ERROR",
 
+  CANCEL = "CANCEL",
   DOWNLOAD = "DOWNLOAD",
   PROGRESS = "PROGRESS",
   LOG = "LOG",

packages/ffmpeg/src/worker.ts

@@ -108,6 +108,19 @@ const ffprobe = ({ args, timeout = -1 }: FFMessageExecData): ExitCode => {
   return ret;
 };
 
+/**
+ * Interrupt any running exec/ffprobe by setting the ffmpeg timeout to 1 ms.
+ * This causes the WASM-side watchdog to fire almost immediately, stopping
+ * the current command and returning exit-code 1 (timeout).  The exec()
+ * call on the main thread has already been rejected with an AbortError by
+ * the time this message arrives, so the exit-code reply is simply discarded.
+ */
+const cancel = (): void => {
+  if (ffmpeg) {
+    ffmpeg.setTimeout(1);
+  }
+};
+
 const writeFile = ({ path, data }: FFMessageWriteFileData): OK => {
   ffmpeg.FS.writeFile(path, data);
   return true;
@@ -181,6 +194,10 @@ self.onmessage = async ({
       case FFMessageType.FFPROBE:
         data = ffprobe(_data as FFMessageExecData);
         break;
+      case FFMessageType.CANCEL:
+        cancel();
+        // CANCEL is fire-and-forget: no reply needed.
+        return;
       case FFMessageType.WRITE_FILE:
         data = writeFile(_data as FFMessageWriteFileData);
         break;