capacitor-native-video-compressor 1.2.0 → 2.1.0

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

@@ -0,0 +1,134 @@
+package com.atomic.videocompressor;
+
+import android.content.Context;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.work.Worker;
+import androidx.work.WorkerParameters;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Giữ pha nén chạy được khi user rời app, không cần foreground service.
+ *
+ * Android 14+ đóng băng process ở trạng thái cached, nên nén bằng một thread
+ * thường sẽ đứng lại ngay khi user chuyển app. Foreground service từng là cách
+ * giữ nó sống, nhưng Google Play từ chối version code 32: use case này được xếp
+ * vào data sync + local processing, không đủ điều kiện cho
+ * FOREGROUND_SERVICE_MEDIA_PROCESSING, và họ chỉ đích danh WorkManager làm
+ * phương án thay thế. Process đang chạy một worker thì không bị đóng băng.
+ *
+ * Worker chỉ là vỏ bọc: việc nén thật do plugin đăng ký qua {@link #register}
+ * ngay trước khi enqueue, vì chỉ plugin mới giữ được PluginCall để trả kết quả.
+ *
+ * Với `holdForUpload`, worker ở lại sau khi nén xong cho tới khi caller gọi
+ * `finishUpload`. Pha upload chạy bằng JS trong webview, và khoảnh khắc worker
+ * kết thúc là khoảnh khắc process thành cached rồi bị đóng băng - đo trên
+ * Android 16: upload chết đúng ~5 giây sau khi worker trả về. Giữ worker sống
+ * xuyên pha upload là cách duy nhất còn lại để nó sống sót, vì foreground
+ * service đã bị Play cấm cho use case này.
+ *
+ * Giới hạn phải biết: WorkManager dừng worker sau 10 phút, tính chung cả nén
+ * lẫn upload. Quá mức đó {@link #onStopped()} huỷ việc đang chạy và caller
+ * nhận lỗi CANCELLED - đổi lại lấy được nhiều thời gian hơn thì phải có
+ * foreground service, thứ không còn được phép ở đây.
+ */
+public class VideoCompressionWorker extends Worker {
+
+    static final String KEY_JOB_ID = "jobId";
+
+    /**
+     * Việc nén do plugin đăng ký, tra theo jobId.
+     *
+     * Static vì worker được WorkManager dựng mới, không nhận được tham chiếu
+     * nào từ phía plugin. Map chỉ có nghĩa trong phạm vi một process: process
+     * chết là WebView chết, không còn ai nhận kết quả nén nữa.
+     */
+    private static final Map<String, Job> pending = new ConcurrentHashMap<>();
+
+    interface Job {
+        /**
+         * Chạy pha nén, và với holdForUpload thì ở lại tới khi caller gọi
+         * finishUpload. Chỉ trả về khi không còn gì phải giữ process sống.
+         */
+        void run();
+
+        /** WorkManager đòi dừng - hết 10 phút, hoặc work bị cancel. */
+        void stop();
+
+        /** Caller báo đã upload xong; worker được phép kết thúc. */
+        void release();
+    }
+
+    static void register(String jobId, Job job) {
+        pending.put(jobId, job);
+    }
+
+    static void unregister(String jobId) {
+        pending.remove(jobId);
+    }
+
+    /**
+     * Thả worker đang giữ process sống cho pha upload của jobId.
+     *
+     * False khi không còn job nào mang id đó - worker đã kết thúc từ trước,
+     * không có gì để thả. Đó là trạng thái bình thường, không phải lỗi.
+     */
+    static boolean release(String jobId) {
+        Job job = pending.get(jobId);
+        if (job == null) return false;
+        job.release();
+        return true;
+    }
+
+    /** Dừng và gỡ mọi job đang đăng ký - chúng thuộc một phiên WebView đã chết. */
+    static void stopAll() {
+        for (String jobId : pending.keySet()) stop(jobId);
+    }
+
+    /** Dừng và gỡ job của jobId; false khi không còn job nào mang id đó. */
+    static boolean stop(String jobId) {
+        Job job = pending.remove(jobId);
+        if (job == null) return false;
+        job.stop();
+        return true;
+    }
+
+    @Nullable
+    private volatile Job running = null;
+
+    public VideoCompressionWorker(@NonNull Context context, @NonNull WorkerParameters params) {
+        super(context, params);
+    }
+
+    @NonNull
+    @Override
+    public Result doWork() {
+        String jobId = getInputData().getString(KEY_JOB_ID);
+        if (jobId == null) return Result.success();
+
+        Job job = pending.get(jobId);
+        // Không còn job: process đã bị kill và WorkManager dựng lại worker ở
+        // process mới. WebView đã chết cùng nó nên không còn ai nhận kết quả -
+        // chạy lại pha nén chỉ tốn pin. Success chứ không retry, để WorkManager
+        // bỏ hẳn work này đi.
+        if (job == null) return Result.success();
+
+        running = job;
+        try {
+            job.run();
+        } finally {
+            running = null;
+            // Hai tham số: một phiên mới có thể đã đăng ký lại cùng jobId.
+            pending.remove(jobId, job);
+        }
+        return Result.success();
+    }
+
+    @Override
+    public void onStopped() {
+        Job job = running;
+        if (job != null) job.stop();
+        super.onStopped();
+    }
+}

package/dist/docs.json

@@ -17,7 +17,7 @@
         ],
         "returns": "Promise<CompressResult>",
         "tags": [],
-        "docs": "",
+        "docs": "Compress one video and resolve with the path of the result.\n\nAndroid: the work runs inside a WorkManager worker, which keeps the\nprocess out of the frozen cached state while the user is away — there is\nno foreground service and no notification, because Google Play classes\nthis use case as data sync plus local processing and rejects\n`FOREGROUND_SERVICE_MEDIA_PROCESSING` for it. WorkManager stops a worker\nafter 10 minutes, so a compress that runs longer rejects with\n{@link CANCELLED}.",
         "complexTypes": [
           "CompressResult",
           "CompressOptions"
@@ -43,6 +43,22 @@
         ],
         "slug": "cancel"
       },
+      {
+        "name": "finishUpload",
+        "signature": "(options: { jobId: string; }) => Promise<{ released: boolean; }>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "{ jobId: string; }"
+          }
+        ],
+        "returns": "Promise<{ released: boolean; }>",
+        "tags": [],
+        "docs": "Release the worker that `holdForUpload` kept alive for this job.\n\nCall it on every terminal branch of the upload, success or failure. A\nmissed call leaves the device feeding an idle job until the hold expires.\n`released` is false when no job by that id was still being held, which is\nthe normal outcome of a late or duplicate call, not an error.\n\nWeb: deletes the compressed output instead, so call it only once the File\nis no longer needed (not before a retry).",
+        "complexTypes": [],
+        "slug": "finishupload"
+      },
       {
         "name": "initialize",
         "signature": "() => Promise<{ success: boolean; message?: string; }>",
@@ -75,29 +91,6 @@
           "PluginListenerHandle"
         ],
         "slug": "addlisteneronprogress-"
-      },
-      {
-        "name": "addListener",
-        "signature": "(eventName: 'onCancelRequested', listenerFunc: () => void) => Promise<PluginListenerHandle>",
-        "parameters": [
-          {
-            "name": "eventName",
-            "docs": "",
-            "type": "'onCancelRequested'"
-          },
-          {
-            "name": "listenerFunc",
-            "docs": "",
-            "type": "() => void"
-          }
-        ],
-        "returns": "Promise<PluginListenerHandle>",
-        "tags": [],
-        "docs": "Android: user đã bấm \"Huỷ\" trên notification của foreground service.\n\nPha nén được plugin tự huỷ trước khi event này bắn, nhưng việc caller định\nlàm với kết quả nén - upload chẳng hạn - thì không ai dừng hộ được, nên\ncaller phải tự abort. Bỏ qua event này nghĩa là nút Huỷ không thật sự huỷ,\nvà Play đánh trượt tiêu chí \"can be terminated or stopped by the user\".",
-        "complexTypes": [
-          "PluginListenerHandle"
-        ],
-        "slug": "addlisteneroncancelrequested-"
       }
     ],
     "properties": []
@@ -160,6 +153,13 @@
           "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": "holdForUpload",
+          "tags": [],
+          "docs": "Android only: keep the background worker alive after the compress ends,\nuntil `finishUpload({ jobId })` is called.\n\nThe upload runs as JavaScript in the webview, and the moment the worker\nreturns the process becomes cached and is frozen — measured on Android 16,\nan in-flight upload dies about five seconds later. Set this whenever the\ncompressed file is about to be uploaded, and always pair it with a\n`finishUpload` in a `finally`.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
         }
       ]
     },

package/dist/esm/definitions.d.ts

@@ -5,6 +5,20 @@ import type { PluginListenerHandle } from '@capacitor/core';
  * retry prompt — and tell it apart from a genuine compression failure.
  */
 export declare const CANCELLED = "CANCELLED";
+/**
+ * `code` on the error `compressVideo` rejects with on web when WebCodecs can't
+ * encode the video and it is larger than 200 MB, the cap for the ffmpeg.wasm
+ * fallback. ffmpeg.wasm copies the whole input into wasm memory (~2 GB
+ * ceiling), so a large file there crashes or hangs the tab rather than failing
+ * cleanly.
+ */
+export declare const TOO_LARGE_FOR_WEB = "TOO_LARGE_FOR_WEB";
+/**
+ * `code` on the error `compressVideo` rejects with on web when the browser
+ * refuses to store more of the output (storage quota). Retryable once space
+ * is freed.
+ */
+export declare const STORAGE_FULL = "STORAGE_FULL";
 export interface CompressOptions {
     sourcePath: string;
     destPath?: string;
@@ -18,6 +32,17 @@ export interface CompressOptions {
      * without one, a cancel from either kills whatever the other is running.
      */
     jobId?: string;
+    /**
+     * Android only: keep the background worker alive after the compress ends,
+     * until `finishUpload({ jobId })` is called.
+     *
+     * The upload runs as JavaScript in the webview, and the moment the worker
+     * returns the process becomes cached and is frozen — measured on Android 16,
+     * an in-flight upload dies about five seconds later. Set this whenever the
+     * compressed file is about to be uploaded, and always pair it with a
+     * `finishUpload` in a `finally`.
+     */
+    holdForUpload?: boolean;
 }
 export interface CompressResult {
     success: boolean;
@@ -35,6 +60,17 @@ export interface CancelResult {
     cancelled: boolean;
 }
 export interface NativeVideoCompressorPlugin {
+    /**
+     * Compress one video and resolve with the path of the result.
+     *
+     * Android: the work runs inside a WorkManager worker, which keeps the
+     * process out of the frozen cached state while the user is away — there is
+     * no foreground service and no notification, because Google Play classes
+     * this use case as data sync plus local processing and rejects
+     * `FOREGROUND_SERVICE_MEDIA_PROCESSING` for it. WorkManager stops a worker
+     * after 10 minutes, so a compress that runs longer rejects with
+     * {@link CANCELLED}.
+     */
     compressVideo(options: CompressOptions): Promise<CompressResult>;
     /**
      * Stop the compress that is running now. `compressVideo` then rejects with
@@ -45,6 +81,22 @@ export interface NativeVideoCompressorPlugin {
      * thread (native), and none of them watch an AbortSignal.
      */
     cancel(options?: CancelOptions): Promise<CancelResult>;
+    /**
+     * Release the worker that `holdForUpload` kept alive for this job.
+     *
+     * Call it on every terminal branch of the upload, success or failure. A
+     * missed call leaves the device feeding an idle job until the hold expires.
+     * `released` is false when no job by that id was still being held, which is
+     * the normal outcome of a late or duplicate call, not an error.
+     *
+     * Web: deletes the compressed output instead, so call it only once the File
+     * is no longer needed (not before a retry).
+     */
+    finishUpload(options: {
+        jobId: string;
+    }): Promise<{
+        released: boolean;
+    }>;
     initialize(): Promise<{
         success: boolean;
         message?: string;
@@ -53,13 +105,4 @@ export interface NativeVideoCompressorPlugin {
         status: string;
         percent?: number;
     }) => void): Promise<PluginListenerHandle>;
-    /**
-     * Android: user đã bấm "Huỷ" trên notification của foreground service.
-     *
-     * Pha nén được plugin tự huỷ trước khi event này bắn, nhưng việc caller định
-     * làm với kết quả nén - upload chẳng hạn - thì không ai dừng hộ được, nên
-     * caller phải tự abort. Bỏ qua event này nghĩa là nút Huỷ không thật sự huỷ,
-     * và Play đánh trượt tiêu chí "can be terminated or stopped by the user".
-     */
-    addListener(eventName: 'onCancelRequested', listenerFunc: () => void): Promise<PluginListenerHandle>;
 }

package/dist/esm/definitions.js

@@ -4,4 +4,18 @@
  * retry prompt — and tell it apart from a genuine compression failure.
  */
 export const CANCELLED = 'CANCELLED';
+/**
+ * `code` on the error `compressVideo` rejects with on web when WebCodecs can't
+ * encode the video and it is larger than 200 MB, the cap for the ffmpeg.wasm
+ * fallback. ffmpeg.wasm copies the whole input into wasm memory (~2 GB
+ * ceiling), so a large file there crashes or hangs the tab rather than failing
+ * cleanly.
+ */
+export const TOO_LARGE_FOR_WEB = 'TOO_LARGE_FOR_WEB';
+/**
+ * `code` on the error `compressVideo` rejects with on web when the browser
+ * refuses to store more of the output (storage quota). Retryable once space
+ * is freed.
+ */
+export const STORAGE_FULL = 'STORAGE_FULL';
 //# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -1 +1 @@
-{"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  /**\n   * Android: user đã bấm \"Huỷ\" trên notification của foreground service.\n   *\n   * Pha nén được plugin tự huỷ trước khi event này bắn, nhưng việc caller định\n   * làm với kết quả nén - upload chẳng hạn - thì không ai dừng hộ được, nên\n   * caller phải tự abort. Bỏ qua event này nghĩa là nút Huỷ không thật sự huỷ,\n   * và Play đánh trượt tiêu chí \"can be terminated or stopped by the user\".\n   */\n  addListener(\n    eventName: 'onCancelRequested',\n    listenerFunc: () => 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;AAErC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,mBAAmB,CAAC;AAErD;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,cAAc,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\n/**\n * `code` on the error `compressVideo` rejects with on web when WebCodecs can't\n * encode the video and it is larger than 200 MB, the cap for the ffmpeg.wasm\n * fallback. ffmpeg.wasm copies the whole input into wasm memory (~2 GB\n * ceiling), so a large file there crashes or hangs the tab rather than failing\n * cleanly.\n */\nexport const TOO_LARGE_FOR_WEB = 'TOO_LARGE_FOR_WEB';\n\n/**\n * `code` on the error `compressVideo` rejects with on web when the browser\n * refuses to store more of the output (storage quota). Retryable once space\n * is freed.\n */\nexport const STORAGE_FULL = 'STORAGE_FULL';\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   * Android only: keep the background worker alive after the compress ends,\n   * until `finishUpload({ jobId })` is called.\n   *\n   * The upload runs as JavaScript in the webview, and the moment the worker\n   * returns the process becomes cached and is frozen — measured on Android 16,\n   * an in-flight upload dies about five seconds later. Set this whenever the\n   * compressed file is about to be uploaded, and always pair it with a\n   * `finishUpload` in a `finally`.\n   */\n  holdForUpload?: boolean;\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  /**\n   * Compress one video and resolve with the path of the result.\n   *\n   * Android: the work runs inside a WorkManager worker, which keeps the\n   * process out of the frozen cached state while the user is away — there is\n   * no foreground service and no notification, because Google Play classes\n   * this use case as data sync plus local processing and rejects\n   * `FOREGROUND_SERVICE_MEDIA_PROCESSING` for it. WorkManager stops a worker\n   * after 10 minutes, so a compress that runs longer rejects with\n   * {@link CANCELLED}.\n   */\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  /**\n   * Release the worker that `holdForUpload` kept alive for this job.\n   *\n   * Call it on every terminal branch of the upload, success or failure. A\n   * missed call leaves the device feeding an idle job until the hold expires.\n   * `released` is false when no job by that id was still being held, which is\n   * the normal outcome of a late or duplicate call, not an error.\n   *\n   * Web: deletes the compressed output instead, so call it only once the File\n   * is no longer needed (not before a retry).\n   */\n  finishUpload(options: { jobId: string }): Promise<{ released: boolean }>;\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/opfs-output.d.ts

@@ -0,0 +1,7 @@
+export interface OpfsOutput {
+    writable: FileSystemWritableFileStream;
+    read: () => Promise<Blob>;
+    discard: () => Promise<void>;
+}
+/** Null when OPFS or `createWritable` (missing on Safari's main thread) isn't there. */
+export declare const createOpfsOutput: () => Promise<OpfsOutput | null>;

package/dist/esm/opfs-output.js

@@ -0,0 +1,94 @@
+/**
+ * WebCodecs output goes to the origin private file system so a long video
+ * never sits whole in memory. The File handed back stays readable only while
+ * its OPFS entry exists, and callers keep it well past `compressVideo` (until
+ * the upload is done, or longer for a retry), so a successful output stays
+ * until the caller releases it with `finishUpload({ jobId })` or the tab
+ * closes. Each tab writes under its own directory and holds a Web Lock named
+ * after it for its whole life; every compress removes the directories whose
+ * lock nobody holds any more, i.e. those of closed tabs. A failed or cancelled
+ * job deletes its own file straight away.
+ */
+const OPFS_ROOT = 'native-video-compressor';
+const lockName = (tabId) => `${OPFS_ROOT}:${tabId}`;
+let tabId = null;
+const getTabId = () => (tabId !== null && tabId !== void 0 ? tabId : (tabId = crypto.randomUUID()));
+let fileCount = 0;
+// Memoised apart from the directories: they are reopened after site data is
+// cleared, but this tab still holds its lock, and requesting it again would
+// wait forever on ourselves.
+let tabLock = null;
+let tabDirsPromise = null;
+// A rejected request (e.g. a sandboxed iframe) rejects here, so openTabDirs
+// fails and the caller buffers in memory instead of waiting forever.
+const holdTabLock = () => new Promise((granted, rejected) => {
+    navigator.locks
+        .request(lockName(getTabId()), () => {
+        granted();
+        return new Promise(() => undefined);
+    })
+        .catch(rejected);
+});
+const sweepClosedTabs = async (base) => {
+    // Names first, locks second: a tab that creates its directory between the two
+    // reads already holds its lock, so it is never mistaken for a closed one.
+    const names = [];
+    for await (const name of base.keys())
+        names.push(name);
+    const { held = [] } = await navigator.locks.query();
+    const live = new Set(held.map((l) => l.name));
+    for (const name of names) {
+        if (!live.has(lockName(name)))
+            await base.removeEntry(name, { recursive: true }).catch(() => undefined);
+    }
+};
+const openTabDirs = async () => {
+    const base = await (await navigator.storage.getDirectory()).getDirectoryHandle(OPFS_ROOT, { create: true });
+    if (navigator.locks) {
+        await (tabLock !== null && tabLock !== void 0 ? tabLock : (tabLock = holdTabLock().catch((e) => {
+            tabLock = null;
+            throw e;
+        })));
+    }
+    return { base, dir: await base.getDirectoryHandle(getTabId(), { create: true }) };
+};
+/** Null when OPFS or `createWritable` (missing on Safari's main thread) isn't there. */
+export const createOpfsOutput = async () => {
+    var _a;
+    try {
+        if (typeof navigator === 'undefined' || !((_a = navigator.storage) === null || _a === void 0 ? void 0 : _a.getDirectory))
+            return null;
+        const { base, dir } = await (tabDirsPromise !== null && tabDirsPromise !== void 0 ? tabDirsPromise : (tabDirsPromise = openTabDirs().catch((e) => {
+            tabDirsPromise = null;
+            throw e;
+        })));
+        // Without Web Locks another tab's live files can't be told apart: no sweep.
+        if (navigator.locks)
+            await sweepClosedTabs(base).catch(() => undefined);
+        const name = `${++fileCount}.mp4`;
+        const handle = await dir.getFileHandle(name, { create: true }).catch((e) => {
+            // The directory was removed under us (site data cleared): reopen it next time.
+            if ((e === null || e === void 0 ? void 0 : e.name) === 'NotFoundError')
+                tabDirsPromise = null;
+            throw e;
+        });
+        if (typeof handle.createWritable !== 'function') {
+            await dir.removeEntry(name).catch(() => undefined);
+            return null;
+        }
+        const writable = await handle.createWritable();
+        const discard = async () => {
+            // Rejects harmlessly once mediabunny holds the writer; it closes it then.
+            await writable.abort().catch(() => undefined);
+            await dir.removeEntry(name).catch(() => undefined);
+        };
+        // OPFS files carry no MIME type, and callers derive the extension from it.
+        const read = async () => (await handle.getFile()).slice(0, undefined, 'video/mp4');
+        return { writable, read, discard };
+    }
+    catch (e) {
+        console.warn('[compress] OPFS unavailable, buffering output in memory:', e);
+        return null;
+    }
+};
+//# sourceMappingURL=opfs-output.js.map

package/dist/esm/opfs-output.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opfs-output.js","sourceRoot":"","sources":["../../src/opfs-output.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * WebCodecs output goes to the origin private file system so a long video\n * never sits whole in memory. The File handed back stays readable only while\n * its OPFS entry exists, and callers keep it well past `compressVideo` (until\n * the upload is done, or longer for a retry), so a successful output stays\n * until the caller releases it with `finishUpload({ jobId })` or the tab\n * closes. Each tab writes under its own directory and holds a Web Lock named\n * after it for its whole life; every compress removes the directories whose\n * lock nobody holds any more, i.e. those of closed tabs. A failed or cancelled\n * job deletes its own file straight away.\n */\nconst OPFS_ROOT = 'native-video-compressor';\nconst lockName = (tabId: string) => `${OPFS_ROOT}:${tabId}`;\n\nlet tabId: string | null = null;\nconst getTabId = () => (tabId ??= crypto.randomUUID());\nlet fileCount = 0;\n\n// Memoised apart from the directories: they are reopened after site data is\n// cleared, but this tab still holds its lock, and requesting it again would\n// wait forever on ourselves.\nlet tabLock: Promise<void> | null = null;\nlet tabDirsPromise: Promise<{ base: FileSystemDirectoryHandle; dir: FileSystemDirectoryHandle }> | null = null;\n\n// A rejected request (e.g. a sandboxed iframe) rejects here, so openTabDirs\n// fails and the caller buffers in memory instead of waiting forever.\nconst holdTabLock = () =>\n  new Promise<void>((granted, rejected) => {\n    navigator.locks\n      .request(lockName(getTabId()), () => {\n        granted();\n        return new Promise<never>(() => undefined);\n      })\n      .catch(rejected);\n  });\n\nconst sweepClosedTabs = async (base: FileSystemDirectoryHandle) => {\n  // Names first, locks second: a tab that creates its directory between the two\n  // reads already holds its lock, so it is never mistaken for a closed one.\n  const names: string[] = [];\n  for await (const name of base.keys()) names.push(name);\n  const { held = [] } = await navigator.locks.query();\n  const live = new Set(held.map((l) => l.name));\n  for (const name of names) {\n    if (!live.has(lockName(name))) await base.removeEntry(name, { recursive: true }).catch(() => undefined);\n  }\n};\n\nconst openTabDirs = async () => {\n  const base = await (await navigator.storage.getDirectory()).getDirectoryHandle(OPFS_ROOT, { create: true });\n  if (navigator.locks) {\n    await (tabLock ??= holdTabLock().catch((e) => {\n      tabLock = null;\n      throw e;\n    }));\n  }\n  return { base, dir: await base.getDirectoryHandle(getTabId(), { create: true }) };\n};\n\nexport interface OpfsOutput {\n  writable: FileSystemWritableFileStream;\n  read: () => Promise<Blob>;\n  discard: () => Promise<void>;\n}\n\n/** Null when OPFS or `createWritable` (missing on Safari's main thread) isn't there. */\nexport const createOpfsOutput = async (): Promise<OpfsOutput | null> => {\n  try {\n    if (typeof navigator === 'undefined' || !navigator.storage?.getDirectory) return null;\n    const { base, dir } = await (tabDirsPromise ??= openTabDirs().catch((e) => {\n      tabDirsPromise = null;\n      throw e;\n    }));\n    // Without Web Locks another tab's live files can't be told apart: no sweep.\n    if (navigator.locks) await sweepClosedTabs(base).catch(() => undefined);\n    const name = `${++fileCount}.mp4`;\n    const handle = await dir.getFileHandle(name, { create: true }).catch((e) => {\n      // The directory was removed under us (site data cleared): reopen it next time.\n      if (e?.name === 'NotFoundError') tabDirsPromise = null;\n      throw e;\n    });\n    if (typeof handle.createWritable !== 'function') {\n      await dir.removeEntry(name).catch(() => undefined);\n      return null;\n    }\n    const writable = await handle.createWritable();\n    const discard = async () => {\n      // Rejects harmlessly once mediabunny holds the writer; it closes it then.\n      await writable.abort().catch(() => undefined);\n      await dir.removeEntry(name).catch(() => undefined);\n    };\n    // OPFS files carry no MIME type, and callers derive the extension from it.\n    const read = async () => (await handle.getFile()).slice(0, undefined, 'video/mp4');\n    return { writable, read, discard };\n  } catch (e) {\n    console.warn('[compress] OPFS unavailable, buffering output in memory:', e);\n    return null;\n  }\n};\n"]}

package/dist/esm/web.d.ts

@@ -1,33 +1,51 @@
 import { WebPlugin } from '@capacitor/core';
 import type { NativeVideoCompressorPlugin, CompressOptions, CompressResult, CancelOptions, CancelResult } from './definitions';
+export declare const webCodecsSize: (displayWidth: number, displayHeight: number, shortSide: number) => {
+    width: number;
+} | {
+    height: number;
+};
+export declare const ffmpegScaleFilter: (shortSide: number) => string;
+export declare const capBitrate: (target: number, sourceBitrate: number | undefined, floor: number, headroom?: number) => number;
+export declare const codecHeadroom: (codec: string | null | undefined) => number;
 export declare class NativeVideoCompressorWeb extends WebPlugin implements NativeVideoCompressorPlugin {
     private ffmpeg;
     private isLoaded;
     /** The mediabunny conversion running now, so `cancel()` can abort it. */
     private activeConversion;
-    /** The job `compressVideo` is running right now, for `cancel({ jobId })`. */
-    private currentJobId;
+    /** The job `compressVideo` is running right now; a fresh object per call, so two calls never look alike. */
+    private currentJob;
     private cancelRequested;
+    /** Kept OPFS outputs by jobId, deleted by `finishUpload`. */
+    private keptOutputs;
     initialize(): Promise<{
         success: boolean;
         message?: string;
     }>;
+    finishUpload({ jobId }: {
+        jobId: string;
+    }): Promise<{
+        released: boolean;
+    }>;
     compressVideo(options: CompressOptions): Promise<CompressResult>;
     /**
      * Kill whichever engine is mid-compress. Only one is ever active at a time,
      * so acting on both is safe.
      *
      * WebCodecs: `conversion.cancel()` makes the in-flight `execute()` reject
-     * with `ConversionCanceledError`, surfaced as a `CancelledError` below.
+     * with `ConversionCanceledError`, surfaced as a CANCELLED `CompressError` below.
      * ffmpeg: `exec()` runs synchronously inside the worker and never reaches a
      * message poll while encoding, so `worker.terminate()` is the only way to
      * stop it — its cost is the loaded core, which is why the core URLs are
      * cached above.
      */
     cancel(options?: CancelOptions): Promise<CancelResult>;
+    private stopEngines;
     private fetchSourceBlob;
     private canUseWebCodecs;
     private compressWithWebCodecs;
+    /** False when mediabunny can't convert this input. */
+    private runConversion;
     private loadFFmpeg;
     private compressWithFfmpeg;
 }