@pol-studios/powersync 1.0.30 → 1.0.33

package/dist/pol-attachment-queue-DqBvLAEY.d.ts

@@ -0,0 +1,255 @@
+import { AbstractAttachmentQueue, AttachmentQueueOptions, AttachmentRecord } from '@powersync/attachments';
+import { AbstractPowerSyncDatabase } from '@powersync/common';
+import { PlatformAdapter } from './platform/index.js';
+import { e as AttachmentStorageAdapter, c as AttachmentSourceConfig, h as UploadHandler, U as UploadConfig, i as DownloadConfig, a as PolAttachmentRecord, f as CompressionConfig, k as CacheConfig, t as UploadStatus, v as AttachmentSyncStats, d as AttachmentConfig } from './types-JCEhw2Lf.js';
+
+/**
+ * POL Attachment Queue
+ *
+ * Extends the official @powersync/attachments AbstractAttachmentQueue with
+ * POL-specific features:
+ * - Reactive watchPaths callback for attachment path sources
+ * - Durable upload queue with exponential backoff retry
+ * - FAILED_PERMANENT state for unrecoverable upload errors
+ * - Image compression integration
+ * - Upload callbacks (onUploadComplete, onUploadFailed)
+ *
+ * @example
+ * ```typescript
+ * const queue = new PolAttachmentQueue({
+ *   powersync: db,
+ *   storage: storageAdapter,
+ *   source: {
+ *     source: { type: 'supabase-bucket', bucket: 'project-assets' },
+ *     watchPaths: (db, supabase, onUpdate) => {
+ *       db.watch(
+ *         // Filter in the query - only emit paths you want to download
+ *         `SELECT storagePath FROM photos
+ *          WHERE storagePath IS NOT NULL
+ *          AND mediaType NOT LIKE 'video/%'`,
+ *         [],
+ *         { onResult: (r) => onUpdate(r.rows._array.map(row => row.storagePath)) }
+ *       );
+ *     },
+ *   },
+ * });
+ *
+ * await queue.init();
+ * ```
+ */
+
+/**
+ * Options for PolAttachmentQueue that extend the official AttachmentQueueOptions.
+ */
+interface PolAttachmentQueueOptions extends AttachmentQueueOptions {
+    platform: PlatformAdapter;
+    remoteStorage: AttachmentStorageAdapter;
+    /** Attachment source configuration with reactive watchPaths callback */
+    source: AttachmentSourceConfig;
+    /**
+     * Supabase client for passing to watchPaths callback.
+     * Required when using watchPaths (new API).
+     */
+    supabaseClient?: unknown;
+    uploadHandler?: UploadHandler;
+    uploadConfig?: Partial<UploadConfig>;
+    /** Download configuration for concurrency tuning */
+    downloadConfig?: Partial<DownloadConfig>;
+    onUploadComplete?: (record: PolAttachmentRecord) => Promise<void>;
+    onUploadFailed?: (record: PolAttachmentRecord, error: Error) => void;
+    compression?: Partial<CompressionConfig>;
+    cache?: Partial<CacheConfig>;
+}
+/**
+ * POL Attachment Queue that extends the official AbstractAttachmentQueue.
+ */
+declare class PolAttachmentQueue extends AbstractAttachmentQueue<PolAttachmentQueueOptions> {
+    private readonly platform;
+    private readonly polLogger;
+    private readonly source;
+    private readonly remoteStorage;
+    private readonly supabaseClient?;
+    private readonly uploadHandler?;
+    private readonly uploadConfig;
+    private readonly downloadConfig;
+    private readonly compressionConfig;
+    private readonly cacheConfig;
+    private _uploadState;
+    private _disposed;
+    private _initialized;
+    private _watchGeneration;
+    private _watchCleanup;
+    private _watchMutex;
+    private _networkListenerCleanup;
+    private _wasConnected;
+    private _cacheCapacityRetries;
+    private _progressCallbacks;
+    private _lastNotifyTime;
+    private _notifyTimer;
+    private _cachedStats;
+    private _cachedStatsTimestamp;
+    constructor(options: PolAttachmentQueueOptions);
+    watchUploads(): void;
+    /**
+     * Override parent's expireCache to disable count-based cache eviction.
+     *
+     * The parent implementation deletes SYNCED/ARCHIVED records beyond cacheLimit,
+     * which caused a bug where downloads would reset because:
+     * 1. expireCache deleted records beyond cacheLimit (default 100)
+     * 2. watchPaths still emitted those IDs
+     * 3. They got re-created as QUEUED_DOWNLOAD
+     * 4. Downloads restarted in an infinite loop
+     *
+     * Our implementation uses size-based cache limits only (via clearCache/cacheConfig.maxSize).
+     */
+    expireCache(): Promise<void>;
+    /**
+     * Override parent's watchDownloads to use concurrent downloads.
+     *
+     * The parent implementation downloads one file at a time.
+     * This override processes downloads in parallel batches for faster sync.
+     */
+    watchDownloads(): void;
+    /**
+     * Process pending downloads with concurrency control.
+     * Downloads multiple files in parallel based on downloadConfig.concurrency.
+     * Enforces cache size limits after each batch completes.
+     */
+    private _downloadRecordsConcurrent;
+    uploadAttachment(record: {
+        id: string;
+    }): Promise<boolean>;
+    watchAttachmentIds(): Promise<void>;
+    saveToQueue(record: Omit<AttachmentRecord, 'timestamp'>): Promise<AttachmentRecord>;
+    onAttachmentIdsChange(onUpdate: (ids: string[]) => void): void;
+    downloadRecord(record: AttachmentRecord): Promise<boolean>;
+    newAttachmentRecord(record?: Partial<AttachmentRecord>): Promise<AttachmentRecord>;
+    init(): Promise<void>;
+    /**
+     * Dispose the attachment queue and clean up resources.
+     * This method is synchronous to ensure callers don't need to await it,
+     * but it fires off async cleanup in the background for graceful shutdown.
+     */
+    dispose(): void;
+    /**
+     * Async cleanup that runs in the background after dispose().
+     * Waits for active upload promises to settle gracefully.
+     */
+    private _asyncCleanup;
+    queueUpload(options: {
+        storagePath: string;
+        sourceUri: string;
+        filename: string;
+        mediaType: string;
+        bucketId?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    getPendingUploads(): Promise<PolAttachmentRecord[]>;
+    getSoonestRetryTime(): Promise<number | null>;
+    getFailedPermanentUploads(): Promise<PolAttachmentRecord[]>;
+    getStaleUploads(): Promise<PolAttachmentRecord[]>;
+    getSyncedUploadsWithPendingCallback(): Promise<PolAttachmentRecord[]>;
+    clearUploadCallback(id: string): Promise<void>;
+    retryUpload(id: string): Promise<void>;
+    /**
+     * Reset all uploads in QUEUED_UPLOAD state so they retry immediately.
+     * This clears retry counts and errors, allowing uploads to be retried fresh.
+     *
+     * @returns The number of uploads that were reset
+     */
+    resetUploadRetries(): Promise<number>;
+    /**
+     * Trigger immediate retry of uploads WITHOUT resetting their retry count.
+     * This preserves backoff state for truly failing uploads while allowing
+     * uploads that were waiting for network to retry immediately.
+     *
+     * Only affects uploads that:
+     * - Are past their retry time (upload_next_retry_at <= now), OR
+     * - Have no retry time set (upload_next_retry_at IS NULL)
+     *
+     * @returns The number of uploads that will be retried
+     */
+    retryUploads(): Promise<number>;
+    deleteUpload(id: string): Promise<void>;
+    /**
+     * Re-queue an upload for an orphaned attachment.
+     * Use this when a database record exists with a storagePath but the file was never uploaded.
+     *
+     * This handles the case where:
+     * - User took a photo and the database record was created with a storagePath
+     * - The attachment queue record was created but disappeared before upload completed
+     * - The photo shows locally but was never uploaded to storage
+     *
+     * @param options.storagePath - The storage path (e.g., "projectId/fileId.jpg")
+     * @param options.localFileUri - URI to the local file to upload
+     * @param options.mediaType - MIME type of the file
+     * @param options.bucketId - Optional bucket ID for multi-bucket setups
+     * @returns true if upload was queued, false if already exists in valid state
+     */
+    requeueOrphanedUpload(options: {
+        storagePath: string;
+        localFileUri: string;
+        mediaType: string;
+        bucketId?: string;
+    }): Promise<boolean>;
+    getRecord(id: string): Promise<PolAttachmentRecord | null>;
+    getFailedUploads(): Promise<PolAttachmentRecord[]>;
+    retryFailedUpload(id: string): Promise<void>;
+    deleteFailedUpload(id: string): Promise<void>;
+    get activeUploads(): UploadStatus[];
+    pauseUploads(): void;
+    resumeUploads(): void;
+    clearCache(): Promise<void>;
+    cacheLocalFile(storagePath: string, sourceUri: string): Promise<void>;
+    getLocalUriForStoragePath(storagePath: string): Promise<string | null>;
+    /**
+     * Purge attachments by their IDs.
+     * Archives and deletes local files for the specified attachment IDs.
+     * Useful for edge cases where external code needs to force-remove attachments.
+     *
+     * @param ids - Array of attachment IDs to purge
+     */
+    purgeAttachments(ids: string[]): Promise<void>;
+    onProgress(callback: (stats: AttachmentSyncStats) => void): () => void;
+    getStats(): Promise<AttachmentSyncStats>;
+    /**
+     * Repair attachment sizes for synced records that have size=0.
+     * This backfills sizes from the actual file system for existing downloads.
+     * @returns Number of records repaired
+     */
+    repairAttachmentSizes(): Promise<number>;
+    private _getDownloadManagerDeps;
+    private _getUploadManagerDeps;
+    private _getCacheManagerDeps;
+    private _startUploadProcessing;
+    private _createTableIfNotExists;
+    private _migrateUploadColumns;
+    private _invalidateStatsCache;
+    private _getStatus;
+    private _notify;
+}
+/**
+ * Factory function options that combine AttachmentConfig with required runtime dependencies.
+ */
+interface CreateAttachmentQueueOptions extends AttachmentConfig {
+    /** Remote storage adapter for downloading/uploading files */
+    remoteStorage: AttachmentStorageAdapter;
+    /**
+     * Supabase client for passing to watchPaths callback.
+     * Required when using watchPaths (new API).
+     */
+    supabaseClient?: unknown;
+    /** Upload handler for processing uploads */
+    uploadHandler?: UploadHandler;
+    /** Upload configuration */
+    uploadConfig?: Partial<UploadConfig>;
+    /** Download configuration (concurrency, timeout) */
+    downloadConfig?: Partial<DownloadConfig>;
+    /** Compression configuration */
+    compression?: Partial<CompressionConfig>;
+    /** Cache configuration */
+    cache?: Partial<CacheConfig>;
+}
+declare function createPolAttachmentQueue(powersync: AbstractPowerSyncDatabase, platform: PlatformAdapter, config: CreateAttachmentQueueOptions): PolAttachmentQueue;
+
+export { PolAttachmentQueue as P, type PolAttachmentQueueOptions as a, createPolAttachmentQueue as c };

package/dist/provider/index.d.ts

@@ -1,17 +1,19 @@
 import { SupabaseClient } from '@supabase/supabase-js';
 import { QueryClient } from '@tanstack/react-query';
-import { A as AbstractPowerSyncDatabase, a as SyncStatus, C as CrudEntry, S as SyncMode, F as FailedTransaction, h as CompletedTransaction, b as ConnectionHealth, e as SyncMetrics, D as DownloadProgress, E as EntitySyncState, f as SyncError, U as UploadBlockReason } from '../types-Dv1uf0LZ.js';
+import { A as AbstractPowerSyncDatabase, a as SyncStatus, C as CrudEntry, S as SyncMode, F as FailedTransaction, h as CompletedTransaction, b as ConnectionHealth, e as SyncMetrics, D as DownloadProgress, E as EntitySyncState, f as SyncError, U as UploadBlockReason } from '../types-B9MptP7E.js';
 import { PlatformAdapter } from '../platform/index.js';
-import { a as ConnectorConfig, i as ConflictBus } from '../types-CpM2_LhU.js';
-import { f as AttachmentConfig, P as PolAttachmentQueue, A as AttachmentSourceConfig, F as AttachmentRecord, C as CompressionConfig, j as DownloadConfig } from '../pol-attachment-queue-BE2HU3Us.js';
-import { S as SupabaseConnector } from '../supabase-connector-C4YpH_l3.js';
+import { a as ConnectorConfig, i as ConflictBus, h as UploadErrorMiddleware } from '../types-DqJnP50o.js';
+import { d as AttachmentConfig, c as AttachmentSourceConfig, z as AttachmentRecord, f as CompressionConfig, i as DownloadConfig } from '../types-JCEhw2Lf.js';
+import { P as PolAttachmentQueue } from '../pol-attachment-queue-DqBvLAEY.js';
+import { S as SupabaseConnector } from '../supabase-connector-HMxBA9Kg.js';
 import * as react from 'react';
 import react__default, { ReactNode } from 'react';
 import { Schema } from '@powersync/react-native';
-import { a as StorageBackend } from '../types-D0WcHrq6.js';
-import { h as BackgroundSyncSystem, c as SyncControlActions } from '../background-sync-CVR3PkFi.js';
-import '@powersync/attachments';
+import { a as StorageBackend } from '../types-CGMibJKD.js';
+import { h as BackgroundSyncSystem, c as SyncControlActions } from '../background-sync-BujnI3IR.js';
+import { a as ProcessedPolConfig } from '../types-BhAEsJj-.js';
 import '@powersync/common';
+import '@powersync/attachments';
 
 /**
  * Provider Types for @pol-studios/powersync
@@ -79,8 +81,12 @@ interface PowerSyncConfig<TSchema = unknown> {
      * @example
      * ```typescript
      * attachments: {
-     *   source: { table: 'photos', idColumn: 'storage_path' },
-     *   remoteStorage: supabaseStorageAdapter,
+     *   source: { type: 'supabase-bucket', bucket: 'photos' },
+     *   watchPaths: (db, supabase, onUpdate) => {
+     *     db.watch('SELECT storage_path FROM photos', [], {
+     *       onResult: (r) => onUpdate(r.rows._array.map(x => x.storage_path)),
+     *     });
+     *   },
      * }
      * ```
      */
@@ -116,6 +122,26 @@ interface SyncConfig {
      */
     enableMetrics?: boolean;
 }
+/**
+ * Options for resetSync operation.
+ */
+interface ResetSyncOptions {
+    /**
+     * Clear downloaded attachments (photos, documents).
+     * @default true
+     */
+    clearAttachments?: boolean;
+    /**
+     * Clear React Query cache.
+     * @default true
+     */
+    clearQueryCache?: boolean;
+    /**
+     * Timeout for cache operations in milliseconds.
+     * @default 30000
+     */
+    timeout?: number;
+}
 /**
  * Value provided by the main PowerSyncContext.
  *
@@ -173,6 +199,23 @@ interface PowerSyncContextValue<TSchema = unknown> {
      * Use this to wire up conflict UI components.
      */
     conflictBus: ConflictBus;
+    /**
+     * Reset sync data by disconnecting and clearing synced data.
+     * Optionally clears React Query cache and attachment cache.
+     *
+     * @param options - Reset options
+     * @example
+     * ```typescript
+     * const { resetSync } = usePowerSync();
+     *
+     * await resetSync({
+     *   clearAttachments: true,  // Clear downloaded photos/documents
+     *   clearQueryCache: true,   // Clear React Query cache
+     *   timeout: 30000,          // Timeout for cache operations
+     * });
+     * ```
+     */
+    resetSync: (options?: ResetSyncOptions) => Promise<void>;
 }
 /**
  * Value provided by SyncStatusContext.
@@ -722,7 +765,26 @@ interface PowerSyncSyncStatusSnapshot {
 }
 /**
  * Attachment configuration for OfflineDataProvider.
- * Uses the new 2-callback API (watchIds, skipDownload).
+ *
+ * @example
+ * ```typescript
+ * attachments: {
+ *   source: { type: 'supabase-bucket', bucket: 'photos', signed: true },
+ *   watchPaths: (db, supabase, onUpdate) => {
+ *     const abort = new AbortController();
+ *     db.watch(
+ *       // Filter directly in the query - only emit paths you want to download
+ *       `SELECT storagePath FROM photos
+ *        WHERE storagePath IS NOT NULL
+ *        AND storagePath NOT LIKE '%.mp4'`,
+ *       [],
+ *       { onResult: (r) => onUpdate(r.rows._array.map(x => x.storagePath)) },
+ *       { signal: abort.signal }
+ *     );
+ *     return () => abort.abort();
+ *   },
+ * }
+ * ```
  */
 interface OfflineDataAttachmentConfig extends AttachmentSourceConfig {
     /** Optional: callback when upload completes */
@@ -768,6 +830,8 @@ interface OfflineDataProviderConfig {
         conflictDetection?: {
             enabled: boolean;
         };
+        /** Upload error middleware chain for classifying and handling upload errors */
+        uploadErrorMiddleware?: UploadErrorMiddleware[];
     };
     /** Sync behavior configuration */
     sync?: {
@@ -783,8 +847,45 @@ interface OfflineDataProviderConfig {
  * Props for OfflineDataProvider
  */
 interface OfflineDataProviderProps {
-    /** Provider configuration */
-    config: OfflineDataProviderConfig;
+    /**
+     * Provider configuration (legacy).
+     * Use either `config` OR `polConfig`, not both.
+     */
+    config?: OfflineDataProviderConfig;
+    /**
+     * Unified configuration from `definePolConfig`.
+     * This is the recommended way to configure OfflineDataProvider.
+     *
+     * When using polConfig, you must also provide:
+     * - `supabaseClient`
+     * - `queryClient`
+     *
+     * @example
+     * ```tsx
+     * import { definePolConfig } from '@pol-studios/powersync/config';
+     *
+     * const polConfig = definePolConfig({ ... });
+     *
+     * <OfflineDataProvider
+     *   polConfig={polConfig}
+     *   supabaseClient={supabase}
+     *   queryClient={queryClient}
+     * >
+     *   <App />
+     * </OfflineDataProvider>
+     * ```
+     */
+    polConfig?: ProcessedPolConfig;
+    /**
+     * Supabase client instance.
+     * Required when using `polConfig`.
+     */
+    supabaseClient?: SupabaseClient;
+    /**
+     * React Query client.
+     * Required when using `polConfig`.
+     */
+    queryClient?: QueryClient;
     children: ReactNode;
     /**
      * DataLayer configuration for @pol-studios/db integration.
@@ -803,6 +904,37 @@ interface OfflineDataProviderProps {
     skipStorageQueueProvider?: boolean;
     /** Custom storage backend (overrides built-in Supabase adapter) */
     storageBackend?: StorageBackend;
+    /**
+     * Custom platform adapter (optional).
+     * Use this to provide custom logging or filesystem implementations.
+     * If not provided, a default native platform adapter is created.
+     */
+    platform?: PlatformAdapter;
+    /**
+     * Attachment callback overrides at React level.
+     * These override the callbacks defined in polConfig.attachments,
+     * allowing you to use React hooks or access component context.
+     *
+     * @example
+     * ```tsx
+     * const watchPaths = useCallback((db, supabase, onUpdate) => {
+     *   db.watch(
+     *     `SELECT storagePath FROM photos
+     *      WHERE storagePath IS NOT NULL
+     *      AND mediaType NOT LIKE 'video/%'`,
+     *     [],
+     *     { onResult: (r) => onUpdate(r.rows._array.map(x => x.storagePath)) }
+     *   );
+     *   return () => {};
+     * }, []);
+     *
+     * <OfflineDataProvider
+     *   polConfig={polConfig}
+     *   attachments={{ watchPaths }}
+     * >
+     * ```
+     */
+    attachments?: Partial<Pick<OfflineDataAttachmentConfig, 'watchPaths'>>;
     /** Custom error UI for initialization errors */
     renderInitError?: (error: Error, retry: () => void) => ReactNode;
     /** Custom error UI (alias for renderInitError) */
@@ -839,94 +971,6 @@ interface ProviderBridgeProps {
     onRemovePendingMutationReady: (remove: (id: string) => void) => void;
 }
 
-/**
- * OfflineDataProvider Component for @pol-studios/powersync
- *
- * Batteries-included offline data provider that combines:
- * - PowerSyncProvider for offline-first data sync
- * - DataLayerProvider integration from @pol-studios/db
- * - ConflictProvider for conflict resolution UI
- * - StorageQueueProvider for attachment queue access
- * - Background sync system setup
- * - Error recovery UI with retry capability
- * - Online-only mode fallback (no PowerSync URL)
- *
- * @example
- * ```tsx
- * <OfflineDataProvider
- *   config={{
- *     schema: AppSchema,
- *     supabaseClient: supabase,
- *     queryClient: queryClient,
- *     powerSyncUrl: env.powerSyncUrl,
- *     attachments: {
- *       bucket: 'my-bucket',
- *       watchIds: (db, onUpdate) => {
- *         db.watch('SELECT storagePath as id FROM photos', [], {
- *           onResult: (r) => onUpdate(r.rows._array.map(x => x.id)),
- *         });
- *       },
- *       skipDownload: async ({ ids }) => {
- *         // Return IDs to skip downloading (e.g., videos)
- *         return ids.filter(id => id.endsWith('.mp4'));
- *       },
- *     },
- *   }}
- *   dataLayer={{ config: dataLayerConfig }}
- *   renderInitError={(error, retry) => <MyErrorUI error={error} onRetry={retry} />}
- * >
- *   <App />
- * </OfflineDataProvider>
- * ```
- */
-
-/**
- * Batteries-included offline data provider.
- *
- * Combines PowerSyncProvider with error boundary, DataLayerProvider integration,
- * and sensible defaults for a complete offline-first data solution.
- *
- * Key features:
- * - Automatic PowerSync setup and initialization
- * - Integration with @pol-studios/db DataLayerProvider
- * - ConflictProvider and StorageQueueProvider wiring
- * - Background sync system support
- * - Error recovery UI with retry capability
- * - Online-only mode fallback when no PowerSync URL is provided
- *
- * @example
- * ```tsx
- * // Basic usage
- * <OfflineDataProvider
- *   config={{
- *     schema: AppSchema,
- *     supabaseClient: supabase,
- *     queryClient: queryClient,
- *     powerSyncUrl: process.env.EXPO_PUBLIC_POWERSYNC_URL,
- *   }}
- * >
- *   <App />
- * </OfflineDataProvider>
- *
- * // With DataLayer integration
- * <OfflineDataProvider
- *   config={{ ... }}
- *   dataLayer={{ config: dataLayerConfig }}
- * >
- *   <App />
- * </OfflineDataProvider>
- *
- * // With custom error UI
- * <OfflineDataProvider
- *   config={{ ... }}
- *   renderInitError={(error, retry) => <MyErrorUI error={error} onRetry={retry} />}
- * >
- *   <App />
- * </OfflineDataProvider>
- * ```
- */
-declare function OfflineDataProvider({ config, children, dataLayer, backgroundSync, skipConflictProvider, skipStorageQueueProvider, storageBackend, renderInitError, renderError, onReady, onError, onSyncStatusChange, onBackgroundSyncSystemReady: onBackgroundSyncSystemReadyProp, }: OfflineDataProviderProps): react__default.ReactElement;
-
 /**
  * ProviderBridge Component for @pol-studios/powersync
  *
@@ -1684,21 +1728,12 @@ interface RetryCountdownResult {
 }
 /**
  * Hook for retry countdown display.
- * Returns the soonest nextRetryAt from all failed transactions.
- * Re-renders every second when countdown is active.
  *
- * @returns Retry countdown information
+ * @deprecated The nextRetryAt and backoffMs fields have been removed from FailedTransaction.
+ * PowerSync SDK now controls retry timing internally. This hook is retained for backward
+ * compatibility but will always return null values.
  *
- * @example
- * ```typescript
- * function RetryTimer() {
- *   const { nextRetryAt, formattedCountdown } = useRetryCountdown();
- *
- *   if (!nextRetryAt) return null;
- *
- *   return <Text>Retrying in {formattedCountdown}</Text>;
- * }
- * ```
+ * @returns Retry countdown information (always returns null values)
  */
 declare function useRetryCountdown(): RetryCountdownResult;
 
@@ -1720,4 +1755,4 @@ declare const UPLOAD_MAX_RETRIES = 7;
  */
 declare const UPLOAD_BACKOFF_DELAYS: readonly [4, 8, 16, 32, 64, 128, 256];
 
-export { AttachmentQueueContext, type BackgroundSyncCallbacks, type BackgroundSyncConfig, type BackgroundSyncStatus, CompletedTransactionsContext, type CompletedTransactionsContextValue, ConnectionHealthContext, type ConnectionHealthContextValue, ConnectionStatusContext, type ConnectionStatusContextValue, DEFAULT_CONNECTION_HEALTH, DEFAULT_SYNC_CONFIG, DEFAULT_SYNC_METRICS, DEFAULT_SYNC_STATUS, type DataLayerConfig, type DataLayerIntegration, type EntitySyncStatusResult, FailedTransactionsContext, type FailedTransactionsContextValue, type OfflineDataAttachmentConfig, OfflineDataProvider, type OfflineDataProviderConfig, type OfflineDataProviderProps, PendingMutationsContext, type PendingMutationsContextValue, type PowerSyncConfig, PowerSyncContext, type PowerSyncContextValue, PowerSyncProvider, type PowerSyncProviderProps, type PowerSyncSyncStatusSnapshot, ProviderBridge, type ProviderBridgeProps, type RetryCountdownResult, SyncActivityContext, type SyncActivityContextValue, type SyncActivityResult, type SyncConfig, SyncMetricsContext, type SyncMetricsContextValue, SyncModeContext, type SyncModeContextValue, SyncStatusContext, type SyncStatusContextValue, UPLOAD_BACKOFF_DELAYS, UPLOAD_MAX_RETRIES, type UploadBlockedReasonResult, type UploadStatusResult, useAttachmentQueue, useAttachmentQueueReady, useCompletedTransactions, useCompletedTransactionsContext, useConnectionHealth, useConnectionStatus, useDatabase, useDownloadProgress, useEntitySyncStatus, useFailedTransactions, useFailedTransactionsContext, useIsSyncing, useOnlineStatus, usePendingMutations, usePendingMutationsContext, usePlatform, usePowerSync, useRetryCountdown, useSyncActivity, useSyncActivityContext, useSyncControl, useSyncMetrics, useSyncMode, useSyncModeContext, useSyncStatus, useUploadBlockedReason, useUploadRetry, useUploadStatus };
+export { AttachmentQueueContext, type BackgroundSyncCallbacks, type BackgroundSyncConfig, type BackgroundSyncStatus, CompletedTransactionsContext, type CompletedTransactionsContextValue, ConnectionHealthContext, type ConnectionHealthContextValue, ConnectionStatusContext, type ConnectionStatusContextValue, DEFAULT_CONNECTION_HEALTH, DEFAULT_SYNC_CONFIG, DEFAULT_SYNC_METRICS, DEFAULT_SYNC_STATUS, type DataLayerConfig, type DataLayerIntegration, type EntitySyncStatusResult, FailedTransactionsContext, type FailedTransactionsContextValue, type OfflineDataAttachmentConfig, type OfflineDataProviderConfig, type OfflineDataProviderProps, PendingMutationsContext, type PendingMutationsContextValue, type PowerSyncConfig, PowerSyncContext, type PowerSyncContextValue, PowerSyncProvider, type PowerSyncProviderProps, type PowerSyncSyncStatusSnapshot, ProviderBridge, type ProviderBridgeProps, type ResetSyncOptions, type RetryCountdownResult, SyncActivityContext, type SyncActivityContextValue, type SyncActivityResult, type SyncConfig, SyncMetricsContext, type SyncMetricsContextValue, SyncModeContext, type SyncModeContextValue, SyncStatusContext, type SyncStatusContextValue, UPLOAD_BACKOFF_DELAYS, UPLOAD_MAX_RETRIES, type UploadBlockedReasonResult, type UploadStatusResult, useAttachmentQueue, useAttachmentQueueReady, useCompletedTransactions, useCompletedTransactionsContext, useConnectionHealth, useConnectionStatus, useDatabase, useDownloadProgress, useEntitySyncStatus, useFailedTransactions, useFailedTransactionsContext, useIsSyncing, useOnlineStatus, usePendingMutations, usePendingMutationsContext, usePlatform, usePowerSync, useRetryCountdown, useSyncActivity, useSyncActivityContext, useSyncControl, useSyncMetrics, useSyncMode, useSyncModeContext, useSyncStatus, useUploadBlockedReason, useUploadRetry, useUploadStatus };

package/dist/provider/index.js

@@ -1,20 +1,17 @@
 import {
-  OfflineDataProvider,
   PowerSyncProvider,
   ProviderBridge,
   UPLOAD_BACKOFF_DELAYS,
   UPLOAD_MAX_RETRIES
-} from "../chunk-JCGOZVWL.js";
-import "../chunk-YHTZ7VMV.js";
-import "../chunk-P6WOZO7H.js";
-import "../chunk-CACKC6XG.js";
-import "../chunk-RE5HWLCB.js";
+} from "../chunk-P4D6BQ4X.js";
+import "../chunk-PGEDE6IM.js";
 import {
   DEFAULT_CONNECTION_HEALTH,
   DEFAULT_SYNC_CONFIG,
   DEFAULT_SYNC_METRICS,
   DEFAULT_SYNC_STATUS
-} from "../chunk-FNYQFILT.js";
+} from "../chunk-2RDWLXJW.js";
+import "../chunk-OGUFUZSY.js";
 import {
   AttachmentQueueContext,
   CompletedTransactionsContext,
@@ -55,15 +52,14 @@ import {
   useUploadBlockedReason,
   useUploadRetry,
   useUploadStatus
-} from "../chunk-C2ACBYBZ.js";
-import "../chunk-CAB26E6F.js";
-import "../chunk-XAEII4ZX.js";
-import "../chunk-Z6VOBGTU.js";
+} from "../chunk-74TBHWJ4.js";
+import "../chunk-NUGQOTEM.js";
+import "../chunk-UOMHWUHV.js";
 import "../chunk-FV2HXEIY.js";
 import "../chunk-CGL33PL4.js";
-import "../chunk-WN5ZJ3E2.js";
-import "../chunk-BC2SRII2.js";
+import "../chunk-65A3SYJZ.js";
 import "../chunk-I2AYMY5O.js";
+import "../chunk-5WRI5ZAA.js";
 export {
   AttachmentQueueContext,
   CompletedTransactionsContext,
@@ -74,7 +70,6 @@ export {
   DEFAULT_SYNC_METRICS,
   DEFAULT_SYNC_STATUS,
   FailedTransactionsContext,
-  OfflineDataProvider,
   PendingMutationsContext,
   PowerSyncContext,
   PowerSyncProvider,