@mentra/engine 0.1.0-dev.0 → 3.1.0-dev.4

package/build/services/asg/cameraRollExportCoordinator.js

@@ -0,0 +1,618 @@
+import * as RNFS from "@dr.pogodin/react-native-fs";
+import { MediaLibraryPermissions } from "../../utils/permissions/MediaLibraryPermissions";
+import { BgTimer } from "../../utils/timers";
+import { cameraRollEntryId, cameraRollExportLedger, cameraRollGeneration, } from "./cameraRollExportLedger";
+import { gallerySettingsService } from "./gallerySettingsService";
+import { galleryTransferLedger } from "./galleryTransferLedger";
+import { localStorageService } from "./localStorageService";
+const TAG = "[CameraRollExport]";
+const MIN_FREE_SPACE_BYTES = 100 * 1024 * 1024;
+const MAX_RETRY_DELAY_MS = 30 * 60 * 1000;
+class CameraRollExportCoordinator {
+    initialized = false;
+    initializing = null;
+    lifecycleGeneration = 0;
+    enabled = true;
+    running = false;
+    rerunRequested = false;
+    retryTimer = null;
+    activeEntryId = null;
+    clearInProgress = false;
+    deletingMediaNames = new Set();
+    listeners = new Set();
+    sourceWaiters = new Map();
+    async initialize() {
+        while (!this.initialized) {
+            if (!this.initializing) {
+                const generation = this.lifecycleGeneration;
+                this.initializing = this.initializeInternal(generation);
+            }
+            const initialization = this.initializing;
+            try {
+                await initialization;
+            }
+            finally {
+                if (this.initializing === initialization)
+                    this.initializing = null;
+            }
+        }
+    }
+    cleanup() {
+        this.lifecycleGeneration += 1;
+        if (this.retryTimer != null)
+            BgTimer.clearTimeout(this.retryTimer);
+        this.retryTimer = null;
+        this.initialized = false;
+        this.rerunRequested = false;
+        const error = new Error("Camera-roll export coordinator stopped");
+        for (const id of [...this.sourceWaiters.keys()])
+            this.rejectSourceWaiters(id, error);
+        if (!this.running)
+            this.activeEntryId = null;
+    }
+    async initializeInternal(generation) {
+        cameraRollExportLedger.setDocumentDirectory(RNFS.DocumentDirectoryPath);
+        // A native camera-roll insert is atomic and cannot be cancelled. On a quick engine
+        // stop/start, let the old drain commit its receipt before the new lifecycle reconciles.
+        while (this.running) {
+            await new Promise((resolve) => BgTimer.setTimeout(resolve, 25));
+        }
+        if (generation !== this.lifecycleGeneration)
+            return;
+        const enabled = await gallerySettingsService.getAutoSaveToCameraRoll();
+        if (generation !== this.lifecycleGeneration)
+            return;
+        this.enabled = enabled;
+        await this.reconcileLocalIndex();
+        if (generation !== this.lifecycleGeneration)
+            return;
+        this.initialized = true;
+        this.emitSummary();
+        if (this.enabled)
+            void this.resume("startup");
+    }
+    /** Rebuild missing per-generation records after upgrading from legacy clients. */
+    async reconcileLocalIndex() {
+        const files = await localStorageService.getDownloadedFiles();
+        const liveIds = new Set();
+        const liveGenerationByMediaName = new Map();
+        for (const file of Object.values(files)) {
+            const id = cameraRollEntryId(file.name, file.size, file.modified);
+            liveIds.add(id);
+            liveGenerationByMediaName.set(file.name, id);
+            const current = cameraRollExportLedger.get(id);
+            const transfer = file.capture_id
+                ? galleryTransferLedger.get(file.capture_id)
+                : galleryTransferLedger.get(file.name);
+            const receipt = file.assetReceipt || transfer?.assetReceipt || current?.receipt;
+            const now = Date.now();
+            cameraRollExportLedger.put({
+                ...(current || {
+                    id,
+                    mediaName: file.name,
+                    generation: cameraRollGeneration(file.name, file.size, file.modified),
+                    filePath: file.filePath,
+                    size: file.size,
+                    modified: file.modified,
+                    isVideo: file.is_video,
+                    captureId: file.capture_id || transfer?.captureId,
+                    priority: "HISTORICAL_BACKFILL",
+                    attempts: 0,
+                    createdAt: now,
+                    updatedAt: now,
+                    state: "LEGACY_UNKNOWN",
+                }),
+                filePath: file.filePath,
+                localPresent: true,
+                receipt,
+                requiresFullLibraryReconciliation: current?.requiresFullLibraryReconciliation ?? (!current && !receipt && !transfer),
+                state: receipt ? "EXPORTED" : this.nextEligibleState(current?.state),
+            });
+        }
+        // Explicit app deletion removes receipts through deleteLocalMedia/clearLocalMedia. An index
+        // miss here is not proof of deletion: recovery may not have rebuilt the row yet, and a load
+        // failure is represented as an empty index. Preserve exported receipts as hidden tombstones;
+        // they are the authoritative proof that prevents a duplicate native-library insert.
+        for (const entry of cameraRollExportLedger.list()) {
+            if (liveIds.has(entry.id))
+                continue;
+            if (entry.receipt) {
+                cameraRollExportLedger.update(entry.id, { state: "EXPORTED", localPresent: false });
+                continue;
+            }
+            // A different live generation with the same display name supersedes an unexported stale
+            // row. Never let its old path export the replacement's bytes under the wrong fingerprint.
+            if (liveGenerationByMediaName.has(entry.mediaName)) {
+                cameraRollExportLedger.remove(entry.id);
+                continue;
+            }
+            cameraRollExportLedger.update(entry.id, {
+                state: "MISSING_LOCAL",
+                localPresent: false,
+                lastError: "Local media is missing",
+                nextRetryAt: undefined,
+            });
+        }
+    }
+    nextEligibleState(current) {
+        if (!this.enabled)
+            return "NOT_REQUESTED";
+        // Reconciliation only calls this for files that are present in the durable local index.
+        // A previous filesystem miss was transient if that same generation is visible again.
+        if (current === "FAILED_PERMANENT")
+            return current;
+        return "QUEUED";
+    }
+    async recordIndexed(file, shouldAutoSave, priority = "HISTORICAL_BACKFILL", captureId) {
+        await this.initialize();
+        const id = cameraRollEntryId(file.name, file.size, file.modified);
+        const current = cameraRollExportLedger.get(id);
+        const now = Date.now();
+        const entry = cameraRollExportLedger.put({
+            ...(current || {
+                id,
+                mediaName: file.name,
+                generation: cameraRollGeneration(file.name, file.size, file.modified),
+                attempts: 0,
+                createdAt: now,
+                updatedAt: now,
+            }),
+            filePath: file.filePath,
+            size: file.size,
+            modified: file.modified,
+            isVideo: file.is_video,
+            captureId: captureId || file.capture_id || current?.captureId,
+            localPresent: true,
+            requiresFullLibraryReconciliation: current?.requiresFullLibraryReconciliation ?? false,
+            priority,
+            receipt: file.assetReceipt || current?.receipt,
+            state: file.assetReceipt || current?.receipt ? "EXPORTED" : shouldAutoSave ? "QUEUED" : "NOT_REQUESTED",
+            lastError: undefined,
+            nextRetryAt: undefined,
+        });
+        this.emitSummary();
+        return entry;
+    }
+    async isAutoSaveEnabled() {
+        await this.initialize();
+        return this.enabled;
+    }
+    /** Source deletion waits on this barrier while enabled; disabled exports remain safely app-local. */
+    async exportForSource(file, captureId) {
+        await this.initialize();
+        // A durable receipt proves this generation is already safe regardless of the current
+        // preference. Return it before enforcing disabled state so recovery can still ack the
+        // glasses after a previously-started export committed.
+        const entry = await this.recordIndexed(file, this.enabled, "SOURCE_BARRIER", captureId);
+        if (entry.receipt)
+            return entry.receipt;
+        if (!this.enabled)
+            return undefined;
+        try {
+            return await new Promise((resolve, reject) => {
+                const current = cameraRollExportLedger.get(entry.id);
+                if (current?.receipt) {
+                    resolve(current.receipt);
+                    return;
+                }
+                if (!current) {
+                    reject(new Error("Camera-roll export was removed before its source barrier registered"));
+                    return;
+                }
+                const waiters = this.sourceWaiters.get(entry.id) || [];
+                waiters.push({ resolve, reject });
+                this.sourceWaiters.set(entry.id, waiters);
+                // Re-read after registration so any future refactor that yields while installing a
+                // waiter still cannot miss a receipt committed by the active runner.
+                const registered = cameraRollExportLedger.get(entry.id);
+                if (registered?.receipt) {
+                    this.resolveSourceWaiters(entry.id, registered.receipt);
+                    return;
+                }
+                if (!registered) {
+                    this.rejectSourceWaiters(entry.id, new Error("Camera-roll export was removed before its source barrier registered"));
+                    return;
+                }
+                void this.resume("source barrier");
+            });
+        }
+        catch (error) {
+            // Turning auto-save off makes the durable app-local commit the source-of-truth. A native
+            // insert already in progress still finishes and returns its receipt; queued work may stop.
+            if (!this.enabled)
+                return undefined;
+            throw error;
+        }
+    }
+    async setEnabled(enabled) {
+        await this.initialize();
+        const previous = this.enabled;
+        await gallerySettingsService.setAutoSaveToCameraRoll(enabled);
+        try {
+            this.enabled = enabled;
+            if (!enabled && this.retryTimer != null) {
+                BgTimer.clearTimeout(this.retryTimer);
+                this.retryTimer = null;
+            }
+            for (const entry of cameraRollExportLedger.list()) {
+                if (entry.receipt || entry.state === "EXPORTED" || entry.state === "MISSING_LOCAL")
+                    continue;
+                if (!enabled && entry.id !== this.activeEntryId) {
+                    cameraRollExportLedger.update(entry.id, { state: "NOT_REQUESTED", nextRetryAt: undefined });
+                    this.rejectSourceWaiters(entry.id, new Error("Automatic camera-roll saving was disabled"));
+                }
+                else if (enabled) {
+                    cameraRollExportLedger.update(entry.id, { state: "QUEUED", nextRetryAt: undefined, lastError: undefined });
+                }
+            }
+        }
+        catch (error) {
+            this.enabled = previous;
+            await gallerySettingsService.setAutoSaveToCameraRoll(previous);
+            throw error;
+        }
+        this.emitSummary();
+        if (enabled)
+            void this.resume("setting enabled");
+    }
+    async resume(reason) {
+        const generation = this.lifecycleGeneration;
+        await this.initialize();
+        if (generation !== this.lifecycleGeneration)
+            return;
+        console.log(`${TAG} Resume requested: ${reason}`);
+        if (cameraRollExportLedger.list().some((entry) => entry.state === "BLOCKED_PERMISSION")) {
+            const hasPermission = await MediaLibraryPermissions.checkPermission();
+            const hasLimitedAccess = hasPermission && (await MediaLibraryPermissions.hasLimitedAccess());
+            if (generation !== this.lifecycleGeneration)
+                return;
+            if (hasPermission) {
+                for (const entry of cameraRollExportLedger.list()) {
+                    if (entry.state === "BLOCKED_PERMISSION" && !(entry.requiresFullLibraryReconciliation && hasLimitedAccess)) {
+                        cameraRollExportLedger.update(entry.id, { state: "QUEUED", lastError: undefined });
+                    }
+                }
+            }
+        }
+        if (generation !== this.lifecycleGeneration)
+            return;
+        if (this.retryTimer != null) {
+            BgTimer.clearTimeout(this.retryTimer);
+            this.retryTimer = null;
+        }
+        if (this.running) {
+            this.rerunRequested = true;
+            while (this.running) {
+                await new Promise((resolve) => BgTimer.setTimeout(resolve, 25));
+            }
+            if (generation !== this.lifecycleGeneration)
+                return;
+            // The active drain normally consumes rerunRequested before releasing running. Keep
+            // this final durable-work check so a late handoff can never strand an eligible entry.
+            if (this.nextEntry())
+                await this.resume("work remained after concurrent resume");
+            return;
+        }
+        this.running = true;
+        this.emitSummary();
+        try {
+            do {
+                this.rerunRequested = false;
+                let entry = this.nextEntry();
+                while (entry && generation === this.lifecycleGeneration) {
+                    await this.processEntry(entry, generation);
+                    if (generation !== this.lifecycleGeneration)
+                        break;
+                    entry = this.nextEntry();
+                }
+            } while (this.rerunRequested && generation === this.lifecycleGeneration);
+        }
+        finally {
+            this.rerunRequested = false;
+            this.running = false;
+            if (generation === this.lifecycleGeneration) {
+                this.emitSummary();
+                this.scheduleRetry();
+            }
+        }
+    }
+    async retryNow() {
+        const generation = this.lifecycleGeneration;
+        await this.initialize();
+        // A recovered transfer may have rebuilt a missing local-index row since the last lifecycle
+        // reconciliation. Refresh before retrying so the same camera-roll generation becomes
+        // eligible again; never rewrite entry state underneath an active native insert.
+        while (this.running) {
+            await new Promise((resolve) => BgTimer.setTimeout(resolve, 25));
+        }
+        if (generation !== this.lifecycleGeneration)
+            return;
+        await this.reconcileLocalIndex();
+        if (generation !== this.lifecycleGeneration)
+            return;
+        for (const entry of cameraRollExportLedger.list()) {
+            if (entry.state === "FAILED_RETRYABLE" ||
+                entry.state === "BLOCKED_PERMISSION" ||
+                (entry.state === "MISSING_LOCAL" && entry.localPresent !== false)) {
+                cameraRollExportLedger.update(entry.id, { state: "QUEUED", nextRetryAt: undefined, lastError: undefined });
+            }
+        }
+        await this.resume("manual retry");
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        // `enabled` is loaded from durable settings during initialize(). Do not emit the
+        // default before that read completes or disabled users briefly see the toggle as on.
+        if (this.initialized)
+            listener(this.getSummary());
+        return () => this.listeners.delete(listener);
+    }
+    getSummary() {
+        const entries = cameraRollExportLedger
+            .list()
+            // Exported receipts with no local row are hidden deduplication tombstones. Unexported
+            // missing generations remain user-visible so data that can no longer be backfilled is
+            // never reported as successfully saved.
+            .filter((entry) => entry.localPresent !== false || entry.state === "MISSING_LOCAL");
+        const pendingStates = new Set([
+            "LEGACY_UNKNOWN",
+            "QUEUED",
+            "RECONCILING",
+            "EXPORTING",
+            "FAILED_RETRYABLE",
+            "BLOCKED_PERMISSION",
+        ]);
+        return {
+            enabled: this.enabled,
+            total: entries.length,
+            exported: entries.filter((entry) => entry.state === "EXPORTED").length,
+            pending: entries.filter((entry) => pendingStates.has(entry.state)).length,
+            failed: entries.filter((entry) => entry.state === "FAILED_RETRYABLE" || entry.state === "FAILED_PERMANENT")
+                .length,
+            blockedPermission: entries.filter((entry) => entry.state === "BLOCKED_PERMISSION").length,
+            fullAccessRequired: entries.filter((entry) => entry.state === "BLOCKED_PERMISSION" && entry.requiresFullLibraryReconciliation).length,
+            missing: entries.filter((entry) => entry.state === "MISSING_LOCAL").length,
+            bytesPending: entries
+                .filter((entry) => pendingStates.has(entry.state))
+                .reduce((sum, entry) => sum + entry.size, 0),
+            isRunning: this.running,
+        };
+    }
+    async countNotExported(mediaNames) {
+        await this.initialize();
+        const uniqueNames = [...new Set(mediaNames)];
+        if (uniqueNames.length === 0)
+            return 0;
+        const files = await localStorageService.getDownloadedFiles();
+        return uniqueNames.filter((name) => {
+            const file = files[name];
+            if (!file)
+                return true;
+            const entry = cameraRollExportLedger.get(cameraRollEntryId(file.name, file.size, file.modified));
+            return entry?.state !== "EXPORTED";
+        }).length;
+    }
+    /** Serialize local deletion against an in-flight native copy of the same item. */
+    async deleteLocalMedia(mediaName) {
+        this.deletingMediaNames.add(mediaName);
+        try {
+            while (this.activeEntryId && cameraRollExportLedger.get(this.activeEntryId)?.mediaName === mediaName) {
+                await new Promise((resolve) => BgTimer.setTimeout(resolve, 25));
+            }
+            const deleted = await localStorageService.deleteDownloadedFile(mediaName);
+            if (deleted) {
+                // An already-running export gets to finish and resolve its source barrier. Queued work
+                // cannot start while the name is in deletingMediaNames, so reject only after deletion
+                // is confirmed. A failed delete leaves the barrier intact and eligible for retry.
+                for (const entry of cameraRollExportLedger.list().filter((candidate) => candidate.mediaName === mediaName)) {
+                    this.rejectSourceWaiters(entry.id, new Error("Local media was deleted before camera-roll export"));
+                }
+                cameraRollExportLedger.removeForMedia(mediaName);
+            }
+            return deleted;
+        }
+        finally {
+            this.deletingMediaNames.delete(mediaName);
+            this.emitSummary();
+            if (this.enabled)
+                void this.resume("local deletion finished");
+        }
+    }
+    /** Stop scheduling exports, finish the current native copy, then atomically clear app media + receipts. */
+    async clearLocalMedia() {
+        this.clearInProgress = true;
+        try {
+            while (this.activeEntryId) {
+                await new Promise((resolve) => BgTimer.setTimeout(resolve, 25));
+            }
+            await localStorageService.clearAllFiles();
+            // Let the active native copy deliver its receipt before rejecting queued barriers, and
+            // reject them only after the app media clear is confirmed. If clear fails, the durable
+            // work and its waiters remain eligible for retry.
+            for (const entry of cameraRollExportLedger.list()) {
+                this.rejectSourceWaiters(entry.id, new Error("Local media was deleted before camera-roll export"));
+            }
+            cameraRollExportLedger.clear();
+        }
+        finally {
+            this.clearInProgress = false;
+            this.emitSummary();
+            if (this.enabled)
+                void this.resume("local clear finished");
+        }
+    }
+    nextEntry() {
+        const now = Date.now();
+        return cameraRollExportLedger
+            .list()
+            .filter((entry) => {
+            if (entry.localPresent === false)
+                return false;
+            if (this.clearInProgress || this.deletingMediaNames.has(entry.mediaName))
+                return false;
+            if (entry.receipt || entry.state === "EXPORTED" || entry.state === "MISSING_LOCAL")
+                return false;
+            if (!this.enabled)
+                return false;
+            if (entry.state === "BLOCKED_PERMISSION" || entry.state === "FAILED_PERMANENT")
+                return false;
+            if (entry.state === "FAILED_RETRYABLE" && (entry.nextRetryAt || 0) > now)
+                return false;
+            return entry.state !== "NOT_REQUESTED";
+        })
+            .sort((a, b) => {
+            if (a.priority !== b.priority)
+                return a.priority === "SOURCE_BARRIER" ? -1 : 1;
+            return a.modified - b.modified;
+        })[0];
+    }
+    async processEntry(original, generation) {
+        let entry = original;
+        this.activeEntryId = entry.id;
+        try {
+            if (!this.enabled) {
+                cameraRollExportLedger.update(entry.id, { state: "NOT_REQUESTED", nextRetryAt: undefined });
+                this.rejectSourceWaiters(entry.id, new Error("Automatic camera-roll saving was disabled"));
+                return;
+            }
+            const exists = await RNFS.exists(entry.filePath);
+            if (generation !== this.lifecycleGeneration)
+                return;
+            if (!exists) {
+                cameraRollExportLedger.update(entry.id, { state: "MISSING_LOCAL", lastError: "Local media is missing" });
+                throw new Error("Local media is missing");
+            }
+            const permission = await MediaLibraryPermissions.checkPermission();
+            if (generation !== this.lifecycleGeneration)
+                return;
+            if (!permission) {
+                cameraRollExportLedger.update(entry.id, {
+                    state: "BLOCKED_PERMISSION",
+                    lastError: "Camera-roll permission is required",
+                });
+                throw new Error("Camera-roll permission is required");
+            }
+            const hasLimitedAccess = entry.requiresFullLibraryReconciliation && (await MediaLibraryPermissions.hasLimitedAccess());
+            if (generation !== this.lifecycleGeneration)
+                return;
+            if (hasLimitedAccess) {
+                cameraRollExportLedger.update(entry.id, {
+                    state: "BLOCKED_PERMISSION",
+                    lastError: "Full photo-library access is required to reconcile this legacy export safely",
+                });
+                throw new Error("Full photo-library access is required to reconcile this legacy export safely");
+            }
+            const fsInfo = await RNFS.getFSInfo();
+            if (generation !== this.lifecycleGeneration)
+                return;
+            if (fsInfo.freeSpace < entry.size + MIN_FREE_SPACE_BYTES) {
+                throw new Error("Insufficient free space for camera-roll export");
+            }
+            // A setting change can land while the filesystem and permission checks are in flight.
+            // Once the native save starts it must finish atomically, but do not begin a new save
+            // after the user has disabled automatic camera-roll exports.
+            if (!this.enabled) {
+                cameraRollExportLedger.update(entry.id, { state: "NOT_REQUESTED", nextRetryAt: undefined });
+                this.rejectSourceWaiters(entry.id, new Error("Automatic camera-roll saving was disabled"));
+                return;
+            }
+            entry = cameraRollExportLedger.update(entry.id, { state: "RECONCILING", lastError: undefined });
+            entry = cameraRollExportLedger.update(entry.id, { state: "EXPORTING" });
+            const result = await MediaLibraryPermissions.saveToLibraryWithReceipt(entry.filePath, entry.modified);
+            if (!result.success)
+                throw new Error(result.error || "Camera-roll export failed");
+            const receipt = {
+                platform: result.platform,
+                uri: result.uri,
+                identifier: result.identifier,
+                exportedAt: Date.now(),
+            };
+            entry = cameraRollExportLedger.update(entry.id, {
+                state: "EXPORTED",
+                receipt,
+                requiresFullLibraryReconciliation: false,
+                attempts: entry.attempts + 1,
+                nextRetryAt: undefined,
+                lastError: undefined,
+            });
+            try {
+                await this.mirrorReceipt(entry, receipt);
+            }
+            catch (mirrorError) {
+                // The per-generation ledger is the authoritative durable receipt. A secondary
+                // metadata mirror failure must not cause a duplicate insert or block source ack.
+                console.warn(`${TAG} Export receipt mirror failed for ${entry.mediaName}:`, mirrorError);
+            }
+            this.resolveSourceWaiters(entry.id, receipt);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const current = cameraRollExportLedger.get(entry.id);
+            if (current && current.state !== "BLOCKED_PERMISSION" && current.state !== "MISSING_LOCAL") {
+                const attempts = current.attempts + 1;
+                cameraRollExportLedger.update(entry.id, {
+                    state: "FAILED_RETRYABLE",
+                    attempts,
+                    lastError: message,
+                    nextRetryAt: Date.now() + Math.min(2 ** Math.min(attempts, 10) * 1000, MAX_RETRY_DELAY_MS),
+                });
+            }
+            this.rejectSourceWaiters(entry.id, error instanceof Error ? error : new Error(message));
+            console.warn(`${TAG} Export remains pending for ${entry.mediaName}: ${message}`);
+        }
+        finally {
+            if (this.activeEntryId === entry.id)
+                this.activeEntryId = null;
+            if (generation === this.lifecycleGeneration)
+                this.emitSummary();
+        }
+    }
+    async mirrorReceipt(entry, receipt) {
+        await localStorageService.updateDownloadedFileAssetReceipt(entry.mediaName, receipt);
+        const transfer = entry.captureId
+            ? galleryTransferLedger.get(entry.captureId)
+            : galleryTransferLedger.get(entry.mediaName);
+        if (transfer)
+            galleryTransferLedger.update(transfer.captureId, { assetReceipt: receipt });
+    }
+    scheduleRetry() {
+        if (!this.enabled || this.retryTimer != null)
+            return;
+        const next = cameraRollExportLedger
+            .list()
+            .filter((entry) => entry.state === "FAILED_RETRYABLE" && entry.nextRetryAt)
+            .sort((a, b) => (a.nextRetryAt || 0) - (b.nextRetryAt || 0))[0];
+        if (!next?.nextRetryAt)
+            return;
+        const generation = this.lifecycleGeneration;
+        this.retryTimer = BgTimer.setTimeout(() => {
+            this.retryTimer = null;
+            if (generation !== this.lifecycleGeneration)
+                return;
+            void this.resume("retry timer");
+        }, Math.max(0, next.nextRetryAt - Date.now()));
+    }
+    resolveSourceWaiters(id, receipt) {
+        for (const waiter of this.sourceWaiters.get(id) || [])
+            waiter.resolve(receipt);
+        this.sourceWaiters.delete(id);
+    }
+    rejectSourceWaiters(id, error) {
+        for (const waiter of this.sourceWaiters.get(id) || [])
+            waiter.reject(error);
+        this.sourceWaiters.delete(id);
+    }
+    emitSummary() {
+        const summary = this.getSummary();
+        for (const listener of this.listeners) {
+            try {
+                listener(summary);
+            }
+            catch (error) {
+                console.warn(`${TAG} Summary listener failed`, error);
+            }
+        }
+    }
+}
+export const cameraRollExportCoordinator = new CameraRollExportCoordinator();
+//# sourceMappingURL=cameraRollExportCoordinator.js.map