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.

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,
stopping the current command as quickly as possible (exit code 1)
without terminating the entire worker.

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

Closes #719

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: JacobiusMakes

packages/ffmpeg/src/classes.ts

@@ -112,6 +112,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 }
       );

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;