@bota.dev/web-app-sdk 2.0.0-beta.0

package/dist/recordingManager.js

@@ -0,0 +1,1397 @@
+import { BotaSDKError, normalizeCoreError, } from "./errors.js";
+import { BOTA_STORAGE_SERVICE, DEVICE_INFORMATION_SERVICE, ENCRYPTED_UPLOAD_V2_CAPABILITY_CHARACTERISTIC, RECORDING_LIST_CHARACTERISTIC, SERIAL_NUMBER_CHARACTERISTIC, TRANSFER_CONTROL_CHARACTERISTIC, } from "./gatt.js";
+import { EncryptedUploadV2Host, EncryptedUploadV2TransferControl, parsePersistedEncryptedUploadV2State, } from "./encryptedUploadV2Host.js";
+import { awaitProviderCall } from "./providerCancellation.js";
+import { BrowserStorageError, } from "./storage.js";
+import { BrowserTransportError, } from "./transport.js";
+import { createBrowserPersistenceHost, } from "./workflowRuntime.js";
+const OPFS_STREAM_CHUNK_SIZE = 64 * 1024;
+export class RecordingManager {
+    core;
+    transport;
+    runtime;
+    devices;
+    storage;
+    uploadProvider;
+    fetcher;
+    now;
+    activeOperations = new Map();
+    destroyed = false;
+    destroyPromise = null;
+    constructor(core, transport, runtime, devices, storage, uploadProvider, fetcher = globalThis.fetch.bind(globalThis), now = Date.now) {
+        this.core = core;
+        this.transport = transport;
+        this.runtime = runtime;
+        this.devices = devices;
+        this.storage = storage;
+        this.uploadProvider = uploadProvider;
+        this.fetcher = fetcher;
+        this.now = now;
+    }
+    async list() {
+        return await this.listWithSignal();
+    }
+    async listWithSignal(externalSignal) {
+        this.ensureAvailable('transfer_recording');
+        return await this.withVerifiedConnection('transfer_recording', async ({ device }, signal) => {
+            const capability = await this.readOptionalV2Capability(device, signal);
+            if (capability
+                && this.core.supportsEncryptedUploadV2Batch(capability)) {
+                const control = new EncryptedUploadV2TransferControl(this.core, this.transport, device, () => this.runtime.poisonBleOwnership(device.id));
+                const listed = await control.list(randomTransportSessionId(), signal);
+                return listed.entries.map(encryptedDeviceRecording);
+            }
+            let subscription = null;
+            const notification = deferred();
+            let received = false;
+            try {
+                subscription = await this.transport.subscribe(device, BOTA_STORAGE_SERVICE, RECORDING_LIST_CHARACTERISTIC, ({ characteristicUuid, value }) => {
+                    if (received
+                        || characteristicUuid.toLowerCase()
+                            !== RECORDING_LIST_CHARACTERISTIC) {
+                        return;
+                    }
+                    received = true;
+                    notification.resolve(value.slice());
+                });
+                throwIfAborted(signal, 'transfer_recording');
+                await awaitWithSignal(this.transport.write(device, BOTA_STORAGE_SERVICE, TRANSFER_CONTROL_CHARACTERISTIC, this.core.encodeRecordingListCommand(), true), signal, 'transfer_recording');
+                const bytes = await awaitWithSignal(notification.promise, signal, 'transfer_recording');
+                try {
+                    return this.core.decodeRecordingList(bytes).map(deviceRecording);
+                }
+                catch {
+                    throw new BotaSDKError('protocol_error', 'transfer_recording');
+                }
+            }
+            finally {
+                await subscription?.remove();
+            }
+        }, externalSignal);
+    }
+    async sync(recording, options) {
+        this.ensureAvailable('transfer_recording');
+        if (options.profile === 'encrypted_upload_v2') {
+            validateEncryptedUploadV2Recording(recording);
+            const operationId = options.operationId ?? createOperationId();
+            validateOperationId(operationId);
+            throwIfAborted(options.signal, 'transfer_recording');
+            return await this.runManagedOperation(operationId, options.signal, async (signal) => await this.startEncryptedUploadV2(operationId, recording, signal, options.onProgress));
+        }
+        if (options.profile !== 'legacy') {
+            throw new BotaSDKError('invalid_input', 'transfer_recording');
+        }
+        validateRecording(recording);
+        const storage = this.requireStorage();
+        this.requireUploadProvider();
+        throwIfAborted(options.signal, 'transfer_recording');
+        const operationId = options.operationId ?? createOperationId();
+        validateOperationId(operationId);
+        return await this.runManagedOperation(operationId, options.signal, async (signal) => {
+            const existing = await storage.loadRecordingJournal(operationId);
+            throwIfAborted(signal, 'transfer_recording');
+            if (existing) {
+                throw new BotaSDKError('resume_rejected', 'transfer_recording');
+            }
+            const connection = await this.verifyConnection(signal);
+            throwIfAborted(signal, 'transfer_recording');
+            const prepared = {
+                schemaVersion: 1,
+                operationId,
+                serialNumber: connection.serialNumber,
+                recordingUuid: recording.uuid,
+                profile: 'legacy',
+                phase: 'prepared',
+                sinkId: sinkId(operationId),
+                uploadId: null,
+                cloudCompletionId: null,
+                confirmationDigestHex: null,
+                devicePlaintextSha256Hex: null,
+                updatedAtEpochMs: this.now(),
+            };
+            try {
+                await storage.saveRecordingJournal(prepared);
+                throwIfAborted(signal, 'transfer_recording');
+                return await this.transferLegacy(prepared, recording, signal, options.onProgress);
+            }
+            catch (error) {
+                const normalized = recordingError(error, 'transfer_recording');
+                if (normalized.code === 'cancelled') {
+                    const current = await storage.loadRecordingJournal(operationId)
+                        .catch(() => null);
+                    if (current) {
+                        await this.deleteUnverifiedState(current).catch(() => undefined);
+                    }
+                }
+                throw normalized;
+            }
+        });
+    }
+    async resume(operationId, options = {}) {
+        this.ensureAvailable('transfer_recording');
+        validateOperationId(operationId);
+        const storage = this.requireStorage();
+        this.requireUploadProvider();
+        throwIfAborted(options.signal, 'transfer_recording');
+        return await this.runManagedOperation(operationId, options.signal, async (signal) => {
+            try {
+                const journal = await storage.loadRecordingJournal(operationId);
+                throwIfAborted(signal, 'transfer_recording');
+                if (!journal) {
+                    throw new BotaSDKError('resume_rejected', 'transfer_recording');
+                }
+                if (journal.profile === 'encrypted_upload_v2') {
+                    if (journal.phase === 'confirmed') {
+                        return await this.finishConfirmedJournal(journal);
+                    }
+                    return await this.resumeEncryptedUploadV2(journal, signal, options.onProgress);
+                }
+                if (journal.profile !== 'legacy') {
+                    throw new BotaSDKError('resume_rejected', 'transfer_recording');
+                }
+                if (journal.phase === 'confirmed') {
+                    return await this.finishConfirmedJournal(journal);
+                }
+                if (journal.phase === 'cloud_completed') {
+                    return await this.confirmJournal(journal, signal);
+                }
+                const connected = this.requireConnectedDevice();
+                if (connected.serialNumber !== journal.serialNumber) {
+                    throw new BotaSDKError('identity_mismatch', 'transfer_recording');
+                }
+                const recordings = await this.listWithSignal(signal);
+                throwIfAborted(signal, 'transfer_recording');
+                const recording = recordings.find(({ uuid }) => uuid === journal.recordingUuid);
+                if (!recording) {
+                    throw new BotaSDKError('resume_rejected', 'transfer_recording');
+                }
+                validateRecording(recording);
+                switch (journal.phase) {
+                    case 'prepared':
+                    case 'transferring':
+                        return await this.transferLegacy(journal, recording, signal, options.onProgress);
+                    case 'staged':
+                        return await this.uploadStaged(journal, recording, signal);
+                    case 'uploading':
+                        return await this.reconcileUpload(journal, recording, signal);
+                }
+            }
+            catch (error) {
+                const normalized = recordingError(error, 'transfer_recording');
+                if (normalized.code === 'cancelled') {
+                    const current = await storage.loadRecordingJournal(operationId)
+                        .catch(() => null);
+                    if (current) {
+                        await this.deleteUnverifiedState(current).catch(() => undefined);
+                    }
+                }
+                throw normalized;
+            }
+        });
+    }
+    async cancel(operationId) {
+        this.ensureAvailable('transfer_recording');
+        validateOperationId(operationId);
+        const active = this.activeOperations.get(operationId);
+        if (active) {
+            active.controller.abort();
+            await this.runtime.cancel(operationId);
+            await active.settled.promise;
+            return;
+        }
+        const storage = this.requireStorage();
+        const journal = await storage.loadRecordingJournal(operationId);
+        if (!journal)
+            return;
+        if ((journal.profile === 'legacy'
+            || journal.profile === 'encrypted_upload_v2')
+            && (journal.phase === 'prepared' || journal.phase === 'transferring')) {
+            await this.deleteUnverifiedState(journal);
+        }
+    }
+    async confirm(operationId) {
+        this.ensureAvailable('upload');
+        validateOperationId(operationId);
+        const storage = this.requireStorage();
+        await this.runManagedOperation(operationId, undefined, async (signal) => {
+            const journal = await storage.loadRecordingJournal(operationId);
+            throwIfAborted(signal, 'upload');
+            if (!journal)
+                throw new BotaSDKError('resume_rejected', 'upload');
+            if (journal.profile === 'encrypted_upload_v2') {
+                if (journal.phase !== 'cloud_completed') {
+                    throw new BotaSDKError('resume_rejected', 'upload');
+                }
+                await this.resumeEncryptedUploadV2(journal, signal);
+                return;
+            }
+            if (journal.profile !== 'legacy') {
+                throw new BotaSDKError('resume_rejected', 'upload');
+            }
+            if (journal.phase === 'confirmed') {
+                await this.finishConfirmedJournal(journal);
+                return;
+            }
+            if (journal.phase !== 'cloud_completed') {
+                throw new BotaSDKError('resume_rejected', 'upload');
+            }
+            await this.confirmJournal(journal, signal);
+        }, 'upload');
+    }
+    async listPendingOperations() {
+        this.ensureAvailable('upload');
+        return (await this.requireStorage().listRecordingJournals()).map((journal) => ({
+            operationId: journal.operationId,
+            serialNumber: journal.serialNumber,
+            recordingUuid: journal.recordingUuid,
+            profile: journal.profile,
+            phase: journal.phase,
+            updatedAtEpochMs: journal.updatedAtEpochMs,
+        }));
+    }
+    destroy() {
+        if (this.destroyPromise)
+            return this.destroyPromise;
+        this.destroyed = true;
+        this.destroyPromise = (async () => {
+            const active = [...this.activeOperations.entries()];
+            for (const [operationId, operation] of active) {
+                operation.controller.abort();
+                await this.runtime.cancel(operationId);
+            }
+            await Promise.all(active.map(([, operation]) => operation.settled.promise));
+        })();
+        return this.destroyPromise;
+    }
+    async startEncryptedUploadV2(operationId, recording, signal, onProgress) {
+        const storage = this.requireStorage();
+        const provider = this.requireUploadProvider();
+        if (await storage.loadRecordingJournal(operationId)) {
+            throw new BotaSDKError('resume_rejected', 'transfer_recording');
+        }
+        const capability = await this.readFreshV2Capability(signal);
+        const metadata = requireEncryptedUploadV2Metadata(recording);
+        this.core.validateEncryptedUploadV2Profile(capability.decoded, metadata.generation, metadata.storageFormat);
+        const bounds = negotiatedEncryptedUploadV2Bounds(capability.decoded, this.transport.maximumWriteValueLength);
+        const journal = {
+            schemaVersion: 1,
+            operationId,
+            serialNumber: capability.connection.serialNumber,
+            recordingUuid: recording.uuid,
+            profile: 'encrypted_upload_v2',
+            phase: 'prepared',
+            sinkId: sinkId(operationId),
+            uploadId: null,
+            cloudCompletionId: null,
+            confirmationDigestHex: null,
+            devicePlaintextSha256Hex: null,
+            updatedAtEpochMs: this.now(),
+        };
+        const providerContext = {
+            operationId,
+            serialNumber: capability.connection.serialNumber,
+            recording: {
+                uuid: recording.uuid,
+                generation: metadata.generation,
+                storageFormat: metadata.storageFormat,
+                ciphertextLength: metadata.ciphertextLength,
+                ciphertextSha256: metadata.ciphertextSha256.slice(),
+            },
+            capability: {
+                rawValue: capability.raw.slice(),
+                sha256: capability.sha256.slice(),
+                decoded: { ...capability.decoded },
+            },
+            checkpoint: null,
+            signal,
+        };
+        const material = await this.prepareEncryptedUploadV2Material(provider, providerContext, signal);
+        let materialOwnedHere = true;
+        try {
+            throwIfAborted(signal, 'transfer_recording');
+            validateEncryptedUploadV2Material(material, capability.decoded);
+            const state = {
+                schemaVersion: 1,
+                operationId,
+                serialNumber: journal.serialNumber,
+                recording: {
+                    ...providerContext.recording,
+                    ciphertextSha256: providerContext.recording.ciphertextSha256.slice(),
+                },
+                materialId: material.materialId,
+                recordingId: material.recordingId,
+                uploadSessionId: material.uploadSessionId,
+                ownerRevision: material.ownerRevision,
+                policy: material.policy,
+                transportSessionId: randomTransportSessionId(),
+                sinkId: journal.sinkId,
+                windowPackets: bounds.windowPackets,
+                dataPayloadBytes: bounds.dataPayloadBytes,
+                maximumSignedBlobBytes: capability.decoded.maximumSignedBlobBytes,
+                maximumMissingSequences: bounds.maximumMissingSequences,
+                checkpointIntervalBlocks: capability.decoded.durableCheckpointIntervalBlocks,
+                capabilitySha256Hex: hex(capability.sha256),
+                coreCheckpoint: null,
+                highestContiguousSequence: null,
+                evidence: null,
+            };
+            await storage.saveEncryptedUploadV2Operation(operationId, state, journal);
+            throwIfAborted(signal, 'transfer_recording');
+            const transferring = await this.saveJournal(journal, {
+                phase: 'transferring',
+            });
+            throwIfAborted(signal, 'transfer_recording');
+            materialOwnedHere = false;
+            return await this.runEncryptedUploadV2(transferring, state, capability.decoded, material, signal, onProgress);
+        }
+        catch (error) {
+            if (materialOwnedHere) {
+                await destroyEncryptedUploadV2Material(material, signal)
+                    .catch(() => undefined);
+                const current = await storage.loadRecordingJournal(operationId)
+                    .catch(() => null);
+                if (current) {
+                    await this.deleteUnverifiedState(current).catch(() => undefined);
+                }
+            }
+            throw recordingError(error, 'transfer_recording');
+        }
+    }
+    async resumeEncryptedUploadV2(journal, signal, onProgress) {
+        const storage = this.requireStorage();
+        const rawState = await storage.loadEncryptedUploadV2Checkpoint(journal.operationId);
+        if (!rawState)
+            throw new BotaSDKError('resume_rejected', 'transfer_recording');
+        const state = parsePersistedEncryptedUploadV2State(rawState);
+        validateEncryptedUploadV2JournalState(journal, state);
+        const capability = await this.readFreshV2Capability(signal);
+        if (capability.connection.serialNumber !== state.serialNumber
+            || hex(capability.sha256) !== state.capabilitySha256Hex)
+            throw new BotaSDKError('integrity_failed', 'transfer_recording');
+        this.core.validateEncryptedUploadV2Profile(capability.decoded, state.recording.generation, state.recording.storageFormat);
+        const bounds = negotiatedEncryptedUploadV2Bounds(capability.decoded, this.transport.maximumWriteValueLength);
+        if (bounds.windowPackets !== state.windowPackets
+            || bounds.dataPayloadBytes !== state.dataPayloadBytes
+            || bounds.maximumMissingSequences !== state.maximumMissingSequences)
+            throw new BotaSDKError('integrity_failed', 'transfer_recording');
+        const provider = this.requireUploadProvider();
+        const material = await this.prepareEncryptedUploadV2Material(provider, {
+            operationId: state.operationId,
+            serialNumber: state.serialNumber,
+            recording: {
+                ...state.recording,
+                ciphertextSha256: state.recording.ciphertextSha256.slice(),
+            },
+            capability: {
+                rawValue: capability.raw.slice(),
+                sha256: capability.sha256.slice(),
+                decoded: { ...capability.decoded },
+            },
+            checkpoint: encryptedUploadV2CheckpointSummary(state),
+            signal,
+        }, signal);
+        let materialOwnedHere = true;
+        try {
+            throwIfAborted(signal, 'transfer_recording');
+            validateEncryptedUploadV2Material(material, capability.decoded, state);
+            materialOwnedHere = false;
+            return await this.runEncryptedUploadV2(journal, state, capability.decoded, material, signal, onProgress);
+        }
+        catch (error) {
+            if (materialOwnedHere) {
+                await destroyEncryptedUploadV2Material(material, signal)
+                    .catch(() => undefined);
+            }
+            throw recordingError(error, 'transfer_recording');
+        }
+    }
+    async runEncryptedUploadV2(initialJournal, state, capabilities, material, signal, onProgress) {
+        const storage = this.requireStorage();
+        let host = null;
+        let workflowCompleted = false;
+        try {
+            throwIfAborted(signal, 'transfer_recording');
+            const connection = this.requireConnectedDevice();
+            if (connection.serialNumber !== state.serialNumber) {
+                throw new BotaSDKError('identity_mismatch', 'transfer_recording');
+            }
+            const blob = await storage.openBlob(state.sinkId);
+            throwIfAborted(signal, 'transfer_recording');
+            let journal = initialJournal;
+            const savePhase = async (phase, update = {}) => {
+                if (recordingPhaseIndex(journal.phase) > recordingPhaseIndex(phase))
+                    return;
+                journal = await this.saveJournal(journal, { phase, ...update });
+            };
+            host = new EncryptedUploadV2Host({
+                core: this.core,
+                transport: this.transport,
+                device: connection.device,
+                storage,
+                blob,
+                material,
+                state,
+                fetcher: this.fetcher,
+                recoveryPhase: journal.phase === 'confirmed'
+                    ? 'cloud_completed'
+                    : journal.phase,
+                expectedReceiptSha256Hex: journal.confirmationDigestHex,
+                onOwnershipUncertain: () => {
+                    this.runtime.poisonBleOwnership(connection.device.id);
+                },
+                callbacks: {
+                    transferCompleted: async (evidence) => {
+                        await savePhase('staged');
+                        onProgress?.({
+                            phase: 'staged',
+                            completedBytes: evidence.ciphertextLength,
+                            totalBytes: state.recording.ciphertextLength,
+                        });
+                    },
+                    uploading: async () => {
+                        await savePhase('uploading', { uploadId: state.materialId });
+                    },
+                    cloudCompleted: async (receiptSha256) => {
+                        await savePhase('cloud_completed', {
+                            uploadId: state.materialId,
+                            cloudCompletionId: state.recordingId,
+                            confirmationDigestHex: hex(receiptSha256),
+                        });
+                    },
+                    confirmed: async () => {
+                        await savePhase('confirmed', {
+                            uploadId: state.materialId,
+                            cloudCompletionId: state.recordingId,
+                        });
+                    },
+                },
+            });
+            const cancellationId = randomCancellationId();
+            await this.runtime.run(state.operationId, cancellationId, () => this.core.startEncryptedUploadV2({
+                serialNumber: state.serialNumber,
+                recordingUuid: state.recording.uuid,
+                recordingGeneration: state.recording.generation,
+                storageFormat: state.recording.storageFormat,
+                uploadSessionId: state.uploadSessionId,
+                ownerRevision: state.ownerRevision,
+                transportSessionId: state.transportSessionId,
+                materialId: state.materialId,
+                sinkId: state.sinkId,
+                policy: state.policy,
+                capabilities,
+                windowPackets: state.windowPackets,
+                dataPayloadBytes: state.dataPayloadBytes,
+                ciphertextLength: state.recording.ciphertextLength,
+                ciphertextSha256: state.recording.ciphertextSha256.slice(),
+                cancellationId,
+            }), {
+                persistence: createBrowserPersistenceHost(storage),
+                encryptedUploadV2: host,
+            }, {
+                onProgress: (completedBytes, totalBytes) => {
+                    onProgress?.({
+                        phase: 'transferring',
+                        completedBytes,
+                        totalBytes,
+                    });
+                },
+            });
+            workflowCompleted = true;
+            const confirmed = await storage.loadRecordingJournal(state.operationId);
+            if (!confirmed || confirmed.phase !== 'confirmed') {
+                throw new BotaSDKError('internal_error', 'transfer_recording');
+            }
+            return await this.finishConfirmedJournal(confirmed);
+        }
+        catch (error) {
+            if (!workflowCompleted) {
+                if (host) {
+                    const confirmationAttempted = await host
+                        .confirmationAttemptedOrClaimCancellation()
+                        .catch(() => true);
+                    if (!confirmationAttempted) {
+                        await host.cancel().catch(() => undefined);
+                    }
+                }
+                else {
+                    await destroyEncryptedUploadV2Material(material, signal)
+                        .catch(() => undefined);
+                }
+            }
+            const normalized = recordingError(error, 'transfer_recording');
+            if (normalized.code === 'cancelled') {
+                const current = await storage.loadRecordingJournal(state.operationId)
+                    .catch(() => null);
+                if (current) {
+                    await this.deleteUnverifiedState(current).catch(() => undefined);
+                }
+            }
+            throw normalized;
+        }
+    }
+    async prepareEncryptedUploadV2Material(provider, context, signal) {
+        let pending = null;
+        try {
+            pending = provider.prepareEncryptedUploadV2(context);
+            return await awaitProviderCall(pending, signal, 'upload');
+        }
+        catch (error) {
+            if (signal.aborted && pending) {
+                void pending.then(async (material) => {
+                    await destroyEncryptedUploadV2Material(material, signal)
+                        .catch(() => undefined);
+                }, () => undefined);
+            }
+            throw uploadError(error, signal);
+        }
+    }
+    async readFreshV2Capability(signal) {
+        return await this.withVerifiedConnection('transfer_recording', async (connection, runtimeSignal) => {
+            const raw = await awaitWithSignal(this.transport.read(connection.device, BOTA_STORAGE_SERVICE, ENCRYPTED_UPLOAD_V2_CAPABILITY_CHARACTERISTIC), runtimeSignal, 'transfer_recording');
+            const decoded = this.core.decodeEncryptedUploadV2Capabilities(raw);
+            return {
+                connection,
+                raw: raw.slice(),
+                sha256: hashBytes(this.core, raw),
+                decoded,
+            };
+        }, signal);
+    }
+    async readOptionalV2Capability(device, signal) {
+        let raw;
+        try {
+            raw = await awaitWithSignal(this.transport.read(device, BOTA_STORAGE_SERVICE, ENCRYPTED_UPLOAD_V2_CAPABILITY_CHARACTERISTIC), signal, 'transfer_recording');
+        }
+        catch (error) {
+            if (error instanceof BrowserTransportError
+                && error.code === 'characteristic_not_found')
+                return null;
+            throw error;
+        }
+        return this.core.decodeEncryptedUploadV2Capabilities(raw);
+    }
+    async transferLegacy(journal, recording, signal, onProgress) {
+        const storage = this.requireStorage();
+        throwIfAborted(signal, 'transfer_recording');
+        await storage.deleteWorkflowCheckpoint(journal.operationId);
+        throwIfAborted(signal, 'transfer_recording');
+        const blob = await storage.openBlob(journal.sinkId);
+        throwIfAborted(signal, 'transfer_recording');
+        const currentSizeValue = await blob.size();
+        throwIfAborted(signal, 'transfer_recording');
+        const currentSize = safeBrowserNumber(currentSizeValue, 'transfer_recording');
+        if (currentSize > 0) {
+            await blob.truncate(0);
+            throwIfAborted(signal, 'transfer_recording');
+        }
+        const transferring = await this.saveJournal(journal, {
+            phase: 'transferring',
+            uploadId: null,
+            cloudCompletionId: null,
+        });
+        throwIfAborted(signal, 'transfer_recording');
+        const sink = createRecordingSinkHost(journal.sinkId, blob, () => this.core.createIntegrityHasher());
+        const cancellationId = randomCancellationId();
+        try {
+            const result = await this.runtime.run(journal.operationId, cancellationId, () => this.core.startRecordingTransfer({
+                serialNumber: journal.serialNumber,
+                recordingUuid: journal.recordingUuid,
+                sinkId: journal.sinkId,
+                totalUnits: recording.fileSizeBytes,
+                cancellationId,
+            }), {
+                persistence: createBrowserPersistenceHost(storage),
+                recordingSink: sink.host,
+            }, {
+                onProgress: (completedBytes, totalBytes) => {
+                    onProgress?.({
+                        phase: 'transferring',
+                        completedBytes,
+                        totalBytes,
+                    });
+                },
+            });
+            const completed = [...result.notifications].reverse().find((notification) => notification.kind === 'recording_transfer_completed');
+            if (!completed
+                || completed.kind !== 'recording_transfer_completed'
+                || !sink.state.finalized) {
+                throw new BotaSDKError('internal_error', 'transfer_recording');
+            }
+            const staged = await this.saveJournal(transferring, {
+                phase: 'staged',
+                devicePlaintextSha256Hex: completed.sha256
+                    ? hex(completed.sha256)
+                    : null,
+            });
+            onProgress?.({
+                phase: 'staged',
+                completedBytes: BigInt(safeBrowserNumber(await blob.size(), 'transfer_recording')),
+                totalBytes: recording.fileSizeBytes,
+            });
+            return await this.uploadStaged(staged, { ...recording, encrypted: completed.encrypted }, signal);
+        }
+        catch (error) {
+            const normalized = recordingError(error, 'transfer_recording');
+            if (normalized.code === 'cancelled' || normalized.code === 'integrity_failed') {
+                const current = await storage.loadRecordingJournal(journal.operationId)
+                    .catch(() => null);
+                if (current) {
+                    await this.deleteUnverifiedState(current).catch(() => undefined);
+                }
+            }
+            throw normalized;
+        }
+    }
+    async uploadStaged(journal, recording, signal) {
+        const storage = this.requireStorage();
+        const provider = this.requireUploadProvider();
+        const blob = await storage.openBlob(journal.sinkId);
+        const context = await this.legacyContext(journal, recording, blob, signal);
+        let prepared;
+        try {
+            prepared = await awaitProviderCall(provider.prepareLegacyUpload(context), signal, 'upload');
+        }
+        catch (error) {
+            throw uploadError(error, signal);
+        }
+        validateProviderIdentifier(prepared.uploadId);
+        validateUploadRequest(prepared.request);
+        const uploading = await this.saveJournal(journal, {
+            phase: 'uploading',
+            uploadId: prepared.uploadId,
+        });
+        try {
+            await this.uploadBlob(prepared.request, blob, signal);
+            const completion = await awaitProviderCall(provider.completeLegacyUpload({
+                ...context,
+                uploadId: prepared.uploadId,
+            }), signal, 'upload');
+            validateProviderIdentifier(completion.cloudCompletionId);
+            const cloudCompleted = await this.saveJournal(uploading, {
+                phase: 'cloud_completed',
+                cloudCompletionId: completion.cloudCompletionId,
+            });
+            return await this.confirmJournal(cloudCompleted, signal);
+        }
+        catch (error) {
+            throw uploadError(error, signal);
+        }
+    }
+    async reconcileUpload(journal, recording, signal) {
+        if (!journal.uploadId)
+            throw new BotaSDKError('resume_rejected', 'upload');
+        const provider = this.requireUploadProvider();
+        const blob = await this.requireStorage().openBlob(journal.sinkId);
+        const context = await this.legacyContext(journal, recording, blob, signal);
+        let reconciliation;
+        try {
+            reconciliation = await awaitProviderCall(provider.reconcileLegacyUpload({
+                ...context,
+                uploadId: journal.uploadId,
+            }), signal, 'upload');
+        }
+        catch (error) {
+            throw uploadError(error, signal);
+        }
+        if (reconciliation.state === 'cloud_completed') {
+            validateProviderIdentifier(reconciliation.cloudCompletionId);
+            const cloudCompleted = await this.saveJournal(journal, {
+                phase: 'cloud_completed',
+                cloudCompletionId: reconciliation.cloudCompletionId,
+            });
+            return await this.confirmJournal(cloudCompleted, signal);
+        }
+        if (reconciliation.state !== 'not_uploaded') {
+            throw new BotaSDKError('upload_failed', 'upload', { retryable: true });
+        }
+        const staged = await this.saveJournal(journal, {
+            phase: 'staged',
+            uploadId: null,
+        });
+        return await this.uploadStaged(staged, recording, signal);
+    }
+    async confirmJournal(journal, signal) {
+        if (journal.profile !== 'legacy'
+            || journal.phase !== 'cloud_completed'
+            || !journal.cloudCompletionId) {
+            throw new BotaSDKError('resume_rejected', 'upload');
+        }
+        throwIfAborted(signal, 'upload');
+        return await this.withVerifiedConnection('upload', async ({ device, serialNumber }, runtimeSignal) => {
+            if (serialNumber !== journal.serialNumber) {
+                throw new BotaSDKError('identity_mismatch', 'upload');
+            }
+            throwIfAborted(runtimeSignal, 'upload');
+            const write = this.transport.write(device, BOTA_STORAGE_SERVICE, TRANSFER_CONTROL_CHARACTERISTIC, this.core.encodeRecordingConfirm(journal.recordingUuid), true);
+            await write;
+            const confirmed = await this.saveJournal(journal, {
+                phase: 'confirmed',
+            });
+            return await this.finishConfirmedJournal(confirmed);
+        }, signal);
+    }
+    async finishConfirmedJournal(journal) {
+        if (journal.phase !== 'confirmed' || !journal.cloudCompletionId) {
+            throw new BotaSDKError('resume_rejected', 'upload');
+        }
+        const storage = this.requireStorage();
+        await (await storage.openBlob(journal.sinkId)).delete();
+        await storage.deleteWorkflowCheckpoint(journal.operationId);
+        if (journal.profile === 'encrypted_upload_v2') {
+            await storage.deleteEncryptedUploadV2Operation(journal.operationId);
+        }
+        else {
+            await storage.deleteRecordingJournal(journal.operationId);
+        }
+        return resultFromJournal(journal);
+    }
+    async legacyContext(journal, recording, blob, signal) {
+        const hasher = this.core.createIntegrityHasher();
+        let streamedSize = 0;
+        for await (const chunk of blob.stream(OPFS_STREAM_CHUNK_SIZE)) {
+            throwIfAborted(signal, 'upload');
+            streamedSize = safeBrowserRange(streamedSize, chunk.byteLength, 'upload');
+            hasher.update(chunk);
+        }
+        const reportedSize = safeBrowserNumber(await blob.size(), 'upload');
+        if (reportedSize !== streamedSize) {
+            throw new BotaSDKError('integrity_failed', 'upload');
+        }
+        return {
+            operationId: journal.operationId,
+            serialNumber: journal.serialNumber,
+            recording,
+            sizeBytes: BigInt(reportedSize),
+            plaintextSha256Hex: journal.devicePlaintextSha256Hex,
+            stagedBodySha256Hex: hex(hasher.sha256Snapshot()),
+            encrypted: recording.encrypted,
+            signal,
+        };
+    }
+    async uploadBlob(request, blob, signal) {
+        throwIfAborted(signal, 'upload');
+        const body = blobReadableStream(blob, signal);
+        const init = {
+            method: 'PUT',
+            headers: { ...request.headers },
+            body,
+            signal,
+            redirect: 'error',
+        };
+        if (fetchRequiresDuplex())
+            init.duplex = 'half';
+        const response = await awaitWithSignal(this.fetcher(request.url, init), signal, 'upload');
+        if (!response.ok) {
+            await response.body?.cancel().catch(() => undefined);
+            throw new BotaSDKError('upload_failed', 'upload', { retryable: true });
+        }
+    }
+    async saveJournal(journal, update) {
+        const next = {
+            ...journal,
+            phase: update.phase,
+            uploadId: update.uploadId === undefined
+                ? journal.uploadId
+                : update.uploadId,
+            cloudCompletionId: update.cloudCompletionId === undefined
+                ? journal.cloudCompletionId
+                : update.cloudCompletionId,
+            confirmationDigestHex: update.confirmationDigestHex === undefined
+                ? journal.confirmationDigestHex
+                : update.confirmationDigestHex,
+            devicePlaintextSha256Hex: update.devicePlaintextSha256Hex === undefined
+                ? journal.devicePlaintextSha256Hex
+                : update.devicePlaintextSha256Hex,
+            updatedAtEpochMs: Math.max(journal.updatedAtEpochMs, this.now()),
+        };
+        await this.requireStorage().saveRecordingJournal(next);
+        return next;
+    }
+    async deleteUnverifiedState(journal) {
+        if (journal.phase !== 'prepared' && journal.phase !== 'transferring')
+            return;
+        const storage = this.requireStorage();
+        if (journal.profile === 'encrypted_upload_v2') {
+            const rawState = await storage.loadEncryptedUploadV2Checkpoint(journal.operationId);
+            if (rawState) {
+                const state = parsePersistedEncryptedUploadV2State(rawState);
+                validateEncryptedUploadV2JournalState(journal, state);
+                state.coreCheckpoint = null;
+                state.highestContiguousSequence = null;
+                await storage.saveEncryptedUploadV2Checkpoint(journal.operationId, state);
+            }
+            await (await storage.openBlob(journal.sinkId)).delete();
+            await storage.deleteWorkflowCheckpoint(journal.operationId);
+            await storage.deleteEncryptedUploadV2Operation(journal.operationId);
+            return;
+        }
+        await (await storage.openBlob(journal.sinkId)).delete();
+        await storage.deleteWorkflowCheckpoint(journal.operationId);
+        await storage.deleteRecordingJournal(journal.operationId);
+    }
+    async verifyConnection(signal) {
+        throwIfAborted(signal, 'transfer_recording');
+        return await this.withVerifiedConnection('transfer_recording', async (connection, runtimeSignal) => {
+            throwIfAborted(runtimeSignal, 'transfer_recording');
+            return connection;
+        }, signal);
+    }
+    async withVerifiedConnection(operation, body, externalSignal) {
+        const connection = this.requireConnectedDevice();
+        try {
+            return await this.runtime.runExclusive(operation, async (signal) => {
+                const combinedSignal = combineSignals(externalSignal, signal);
+                throwIfAborted(combinedSignal, operation);
+                const current = this.requireConnectedDevice();
+                if (current.device.id !== connection.device.id) {
+                    throw new BotaSDKError('device_disconnected', operation);
+                }
+                const value = await awaitWithSignal(this.transport.read(current.device, DEVICE_INFORMATION_SERVICE, SERIAL_NUMBER_CHARACTERISTIC), combinedSignal, operation);
+                if (decodeSerial(value, operation) !== current.serialNumber) {
+                    throw new BotaSDKError('identity_mismatch', operation);
+                }
+                return await body(current, combinedSignal);
+            });
+        }
+        catch (error) {
+            const normalized = recordingError(error, operation);
+            if (normalized.code === 'identity_mismatch') {
+                await this.devices.disconnect().catch(() => undefined);
+            }
+            throw normalized;
+        }
+    }
+    requireConnectedDevice() {
+        const connected = this.devices.connectedDevice;
+        const device = this.runtime.connectedDeviceHandle;
+        if (!connected || !device || connected.id !== device.id) {
+            throw new BotaSDKError('device_disconnected', 'transfer_recording');
+        }
+        return { device, serialNumber: connected.serialNumber };
+    }
+    async runManagedOperation(operationId, externalSignal, body, operation = 'transfer_recording') {
+        this.ensureAvailable(operation);
+        if (this.activeOperations.has(operationId)) {
+            throw new BotaSDKError('operation_in_progress', operation);
+        }
+        throwIfAborted(externalSignal, operation);
+        const controller = new AbortController();
+        const settled = deferred();
+        const abort = () => controller.abort();
+        const cancelRuntime = () => {
+            void this.runtime.cancel(operationId).catch(() => undefined);
+        };
+        externalSignal?.addEventListener('abort', abort, { once: true });
+        controller.signal.addEventListener('abort', cancelRuntime, { once: true });
+        if (externalSignal?.aborted)
+            controller.abort();
+        const active = {
+            controller,
+            settled,
+            removeExternalAbort: () => externalSignal?.removeEventListener('abort', abort),
+        };
+        this.activeOperations.set(operationId, active);
+        try {
+            return await body(controller.signal);
+        }
+        finally {
+            active.removeExternalAbort();
+            controller.signal.removeEventListener('abort', cancelRuntime);
+            if (this.activeOperations.get(operationId) === active) {
+                this.activeOperations.delete(operationId);
+            }
+            settled.resolve(undefined);
+        }
+    }
+    requireStorage() {
+        if (!this.storage)
+            throw new BotaSDKError('storage_unavailable', 'upload');
+        return this.storage;
+    }
+    requireUploadProvider() {
+        if (!this.uploadProvider) {
+            throw new BotaSDKError('unsupported_capability', 'upload');
+        }
+        return this.uploadProvider;
+    }
+    ensureAvailable(operation) {
+        if (this.destroyed)
+            throw new BotaSDKError('cancelled', operation);
+    }
+}
+function createRecordingSinkHost(sinkId, blob, createHasher) {
+    const state = {
+        hasher: createHasher(),
+        finalized: false,
+    };
+    const host = {
+        execute: async (envelope) => {
+            const effect = envelope.effect;
+            try {
+                switch (effect.kind) {
+                    case 'recording_sink_truncate': {
+                        assertSink(effect.sinkId, sinkId);
+                        const size = safeBrowserBigint(effect.completedUnits, 'transfer_recording');
+                        await blob.truncate(size);
+                        state.hasher = createHasher();
+                        let restored = 0;
+                        for await (const chunk of blob.stream(OPFS_STREAM_CHUNK_SIZE)) {
+                            restored = safeBrowserRange(restored, chunk.byteLength, 'transfer_recording');
+                            state.hasher.update(chunk);
+                        }
+                        if (restored !== size) {
+                            return sinkFailure(envelope.requestId);
+                        }
+                        return {
+                            requestId: envelope.requestId,
+                            kind: 'recording_sink_truncated',
+                        };
+                    }
+                    case 'recording_sink_append': {
+                        assertSink(effect.sinkId, sinkId);
+                        const offset = safeBrowserNumber(await blob.size(), 'transfer_recording');
+                        const durable = safeBrowserRange(offset, effect.payload.byteLength, 'transfer_recording');
+                        await blob.write(offset, effect.payload);
+                        state.hasher.update(effect.payload);
+                        return {
+                            requestId: envelope.requestId,
+                            kind: 'recording_sink_append_completed',
+                            durableUnits: BigInt(durable),
+                        };
+                    }
+                    case 'recording_sink_finalize': {
+                        assertSink(effect.sinkId, sinkId);
+                        const size = safeBrowserNumber(await blob.size(), 'transfer_recording');
+                        if (effect.expectedCrc32 !== null
+                            && state.hasher.crc32() !== effect.expectedCrc32) {
+                            return {
+                                requestId: envelope.requestId,
+                                kind: 'recording_sink_integrity_failed',
+                            };
+                        }
+                        state.finalized = true;
+                        return {
+                            requestId: envelope.requestId,
+                            kind: 'recording_sink_finalized',
+                            durableUnits: BigInt(size),
+                        };
+                    }
+                    case 'recording_sink_discard':
+                        assertSink(effect.sinkId, sinkId);
+                        await blob.delete();
+                        return null;
+                    default:
+                        throw new BotaSDKError('internal_error', 'transfer_recording');
+                }
+            }
+            catch (error) {
+                if (error instanceof BotaSDKError || error instanceof BrowserStorageError) {
+                    throw error;
+                }
+                return sinkFailure(envelope.requestId);
+            }
+        },
+        cancel: async () => undefined,
+    };
+    return { host, state };
+}
+function sinkFailure(requestId) {
+    return {
+        requestId,
+        kind: 'recording_sink_failed',
+        platformCode: null,
+    };
+}
+function assertSink(actual, expected) {
+    if (actual !== expected) {
+        throw new BotaSDKError('internal_error', 'transfer_recording');
+    }
+}
+function deviceRecording(recording) {
+    return {
+        uuid: recording.uuid,
+        startedAtTimestampSeconds: recording.startedAtTimestampSeconds,
+        durationMilliseconds: recording.durationMilliseconds,
+        fileSizeBytes: recording.fileSizeBytes,
+        codec: recording.codec,
+        ...(recording.codecRaw === undefined ? {} : { codecRaw: recording.codecRaw }),
+        encrypted: recording.encrypted,
+        encryptedUploadV2: null,
+    };
+}
+function encryptedDeviceRecording(recording) {
+    if (recording.startedAt < 0n
+        || recording.startedAt > BigInt(Number.MAX_SAFE_INTEGER)
+        || recording.durationSeconds > Math.floor(Number.MAX_SAFE_INTEGER / 1000)
+        || recording.plaintextLength > BigInt(Number.MAX_SAFE_INTEGER))
+        throw new BotaSDKError('protocol_error', 'transfer_recording');
+    return {
+        uuid: recording.recordingUuid,
+        startedAtTimestampSeconds: Number(recording.startedAt),
+        durationMilliseconds: BigInt(recording.durationSeconds) * 1000n,
+        fileSizeBytes: recording.plaintextLength,
+        codec: 'unknown',
+        encrypted: true,
+        encryptedUploadV2: {
+            generation: recording.recordingGeneration,
+            storageFormat: recording.storageFormat,
+            plaintextLength: recording.plaintextLength,
+            ciphertextLength: recording.ciphertextLength,
+            ciphertextSha256: recording.ciphertextSha256.slice(),
+        },
+    };
+}
+function validateRecording(recording) {
+    if (!Number.isSafeInteger(recording.startedAtTimestampSeconds)
+        || recording.startedAtTimestampSeconds < 0
+        || recording.durationMilliseconds < 0n
+        || recording.fileSizeBytes < 0n
+        || recording.fileSizeBytes > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new BotaSDKError('invalid_input', 'transfer_recording');
+    }
+}
+function validateEncryptedUploadV2Recording(recording) {
+    validateRecording(recording);
+    const metadata = recording.encryptedUploadV2;
+    if (!recording.encrypted
+        || !metadata
+        || !isUint32(metadata.generation)
+        || !Number.isInteger(metadata.storageFormat)
+        || metadata.storageFormat <= 0
+        || metadata.storageFormat > 0xff
+        || metadata.plaintextLength < 0n
+        || metadata.ciphertextLength <= 0n
+        || metadata.ciphertextLength > BigInt(Number.MAX_SAFE_INTEGER)
+        || metadata.ciphertextSha256.byteLength !== 32)
+        throw new BotaSDKError('invalid_input', 'transfer_recording');
+}
+function requireEncryptedUploadV2Metadata(recording) {
+    validateEncryptedUploadV2Recording(recording);
+    return recording.encryptedUploadV2;
+}
+function negotiatedEncryptedUploadV2Bounds(capabilities, transportMaximumWriteValueLength) {
+    const frameBytes = Math.min(transportMaximumWriteValueLength, 128);
+    if (frameBytes < 128) {
+        throw new BotaSDKError('unsupported_capability', 'transfer_recording');
+    }
+    const maximumMissingSequences = Math.min(capabilities.maximumMissingSequences, Math.floor((frameBytes - 68) / 4));
+    const windowPackets = Math.min(capabilities.maximumWindowPackets, maximumMissingSequences);
+    const dataPayloadBytes = Math.min(capabilities.maximumDataPayloadBytes, frameBytes - 28);
+    if (maximumMissingSequences <= 0
+        || windowPackets <= 0
+        || dataPayloadBytes <= 0)
+        throw new BotaSDKError('unsupported_capability', 'transfer_recording');
+    return { windowPackets, dataPayloadBytes, maximumMissingSequences };
+}
+function validateEncryptedUploadV2Material(material, capabilities, expected) {
+    validateProviderIdentifier(material.materialId);
+    validateProviderIdentifier(material.recordingId);
+    if (!isUuid(material.uploadSessionId)
+        || !isUint32(material.ownerRevision)
+        || material.ownerRevision === 0
+        || (material.policy !== 'legacy_allowed'
+            && material.policy !== 'v2_preferred'
+            && material.policy !== 'v2_required')
+        || !(material.authorization instanceof Uint8Array)
+        || material.authorization.byteLength !== 408
+        || material.authorization.byteLength > capabilities.maximumSignedBlobBytes
+        || typeof material.stagingRequest !== 'function'
+        || typeof material.submitManifest !== 'function'
+        || typeof material.finalize !== 'function'
+        || typeof material.completionReceipt !== 'function'
+        || typeof material.cancel !== 'function')
+        throw new BotaSDKError('upload_failed', 'upload');
+    if (expected
+        && (material.materialId !== expected.materialId
+            || material.recordingId !== expected.recordingId
+            || material.uploadSessionId !== expected.uploadSessionId
+            || material.ownerRevision !== expected.ownerRevision
+            || material.policy !== expected.policy))
+        throw new BotaSDKError('integrity_failed', 'upload');
+}
+async function destroyEncryptedUploadV2Material(material, signal) {
+    if (material.authorization instanceof Uint8Array) {
+        material.authorization.fill(0);
+    }
+    if (typeof material.cancel === 'function') {
+        await awaitProviderCall(material.cancel(signal), signal, 'upload');
+    }
+}
+function validateEncryptedUploadV2JournalState(journal, state) {
+    const phase = recordingPhaseIndex(journal.phase);
+    if (journal.profile !== 'encrypted_upload_v2'
+        || journal.operationId !== state.operationId
+        || journal.serialNumber !== state.serialNumber
+        || journal.recordingUuid !== state.recording.uuid
+        || journal.sinkId !== state.sinkId
+        || (phase >= recordingPhaseIndex('staged') && !state.evidence)
+        || (phase >= recordingPhaseIndex('uploading')
+            && journal.uploadId !== state.materialId)
+        || (phase >= recordingPhaseIndex('cloud_completed')
+            && (journal.cloudCompletionId !== state.recordingId
+                || !journal.confirmationDigestHex
+                || !/^[0-9a-f]{64}$/.test(journal.confirmationDigestHex))))
+        throw new BotaSDKError('integrity_failed', 'transfer_recording');
+}
+function encryptedUploadV2CheckpointSummary(state) {
+    const checkpoint = state.coreCheckpoint;
+    if (!checkpoint)
+        return null;
+    return {
+        uploadSessionId: state.uploadSessionId,
+        ownerRevision: state.ownerRevision,
+        checkpointRevision: checkpoint.checkpointRevision,
+        nextCiphertextOffset: checkpoint.nextCiphertextOffset,
+        prefixSha256: checkpoint.prefixSha256.slice(),
+        transportSessionId: state.transportSessionId,
+        sinkId: state.sinkId,
+        windowPackets: state.windowPackets,
+        dataPayloadBytes: state.dataPayloadBytes,
+    };
+}
+function hashBytes(core, value) {
+    const hasher = core.createIntegrityHasher();
+    hasher.update(value);
+    return hasher.sha256Snapshot();
+}
+function randomTransportSessionId() {
+    const value = crypto.getRandomValues(new Uint32Array(2));
+    const session = (BigInt(value[0] ?? 0) << 32n) | BigInt(value[1] ?? 0);
+    return session === 0n ? 1n : session;
+}
+function recordingPhaseIndex(phase) {
+    return [
+        'prepared',
+        'transferring',
+        'staged',
+        'uploading',
+        'cloud_completed',
+        'confirmed',
+    ].indexOf(phase);
+}
+function isUint32(value) {
+    return typeof value === 'number'
+        && Number.isInteger(value)
+        && value >= 0
+        && value <= 0xffffffff;
+}
+function isUuid(value) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function validateOperationId(operationId) {
+    if (operationId.length === 0 || !isWellFormedUtf16(operationId)) {
+        throw new BotaSDKError('invalid_input', 'transfer_recording');
+    }
+}
+function validateProviderIdentifier(value) {
+    if (typeof value !== 'string'
+        || value.length === 0
+        || !isWellFormedUtf16(value)) {
+        throw new BotaSDKError('upload_failed', 'upload');
+    }
+}
+function validateUploadRequest(request) {
+    if (typeof request !== 'object' || request === null) {
+        throw new BotaSDKError('upload_failed', 'upload');
+    }
+    const candidate = request;
+    if (candidate.method !== 'PUT' || typeof candidate.url !== 'string') {
+        throw new BotaSDKError('upload_failed', 'upload');
+    }
+    let url;
+    try {
+        url = new URL(candidate.url);
+    }
+    catch {
+        throw new BotaSDKError('upload_failed', 'upload');
+    }
+    if (url.protocol !== 'https:') {
+        throw new BotaSDKError('upload_failed', 'upload');
+    }
+    if (typeof candidate.headers !== 'object'
+        || candidate.headers === null
+        || Array.isArray(candidate.headers)) {
+        throw new BotaSDKError('upload_failed', 'upload');
+    }
+    for (const [name, value] of Object.entries(candidate.headers)) {
+        if (!name
+            || typeof value !== 'string'
+            || /[\r\n]/.test(name)
+            || /[\r\n]/.test(value)) {
+            throw new BotaSDKError('upload_failed', 'upload');
+        }
+    }
+}
+function resultFromJournal(journal) {
+    if (!journal.cloudCompletionId) {
+        throw new BotaSDKError('resume_rejected', 'upload');
+    }
+    return {
+        operationId: journal.operationId,
+        recordingUuid: journal.recordingUuid,
+        profile: journal.profile,
+        cloudCompletionId: journal.cloudCompletionId,
+    };
+}
+function sinkId(operationId) {
+    return `recording:${operationId}`;
+}
+function createOperationId() {
+    return `transfer_recording:${crypto.randomUUID()}`;
+}
+function randomCancellationId() {
+    return crypto.getRandomValues(new Uint8Array(16));
+}
+function decodeSerial(value, operation) {
+    try {
+        const serial = new TextDecoder('utf-8', { fatal: true })
+            .decode(value)
+            .replace(/^[\0\s]+|[\0\s]+$/g, '');
+        if (!serial)
+            throw new Error('empty serial');
+        return serial;
+    }
+    catch {
+        throw new BotaSDKError('protocol_error', operation);
+    }
+}
+function safeBrowserBigint(value, operation) {
+    if (value < 0n || value > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new BotaSDKError('invalid_input', operation);
+    }
+    return Number(value);
+}
+function safeBrowserNumber(value, operation) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new BotaSDKError('invalid_input', operation);
+    }
+    return value;
+}
+function safeBrowserRange(offset, length, operation) {
+    safeBrowserNumber(offset, operation);
+    safeBrowserNumber(length, operation);
+    if (length > Number.MAX_SAFE_INTEGER - offset) {
+        throw new BotaSDKError('invalid_input', operation);
+    }
+    return offset + length;
+}
+function blobReadableStream(blob, signal) {
+    const iterator = blob.stream(OPFS_STREAM_CHUNK_SIZE)[Symbol.asyncIterator]();
+    return new ReadableStream({
+        pull: async (controller) => {
+            try {
+                throwIfAborted(signal, 'upload');
+                const next = await iterator.next();
+                if (next.done) {
+                    controller.close();
+                }
+                else {
+                    controller.enqueue(next.value);
+                }
+            }
+            catch (error) {
+                controller.error(recordingError(error, 'upload'));
+            }
+        },
+        cancel: async () => {
+            await iterator.return?.();
+        },
+    });
+}
+let duplexRequired = null;
+function fetchRequiresDuplex() {
+    if (duplexRequired !== null)
+        return duplexRequired;
+    if (typeof Request !== 'function' || typeof ReadableStream !== 'function') {
+        duplexRequired = false;
+        return duplexRequired;
+    }
+    try {
+        new Request('https://example.invalid', {
+            method: 'PUT',
+            body: new ReadableStream(),
+        });
+        duplexRequired = false;
+    }
+    catch {
+        duplexRequired = true;
+    }
+    return duplexRequired;
+}
+async function awaitWithSignal(promise, signal, operation) {
+    throwIfAborted(signal, operation);
+    let rejectAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        rejectAbort = reject;
+    });
+    const onAbort = () => {
+        rejectAbort(new BotaSDKError('cancelled', operation));
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    try {
+        return await Promise.race([promise, aborted]);
+    }
+    finally {
+        signal.removeEventListener('abort', onAbort);
+    }
+}
+function throwIfAborted(signal, operation) {
+    if (signal?.aborted)
+        throw new BotaSDKError('cancelled', operation);
+}
+function combineSignals(first, second) {
+    if (!first)
+        return second;
+    return AbortSignal.any([first, second]);
+}
+function recordingError(error, operation) {
+    if (error instanceof BotaSDKError)
+        return error;
+    if (error instanceof BrowserStorageError) {
+        return new BotaSDKError(error.code, operation);
+    }
+    if (error instanceof BrowserTransportError) {
+        const code = error.code === 'disconnected'
+            ? 'device_disconnected'
+            : error.code === 'permission_denied'
+                ? 'permission_denied'
+                : 'bluetooth_unavailable';
+        return new BotaSDKError(code, operation);
+    }
+    return normalizeCoreError(error, operation);
+}
+function uploadError(error, signal) {
+    if (signal.aborted)
+        return new BotaSDKError('cancelled', 'upload');
+    if (error instanceof BotaSDKError)
+        return error;
+    if (error instanceof BrowserStorageError) {
+        return new BotaSDKError(error.code, 'upload');
+    }
+    return new BotaSDKError('upload_failed', 'upload', { retryable: true });
+}
+function deferred() {
+    let resolve;
+    const promise = new Promise((resolvePromise) => {
+        resolve = resolvePromise;
+    });
+    return { promise, resolve };
+}
+function hex(value) {
+    return Array.from(value, (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function isWellFormedUtf16(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                return false;
+            index += 1;
+        }
+        else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+}