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

package/dist/providerCancellation.d.ts

@@ -0,0 +1,2 @@
+import { type BotaOperation } from './errors.ts';
+export declare function awaitProviderCall<T>(promise: Promise<T>, signal: AbortSignal, operation: BotaOperation): Promise<T>;

package/dist/providerCancellation.js

@@ -0,0 +1,23 @@
+import { BotaSDKError } from "./errors.js";
+export async function awaitProviderCall(promise, signal, operation) {
+    const observed = promise.then((value) => ({ kind: 'fulfilled', value }), (error) => ({ kind: 'rejected', error }));
+    let cancel;
+    const cancelled = new Promise((resolve) => {
+        cancel = () => resolve({
+            kind: 'rejected',
+            error: new BotaSDKError('cancelled', operation),
+        });
+    });
+    signal.addEventListener('abort', cancel, { once: true });
+    if (signal.aborted)
+        cancel();
+    try {
+        const outcome = await Promise.race([observed, cancelled]);
+        if (outcome.kind === 'rejected')
+            throw outcome.error;
+        return outcome.value;
+    }
+    finally {
+        signal.removeEventListener('abort', cancel);
+    }
+}

package/dist/providers.d.ts

@@ -0,0 +1,138 @@
+import type { DeviceRecording, EncryptedUploadV2Capabilities, FirmwareImageDescriptor } from './models.ts';
+import type { BotaSDKErrorCode } from './errors.ts';
+export interface ProvisioningPrepareContext {
+    attemptId: string;
+    materialId: string;
+    serialNumber: string;
+    nonce: Uint8Array;
+    devicePublicKey: Uint8Array;
+    signal: AbortSignal;
+}
+export interface ProvisioningMaterial {
+    materialId: string;
+    apiEndpoint: Uint8Array;
+    deviceToken: Uint8Array;
+    mtu: number;
+}
+export interface ProvisioningProvider {
+    prepare(context: ProvisioningPrepareContext): Promise<ProvisioningMaterial>;
+    confirm(context: {
+        attemptId: string;
+        serialNumber: string;
+        signal: AbortSignal;
+    }): Promise<void>;
+    abort(context: {
+        attemptId: string;
+        serialNumber: string;
+        reason: BotaSDKErrorCode;
+        signal: AbortSignal;
+    }): Promise<void>;
+}
+export interface RecordingControlProvider {
+    prepare(context: {
+        operationId: string;
+        serialNumber: string;
+        action: 'start' | 'stop';
+        authorityId: string;
+        signal: AbortSignal;
+    }): Promise<{
+        grant: Uint8Array;
+    }>;
+}
+export interface FirmwareDownloadProvider {
+    resolve(context: {
+        operationId: string;
+        serialNumber: string;
+        image: FirmwareImageDescriptor;
+        signal: AbortSignal;
+    }): Promise<{
+        method: 'GET';
+        url: string;
+        headers: Readonly<Record<string, string>>;
+    }>;
+}
+export interface UploadRequestTemplate {
+    method: 'PUT';
+    url: string;
+    headers: Readonly<Record<string, string>>;
+}
+export interface LegacyUploadContext {
+    operationId: string;
+    serialNumber: string;
+    recording: DeviceRecording;
+    sizeBytes: bigint;
+    plaintextSha256Hex: string | null;
+    stagedBodySha256Hex: string;
+    encrypted: boolean;
+    signal: AbortSignal;
+}
+export interface EncryptedUploadV2Recording {
+    uuid: string;
+    generation: number;
+    storageFormat: number;
+    ciphertextLength: bigint;
+    ciphertextSha256: Uint8Array;
+}
+export interface EncryptedUploadV2CheckpointSummary {
+    uploadSessionId: string;
+    ownerRevision: number;
+    checkpointRevision: number;
+    nextCiphertextOffset: bigint;
+    prefixSha256: Uint8Array;
+    transportSessionId: bigint;
+    sinkId: string;
+    windowPackets: number;
+    dataPayloadBytes: number;
+}
+export interface EncryptedUploadV2ProviderContext {
+    operationId: string;
+    serialNumber: string;
+    recording: EncryptedUploadV2Recording;
+    capability: {
+        rawValue: Uint8Array;
+        sha256: Uint8Array;
+        decoded: EncryptedUploadV2Capabilities;
+    };
+    checkpoint: EncryptedUploadV2CheckpointSummary | null;
+    signal: AbortSignal;
+}
+export interface EncryptedUploadV2Evidence {
+    ciphertextLength: bigint;
+    ciphertextSha256: Uint8Array;
+    manifestLength: number;
+    manifestSha256: Uint8Array;
+    blockCount: number;
+}
+export interface EncryptedUploadV2Material {
+    materialId: string;
+    recordingId: string;
+    uploadSessionId: string;
+    ownerRevision: number;
+    policy: 'legacy_allowed' | 'v2_preferred' | 'v2_required';
+    authorization: Uint8Array;
+    stagingRequest(evidence: EncryptedUploadV2Evidence, signal: AbortSignal): Promise<UploadRequestTemplate>;
+    submitManifest(manifest: Uint8Array, evidence: EncryptedUploadV2Evidence, signal: AbortSignal): Promise<void>;
+    finalize(evidence: EncryptedUploadV2Evidence, signal: AbortSignal): Promise<void>;
+    completionReceipt(evidence: EncryptedUploadV2Evidence, signal: AbortSignal): Promise<Uint8Array>;
+    cancel(signal: AbortSignal): Promise<void>;
+}
+export interface RecordingUploadProvider {
+    prepareLegacyUpload(context: LegacyUploadContext): Promise<{
+        uploadId: string;
+        request: UploadRequestTemplate;
+    }>;
+    completeLegacyUpload(context: LegacyUploadContext & {
+        uploadId: string;
+    }): Promise<{
+        cloudCompletionId: string;
+    }>;
+    reconcileLegacyUpload(context: LegacyUploadContext & {
+        uploadId: string;
+    }): Promise<{
+        state: 'not_uploaded';
+    } | {
+        state: 'cloud_completed';
+        cloudCompletionId: string;
+    }>;
+    prepareEncryptedUploadV2(context: EncryptedUploadV2ProviderContext): Promise<EncryptedUploadV2Material>;
+}

package/dist/providers.js

@@ -0,0 +1 @@
+export {};

package/dist/provisioningManager.d.ts

@@ -0,0 +1,48 @@
+import type { CoreBridge } from './core.ts';
+import { DeviceManager } from './deviceManager.ts';
+import type { DeprovisionRequest, DeprovisionResult, DeviceConnectionSettings, ProvisionRequest } from './models.ts';
+import type { ProvisioningProvider } from './providers.ts';
+import { type BrowserSdkStorage } from './storage.ts';
+import { type BrowserBluetoothTransport } from './transport.ts';
+import { BrowserWorkflowRuntime } from './workflowRuntime.ts';
+interface ProvisioningManagerOptions {
+    core: CoreBridge;
+    transport: BrowserBluetoothTransport;
+    runtime: BrowserWorkflowRuntime;
+    devices: DeviceManager;
+    storage?: BrowserSdkStorage | null;
+    provider?: ProvisioningProvider | null;
+    now?: () => number;
+    deprovisionTimeoutMs?: number | undefined;
+}
+export declare class ProvisioningManager {
+    private readonly core;
+    private readonly transport;
+    private readonly runtime;
+    private readonly devices;
+    private readonly storage;
+    private readonly provider;
+    private readonly now;
+    private readonly deprovisionTimeoutMs;
+    private activeProvision;
+    private destroyed;
+    private destroyPromise;
+    constructor(options: ProvisioningManagerOptions);
+    provision(request: ProvisionRequest): Promise<void>;
+    deprovision(request: DeprovisionRequest): Promise<DeprovisionResult>;
+    readConnectionSettings(): Promise<DeviceConnectionSettings>;
+    writeConnectionSettings(settings: DeviceConnectionSettings): Promise<void>;
+    destroy(): Promise<void>;
+    private runProvision;
+    private confirmProvisioning;
+    private confirmProvisioningWhileOwned;
+    private requireProvisioningReconciliation;
+    private performDeprovision;
+    private verifyConnectedDevice;
+    private requireConnected;
+    private gattStep;
+    private validateProvisionRequest;
+    private throwIfProvisionCancelled;
+    private disconnectMismatch;
+}
+export {};