capacitor-native-video-compressor 1.0.4 → 1.0.5

package/README.md

@@ -124,6 +124,51 @@ try {
 listener.remove();
 ```
 
+### 3. Cancelling a Compression
+
+Compressing a long video runs for minutes, so give the user a way out. Pass a
+`jobId` when starting, then cancel with the same id:
+
+```typescript
+import { NativeVideoCompressor, CANCELLED } from 'capacitor-native-video-compressor';
+
+const jobId = crypto.randomUUID();
+
+try {
+  const result = await NativeVideoCompressor.compressVideo({
+    sourcePath: '/path/to/video.mp4',
+    quality: 'HIGH',
+    jobId,
+  });
+} catch (error) {
+  if (error.code === CANCELLED) {
+    // The user asked for this — no error toast, no retry prompt.
+    return;
+  }
+  throw error;
+}
+
+// From a Cancel button, anywhere:
+await NativeVideoCompressor.cancel({ jobId });
+```
+
+**Why `jobId`.** Every platform compresses one video at a time, so cancellation
+is global by nature. Two independent queues in the same app (say comments and
+notes) would otherwise cancel each other's work. `cancel()` with no `jobId`
+cancels whatever is running, whoever started it — fine when there is only one
+caller.
+
+**What it costs.** The partial output is deleted on every platform. On web,
+cancelling terminates the FFmpeg worker, because `ffmpeg.exec()` runs as
+synchronous WASM inside it and never reaches a message poll while encoding —
+the `AbortSignal` `exec()` accepts only rejects the main-thread promise while
+the encode keeps burning CPU behind it. The loaded core is dropped with the
+worker, but the core URLs are cached in module scope, so the next compress
+re-instantiates without re-downloading the wasm.
+
+`cancel()` resolves `{ cancelled: false }` when nothing was running, or when a
+different job was — it never throws.
+
 ### Quality Presets
 
 The `quality` parameter determines the output resolution and compression ratio. Depending on the original aspect ratio, the video will be scaled to match the following heights (or widths, preserving aspect ratio):
@@ -149,6 +194,7 @@ The `quality` parameter determines the output resolution and compression ratio.
 <docgen-index>
 
 * [`compressVideo(...)`](#compressvideo)
+* [`cancel(...)`](#cancel)
 * [`initialize()`](#initialize)
 * [`addListener('onProgress', ...)`](#addlisteneronprogress-)
 * [Interfaces](#interfaces)
@@ -173,6 +219,28 @@ compressVideo(options: CompressOptions) => Promise<CompressResult>
 --------------------
 
 
+### cancel(...)
+
+```typescript
+cancel(options?: CancelOptions | undefined) => Promise<CancelResult>
+```
+
+Stop the compress that is running now. `compressVideo` then rejects with
+code {@link CANCELLED} and its partial output is deleted.
+
+This is the only way to stop one: the work is synchronous WASM inside a
+web worker (web) or an AVFoundation / LightCompressor pass on its own
+thread (native), and none of them watch an AbortSignal.
+
+| Param         | Type                                                    |
+| ------------- | ------------------------------------------------------- |
+| **`options`** | <code><a href="#canceloptions">CancelOptions</a></code> |
+
+**Returns:** <code>Promise&lt;<a href="#cancelresult">CancelResult</a>&gt;</code>
+
+--------------------
+
+
 ### initialize()
 
 ```typescript
@@ -213,11 +281,26 @@ addListener(eventName: 'onProgress', listenerFunc: (info: { status: string; perc
 
 #### CompressOptions
 
-| Prop             | Type                                                                            |
-| ---------------- | ------------------------------------------------------------------------------- |
-| **`sourcePath`** | <code>string</code>                                                             |
-| **`destPath`**   | <code>string</code>                                                             |
-| **`quality`**    | <code>'VERY_HIGH' \| 'HIGH' \| 'MEDIUM' \| 'LOW' \| 'VERY_LOW' \| '360P'</code> |
+| Prop             | Type                                                                            | Description                                                                                                                                                                                                                                                                                                                                              |
+| ---------------- | ------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **`sourcePath`** | <code>string</code>                                                             |                                                                                                                                                                                                                                                                                                                                                          |
+| **`destPath`**   | <code>string</code>                                                             |                                                                                                                                                                                                                                                                                                                                                          |
+| **`quality`**    | <code>'VERY_HIGH' \| 'HIGH' \| 'MEDIUM' \| 'LOW' \| 'VERY_LOW' \| '360P'</code> |                                                                                                                                                                                                                                                                                                                                                          |
+| **`jobId`**      | <code>string</code>                                                             | Names this compress so `cancel({ jobId })` can target it. Every platform compresses one video at a time, so cancellation is global by nature. Two independent callers in the same app (say a comment queue and a notes queue) therefore need a way to say *which* job they mean — without one, a cancel from either kills whatever the other is running. |
+
+
+#### CancelResult
+
+| Prop            | Type                 | Description                                                  |
+| --------------- | -------------------- | ------------------------------------------------------------ |
+| **`cancelled`** | <code>boolean</code> | False when nothing was running, or when a different job was. |
+
+
+#### CancelOptions
+
+| Prop        | Type                | Description                                                                                               |
+| ----------- | ------------------- | --------------------------------------------------------------------------------------------------------- |
+| **`jobId`** | <code>string</code> | Only cancel if this is the job currently running. Omit to cancel whatever is running, whoever started it. |
 
 
 #### PluginListenerHandle

package/android/src/main/java/com/atomic/videocompressor/NativeVideoCompressorPlugin.java

@@ -22,6 +22,57 @@ import java.util.Collections;
 @CapacitorPlugin(name = "NativeVideoCompressor")
 public class NativeVideoCompressorPlugin extends Plugin {
 
+    /**
+     * Matches the `CANCELLED` constant the JS side exports, so one
+     * `error.code` check covers web, iOS and Android alike.
+     */
+    private static final String CANCELLED_CODE = "CANCELLED";
+
+    private static final String STORAGE_SUBFOLDER = "compressed_videos";
+
+    /** The job compressVideo is running right now, for cancel({ jobId }). */
+    private String currentJobId = null;
+
+    /**
+     * Nothing to do natively; LightCompressor needs no warm-up. Answered
+     * rather than left unimplemented so a caller can await it unconditionally
+     * (the web build does need it, and shares the call site).
+     */
+    @PluginMethod
+    public void initialize(PluginCall call) {
+        JSObject ret = new JSObject();
+        ret.put("success", true);
+        ret.put("message", "No initialization needed on Android");
+        call.resolve(ret);
+    }
+
+    /**
+     * Stop the running compress. LightCompressor cancels its coroutine job and
+     * fires onCancelled, which is already wired below.
+     */
+    @PluginMethod
+    public void cancel(PluginCall call) {
+        String requested = call.getString("jobId");
+        JSObject ret = new JSObject();
+        boolean cancelled;
+
+        // The cancel call itself must be INSIDE the lock. Released first, the
+        // running job could finish and a new one start in the gap — and
+        // VideoCompressor.cancel() being global, it would kill the newcomer.
+        // That is exactly what checking the jobId is meant to prevent.
+        // The call is non-blocking (it cancels a coroutine job), so holding
+        // the lock across it costs nothing.
+        synchronized (this) {
+            cancelled = currentJobId != null && (requested == null || requested.equals(currentJobId));
+            if (cancelled) {
+                VideoCompressor.cancel();
+            }
+        }
+
+        ret.put("cancelled", cancelled);
+        call.resolve(ret);
+    }
+
     @PluginMethod
     public void compressVideo(PluginCall call) {
         String sourcePath = call.getString("sourcePath");
@@ -31,6 +82,11 @@ public class NativeVideoCompressorPlugin extends Plugin {
             return;
         }
 
+        String jobId = call.getString("jobId", "default");
+        synchronized (this) {
+            currentJobId = jobId;
+        }
+
         // 1. Chuẩn bị Uri và Tên file xuất ra
         Uri srcUri;
         String fileName = "compressed_" + System.currentTimeMillis() + ".mp4";
@@ -80,7 +136,7 @@ public class NativeVideoCompressorPlugin extends Plugin {
         );
 
         // 3. Cấu hình nơi lưu (Lưu an toàn vào thư mục nội bộ của App)
-        AppSpecificStorageConfiguration storageConfig = new AppSpecificStorageConfiguration("compressed_videos");
+        AppSpecificStorageConfiguration storageConfig = new AppSpecificStorageConfiguration(STORAGE_SUBFOLDER);
 
         // Khởi động Foreground Service để giữ app luôn sống khi chạy ngầm
         Intent serviceIntent = new Intent(getContext(), VideoCompressionService.class);
@@ -114,13 +170,13 @@ public class NativeVideoCompressorPlugin extends Plugin {
 
                 @Override
                 public void onFailure(int i, @NonNull String failureMessage) {
-                    getContext().stopService(serviceIntent);
+                    finishJob(serviceIntent);
                     call.reject("Nén thất bại: " + failureMessage);
                 }
 
                 @Override
                 public void onSuccess(int i, long l, @Nullable String s) {
-                    getContext().stopService(serviceIntent);
+                    finishJob(serviceIntent);
                     // Nén xong, trả kết quả đường dẫn file mới về cho JS
                     JSObject ret = new JSObject();
                     ret.put("success", true);
@@ -137,10 +193,37 @@ public class NativeVideoCompressorPlugin extends Plugin {
 
                 @Override
                 public void onCancelled(int i) {
-                    getContext().stopService(serviceIntent);
-                    call.reject("Đã hủy nén");
+                    finishJob(serviceIntent);
+                    // LightCompressor leaves whatever it had already written
+                    // behind; without this the cache keeps a partial mp4 per
+                    // cancel, and nothing ever collects them.
+                    deleteOutput(fileName);
+                    // Coded so the caller can tell "the user asked for this"
+                    // apart from a real failure — same code on every platform.
+                    call.reject("Đã hủy nén", CANCELLED_CODE);
                 }
             }
         );
     }
+
+    /** Every terminal callback ends here, so neither is ever left running. */
+    private void finishJob(Intent serviceIntent) {
+        getContext().stopService(serviceIntent);
+        synchronized (this) {
+            currentJobId = null;
+        }
+    }
+
+    /** Best-effort: a partial file left in the cache is not worth failing over. */
+    private void deleteOutput(String fileName) {
+        try {
+            File dir = new File(getContext().getExternalFilesDir(null), STORAGE_SUBFOLDER);
+            File partial = new File(dir, fileName);
+            if (partial.exists()) {
+                partial.delete();
+            }
+        } catch (Exception e) {
+            Log.w("NativeVideoCompressor", "Could not delete cancelled output", e);
+        }
+    }
 }

package/dist/docs.json

@@ -24,6 +24,25 @@
         ],
         "slug": "compressvideo"
       },
+      {
+        "name": "cancel",
+        "signature": "(options?: CancelOptions | undefined) => Promise<CancelResult>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "CancelOptions | undefined"
+          }
+        ],
+        "returns": "Promise<CancelResult>",
+        "tags": [],
+        "docs": "Stop the compress that is running now. `compressVideo` then rejects with\ncode {@link CANCELLED} and its partial output is deleted.\n\nThis is the only way to stop one: the work is synchronous WASM inside a\nweb worker (web) or an AVFoundation / LightCompressor pass on its own\nthread (native), and none of them watch an AbortSignal.",
+        "complexTypes": [
+          "CancelResult",
+          "CancelOptions"
+        ],
+        "slug": "cancel"
+      },
       {
         "name": "initialize",
         "signature": "() => Promise<{ success: boolean; message?: string; }>",
@@ -111,6 +130,45 @@
           "docs": "",
           "complexTypes": [],
           "type": "'VERY_HIGH' | 'HIGH' | 'MEDIUM' | 'LOW' | 'VERY_LOW' | '360P' | undefined"
+        },
+        {
+          "name": "jobId",
+          "tags": [],
+          "docs": "Names this compress so `cancel({ jobId })` can target it.\n\nEvery platform compresses one video at a time, so cancellation is global\nby nature. Two independent callers in the same app (say a comment queue\nand a notes queue) therefore need a way to say *which* job they mean —\nwithout one, a cancel from either kills whatever the other is running.",
+          "complexTypes": [],
+          "type": "string | undefined"
+        }
+      ]
+    },
+    {
+      "name": "CancelResult",
+      "slug": "cancelresult",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "cancelled",
+          "tags": [],
+          "docs": "False when nothing was running, or when a different job was.",
+          "complexTypes": [],
+          "type": "boolean"
+        }
+      ]
+    },
+    {
+      "name": "CancelOptions",
+      "slug": "canceloptions",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "jobId",
+          "tags": [],
+          "docs": "Only cancel if this is the job currently running. Omit to cancel whatever\nis running, whoever started it.",
+          "complexTypes": [],
+          "type": "string | undefined"
         }
       ]
     },

package/dist/esm/definitions.d.ts

@@ -1,15 +1,50 @@
 import type { PluginListenerHandle } from '@capacitor/core';
+/**
+ * `code` on the error `compressVideo` rejects with when `cancel()` stopped it.
+ * Callers should treat it as "the user asked for this" — no error toast, no
+ * retry prompt — and tell it apart from a genuine compression failure.
+ */
+export declare const CANCELLED = "CANCELLED";
 export interface CompressOptions {
     sourcePath: string;
     destPath?: string;
     quality?: 'VERY_HIGH' | 'HIGH' | 'MEDIUM' | 'LOW' | 'VERY_LOW' | '360P';
+    /**
+     * Names this compress so `cancel({ jobId })` can target it.
+     *
+     * Every platform compresses one video at a time, so cancellation is global
+     * by nature. Two independent callers in the same app (say a comment queue
+     * and a notes queue) therefore need a way to say *which* job they mean —
+     * without one, a cancel from either kills whatever the other is running.
+     */
+    jobId?: string;
 }
 export interface CompressResult {
     success: boolean;
     destPath: string;
 }
+export interface CancelOptions {
+    /**
+     * Only cancel if this is the job currently running. Omit to cancel whatever
+     * is running, whoever started it.
+     */
+    jobId?: string;
+}
+export interface CancelResult {
+    /** False when nothing was running, or when a different job was. */
+    cancelled: boolean;
+}
 export interface NativeVideoCompressorPlugin {
     compressVideo(options: CompressOptions): Promise<CompressResult>;
+    /**
+     * Stop the compress that is running now. `compressVideo` then rejects with
+     * code {@link CANCELLED} and its partial output is deleted.
+     *
+     * This is the only way to stop one: the work is synchronous WASM inside a
+     * web worker (web) or an AVFoundation / LightCompressor pass on its own
+     * thread (native), and none of them watch an AbortSignal.
+     */
+    cancel(options?: CancelOptions): Promise<CancelResult>;
     initialize(): Promise<{
         success: boolean;
         message?: string;

package/dist/esm/definitions.js

@@ -1,2 +1,7 @@
-export {};
+/**
+ * `code` on the error `compressVideo` rejects with when `cancel()` stopped it.
+ * Callers should treat it as "the user asked for this" — no error toast, no
+ * retry prompt — and tell it apart from a genuine compression failure.
+ */
+export const CANCELLED = 'CANCELLED';
 //# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["import type { PluginListenerHandle } from '@capacitor/core';\n\nexport interface CompressOptions {\n  sourcePath: string;\n  destPath?: string;\n  quality?: 'VERY_HIGH' | 'HIGH' | 'MEDIUM' | 'LOW' | 'VERY_LOW' | '360P';\n}\n\nexport interface CompressResult {\n  success: boolean;\n  destPath: string;\n}\n\nexport interface NativeVideoCompressorPlugin {\n  compressVideo(options: CompressOptions): Promise<CompressResult>;\n\n  initialize(): Promise<{ success: boolean; message?: string }>;\n\n  // Đã sửa lại chuẩn cho Capacitor mới nhất (chỉ trả về Promise)\n  addListener(\n    eventName: 'onProgress',\n    listenerFunc: (info: { status: string; percent?: number }) => void,\n  ): Promise<PluginListenerHandle>;\n}\n"]}
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,WAAW,CAAC","sourcesContent":["import type { PluginListenerHandle } from '@capacitor/core';\n\n/**\n * `code` on the error `compressVideo` rejects with when `cancel()` stopped it.\n * Callers should treat it as \"the user asked for this\" — no error toast, no\n * retry prompt — and tell it apart from a genuine compression failure.\n */\nexport const CANCELLED = 'CANCELLED';\n\nexport interface CompressOptions {\n  sourcePath: string;\n  destPath?: string;\n  quality?: 'VERY_HIGH' | 'HIGH' | 'MEDIUM' | 'LOW' | 'VERY_LOW' | '360P';\n  /**\n   * Names this compress so `cancel({ jobId })` can target it.\n   *\n   * Every platform compresses one video at a time, so cancellation is global\n   * by nature. Two independent callers in the same app (say a comment queue\n   * and a notes queue) therefore need a way to say *which* job they mean —\n   * without one, a cancel from either kills whatever the other is running.\n   */\n  jobId?: string;\n}\n\nexport interface CompressResult {\n  success: boolean;\n  destPath: string;\n}\n\nexport interface CancelOptions {\n  /**\n   * Only cancel if this is the job currently running. Omit to cancel whatever\n   * is running, whoever started it.\n   */\n  jobId?: string;\n}\n\nexport interface CancelResult {\n  /** False when nothing was running, or when a different job was. */\n  cancelled: boolean;\n}\n\nexport interface NativeVideoCompressorPlugin {\n  compressVideo(options: CompressOptions): Promise<CompressResult>;\n\n  /**\n   * Stop the compress that is running now. `compressVideo` then rejects with\n   * code {@link CANCELLED} and its partial output is deleted.\n   *\n   * This is the only way to stop one: the work is synchronous WASM inside a\n   * web worker (web) or an AVFoundation / LightCompressor pass on its own\n   * thread (native), and none of them watch an AbortSignal.\n   */\n  cancel(options?: CancelOptions): Promise<CancelResult>;\n\n  initialize(): Promise<{ success: boolean; message?: string }>;\n\n  // Đã sửa lại chuẩn cho Capacitor mới nhất (chỉ trả về Promise)\n  addListener(\n    eventName: 'onProgress',\n    listenerFunc: (info: { status: string; percent?: number }) => void,\n  ): Promise<PluginListenerHandle>;\n}\n"]}

package/dist/esm/web.d.ts

@@ -1,9 +1,24 @@
 import { WebPlugin } from '@capacitor/core';
-import type { NativeVideoCompressorPlugin, CompressOptions, CompressResult } from './definitions';
+import type { NativeVideoCompressorPlugin, CompressOptions, CompressResult, CancelOptions, CancelResult } from './definitions';
 export declare class NativeVideoCompressorWeb extends WebPlugin implements NativeVideoCompressorPlugin {
     private ffmpeg;
     private isLoaded;
+    /** The job `compressVideo` is running right now, for `cancel({ jobId })`. */
+    private currentJobId;
+    private cancelRequested;
     private loadFFmpeg;
+    /**
+     * Kill the worker outright — there is no gentler option.
+     *
+     * `ffmpeg.exec()` runs *synchronously* inside the worker (see
+     * @ffmpeg/ffmpeg's worker.js: `ffmpeg.exec(...args)` is not awaited), so the
+     * worker never reaches a message poll while encoding. The AbortSignal that
+     * `exec()` accepts only rejects the main-thread promise; the encode keeps
+     * burning CPU behind it. `worker.terminate()` is what actually stops it.
+     *
+     * The cost is the loaded core, which is why the core URLs are cached above.
+     */
+    cancel(options?: CancelOptions): Promise<CancelResult>;
     initialize(): Promise<{
         success: boolean;
         message?: string;

package/dist/esm/web.js

@@ -1,41 +1,116 @@
 import { WebPlugin } from '@capacitor/core';
 import { FFmpeg } from '@ffmpeg/ffmpeg';
 import { fetchFile, toBlobURL } from '@ffmpeg/util';
+import { CANCELLED } from './definitions';
+/**
+ * Rejection shape for a cancelled compress. `code` matches what `call.reject`
+ * puts on the error object on iOS/Android, so one `error.code === 'CANCELLED'`
+ * check works on every platform.
+ */
+class CancelledError extends Error {
+    constructor() {
+        super('Đã hủy nén');
+        this.code = CANCELLED;
+        this.name = 'CancelledError';
+    }
+}
+const CORE_BASE_URL = 'https://unpkg.com/@ffmpeg/core@0.12.6/dist/esm';
+/**
+ * Cancelling means terminating the worker, which drops the loaded core with
+ * it — so without this the next compress re-downloads ~30 MB of wasm and
+ * "cancel" quietly costs more than it saves. Module scope, not instance: the
+ * bytes are identical for every instance and every job.
+ */
+let corePromise = null;
+const loadCoreURLs = () => {
+    if (!corePromise) {
+        corePromise = Promise.all([
+            toBlobURL(`${CORE_BASE_URL}/ffmpeg-core.js`, 'text/javascript'),
+            toBlobURL(`${CORE_BASE_URL}/ffmpeg-core.wasm`, 'application/wasm'),
+        ])
+            .then(([coreURL, wasmURL]) => ({ coreURL, wasmURL }))
+            .catch((e) => {
+            // Don't cache a failure — a flaky network shouldn't make every later
+            // compress in this session fail too.
+            corePromise = null;
+            throw e;
+        });
+    }
+    return corePromise;
+};
 export class NativeVideoCompressorWeb extends WebPlugin {
     constructor() {
         super(...arguments);
         this.ffmpeg = null;
         this.isLoaded = false;
+        /** The job `compressVideo` is running right now, for `cancel({ jobId })`. */
+        this.currentJobId = null;
+        this.cancelRequested = false;
     }
     async loadFFmpeg() {
         if (this.isLoaded && this.ffmpeg)
             return;
         this.notifyListeners('onProgress', { status: 'loading_core', percent: 0 });
+        // Built on a local, published to the field only once it is ready and still
+        // wanted. Assigning `this.ffmpeg` up front and setting `isLoaded` after the
+        // await left a window where a cancel could null the instance and the load,
+        // finishing a moment later, would set `isLoaded = true` on nothing at all —
+        // after which every compressVideo threw 'FFmpeg failed to load' for the
+        // rest of the page's life.
+        const instance = new FFmpeg();
+        // Listen to FFmpeg progress and map it to capacitor plugin events
+        instance.on('progress', ({ progress }) => {
+            // progress is a fraction between 0 and 1
+            this.notifyListeners('onProgress', { status: 'progress', percent: Math.round(progress * 100) });
+        });
+        instance.on('log', ({ message }) => {
+            console.log('[FFmpeg Log]', message);
+        });
         try {
-            this.ffmpeg = new FFmpeg();
-            // Listen to FFmpeg progress and map it to capacitor plugin events
-            this.ffmpeg.on('progress', ({ progress }) => {
-                // progress is a fraction between 0 and 1
-                this.notifyListeners('onProgress', { status: 'progress', percent: Math.round(progress * 100) });
-            });
-            this.ffmpeg.on('log', ({ message }) => {
-                console.log('[FFmpeg Log]', message);
-            });
             // Use standard single-threaded version for best compatibility across browsers
             // without requiring complex SharedArrayBuffer headers configuration
-            const baseURL = 'https://unpkg.com/@ffmpeg/core@0.12.6/dist/esm';
-            console.log('Starting to load FFmpeg core from:', baseURL);
-            await this.ffmpeg.load({
-                coreURL: await toBlobURL(`${baseURL}/ffmpeg-core.js`, 'text/javascript'),
-                wasmURL: await toBlobURL(`${baseURL}/ffmpeg-core.wasm`, 'application/wasm'),
-            });
-            this.isLoaded = true;
-            console.log('FFmpeg core loaded successfully');
+            console.log('Starting to load FFmpeg core from:', CORE_BASE_URL);
+            await instance.load(await loadCoreURLs());
         }
         catch (e) {
+            instance.terminate();
             console.error('Failed to load FFmpeg:', e);
             throw e;
         }
+        // Cancelled while this was loading. Terminate what we just built rather
+        // than publish it — the caller asked for none of it.
+        if (this.cancelRequested) {
+            instance.terminate();
+            throw new CancelledError();
+        }
+        this.ffmpeg = instance;
+        this.isLoaded = true;
+        console.log('FFmpeg core loaded successfully');
+    }
+    /**
+     * Kill the worker outright — there is no gentler option.
+     *
+     * `ffmpeg.exec()` runs *synchronously* inside the worker (see
+     * @ffmpeg/ffmpeg's worker.js: `ffmpeg.exec(...args)` is not awaited), so the
+     * worker never reaches a message poll while encoding. The AbortSignal that
+     * `exec()` accepts only rejects the main-thread promise; the encode keeps
+     * burning CPU behind it. `worker.terminate()` is what actually stops it.
+     *
+     * The cost is the loaded core, which is why the core URLs are cached above.
+     */
+    async cancel(options) {
+        var _a;
+        if (!this.currentJobId)
+            return { cancelled: false };
+        if ((options === null || options === void 0 ? void 0 : options.jobId) && options.jobId !== this.currentJobId)
+            return { cancelled: false };
+        // Set even when there is no instance yet: the job may still be inside
+        // loadFFmpeg, which reads this flag before publishing what it built.
+        this.cancelRequested = true;
+        (_a = this.ffmpeg) === null || _a === void 0 ? void 0 : _a.terminate();
+        this.ffmpeg = null;
+        this.isLoaded = false;
+        return { cancelled: true };
     }
     async initialize() {
         try {
@@ -50,13 +125,30 @@ export class NativeVideoCompressorWeb extends WebPlugin {
         }
     }
     async compressVideo(options) {
+        var _a;
+        this.currentJobId = (_a = options.jobId) !== null && _a !== void 0 ? _a : 'default';
+        this.cancelRequested = false;
+        // Checked at every stage boundary, not just around exec: terminate() only
+        // reaches work that has already got to the worker, so a cancel during the
+        // core download or the source fetch has nothing to interrupt and would
+        // otherwise let the compress carry on as if nothing had happened.
+        const throwIfCancelled = () => {
+            if (this.cancelRequested)
+                throw new CancelledError();
+        };
         try {
             if (!this.isLoaded) {
                 await this.loadFFmpeg();
             }
+            throwIfCancelled();
             if (!this.ffmpeg) {
                 throw new Error('FFmpeg failed to load');
             }
+            // Bound once. `this.ffmpeg` is nulled by cancel(), so reading it after
+            // any of the four awaits below can hand back null on a reference the
+            // compiler narrowed at this line — surfacing a cancel as a TypeError
+            // instead of a CancelledError.
+            const ffmpeg = this.ffmpeg;
             this.notifyListeners('onProgress', { status: 'started', percent: 0 });
             const { sourcePath, quality = 'MEDIUM' } = options;
             const inputFileName = 'input.mp4';
@@ -106,14 +198,18 @@ export class NativeVideoCompressorWeb extends WebPlugin {
                 console.error('[FFmpeg] Error fetching source file:', err);
                 throw new Error('Could not fetch source video file');
             }
+            throwIfCancelled();
             console.log('[FFmpeg] Writing file to FS...', inputData.byteLength, 'bytes');
             try {
-                await this.ffmpeg.writeFile(inputFileName, inputData);
+                await ffmpeg.writeFile(inputFileName, inputData);
             }
             catch (err) {
+                if (this.cancelRequested)
+                    throw new CancelledError();
                 console.error('[FFmpeg] Error writing to FS:', err);
                 throw new Error('Could not write to FFmpeg FS');
             }
+            throwIfCancelled();
             // Construct FFmpeg command array
             const args = ['-i', inputFileName];
             // Video codec and compression parameters (superfast provides much better size than ultrafast)
@@ -128,25 +224,32 @@ export class NativeVideoCompressorWeb extends WebPlugin {
             args.push(outputFileName);
             console.log('[FFmpeg] Executing command:', args.join(' '));
             try {
-                const retCode = await this.ffmpeg.exec(args);
+                const retCode = await ffmpeg.exec(args);
                 console.log('[FFmpeg] Exec returned code:', retCode);
             }
             catch (err) {
+                // terminate() rejects every in-flight call, so a cancel arrives here
+                // looking like a generic failure unless we name it.
+                if (this.cancelRequested)
+                    throw new CancelledError();
                 console.error('[FFmpeg] Error executing command:', err);
                 throw new Error('FFmpeg execution failed');
             }
+            throwIfCancelled();
             console.log('[FFmpeg] Reading output file...');
             let data;
             try {
-                data = await this.ffmpeg.readFile(outputFileName);
+                data = await ffmpeg.readFile(outputFileName);
             }
             catch (err) {
+                if (this.cancelRequested)
+                    throw new CancelledError();
                 console.error('[FFmpeg] Error reading output file:', err);
                 throw new Error('Could not read FFmpeg output');
             }
             // Free memory
-            await this.ffmpeg.deleteFile(inputFileName);
-            await this.ffmpeg.deleteFile(outputFileName);
+            await ffmpeg.deleteFile(inputFileName);
+            await ffmpeg.deleteFile(outputFileName);
             console.log('[FFmpeg] Creating Blob URL from output...', data.byteLength, 'bytes');
             // Create a blob URL for the resulting file
             const blob = new Blob([data], { type: 'video/mp4' });
@@ -158,9 +261,18 @@ export class NativeVideoCompressorWeb extends WebPlugin {
             };
         }
         catch (error) {
-            console.error('[FFmpeg] Compression process failed:', error);
+            if ((error === null || error === void 0 ? void 0 : error.code) === CANCELLED) {
+                console.log('[FFmpeg] Compression cancelled');
+            }
+            else {
+                console.error('[FFmpeg] Compression process failed:', error);
+            }
             throw error;
         }
+        finally {
+            this.currentJobId = null;
+            this.cancelRequested = false;
+        }
     }
 }
 //# sourceMappingURL=web.js.map