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

package/dist/encryptedUploadV2Host.js

@@ -0,0 +1,2136 @@
+import { BotaSDKError } from "./errors.js";
+import { BOTA_STORAGE_SERVICE, RECORDING_LIST_V2_CHARACTERISTIC, RECORDING_TRANSFER_V2_CHARACTERISTIC, TRANSFER_CONTROL_V2_CHARACTERISTIC, TRANSFER_SIGNED_BLOB_V2_CHARACTERISTIC, } from "./gatt.js";
+import { awaitProviderCall } from "./providerCancellation.js";
+import { BrowserStorageError, } from "./storage.js";
+import { BrowserTransportError, } from "./transport.js";
+const MAXIMUM_FRAME_BYTES = 512;
+const MAXIMUM_QUEUED_BYTES = 1024 * 1024;
+const MANIFEST_LENGTH = 580;
+const EMPTY_SHA256_HEX = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855';
+const SIGNED_RESULT_TIMEOUT_MS = 10_000;
+const BLE_CLEANUP_TIMEOUT_MS = 1_000;
+let signedBlobWriteIdValue = null;
+function nextSignedBlobWriteId() {
+    if (signedBlobWriteIdValue === null) {
+        const seed = crypto.getRandomValues(new Uint32Array(1))[0] ?? 1;
+        signedBlobWriteIdValue = seed === 0 ? 1 : seed;
+    }
+    const value = signedBlobWriteIdValue;
+    signedBlobWriteIdValue = value === 0xffff_ffff ? 1 : value + 1;
+    return value;
+}
+export class EncryptedUploadV2SignedBlobWriter {
+    core;
+    transport;
+    device;
+    onOwnershipUncertain;
+    resultTimeoutMs;
+    cleanupTimeoutMs;
+    writes = new SerializedGattWrites();
+    active = false;
+    operation = null;
+    cancelled = false;
+    constructor(core, transport, device, onOwnershipUncertain = () => undefined, timing = {}) {
+        this.core = core;
+        this.transport = transport;
+        this.device = device;
+        this.onOwnershipUncertain = onOwnershipUncertain;
+        this.resultTimeoutMs = positiveTimeout(timing.resultTimeoutMs, SIGNED_RESULT_TIMEOUT_MS);
+        this.cleanupTimeoutMs = positiveTimeout(timing.cleanupTimeoutMs, BLE_CLEANUP_TIMEOUT_MS);
+    }
+    send(blobKind, writeId, value, maximumBlobBytes, signal, terminalCallback = () => undefined) {
+        if (this.active)
+            return Promise.reject(operationInProgress());
+        if (this.cancelled
+            || signal?.aborted
+            || !isUint32(writeId)
+            || writeId === 0
+            || value.byteLength === 0
+            || value.byteLength > maximumBlobBytes
+            || value.byteLength > 0xffff) {
+            terminalCallback();
+            return Promise.reject(this.cancelled || signal?.aborted
+                ? cancelled()
+                : protocolFailure());
+        }
+        this.active = true;
+        const operation = {
+            abort: new AbortController(),
+            terminal: deferred(),
+            terminalCallback,
+            terminalSettled: false,
+            poisoned: false,
+        };
+        this.operation = operation;
+        return this.runSend(operation, blobKind, writeId, value, signal);
+    }
+    async runSend(operation, blobKind, writeId, value, signal) {
+        const activeSignal = signal
+            ? AbortSignal.any([signal, operation.abort.signal])
+            : operation.abort.signal;
+        let subscription = null;
+        let began = false;
+        let terminalResultReceived = false;
+        let resultWindowOpen = false;
+        let primary = null;
+        const result = deferred();
+        let unmatchedResults = 0;
+        let unmatchedBytes = 0;
+        try {
+            subscription = await this.transport.subscribe(this.device, BOTA_STORAGE_SERVICE, TRANSFER_SIGNED_BLOB_V2_CHARACTERISTIC, ({ characteristicUuid, value: notification }) => {
+                if (characteristicUuid.toLowerCase()
+                    !== TRANSFER_SIGNED_BLOB_V2_CHARACTERISTIC)
+                    return;
+                if (!resultWindowOpen)
+                    return;
+                try {
+                    const decoded = this.core.decodeEncryptedUploadV2SignedBlobResult(notification);
+                    if (decoded.blobKind === blobKind && decoded.writeId === writeId) {
+                        terminalResultReceived = true;
+                        if (decoded.result === 0)
+                            result.resolve(undefined);
+                        else
+                            result.reject(new BotaSDKError('protocol_error', 'transfer_recording', { protocolStatus: decoded.result }));
+                        return;
+                    }
+                    unmatchedResults += 1;
+                    unmatchedBytes += notification.byteLength;
+                    if (unmatchedResults > 64 || unmatchedBytes > 32 * 1024) {
+                        result.reject(protocolFailure());
+                    }
+                }
+                catch (error) {
+                    result.reject(protocolFailure(error));
+                }
+            });
+            throwIfCancelled(this.cancelled, activeSignal);
+            const frameLimit = Math.min(this.transport.maximumWriteValueLength, MAXIMUM_FRAME_BYTES);
+            if (frameLimit < 64)
+                throw protocolFailure();
+            const digest = sha256(this.core, value);
+            began = true;
+            await this.write(this.core.encodeEncryptedUploadV2SignedBlob({
+                kind: 'begin',
+                blobKind,
+                writeId,
+                totalLength: value.byteLength,
+                sha256: digest,
+            }), frameLimit);
+            for (let offset = 0; offset < value.byteLength;) {
+                throwIfCancelled(this.cancelled, activeSignal);
+                const length = this.largestChunk(blobKind, writeId, offset, value, frameLimit);
+                await this.write(this.core.encodeEncryptedUploadV2SignedBlob({
+                    kind: 'data',
+                    blobKind,
+                    writeId,
+                    offset,
+                    data: value.slice(offset, offset + length),
+                }), frameLimit);
+                offset += length;
+            }
+            await this.write(this.core.encodeEncryptedUploadV2SignedBlob({
+                kind: 'commit',
+                blobKind,
+                writeId,
+            }), frameLimit, () => {
+                resultWindowOpen = true;
+            });
+            await rejectAfter(abortable(result.promise, activeSignal), this.resultTimeoutMs, signedResultTimeout);
+        }
+        catch (error) {
+            primary = error;
+        }
+        const cleanup = (async () => {
+            let cleanupError = null;
+            if (primary !== null && began && !terminalResultReceived) {
+                try {
+                    const frameLimit = Math.min(this.transport.maximumWriteValueLength, MAXIMUM_FRAME_BYTES);
+                    await this.write(this.core.encodeEncryptedUploadV2SignedBlob({
+                        kind: 'abort',
+                        blobKind,
+                        writeId,
+                    }), frameLimit);
+                }
+                catch (error) {
+                    cleanupError = error;
+                }
+            }
+            try {
+                await subscription?.remove();
+            }
+            catch (error) {
+                cleanupError ??= error;
+            }
+            if (cleanupError !== null)
+                throw cleanupError;
+        })();
+        const cleanupSettlement = settle(cleanup);
+        const bounded = await boundedSettlement(cleanupSettlement, this.cleanupTimeoutMs);
+        if (bounded === null) {
+            this.poison(operation);
+            void cleanupSettlement.then((settlement) => {
+                this.finishOperation(operation);
+                if (settlement.error !== null)
+                    this.poison(operation);
+            });
+            throw ownershipUnknown();
+        }
+        this.finishOperation(operation);
+        if (bounded.error !== null) {
+            this.poison(operation);
+            throw ownershipUnknown(bounded.error);
+        }
+        if (primary !== null)
+            throw normalizeHostError(primary);
+    }
+    async cancel() {
+        this.cancelled = true;
+        const operation = this.operation;
+        if (!operation)
+            return;
+        operation.abort.abort();
+        const terminal = settle(operation.terminal.promise);
+        const bounded = await boundedSettlement(terminal, this.cleanupTimeoutMs);
+        if (bounded === null) {
+            this.poison(operation);
+            throw ownershipUnknown();
+        }
+        if (bounded.error !== null)
+            throw ownershipUnknown(bounded.error);
+    }
+    finishOperation(operation) {
+        if (operation.terminalSettled)
+            return;
+        operation.terminalSettled = true;
+        try {
+            operation.terminalCallback();
+        }
+        finally {
+            operation.terminal.resolve(undefined);
+            if (this.operation === operation)
+                this.operation = null;
+            this.active = false;
+        }
+    }
+    poison(operation) {
+        if (operation.poisoned)
+            return;
+        operation.poisoned = true;
+        this.onOwnershipUncertain();
+    }
+    largestChunk(blobKind, writeId, offset, value, frameLimit) {
+        let low = 1;
+        let high = Math.min(value.byteLength - offset, 0xffff - offset);
+        let best = 0;
+        while (low <= high) {
+            const middle = Math.floor((low + high) / 2);
+            const frame = this.core.encodeEncryptedUploadV2SignedBlob({
+                kind: 'data',
+                blobKind,
+                writeId,
+                offset,
+                data: value.slice(offset, offset + middle),
+            });
+            if (frame.byteLength <= frameLimit) {
+                best = middle;
+                low = middle + 1;
+            }
+            else {
+                high = middle - 1;
+            }
+        }
+        if (best === 0)
+            throw protocolFailure();
+        return best;
+    }
+    async write(frame, frameLimit, onInitiated) {
+        if (frame.byteLength > frameLimit)
+            throw protocolFailure();
+        await this.writes.run(async () => {
+            onInitiated?.();
+            await this.transport.write(this.device, BOTA_STORAGE_SERVICE, TRANSFER_SIGNED_BLOB_V2_CHARACTERISTIC, frame, true);
+        });
+    }
+}
+export class EncryptedUploadV2TransferControl {
+    core;
+    transport;
+    device;
+    onOwnershipUncertain;
+    cleanupTimeoutMs;
+    writes = new SerializedGattWrites();
+    active = false;
+    session = null;
+    constructor(core, transport, device, onOwnershipUncertain = () => undefined, timing = {}) {
+        this.core = core;
+        this.transport = transport;
+        this.device = device;
+        this.onOwnershipUncertain = onOwnershipUncertain;
+        this.cleanupTimeoutMs = positiveTimeout(timing.cleanupTimeoutMs, BLE_CLEANUP_TIMEOUT_MS);
+    }
+    async open(request, checkpoint, signal) {
+        if (this.session)
+            throw operationInProgress();
+        validateTransferRequest(request);
+        throwIfCancelled(false, signal);
+        const queue = new BoundedFrameQueue();
+        const control = deferred();
+        const session = {
+            request: copyTransferRequest(request),
+            subscription: null,
+            queue,
+            phase: 'awaiting_control',
+            pendingNotifications: [],
+            pendingNotificationBytes: 0,
+            repairSequences: null,
+            confirmationAttempted: false,
+            confirmationSucceeded: false,
+            abort: new AbortController(),
+            opening: true,
+            writeAttempted: false,
+            abortRequested: false,
+            abortReason: 0x00ff,
+            releasePromise: null,
+            terminal: deferred(),
+            poisoned: false,
+        };
+        this.session = session;
+        void session.terminal.promise.catch(() => undefined);
+        const activeSignal = signal
+            ? AbortSignal.any([signal, session.abort.signal])
+            : session.abort.signal;
+        try {
+            session.subscription = await this.transport.subscribe(this.device, BOTA_STORAGE_SERVICE, RECORDING_TRANSFER_V2_CHARACTERISTIC, ({ characteristicUuid, value }) => {
+                if (characteristicUuid.toLowerCase()
+                    !== RECORDING_TRANSFER_V2_CHARACTERISTIC)
+                    return;
+                try {
+                    const frame = this.core.decodeEncryptedUploadV2Transfer(value);
+                    if (frame.transportSessionId !== request.transportSessionId) {
+                        throw identityFailure();
+                    }
+                    if (session.phase === 'awaiting_control') {
+                        session.phase = 'control_pending';
+                        control.resolve(frame);
+                        return;
+                    }
+                    if (session.phase === 'control_pending') {
+                        if (session.pendingNotificationBytes + value.byteLength
+                            > MAXIMUM_QUEUED_BYTES)
+                            throw protocolFailure();
+                        session.pendingNotificationBytes += value.byteLength;
+                        session.pendingNotifications.push({
+                            frame,
+                            rawLength: value.byteLength,
+                        });
+                        return;
+                    }
+                    this.acceptTransferFrame(session, frame, value.byteLength);
+                }
+                catch (error) {
+                    const normalized = normalizeHostError(error);
+                    control.reject(normalized);
+                    queue.fail(normalized);
+                }
+            });
+            throwIfCancelled(false, activeSignal);
+            const frame = checkpoint
+                ? this.core.encodeEncryptedUploadV2Transfer({
+                    kind: 'resume_request',
+                    flags: 0,
+                    transportSessionId: request.transportSessionId,
+                    uploadSessionUuid: request.uploadSessionUuid,
+                    recordingUuid: request.recordingUuid,
+                    recordingGeneration: request.recordingGeneration,
+                    checkpointRevision: checkpoint.revision,
+                    nextCiphertextOffset: checkpoint.nextCiphertextOffset,
+                    prefixSha256: checkpoint.prefixSha256,
+                    windowPackets: request.windowPackets,
+                    dataPayloadBytes: request.dataPayloadBytes,
+                })
+                : this.core.encodeEncryptedUploadV2Transfer({
+                    kind: 'start',
+                    flags: 0,
+                    transportSessionId: request.transportSessionId,
+                    uploadSessionUuid: request.uploadSessionUuid,
+                    recordingUuid: request.recordingUuid,
+                    recordingGeneration: request.recordingGeneration,
+                    authorizationSha256: request.authorizationSha256,
+                    checkpointRevision: 0,
+                    nextCiphertextOffset: 0n,
+                    prefixSha256: initialEncryptedUploadV2Checkpoint().prefixSha256,
+                    windowPackets: request.windowPackets,
+                    dataPayloadBytes: request.dataPayloadBytes,
+                });
+            session.phase = 'awaiting_control';
+            session.writeAttempted = true;
+            await this.writeControl(frame);
+            const response = await abortable(control.promise, activeSignal);
+            if (response.kind === 'resume_reject') {
+                if (!checkpoint
+                    || response.reason === 0
+                    || response.checkpointRevision !== checkpoint.revision
+                    || response.nextCiphertextOffset !== checkpoint.nextCiphertextOffset
+                    || !equalBytes(response.prefixSha256, checkpoint.prefixSha256))
+                    throw identityFailure();
+                session.opening = false;
+                await this.releaseSession(session, false);
+                return { kind: 'resume_rejected' };
+            }
+            if (response.kind === 'error') {
+                const expectedType = checkpoint ? 0x22 : 0x20;
+                if (response.result === 0 || response.failedMessageType !== expectedType) {
+                    throw identityFailure();
+                }
+                const rejection = new BotaSDKError('protocol_error', 'transfer_recording', { protocolStatus: response.result });
+                session.opening = false;
+                await this.releaseSession(session, false);
+                throw rejection;
+            }
+            if (checkpoint) {
+                if (response.kind !== 'resume_accept')
+                    throw identityFailure();
+                validateResumeAcknowledgement(request, checkpoint, response);
+            }
+            else {
+                if (response.kind !== 'start_ack')
+                    throw identityFailure();
+                validateStartAcknowledgement(request, response);
+            }
+            session.phase = checkpoint?.nextCiphertextOffset
+                === request.expectedCiphertextLength
+                ? 'manifest'
+                : 'window';
+            for (const pending of session.pendingNotifications.splice(0)) {
+                this.acceptTransferFrame(session, pending.frame, pending.rawLength);
+            }
+            session.pendingNotificationBytes = 0;
+            session.opening = false;
+            return { kind: 'opened', notifications: queue };
+        }
+        catch (error) {
+            try {
+                await this.releaseSession(session, session.writeAttempted);
+            }
+            catch (cleanupError) {
+                throw normalizeHostError(cleanupError);
+            }
+            throw normalizeHostError(error);
+        }
+    }
+    async sendActiveFrame(frame, continuation) {
+        const session = this.requireSession(frame.transportSessionId);
+        if (session.phase !== 'paused')
+            throw protocolFailure();
+        session.phase = continuation.kind;
+        session.repairSequences = continuation.kind === 'repair'
+            ? new Set(continuation.missingSequences)
+            : null;
+        try {
+            await this.writeControl(this.core.encodeEncryptedUploadV2Transfer(frame));
+        }
+        catch (error) {
+            this.onOwnershipUncertain();
+            session.queue.fail(ownershipUnknown(error));
+            throw ownershipUnknown(error);
+        }
+    }
+    async confirm(frame, writeSucceeded) {
+        const session = this.requireSession(frame.transportSessionId);
+        if (session.phase !== 'paused' && session.phase !== 'terminal') {
+            throw protocolFailure();
+        }
+        session.phase = 'confirming';
+        session.confirmationAttempted = true;
+        try {
+            await this.writeControl(this.core.encodeEncryptedUploadV2Transfer(frame));
+            session.confirmationSucceeded = true;
+            await writeSucceeded();
+            session.phase = 'confirmed';
+            await this.releaseSession(session, false, true);
+        }
+        catch (error) {
+            this.onOwnershipUncertain();
+            throw ownershipUnknown(error);
+        }
+    }
+    async confirmationAttemptedOrClaimCancellation() {
+        const session = this.session;
+        if (!session)
+            return false;
+        if (session.confirmationAttempted
+            || session.phase === 'confirming'
+            || session.phase === 'confirmed')
+            return true;
+        session.abortRequested = true;
+        return false;
+    }
+    async abort(reason = 0x00ff) {
+        const session = this.session;
+        if (!session)
+            return;
+        if (session.phase === 'confirming' || session.phase === 'confirmed') {
+            throw ownershipUnknown();
+        }
+        session.abortRequested = true;
+        session.abortReason = reason;
+        session.abort.abort();
+        if (!session.opening) {
+            await this.releaseSession(session, true, false, reason);
+            return;
+        }
+        const bounded = await boundedSettlement(settle(session.terminal.promise), this.cleanupTimeoutMs);
+        if (bounded === null) {
+            this.poison(session);
+            throw ownershipUnknown();
+        }
+        if (bounded.error !== null)
+            throw ownershipUnknown(bounded.error);
+    }
+    async cancel() {
+        await this.abort();
+    }
+    acceptTransferFrame(session, frame, rawLength) {
+        if (frame.kind === 'error') {
+            session.phase = 'terminal';
+            session.queue.push(frame, rawLength);
+            return;
+        }
+        switch (session.phase) {
+            case 'window':
+                if (frame.kind !== 'data' && frame.kind !== 'window_end') {
+                    throw protocolFailure();
+                }
+                if (frame.kind === 'window_end')
+                    session.phase = 'paused';
+                break;
+            case 'manifest':
+                if (frame.kind !== 'manifest_chunk' && frame.kind !== 'eof') {
+                    throw protocolFailure();
+                }
+                if (frame.kind === 'eof')
+                    session.phase = 'terminal';
+                break;
+            case 'repair':
+                if (frame.kind === 'data') {
+                    if (!session.repairSequences?.delete(frame.sequence)) {
+                        throw protocolFailure();
+                    }
+                }
+                else if (frame.kind === 'window_end') {
+                    if (session.repairSequences && session.repairSequences.size > 0) {
+                        throw protocolFailure();
+                    }
+                    session.phase = 'paused';
+                }
+                else {
+                    throw protocolFailure();
+                }
+                break;
+            default:
+                throw protocolFailure();
+        }
+        session.queue.push(frame, rawLength);
+    }
+    requireSession(transportSessionId) {
+        const session = this.session;
+        if (!session || session.request.transportSessionId !== transportSessionId) {
+            throw identityFailure();
+        }
+        return session;
+    }
+    async releaseSession(session, abort, confirmed = false, reason = 0x00ff) {
+        if (!confirmed
+            && (session.phase === 'confirming' || session.phase === 'confirmed'))
+            throw ownershipUnknown();
+        session.abortRequested ||= abort;
+        if (abort)
+            session.abortReason = reason;
+        session.opening = false;
+        if (!session.releasePromise) {
+            session.phase = 'cleaning';
+            session.releasePromise = (async () => {
+                let failure = null;
+                if (session.abortRequested && session.writeAttempted) {
+                    try {
+                        await this.writeControl(this.core.encodeEncryptedUploadV2Transfer({
+                            kind: 'abort',
+                            flags: 0,
+                            transportSessionId: session.request.transportSessionId,
+                            reason: session.abortReason,
+                        }));
+                    }
+                    catch (error) {
+                        failure = error;
+                    }
+                }
+                try {
+                    await session.subscription?.remove();
+                }
+                catch (error) {
+                    failure ??= error;
+                }
+                session.queue.close();
+                if (failure === null) {
+                    session.terminal.resolve(undefined);
+                    if (this.session === session)
+                        this.session = null;
+                    return;
+                }
+                session.terminal.reject(failure);
+                throw failure;
+            })();
+        }
+        const bounded = await boundedSettlement(settle(session.releasePromise), this.cleanupTimeoutMs);
+        if (bounded === null) {
+            this.poison(session);
+            throw ownershipUnknown();
+        }
+        if (bounded.error !== null) {
+            this.poison(session);
+            throw ownershipUnknown(bounded.error);
+        }
+    }
+    poison(session) {
+        if (session.poisoned)
+            return;
+        session.poisoned = true;
+        this.onOwnershipUncertain();
+    }
+    async list(transportSessionId, signal) {
+        if (this.active)
+            throw operationInProgress();
+        if (transportSessionId <= 0n || signal?.aborted) {
+            throw signal?.aborted ? cancelled() : protocolFailure();
+        }
+        this.active = true;
+        let listSubscription = null;
+        let errorSubscription = null;
+        const completed = deferred();
+        const entries = [];
+        const digest = this.core.createIntegrityHasher();
+        let queuedBytes = 0;
+        let result = null;
+        let primary = null;
+        try {
+            listSubscription = await this.transport.subscribe(this.device, BOTA_STORAGE_SERVICE, RECORDING_LIST_V2_CHARACTERISTIC, ({ characteristicUuid, value }) => {
+                if (characteristicUuid.toLowerCase()
+                    !== RECORDING_LIST_V2_CHARACTERISTIC)
+                    return;
+                try {
+                    queuedBytes += value.byteLength;
+                    if (queuedBytes > MAXIMUM_QUEUED_BYTES)
+                        throw protocolFailure();
+                    const frame = this.core.decodeEncryptedUploadV2Transfer(value);
+                    if (frame.transportSessionId !== transportSessionId) {
+                        throw identityFailure();
+                    }
+                    if (frame.kind === 'recording_entry') {
+                        if (frame.completionState !== 1)
+                            throw protocolFailure();
+                        digest.update(value.slice(12));
+                        entries.push(copyRecordingEntry(frame));
+                        return;
+                    }
+                    if (frame.kind !== 'recording_list_end')
+                        throw protocolFailure();
+                    if (frame.count !== entries.length
+                        || frame.listRevision === 0
+                        || !equalBytes(frame.listSha256, digest.sha256Snapshot()))
+                        throw integrityFailure();
+                    completed.resolve({
+                        entries: entries.map(copyRecordingEntry),
+                        listRevision: frame.listRevision,
+                    });
+                }
+                catch (error) {
+                    completed.reject(normalizeHostError(error));
+                }
+            });
+            throwIfCancelled(false, signal);
+            errorSubscription = await this.transport.subscribe(this.device, BOTA_STORAGE_SERVICE, RECORDING_TRANSFER_V2_CHARACTERISTIC, ({ characteristicUuid, value }) => {
+                if (characteristicUuid.toLowerCase()
+                    !== RECORDING_TRANSFER_V2_CHARACTERISTIC)
+                    return;
+                try {
+                    queuedBytes += value.byteLength;
+                    if (queuedBytes > MAXIMUM_QUEUED_BYTES)
+                        throw protocolFailure();
+                    const frame = this.core.decodeEncryptedUploadV2Transfer(value);
+                    if (frame.transportSessionId !== transportSessionId)
+                        return;
+                    if (frame.kind !== 'error'
+                        || frame.result === 0
+                        || frame.failedMessageType !== 0x25)
+                        throw protocolFailure();
+                    completed.reject(new BotaSDKError('protocol_error', 'transfer_recording', { protocolStatus: frame.result }));
+                }
+                catch (error) {
+                    completed.reject(normalizeHostError(error));
+                }
+            });
+            throwIfCancelled(false, signal);
+            const request = this.core.encodeEncryptedUploadV2Transfer({
+                kind: 'list',
+                flags: 0,
+                transportSessionId,
+            });
+            await this.writeControl(request);
+            result = await abortable(completed.promise, signal);
+        }
+        catch (error) {
+            primary = error;
+        }
+        const cleanup = (async () => {
+            let cleanupError = null;
+            for (const subscription of [errorSubscription, listSubscription]) {
+                try {
+                    await subscription?.remove();
+                }
+                catch (error) {
+                    cleanupError ??= error;
+                }
+            }
+            if (cleanupError !== null)
+                throw cleanupError;
+        })();
+        const cleanupSettlement = settle(cleanup);
+        const bounded = await boundedSettlement(cleanupSettlement, this.cleanupTimeoutMs);
+        if (bounded === null) {
+            this.onOwnershipUncertain();
+            void cleanupSettlement.then(() => {
+                this.active = false;
+            });
+            throw ownershipUnknown();
+        }
+        this.active = false;
+        if (bounded.error !== null) {
+            this.onOwnershipUncertain();
+            throw ownershipUnknown(bounded.error);
+        }
+        if (primary !== null)
+            throw normalizeHostError(primary);
+        if (!result)
+            throw protocolFailure();
+        return result;
+    }
+    async writeControl(frame) {
+        if (frame.byteLength > Math.min(this.transport.maximumWriteValueLength, MAXIMUM_FRAME_BYTES))
+            throw protocolFailure();
+        await this.writes.run(async () => await this.transport.write(this.device, BOTA_STORAGE_SERVICE, TRANSFER_CONTROL_V2_CHARACTERISTIC, frame, true));
+    }
+}
+class BoundedFrameQueue {
+    values = [];
+    waiters = [];
+    bufferedBytes = 0;
+    terminalError = null;
+    closed = false;
+    push(frame, rawLength) {
+        if (this.closed || this.terminalError !== null)
+            throw protocolFailure();
+        const waiter = this.waiters.shift();
+        if (waiter) {
+            waiter.resolve({ done: false, value: frame });
+            return;
+        }
+        if (this.bufferedBytes + rawLength > MAXIMUM_QUEUED_BYTES) {
+            const error = protocolFailure();
+            this.fail(error);
+            throw error;
+        }
+        this.bufferedBytes += rawLength;
+        this.values.push({ frame, rawLength });
+    }
+    fail(error) {
+        if (this.terminalError !== null || this.closed)
+            return;
+        this.terminalError = error;
+        this.values.length = 0;
+        this.bufferedBytes = 0;
+        for (const waiter of this.waiters.splice(0))
+            waiter.reject(error);
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.values.length = 0;
+        this.bufferedBytes = 0;
+        for (const waiter of this.waiters.splice(0)) {
+            waiter.resolve({ done: true, value: undefined });
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                const value = this.values.shift();
+                if (value) {
+                    this.bufferedBytes -= value.rawLength;
+                    return { done: false, value: value.frame };
+                }
+                if (this.terminalError !== null)
+                    throw this.terminalError;
+                if (this.closed)
+                    return { done: true, value: undefined };
+                return await new Promise((resolve, reject) => this.waiters.push({ resolve, reject }));
+            },
+        };
+    }
+}
+export class EncryptedUploadV2Host {
+    core;
+    storage;
+    blob;
+    material;
+    state;
+    fetcher;
+    callbacks;
+    recoveryPhase;
+    expectedReceiptSha256Hex;
+    signedWriter;
+    transferControl;
+    uploadAbort = new AbortController();
+    receiver = null;
+    pendingNativeCheckpoint = null;
+    persistedCoreCheckpoint = null;
+    completedManifest = null;
+    completedEvidence = null;
+    acceptedReceipt = null;
+    acceptedReceiptSha256 = null;
+    boundaryTarget = null;
+    boundaryGate = null;
+    startBoundaryTarget = null;
+    pumpPromise = null;
+    preparedAuthorizationSha256 = null;
+    cancelledValue = false;
+    abortPromise = null;
+    constructor(options) {
+        this.core = options.core;
+        this.storage = options.storage;
+        this.blob = options.blob;
+        this.material = options.material;
+        this.state = copyPersistedState(options.state);
+        this.fetcher = options.fetcher;
+        this.callbacks = options.callbacks;
+        this.recoveryPhase = options.recoveryPhase;
+        this.expectedReceiptSha256Hex = options.expectedReceiptSha256Hex;
+        this.signedWriter = new EncryptedUploadV2SignedBlobWriter(options.core, options.transport, options.device, options.onOwnershipUncertain);
+        this.transferControl = new EncryptedUploadV2TransferControl(options.core, options.transport, options.device, options.onOwnershipUncertain);
+    }
+    async execute(envelope, context) {
+        const effect = envelope.effect;
+        switch (effect.kind) {
+            case 'encrypted_upload_v2_load_checkpoint': {
+                this.validateCheckpointOwner(effect.serialNumber, uuidString(effect.recordingUuid), effect.recordingGeneration, uuidString(effect.uploadSessionId), effect.ownerRevision);
+                return {
+                    requestId: envelope.requestId,
+                    kind: 'encrypted_upload_v2_checkpoint_loaded',
+                    checkpoint: this.state.coreCheckpoint
+                        ? copyCoreCheckpoint(this.state.coreCheckpoint)
+                        : null,
+                };
+            }
+            case 'encrypted_upload_v2_delete_checkpoint':
+                if (uuidString(effect.uploadSessionId) !== this.state.uploadSessionId) {
+                    throw identityFailure();
+                }
+                this.state.coreCheckpoint = null;
+                this.state.highestContiguousSequence = null;
+                await this.storage.saveEncryptedUploadV2Checkpoint(this.state.operationId, copyPersistedState(this.state));
+                return null;
+            case 'encrypted_upload_v2_truncate_sink': {
+                if (effect.sinkId !== this.state.sinkId)
+                    throw identityFailure();
+                const offset = safeNumber(effect.nextCiphertextOffset);
+                const size = await this.blob.size();
+                if (size < offset)
+                    throw integrityFailure();
+                if (size > offset)
+                    await this.blob.truncate(offset);
+                return {
+                    requestId: envelope.requestId,
+                    kind: 'encrypted_upload_v2_sink_truncated',
+                };
+            }
+            case 'encrypted_upload_v2_prepare_session': {
+                if (effect.materialId !== this.state.materialId)
+                    throw identityFailure();
+                const source = this.material.authorization;
+                if (source.byteLength !== 408)
+                    throw protocolFailure();
+                const digest = sha256(this.core, source);
+                await this.signedWriter.send('authorization', nextSignedBlobWriteId(), source, this.state.maximumSignedBlobBytes, context.signal, () => source.fill(0));
+                this.preparedAuthorizationSha256 = digest;
+                return {
+                    requestId: envelope.requestId,
+                    kind: 'encrypted_upload_v2_session_prepared',
+                    authorizationSha256: digest.slice(),
+                };
+            }
+            case 'encrypted_upload_v2_start_transfer':
+                return await this.startTransfer(envelope.requestId, effect, context);
+            case 'encrypted_upload_v2_repair_window':
+                return await this.repairWindow(envelope.requestId, effect.missingSequences);
+            case 'encrypted_upload_v2_save_checkpoint':
+                return await this.saveCheckpoint(envelope.requestId, effect.checkpoint);
+            case 'encrypted_upload_v2_acknowledge_window':
+                return await this.acknowledgeWindow(envelope.requestId, effect.checkpoint, context);
+            case 'encrypted_upload_v2_stage_artifacts':
+                return await this.stageArtifacts(envelope.requestId, effect.sinkId, effect.materialId, effect.evidence, context.signal);
+            case 'encrypted_upload_v2_await_completion_receipt':
+                return await this.awaitReceipt(envelope.requestId, effect.materialId, effect.evidence, context.signal);
+            case 'encrypted_upload_v2_confirm_with_receipt':
+                return await this.confirm(envelope.requestId, envelope.cancellationId, effect.materialId, effect.receiptSha256);
+            case 'encrypted_upload_v2_abort':
+                if (effect.materialId !== this.state.materialId)
+                    throw identityFailure();
+                await this.abortState();
+                return null;
+            default:
+                throw new BotaSDKError('internal_error', 'transfer_recording');
+        }
+    }
+    async confirmationAttemptedOrClaimCancellation() {
+        return await this.transferControl.confirmationAttemptedOrClaimCancellation();
+    }
+    async cancel() {
+        await this.abortState();
+    }
+    async startTransfer(requestId, effect, context) {
+        this.validateStartEffect(effect);
+        const nativeCheckpoint = effect.checkpoint
+            ? {
+                revision: effect.checkpoint.checkpointRevision,
+                nextCiphertextOffset: effect.checkpoint.nextCiphertextOffset,
+                prefixSha256: effect.checkpoint.prefixSha256.slice(),
+                highestContiguousSequence: this.state.highestContiguousSequence,
+            }
+            : initialEncryptedUploadV2Checkpoint();
+        this.receiver = new EncryptedUploadV2TransferReceiver(this.core, this.blob, {
+            transportSessionId: this.state.transportSessionId,
+            expectedCiphertextLength: this.state.recording.ciphertextLength,
+            expectedCiphertextSha256: this.state.recording.ciphertextSha256,
+            maximumDataPayloadBytes: this.state.dataPayloadBytes,
+            maximumWindowPackets: this.state.windowPackets,
+            maximumMissingSequences: this.state.maximumMissingSequences,
+            checkpoint: nativeCheckpoint,
+        });
+        await this.receiver.prepare();
+        const opened = await this.transferControl.open({
+            transportSessionId: this.state.transportSessionId,
+            uploadSessionUuid: this.state.uploadSessionId,
+            recordingUuid: this.state.recording.uuid,
+            recordingGeneration: this.state.recording.generation,
+            authorizationSha256: effect.authorizationSha256,
+            expectedCiphertextLength: this.state.recording.ciphertextLength,
+            expectedCiphertextSha256: this.state.recording.ciphertextSha256,
+            expectedCheckpointIntervalBlocks: this.state.checkpointIntervalBlocks,
+            windowPackets: this.state.windowPackets,
+            dataPayloadBytes: this.state.dataPayloadBytes,
+        }, effect.checkpoint ? nativeCheckpoint : null, context.signal);
+        if (opened.kind === 'resume_rejected') {
+            await context.dispatch({
+                requestId,
+                kind: 'encrypted_upload_v2_resume_rejected',
+            });
+            return null;
+        }
+        const target = this.dispatchTarget(requestId, context);
+        this.startBoundaryTarget = target;
+        this.boundaryTarget = target;
+        await context.dispatch({
+            requestId,
+            kind: 'encrypted_upload_v2_transfer_started',
+        });
+        this.pumpPromise = this.pump(opened.notifications);
+        void this.pumpPromise.catch(() => undefined);
+        return null;
+    }
+    async repairWindow(requestId, missingSequences) {
+        const receiver = this.requireReceiver();
+        const frame = receiver.repairAcknowledgement(missingSequences);
+        const boundary = deferred();
+        this.boundaryTarget = async (event) => boundary.resolve(event);
+        const gate = this.boundaryGate;
+        if (!gate)
+            throw protocolFailure();
+        await this.transferControl.sendActiveFrame(frame, {
+            kind: 'repair',
+            missingSequences,
+        });
+        gate.resolve(undefined);
+        return boundaryHostEvent(requestId, await boundary.promise);
+    }
+    async saveCheckpoint(requestId, checkpoint) {
+        const native = this.pendingNativeCheckpoint;
+        if (!native || !sameCoreAndNativeCheckpoint(checkpoint, native, this.state)) {
+            throw integrityFailure();
+        }
+        this.state.coreCheckpoint = copyCoreCheckpoint(checkpoint);
+        this.state.highestContiguousSequence = native.highestContiguousSequence;
+        await this.storage.saveEncryptedUploadV2Checkpoint(this.state.operationId, copyPersistedState(this.state));
+        this.requireReceiver().checkpointDidPersist(native);
+        this.persistedCoreCheckpoint = copyCoreCheckpoint(checkpoint);
+        return {
+            requestId,
+            kind: 'encrypted_upload_v2_checkpoint_saved',
+        };
+    }
+    async acknowledgeWindow(requestId, checkpoint, context) {
+        if (!this.persistedCoreCheckpoint
+            || !sameCoreCheckpoint(this.persistedCoreCheckpoint, checkpoint)
+            || !this.pendingNativeCheckpoint)
+            throw integrityFailure();
+        const frame = this.requireReceiver().windowAcknowledgement(this.pendingNativeCheckpoint);
+        this.boundaryTarget = this.startBoundaryTarget;
+        const gate = this.boundaryGate;
+        if (!gate || !this.boundaryTarget)
+            throw protocolFailure();
+        await this.transferControl.sendActiveFrame(frame, checkpoint.nextCiphertextOffset === this.state.recording.ciphertextLength
+            ? { kind: 'manifest' }
+            : { kind: 'window' });
+        this.pendingNativeCheckpoint = null;
+        this.persistedCoreCheckpoint = null;
+        this.boundaryGate = null;
+        await context.dispatch({
+            requestId,
+            kind: 'encrypted_upload_v2_window_acknowledged',
+            checkpoint: copyCoreCheckpoint(checkpoint),
+        });
+        gate.resolve(undefined);
+        return null;
+    }
+    async stageArtifacts(requestId, sinkId, materialId, evidence, signal) {
+        this.validateCompletion(sinkId, materialId, evidence);
+        if (this.recoveryPhase !== 'cloud_completed') {
+            throwIfCancelled(this.cancelledValue, signal);
+            await this.callbacks.uploading();
+            throwIfCancelled(this.cancelledValue, signal);
+            const request = await awaitProviderCall(this.material.stagingRequest(providerEvidence(evidence), signal), signal, 'upload');
+            validateUploadRequest(request);
+            await this.uploadCiphertext(request, signal);
+            throwIfCancelled(this.cancelledValue, signal);
+            await awaitProviderCall(this.material.submitManifest(this.requireCompletedManifest().slice(), providerEvidence(evidence), signal), signal, 'upload');
+        }
+        return {
+            requestId,
+            kind: 'encrypted_upload_v2_artifacts_staged',
+        };
+    }
+    async awaitReceipt(requestId, materialId, evidence, signal) {
+        this.validateCompletion(this.state.sinkId, materialId, evidence);
+        if (this.recoveryPhase !== 'cloud_completed') {
+            throwIfCancelled(this.cancelledValue, signal);
+            await awaitProviderCall(this.material.finalize(providerEvidence(evidence), signal), signal, 'upload');
+        }
+        throwIfCancelled(this.cancelledValue, signal);
+        const pendingReceipt = this.material.completionReceipt(providerEvidence(evidence), signal);
+        let receipt;
+        try {
+            receipt = await awaitProviderCall(pendingReceipt, signal, 'upload');
+        }
+        catch (error) {
+            void pendingReceipt.then((lateReceipt) => {
+                if (lateReceipt instanceof Uint8Array)
+                    lateReceipt.fill(0);
+            }, () => undefined);
+            throw error;
+        }
+        if (this.cancelledValue || signal.aborted) {
+            receipt.fill(0);
+            throw cancelled();
+        }
+        if (!(receipt instanceof Uint8Array))
+            throw integrityFailure();
+        if (receipt.byteLength !== 336) {
+            receipt.fill(0);
+            throw integrityFailure();
+        }
+        const digest = sha256(this.core, receipt);
+        if (this.expectedReceiptSha256Hex !== null
+            && hexString(digest) !== this.expectedReceiptSha256Hex) {
+            receipt.fill(0);
+            throw integrityFailure();
+        }
+        this.acceptedReceipt = receipt;
+        this.acceptedReceiptSha256 = digest;
+        await this.callbacks.cloudCompleted(digest.slice());
+        return {
+            requestId,
+            kind: 'encrypted_upload_v2_completion_receipt_accepted',
+            receiptSha256: digest.slice(),
+        };
+    }
+    async confirm(requestId, _cancellationId, materialId, receiptSha256) {
+        if (materialId !== this.state.materialId
+            || !this.acceptedReceipt
+            || !this.acceptedReceiptSha256
+            || !equalBytes(receiptSha256, this.acceptedReceiptSha256))
+            throw integrityFailure();
+        const receipt = this.acceptedReceipt;
+        await this.signedWriter.send('receipt', nextSignedBlobWriteId(), receipt, this.state.maximumSignedBlobBytes, undefined, () => {
+            receipt.fill(0);
+            if (this.acceptedReceipt === receipt)
+                this.acceptedReceipt = null;
+        });
+        const frame = {
+            kind: 'confirm',
+            flags: 0,
+            transportSessionId: this.state.transportSessionId,
+            uploadSessionUuid: this.state.uploadSessionId,
+            recordingUuid: this.state.recording.uuid,
+            recordingGeneration: this.state.recording.generation,
+            ownerRevision: this.state.ownerRevision,
+            receiptSha256: receiptSha256.slice(),
+        };
+        await this.transferControl.confirm(frame, async () => {
+            await this.callbacks.confirmed();
+        });
+        return {
+            requestId,
+            kind: 'encrypted_upload_v2_recording_confirmed',
+        };
+    }
+    async pump(notifications) {
+        try {
+            for await (const frame of notifications) {
+                const event = await this.requireReceiver().receive(frame);
+                if (!event)
+                    continue;
+                const target = this.boundaryTarget;
+                if (!target)
+                    throw protocolFailure();
+                if (event.kind === 'window_staged') {
+                    this.pendingNativeCheckpoint = copyNativeCheckpoint(event.checkpoint);
+                    const checkpoint = coreCheckpoint(this.state.serialNumber, uuidBytes(this.state.recording.uuid), this.state.recording.generation, uuidBytes(this.state.uploadSessionId), this.state.ownerRevision, this.state.transportSessionId, event.checkpoint, this.state.windowPackets, this.state.dataPayloadBytes);
+                    const gate = deferred();
+                    this.boundaryGate = gate;
+                    await target({
+                        kind: 'encrypted_upload_v2_window_staged',
+                        checkpoint,
+                        missingSequences: [...event.missingSequences],
+                    });
+                    await gate.promise;
+                    continue;
+                }
+                this.completedManifest = event.manifest.slice();
+                this.completedEvidence = copyEvidence(event.evidence);
+                this.state.evidence = copyEvidence(event.evidence);
+                await this.storage.saveEncryptedUploadV2Checkpoint(this.state.operationId, copyPersistedState(this.state));
+                if (this.recoveryPhase !== 'cloud_completed') {
+                    await this.callbacks.transferCompleted(copyEvidence(event.evidence));
+                }
+                await target({
+                    kind: 'encrypted_upload_v2_transfer_completed',
+                    evidence: copyEvidence(event.evidence),
+                });
+                return;
+            }
+            throw protocolFailure();
+        }
+        catch (error) {
+            if (this.cancelledValue)
+                return;
+            const target = this.boundaryTarget;
+            if (target) {
+                await target({
+                    kind: 'encrypted_upload_v2_failed',
+                    error: coreProtocolError(error),
+                }).catch(() => undefined);
+            }
+            throw error;
+        }
+    }
+    dispatchTarget(requestId, context) {
+        return async (event) => await context.dispatch(boundaryHostEvent(requestId, event));
+    }
+    validateCheckpointOwner(serialNumber, recordingUuid, recordingGeneration, uploadSessionId, ownerRevision) {
+        if (serialNumber !== this.state.serialNumber
+            || recordingUuid !== this.state.recording.uuid
+            || recordingGeneration !== this.state.recording.generation
+            || uploadSessionId !== this.state.uploadSessionId
+            || ownerRevision !== this.state.ownerRevision)
+            throw identityFailure();
+    }
+    validateStartEffect(effect) {
+        this.validateCheckpointOwner(effect.serialNumber, uuidString(effect.recordingUuid), effect.recordingGeneration, uuidString(effect.uploadSessionId), effect.ownerRevision);
+        if (effect.storageFormat !== this.state.recording.storageFormat
+            || effect.transportSessionId !== this.state.transportSessionId
+            || effect.materialId !== this.state.materialId
+            || effect.sinkId !== this.state.sinkId
+            || effect.policy !== this.state.policy
+            || effect.windowPackets !== this.state.windowPackets
+            || effect.dataPayloadBytes !== this.state.dataPayloadBytes
+            || effect.ciphertextLength !== this.state.recording.ciphertextLength
+            || !equalBytes(effect.ciphertextSha256, this.state.recording.ciphertextSha256)
+            || !this.preparedAuthorizationSha256
+            || !equalBytes(effect.authorizationSha256, this.preparedAuthorizationSha256)
+            || !sameOptionalCoreCheckpoint(effect.checkpoint, this.state.coreCheckpoint))
+            throw integrityFailure();
+    }
+    validateCompletion(sinkId, materialId, evidence) {
+        if (sinkId !== this.state.sinkId
+            || materialId !== this.state.materialId
+            || !this.completedEvidence
+            || !sameEvidence(evidence, this.completedEvidence))
+            throw integrityFailure();
+    }
+    requireReceiver() {
+        if (!this.receiver)
+            throw protocolFailure();
+        return this.receiver;
+    }
+    requireCompletedManifest() {
+        if (!this.completedManifest)
+            throw protocolFailure();
+        return this.completedManifest;
+    }
+    async uploadCiphertext(request, signal) {
+        const combinedSignal = AbortSignal.any([
+            signal,
+            this.uploadAbort.signal,
+        ]);
+        const body = blobReadableStream(this.blob, combinedSignal);
+        const init = {
+            method: 'PUT',
+            headers: { ...request.headers },
+            body,
+            signal: combinedSignal,
+            redirect: 'error',
+            duplex: 'half',
+        };
+        const pendingResponse = this.fetcher(request.url, init);
+        let response;
+        try {
+            response = await abortable(pendingResponse, combinedSignal);
+        }
+        catch (error) {
+            if (combinedSignal.aborted) {
+                void pendingResponse.then(async (lateResponse) => {
+                    await lateResponse.body?.cancel().catch(() => undefined);
+                }, () => undefined);
+            }
+            throw error;
+        }
+        throwIfCancelled(this.cancelledValue, combinedSignal);
+        if (!response.ok) {
+            await response.body?.cancel().catch(() => undefined);
+            throw new BotaSDKError('upload_failed', 'upload', { retryable: true });
+        }
+    }
+    async abortState() {
+        if (this.abortPromise)
+            return await this.abortPromise;
+        this.cancelledValue = true;
+        this.abortPromise = (async () => {
+            this.uploadAbort.abort();
+            this.boundaryGate?.resolve(undefined);
+            let failure = null;
+            let signedTerminalJoined = false;
+            try {
+                await this.signedWriter.cancel();
+                signedTerminalJoined = true;
+            }
+            catch (error) {
+                failure = error;
+            }
+            if (signedTerminalJoined) {
+                this.material.authorization.fill(0);
+                this.acceptedReceipt?.fill(0);
+                this.acceptedReceipt = null;
+            }
+            try {
+                await this.transferControl.abort();
+            }
+            catch (error) {
+                failure ??= error;
+            }
+            try {
+                await awaitProviderCall(this.material.cancel(this.uploadAbort.signal), this.uploadAbort.signal, 'upload');
+            }
+            catch (error) {
+                if (!this.uploadAbort.signal.aborted)
+                    failure ??= error;
+            }
+            if (failure !== null)
+                throw normalizeHostError(failure);
+        })();
+        return await this.abortPromise;
+    }
+}
+export class EncryptedUploadV2TransferReceiver {
+    core;
+    blob;
+    options;
+    checkpoint;
+    packets = new Map();
+    pendingWindow = null;
+    manifest = new Uint8Array(MANIFEST_LENGTH);
+    manifestPresent = new Uint8Array(MANIFEST_LENGTH);
+    manifestSha256 = null;
+    prepared = false;
+    terminal = false;
+    completed = false;
+    bufferedBytes = 0;
+    constructor(core, blob, options) {
+        this.core = core;
+        this.blob = blob;
+        this.options = {
+            ...options,
+            expectedCiphertextSha256: options.expectedCiphertextSha256.slice(),
+            checkpoint: copyNativeCheckpoint(options.checkpoint),
+        };
+        this.checkpoint = copyNativeCheckpoint(options.checkpoint);
+        if (options.transportSessionId <= 0n
+            || options.expectedCiphertextLength <= 0n
+            || options.expectedCiphertextLength > BigInt(Number.MAX_SAFE_INTEGER)
+            || options.expectedCiphertextSha256.byteLength !== 32
+            || options.maximumDataPayloadBytes <= 0
+            || options.maximumWindowPackets <= 0
+            || options.maximumMissingSequences <= 0
+            || options.checkpoint.nextCiphertextOffset < 0n
+            || options.checkpoint.nextCiphertextOffset > options.expectedCiphertextLength
+            || options.checkpoint.prefixSha256.byteLength !== 32
+            || ((options.checkpoint.nextCiphertextOffset === 0n)
+                !== (options.checkpoint.highestContiguousSequence === null)))
+            throw protocolFailure();
+    }
+    async prepare() {
+        const checkpointOffset = safeNumber(this.checkpoint.nextCiphertextOffset);
+        const size = await this.blob.size();
+        if (size < checkpointOffset)
+            throw integrityFailure();
+        if (size !== checkpointOffset)
+            await this.blob.truncate(checkpointOffset);
+        const digest = await hashBlobPrefix(this.core, this.blob, checkpointOffset);
+        if (!equalBytes(digest, this.checkpoint.prefixSha256)) {
+            throw integrityFailure();
+        }
+        this.prepared = true;
+    }
+    async receive(frame) {
+        if (!this.prepared || this.terminal || this.completed)
+            throw protocolFailure();
+        if (frame.transportSessionId !== this.options.transportSessionId) {
+            this.terminal = true;
+            throw identityFailure();
+        }
+        try {
+            switch (frame.kind) {
+                case 'data':
+                    this.receiveData(frame);
+                    return null;
+                case 'window_end':
+                    return await this.receiveWindowEnd(frame);
+                case 'manifest_chunk':
+                    this.receiveManifest(frame);
+                    return null;
+                case 'eof': {
+                    const completed = await this.receiveEof(frame);
+                    this.completed = true;
+                    return completed;
+                }
+                case 'error':
+                    throw new BotaSDKError('protocol_error', 'transfer_recording', { protocolStatus: frame.result });
+                default:
+                    throw protocolFailure();
+            }
+        }
+        catch (error) {
+            this.terminal = true;
+            throw normalizeHostError(error);
+        }
+    }
+    repairAcknowledgement(missingSequences) {
+        const pending = this.pendingWindow;
+        if (!pending
+            || pending.missingSequences.length === 0
+            || !equalNumbers(pending.missingSequences, missingSequences))
+            throw protocolFailure();
+        return this.acknowledgement(pending, pending.highestContiguousSequence, pending.contiguousOffset, pending.contiguousSha256, this.checkpoint.revision, missingSequences);
+    }
+    checkpointDidPersist(checkpoint) {
+        const pending = this.pendingWindow;
+        if (!pending
+            || pending.missingSequences.length !== 0
+            || !sameCheckpoint(pending.checkpoint, checkpoint))
+            throw protocolFailure();
+        pending.persisted = true;
+    }
+    windowAcknowledgement(checkpoint) {
+        const pending = this.pendingWindow;
+        if (!pending
+            || pending.missingSequences.length !== 0
+            || !sameCheckpoint(pending.checkpoint, checkpoint)
+            || !pending.persisted)
+            throw protocolFailure();
+        const acknowledgement = this.acknowledgement(pending, pending.boundary.lastSequence, checkpoint.nextCiphertextOffset, checkpoint.prefixSha256, checkpoint.revision, []);
+        this.checkpoint = copyNativeCheckpoint(checkpoint);
+        this.packets.clear();
+        this.bufferedBytes = 0;
+        this.pendingWindow = null;
+        return acknowledgement;
+    }
+    receiveData(frame) {
+        const end = frame.offset + BigInt(frame.data.byteLength);
+        const repair = this.pendingWindow?.missingSequences ?? null;
+        if (frame.data.byteLength === 0
+            || frame.data.byteLength > this.options.maximumDataPayloadBytes
+            || frame.offset < this.checkpoint.nextCiphertextOffset
+            || end > this.options.expectedCiphertextLength
+            || (repair !== null && !repair.includes(frame.sequence)))
+            throw protocolFailure();
+        const metadata = {
+            offset: frame.offset,
+            bytes: frame.data.slice(),
+            sha256: sha256(this.core, frame.data),
+        };
+        const existing = this.packets.get(frame.sequence);
+        if (existing) {
+            if (existing.offset !== metadata.offset
+                || existing.bytes.byteLength !== metadata.bytes.byteLength
+                || !equalBytes(existing.sha256, metadata.sha256)
+                || !equalBytes(existing.bytes, metadata.bytes))
+                throw integrityFailure();
+            return;
+        }
+        if (this.packets.size >= this.options.maximumWindowPackets
+            || [...this.packets.values()].some((candidate) => overlaps(candidate, metadata))
+            || this.bufferedBytes + metadata.bytes.byteLength + 80 > MAXIMUM_QUEUED_BYTES)
+            throw protocolFailure();
+        this.packets.set(frame.sequence, metadata);
+        this.bufferedBytes += metadata.bytes.byteLength + 80;
+    }
+    async receiveWindowEnd(frame) {
+        if (this.pendingWindow && !sameWindow(this.pendingWindow.boundary, frame)) {
+            throw protocolFailure();
+        }
+        const previous = this.checkpoint.highestContiguousSequence;
+        const follows = previous === null
+            || (previous < 0xffffffff && frame.firstSequence === previous + 1);
+        const span = frame.lastSequence - frame.firstSequence;
+        if (frame.firstSequence > frame.lastSequence
+            || !follows
+            || frame.checkpointRevision <= this.checkpoint.revision
+            || frame.nextCiphertextOffset <= this.checkpoint.nextCiphertextOffset
+            || frame.nextCiphertextOffset > this.options.expectedCiphertextLength
+            || frame.prefixSha256.byteLength !== 32
+            || span >= this.options.maximumWindowPackets
+            || [...this.packets.keys()].some((sequence) => sequence < frame.firstSequence || sequence > frame.lastSequence))
+            throw protocolFailure();
+        const missing = [];
+        for (let sequence = frame.firstSequence; sequence <= frame.lastSequence; sequence += 1) {
+            if (!this.packets.has(sequence))
+                missing.push(sequence);
+        }
+        if (missing.length > this.options.maximumMissingSequences) {
+            throw protocolFailure();
+        }
+        let contiguousOffset = this.checkpoint.nextCiphertextOffset;
+        let highest = frame.firstSequence === 0 ? 0 : frame.firstSequence - 1;
+        for (let sequence = frame.firstSequence; sequence <= frame.lastSequence; sequence += 1) {
+            const packet = this.packets.get(sequence);
+            if (!packet)
+                break;
+            if (packet.offset !== contiguousOffset)
+                throw integrityFailure();
+            contiguousOffset += BigInt(packet.bytes.byteLength);
+            highest = sequence;
+        }
+        const contiguousSha256 = await this.hashProspectivePrefix(frame.firstSequence, highest);
+        const checkpoint = {
+            revision: frame.checkpointRevision,
+            nextCiphertextOffset: frame.nextCiphertextOffset,
+            prefixSha256: frame.prefixSha256.slice(),
+            highestContiguousSequence: frame.lastSequence,
+        };
+        if (missing.length === 0) {
+            if (contiguousOffset !== frame.nextCiphertextOffset
+                || !equalBytes(contiguousSha256, frame.prefixSha256))
+                throw integrityFailure();
+            await this.flushWindow(frame.firstSequence, frame.lastSequence);
+        }
+        this.pendingWindow = {
+            boundary: copyWindow(frame),
+            checkpoint,
+            missingSequences: missing,
+            highestContiguousSequence: highest,
+            contiguousOffset,
+            contiguousSha256,
+            persisted: false,
+        };
+        return {
+            kind: 'window_staged',
+            checkpoint: copyNativeCheckpoint(checkpoint),
+            missingSequences: [...missing],
+        };
+    }
+    receiveManifest(frame) {
+        const end = frame.chunkOffset + frame.chunk.byteLength;
+        if (this.pendingWindow !== null
+            || frame.totalManifestLength !== MANIFEST_LENGTH
+            || frame.manifestSha256.byteLength !== 32
+            || frame.chunk.byteLength === 0
+            || end > MANIFEST_LENGTH
+            || (this.manifestSha256 !== null
+                && !equalBytes(this.manifestSha256, frame.manifestSha256)))
+            throw protocolFailure();
+        for (let relative = 0; relative < frame.chunk.byteLength; relative += 1) {
+            const index = frame.chunkOffset + relative;
+            if (this.manifestPresent[index] && this.manifest[index] !== frame.chunk[relative]) {
+                throw integrityFailure();
+            }
+            this.manifest[index] = frame.chunk[relative] ?? 0;
+            this.manifestPresent[index] = 1;
+        }
+        this.manifestSha256 = frame.manifestSha256.slice();
+    }
+    async receiveEof(frame) {
+        const size = await this.blob.size();
+        const digest = await hashBlobPrefix(this.core, this.blob, size);
+        if (this.pendingWindow !== null
+            || this.packets.size !== 0
+            || this.checkpoint.highestContiguousSequence !== frame.finalSequence
+            || frame.blockCount === 0
+            || frame.ciphertextLength !== this.options.expectedCiphertextLength
+            || !equalBytes(frame.ciphertextSha256, this.options.expectedCiphertextSha256)
+            || this.manifestSha256 === null
+            || !equalBytes(frame.manifestSha256, this.manifestSha256)
+            || this.manifestPresent.some((present) => present !== 1)
+            || !equalBytes(sha256(this.core, this.manifest), frame.manifestSha256)
+            || BigInt(size) !== this.options.expectedCiphertextLength
+            || !equalBytes(digest, this.options.expectedCiphertextSha256))
+            throw integrityFailure();
+        return {
+            kind: 'completed',
+            manifest: this.manifest.slice(),
+            evidence: {
+                ciphertextLength: frame.ciphertextLength,
+                ciphertextSha256: frame.ciphertextSha256.slice(),
+                manifestLength: MANIFEST_LENGTH,
+                manifestSha256: frame.manifestSha256.slice(),
+                blockCount: frame.blockCount,
+            },
+        };
+    }
+    async flushWindow(firstSequence, lastSequence) {
+        let offset = safeNumber(this.checkpoint.nextCiphertextOffset);
+        for (let sequence = firstSequence; sequence <= lastSequence; sequence += 1) {
+            const packet = this.packets.get(sequence);
+            if (!packet || safeNumber(packet.offset) !== offset)
+                throw integrityFailure();
+            await this.blob.write(offset, packet.bytes);
+            offset += packet.bytes.byteLength;
+        }
+    }
+    async hashProspectivePrefix(firstSequence, highestSequence) {
+        const hasher = this.core.createIntegrityHasher();
+        const prefixLength = safeNumber(this.checkpoint.nextCiphertextOffset);
+        for await (const chunk of this.blob.stream(64 * 1024)) {
+            if (hasher.length() + BigInt(chunk.byteLength) > BigInt(prefixLength)) {
+                const remaining = prefixLength - safeNumber(hasher.length());
+                if (remaining > 0)
+                    hasher.update(chunk.slice(0, remaining));
+                break;
+            }
+            hasher.update(chunk);
+        }
+        if (hasher.length() !== BigInt(prefixLength))
+            throw integrityFailure();
+        for (let sequence = firstSequence; sequence <= highestSequence; sequence += 1) {
+            const packet = this.packets.get(sequence);
+            if (!packet)
+                break;
+            hasher.update(packet.bytes);
+        }
+        return hasher.sha256Snapshot();
+    }
+    acknowledgement(pending, highestContiguousSequence, nextCiphertextOffset, prefixSha256, checkpointRevision, missingSequences) {
+        return {
+            kind: 'window_ack',
+            flags: 0,
+            transportSessionId: this.options.transportSessionId,
+            windowIndex: pending.boundary.windowIndex,
+            highestContiguousSequence,
+            nextCiphertextOffset,
+            prefixSha256: prefixSha256.slice(),
+            checkpointRevision,
+            missingSequences: [...missingSequences],
+        };
+    }
+}
+export function initialEncryptedUploadV2Checkpoint() {
+    return {
+        revision: 0,
+        nextCiphertextOffset: 0n,
+        prefixSha256: hexBytes(EMPTY_SHA256_HEX),
+        highestContiguousSequence: null,
+    };
+}
+export function coreCheckpoint(serialNumber, recordingUuid, recordingGeneration, uploadSessionId, ownerRevision, transportSessionId, checkpoint, windowPackets, dataPayloadBytes) {
+    return {
+        serialNumber,
+        recordingUuid: recordingUuid.slice(),
+        recordingGeneration,
+        uploadSessionId: uploadSessionId.slice(),
+        ownerRevision,
+        transportSessionId,
+        checkpointRevision: checkpoint.revision,
+        nextCiphertextOffset: checkpoint.nextCiphertextOffset,
+        prefixSha256: checkpoint.prefixSha256.slice(),
+        windowPackets,
+        dataPayloadBytes,
+    };
+}
+function copyRecordingEntry(frame) {
+    return { ...frame, ciphertextSha256: frame.ciphertextSha256.slice() };
+}
+function copyNativeCheckpoint(checkpoint) {
+    return { ...checkpoint, prefixSha256: checkpoint.prefixSha256.slice() };
+}
+function copyWindow(frame) {
+    return { ...frame, prefixSha256: frame.prefixSha256.slice() };
+}
+function copyTransferRequest(request) {
+    return {
+        ...request,
+        authorizationSha256: request.authorizationSha256.slice(),
+        expectedCiphertextSha256: request.expectedCiphertextSha256.slice(),
+    };
+}
+function validateTransferRequest(request) {
+    if (request.transportSessionId <= 0n
+        || request.authorizationSha256.byteLength !== 32
+        || request.expectedCiphertextSha256.byteLength !== 32
+        || request.expectedCiphertextLength <= 0n
+        || !isUint32(request.recordingGeneration)
+        || !isUint32(request.expectedCheckpointIntervalBlocks)
+        || request.expectedCheckpointIntervalBlocks === 0
+        || request.windowPackets <= 0
+        || request.windowPackets > 0xffff
+        || request.dataPayloadBytes <= 0
+        || request.dataPayloadBytes > 0xffff)
+        throw protocolFailure();
+}
+function validateStartAcknowledgement(request, response) {
+    if (response.uploadSessionUuid !== request.uploadSessionUuid
+        || response.recordingUuid !== request.recordingUuid
+        || response.recordingGeneration !== request.recordingGeneration
+        || response.ciphertextLength !== request.expectedCiphertextLength
+        || !equalBytes(response.ciphertextSha256, request.expectedCiphertextSha256)
+        || response.windowPackets !== request.windowPackets
+        || response.dataPayloadBytes !== request.dataPayloadBytes
+        || response.checkpointIntervalBlocks
+            !== request.expectedCheckpointIntervalBlocks
+        || response.checkpointRevision !== 0
+        || response.nextCiphertextOffset !== 0n
+        || !equalBytes(response.prefixSha256, initialEncryptedUploadV2Checkpoint().prefixSha256))
+        throw identityFailure();
+}
+function validateResumeAcknowledgement(request, checkpoint, response) {
+    if (response.uploadSessionUuid !== request.uploadSessionUuid
+        || response.recordingUuid !== request.recordingUuid
+        || response.recordingGeneration !== request.recordingGeneration
+        || response.checkpointRevision !== checkpoint.revision
+        || response.nextCiphertextOffset !== checkpoint.nextCiphertextOffset
+        || !equalBytes(response.prefixSha256, checkpoint.prefixSha256)
+        || response.windowPackets !== request.windowPackets
+        || response.dataPayloadBytes !== request.dataPayloadBytes)
+        throw identityFailure();
+}
+function sameWindow(left, right) {
+    return left.transportSessionId === right.transportSessionId
+        && left.windowIndex === right.windowIndex
+        && left.firstSequence === right.firstSequence
+        && left.lastSequence === right.lastSequence
+        && left.nextCiphertextOffset === right.nextCiphertextOffset
+        && left.checkpointRevision === right.checkpointRevision
+        && equalBytes(left.prefixSha256, right.prefixSha256);
+}
+function sameCheckpoint(left, right) {
+    return left.revision === right.revision
+        && left.nextCiphertextOffset === right.nextCiphertextOffset
+        && left.highestContiguousSequence === right.highestContiguousSequence
+        && equalBytes(left.prefixSha256, right.prefixSha256);
+}
+function overlaps(left, right) {
+    const leftEnd = left.offset + BigInt(left.bytes.byteLength);
+    const rightEnd = right.offset + BigInt(right.bytes.byteLength);
+    return left.offset < rightEnd && right.offset < leftEnd;
+}
+async function hashBlobPrefix(core, blob, length) {
+    const hasher = core.createIntegrityHasher();
+    for await (const chunk of blob.stream(64 * 1024)) {
+        const remaining = length - safeNumber(hasher.length());
+        if (remaining <= 0)
+            break;
+        hasher.update(chunk.byteLength <= remaining ? chunk : chunk.slice(0, remaining));
+    }
+    if (hasher.length() !== BigInt(length))
+        throw integrityFailure();
+    return hasher.sha256Snapshot();
+}
+function sha256(core, value) {
+    const hasher = core.createIntegrityHasher();
+    hasher.update(value);
+    return hasher.sha256Snapshot();
+}
+function hexBytes(value) {
+    return Uint8Array.from(value.match(/../g) ?? [], (byte) => Number.parseInt(byte, 16));
+}
+function equalBytes(left, right) {
+    if (left.byteLength !== right.byteLength)
+        return false;
+    let different = 0;
+    for (let index = 0; index < left.byteLength; index += 1) {
+        different |= (left[index] ?? 0) ^ (right[index] ?? 0);
+    }
+    return different === 0;
+}
+function equalNumbers(left, right) {
+    return left.length === right.length
+        && left.every((value, index) => value === right[index]);
+}
+function boundaryHostEvent(requestId, event) {
+    switch (event.kind) {
+        case 'encrypted_upload_v2_window_staged':
+            return { requestId, ...event };
+        case 'encrypted_upload_v2_transfer_completed':
+            return { requestId, ...event };
+        case 'encrypted_upload_v2_mixed_profile':
+            return { requestId, ...event };
+        case 'encrypted_upload_v2_failed':
+            return { requestId, ...event };
+    }
+}
+function coreProtocolError(error) {
+    const normalized = normalizeHostError(error);
+    return {
+        code: normalized.code === 'integrity_failed'
+            ? 'IntegrityFailed'
+            : normalized.code === 'identity_mismatch'
+                ? 'IdentityMismatch'
+                : 'ProtocolRejected',
+        operation: 'TransferRecording',
+        retryable: normalized.retryable,
+        protocol_status: normalized.protocolStatus ?? undefined,
+        detail: 'encrypted_upload_v2_browser_host_failure',
+    };
+}
+function sameEvidence(left, right) {
+    return left.ciphertextLength === right.ciphertextLength
+        && equalBytes(left.ciphertextSha256, right.ciphertextSha256)
+        && left.manifestLength === right.manifestLength
+        && equalBytes(left.manifestSha256, right.manifestSha256)
+        && left.blockCount === right.blockCount;
+}
+function copyEvidence(evidence) {
+    return {
+        ...evidence,
+        ciphertextSha256: evidence.ciphertextSha256.slice(),
+        manifestSha256: evidence.manifestSha256.slice(),
+    };
+}
+function providerEvidence(evidence) {
+    return copyEvidence(evidence);
+}
+function copyCoreCheckpoint(checkpoint) {
+    return {
+        ...checkpoint,
+        recordingUuid: checkpoint.recordingUuid.slice(),
+        uploadSessionId: checkpoint.uploadSessionId.slice(),
+        prefixSha256: checkpoint.prefixSha256.slice(),
+    };
+}
+function sameCoreCheckpoint(left, right) {
+    return left.serialNumber === right.serialNumber
+        && equalBytes(left.recordingUuid, right.recordingUuid)
+        && left.recordingGeneration === right.recordingGeneration
+        && equalBytes(left.uploadSessionId, right.uploadSessionId)
+        && left.ownerRevision === right.ownerRevision
+        && left.transportSessionId === right.transportSessionId
+        && left.checkpointRevision === right.checkpointRevision
+        && left.nextCiphertextOffset === right.nextCiphertextOffset
+        && equalBytes(left.prefixSha256, right.prefixSha256)
+        && left.windowPackets === right.windowPackets
+        && left.dataPayloadBytes === right.dataPayloadBytes;
+}
+function sameOptionalCoreCheckpoint(left, right) {
+    return left === null || right === null
+        ? left === right
+        : sameCoreCheckpoint(left, right);
+}
+function sameCoreAndNativeCheckpoint(core, native, state) {
+    return core.serialNumber === state.serialNumber
+        && uuidString(core.recordingUuid) === state.recording.uuid
+        && core.recordingGeneration === state.recording.generation
+        && uuidString(core.uploadSessionId) === state.uploadSessionId
+        && core.ownerRevision === state.ownerRevision
+        && core.transportSessionId === state.transportSessionId
+        && core.checkpointRevision === native.revision
+        && core.nextCiphertextOffset === native.nextCiphertextOffset
+        && equalBytes(core.prefixSha256, native.prefixSha256)
+        && core.windowPackets === state.windowPackets
+        && core.dataPayloadBytes === state.dataPayloadBytes;
+}
+function copyPersistedState(state) {
+    return {
+        ...state,
+        recording: {
+            ...state.recording,
+            ciphertextSha256: state.recording.ciphertextSha256.slice(),
+        },
+        coreCheckpoint: state.coreCheckpoint
+            ? copyCoreCheckpoint(state.coreCheckpoint)
+            : null,
+        evidence: state.evidence ? copyEvidence(state.evidence) : null,
+    };
+}
+export function parsePersistedEncryptedUploadV2State(value) {
+    if (!isRecord(value) || value.schemaVersion !== 1)
+        throw integrityFailure();
+    const recording = value.recording;
+    const coreCheckpointValue = value.coreCheckpoint;
+    const evidenceValue = value.evidence;
+    if (!isRecord(recording)
+        || typeof recording.uuid !== 'string'
+        || !isUuid(recording.uuid)
+        || !isUint32(recording.generation)
+        || typeof recording.storageFormat !== 'number'
+        || !Number.isInteger(recording.storageFormat)
+        || recording.storageFormat <= 0
+        || recording.storageFormat > 0xff
+        || typeof recording.ciphertextLength !== 'bigint'
+        || recording.ciphertextLength <= 0n
+        || recording.ciphertextLength > BigInt(Number.MAX_SAFE_INTEGER)
+        || !(recording.ciphertextSha256 instanceof Uint8Array)
+        || recording.ciphertextSha256.byteLength !== 32
+        || typeof value.operationId !== 'string'
+        || value.operationId.length === 0
+        || typeof value.serialNumber !== 'string'
+        || value.serialNumber.length === 0
+        || typeof value.materialId !== 'string'
+        || value.materialId.length === 0
+        || typeof value.recordingId !== 'string'
+        || value.recordingId.length === 0
+        || typeof value.uploadSessionId !== 'string'
+        || !isUuid(value.uploadSessionId)
+        || !isUint32(value.ownerRevision)
+        || value.ownerRevision === 0
+        || !isUploadPolicy(value.policy)
+        || typeof value.transportSessionId !== 'bigint'
+        || value.transportSessionId <= 0n
+        || typeof value.sinkId !== 'string'
+        || value.sinkId.length === 0
+        || !isPositiveU16(value.windowPackets)
+        || !isPositiveU16(value.dataPayloadBytes)
+        || !isPositiveU16(value.maximumSignedBlobBytes)
+        || !isPositiveU16(value.maximumMissingSequences)
+        || !isUint32(value.checkpointIntervalBlocks)
+        || value.checkpointIntervalBlocks === 0
+        || typeof value.capabilitySha256Hex !== 'string'
+        || !/^[0-9a-f]{64}$/.test(value.capabilitySha256Hex)
+        || (value.highestContiguousSequence !== null
+            && !isUint32(value.highestContiguousSequence)))
+        throw integrityFailure();
+    if (coreCheckpointValue !== null)
+        validateCoreCheckpoint(coreCheckpointValue);
+    if (evidenceValue !== null)
+        validateEvidence(evidenceValue);
+    const state = {
+        schemaVersion: 1,
+        operationId: value.operationId,
+        serialNumber: value.serialNumber,
+        recording: {
+            uuid: recording.uuid,
+            generation: recording.generation,
+            storageFormat: recording.storageFormat,
+            ciphertextLength: recording.ciphertextLength,
+            ciphertextSha256: recording.ciphertextSha256.slice(),
+        },
+        materialId: value.materialId,
+        recordingId: value.recordingId,
+        uploadSessionId: value.uploadSessionId,
+        ownerRevision: value.ownerRevision,
+        policy: value.policy,
+        transportSessionId: value.transportSessionId,
+        sinkId: value.sinkId,
+        windowPackets: value.windowPackets,
+        dataPayloadBytes: value.dataPayloadBytes,
+        maximumSignedBlobBytes: value.maximumSignedBlobBytes,
+        maximumMissingSequences: value.maximumMissingSequences,
+        checkpointIntervalBlocks: value.checkpointIntervalBlocks,
+        capabilitySha256Hex: value.capabilitySha256Hex,
+        coreCheckpoint: coreCheckpointValue === null
+            ? null
+            : copyCoreCheckpoint(coreCheckpointValue),
+        highestContiguousSequence: value.highestContiguousSequence,
+        evidence: evidenceValue === null
+            ? null
+            : copyEvidence(evidenceValue),
+    };
+    validatePersistedStateBindings(state);
+    return state;
+}
+function validatePersistedStateBindings(state) {
+    const checkpoint = state.coreCheckpoint;
+    if (!checkpoint) {
+        if (state.highestContiguousSequence !== null) {
+            throw integrityFailure();
+        }
+        if (state.evidence
+            && (state.evidence.ciphertextLength !== state.recording.ciphertextLength
+                || !equalBytes(state.evidence.ciphertextSha256, state.recording.ciphertextSha256)))
+            throw integrityFailure();
+        return;
+    }
+    if (checkpoint.serialNumber !== state.serialNumber
+        || uuidString(checkpoint.recordingUuid) !== state.recording.uuid
+        || checkpoint.recordingGeneration !== state.recording.generation
+        || uuidString(checkpoint.uploadSessionId) !== state.uploadSessionId
+        || checkpoint.ownerRevision !== state.ownerRevision
+        || checkpoint.transportSessionId !== state.transportSessionId
+        || checkpoint.checkpointRevision === 0
+        || checkpoint.nextCiphertextOffset <= 0n
+        || checkpoint.nextCiphertextOffset > state.recording.ciphertextLength
+        || checkpoint.windowPackets !== state.windowPackets
+        || checkpoint.dataPayloadBytes !== state.dataPayloadBytes
+        || state.highestContiguousSequence === null)
+        throw integrityFailure();
+    const evidence = state.evidence;
+    if (evidence
+        && (evidence.ciphertextLength !== state.recording.ciphertextLength
+            || !equalBytes(evidence.ciphertextSha256, state.recording.ciphertextSha256)
+            || checkpoint.nextCiphertextOffset !== state.recording.ciphertextLength
+            || !equalBytes(checkpoint.prefixSha256, state.recording.ciphertextSha256)))
+        throw integrityFailure();
+}
+function validateCoreCheckpoint(value) {
+    if (!isRecord(value)
+        || typeof value.serialNumber !== 'string'
+        || !(value.recordingUuid instanceof Uint8Array)
+        || value.recordingUuid.byteLength !== 16
+        || !isUint32(value.recordingGeneration)
+        || !(value.uploadSessionId instanceof Uint8Array)
+        || value.uploadSessionId.byteLength !== 16
+        || !isUint32(value.ownerRevision)
+        || typeof value.transportSessionId !== 'bigint'
+        || !isUint32(value.checkpointRevision)
+        || typeof value.nextCiphertextOffset !== 'bigint'
+        || !(value.prefixSha256 instanceof Uint8Array)
+        || value.prefixSha256.byteLength !== 32
+        || !isPositiveU16(value.windowPackets)
+        || !isPositiveU16(value.dataPayloadBytes))
+        throw integrityFailure();
+}
+function validateEvidence(value) {
+    if (!isRecord(value)
+        || typeof value.ciphertextLength !== 'bigint'
+        || !(value.ciphertextSha256 instanceof Uint8Array)
+        || value.ciphertextSha256.byteLength !== 32
+        || value.manifestLength !== MANIFEST_LENGTH
+        || !(value.manifestSha256 instanceof Uint8Array)
+        || value.manifestSha256.byteLength !== 32
+        || !isUint32(value.blockCount)
+        || value.blockCount === 0)
+        throw integrityFailure();
+}
+function validateUploadRequest(request) {
+    if (!isRecord(request) || request.method !== 'PUT') {
+        throw new BotaSDKError('upload_failed', 'upload');
+    }
+    if (typeof request.url !== 'string') {
+        throw new BotaSDKError('upload_failed', 'upload');
+    }
+    let url;
+    try {
+        url = new URL(request.url);
+    }
+    catch {
+        throw new BotaSDKError('upload_failed', 'upload');
+    }
+    if (url.protocol !== 'https:' || !isRecord(request.headers)) {
+        throw new BotaSDKError('upload_failed', 'upload');
+    }
+    for (const [name, value] of Object.entries(request.headers)) {
+        if (name.length === 0
+            || typeof value !== 'string'
+            || /[\r\n]/.test(name)
+            || /[\r\n]/.test(value))
+            throw new BotaSDKError('upload_failed', 'upload');
+    }
+}
+function blobReadableStream(blob, signal) {
+    const iterator = blob.stream(64 * 1024)[Symbol.asyncIterator]();
+    return new ReadableStream({
+        pull: async (controller) => {
+            try {
+                if (signal.aborted)
+                    throw cancelled();
+                const next = await iterator.next();
+                if (next.done)
+                    controller.close();
+                else
+                    controller.enqueue(next.value);
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+        cancel: async () => {
+            await iterator.return?.();
+        },
+    });
+}
+function uuidBytes(value) {
+    if (!isUuid(value)) {
+        throw protocolFailure();
+    }
+    return hexBytes(value.replaceAll('-', ''));
+}
+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 uuidString(value) {
+    if (value.byteLength !== 16)
+        throw protocolFailure();
+    const hex = hexString(value);
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function hexString(value) {
+    return Array.from(value, (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isPositiveU16(value) {
+    return typeof value === 'number'
+        && Number.isInteger(value)
+        && value > 0
+        && value <= 0xffff;
+}
+function isUploadPolicy(value) {
+    return value === 'legacy_allowed'
+        || value === 'v2_preferred'
+        || value === 'v2_required';
+}
+function safeNumber(value) {
+    if (value < 0n || value > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw protocolFailure();
+    }
+    return Number(value);
+}
+function isUint32(value) {
+    return typeof value === 'number'
+        && Number.isInteger(value)
+        && value >= 0
+        && value <= 0xffffffff;
+}
+function throwIfCancelled(cancelledValue, signal) {
+    if (cancelledValue || signal?.aborted)
+        throw cancelled();
+}
+function abortable(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted)
+        return Promise.reject(cancelled());
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(cancelled());
+        signal.addEventListener('abort', abort, { once: true });
+        void promise.then((value) => {
+            signal.removeEventListener('abort', abort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener('abort', abort);
+            reject(error);
+        });
+    });
+}
+class SerializedGattWrites {
+    tail = Promise.resolve();
+    run(write) {
+        const result = this.tail.then(write);
+        this.tail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+}
+function settle(promise) {
+    return promise.then(() => ({ error: null }), (error) => ({ error }));
+}
+async function boundedSettlement(settlement, timeoutMs) {
+    let timer = null;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), timeoutMs);
+    });
+    const result = await Promise.race([settlement, timeout]);
+    if (timer !== null)
+        clearTimeout(timer);
+    return result;
+}
+function rejectAfter(promise, timeoutMs, error) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(error()), timeoutMs);
+        void promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (reason) => {
+            clearTimeout(timer);
+            reject(reason);
+        });
+    });
+}
+function positiveTimeout(value, fallback) {
+    return value !== undefined
+        && Number.isFinite(value)
+        && value > 0
+        ? value
+        : fallback;
+}
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolvePromise, rejectPromise) => {
+        resolve = resolvePromise;
+        reject = rejectPromise;
+    });
+    return { promise, resolve, reject };
+}
+function normalizeHostError(error) {
+    if (error instanceof BotaSDKError)
+        return error;
+    if (error instanceof BrowserStorageError) {
+        return new BotaSDKError(error.code, 'transfer_recording');
+    }
+    if (error instanceof BrowserTransportError) {
+        const code = error.code === 'disconnected'
+            ? 'device_disconnected'
+            : error.code === 'permission_denied'
+                ? 'permission_denied'
+                : 'bluetooth_unavailable';
+        return new BotaSDKError(code, 'transfer_recording');
+    }
+    return protocolFailure(error);
+}
+function protocolFailure(cause) {
+    return new BotaSDKError('protocol_error', 'transfer_recording', { cause });
+}
+function identityFailure() {
+    return new BotaSDKError('identity_mismatch', 'transfer_recording');
+}
+function integrityFailure() {
+    return new BotaSDKError('integrity_failed', 'transfer_recording');
+}
+function cancelled() {
+    return new BotaSDKError('cancelled', 'transfer_recording');
+}
+function operationInProgress() {
+    return new BotaSDKError('operation_in_progress', 'transfer_recording');
+}
+function ownershipUnknown(cause) {
+    return new BotaSDKError('integrity_failed', 'transfer_recording', { cause });
+}
+function signedResultTimeout() {
+    return new BotaSDKError('connection_failed', 'transfer_recording', { retryable: true });
+}