@pol-studios/powersync 1.0.25 → 1.0.32

package/dist/{chunk-VB737IVN.js → chunk-P4D6BQ4X.js}

@@ -1,19 +1,18 @@
 import {
-  PowerSyncErrorBoundary
-} from "./chunk-P6WOZO7H.js";
-import {
-  createPolAttachmentQueue
-} from "./chunk-CACKC6XG.js";
+  createPolAttachmentQueue,
+  getCustomUrlResolver,
+  isCustomSource,
+  isSignedUrlSource,
+  resolveBucketFromConfig
+} from "./chunk-PGEDE6IM.js";
 import {
+  DEFAULT_CONNECTION_HEALTH,
+  DEFAULT_SYNC_METRICS,
+  DEFAULT_SYNC_STATUS,
   HealthMonitor,
   MetricsCollector,
   SyncStatusTracker
-} from "./chunk-55DKCJV4.js";
-import {
-  DEFAULT_CONNECTION_HEALTH,
-  DEFAULT_SYNC_METRICS,
-  DEFAULT_SYNC_STATUS
-} from "./chunk-24RDMMCL.js";
+} from "./chunk-2RDWLXJW.js";
 import {
   AttachmentQueueContext,
   CompletedTransactionsContext,
@@ -30,19 +29,13 @@ import {
   usePendingMutationsContext,
   usePowerSync,
   useSyncStatus
-} from "./chunk-YSTEESEG.js";
-import {
-  createSupabaseUploadHandler
-} from "./chunk-CAB26E6F.js";
+} from "./chunk-74TBHWJ4.js";
 import {
   SupabaseStorageAdapter
-} from "./chunk-XAEII4ZX.js";
-import {
-  createNativePlatformAdapter
-} from "./chunk-WN5ZJ3E2.js";
+} from "./chunk-NUGQOTEM.js";
 import {
   SupabaseConnector
-} from "./chunk-BGBQYQV3.js";
+} from "./chunk-65A3SYJZ.js";
 import {
   createSyncError,
   extractEntityIds,
@@ -120,6 +113,10 @@ var ConflictBus = class _ConflictBus {
   }
 };
 
+// src/provider/constants.ts
+var UPLOAD_MAX_RETRIES = 7;
+var UPLOAD_BACKOFF_DELAYS = [4, 8, 16, 32, 64, 128, 256];
+
 // src/provider/PowerSyncProvider.tsx
 import { jsx } from "react/jsx-runtime";
 function PowerSyncProvider({
@@ -134,6 +131,7 @@ function PowerSyncProvider({
     schema,
     powerSyncUrl,
     supabaseClient,
+    queryClient,
     dbFilename = "powersync.db",
     connector: connectorConfig,
     attachments: attachmentConfig,
@@ -170,6 +168,13 @@ function PowerSyncProvider({
   const [failedTransactions, setFailedTransactions] = useState([]);
   const [completedTransactions, setCompletedTransactions] = useState([]);
   const [newCompletedTransactions, setNewCompletedTransactions] = useState([]);
+  const [uploadRetryState, setUploadRetryState] = useState({
+    retryCount: 0,
+    nextRetryAt: null,
+    isWaitingForRetry: false,
+    maxRetriesReached: false
+  });
+  const failureHandledThisCycleRef = useRef(false);
   const [connectionHealth, setConnectionHealth] = useState(DEFAULT_CONNECTION_HEALTH);
   const [syncMetrics, setSyncMetrics] = useState(DEFAULT_SYNC_METRICS);
   const [isAutoOffline, setIsAutoOffline] = useState(false);
@@ -192,6 +197,9 @@ function PowerSyncProvider({
   const syncModeRef = useRef("push-pull");
   const removePendingMutationRef = useRef(() => {
   });
+  const removePendingMutationsRef = useRef(() => {
+  });
+  const uploadRetryTimeoutRef = useRef(null);
   const onSyncStatusChangeRef = useRef(onSyncStatusChange);
   const onReadyRef = useRef(onReady);
   const onErrorRef = useRef(onError);
@@ -313,6 +321,13 @@ function PowerSyncProvider({
         setIsReady(true);
         setIsInitializing(false);
         healthMonitorRef.current?.setDatabase(database);
+        if (statusTrackerRef.current) {
+          statusTrackerRef.current.setDatabaseAndInit(database).then(() => {
+            setCompletedTransactions(statusTrackerRef.current?.getCompletedTransactions() ?? []);
+            setNewCompletedTransactions(statusTrackerRef.current?.getNewCompletedTransactions() ?? []);
+            setFailedTransactions(statusTrackerRef.current?.getFailedTransactions() ?? []);
+          });
+        }
         if (mergedSyncConfig.enableHealthMonitoring) {
           healthMonitorRef.current?.start();
         }
@@ -387,6 +402,7 @@ function PowerSyncProvider({
           schemaRouter: connectorConfig?.schemaRouter,
           crudHandler: connectorConfig?.crudHandler,
           retryConfig: connectorConfig?.retryConfig,
+          uploadErrorMiddleware: connectorConfig?.uploadErrorMiddleware,
           logger,
           // Conflict detection - enabled by default
           conflictDetection: {
@@ -395,21 +411,84 @@ function PowerSyncProvider({
           conflictBus,
           // Check if uploads should be performed based on sync mode
           shouldUpload: () => statusTrackerRef.current?.shouldUpload() ?? true,
-          // Clear failures when transaction succeeds
+          // Clear failures when transaction succeeds (auto-clear on success)
           onTransactionSuccess: (entries) => {
             if (!statusTracker_0) return;
-            const entityIds = extractEntityIds(entries);
-            entityIds.forEach((id) => {
-              const failures = statusTracker_0.getFailuresForEntity(id);
-              failures.forEach((f) => statusTracker_0.clearFailure(f.id));
-            });
+            const entryIds = entries.map((e) => e.id);
+            statusTracker_0.clearSuccessfulEntries(entryIds);
             setFailedTransactions(statusTracker_0.getFailedTransactions());
+            failureHandledThisCycleRef.current = false;
+            if (uploadRetryTimeoutRef.current) {
+              clearTimeout(uploadRetryTimeoutRef.current);
+              uploadRetryTimeoutRef.current = null;
+            }
+            setUploadRetryState({
+              retryCount: 0,
+              nextRetryAt: null,
+              isWaitingForRetry: false,
+              maxRetriesReached: false
+            });
           },
-          // Record failures when transaction fails
+          // Record failures when transaction fails with disconnect-based exponential backoff
           onTransactionFailure: (entries_0, error_0, classified) => {
             if (!statusTracker_0) return;
             statusTracker_0.recordTransactionFailure(entries_0, createSyncError(classified, error_0.message), classified.isPermanent, extractEntityIds(entries_0), extractTableNames(entries_0));
             setFailedTransactions(statusTracker_0.getFailedTransactions());
+            if (failureHandledThisCycleRef.current) {
+              logger.debug("[PowerSyncProvider] Failure already handled this cycle, skipping backoff");
+              return;
+            }
+            failureHandledThisCycleRef.current = true;
+            const BACKOFF_DELAYS = UPLOAD_BACKOFF_DELAYS;
+            const MAX_RETRIES = UPLOAD_MAX_RETRIES;
+            if (uploadRetryTimeoutRef.current) {
+              clearTimeout(uploadRetryTimeoutRef.current);
+              uploadRetryTimeoutRef.current = null;
+            }
+            setUploadRetryState((prev) => {
+              const newRetryCount = prev.retryCount + 1;
+              if (newRetryCount > MAX_RETRIES) {
+                logger.warn(`[PowerSyncProvider] Max upload retries (${MAX_RETRIES}) reached, staying disconnected`);
+                return {
+                  retryCount: newRetryCount,
+                  nextRetryAt: null,
+                  isWaitingForRetry: false,
+                  maxRetriesReached: true
+                };
+              }
+              const delaySeconds = BACKOFF_DELAYS[Math.min(newRetryCount - 1, BACKOFF_DELAYS.length - 1)];
+              const delayMs = delaySeconds * 1e3;
+              const nextRetryAt = new Date(Date.now() + delayMs);
+              logger.info(`[PowerSyncProvider] Upload failed (attempt ${newRetryCount}/${MAX_RETRIES}), disconnecting and retrying in ${delaySeconds}s`);
+              db.disconnect().catch((err_1) => {
+                logger.warn("[PowerSyncProvider] Error during backoff disconnect:", err_1);
+              });
+              uploadRetryTimeoutRef.current = setTimeout(async () => {
+                uploadRetryTimeoutRef.current = null;
+                failureHandledThisCycleRef.current = false;
+                logger.info(`[PowerSyncProvider] Backoff complete, reconnecting for retry attempt ${newRetryCount}`);
+                setUploadRetryState((curr) => ({
+                  ...curr,
+                  isWaitingForRetry: false,
+                  nextRetryAt: null
+                }));
+                const currentConnector = connectorRef.current;
+                if (currentConnector && db && !dbClosedRef.current) {
+                  try {
+                    await db.connect(currentConnector);
+                    logger.info("[PowerSyncProvider] Reconnected after backoff");
+                  } catch (reconnectErr) {
+                    logger.error("[PowerSyncProvider] Failed to reconnect after backoff:", reconnectErr);
+                  }
+                }
+              }, delayMs);
+              return {
+                retryCount: newRetryCount,
+                nextRetryAt,
+                isWaitingForRetry: true,
+                maxRetriesReached: false
+              };
+            });
           },
           // Record completed transactions
           onTransactionComplete: (entries_1) => {
@@ -417,6 +496,7 @@ function PowerSyncProvider({
             statusTracker_0.recordTransactionComplete(entries_1);
             setCompletedTransactions(statusTracker_0.getCompletedTransactions());
             setNewCompletedTransactions(statusTracker_0.getNewCompletedTransactions());
+            removePendingMutationsRef.current(entries_1.map((e_0) => e_0.id));
           }
         });
         if (abortController.signal.aborted) {
@@ -537,7 +617,7 @@ function PowerSyncProvider({
         } catch {
           return null;
         }
-      }).filter((e) => e !== null);
+      }).filter((e_1) => e_1 !== null);
       if (!dbClosedRef.current) {
         statusTrackerRef.current?.updatePendingMutations(mutations);
         setPendingMutations(mutations);
@@ -550,22 +630,32 @@ function PowerSyncProvider({
       ...entry,
       createdAt: entry.createdAt ?? /* @__PURE__ */ new Date()
     };
-    setPendingMutations((prev) => {
-      const newMutations = [...prev, entryWithTimestamp];
+    setPendingMutations((prev_0) => {
+      const newMutations = [...prev_0, entryWithTimestamp];
       statusTrackerRef.current?.updatePendingMutations(newMutations);
       return newMutations;
     });
   }, []);
-  const removePendingMutation = useCallback((id_0) => {
-    setPendingMutations((prev_0) => {
-      const newMutations_0 = prev_0.filter((m) => m.id !== id_0);
+  const removePendingMutation = useCallback((id) => {
+    setPendingMutations((prev_1) => {
+      const newMutations_0 = prev_1.filter((m) => m.id !== id);
       statusTrackerRef.current?.updatePendingMutations(newMutations_0);
       return newMutations_0;
     });
   }, []);
+  const removePendingMutations = useCallback((ids) => {
+    if (ids.length === 0) return;
+    const idSet = new Set(ids);
+    setPendingMutations((prev_2) => {
+      const newMutations_1 = prev_2.filter((m_0) => !idSet.has(m_0.id));
+      statusTrackerRef.current?.updatePendingMutations(newMutations_1);
+      return newMutations_1;
+    });
+  }, []);
   useEffect(() => {
     removePendingMutationRef.current = removePendingMutation;
-  }, [removePendingMutation]);
+    removePendingMutationsRef.current = removePendingMutations;
+  }, [removePendingMutation, removePendingMutations]);
   useEffect(() => {
     if (!db) return;
     dbClosedRef.current = false;
@@ -581,19 +671,36 @@ function PowerSyncProvider({
     const initAttachmentQueue = async () => {
       try {
         logger.info("[PowerSyncProvider] Initializing attachment queue...");
+        const bucket = resolveBucketFromConfig(attachmentConfig);
+        if (!bucket && !isCustomSource(attachmentConfig)) {
+          throw new Error("[PowerSyncProvider] Attachment config requires source.bucket or a custom source");
+        }
+        if (isCustomSource(attachmentConfig)) {
+          const resolver = getCustomUrlResolver(attachmentConfig);
+          if (!resolver) {
+            throw new Error('[PowerSyncProvider] Custom attachment source requires a getUrl function. Provide: source: { type: "custom", getUrl: (path) => "https://..." }');
+          }
+        }
+        const useSignedUrls = isSignedUrlSource(attachmentConfig);
+        const customUrlResolver = getCustomUrlResolver(attachmentConfig);
+        const sourceCompression = attachmentConfig.source?.type === "supabase-bucket" ? attachmentConfig.source.compression : void 0;
         const remoteStorage = new SupabaseStorageAdapter({
           client: supabaseClient,
-          defaultBucket: attachmentConfig.bucket,
+          defaultBucket: bucket ?? "",
           logger,
-          imageTransform: attachmentConfig.compression ? {
-            enabled: attachmentConfig.compression.enabled ?? true,
-            width: attachmentConfig.compression.maxWidth,
-            quality: attachmentConfig.compression.quality ? Math.round(attachmentConfig.compression.quality * 100) : void 0
+          useSignedUrls,
+          customUrlResolver,
+          imageTransform: sourceCompression ? {
+            enabled: sourceCompression.enabled ?? true,
+            width: sourceCompression.maxWidth,
+            quality: sourceCompression.quality ? Math.round(sourceCompression.quality * 100) : void 0
           } : void 0
         }, platform.fileSystem);
         const queueOptions = {
           ...attachmentConfig,
-          remoteStorage
+          remoteStorage,
+          supabaseClient
+          // Pass supabase client for watchPaths callback
         };
         const queue = createPolAttachmentQueue(db, platform, queueOptions);
         await queue.init();
@@ -605,9 +712,9 @@ function PowerSyncProvider({
         setAttachmentQueue(queue);
         setAttachmentQueueReady(true);
         logger.info("[PowerSyncProvider] Attachment queue initialized successfully");
-      } catch (err_1) {
+      } catch (err_2) {
         if (!controller_0.cancelled) {
-          logger.error("[PowerSyncProvider] Attachment queue initialization failed:", err_1);
+          logger.error("[PowerSyncProvider] Attachment queue initialization failed:", err_2);
           setAttachmentQueueReady(true);
         }
       }
@@ -635,16 +742,20 @@ function PowerSyncProvider({
       attachmentQueueRef.current?.dispose();
       healthMonitorRef.current?.stop();
       conflictBusRef.current?.destroy();
+      if (uploadRetryTimeoutRef.current) {
+        clearTimeout(uploadRetryTimeoutRef.current);
+        uploadRetryTimeoutRef.current = null;
+      }
       if (db) {
         cleanupPromiseRef.current = (async () => {
           try {
             await db.disconnect();
             await db.close();
             logger.debug("[PowerSyncProvider] Database cleanup completed");
-          } catch (err_2) {
-            const errorMessage = err_2 instanceof Error ? err_2.message : String(err_2);
+          } catch (err_3) {
+            const errorMessage = err_3 instanceof Error ? err_3.message : String(err_3);
             if (!errorMessage.includes("not open") && !errorMessage.includes("closed")) {
-              logger.warn("[PowerSyncProvider] Error during cleanup:", err_2);
+              logger.warn("[PowerSyncProvider] Error during cleanup:", err_3);
             }
           } finally {
             isCleaningUpRef.current = false;
@@ -701,8 +812,8 @@ function PowerSyncProvider({
               try {
                 await db.connect(connector);
                 logger.info("[PowerSyncProvider] Reconnected after network restore");
-              } catch (err_3) {
-                logger.warn("[PowerSyncProvider] Failed to reconnect after network restore:", err_3);
+              } catch (err_4) {
+                logger.warn("[PowerSyncProvider] Failed to reconnect after network restore:", err_4);
               }
             }
           }
@@ -733,8 +844,8 @@ function PowerSyncProvider({
           if (db && connector && !db.connected) {
             db.connect(connector).then(() => {
               logger.info("[PowerSyncProvider] Reconnected after auto-resume on startup");
-            }).catch((err_4) => {
-              logger.warn("[PowerSyncProvider] Failed to reconnect after auto-resume on startup:", err_4);
+            }).catch((err_5) => {
+              logger.warn("[PowerSyncProvider] Failed to reconnect after auto-resume on startup:", err_5);
             });
           }
         }
@@ -754,75 +865,66 @@ function PowerSyncProvider({
     tracker_3.clearFailure(failureId);
     setFailedTransactions(tracker_3.getFailedTransactions());
   }, [logger]);
-  const clearAllFailures = useCallback(() => {
+  const clearCompletedHistory = useCallback(() => {
     const tracker_4 = statusTrackerRef.current;
     if (!tracker_4) {
-      logger.warn("[PowerSyncProvider] Cannot clear failures - tracker not initialized");
+      logger.warn("[PowerSyncProvider] Cannot clear completed history - tracker not initialized");
       return;
     }
-    tracker_4.clearAllFailures();
-    setFailedTransactions(tracker_4.getFailedTransactions());
+    tracker_4.clearCompletedHistory();
+    setCompletedTransactions(tracker_4.getCompletedTransactions());
+    setNewCompletedTransactions(tracker_4.getNewCompletedTransactions());
   }, [logger]);
-  const clearCompletedHistory = useCallback(() => {
+  const clearCompletedItem = useCallback((completedId) => {
     const tracker_5 = statusTrackerRef.current;
     if (!tracker_5) {
-      logger.warn("[PowerSyncProvider] Cannot clear completed history - tracker not initialized");
+      logger.warn("[PowerSyncProvider] Cannot clear completed item - tracker not initialized");
       return;
     }
-    tracker_5.clearCompletedHistory();
+    tracker_5.clearCompletedItem(completedId);
     setCompletedTransactions(tracker_5.getCompletedTransactions());
     setNewCompletedTransactions(tracker_5.getNewCompletedTransactions());
   }, [logger]);
-  const clearCompletedItem = useCallback((completedId) => {
+  const markNotificationsAsSeen = useCallback(() => {
     const tracker_6 = statusTrackerRef.current;
     if (!tracker_6) {
-      logger.warn("[PowerSyncProvider] Cannot clear completed item - tracker not initialized");
+      logger.warn("[PowerSyncProvider] Cannot mark notifications as seen - tracker not initialized");
       return;
     }
-    tracker_6.clearCompletedItem(completedId);
-    setCompletedTransactions(tracker_6.getCompletedTransactions());
+    tracker_6.markNotificationsAsSeen();
     setNewCompletedTransactions(tracker_6.getNewCompletedTransactions());
   }, [logger]);
-  const markNotificationsAsSeen = useCallback(() => {
+  const setSyncMode = useCallback(async (mode) => {
     const tracker_7 = statusTrackerRef.current;
     if (!tracker_7) {
-      logger.warn("[PowerSyncProvider] Cannot mark notifications as seen - tracker not initialized");
-      return;
-    }
-    tracker_7.markNotificationsAsSeen();
-    setNewCompletedTransactions(tracker_7.getNewCompletedTransactions());
-  }, [logger]);
-  const setSyncMode = useCallback(async (mode) => {
-    const tracker_8 = statusTrackerRef.current;
-    if (!tracker_8) {
       logger.warn("[PowerSyncProvider] Cannot set sync mode - tracker not initialized");
       return;
     }
-    await tracker_8.setIsAutoOffline(false);
+    await tracker_7.setIsAutoOffline(false);
     setIsAutoOffline(false);
-    await tracker_8.setSyncMode(mode);
+    await tracker_7.setSyncMode(mode);
     setSyncModeState({
       loaded: true,
       mode
     });
   }, [logger]);
   const setForceNextUpload = useCallback((force) => {
-    const tracker_9 = statusTrackerRef.current;
-    if (!tracker_9) {
+    const tracker_8 = statusTrackerRef.current;
+    if (!tracker_8) {
       logger.warn("[PowerSyncProvider] Cannot set force upload - tracker not initialized");
       return;
     }
-    tracker_9.setForceNextUpload(force);
+    tracker_8.setForceNextUpload(force);
   }, [logger]);
   const setAutoOfflineMode = useCallback(async (mode_0, isAuto) => {
-    const tracker_10 = statusTrackerRef.current;
-    if (!tracker_10) {
+    const tracker_9 = statusTrackerRef.current;
+    if (!tracker_9) {
       logger.warn("[PowerSyncProvider] Cannot set sync mode - tracker not initialized");
       return;
     }
-    await tracker_10.setIsAutoOffline(isAuto);
+    await tracker_9.setIsAutoOffline(isAuto);
     setIsAutoOffline(isAuto);
-    await tracker_10.setSyncMode(mode_0);
+    await tracker_9.setSyncMode(mode_0);
     setSyncModeState({
       loaded: true,
       mode: mode_0
@@ -853,51 +955,81 @@ function PowerSyncProvider({
       }
     }
   }, [db, connector, syncStatus.uploading, logger]);
-  const discardAllPendingMutations = useCallback(async () => {
-    if (!db || !connector) {
-      logger.warn("[PowerSync] Cannot discard all - not initialized");
+  const manualUploadRetry = useCallback(async () => {
+    const currentConnector_0 = connectorRef.current;
+    if (!db || !currentConnector_0) {
+      logger.warn("[PowerSyncProvider] Cannot manual retry - not initialized");
       return;
     }
-    if (syncStatus.uploading) {
-      throw new Error("Cannot discard while upload is in progress");
+    if (uploadRetryTimeoutRef.current) {
+      clearTimeout(uploadRetryTimeoutRef.current);
+      uploadRetryTimeoutRef.current = null;
     }
-    logger.info("[PowerSync] Discarding all pending mutations");
-    await db.disconnect();
+    failureHandledThisCycleRef.current = false;
+    setUploadRetryState({
+      retryCount: 0,
+      nextRetryAt: null,
+      isWaitingForRetry: false,
+      maxRetriesReached: false
+    });
+    logger.info("[PowerSyncProvider] Manual upload retry triggered");
     try {
-      await db.execute("DELETE FROM ps_crud");
-      logger.info("[PowerSync] All mutations discarded successfully");
-    } finally {
-      const currentConnector = connectorRef.current;
-      if (currentConnector && db) {
-        try {
-          await db.connect(currentConnector);
-        } catch (reconnectError) {
-          logger.error("[PowerSync] Failed to reconnect after discard:", reconnectError);
-          throw reconnectError;
-        }
+      if (db.connected) {
+        await db.disconnect();
       }
+      await db.connect(currentConnector_0);
+      logger.info("[PowerSyncProvider] Reconnected after manual retry");
+    } catch (err_6) {
+      logger.error("[PowerSyncProvider] Manual retry failed:", err_6);
     }
-  }, [db, connector, syncStatus.uploading, logger]);
-  const pauseAutoRetry = useCallback(() => {
-    if (!connector) {
-      logger.warn("[PowerSyncProvider] Cannot pause auto-retry - connector not initialized");
+  }, [db, logger]);
+  const discardFailedEntryAndReconnect = useCallback(async (entryId) => {
+    const currentConnector_1 = connectorRef.current;
+    const tracker_10 = statusTrackerRef.current;
+    if (!db || !currentConnector_1) {
+      logger.warn("[PowerSyncProvider] Cannot discard failed entry - not initialized");
       return;
     }
-    connector.pauseAutoRetry();
-  }, [connector, logger]);
-  const resumeAutoRetry = useCallback(() => {
-    if (!connector) {
-      logger.warn("[PowerSyncProvider] Cannot resume auto-retry - connector not initialized");
-      return;
+    if (uploadRetryTimeoutRef.current) {
+      clearTimeout(uploadRetryTimeoutRef.current);
+      uploadRetryTimeoutRef.current = null;
+    }
+    logger.info("[PowerSyncProvider] Discarding entry", entryId, "and reconnecting");
+    await db.disconnect();
+    try {
+      await db.execute("DELETE FROM ps_crud WHERE id = ?", [entryId]);
+      logger.info("[PowerSyncProvider] Entry", entryId, "discarded");
+      if (tracker_10) {
+        const failures = tracker_10.getFailedTransactions();
+        for (const failure of failures) {
+          const hasEntry = failure.entries.some((e_2) => e_2.clientId === entryId);
+          if (hasEntry) {
+            tracker_10.clearFailure(failure.id);
+            break;
+          }
+        }
+        setFailedTransactions(tracker_10.getFailedTransactions());
+      }
+      failureHandledThisCycleRef.current = false;
+      setUploadRetryState({
+        retryCount: 0,
+        nextRetryAt: null,
+        isWaitingForRetry: false,
+        maxRetriesReached: false
+      });
+      await db.connect(currentConnector_1);
+      logger.info("[PowerSyncProvider] Reconnected after discarding entry", entryId);
+    } catch (err_7) {
+      logger.error("[PowerSyncProvider] Failed to discard entry and reconnect:", err_7);
+      throw err_7;
     }
-    connector.resumeAutoRetry();
-  }, [connector, logger]);
+  }, [db, logger]);
   const retryFailure = useCallback(async (failureId_0) => {
     const tracker_11 = statusTrackerRef.current;
     if (!tracker_11) return;
     const failures_0 = tracker_11.getFailedTransactions();
-    const failure = failures_0.find((f_0) => f_0.id === failureId_0);
-    if (!failure) {
+    const failure_0 = failures_0.find((f) => f.id === failureId_0);
+    if (!failure_0) {
       logger.warn("[PowerSyncProvider] Failure not found:", failureId_0);
       return;
     }
@@ -906,9 +1038,9 @@ function PowerSyncProvider({
     setFailedTransactions(tracker_11.getFailedTransactions());
     if (!db || !connector) {
       logger.warn("[PowerSyncProvider] Cannot retry - not initialized");
-      tracker_11.recordTransactionFailure(failure.entries, failure.error, failure.isPermanent, failure.affectedEntityIds, failure.affectedTables, {
-        retryCount: failure.retryCount,
-        firstFailedAt: failure.firstFailedAt
+      tracker_11.recordTransactionFailure(failure_0.entries, failure_0.error, failure_0.isPermanent, failure_0.affectedEntityIds, failure_0.affectedTables, {
+        retryCount: failure_0.retryCount,
+        firstFailedAt: failure_0.firstFailedAt
       });
       setFailedTransactions(tracker_11.getFailedTransactions());
       return;
@@ -919,15 +1051,64 @@ function PowerSyncProvider({
       }
       await db.connect(connector);
       logger.info("[PowerSyncProvider] Retry triggered for failure:", failureId_0);
-    } catch (err_5) {
-      logger.error("[PowerSyncProvider] Retry failed, re-recording failure:", err_5);
-      tracker_11.recordTransactionFailure(failure.entries, failure.error, failure.isPermanent, failure.affectedEntityIds, failure.affectedTables, {
-        retryCount: failure.retryCount,
-        firstFailedAt: failure.firstFailedAt
+    } catch (err_8) {
+      logger.error("[PowerSyncProvider] Retry failed, re-recording failure:", err_8);
+      tracker_11.recordTransactionFailure(failure_0.entries, failure_0.error, failure_0.isPermanent, failure_0.affectedEntityIds, failure_0.affectedTables, {
+        retryCount: failure_0.retryCount,
+        firstFailedAt: failure_0.firstFailedAt
       });
       setFailedTransactions(tracker_11.getFailedTransactions());
     }
   }, [db, connector, logger]);
+  const resetSync = useCallback(async (options) => {
+    const {
+      clearAttachments = true,
+      clearQueryCache = true,
+      timeout = 3e4
+    } = options ?? {};
+    logger.info("[PowerSyncProvider] Starting sync reset...", {
+      clearAttachments,
+      clearQueryCache,
+      timeout
+    });
+    if (!db) {
+      logger.warn("[PowerSyncProvider] Cannot reset sync: database not initialized");
+      return;
+    }
+    try {
+      logger.info("[PowerSyncProvider] Disconnecting and clearing sync data...");
+      await db.disconnectAndClear({
+        clearLocal: false
+      });
+      logger.info("[PowerSyncProvider] Sync data cleared");
+      if (clearQueryCache && queryClient) {
+        try {
+          logger.info("[PowerSyncProvider] Clearing React Query cache...");
+          queryClient.clear();
+          logger.info("[PowerSyncProvider] React Query cache cleared");
+        } catch (cacheError) {
+          logger.error("[PowerSyncProvider] Failed to clear React Query cache:", cacheError);
+        }
+      }
+      if (clearAttachments && attachmentQueue) {
+        try {
+          logger.info("[PowerSyncProvider] Clearing attachment cache...");
+          const clearPromise = attachmentQueue.clearCache();
+          const timeoutPromise_0 = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error("Attachment cache clear timed out")), timeout);
+          });
+          await Promise.race([clearPromise, timeoutPromise_0]);
+          logger.info("[PowerSyncProvider] Attachment cache cleared");
+        } catch (attachmentError) {
+          logger.error("[PowerSyncProvider] Failed to clear attachment cache:", attachmentError);
+        }
+      }
+      logger.info("[PowerSyncProvider] Sync reset completed successfully");
+    } catch (err_9) {
+      logger.error("[PowerSyncProvider] Sync reset failed:", err_9);
+      throw err_9;
+    }
+  }, [db, queryClient, attachmentQueue, logger]);
   const powerSyncContextValue = useMemo(() => ({
     db,
     connector,
@@ -938,8 +1119,9 @@ function PowerSyncProvider({
     error,
     schema,
     platform,
-    conflictBus
-  }), [db, connector, attachmentQueue, isReady, isInitializing, attachmentQueueReady, error, schema, platform, conflictBus]);
+    conflictBus,
+    resetSync
+  }), [db, connector, attachmentQueue, isReady, isInitializing, attachmentQueueReady, error, schema, platform, conflictBus, resetSync]);
   const syncStatusContextValue = useMemo(() => ({
     status: syncStatus,
     pendingMutations,
@@ -955,10 +1137,9 @@ function PowerSyncProvider({
     // Failed transaction fields
     failedTransactions,
     hasUploadErrors: failedTransactions.length > 0,
-    permanentErrorCount: failedTransactions.filter((f_1) => f_1.isPermanent).length,
+    permanentErrorCount: failedTransactions.filter((f_0) => f_0.isPermanent).length,
     // Clear failure functions
     clearFailure,
-    clearAllFailures,
     // Completed transaction fields
     completedTransactions,
     clearCompletedHistory,
@@ -967,11 +1148,14 @@ function PowerSyncProvider({
     setForceNextUpload,
     // Discard mutation functions
     discardPendingMutation,
-    discardAllPendingMutations,
-    // Retry control functions
-    pauseAutoRetry,
-    resumeAutoRetry
-  }), [syncStatus, pendingMutations, syncModeState.mode, lastSyncedAt, connectionError, failedTransactions, clearFailure, clearAllFailures, completedTransactions, clearCompletedHistory, setSyncMode, setForceNextUpload, discardPendingMutation, discardAllPendingMutations, pauseAutoRetry, resumeAutoRetry]);
+    // Upload retry state
+    isWaitingForUploadRetry: uploadRetryState.isWaitingForRetry,
+    nextUploadRetryAt: uploadRetryState.nextRetryAt,
+    maxUploadRetriesReached: uploadRetryState.maxRetriesReached,
+    uploadRetryCount: uploadRetryState.retryCount,
+    manualUploadRetry,
+    discardFailedEntryAndReconnect
+  }), [syncStatus, pendingMutations, syncModeState.mode, lastSyncedAt, connectionError, failedTransactions, clearFailure, completedTransactions, clearCompletedHistory, setSyncMode, setForceNextUpload, discardPendingMutation, uploadRetryState, manualUploadRetry, discardFailedEntryAndReconnect]);
   const connectionHealthContextValue = useMemo(() => ({
     health: connectionHealth
   }), [connectionHealth]);
@@ -994,20 +1178,16 @@ function PowerSyncProvider({
     pendingMutations,
     pendingCount: pendingMutations.length,
     discardPendingMutation,
-    discardAllPendingMutations,
     addPendingMutation,
     removePendingMutation
-  }), [pendingMutations, discardPendingMutation, discardAllPendingMutations, addPendingMutation, removePendingMutation]);
+  }), [pendingMutations, discardPendingMutation, addPendingMutation, removePendingMutation]);
   const failedTransactionsValue = useMemo(() => ({
     failedTransactions,
     hasUploadErrors: failedTransactions.length > 0,
-    permanentErrorCount: failedTransactions.filter((f_2) => f_2.isPermanent).length,
+    permanentErrorCount: failedTransactions.filter((f_1) => f_1.isPermanent).length,
     clearFailure,
-    clearAllFailures,
-    pauseAutoRetry,
-    resumeAutoRetry,
     retryFailure
-  }), [failedTransactions, clearFailure, clearAllFailures, pauseAutoRetry, resumeAutoRetry, retryFailure]);
+  }), [failedTransactions, clearFailure, retryFailure]);
   const completedTransactionsValue = useMemo(() => ({
     completedTransactions,
     clearCompletedHistory,
@@ -1021,17 +1201,18 @@ function PowerSyncProvider({
     isAutoOffline,
     networkReachable,
     setSyncMode,
-    setForceNextUpload
-  }), [syncModeState.mode, isAutoOffline, networkReachable, setSyncMode, setForceNextUpload]);
+    setForceNextUpload,
+    // Upload retry state
+    isWaitingForUploadRetry: uploadRetryState.isWaitingForRetry,
+    nextUploadRetryAt: uploadRetryState.nextRetryAt,
+    maxUploadRetriesReached: uploadRetryState.maxRetriesReached,
+    uploadRetryCount: uploadRetryState.retryCount,
+    manualUploadRetry,
+    discardFailedEntryAndReconnect
+  }), [syncModeState.mode, isAutoOffline, networkReachable, setSyncMode, setForceNextUpload, uploadRetryState, manualUploadRetry, discardFailedEntryAndReconnect]);
   return /* @__PURE__ */ jsx(PowerSyncContext.Provider, { value: powerSyncContextValue, children: /* @__PURE__ */ jsx(ConnectionStatusContext.Provider, { value: connectionStatusValue, children: /* @__PURE__ */ jsx(SyncActivityContext.Provider, { value: syncActivityValue, children: /* @__PURE__ */ jsx(PendingMutationsContext.Provider, { value: pendingMutationsValue, children: /* @__PURE__ */ jsx(FailedTransactionsContext.Provider, { value: failedTransactionsValue, children: /* @__PURE__ */ jsx(CompletedTransactionsContext.Provider, { value: completedTransactionsValue, children: /* @__PURE__ */ jsx(SyncModeContext.Provider, { value: syncModeValue, children: /* @__PURE__ */ jsx(SyncStatusContext.Provider, { value: syncStatusContextValue, children: /* @__PURE__ */ jsx(ConnectionHealthContext.Provider, { value: connectionHealthContextValue, children: /* @__PURE__ */ jsx(SyncMetricsContext.Provider, { value: syncMetricsContextValue, children: /* @__PURE__ */ jsx(AttachmentQueueContext.Provider, { value: attachmentQueue, children }) }) }) }) }) }) }) }) }) }) });
 }
 
-// src/provider/OfflineDataProvider.tsx
-import { c as _c } from "react/compiler-runtime";
-import { useEffect as useEffect3, useRef as useRef3, useState as useState2 } from "react";
-import { View, Text, StyleSheet, Pressable } from "react-native";
-import { DataLayerProvider } from "@pol-studios/db";
-
 // src/provider/ProviderBridge.tsx
 import { useEffect as useEffect2, useRef as useRef2 } from "react";
 import { PowerSyncContext as PowerSyncContext2 } from "@powersync/react-native";
@@ -1143,570 +1324,11 @@ function ProviderBridge({
   return /* @__PURE__ */ jsx2(Fragment, { children: content });
 }
 
-// src/provider/OfflineDataProvider.tsx
-import { Fragment as Fragment2, jsx as jsx3, jsxs } from "react/jsx-runtime";
-var defaultLogger = {
-  debug: (...args) => console.debug("[OfflineData]", ...args),
-  info: (...args) => console.info("[OfflineData]", ...args),
-  warn: (...args) => console.warn("[OfflineData]", ...args),
-  error: (...args) => console.error("[OfflineData]", ...args)
-};
-var errorStyles = StyleSheet.create({
-  container: {
-    flex: 1,
-    justifyContent: "center",
-    alignItems: "center",
-    backgroundColor: "#f5f5f5",
-    padding: 20
-  },
-  content: {
-    backgroundColor: "white",
-    borderRadius: 12,
-    padding: 24,
-    maxWidth: 400,
-    width: "100%",
-    shadowColor: "#000",
-    shadowOffset: {
-      width: 0,
-      height: 2
-    },
-    shadowOpacity: 0.1,
-    shadowRadius: 8,
-    elevation: 4
-  },
-  title: {
-    fontSize: 20,
-    fontWeight: "600",
-    color: "#1a1a1a",
-    marginBottom: 12,
-    textAlign: "center"
-  },
-  message: {
-    fontSize: 14,
-    color: "#666",
-    marginBottom: 16,
-    textAlign: "center",
-    lineHeight: 20
-  },
-  errorDetail: {
-    fontSize: 12,
-    color: "#999",
-    marginBottom: 20,
-    textAlign: "center",
-    fontFamily: "monospace"
-  },
-  retryButton: {
-    backgroundColor: "#007AFF",
-    borderRadius: 8,
-    paddingVertical: 12,
-    paddingHorizontal: 24,
-    alignItems: "center"
-  },
-  retryButtonText: {
-    color: "white",
-    fontSize: 16,
-    fontWeight: "600"
-  }
-});
-function DefaultErrorRecoveryUI(t0) {
-  const $ = _c(10);
-  const {
-    error,
-    onRetry
-  } = t0;
-  let t1;
-  let t2;
-  if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
-    t1 = /* @__PURE__ */ jsx3(Text, { style: errorStyles.title, children: "Database Error" });
-    t2 = /* @__PURE__ */ jsx3(Text, { style: errorStyles.message, children: "The local database encountered an error. This can happen if the app was interrupted during startup." });
-    $[0] = t1;
-    $[1] = t2;
-  } else {
-    t1 = $[0];
-    t2 = $[1];
-  }
-  let t3;
-  if ($[2] !== error.message) {
-    t3 = /* @__PURE__ */ jsx3(Text, { style: errorStyles.errorDetail, children: error.message });
-    $[2] = error.message;
-    $[3] = t3;
-  } else {
-    t3 = $[3];
-  }
-  let t4;
-  if ($[4] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
-    t4 = /* @__PURE__ */ jsx3(Text, { style: errorStyles.retryButtonText, children: "Retry" });
-    $[4] = t4;
-  } else {
-    t4 = $[4];
-  }
-  let t5;
-  if ($[5] !== onRetry) {
-    t5 = /* @__PURE__ */ jsx3(Pressable, { style: errorStyles.retryButton, onPress: onRetry, children: t4 });
-    $[5] = onRetry;
-    $[6] = t5;
-  } else {
-    t5 = $[6];
-  }
-  let t6;
-  if ($[7] !== t3 || $[8] !== t5) {
-    t6 = /* @__PURE__ */ jsx3(View, { style: errorStyles.container, children: /* @__PURE__ */ jsxs(View, { style: errorStyles.content, children: [
-      t1,
-      t2,
-      t3,
-      t5
-    ] }) });
-    $[7] = t3;
-    $[8] = t5;
-    $[9] = t6;
-  } else {
-    t6 = $[9];
-  }
-  return t6;
-}
-function OfflineDataProvider(t0) {
-  const $ = _c(103);
-  const {
-    config,
-    children,
-    dataLayer,
-    backgroundSync,
-    skipConflictProvider: t1,
-    skipStorageQueueProvider: t2,
-    storageBackend,
-    renderInitError,
-    renderError,
-    onReady,
-    onError,
-    onSyncStatusChange,
-    onBackgroundSyncSystemReady: onBackgroundSyncSystemReadyProp
-  } = t0;
-  const skipConflictProvider = t1 === void 0 ? false : t1;
-  const skipStorageQueueProvider = t2 === void 0 ? false : t2;
-  const {
-    schema,
-    supabaseClient,
-    queryClient,
-    powerSyncUrl,
-    dbFilename: t3,
-    attachments,
-    platform: customPlatform,
-    connector: connectorConfig,
-    sync: syncConfig
-  } = config;
-  const dbFilename = t3 === void 0 ? "powersync.db" : t3;
-  const [initError, setInitError] = useState2(null);
-  const [retryKey, setRetryKey] = useState2(0);
-  const [powerSyncInstance, setPowerSyncInstance] = useState2(null);
-  const [powerSyncSyncStatus, setPowerSyncSyncStatus] = useState2(void 0);
-  const addPendingMutationRef = useRef3(null);
-  const removePendingMutationRef = useRef3(null);
-  const backgroundSyncSystemRef = useRef3(null);
-  let t4;
-  if ($[0] !== customPlatform) {
-    t4 = customPlatform ?? createNativePlatformAdapter(defaultLogger);
-    $[0] = customPlatform;
-    $[1] = t4;
-  } else {
-    t4 = $[1];
-  }
-  const platform = t4;
-  let t10;
-  let t5;
-  let t6;
-  let t7;
-  let t8;
-  let t9;
-  if ($[2] !== platform.logger) {
-    t5 = async () => {
-      platform.logger.warn("Sync not available: Use useSyncControl from PowerSync context");
-    };
-    t6 = async () => {
-      platform.logger.warn("Live sync not available: Use useSyncControl from PowerSync context");
-    };
-    t7 = () => {
-      platform.logger.warn("Live sync not available: Use useSyncControl from PowerSync context");
-    };
-    t8 = async () => {
-      platform.logger.warn("Scope control not available: Use useSyncControl from PowerSync context");
-    };
-    t9 = async () => {
-      platform.logger.warn("Retry not available: Use useSyncControl from PowerSync context");
-    };
-    t10 = () => {
-      platform.logger.warn("Clear failed uploads not available: Use useSyncControl from PowerSync context");
-    };
-    $[2] = platform.logger;
-    $[3] = t10;
-    $[4] = t5;
-    $[5] = t6;
-    $[6] = t7;
-    $[7] = t8;
-    $[8] = t9;
-  } else {
-    t10 = $[3];
-    t5 = $[4];
-    t6 = $[5];
-    t7 = $[6];
-    t8 = $[7];
-    t9 = $[8];
-  }
-  let t11;
-  if ($[9] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
-    t11 = [];
-    $[9] = t11;
-  } else {
-    t11 = $[9];
-  }
-  let t12;
-  let t13;
-  if ($[10] !== platform.logger) {
-    t12 = () => {
-      platform.logger.warn("Pause auto-retry not available: Use useSyncControl from PowerSync context");
-    };
-    t13 = () => {
-      platform.logger.warn("Resume auto-retry not available: Use useSyncControl from PowerSync context");
-    };
-    $[10] = platform.logger;
-    $[11] = t12;
-    $[12] = t13;
-  } else {
-    t12 = $[11];
-    t13 = $[12];
-  }
-  let t14;
-  let t15;
-  if ($[13] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
-    t14 = (entry) => {
-      if (addPendingMutationRef.current) {
-        addPendingMutationRef.current(entry);
-      }
-    };
-    t15 = (id) => {
-      if (removePendingMutationRef.current) {
-        removePendingMutationRef.current(id);
-      }
-    };
-    $[13] = t14;
-    $[14] = t15;
-  } else {
-    t14 = $[13];
-    t15 = $[14];
-  }
-  let t16;
-  if ($[15] !== t10 || $[16] !== t12 || $[17] !== t13 || $[18] !== t5 || $[19] !== t6 || $[20] !== t7 || $[21] !== t8 || $[22] !== t9) {
-    t16 = {
-      triggerSync: t5,
-      startLiveSync: t6,
-      stopLiveSync: t7,
-      setScope: t8,
-      retryFailedUploads: t9,
-      clearFailedUploads: t10,
-      failedUploads: t11,
-      pauseAutoRetry: t12,
-      resumeAutoRetry: t13,
-      isAutoRetryPaused: false,
-      addPendingMutation: t14,
-      removePendingMutation: t15
-    };
-    $[15] = t10;
-    $[16] = t12;
-    $[17] = t13;
-    $[18] = t5;
-    $[19] = t6;
-    $[20] = t7;
-    $[21] = t8;
-    $[22] = t9;
-    $[23] = t16;
-  } else {
-    t16 = $[23];
-  }
-  const syncControl = t16;
-  let t17;
-  bb0: {
-    if (!attachments) {
-      t17 = void 0;
-      break bb0;
-    }
-    let t182;
-    if ($[24] !== attachments.bucket || $[25] !== storageBackend || $[26] !== supabaseClient) {
-      t182 = supabaseClient ? createSupabaseUploadHandler(supabaseClient, {
-        defaultBucket: attachments.bucket,
-        resolver: storageBackend?.resolveBucket?.bind(storageBackend)
-      }) : void 0;
-      $[24] = attachments.bucket;
-      $[25] = storageBackend;
-      $[26] = supabaseClient;
-      $[27] = t182;
-    } else {
-      t182 = $[27];
-    }
-    const nativeUploadHandler = t182;
-    const t192 = storageBackend;
-    let t202;
-    if ($[28] !== attachments.bucket || $[29] !== attachments.compression || $[30] !== attachments.download || $[31] !== attachments.maxCacheBytes || $[32] !== attachments.onUploadComplete || $[33] !== attachments.onUploadFailed || $[34] !== attachments.skipDownload || $[35] !== attachments.watchIds || $[36] !== nativeUploadHandler || $[37] !== t192) {
-      t202 = {
-        bucket: attachments.bucket,
-        watchIds: attachments.watchIds,
-        skipDownload: attachments.skipDownload,
-        onUploadComplete: attachments.onUploadComplete,
-        onUploadFailed: attachments.onUploadFailed,
-        maxCacheBytes: attachments.maxCacheBytes,
-        compression: attachments.compression,
-        download: attachments.download,
-        remoteStorage: t192,
-        uploadHandler: nativeUploadHandler
-      };
-      $[28] = attachments.bucket;
-      $[29] = attachments.compression;
-      $[30] = attachments.download;
-      $[31] = attachments.maxCacheBytes;
-      $[32] = attachments.onUploadComplete;
-      $[33] = attachments.onUploadFailed;
-      $[34] = attachments.skipDownload;
-      $[35] = attachments.watchIds;
-      $[36] = nativeUploadHandler;
-      $[37] = t192;
-      $[38] = t202;
-    } else {
-      t202 = $[38];
-    }
-    t17 = t202;
-  }
-  const attachmentConfig = t17;
-  const t18 = powerSyncUrl ?? "";
-  const t19 = syncConfig?.autoConnect ?? true;
-  const t20 = syncConfig?.enableHealthMonitoring ?? true;
-  const t21 = syncConfig?.enableMetrics ?? true;
-  let t22;
-  if ($[39] !== t19 || $[40] !== t20 || $[41] !== t21) {
-    t22 = {
-      autoConnect: t19,
-      enableHealthMonitoring: t20,
-      enableMetrics: t21
-    };
-    $[39] = t19;
-    $[40] = t20;
-    $[41] = t21;
-    $[42] = t22;
-  } else {
-    t22 = $[42];
-  }
-  let t23;
-  if ($[43] !== attachmentConfig || $[44] !== connectorConfig || $[45] !== dbFilename || $[46] !== platform || $[47] !== queryClient || $[48] !== schema || $[49] !== supabaseClient || $[50] !== t18 || $[51] !== t22) {
-    t23 = {
-      platform,
-      schema,
-      powerSyncUrl: t18,
-      supabaseClient,
-      queryClient,
-      dbFilename,
-      connector: connectorConfig,
-      attachments: attachmentConfig,
-      sync: t22
-    };
-    $[43] = attachmentConfig;
-    $[44] = connectorConfig;
-    $[45] = dbFilename;
-    $[46] = platform;
-    $[47] = queryClient;
-    $[48] = schema;
-    $[49] = supabaseClient;
-    $[50] = t18;
-    $[51] = t22;
-    $[52] = t23;
-  } else {
-    t23 = $[52];
-  }
-  const powerSyncConfig = t23;
-  let t24;
-  if ($[53] !== onError || $[54] !== platform.logger) {
-    t24 = (err) => {
-      platform.logger.error("PowerSync error:", err);
-      const errorMessage = err.message ?? "";
-      if (errorMessage.includes("not open") || errorMessage.includes("closed") || errorMessage.includes("failed to open") || errorMessage.includes("initialization failed")) {
-        setInitError(err);
-      }
-      onError?.(err);
-    };
-    $[53] = onError;
-    $[54] = platform.logger;
-    $[55] = t24;
-  } else {
-    t24 = $[55];
-  }
-  const handlePowerSyncError = t24;
-  let t25;
-  if ($[56] !== platform.logger) {
-    t25 = () => {
-      platform.logger.info("Retrying PowerSync initialization...");
-      setInitError(null);
-      setRetryKey(_temp);
-    };
-    $[56] = platform.logger;
-    $[57] = t25;
-  } else {
-    t25 = $[57];
-  }
-  const handleRetry = t25;
-  let t26;
-  if ($[58] !== backgroundSync?.callbacks || $[59] !== onBackgroundSyncSystemReadyProp || $[60] !== platform.logger) {
-    t26 = (system) => {
-      backgroundSyncSystemRef.current = system;
-      backgroundSync?.callbacks?.onSyncStart?.();
-      onBackgroundSyncSystemReadyProp?.(system);
-      platform.logger.info("[Background Sync] System ready");
-    };
-    $[58] = backgroundSync?.callbacks;
-    $[59] = onBackgroundSyncSystemReadyProp;
-    $[60] = platform.logger;
-    $[61] = t26;
-  } else {
-    t26 = $[61];
-  }
-  backgroundSync?.callbacks;
-  const handleBackgroundSyncSystemReady = t26;
-  let t27;
-  if ($[62] !== renderError || $[63] !== renderInitError) {
-    t27 = (error, retry) => {
-      const customRenderer = renderInitError ?? renderError;
-      if (customRenderer) {
-        return customRenderer(error, retry);
-      }
-      return /* @__PURE__ */ jsx3(DefaultErrorRecoveryUI, { error, onRetry: retry });
-    };
-    $[62] = renderError;
-    $[63] = renderInitError;
-    $[64] = t27;
-  } else {
-    t27 = $[64];
-  }
-  const errorFallback = t27;
-  let t28;
-  if ($[65] !== powerSyncSyncStatus || $[66] !== powerSyncUrl) {
-    t28 = !powerSyncUrl ? {
-      hasSynced: true,
-      connected: true,
-      connecting: false,
-      isOnline: true
-    } : powerSyncSyncStatus;
-    $[65] = powerSyncSyncStatus;
-    $[66] = powerSyncUrl;
-    $[67] = t28;
-  } else {
-    t28 = $[67];
-  }
-  const effectiveSyncStatus = t28;
-  let t29;
-  let t30;
-  if ($[68] !== effectiveSyncStatus || $[69] !== onSyncStatusChange) {
-    t29 = () => {
-      if (effectiveSyncStatus) {
-        onSyncStatusChange?.(effectiveSyncStatus);
-      }
-    };
-    t30 = [effectiveSyncStatus, onSyncStatusChange];
-    $[68] = effectiveSyncStatus;
-    $[69] = onSyncStatusChange;
-    $[70] = t29;
-    $[71] = t30;
-  } else {
-    t29 = $[70];
-    t30 = $[71];
-  }
-  useEffect3(t29, t30);
-  let t31;
-  let t32;
-  if ($[72] !== backgroundSync || $[73] !== children || $[74] !== dataLayer || $[75] !== effectiveSyncStatus || $[76] !== errorFallback || $[77] !== handleBackgroundSyncSystemReady || $[78] !== handlePowerSyncError || $[79] !== handleRetry || $[80] !== initError || $[81] !== onReady || $[82] !== platform.logger || $[83] !== powerSyncConfig || $[84] !== powerSyncInstance || $[85] !== powerSyncUrl || $[86] !== queryClient || $[87] !== renderError || $[88] !== renderInitError || $[89] !== retryKey || $[90] !== skipConflictProvider || $[91] !== skipStorageQueueProvider || $[92] !== supabaseClient || $[93] !== syncControl) {
-    t32 = /* @__PURE__ */ Symbol.for("react.early_return_sentinel");
-    bb1: {
-      const renderContent = () => {
-        if (!powerSyncUrl) {
-          return /* @__PURE__ */ jsx3(Fragment2, { children });
-        }
-        if (initError) {
-          const customRenderer_0 = renderInitError ?? renderError;
-          if (customRenderer_0) {
-            return /* @__PURE__ */ jsx3(Fragment2, { children: customRenderer_0(initError, handleRetry) });
-          }
-          return /* @__PURE__ */ jsx3(DefaultErrorRecoveryUI, { error: initError, onRetry: handleRetry });
-        }
-        return /* @__PURE__ */ jsx3(PowerSyncErrorBoundary, { fallback: errorFallback, onError: handlePowerSyncError, children: /* @__PURE__ */ jsx3(PowerSyncProvider, { config: powerSyncConfig, onReady: () => {
-          platform.logger.info("PowerSync initialized and ready");
-          setInitError(null);
-          onReady?.();
-        }, onError: handlePowerSyncError, children: /* @__PURE__ */ jsx3(ProviderBridge, { skipConflictProvider, skipStorageQueueProvider, backgroundSync, onBackgroundSyncSystemReady: handleBackgroundSyncSystemReady, onDbReady: (db, syncStatus) => {
-          setPowerSyncInstance(db);
-          setPowerSyncSyncStatus(syncStatus);
-        }, onSyncStatusChange: (syncStatus_0) => {
-          setPowerSyncSyncStatus(syncStatus_0);
-        }, onAddPendingMutationReady: (add) => {
-          addPendingMutationRef.current = add;
-        }, onRemovePendingMutationReady: (remove) => {
-          removePendingMutationRef.current = remove;
-        }, children }) }, retryKey) });
-      };
-      let t33;
-      if ($[96] !== dataLayer.config || $[97] !== effectiveSyncStatus || $[98] !== powerSyncInstance || $[99] !== queryClient || $[100] !== supabaseClient || $[101] !== syncControl) {
-        t33 = (content) => /* @__PURE__ */ jsx3(DataLayerProvider, { config: dataLayer.config, powerSyncInstance, supabaseClient, queryClient, powerSyncSyncStatus: effectiveSyncStatus, syncControl, children: content });
-        $[96] = dataLayer.config;
-        $[97] = effectiveSyncStatus;
-        $[98] = powerSyncInstance;
-        $[99] = queryClient;
-        $[100] = supabaseClient;
-        $[101] = syncControl;
-        $[102] = t33;
-      } else {
-        t33 = $[102];
-      }
-      const renderWithDataLayer = t33;
-      if (dataLayer && !dataLayer.skip) {
-        t32 = renderWithDataLayer(renderContent());
-        break bb1;
-      }
-      t31 = renderContent();
-    }
-    $[72] = backgroundSync;
-    $[73] = children;
-    $[74] = dataLayer;
-    $[75] = effectiveSyncStatus;
-    $[76] = errorFallback;
-    $[77] = handleBackgroundSyncSystemReady;
-    $[78] = handlePowerSyncError;
-    $[79] = handleRetry;
-    $[80] = initError;
-    $[81] = onReady;
-    $[82] = platform.logger;
-    $[83] = powerSyncConfig;
-    $[84] = powerSyncInstance;
-    $[85] = powerSyncUrl;
-    $[86] = queryClient;
-    $[87] = renderError;
-    $[88] = renderInitError;
-    $[89] = retryKey;
-    $[90] = skipConflictProvider;
-    $[91] = skipStorageQueueProvider;
-    $[92] = supabaseClient;
-    $[93] = syncControl;
-    $[94] = t31;
-    $[95] = t32;
-  } else {
-    t31 = $[94];
-    t32 = $[95];
-  }
-  if (t32 !== /* @__PURE__ */ Symbol.for("react.early_return_sentinel")) {
-    return t32;
-  }
-  return t31;
-}
-function _temp(prev) {
-  return prev + 1;
-}
-
 export {
   ConflictBus,
+  UPLOAD_MAX_RETRIES,
+  UPLOAD_BACKOFF_DELAYS,
   PowerSyncProvider,
-  ProviderBridge,
-  OfflineDataProvider
+  ProviderBridge
 };
-//# sourceMappingURL=chunk-VB737IVN.js.map
+//# sourceMappingURL=chunk-P4D6BQ4X.js.map