@syncular/client 0.0.6-96 → 0.1.1

package/dist/client.js

@@ -1,993 +1,219 @@
-/**
- * @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 { countSyncMetric } from '@syncular/core';
-import { sql } from 'kysely';
-import { ensureClientBlobSchema } from './blobs/migrate.js';
-import { SyncEngine } from './engine/SyncEngine.js';
-import { ensureClientSyncSchema } from './migrate.js';
-import { createMutationsApi, createOutboxCommit, } from './mutations.js';
-// ============================================================================
-// 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', table: '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;
-    emittedConflictIds = new Set();
-    eventListeners = new Map();
-    outboxStats = {
-        pending: 0,
-        sending: 0,
-        failed: 0,
-        acked: 0,
-        total: 0,
+import { isSyncularOfflineError } from './errors.js';
+import { browserSyncularNetworkStatusSource } from './network.js';
+export function getSyncularClientStatus(client) {
+    const lifecycle = client.lifecycleState();
+    const connection = client.connectionState();
+    const outbox = lifecycle.outbox ?? null;
+    const conflicts = lifecycle.conflicts ?? null;
+    return {
+        lifecycle,
+        connection,
+        outbox,
+        conflicts,
+        isConnected: connection.realtime === 'connected' && !connection.closed,
+        isSyncing: lifecycle.phase === 'syncing' || lifecycle.phase === 'recovering',
+        hasPendingMutations: (outbox?.pending ?? 0) + (outbox?.sending ?? 0) > 0,
+        hasConflicts: (conflicts?.unresolved ?? 0) > 0,
+        requiresAction: lifecycle.requiresAction,
     };
-    /** Mutations API (always available) */
-    mutations;
-    /** Blob client (only available if blobStorage configured) */
-    blobs;
-    constructor(options) {
+}
+export class SyncularClientLifecycle {
+    client;
+    options;
+    #started = false;
+    #pollTimer;
+    #unsubscribeDiagnostics;
+    #unsubscribeNetwork;
+    #syncInFlight;
+    #queuedSyncWaiters = [];
+    #hasConnectedRealtime = false;
+    #realtimeStarted = false;
+    #network;
+    constructor(client, options = {}) {
+        this.client = client;
         this.options = options;
-        // Create mutations API
-        const commitFn = createOutboxCommit({
-            db: options.db,
-            idColumn: options.idColumn ?? 'id',
-            versionColumn: options.versionColumn ?? 'server_version',
-            omitColumns: options.omitColumns ?? [],
-            codecs: options.codecs,
-            codecDialect: options.codecDialect,
-        });
-        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;
+        this.#network =
+            options.network === false
+                ? undefined
+                : (options.network ?? browserSyncularNetworkStatusSource());
     }
-    /** 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) {
+        if (this.#started)
             return;
+        this.#started = true;
+        this.#hasConnectedRealtime =
+            this.client.connectionState().realtime === 'connected';
+        this.#realtimeStarted = this.#hasConnectedRealtime;
+        this.#unsubscribeDiagnostics = this.client.addDiagnosticListener((event) => this.#handleDiagnostic(event));
+        this.#unsubscribeNetwork = this.#subscribeNetworkEvents();
+        try {
+            if (this.options.subscriptions) {
+                await this.client.setSubscriptions(this.options.subscriptions);
+            }
+            if (this.options.initialSync !== false && this.#isOnline()) {
+                await this.#syncForLifecycle();
+            }
+            if (this.options.realtime !== false && this.#isOnline()) {
+                await this.#startRealtimeForLifecycle();
+            }
+            this.#startPolling();
         }
-        // Run migrations
-        await ensureClientSyncSchema(this.options.db);
-        if (this.options.blobStorage) {
-            await ensureClientBlobSchema(this.options.db);
+        catch (error) {
+            await this.stop().catch(() => undefined);
+            throw error;
         }
-        // Create and start engine
-        this.engine = new SyncEngine({
-            db: this.options.db,
-            transport: this.options.transport,
-            handlers: this.options.tableHandlers,
-            clientId: this.options.clientId,
-            actorId: this.options.actorId,
-            subscriptions: this.options.subscriptions.map((s) => ({
-                id: s.id,
-                table: s.table,
-                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;
+    async stop() {
+        if (!this.#started)
+            return;
+        this.#started = false;
+        this.#stopPolling();
+        this.#unsubscribeDiagnostics?.();
+        this.#unsubscribeDiagnostics = undefined;
+        this.#unsubscribeNetwork?.();
+        this.#unsubscribeNetwork = undefined;
+        this.#rejectQueuedSyncWaiters(new Error('Syncular lifecycle stopped before queued sync could run'));
+        if (this.options.realtime !== false) {
+            await this.client.stopRealtime();
+        }
+        this.#realtimeStarted = false;
     }
-    // ===========================================================================
-    // 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,
-                table: s.table,
-                scopes: s.scopes ?? {},
-                params: s.params ?? {},
-            })));
-        }
-    }
-    /**
-     * Get current subscriptions.
-     */
-    getSubscriptions() {
-        return this.options.subscriptions.map((s) => ({
-            id: s.id,
-            table: s.table,
-            scopes: s.scopes ?? {},
-            params: s.params ?? {},
-        }));
-    }
-    /**
-     * List persisted subscription metadata rows.
-     */
-    async listSubscriptionStates(args) {
-        if (!this.engine)
-            return [];
-        return this.engine.listSubscriptionStates(args);
-    }
-    /**
-     * Read one persisted subscription metadata row.
-     */
-    async getSubscriptionState(subscriptionId, options) {
-        if (!this.engine)
-            return null;
-        return this.engine.getSubscriptionState(subscriptionId, options);
-    }
-    // ===========================================================================
-    // 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,
-        };
-    }
-    /**
-     * Get current transport health details.
-     */
-    getTransportHealth() {
-        if (!this.engine)
-            return null;
-        return this.engine.getTransportHealth();
-    }
-    /**
-     * Get computed sync progress across subscriptions.
-     */
-    async getProgress() {
-        if (!this.engine)
-            return null;
-        return this.engine.getProgress();
-    }
-    /**
-     * Get a diagnostics snapshot for support/debug flows.
-     */
-    async getDiagnostics() {
-        if (!this.engine)
-            return null;
-        return this.engine.getDiagnostics();
-    }
-    /**
-     * Get a serializable inspector snapshot for in-app debug tooling.
-     */
-    async getInspectorSnapshot(options) {
-        if (!this.engine)
-            return null;
-        return this.engine.getInspectorSnapshot(options);
-    }
-    /**
-     * Reset local sync metadata (and optionally synced app rows/outbox/conflicts).
-     */
-    async reset(options) {
-        if (!this.engine) {
-            return {
-                deletedSubscriptionStates: 0,
-                deletedOutboxCommits: 0,
-                deletedConflicts: 0,
-                clearedTables: [],
-            };
-        }
-        return this.engine.reset(options);
-    }
-    /**
-     * Run a built-in repair flow for common corruption scenarios.
-     */
-    async repair(options) {
-        if (!this.engine) {
-            return {
-                deletedSubscriptionStates: 0,
-                deletedOutboxCommits: 0,
-                deletedConflicts: 0,
-                clearedTables: [],
-            };
+        if (this.#syncInFlight) {
+            return new Promise((resolve, reject) => {
+                this.#queuedSyncWaiters.push({ resolve, reject });
+            });
         }
-        return this.engine.repair(options);
+        this.#syncInFlight = this.#startSyncCycle();
+        return this.#syncInFlight;
     }
-    /**
-     * Wait until the channel reaches a target phase.
-     */
-    async awaitPhase(phase, options = {}) {
-        if (!this.engine)
-            return null;
-        return this.engine.awaitPhase(phase, options);
-    }
-    /**
-     * Wait until bootstrap completes for the default state or a specific subscription.
-     */
-    async awaitBootstrapComplete(options = {}) {
-        if (!this.engine)
-            return null;
-        return this.engine.awaitBootstrapComplete(options);
-    }
-    /**
-     * Subscribe to state changes (for useSyncExternalStore).
-     */
-    subscribe(callback) {
-        if (!this.engine) {
-            // Return no-op unsubscribe before engine is started
-            return () => { };
+    #startSyncCycle() {
+        let sync;
+        try {
+            sync = Promise.resolve(this.client.syncOnce());
         }
-        return this.engine.subscribe(callback);
-    }
-    // ===========================================================================
-    // Events
-    // ===========================================================================
-    /**
-     * Subscribe to client events.
-     */
-    on(event, handler) {
-        if (!this.eventListeners.has(event)) {
-            this.eventListeners.set(event, new Set());
+        catch (error) {
+            sync = Promise.reject(error);
         }
-        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);
-                }
+        const finish = () => {
+            if (this.#syncInFlight === sync) {
+                this.#syncInFlight = undefined;
             }
-        }
-    }
-    // ===========================================================================
-    // 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.js');
-        const pendingBeforeResolve = await this.getConflicts();
-        const resolvedConflict = pendingBeforeResolve.find((c) => c.id === id);
-        // 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 });
-        countSyncMetric('sync.conflicts.resolved', 1, {
-            attributes: {
-                strategy: resolution.strategy,
-            },
+            const waiters = this.#queuedSyncWaiters.splice(0);
+            if (waiters.length === 0)
+                return;
+            if (!this.#started) {
+                const error = new Error('Syncular lifecycle stopped before queued sync could run');
+                for (const waiter of waiters)
+                    waiter.reject(error);
+                return;
+            }
+            const queued = this.#startSyncCycle();
+            this.#syncInFlight = queued;
+            queued.then((result) => {
+                for (const waiter of waiters)
+                    waiter.resolve(result);
+            }, (error) => {
+                for (const waiter of waiters)
+                    waiter.reject(error);
+            });
+        };
+        void sync.then(finish, finish).catch((error) => {
+            this.#rejectQueuedSyncWaiters(error);
         });
-        this.emittedConflictIds.delete(id);
-        if (resolvedConflict) {
-            this.emit('conflict:resolved', resolvedConflict);
+        return sync;
+    }
+    #rejectQueuedSyncWaiters(error) {
+        const waiters = this.#queuedSyncWaiters.splice(0);
+        for (const waiter of waiters)
+            waiter.reject(error);
+    }
+    #handleDiagnostic(event) {
+        if (event.source === 'sync' && event.details?.resyncRequired === true) {
+            void this.client
+                .forceSubscriptionsBootstrap()
+                .then(() => this.sync())
+                .catch(() => undefined);
+            return;
         }
-    }
-    // ===========================================================================
-    // Outbox
-    // ===========================================================================
-    /**
-     * Get outbox statistics.
-     */
-    async getOutboxStats() {
-        if (!this.engine) {
-            return this.outboxStats;
+        if (event.source !== 'realtime' ||
+            event.code !== 'realtime.state' ||
+            event.details?.state == null) {
+            return;
         }
-        this.outboxStats = await this.engine.refreshOutboxStats({ emit: false });
-        return this.outboxStats;
+        const state = event.details.state;
+        if (state !== 'connected')
+            return;
+        const wasReconnect = this.#hasConnectedRealtime;
+        this.#hasConnectedRealtime = true;
+        const shouldSync = this.options.syncOnRealtimeConnect !== false &&
+            (wasReconnect || this.options.initialSync === false);
+        if (!shouldSync)
+            return;
+        void this.sync().catch(() => undefined);
     }
-    /**
-     * Clear failed commits from outbox.
-     */
-    async clearFailedCommits() {
-        if (!this.engine) {
-            return 0;
-        }
-        return this.engine.clearFailedCommits();
+    #subscribeNetworkEvents() {
+        const network = this.#network;
+        if (!network?.addEventListener || !network.removeEventListener)
+            return;
+        const handleOnline = () => {
+            if (!this.#started)
+                return;
+            void this.#resumeOnline().catch(() => undefined);
+        };
+        network.addEventListener('online', handleOnline);
+        return () => {
+            network.removeEventListener?.('online', handleOnline);
+        };
     }
-    /**
-     * 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();
+    async #resumeOnline() {
+        if (!this.#started || !this.#isOnline())
+            return;
+        if (this.options.initialSync !== false) {
+            await this.#syncForLifecycle();
         }
-        return count;
-    }
-    // ===========================================================================
-    // Presence
-    // ===========================================================================
-    /**
-     * Get presence for a scope.
-     */
-    getPresence(scopeKey) {
-        if (!this.engine) {
-            return [];
+        if (this.options.realtime !== false && !this.#realtimeStarted) {
+            await this.#startRealtimeForLifecycle();
         }
-        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;
+    async #syncForLifecycle() {
         try {
-            await this.options.db
-                .selectFrom('sync_outbox_commits')
-                .selectAll()
-                .limit(1)
-                .execute();
-            syncMigrated = true;
-        }
-        catch {
-            syncMigrated = false;
+            await this.sync();
         }
-        // Check if blob tables exist
-        let blobsMigrated = false;
-        try {
-            await this.options.db
-                .selectFrom('sync_blob_cache')
-                .selectAll()
-                .limit(1)
-                .execute();
-            blobsMigrated = true;
+        catch (error) {
+            if (!isSyncularOfflineError(error))
+                throw error;
         }
-        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;
-        }
+    async #startRealtimeForLifecycle() {
         try {
-            await db.selectFrom('sync_blob_cache').selectAll().limit(1).execute();
-            blobsMigrated = true;
-        }
-        catch {
-            blobsMigrated = false;
+            await this.client.startRealtime(this.options.realtime);
+            this.#realtimeStarted = true;
         }
-        return {
-            needsMigration: !syncMigrated,
-            syncMigrated,
-            blobsMigrated,
-        };
-    }
-    /**
-     * Static: Run migrations.
-     */
-    static async migrate(db, options) {
-        await ensureClientSyncSchema(db);
-        if (options?.blobs) {
-            await ensureClientBlobSchema(db);
+        catch (error) {
+            this.#realtimeStarted = false;
+            if (!isSyncularOfflineError(error))
+                throw error;
         }
     }
-    // ===========================================================================
-    // Private Helpers
-    // ===========================================================================
-    createInitialEngineState() {
-        return {
-            enabled: false,
-            isSyncing: false,
-            connectionState: 'disconnected',
-            transportMode: 'polling',
-            lastSyncAt: null,
-            error: null,
-            pendingCount: 0,
-            retryCount: 0,
-            isRetrying: false,
-        };
+    #isOnline() {
+        return this.#network?.isOnline() !== false;
     }
-    wireEngineEvents() {
-        if (!this.engine)
+    #startPolling() {
+        const interval = this.options.pollIntervalMs;
+        if (interval === false || interval === undefined || interval <= 0)
             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:live', (payload) => {
-            this.emit('sync:live', payload);
-        });
-        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('bootstrap:start', (payload) => {
-            this.emit('bootstrap:start', payload);
-        });
-        this.engine.on('bootstrap:progress', (payload) => {
-            this.emit('bootstrap:progress', payload);
-        });
-        this.engine.on('bootstrap:complete', (payload) => {
-            this.emit('bootstrap:complete', payload);
-        });
-        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();
-        const activeIds = new Set(conflicts.map((conflict) => conflict.id));
-        for (const id of this.emittedConflictIds) {
-            if (!activeIds.has(id)) {
-                this.emittedConflictIds.delete(id);
-            }
-        }
-        for (const conflict of conflicts) {
-            if (this.emittedConflictIds.has(conflict.id)) {
-                continue;
-            }
-            this.emittedConflictIds.add(conflict.id);
-            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;
-        const staleUploadingTimeoutMs = 30_000;
-        const maxUploadRetries = 3;
-        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 now = Date.now();
-                const staleThreshold = now - staleUploadingTimeoutMs;
-                await sql `
-          update ${sql.table('sync_blob_outbox')}
-          set
-            ${sql.ref('status')} = ${sql.val('failed')},
-            ${sql.ref('attempt_count')} = ${sql.ref('attempt_count')} + ${sql.val(1)},
-            ${sql.ref('error')} = ${sql.val('Upload timed out while in uploading state')},
-            ${sql.ref('updated_at')} = ${sql.val(now)}
-          where ${sql.ref('status')} = ${sql.val('uploading')}
-            and ${sql.ref('updated_at')} < ${sql.val(staleThreshold)}
-            and ${sql.ref('attempt_count')} + ${sql.val(1)} >= ${sql.val(maxUploadRetries)}
-        `.execute(db);
-                await sql `
-          update ${sql.table('sync_blob_outbox')}
-          set
-            ${sql.ref('status')} = ${sql.val('pending')},
-            ${sql.ref('attempt_count')} = ${sql.ref('attempt_count')} + ${sql.val(1)},
-            ${sql.ref('error')} = ${sql.val('Upload timed out while in uploading state; retrying')},
-            ${sql.ref('updated_at')} = ${sql.val(now)}
-          where ${sql.ref('status')} = ${sql.val('uploading')}
-            and ${sql.ref('updated_at')} < ${sql.val(staleThreshold)}
-            and ${sql.ref('attempt_count')} + ${sql.val(1)} < ${sql.val(maxUploadRetries)}
-        `.execute(db);
-                const pendingResult = await sql `
-          select
-            ${sql.ref('hash')},
-            ${sql.ref('size')},
-            ${sql.ref('mime_type')},
-            ${sql.ref('body')},
-            ${sql.ref('attempt_count')}
-          from ${sql.table('sync_blob_outbox')}
-          where ${sql.ref('status')} = ${sql.val('pending')}
-            and ${sql.ref('attempt_count')} < ${sql.val(maxUploadRetries)}
-          limit ${sql.val(10)}
-        `.execute(db);
-                const pending = pendingResult.rows;
-                for (const item of pending) {
-                    const nextAttemptCount = item.attempt_count + 1;
-                    try {
-                        // Mark as uploading
-                        await sql `
-              update ${sql.table('sync_blob_outbox')}
-              set
-                ${sql.ref('status')} = ${sql.val('uploading')},
-                ${sql.ref('attempt_count')} = ${sql.val(nextAttemptCount)},
-                ${sql.ref('error')} = ${sql.val(null)},
-                ${sql.ref('updated_at')} = ${sql.val(Date.now())}
-              where ${sql.ref('hash')} = ${sql.val(item.hash)}
-                and ${sql.ref('status')} = ${sql.val('pending')}
-            `.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
-                            const completeResult = await blobs.completeUpload(item.hash);
-                            if (!completeResult.ok) {
-                                throw new Error(completeResult.error ?? 'Failed to complete blob upload');
-                            }
-                        }
-                        // 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) {
-                        const nextStatus = nextAttemptCount >= maxUploadRetries ? 'failed' : 'pending';
-                        await sql `
-              update ${sql.table('sync_blob_outbox')}
-              set
-                ${sql.ref('status')} = ${sql.val(nextStatus)},
-                ${sql.ref('error')} = ${sql.val(err instanceof Error ? err.message : 'Unknown error')},
-                ${sql.ref('updated_at')} = ${sql.val(Date.now())}
-              where ${sql.ref('hash')} = ${sql.val(item.hash)}
-            `.execute(db);
-                        if (nextStatus === 'failed') {
-                            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;
+        this.#pollTimer = setInterval(() => {
+            if (!this.#isOnline())
+                return;
+            void this.#syncForLifecycle();
+        }, interval);
+    }
+    #stopPolling() {
+        if (!this.#pollTimer)
+            return;
+        clearInterval(this.#pollTimer);
+        this.#pollTimer = undefined;
     }
-    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