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

package/dist/provisioningManager.js

@@ -0,0 +1,753 @@
+import { BotaSDKError, normalizeCoreError, } from "./errors.js";
+import { BOTA_CONTROL_SERVICE, BOTA_PROVISIONING_SERVICE, DEVICE_COMMAND_CHARACTERISTIC, DEVICE_INFORMATION_SERVICE, DEVICE_SETTINGS_CHARACTERISTIC, MODEL_NUMBER_CHARACTERISTIC, PROVISIONING_RESULT_CHARACTERISTIC, SERIAL_NUMBER_CHARACTERISTIC, canonicalGattUuid, } from "./gatt.js";
+import { awaitProviderCall } from "./providerCancellation.js";
+import { BrowserStorageError, } from "./storage.js";
+import { BrowserTransportError, } from "./transport.js";
+import { createBrowserPersistenceHost, } from "./workflowRuntime.js";
+const DEFAULT_DEPROVISION_TIMEOUT_MS = 30_000;
+export class ProvisioningManager {
+    core;
+    transport;
+    runtime;
+    devices;
+    storage;
+    provider;
+    now;
+    deprovisionTimeoutMs;
+    activeProvision = null;
+    destroyed = false;
+    destroyPromise = null;
+    constructor(options) {
+        this.core = options.core;
+        this.transport = options.transport;
+        this.runtime = options.runtime;
+        this.devices = options.devices;
+        this.storage = options.storage ?? null;
+        this.provider = options.provider ?? null;
+        this.now = options.now ?? Date.now;
+        this.deprovisionTimeoutMs =
+            options.deprovisionTimeoutMs ?? DEFAULT_DEPROVISION_TIMEOUT_MS;
+    }
+    async provision(request) {
+        this.validateProvisionRequest(request);
+        if (!this.provider) {
+            throw new BotaSDKError('unsupported_capability', 'provision');
+        }
+        if (!this.storage) {
+            throw new BotaSDKError('storage_unavailable', 'provision');
+        }
+        if (this.activeProvision) {
+            throw new BotaSDKError('operation_in_progress', 'provision');
+        }
+        let settle;
+        const active = {
+            controller: new AbortController(),
+            operationId: null,
+            physicalCompleted: false,
+            settled: new Promise((resolve) => {
+                settle = resolve;
+            }),
+            settle: () => settle(),
+        };
+        this.activeProvision = active;
+        const cancel = () => {
+            active.controller.abort();
+            if (active.operationId)
+                void this.runtime.cancel(active.operationId);
+        };
+        request.signal?.addEventListener('abort', cancel, { once: true });
+        if (request.signal?.aborted)
+            cancel();
+        try {
+            await this.runProvision(request.attemptId, active);
+        }
+        catch (error) {
+            const normalized = managerError(error, 'provision');
+            if (normalized.code === 'identity_mismatch')
+                await this.disconnectMismatch();
+            throw normalized;
+        }
+        finally {
+            request.signal?.removeEventListener('abort', cancel);
+            if (this.activeProvision === active)
+                this.activeProvision = null;
+            active.settle();
+        }
+    }
+    async deprovision(request) {
+        if (this.destroyed)
+            throw new BotaSDKError('cancelled', 'deprovision');
+        if (!(request.grant instanceof Uint8Array) || request.grant.byteLength === 0) {
+            throw new BotaSDKError('invalid_input', 'deprovision');
+        }
+        if (request.signal?.aborted) {
+            throw new BotaSDKError('cancelled', 'deprovision');
+        }
+        try {
+            return await this.runtime.runExclusive('deprovision', async (runtimeSignal) => await withCombinedSignal(runtimeSignal, request.signal, async (signal) => await this.performDeprovision(request.grant, signal)));
+        }
+        catch (error) {
+            const normalized = managerError(error, 'deprovision');
+            if (normalized.code === 'identity_mismatch')
+                await this.disconnectMismatch();
+            throw normalized;
+        }
+    }
+    async readConnectionSettings() {
+        if (this.destroyed)
+            throw new BotaSDKError('cancelled', 'settings');
+        try {
+            return await this.runtime.runExclusive('settings', async (signal) => {
+                const { device } = await this.verifyConnectedDevice(signal, true, 'settings');
+                const encoded = await this.gattStep(this.transport.read(device, BOTA_PROVISIONING_SERVICE, DEVICE_SETTINGS_CHARACTERISTIC), signal, 'settings');
+                return publicSettings(this.core.decodeConnectionSettings(encoded));
+            });
+        }
+        catch (error) {
+            const normalized = managerError(error, 'settings');
+            if (normalized.code === 'identity_mismatch')
+                await this.disconnectMismatch();
+            throw normalized;
+        }
+    }
+    async writeConnectionSettings(settings) {
+        if (this.destroyed)
+            throw new BotaSDKError('cancelled', 'settings');
+        try {
+            await this.runtime.runExclusive('settings', async (signal) => {
+                const { device, model } = await this.verifyConnectedDevice(signal, true, 'settings');
+                if (!model)
+                    throw new BotaSDKError('protocol_error', 'settings');
+                let encoded = null;
+                try {
+                    encoded = this.core.encodeConnectionSettings(coreSettings(settings), model);
+                    await this.gattStep(this.transport.write(device, BOTA_PROVISIONING_SERVICE, DEVICE_SETTINGS_CHARACTERISTIC, encoded, true), signal, 'settings');
+                }
+                finally {
+                    encoded?.fill(0);
+                }
+            });
+        }
+        catch (error) {
+            const normalized = managerError(error, 'settings');
+            if (normalized.code === 'identity_mismatch')
+                await this.disconnectMismatch();
+            throw normalized;
+        }
+    }
+    destroy() {
+        if (this.destroyPromise)
+            return this.destroyPromise;
+        this.destroyed = true;
+        this.destroyPromise = (async () => {
+            const active = this.activeProvision;
+            if (!active)
+                return;
+            active.controller.abort();
+            if (active.operationId)
+                await this.runtime.cancel(active.operationId);
+            await active.settled;
+        })();
+        return this.destroyPromise;
+    }
+    async runProvision(attemptId, active) {
+        const storage = this.storage;
+        const provider = this.provider;
+        if (!storage || !provider) {
+            throw new BotaSDKError('unsupported_capability', 'provision');
+        }
+        const connected = this.requireConnected('provision');
+        let journal;
+        let journals;
+        try {
+            const listJournals = storage.listProvisioningJournals;
+            const loaded = await Promise.all([
+                storage.loadProvisioningJournal(attemptId),
+                listJournals ? listJournals.call(storage) : Promise.resolve([]),
+            ]);
+            journal = loaded[0];
+            journals = loaded[1];
+        }
+        catch (error) {
+            throw managerError(error, 'provision');
+        }
+        if (journal) {
+            if (journal.serialNumber !== connected.serialNumber) {
+                throw new BotaSDKError('identity_mismatch', 'provision');
+            }
+            if (journal.phase === 'backend_confirmed')
+                return;
+            if (journal.phase === 'prepared') {
+                await this.requireProvisioningReconciliation(journal);
+                return;
+            }
+            if (journal.phase !== 'device_applied') {
+                throw new BotaSDKError('resume_rejected', 'provision');
+            }
+            await this.confirmProvisioning(journal, active.controller.signal);
+            return;
+        }
+        const unresolved = journals.find((candidate) => candidate.serialNumber === connected.serialNumber
+            && candidate.attemptId !== attemptId
+            && (candidate.phase === 'prepared' || candidate.phase === 'device_applied'));
+        if (unresolved) {
+            await this.requireProvisioningReconciliation(unresolved);
+            return;
+        }
+        this.throwIfProvisionCancelled(active);
+        const cancellationId = randomBytes(16);
+        const operationId = `provision:${bytesHex(cancellationId)}`;
+        const materialId = `web-${bytesHex(randomBytes(16))}`;
+        active.operationId = operationId;
+        const host = new ProvisioningMaterialHost({
+            provider,
+            storage,
+            transport: this.transport,
+            runtime: this.runtime,
+            attemptId,
+            materialId,
+            serialNumber: connected.serialNumber,
+            now: this.now,
+        });
+        try {
+            await this.runtime.run(operationId, cancellationId, () => this.core.startProvisioning({
+                serialNumber: connected.serialNumber,
+                materialId,
+                cancellationId: cancellationId.slice(),
+            }), {
+                persistence: createBrowserPersistenceHost(storage),
+                hostMaterial: host,
+            }, undefined, async () => {
+                active.physicalCompleted = true;
+                const prepared = host.preparedJournal;
+                if (!prepared)
+                    throw new BotaSDKError('internal_error', 'provision');
+                const deviceApplied = nextProvisioningJournal(prepared, 'device_applied', this.now);
+                await storage.saveProvisioningJournal(deviceApplied);
+                await this.confirmProvisioningWhileOwned(deviceApplied, active.controller.signal);
+            });
+        }
+        catch (error) {
+            const normalized = managerError(error, 'provision');
+            if (!active.physicalCompleted && host.prepareStarted) {
+                try {
+                    await host.abort(normalized.code, active.controller.signal);
+                    const prepared = host.preparedJournal;
+                    if (prepared) {
+                        await storage.saveProvisioningJournal(nextProvisioningJournal(prepared, 'aborted', this.now));
+                    }
+                }
+                catch {
+                    if (normalized.code === 'cancelled')
+                        throw normalized;
+                    throw new BotaSDKError('internal_error', 'provision', {
+                        retryable: true,
+                    });
+                }
+            }
+            throw normalized;
+        }
+        finally {
+            active.operationId = null;
+            cancellationId.fill(0);
+        }
+    }
+    async confirmProvisioning(journal, signal) {
+        try {
+            await this.runtime.runExclusive('provision', async (runtimeSignal) => await withCombinedSignal(runtimeSignal, signal, async (combined) => {
+                throwIfAborted(combined, 'provision');
+                await this.confirmProvisioningWhileOwned(journal, combined);
+                throwIfAborted(combined, 'provision');
+            }));
+        }
+        catch (error) {
+            const normalized = managerError(error, 'provision');
+            if (normalized.code === 'cancelled'
+                || normalized.code === 'operation_in_progress'
+                || normalized.code === 'storage_unavailable'
+                || normalized.code === 'storage_quota_exceeded'
+                || normalized.code === 'resume_rejected'
+                || normalized.code === 'reconciliation_required') {
+                throw normalized;
+            }
+            throw new BotaSDKError('internal_error', 'provision', { retryable: true });
+        }
+    }
+    async confirmProvisioningWhileOwned(journal, signal) {
+        const provider = this.provider;
+        const storage = this.storage;
+        if (!provider || !storage) {
+            throw new BotaSDKError('unsupported_capability', 'provision');
+        }
+        try {
+            await awaitProviderCall(provider.confirm({
+                attemptId: journal.attemptId,
+                serialNumber: journal.serialNumber,
+                signal,
+            }), signal, 'provision');
+        }
+        catch (error) {
+            if (error instanceof BotaSDKError && error.code === 'cancelled')
+                throw error;
+            throw new BotaSDKError('internal_error', 'provision', { retryable: true });
+        }
+        try {
+            await storage.saveProvisioningJournal(nextProvisioningJournal(journal, 'backend_confirmed', this.now));
+        }
+        catch (error) {
+            throw managerError(error, 'provision');
+        }
+    }
+    async requireProvisioningReconciliation(journal) {
+        return await this.runtime.runExclusive('provision', async (signal) => {
+            const connected = this.requireConnected('provision');
+            if (journal.serialNumber !== connected.serialNumber) {
+                throw new BotaSDKError('identity_mismatch', 'provision');
+            }
+            await this.verifyConnectedDevice(signal, false, 'provision');
+            throw new BotaSDKError('reconciliation_required', 'provision', {
+                retryable: true,
+            });
+        });
+    }
+    async performDeprovision(callerGrant, signal) {
+        const { device } = await this.verifyConnectedDevice(signal, false, 'deprovision');
+        const grant = callerGrant.slice();
+        let command = null;
+        let subscription = null;
+        let resultWindowOpen = false;
+        let resolveResult;
+        const result = new Promise((resolve) => {
+            resolveResult = resolve;
+        });
+        let resultReceived = false;
+        try {
+            await this.gattStep(this.transport.write(device, BOTA_CONTROL_SERVICE, DEVICE_COMMAND_CHARACTERISTIC, grant, true), signal, 'deprovision');
+            const subscribe = await settled(this.transport.subscribe(device, BOTA_PROVISIONING_SERVICE, PROVISIONING_RESULT_CHARACTERISTIC, (notification) => {
+                if (!resultWindowOpen
+                    || resultReceived
+                    || canonicalGattUuid(notification.characteristicUuid)
+                        !== canonicalGattUuid(PROVISIONING_RESULT_CHARACTERISTIC))
+                    return;
+                resultReceived = true;
+                resolveResult(notification.value.slice());
+            }));
+            if (subscribe.kind === 'failed')
+                throw subscribe.error;
+            subscription = subscribe.value;
+            throwIfAborted(signal, 'deprovision');
+            command = this.core.encodeDeprovisionCommand();
+            await this.gattStep(this.transport.write(device, BOTA_CONTROL_SERVICE, DEVICE_COMMAND_CHARACTERISTIC, command, true), signal, 'deprovision');
+            resultWindowOpen = true;
+            const encodedResult = await resultWithDeadline(result, signal, this.deprovisionTimeoutMs);
+            return deprovisionResult(this.core.decodeDeprovisionResult(encodedResult));
+        }
+        finally {
+            resultWindowOpen = false;
+            resultReceived = true;
+            grant.fill(0);
+            command?.fill(0);
+            if (subscription)
+                await subscription.remove().catch(() => undefined);
+        }
+    }
+    async verifyConnectedDevice(signal, includeModel, operation) {
+        const connected = this.requireConnected(operation);
+        const device = this.runtime.connectedDeviceHandle;
+        if (!device || device.id !== connected.id) {
+            throw new BotaSDKError('device_disconnected', operation);
+        }
+        const serialBytes = await this.gattStep(this.transport.read(device, DEVICE_INFORMATION_SERVICE, SERIAL_NUMBER_CHARACTERISTIC), signal, operation);
+        if (decodeRequiredText(serialBytes, operation) !== connected.serialNumber) {
+            throw new BotaSDKError('identity_mismatch', operation);
+        }
+        if (!includeModel)
+            return { device, model: null };
+        const modelBytes = await this.gattStep(this.transport.read(device, DEVICE_INFORMATION_SERVICE, MODEL_NUMBER_CHARACTERISTIC), signal, operation);
+        const model = deviceModel(decodeRequiredText(modelBytes, operation));
+        if (!model)
+            throw new BotaSDKError('protocol_error', operation);
+        return { device, model };
+    }
+    requireConnected(operation) {
+        const connected = this.devices.connectedDevice;
+        if (!connected || this.runtime.connectedDeviceHandle?.id !== connected.id) {
+            throw new BotaSDKError('device_disconnected', operation);
+        }
+        return connected;
+    }
+    async gattStep(promise, signal, operation) {
+        const outcome = await settled(promise);
+        if (outcome.kind === 'failed')
+            throw outcome.error;
+        throwIfAborted(signal, operation);
+        return outcome.value;
+    }
+    validateProvisionRequest(request) {
+        if (this.destroyed)
+            throw new BotaSDKError('cancelled', 'provision');
+        if (typeof request.attemptId !== 'string' || request.attemptId.length === 0) {
+            throw new BotaSDKError('invalid_input', 'provision');
+        }
+        if (request.signal?.aborted) {
+            throw new BotaSDKError('cancelled', 'provision');
+        }
+    }
+    throwIfProvisionCancelled(active) {
+        if (this.destroyed || active.controller.signal.aborted) {
+            throw new BotaSDKError('cancelled', 'provision');
+        }
+    }
+    async disconnectMismatch() {
+        await this.devices.disconnect().catch(() => undefined);
+    }
+}
+class ProvisioningMaterialHost {
+    attemptId;
+    materialId;
+    serialNumber;
+    provider;
+    storage;
+    transport;
+    runtime;
+    now;
+    prepareAbortController = new AbortController();
+    cancelled = false;
+    currentContext = null;
+    currentMaterial = null;
+    prepareSettlement = null;
+    durableSettlement = null;
+    abortPromise = null;
+    didStartPrepare = false;
+    journal = null;
+    constructor(options) {
+        this.provider = options.provider;
+        this.storage = options.storage;
+        this.transport = options.transport;
+        this.runtime = options.runtime;
+        this.attemptId = options.attemptId;
+        this.materialId = options.materialId;
+        this.serialNumber = options.serialNumber;
+        this.now = options.now;
+    }
+    get prepareStarted() {
+        return this.didStartPrepare;
+    }
+    get preparedJournal() {
+        return this.journal ? { ...this.journal } : null;
+    }
+    async execute(envelope, context) {
+        if (envelope.effect.kind !== 'host_material_prepare_provisioning') {
+            throw new BotaSDKError('internal_error', 'provision');
+        }
+        const effect = envelope.effect;
+        const providerContext = {
+            attemptId: this.attemptId,
+            materialId: effect.materialId,
+            serialNumber: this.serialNumber,
+            nonce: effect.nonce.slice(),
+            devicePublicKey: effect.devicePublicKey.slice(),
+            signal: this.prepareAbortController.signal,
+        };
+        effect.nonce.fill(0);
+        effect.devicePublicKey.fill(0);
+        this.currentContext = providerContext;
+        const prepareLifecycle = deferredVoid();
+        try {
+            if (effect.materialId !== this.materialId) {
+                throw new BotaSDKError('internal_error', 'provision');
+            }
+            const device = this.runtime.connectedDeviceHandle;
+            if (!device)
+                throw new BotaSDKError('device_disconnected', 'provision');
+            const serialBytes = await this.transport.read(device, DEVICE_INFORMATION_SERVICE, SERIAL_NUMBER_CHARACTERISTIC);
+            this.throwIfCancelled(context.signal);
+            const freshSerial = decodeRequiredText(serialBytes, 'provision');
+            if (freshSerial !== this.serialNumber
+                || effect.serialNumber !== this.serialNumber) {
+                throw new BotaSDKError('identity_mismatch', 'provision');
+            }
+            providerContext.serialNumber = freshSerial;
+            this.didStartPrepare = true;
+            this.prepareSettlement = prepareLifecycle.promise;
+            const pending = this.provider.prepare(providerContext);
+            let material;
+            try {
+                material = await awaitProviderCall(pending, this.prepareAbortController.signal, 'provision');
+            }
+            catch (error) {
+                if (this.prepareAbortController.signal.aborted) {
+                    void pending.then(scrubMaterial).catch(() => undefined);
+                }
+                if (error instanceof BotaSDKError && error.code === 'cancelled')
+                    throw error;
+                return {
+                    requestId: envelope.requestId,
+                    kind: 'host_material_failed',
+                    platformCode: null,
+                };
+            }
+            this.currentMaterial = material;
+            this.throwIfCancelled(context.signal);
+            if (!validMaterial(material, this.materialId)) {
+                return {
+                    requestId: envelope.requestId,
+                    kind: 'host_material_failed',
+                    platformCode: null,
+                };
+            }
+            const journal = {
+                schemaVersion: 1,
+                attemptId: this.attemptId,
+                materialId: this.materialId,
+                serialNumber: freshSerial,
+                phase: 'prepared',
+                updatedAtEpochMs: this.now(),
+            };
+            const save = this.storage.saveProvisioningJournal(journal).then(() => {
+                this.journal = journal;
+            });
+            this.durableSettlement = save.then(() => undefined, () => undefined);
+            await save;
+            this.throwIfCancelled(context.signal);
+            await context.dispatch({
+                requestId: envelope.requestId,
+                kind: 'provisioning_material_prepared',
+                apiEndpoint: material.apiEndpoint,
+                deviceToken: material.deviceToken,
+                mtu: material.mtu,
+            });
+            return null;
+        }
+        finally {
+            scrubContext(providerContext);
+            if (this.currentContext === providerContext)
+                this.currentContext = null;
+            if (this.currentMaterial)
+                scrubMaterial(this.currentMaterial);
+            this.currentMaterial = null;
+            prepareLifecycle.resolve();
+        }
+    }
+    async cancel() {
+        this.cancelled = true;
+        this.prepareAbortController.abort();
+        await this.prepareSettlement;
+        await this.durableSettlement;
+        if (this.currentContext)
+            scrubContext(this.currentContext);
+        if (this.currentMaterial)
+            scrubMaterial(this.currentMaterial);
+    }
+    abort(reason, signal) {
+        if (!this.abortPromise) {
+            this.abortPromise = awaitProviderCall(this.provider.abort({
+                attemptId: this.attemptId,
+                serialNumber: this.serialNumber,
+                reason,
+                signal,
+            }), signal, 'provision');
+        }
+        return this.abortPromise;
+    }
+    throwIfCancelled(signal) {
+        if (this.cancelled || signal.aborted) {
+            throw new BotaSDKError('cancelled', 'provision');
+        }
+    }
+}
+function nextProvisioningJournal(previous, phase, now) {
+    return {
+        schemaVersion: 1,
+        attemptId: previous.attemptId,
+        materialId: previous.materialId,
+        serialNumber: previous.serialNumber,
+        phase,
+        updatedAtEpochMs: Math.max(previous.updatedAtEpochMs, now()),
+    };
+}
+function validMaterial(material, expectedMaterialId) {
+    return typeof material.materialId === 'string'
+        && material.materialId === expectedMaterialId
+        && material.apiEndpoint instanceof Uint8Array
+        && material.apiEndpoint.byteLength > 0
+        && material.deviceToken instanceof Uint8Array
+        && material.deviceToken.byteLength > 0
+        && Number.isSafeInteger(material.mtu)
+        && material.mtu > 0;
+}
+function scrubContext(context) {
+    context.nonce.fill(0);
+    context.devicePublicKey.fill(0);
+}
+function scrubMaterial(material) {
+    try {
+        if (typeof material !== 'object' || material === null)
+            return;
+        const candidate = material;
+        if (candidate.apiEndpoint instanceof Uint8Array) {
+            candidate.apiEndpoint.fill(0);
+        }
+        if (candidate.deviceToken instanceof Uint8Array) {
+            candidate.deviceToken.fill(0);
+        }
+    }
+    catch {
+        // Application-owned late values are untrusted and already ignored.
+    }
+}
+function coreSettings(settings) {
+    return {
+        enabledConnections: { ...settings.enabledConnections },
+        heartbeatEnabledConnections: { ...settings.heartbeatEnabledConnections },
+        uploadNetworkPreference: [...settings.uploadNetworkPreference],
+        powerManagement: { ...settings.powerManagement },
+        streamingEnabled: settings.streamingEnabled,
+        streamingFlushIntervalSeconds: settings.streamingFlushIntervalSeconds,
+    };
+}
+function publicSettings(settings) {
+    return {
+        enabledConnections: { ...settings.enabledConnections },
+        heartbeatEnabledConnections: { ...settings.heartbeatEnabledConnections },
+        uploadNetworkPreference: settings.uploadNetworkPreference.filter((connection) => connection === 'wifi' || connection === 'ble' || connection === 'cellular'),
+        powerManagement: { ...settings.powerManagement },
+        streamingEnabled: settings.streamingEnabled,
+        streamingFlushIntervalSeconds: settings.streamingFlushIntervalSeconds,
+    };
+}
+function deprovisionResult(result) {
+    if (result.success)
+        return { success: true };
+    const error = result.error === 'invalid_token'
+        || result.error === 'storage_error'
+        || result.error === 'chunk_error'
+        || result.error === 'already_paired'
+        ? result.error
+        : 'unknown';
+    return {
+        success: false,
+        error,
+        ...(typeof result.errorRaw === 'number'
+            ? { errorRaw: result.errorRaw }
+            : {}),
+    };
+}
+function deviceModel(value) {
+    switch (value.trim().toLowerCase().replace(/[ -]+/g, '_')) {
+        case 'bota_note':
+        case 'note':
+            return 'note';
+        case 'pin':
+            return 'pin';
+        case 'bota_pin':
+        case 'bota_pin_4g':
+        case 'bota_pin_pro':
+        case 'pin_4g':
+        case 'pin_pro':
+            return 'pin_4g';
+        default:
+            return null;
+    }
+}
+function decodeRequiredText(value, operation) {
+    try {
+        const decoded = new TextDecoder('utf-8', { fatal: true })
+            .decode(value)
+            .replace(/^[\0\s]+|[\0\s]+$/g, '');
+        if (!decoded)
+            throw new Error('empty');
+        return decoded;
+    }
+    catch {
+        throw new BotaSDKError('protocol_error', operation);
+    }
+}
+async function resultWithDeadline(result, signal, timeoutMs) {
+    if (signal.aborted)
+        throw new BotaSDKError('cancelled', 'deprovision');
+    let timer = null;
+    let cancel;
+    const cancellation = new Promise((_resolve, reject) => {
+        cancel = () => reject(new BotaSDKError('cancelled', 'deprovision'));
+    });
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+            reject(new BotaSDKError('connection_failed', 'deprovision', {
+                retryable: true,
+            }));
+        }, timeoutMs);
+    });
+    signal.addEventListener('abort', cancel, { once: true });
+    try {
+        return await Promise.race([result, cancellation, timeout]);
+    }
+    finally {
+        signal.removeEventListener('abort', cancel);
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+async function withCombinedSignal(primary, secondary, body) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    primary.addEventListener('abort', abort, { once: true });
+    secondary?.addEventListener('abort', abort, { once: true });
+    if (primary.aborted || secondary?.aborted)
+        controller.abort();
+    try {
+        return await body(controller.signal);
+    }
+    finally {
+        primary.removeEventListener('abort', abort);
+        secondary?.removeEventListener('abort', abort);
+    }
+}
+function throwIfAborted(signal, operation) {
+    if (signal.aborted)
+        throw new BotaSDKError('cancelled', operation);
+}
+async function settled(promise) {
+    return await promise.then((value) => ({ kind: 'completed', value }), (error) => ({ kind: 'failed', error }));
+}
+function deferredVoid() {
+    let resolve;
+    const promise = new Promise((resolvePromise) => {
+        resolve = resolvePromise;
+    });
+    return { promise, resolve };
+}
+function managerError(error, operation) {
+    if (error instanceof BotaSDKError) {
+        return new BotaSDKError(error.code, operation, {
+            retryable: error.retryable,
+            protocolStatus: error.protocolStatus,
+        });
+    }
+    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);
+    }
+    const normalized = normalizeCoreError(error, operation);
+    return new BotaSDKError(normalized.code, operation, {
+        retryable: normalized.retryable,
+        protocolStatus: normalized.protocolStatus,
+    });
+}
+function randomBytes(length) {
+    const value = new Uint8Array(length);
+    globalThis.crypto.getRandomValues(value);
+    return value;
+}
+function bytesHex(value) {
+    return [...value]
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join('');
+}