@syncular/client 0.0.1-60

package/dist/client.js

@@ -0,0 +1,834 @@
+/**
+ * @syncular/client - Unified Client class
+ *
+ * Single entry point for offline-first sync with:
+ * - Built-in mutations API
+ * - Optional blob support
+ * - Automatic migrations
+ * - Event-driven state management
+ * - Conflict handling with events
+ */
+import { sql } from 'kysely';
+import { ensureClientBlobSchema } from './blobs/migrate';
+import { SyncEngine } from './engine/SyncEngine';
+import { ensureClientSyncSchema } from './migrate';
+import { createMutationsApi, createOutboxCommit, } from './mutations';
+// ============================================================================
+// Client Class
+// ============================================================================
+/**
+ * Unified sync client.
+ *
+ * @example
+ * ```typescript
+ * import { Client } from '@syncular/client';
+ * import { createHttpTransport } from '@syncular/transport-http';
+ *
+ * const client = new Client({
+ *   db,
+ *   transport: createHttpTransport({ baseUrl: '/api/sync', getHeaders }),
+ *   tableHandlers,
+ *   clientId: 'device-123',
+ *   actorId: 'user-456',
+ *   subscriptions: [{ id: 'tasks', shape: 'tasks', scopes: { user_id: 'user-456' } }],
+ * });
+ *
+ * await client.start();
+ *
+ * // Mutations
+ * await client.mutations.tasks.insert({ title: 'New task' });
+ *
+ * // Events
+ * client.on('sync:complete', () => console.log('synced'));
+ * ```
+ */
+export class Client {
+    options;
+    engine = null;
+    started = false;
+    destroyed = false;
+    eventListeners = new Map();
+    outboxStats = {
+        pending: 0,
+        sending: 0,
+        failed: 0,
+        acked: 0,
+        total: 0,
+    };
+    /** Mutations API (always available) */
+    mutations;
+    /** Blob client (only available if blobStorage configured) */
+    blobs;
+    constructor(options) {
+        this.options = options;
+        // Create mutations API
+        const commitFn = createOutboxCommit({
+            db: options.db,
+            idColumn: options.idColumn ?? 'id',
+            versionColumn: options.versionColumn ?? 'server_version',
+            omitColumns: options.omitColumns ?? [],
+        });
+        this.mutations = createMutationsApi(commitFn);
+        // Create blob client if storage provided
+        if (options.blobStorage && options.transport.blobs) {
+            this.blobs = this.createBlobClient(options.blobStorage, options.transport);
+        }
+    }
+    // ===========================================================================
+    // Identity Getters
+    // ===========================================================================
+    /** Client ID */
+    get clientId() {
+        return this.options.clientId;
+    }
+    /** Actor ID */
+    get actorId() {
+        return this.options.actorId;
+    }
+    /** Database instance */
+    get db() {
+        return this.options.db;
+    }
+    // ===========================================================================
+    // Lifecycle
+    // ===========================================================================
+    /**
+     * Start the client.
+     * Runs migrations and starts sync engine.
+     */
+    async start() {
+        if (this.destroyed) {
+            throw new Error('Client has been destroyed');
+        }
+        if (this.started) {
+            return;
+        }
+        // Run migrations
+        await ensureClientSyncSchema(this.options.db);
+        if (this.options.blobStorage) {
+            await ensureClientBlobSchema(this.options.db);
+        }
+        // Create and start engine
+        this.engine = new SyncEngine({
+            db: this.options.db,
+            transport: this.options.transport,
+            shapes: this.options.tableHandlers,
+            clientId: this.options.clientId,
+            actorId: this.options.actorId,
+            subscriptions: this.options.subscriptions.map((s) => ({
+                id: s.id,
+                shape: s.shape,
+                scopes: s.scopes ?? {},
+                params: s.params ?? {},
+            })),
+            plugins: this.options.plugins,
+            realtimeEnabled: this.options.realtimeEnabled,
+            pollIntervalMs: this.options.pollIntervalMs,
+            stateId: this.options.stateId,
+            migrate: undefined, // We already ran migrations
+        });
+        // Wire up engine events to client events
+        this.wireEngineEvents();
+        await this.engine.start();
+        this.started = true;
+    }
+    /**
+     * Stop the client (can be restarted).
+     */
+    stop() {
+        this.engine?.stop();
+    }
+    /**
+     * Destroy the client (cannot be restarted).
+     */
+    destroy() {
+        this.engine?.destroy();
+        this.eventListeners.clear();
+        this.destroyed = true;
+    }
+    // ===========================================================================
+    // Sync
+    // ===========================================================================
+    /**
+     * Trigger a manual sync.
+     */
+    async sync() {
+        if (!this.engine) {
+            throw new Error('Client not started');
+        }
+        return this.engine.sync();
+    }
+    // ===========================================================================
+    // Subscriptions
+    // ===========================================================================
+    /**
+     * Update subscriptions.
+     */
+    updateSubscriptions(subscriptions) {
+        this.options.subscriptions = subscriptions;
+        if (this.engine) {
+            this.engine.updateSubscriptions(subscriptions.map((s) => ({
+                id: s.id,
+                shape: s.shape,
+                scopes: s.scopes ?? {},
+                params: s.params ?? {},
+            })));
+        }
+    }
+    /**
+     * Get current subscriptions.
+     */
+    getSubscriptions() {
+        return this.options.subscriptions.map((s) => ({
+            id: s.id,
+            shape: s.shape,
+            scopes: s.scopes ?? {},
+            params: s.params ?? {},
+        }));
+    }
+    // ===========================================================================
+    // State
+    // ===========================================================================
+    /**
+     * Get current client state.
+     */
+    getState() {
+        const engineState = this.engine?.getState() ?? this.createInitialEngineState();
+        return {
+            clientId: this.options.clientId,
+            actorId: this.options.actorId,
+            enabled: engineState.enabled,
+            isSyncing: engineState.isSyncing,
+            connectionState: engineState.connectionState,
+            lastSyncAt: engineState.lastSyncAt,
+            error: engineState.error
+                ? { code: engineState.error.code, message: engineState.error.message }
+                : null,
+            outbox: this.outboxStats,
+        };
+    }
+    /**
+     * Subscribe to state changes (for useSyncExternalStore).
+     */
+    subscribe(callback) {
+        if (!this.engine) {
+            // Return no-op unsubscribe before engine is started
+            return () => { };
+        }
+        return this.engine.subscribe(callback);
+    }
+    // ===========================================================================
+    // Events
+    // ===========================================================================
+    /**
+     * Subscribe to client events.
+     */
+    on(event, handler) {
+        if (!this.eventListeners.has(event)) {
+            this.eventListeners.set(event, new Set());
+        }
+        this.eventListeners.get(event).add(handler);
+        return () => {
+            this.eventListeners.get(event)?.delete(handler);
+        };
+    }
+    emit(event, payload) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            for (const listener of listeners) {
+                try {
+                    listener(payload);
+                }
+                catch (err) {
+                    console.error(`[Client] Error in ${event} listener:`, err);
+                }
+            }
+        }
+    }
+    // ===========================================================================
+    // Conflicts
+    // ===========================================================================
+    /**
+     * Get pending conflicts.
+     */
+    async getConflicts() {
+        if (!this.engine) {
+            return [];
+        }
+        const conflicts = await this.engine.getConflicts();
+        return conflicts.map((c) => this.mapConflictInfo(c));
+    }
+    /**
+     * Resolve a conflict.
+     */
+    async resolveConflict(id, resolution) {
+        const { resolveConflict } = await import('./conflicts');
+        // For 'keep-local' and 'keep-server', we just mark it resolved
+        // For 'custom', we would need to apply the payload - but that requires
+        // creating a new mutation, which the user should do separately
+        const resolutionStr = resolution.strategy === 'custom'
+            ? `custom:${JSON.stringify(resolution.payload)}`
+            : resolution.strategy;
+        await resolveConflict(this.options.db, { id, resolution: resolutionStr });
+        // Get the conflict for the event
+        const conflicts = await this.getConflicts();
+        const resolved = conflicts.find((c) => c.id === id);
+        if (resolved) {
+            this.emit('conflict:resolved', resolved);
+        }
+    }
+    // ===========================================================================
+    // Outbox
+    // ===========================================================================
+    /**
+     * Get outbox statistics.
+     */
+    async getOutboxStats() {
+        if (!this.engine) {
+            return this.outboxStats;
+        }
+        this.outboxStats = await this.engine.refreshOutboxStats({ emit: false });
+        return this.outboxStats;
+    }
+    /**
+     * Clear failed commits from outbox.
+     */
+    async clearFailedCommits() {
+        if (!this.engine) {
+            return 0;
+        }
+        return this.engine.clearFailedCommits();
+    }
+    /**
+     * Retry failed commits.
+     */
+    async retryFailedCommits() {
+        // Mark failed commits as pending and trigger sync
+        const result = await sql `
+      update ${sql.table('sync_outbox_commits')}
+      set
+        ${sql.ref('status')} = ${sql.val('pending')},
+        ${sql.ref('attempt_count')} = ${sql.val(0)},
+        ${sql.ref('error')} = ${sql.val(null)}
+      where ${sql.ref('status')} = ${sql.val('failed')}
+    `.execute(this.options.db);
+        const count = Number(result.numAffectedRows ?? 0n);
+        if (count > 0 && this.engine) {
+            await this.engine.refreshOutboxStats();
+            await this.engine.sync();
+        }
+        return count;
+    }
+    // ===========================================================================
+    // Presence
+    // ===========================================================================
+    /**
+     * Get presence for a scope.
+     */
+    getPresence(scopeKey) {
+        if (!this.engine) {
+            return [];
+        }
+        return this.engine.getPresence(scopeKey);
+    }
+    /**
+     * Join presence for a scope key.
+     */
+    joinPresence(scopeKey, metadata) {
+        this.engine?.joinPresence(scopeKey, metadata);
+    }
+    /**
+     * Leave presence for a scope key.
+     */
+    leavePresence(scopeKey) {
+        this.engine?.leavePresence(scopeKey);
+    }
+    /**
+     * Update presence metadata for a scope key.
+     */
+    updatePresenceMetadata(scopeKey, metadata) {
+        this.engine?.updatePresenceMetadata(scopeKey, metadata);
+    }
+    // ===========================================================================
+    // Migration Info
+    // ===========================================================================
+    /**
+     * Get migration info.
+     */
+    async getMigrationInfo() {
+        // Check if sync tables exist
+        let syncMigrated = false;
+        try {
+            await this.options.db
+                .selectFrom('sync_outbox_commits')
+                .selectAll()
+                .limit(1)
+                .execute();
+            syncMigrated = true;
+        }
+        catch {
+            syncMigrated = false;
+        }
+        // Check if blob tables exist
+        let blobsMigrated = false;
+        try {
+            await this.options.db
+                .selectFrom('sync_blob_cache')
+                .selectAll()
+                .limit(1)
+                .execute();
+            blobsMigrated = true;
+        }
+        catch {
+            blobsMigrated = false;
+        }
+        return { syncMigrated, blobsMigrated };
+    }
+    /**
+     * Static: Check if migrations are needed.
+     */
+    static async checkMigrations(db) {
+        let syncMigrated = false;
+        let blobsMigrated = false;
+        try {
+            await db.selectFrom('sync_outbox_commits').selectAll().limit(1).execute();
+            syncMigrated = true;
+        }
+        catch {
+            syncMigrated = false;
+        }
+        try {
+            await db.selectFrom('sync_blob_cache').selectAll().limit(1).execute();
+            blobsMigrated = true;
+        }
+        catch {
+            blobsMigrated = false;
+        }
+        return {
+            needsMigration: !syncMigrated,
+            syncMigrated,
+            blobsMigrated,
+        };
+    }
+    /**
+     * Static: Run migrations.
+     */
+    static async migrate(db, options) {
+        await ensureClientSyncSchema(db);
+        if (options?.blobs) {
+            await ensureClientBlobSchema(db);
+        }
+    }
+    // ===========================================================================
+    // Private Helpers
+    // ===========================================================================
+    createInitialEngineState() {
+        return {
+            enabled: false,
+            isSyncing: false,
+            connectionState: 'disconnected',
+            transportMode: 'polling',
+            lastSyncAt: null,
+            error: null,
+            pendingCount: 0,
+            retryCount: 0,
+            isRetrying: false,
+        };
+    }
+    wireEngineEvents() {
+        if (!this.engine)
+            return;
+        this.engine.on('sync:start', (payload) => {
+            this.emit('sync:start', payload);
+        });
+        this.engine.on('sync:complete', (payload) => {
+            this.emit('sync:complete', {
+                success: true,
+                pushedCommits: payload.pushedCommits,
+                pullRounds: payload.pullRounds,
+                pullResponse: payload.pullResponse,
+            });
+        });
+        this.engine.on('sync:error', (error) => {
+            this.emit('sync:error', { code: error.code, message: error.message });
+            // Check for new conflicts after sync error
+            this.checkForNewConflicts();
+        });
+        this.engine.on('connection:change', (payload) => {
+            this.emit('connection:change', payload);
+        });
+        this.engine.on('data:change', (payload) => {
+            this.emit('data:change', payload);
+        });
+        this.engine.on('outbox:change', (payload) => {
+            this.outboxStats = {
+                pending: payload.pendingCount,
+                sending: payload.sendingCount,
+                failed: payload.failedCount,
+                acked: payload.ackedCount ?? 0,
+                total: payload.pendingCount +
+                    payload.sendingCount +
+                    payload.failedCount +
+                    (payload.ackedCount ?? 0),
+            };
+            this.emit('outbox:change', this.outboxStats);
+        });
+        this.engine.on('presence:change', (payload) => {
+            this.emit('presence:change', payload);
+        });
+    }
+    async checkForNewConflicts() {
+        const conflicts = await this.getConflicts();
+        for (const conflict of conflicts) {
+            this.emit('conflict:new', conflict);
+        }
+    }
+    mapConflictInfo(info) {
+        let serverPayload = null;
+        if (info.serverRowJson) {
+            try {
+                serverPayload = JSON.parse(info.serverRowJson);
+            }
+            catch {
+                serverPayload = null;
+            }
+        }
+        return {
+            id: info.id,
+            table: info.table,
+            rowId: info.rowId,
+            opIndex: info.opIndex,
+            localPayload: info.localPayload,
+            serverPayload,
+            serverVersion: info.serverVersion,
+            message: info.message,
+            code: info.code,
+            createdAt: info.createdAt,
+        };
+    }
+    createBlobClient(storage, transport) {
+        const db = this.options.db;
+        const blobs = transport.blobs;
+        return {
+            async store(data, options) {
+                const bytes = await toUint8Array(data);
+                const mimeType = data instanceof Blob
+                    ? data.type
+                    : (options?.mimeType ?? 'application/octet-stream');
+                // Compute hash
+                const hashHex = await computeSha256Hex(bytes);
+                const hash = `sha256:${hashHex}`;
+                // Store locally
+                await storage.write(hash, bytes);
+                // Store metadata
+                const now = Date.now();
+                await sql `
+          insert into ${sql.table('sync_blob_cache')} (
+            ${sql.join([
+                    sql.ref('hash'),
+                    sql.ref('size'),
+                    sql.ref('mime_type'),
+                    sql.ref('cached_at'),
+                    sql.ref('last_accessed_at'),
+                    sql.ref('encrypted'),
+                    sql.ref('key_id'),
+                    sql.ref('body'),
+                ])}
+          ) values (
+            ${sql.join([
+                    sql.val(hash),
+                    sql.val(bytes.length),
+                    sql.val(mimeType),
+                    sql.val(now),
+                    sql.val(now),
+                    sql.val(0),
+                    sql.val(null),
+                    sql.val(bytes),
+                ])}
+          )
+          on conflict (${sql.ref('hash')}) do nothing
+        `.execute(db);
+                // Queue for upload or upload immediately
+                if (options?.immediate) {
+                    // Initiate upload
+                    const initResult = await blobs.initiateUpload({
+                        hash,
+                        size: bytes.length,
+                        mimeType,
+                    });
+                    if (!initResult.exists && initResult.uploadUrl) {
+                        // Upload to presigned URL
+                        const uploadResponse = await fetch(initResult.uploadUrl, {
+                            method: initResult.uploadMethod ?? 'PUT',
+                            body: bytes.buffer,
+                            headers: initResult.uploadHeaders,
+                        });
+                        if (!uploadResponse.ok) {
+                            throw new Error(`Upload failed: ${uploadResponse.statusText}`);
+                        }
+                        // Complete upload
+                        await blobs.completeUpload(hash);
+                    }
+                }
+                else {
+                    // Queue for later upload
+                    await sql `
+            insert into ${sql.table('sync_blob_outbox')} (
+              ${sql.join([
+                        sql.ref('hash'),
+                        sql.ref('size'),
+                        sql.ref('mime_type'),
+                        sql.ref('status'),
+                        sql.ref('created_at'),
+                        sql.ref('updated_at'),
+                        sql.ref('attempt_count'),
+                        sql.ref('error'),
+                        sql.ref('encrypted'),
+                        sql.ref('key_id'),
+                        sql.ref('body'),
+                    ])}
+            ) values (
+              ${sql.join([
+                        sql.val(hash),
+                        sql.val(bytes.length),
+                        sql.val(mimeType),
+                        sql.val('pending'),
+                        sql.val(now),
+                        sql.val(now),
+                        sql.val(0),
+                        sql.val(null),
+                        sql.val(0),
+                        sql.val(null),
+                        sql.val(bytes),
+                    ])}
+            )
+            on conflict (${sql.ref('hash')}) do nothing
+          `.execute(db);
+                }
+                return {
+                    hash,
+                    size: bytes.length,
+                    mimeType,
+                };
+            },
+            async retrieve(ref) {
+                // Check local storage first
+                const local = await storage.read(ref.hash);
+                if (local) {
+                    // Update access time
+                    await sql `
+            update ${sql.table('sync_blob_cache')}
+            set ${sql.ref('last_accessed_at')} = ${sql.val(Date.now())}
+            where ${sql.ref('hash')} = ${sql.val(ref.hash)}
+          `.execute(db);
+                    return local;
+                }
+                // Fetch from server
+                const { url } = await blobs.getDownloadUrl(ref.hash);
+                const response = await fetch(url);
+                if (!response.ok) {
+                    throw new Error(`Download failed: ${response.statusText}`);
+                }
+                const bytes = new Uint8Array(await response.arrayBuffer());
+                // Cache locally
+                await storage.write(ref.hash, bytes);
+                const now = Date.now();
+                await sql `
+          insert into ${sql.table('sync_blob_cache')} (
+            ${sql.join([
+                    sql.ref('hash'),
+                    sql.ref('size'),
+                    sql.ref('mime_type'),
+                    sql.ref('cached_at'),
+                    sql.ref('last_accessed_at'),
+                    sql.ref('encrypted'),
+                    sql.ref('key_id'),
+                    sql.ref('body'),
+                ])}
+          ) values (
+            ${sql.join([
+                    sql.val(ref.hash),
+                    sql.val(bytes.length),
+                    sql.val(ref.mimeType),
+                    sql.val(now),
+                    sql.val(now),
+                    sql.val(0),
+                    sql.val(null),
+                    sql.val(bytes),
+                ])}
+          )
+          on conflict (${sql.ref('hash')}) do nothing
+        `.execute(db);
+                return bytes;
+            },
+            async isLocal(hash) {
+                return storage.exists(hash);
+            },
+            async preload(refs) {
+                await Promise.all(refs.map((ref) => this.retrieve(ref)));
+            },
+            async processUploadQueue() {
+                let uploaded = 0;
+                let failed = 0;
+                const pendingResult = await sql `
+          select
+            ${sql.ref('hash')},
+            ${sql.ref('size')},
+            ${sql.ref('mime_type')},
+            ${sql.ref('body')}
+          from ${sql.table('sync_blob_outbox')}
+          where ${sql.ref('status')} = ${sql.val('pending')}
+          limit ${sql.val(10)}
+        `.execute(db);
+                const pending = pendingResult.rows;
+                for (const item of pending) {
+                    try {
+                        // Mark as uploading
+                        await sql `
+              update ${sql.table('sync_blob_outbox')}
+              set
+                ${sql.ref('status')} = ${sql.val('uploading')},
+                ${sql.ref('updated_at')} = ${sql.val(Date.now())}
+              where ${sql.ref('hash')} = ${sql.val(item.hash)}
+            `.execute(db);
+                        // Initiate upload
+                        const initResult = await blobs.initiateUpload({
+                            hash: item.hash,
+                            size: item.size,
+                            mimeType: item.mime_type,
+                        });
+                        if (!initResult.exists && initResult.uploadUrl && item.body) {
+                            const uploadBody = new ArrayBuffer(item.body.byteLength);
+                            new Uint8Array(uploadBody).set(item.body);
+                            // Upload
+                            const uploadResponse = await fetch(initResult.uploadUrl, {
+                                method: initResult.uploadMethod ?? 'PUT',
+                                body: uploadBody,
+                                headers: initResult.uploadHeaders,
+                            });
+                            if (!uploadResponse.ok) {
+                                throw new Error(`Upload failed: ${uploadResponse.statusText}`);
+                            }
+                            // Complete
+                            await blobs.completeUpload(item.hash);
+                        }
+                        // Mark as complete
+                        await sql `
+              delete from ${sql.table('sync_blob_outbox')}
+              where ${sql.ref('hash')} = ${sql.val(item.hash)}
+            `.execute(db);
+                        uploaded++;
+                    }
+                    catch (err) {
+                        // Mark as failed
+                        await sql `
+              update ${sql.table('sync_blob_outbox')}
+              set
+                ${sql.ref('status')} = ${sql.val('failed')},
+                ${sql.ref('error')} = ${sql.val(err instanceof Error ? err.message : 'Unknown error')},
+                ${sql.ref('attempt_count')} = ${sql.ref('attempt_count')} + ${sql.val(1)},
+                ${sql.ref('updated_at')} = ${sql.val(Date.now())}
+              where ${sql.ref('hash')} = ${sql.val(item.hash)}
+            `.execute(db);
+                        failed++;
+                    }
+                }
+                return { uploaded, failed };
+            },
+            async getUploadQueueStats() {
+                const rowsResult = await sql `
+          select
+            ${sql.ref('status')} as status,
+            count(${sql.ref('hash')}) as count
+          from ${sql.table('sync_blob_outbox')}
+          group by ${sql.ref('status')}
+        `.execute(db);
+                const stats = { pending: 0, uploading: 0, failed: 0 };
+                for (const row of rowsResult.rows) {
+                    if (row.status === 'pending')
+                        stats.pending = Number(row.count);
+                    if (row.status === 'uploading')
+                        stats.uploading = Number(row.count);
+                    if (row.status === 'failed')
+                        stats.failed = Number(row.count);
+                }
+                return stats;
+            },
+            async getCacheStats() {
+                const result = await sql `
+          select
+            count(${sql.ref('hash')}) as count,
+            sum(${sql.ref('size')}) as totalBytes
+          from ${sql.table('sync_blob_cache')}
+        `.execute(db);
+                const row = result.rows[0];
+                return {
+                    count: Number(row?.count ?? 0),
+                    totalBytes: Number(row?.totalBytes ?? 0),
+                };
+            },
+            async pruneCache(maxBytes) {
+                if (!maxBytes)
+                    return 0;
+                // Get current size
+                const stats = await this.getCacheStats();
+                if (stats.totalBytes <= maxBytes)
+                    return 0;
+                // Get oldest entries to delete
+                const toFree = stats.totalBytes - maxBytes;
+                let freed = 0;
+                const oldEntriesResult = await sql `
+          select ${sql.ref('hash')}, ${sql.ref('size')}
+          from ${sql.table('sync_blob_cache')}
+          order by ${sql.ref('last_accessed_at')} asc
+        `.execute(db);
+                const oldEntries = oldEntriesResult.rows;
+                for (const entry of oldEntries) {
+                    if (freed >= toFree)
+                        break;
+                    await storage.delete(entry.hash);
+                    await sql `
+            delete from ${sql.table('sync_blob_cache')}
+            where ${sql.ref('hash')} = ${sql.val(entry.hash)}
+          `.execute(db);
+                    freed += entry.size;
+                }
+                return freed;
+            },
+            async clearCache() {
+                if (storage.clear) {
+                    await storage.clear();
+                }
+                else {
+                    // Delete each entry individually
+                    const entriesResult = await sql `
+            select ${sql.ref('hash')}
+            from ${sql.table('sync_blob_cache')}
+          `.execute(db);
+                    for (const entry of entriesResult.rows) {
+                        await storage.delete(entry.hash);
+                    }
+                }
+                await sql `delete from ${sql.table('sync_blob_cache')}`.execute(db);
+            },
+        };
+    }
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+async function toUint8Array(data) {
+    if (data instanceof Uint8Array) {
+        return data;
+    }
+    const buffer = await data.arrayBuffer();
+    return new Uint8Array(buffer);
+}
+async function computeSha256Hex(data) {
+    const hashBuffer = await crypto.subtle.digest('SHA-256', data.buffer);
+    const hashArray = new Uint8Array(hashBuffer);
+    return Array.from(hashArray)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+//# sourceMappingURL=client.js.map