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

package/dist/storage.d.ts

@@ -0,0 +1,103 @@
+import type { CoreIntegrityHasher } from './core.ts';
+import type { RecordingJournalPhase } from './models.ts';
+export { BrowserStorageError } from './indexedDbWorkflowStore.ts';
+export type { BrowserStorageErrorCode } from './indexedDbWorkflowStore.ts';
+export type { RecordingJournalPhase } from './models.ts';
+export interface RecordingJournal {
+    schemaVersion: 1;
+    operationId: string;
+    serialNumber: string;
+    recordingUuid: string;
+    profile: 'legacy' | 'encrypted_upload_v2';
+    phase: RecordingJournalPhase;
+    sinkId: string;
+    uploadId: string | null;
+    cloudCompletionId: string | null;
+    confirmationDigestHex: string | null;
+    devicePlaintextSha256Hex: string | null;
+    updatedAtEpochMs: number;
+}
+export interface FirmwareJournal {
+    schemaVersion: 1;
+    operationId: string;
+    serialNumber: string;
+    imageId: string;
+    downloadId: bigint;
+    version: string;
+    sizeBytes: number;
+    crc32: number;
+    sha256Hex: string;
+    blobId: string;
+    downloadedBytes: number;
+    verified: boolean;
+    state?: 'active' | 'cleanup_only';
+    updatedAtEpochMs: number;
+}
+export interface VerifiedDeviceHint {
+    schemaVersion: 1;
+    serialNumber: string;
+    browserDeviceId: string;
+    name: string | null;
+    updatedAtEpochMs: number;
+}
+export interface WorkflowCheckpointRecord {
+    schemaVersion: 1;
+    operationId: string;
+    checkpoint: unknown;
+}
+export interface EncryptedUploadV2CheckpointRecord {
+    schemaVersion: 1;
+    operationId: string;
+    checkpoint: unknown;
+}
+export interface ProvisioningJournal {
+    schemaVersion: 1;
+    attemptId: string;
+    materialId: string | null;
+    serialNumber: string;
+    phase: 'prepared' | 'device_applied' | 'backend_confirmed' | 'aborted';
+    updatedAtEpochMs: number;
+}
+export interface BrowserBlobHandle {
+    readonly id: string;
+    size(): Promise<number>;
+    truncate(size: number): Promise<void>;
+    write(offset: number, bytes: Uint8Array): Promise<void>;
+    read(offset: number, maximumLength: number): Promise<Uint8Array>;
+    stream(chunkSize?: number): AsyncIterable<Uint8Array>;
+    delete(): Promise<void>;
+}
+export interface BrowserSdkStorage {
+    readonly namespace: string;
+    loadVerifiedDevice(serialNumber: string): Promise<VerifiedDeviceHint | null>;
+    saveVerifiedDevice(value: VerifiedDeviceHint): Promise<void>;
+    deleteVerifiedDevice(serialNumber: string): Promise<void>;
+    loadWorkflowCheckpoint(operationId: string): Promise<unknown | null>;
+    saveWorkflowCheckpoint(operationId: string, checkpoint: unknown): Promise<void>;
+    deleteWorkflowCheckpoint(operationId: string): Promise<void>;
+    loadEncryptedUploadV2Checkpoint(operationId: string): Promise<unknown | null>;
+    saveEncryptedUploadV2Checkpoint(operationId: string, checkpoint: unknown): Promise<void>;
+    deleteEncryptedUploadV2Checkpoint(operationId: string): Promise<void>;
+    saveEncryptedUploadV2Operation(operationId: string, checkpoint: unknown, journal: RecordingJournal): Promise<void>;
+    deleteEncryptedUploadV2Operation(operationId: string): Promise<void>;
+    loadRecordingJournal(operationId: string): Promise<RecordingJournal | null>;
+    saveRecordingJournal(journal: RecordingJournal): Promise<void>;
+    listRecordingJournals(): Promise<RecordingJournal[]>;
+    deleteRecordingJournal(operationId: string): Promise<void>;
+    loadProvisioningJournal(attemptId: string): Promise<ProvisioningJournal | null>;
+    saveProvisioningJournal(journal: ProvisioningJournal): Promise<void>;
+    listProvisioningJournals?(): Promise<ProvisioningJournal[]>;
+    deleteProvisioningJournal(attemptId: string): Promise<void>;
+    loadFirmwareJournal(operationId: string): Promise<FirmwareJournal | null>;
+    saveFirmwareJournal(journal: FirmwareJournal): Promise<void>;
+    deleteFirmwareJournal(operationId: string): Promise<void>;
+    openBlob(blobId: string): Promise<BrowserBlobHandle>;
+    clear(): Promise<void>;
+}
+export interface BrowserStorageDependencies {
+    indexedDB?: IDBFactory | null;
+    keyRange?: typeof IDBKeyRange | null;
+    opfsRoot?: FileSystemDirectoryHandle | null;
+    createIntegrityHasher?: (() => CoreIntegrityHasher) | null;
+}
+export declare function createDefaultBrowserStorage(namespace: string, dependencies?: BrowserStorageDependencies): Promise<BrowserSdkStorage>;

package/dist/storage.js

@@ -0,0 +1,60 @@
+import { BrowserStorageError, IndexedDbWorkflowStore, mapBrowserStorageError, validateStorageNamespace, } from "./indexedDbWorkflowStore.js";
+import { OpfsBlobStore } from "./opfsBlobStore.js";
+import { loadDefaultCore } from "./wasmCore.js";
+export { BrowserStorageError } from "./indexedDbWorkflowStore.js";
+export async function createDefaultBrowserStorage(namespace, dependencies = {}) {
+    validateStorageNamespace(namespace);
+    const indexedDB = dependencies.indexedDB === undefined
+        ? globalThis.indexedDB
+        : dependencies.indexedDB;
+    const keyRange = dependencies.keyRange === undefined
+        ? globalThis.IDBKeyRange
+        : dependencies.keyRange;
+    if (!indexedDB || !keyRange) {
+        throw new BrowserStorageError('storage_unavailable');
+    }
+    let opfsRoot = dependencies.opfsRoot;
+    if (opfsRoot === undefined) {
+        const storage = typeof navigator === 'undefined' ? undefined : navigator.storage;
+        if (typeof storage?.getDirectory !== 'function') {
+            throw new BrowserStorageError('storage_unavailable');
+        }
+        try {
+            opfsRoot = await storage.getDirectory();
+        }
+        catch (error) {
+            throw mapBrowserStorageError(error);
+        }
+    }
+    if (!opfsRoot)
+        throw new BrowserStorageError('storage_unavailable');
+    let createIntegrityHasher = dependencies.createIntegrityHasher;
+    if (createIntegrityHasher === undefined) {
+        try {
+            const core = await loadDefaultCore();
+            createIntegrityHasher = () => core.createIntegrityHasher();
+        }
+        catch (error) {
+            throw mapBrowserStorageError(error);
+        }
+    }
+    if (!createIntegrityHasher) {
+        throw new BrowserStorageError('storage_unavailable');
+    }
+    const blobs = new OpfsBlobStore(namespace, opfsRoot, createIntegrityHasher);
+    return new DefaultBrowserStorage(namespace, indexedDB, keyRange, blobs);
+}
+class DefaultBrowserStorage extends IndexedDbWorkflowStore {
+    blobs;
+    constructor(namespace, indexedDB, keyRange, blobs) {
+        super(namespace, indexedDB, keyRange);
+        this.blobs = blobs;
+    }
+    async openBlob(blobId) {
+        return await this.blobs.open(blobId);
+    }
+    async clear() {
+        await super.clear();
+        await this.blobs.clear();
+    }
+}

package/dist/transport.d.ts

@@ -0,0 +1,33 @@
+export interface BrowserDeviceHandle {
+    readonly id: string;
+    readonly name: string | null;
+    readonly nativeValue?: unknown;
+}
+export interface BrowserNotification {
+    characteristicUuid: string;
+    value: Uint8Array;
+}
+export interface BrowserSubscription {
+    remove(): Promise<void>;
+}
+export interface BrowserBluetoothTransport {
+    readonly isSupported: boolean;
+    readonly supportsAuthorizedDevices: boolean;
+    readonly maximumWriteValueLength: number;
+    requestDevice(): Promise<BrowserDeviceHandle>;
+    getAuthorizedDevices(): Promise<BrowserDeviceHandle[]>;
+    connect(device: BrowserDeviceHandle): Promise<void>;
+    discoverServices(device: BrowserDeviceHandle): Promise<void>;
+    read(device: BrowserDeviceHandle, serviceUuid: string, characteristicUuid: string): Promise<Uint8Array>;
+    write(device: BrowserDeviceHandle, serviceUuid: string, characteristicUuid: string, value: Uint8Array, withResponse: boolean): Promise<void>;
+    subscribe(device: BrowserDeviceHandle, serviceUuid: string, characteristicUuid: string, listener: (notification: BrowserNotification) => void): Promise<BrowserSubscription>;
+    disconnect(device: BrowserDeviceHandle): Promise<void>;
+    onDisconnected(device: BrowserDeviceHandle, listener: () => void): () => void;
+}
+export type BrowserTransportErrorCode = 'characteristic_not_found' | 'disconnected' | 'permission_denied' | 'picker_cancelled' | 'unavailable';
+export declare class BrowserTransportError extends Error {
+    readonly code: BrowserTransportErrorCode;
+    constructor(code: BrowserTransportErrorCode, options?: {
+        cause?: unknown;
+    });
+}

package/dist/transport.js

@@ -0,0 +1,8 @@
+export class BrowserTransportError extends Error {
+    code;
+    constructor(code, options = {}) {
+        super(code, { cause: options.cause });
+        this.name = 'BrowserTransportError';
+        this.code = code;
+    }
+}

package/dist/wasmCore.d.ts

@@ -0,0 +1,3 @@
+import type { CoreBridge } from './core.ts';
+export declare function createWasmCore(moduleInput?: unknown): Promise<CoreBridge>;
+export declare const loadDefaultCore: import("./core.ts").CoreLoader;