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

package/dist/opfsBlobStore.js

@@ -0,0 +1,250 @@
+import { BrowserStorageError, mapBrowserStorageError, validateStorageIdentifier, validateStorageNamespace, } from "./indexedDbWorkflowStore.js";
+const DEFAULT_STREAM_CHUNK_SIZE = 64 * 1024;
+const SDK_DIRECTORY = 'bota-app-sdk';
+const SCHEMA_DIRECTORY = 'v1';
+const inProcessBlobLocks = new Map();
+export class OpfsBlobStore {
+    root;
+    createIntegrityHasher;
+    namespaceDirectoryName;
+    constructor(namespace, root, createIntegrityHasher) {
+        validateStorageNamespace(namespace);
+        this.root = root;
+        this.createIntegrityHasher = createIntegrityHasher;
+        this.namespaceDirectoryName = this.hashName(namespace);
+    }
+    async open(blobId) {
+        validateStorageIdentifier(blobId);
+        const fileName = this.hashName(blobId);
+        const lockName = [
+            SDK_DIRECTORY,
+            SCHEMA_DIRECTORY,
+            this.namespaceDirectoryName,
+            fileName,
+        ].join(':');
+        return new OpfsBlobHandle(blobId, fileName, async () => await this.namespaceDirectory(), async (action) => await withBlobLock(lockName, action));
+    }
+    async clear() {
+        try {
+            const sdk = await this.root.getDirectoryHandle(SDK_DIRECTORY);
+            const version = await sdk.getDirectoryHandle(SCHEMA_DIRECTORY);
+            await version.removeEntry(this.namespaceDirectoryName, { recursive: true });
+        }
+        catch (error) {
+            if (domExceptionName(error) === 'NotFoundError')
+                return;
+            throw mapBrowserStorageError(error);
+        }
+    }
+    async namespaceDirectory() {
+        try {
+            const sdk = await this.root.getDirectoryHandle(SDK_DIRECTORY, { create: true });
+            const version = await sdk.getDirectoryHandle(SCHEMA_DIRECTORY, { create: true });
+            return await version.getDirectoryHandle(this.namespaceDirectoryName, {
+                create: true,
+            });
+        }
+        catch (error) {
+            throw mapBrowserStorageError(error);
+        }
+    }
+    hashName(value) {
+        try {
+            const hasher = this.createIntegrityHasher();
+            hasher.update(new TextEncoder().encode(value));
+            const digest = hasher.sha256Snapshot();
+            if (digest.byteLength !== 32) {
+                throw new BrowserStorageError('storage_unavailable');
+            }
+            return Array.from(digest, (byte) => byte.toString(16).padStart(2, '0')).join('');
+        }
+        catch (error) {
+            throw mapBrowserStorageError(error);
+        }
+    }
+}
+class OpfsBlobHandle {
+    id;
+    fileName;
+    directory;
+    withLock;
+    constructor(id, fileName, directory, withLock) {
+        this.id = id;
+        this.fileName = fileName;
+        this.directory = directory;
+        this.withLock = withLock;
+    }
+    async size() {
+        try {
+            return validFileSize((await (await this.fileHandle()).getFile()).size);
+        }
+        catch (error) {
+            throw mapBrowserStorageError(error);
+        }
+    }
+    async truncate(size) {
+        validateOffset(size);
+        await this.withLock(async () => {
+            const currentSize = await this.size();
+            if (size > currentSize)
+                throw new BrowserStorageError('resume_rejected');
+            if (size === currentSize)
+                return;
+            await this.withWritable(async (writable) => {
+                await writable.truncate(size);
+            });
+        });
+    }
+    async write(offset, bytes) {
+        validateOffset(offset);
+        if (!(bytes instanceof Uint8Array)) {
+            throw new BrowserStorageError('invalid_input');
+        }
+        validateRange(offset, bytes.byteLength);
+        const copy = new Uint8Array(bytes);
+        await this.withLock(async () => {
+            const currentSize = await this.size();
+            if (offset !== currentSize) {
+                throw new BrowserStorageError('resume_rejected');
+            }
+            if (copy.byteLength === 0)
+                return;
+            await this.withWritable(async (writable) => {
+                await writable.seek(offset);
+                await writable.write(copy);
+            });
+        });
+    }
+    async read(offset, maximumLength) {
+        validateOffset(offset);
+        validateLength(maximumLength, true);
+        validateRange(offset, maximumLength);
+        if (maximumLength === 0)
+            return new Uint8Array();
+        try {
+            const file = await (await this.fileHandle()).getFile();
+            const size = validFileSize(file.size);
+            if (offset >= size)
+                return new Uint8Array();
+            const end = Math.min(size, offset + maximumLength);
+            return new Uint8Array(await file.slice(offset, end).arrayBuffer());
+        }
+        catch (error) {
+            throw mapBrowserStorageError(error);
+        }
+    }
+    async *stream(chunkSize = DEFAULT_STREAM_CHUNK_SIZE) {
+        validateLength(chunkSize, false);
+        const size = await this.size();
+        let offset = 0;
+        while (offset < size) {
+            const length = Math.min(chunkSize, size - offset);
+            yield await this.read(offset, length);
+            offset += length;
+        }
+    }
+    async delete() {
+        await this.withLock(async () => {
+            try {
+                const directory = await this.directory();
+                await directory.removeEntry(this.fileName);
+            }
+            catch (error) {
+                if (domExceptionName(error) === 'NotFoundError')
+                    return;
+                throw mapBrowserStorageError(error);
+            }
+        });
+    }
+    async fileHandle() {
+        const directory = await this.directory();
+        return await directory.getFileHandle(this.fileName, { create: true });
+    }
+    async withWritable(action) {
+        let writable = null;
+        try {
+            writable = await (await this.fileHandle()).createWritable({
+                keepExistingData: true,
+            });
+            await action(writable);
+            await writable.close();
+        }
+        catch (error) {
+            if (writable) {
+                try {
+                    await writable.abort();
+                }
+                catch {
+                    // Preserve the original storage failure.
+                }
+            }
+            throw mapBrowserStorageError(error);
+        }
+    }
+}
+async function withBlobLock(name, action) {
+    const lockManager = browserLockManager();
+    if (lockManager) {
+        try {
+            return await lockManager.request(name, action);
+        }
+        catch (error) {
+            throw mapBrowserStorageError(error);
+        }
+    }
+    return await withInProcessBlobLock(name, action);
+}
+async function withInProcessBlobLock(name, action) {
+    const previous = inProcessBlobLocks.get(name) ?? Promise.resolve();
+    let release = () => undefined;
+    const gate = new Promise((resolve) => {
+        release = resolve;
+    });
+    const tail = previous.then(() => gate);
+    inProcessBlobLocks.set(name, tail);
+    await previous;
+    try {
+        return await action();
+    }
+    finally {
+        release();
+        if (inProcessBlobLocks.get(name) === tail)
+            inProcessBlobLocks.delete(name);
+    }
+}
+function browserLockManager() {
+    if (typeof navigator === 'undefined' || !('locks' in navigator))
+        return null;
+    const lockManager = Reflect.get(navigator, 'locks');
+    return lockManager && typeof lockManager.request === 'function'
+        ? lockManager
+        : null;
+}
+function validateOffset(value) {
+    validateLength(value, true);
+}
+function validateLength(value, allowZero) {
+    if (!Number.isSafeInteger(value)
+        || value < 0
+        || (!allowZero && value === 0)) {
+        throw new BrowserStorageError('invalid_input');
+    }
+}
+function validateRange(offset, length) {
+    validateOffset(offset);
+    validateLength(length, true);
+    if (length > Number.MAX_SAFE_INTEGER - offset) {
+        throw new BrowserStorageError('invalid_input');
+    }
+}
+function validFileSize(size) {
+    if (!Number.isSafeInteger(size) || size < 0) {
+        throw new BrowserStorageError('resume_rejected');
+    }
+    return size;
+}
+function domExceptionName(error) {
+    if (typeof error !== 'object' || error === null || !('name' in error))
+        return null;
+    return typeof error.name === 'string' ? error.name : null;
+}

package/dist/otaManager.d.ts

@@ -0,0 +1,49 @@
+import type { CoreBridge } from './core.ts';
+import { type DeviceManager } from './deviceManager.ts';
+import type { FirmwareImageDescriptor, FirmwareUpdateOptions } from './models.ts';
+import type { FirmwareDownloadProvider } from './providers.ts';
+import { type BrowserSdkStorage } from './storage.ts';
+import { type BrowserBluetoothTransport } from './transport.ts';
+import { BrowserWorkflowRuntime } from './workflowRuntime.ts';
+type Fetcher = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+interface OTAManagerOptions {
+    core: CoreBridge;
+    transport: BrowserBluetoothTransport;
+    runtime: BrowserWorkflowRuntime;
+    devices: DeviceManager;
+    storage?: BrowserSdkStorage | null;
+    provider?: FirmwareDownloadProvider | null;
+    fetcher?: Fetcher;
+    now?: () => number;
+}
+export declare class OTAManager {
+    private readonly core;
+    private readonly transport;
+    private readonly runtime;
+    private readonly devices;
+    private readonly storage;
+    private readonly provider;
+    private readonly fetcher;
+    private readonly now;
+    private readonly activeOperations;
+    private destroyed;
+    private destroyPromise;
+    constructor(options: OTAManagerOptions);
+    updateFirmware(image: FirmwareImageDescriptor, options?: FirmwareUpdateOptions): Promise<void>;
+    resumeFirmwareUpdate(operationId: string, options?: Pick<FirmwareUpdateOptions, 'signal' | 'onProgress'>): Promise<void>;
+    cancelFirmwareUpdate(operationId: string): Promise<void>;
+    destroy(): Promise<void>;
+    private runFirmwareWorkflow;
+    private createArtifactHost;
+    private createFirmwarePersistenceHost;
+    private finishFirmwareCleanup;
+    private recoverExactConnection;
+    private deleteLatestBlob;
+    private loadReconnectHint;
+    private requireConnectedDevice;
+    private runManagedOperation;
+    private ensureFirmwareCapability;
+    private requireStorage;
+    private requireProvider;
+}
+export {};