@pol-studios/powersync 1.0.25 → 1.0.30

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

@@ -8,12 +8,12 @@ import {
   HealthMonitor,
   MetricsCollector,
   SyncStatusTracker
-} from "./chunk-55DKCJV4.js";
+} from "./chunk-RE5HWLCB.js";
 import {
   DEFAULT_CONNECTION_HEALTH,
   DEFAULT_SYNC_METRICS,
   DEFAULT_SYNC_STATUS
-} from "./chunk-24RDMMCL.js";
+} from "./chunk-FNYQFILT.js";
 import {
   AttachmentQueueContext,
   CompletedTransactionsContext,
@@ -30,7 +30,7 @@ import {
   usePendingMutationsContext,
   usePowerSync,
   useSyncStatus
-} from "./chunk-YSTEESEG.js";
+} from "./chunk-C2ACBYBZ.js";
 import {
   createSupabaseUploadHandler
 } from "./chunk-CAB26E6F.js";
@@ -42,7 +42,7 @@ import {
 } from "./chunk-WN5ZJ3E2.js";
 import {
   SupabaseConnector
-} from "./chunk-BGBQYQV3.js";
+} from "./chunk-BC2SRII2.js";
 import {
   createSyncError,
   extractEntityIds,
@@ -120,6 +120,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({
@@ -170,6 +174,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 +203,7 @@ function PowerSyncProvider({
   const syncModeRef = useRef("push-pull");
   const removePendingMutationRef = useRef(() => {
   });
+  const uploadRetryTimeoutRef = useRef(null);
   const onSyncStatusChangeRef = useRef(onSyncStatusChange);
   const onReadyRef = useRef(onReady);
   const onErrorRef = useRef(onError);
@@ -395,21 +407,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) => {
@@ -537,7 +612,7 @@ function PowerSyncProvider({
         } catch {
           return null;
         }
-      }).filter((e) => e !== null);
+      }).filter((e_0) => e_0 !== null);
       if (!dbClosedRef.current) {
         statusTrackerRef.current?.updatePendingMutations(mutations);
         setPendingMutations(mutations);
@@ -550,15 +625,15 @@ 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;
     });
@@ -605,9 +680,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 +710,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 +780,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 +812,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 +833,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 +923,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_1) => e_1.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 +1006,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,11 +1019,11 @@ 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());
     }
@@ -955,10 +1055,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 +1066,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 +1096,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,8 +1119,15 @@ 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 }) }) }) }) }) }) }) }) }) }) });
 }
 
@@ -1265,7 +1370,7 @@ function DefaultErrorRecoveryUI(t0) {
   return t6;
 }
 function OfflineDataProvider(t0) {
-  const $ = _c(103);
+  const $ = _c(98);
   const {
     config,
     children,
@@ -1352,50 +1457,31 @@ function OfflineDataProvider(t0) {
     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 ($[9] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t11 = [];
+    t12 = (entry) => {
       if (addPendingMutationRef.current) {
         addPendingMutationRef.current(entry);
       }
     };
-    t15 = (id) => {
+    t13 = (id) => {
       if (removePendingMutationRef.current) {
         removePendingMutationRef.current(id);
       }
     };
-    $[13] = t14;
-    $[14] = t15;
+    $[9] = t11;
+    $[10] = t12;
+    $[11] = t13;
   } else {
-    t14 = $[13];
-    t15 = $[14];
+    t11 = $[9];
+    t12 = $[10];
+    t13 = $[11];
   }
-  let t16;
-  if ($[15] !== t10 || $[16] !== t12 || $[17] !== t13 || $[18] !== t5 || $[19] !== t6 || $[20] !== t7 || $[21] !== t8 || $[22] !== t9) {
-    t16 = {
+  let t14;
+  if ($[12] !== t10 || $[13] !== t5 || $[14] !== t6 || $[15] !== t7 || $[16] !== t8 || $[17] !== t9) {
+    t14 = {
       triggerSync: t5,
       startLiveSync: t6,
       stopLiveSync: t7,
@@ -1403,49 +1489,44 @@ function OfflineDataProvider(t0) {
       retryFailedUploads: t9,
       clearFailedUploads: t10,
       failedUploads: t11,
-      pauseAutoRetry: t12,
-      resumeAutoRetry: t13,
-      isAutoRetryPaused: false,
-      addPendingMutation: t14,
-      removePendingMutation: t15
+      addPendingMutation: t12,
+      removePendingMutation: t13
     };
-    $[15] = t10;
-    $[16] = t12;
-    $[17] = t13;
-    $[18] = t5;
-    $[19] = t6;
-    $[20] = t7;
-    $[21] = t8;
-    $[22] = t9;
-    $[23] = t16;
+    $[12] = t10;
+    $[13] = t5;
+    $[14] = t6;
+    $[15] = t7;
+    $[16] = t8;
+    $[17] = t9;
+    $[18] = t14;
   } else {
-    t16 = $[23];
+    t14 = $[18];
   }
-  const syncControl = t16;
-  let t17;
+  const syncControl = t14;
+  let t15;
   bb0: {
     if (!attachments) {
-      t17 = void 0;
+      t15 = void 0;
       break bb0;
     }
-    let t182;
-    if ($[24] !== attachments.bucket || $[25] !== storageBackend || $[26] !== supabaseClient) {
-      t182 = supabaseClient ? createSupabaseUploadHandler(supabaseClient, {
+    let t162;
+    if ($[19] !== attachments.bucket || $[20] !== storageBackend || $[21] !== supabaseClient) {
+      t162 = supabaseClient ? createSupabaseUploadHandler(supabaseClient, {
         defaultBucket: attachments.bucket,
         resolver: storageBackend?.resolveBucket?.bind(storageBackend)
       }) : void 0;
-      $[24] = attachments.bucket;
-      $[25] = storageBackend;
-      $[26] = supabaseClient;
-      $[27] = t182;
+      $[19] = attachments.bucket;
+      $[20] = storageBackend;
+      $[21] = supabaseClient;
+      $[22] = t162;
     } else {
-      t182 = $[27];
+      t162 = $[22];
     }
-    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 = {
+    const nativeUploadHandler = t162;
+    const t172 = storageBackend;
+    let t182;
+    if ($[23] !== attachments.bucket || $[24] !== attachments.compression || $[25] !== attachments.download || $[26] !== attachments.maxCacheBytes || $[27] !== attachments.onUploadComplete || $[28] !== attachments.onUploadFailed || $[29] !== attachments.skipDownload || $[30] !== attachments.watchIds || $[31] !== nativeUploadHandler || $[32] !== t172) {
+      t182 = {
         bucket: attachments.bucket,
         watchIds: attachments.watchIds,
         skipDownload: attachments.skipDownload,
@@ -1454,74 +1535,74 @@ function OfflineDataProvider(t0) {
         maxCacheBytes: attachments.maxCacheBytes,
         compression: attachments.compression,
         download: attachments.download,
-        remoteStorage: t192,
+        remoteStorage: t172,
         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;
+      $[23] = attachments.bucket;
+      $[24] = attachments.compression;
+      $[25] = attachments.download;
+      $[26] = attachments.maxCacheBytes;
+      $[27] = attachments.onUploadComplete;
+      $[28] = attachments.onUploadFailed;
+      $[29] = attachments.skipDownload;
+      $[30] = attachments.watchIds;
+      $[31] = nativeUploadHandler;
+      $[32] = t172;
+      $[33] = t182;
     } else {
-      t202 = $[38];
+      t182 = $[33];
     }
-    t17 = t202;
+    t15 = t182;
   }
-  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
+  const attachmentConfig = t15;
+  const t16 = powerSyncUrl ?? "";
+  const t17 = syncConfig?.autoConnect ?? true;
+  const t18 = syncConfig?.enableHealthMonitoring ?? true;
+  const t19 = syncConfig?.enableMetrics ?? true;
+  let t20;
+  if ($[34] !== t17 || $[35] !== t18 || $[36] !== t19) {
+    t20 = {
+      autoConnect: t17,
+      enableHealthMonitoring: t18,
+      enableMetrics: t19
     };
-    $[39] = t19;
-    $[40] = t20;
-    $[41] = t21;
-    $[42] = t22;
+    $[34] = t17;
+    $[35] = t18;
+    $[36] = t19;
+    $[37] = t20;
   } else {
-    t22 = $[42];
+    t20 = $[37];
   }
-  let t23;
-  if ($[43] !== attachmentConfig || $[44] !== connectorConfig || $[45] !== dbFilename || $[46] !== platform || $[47] !== queryClient || $[48] !== schema || $[49] !== supabaseClient || $[50] !== t18 || $[51] !== t22) {
-    t23 = {
+  let t21;
+  if ($[38] !== attachmentConfig || $[39] !== connectorConfig || $[40] !== dbFilename || $[41] !== platform || $[42] !== queryClient || $[43] !== schema || $[44] !== supabaseClient || $[45] !== t16 || $[46] !== t20) {
+    t21 = {
       platform,
       schema,
-      powerSyncUrl: t18,
+      powerSyncUrl: t16,
       supabaseClient,
       queryClient,
       dbFilename,
       connector: connectorConfig,
       attachments: attachmentConfig,
-      sync: t22
+      sync: t20
     };
-    $[43] = attachmentConfig;
-    $[44] = connectorConfig;
-    $[45] = dbFilename;
-    $[46] = platform;
-    $[47] = queryClient;
-    $[48] = schema;
-    $[49] = supabaseClient;
-    $[50] = t18;
-    $[51] = t22;
-    $[52] = t23;
+    $[38] = attachmentConfig;
+    $[39] = connectorConfig;
+    $[40] = dbFilename;
+    $[41] = platform;
+    $[42] = queryClient;
+    $[43] = schema;
+    $[44] = supabaseClient;
+    $[45] = t16;
+    $[46] = t20;
+    $[47] = t21;
   } else {
-    t23 = $[52];
+    t21 = $[47];
   }
-  const powerSyncConfig = t23;
-  let t24;
-  if ($[53] !== onError || $[54] !== platform.logger) {
-    t24 = (err) => {
+  const powerSyncConfig = t21;
+  let t22;
+  if ($[48] !== onError || $[49] !== platform.logger) {
+    t22 = (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")) {
@@ -1529,96 +1610,96 @@ function OfflineDataProvider(t0) {
       }
       onError?.(err);
     };
-    $[53] = onError;
-    $[54] = platform.logger;
-    $[55] = t24;
+    $[48] = onError;
+    $[49] = platform.logger;
+    $[50] = t22;
   } else {
-    t24 = $[55];
+    t22 = $[50];
   }
-  const handlePowerSyncError = t24;
-  let t25;
-  if ($[56] !== platform.logger) {
-    t25 = () => {
+  const handlePowerSyncError = t22;
+  let t23;
+  if ($[51] !== platform.logger) {
+    t23 = () => {
       platform.logger.info("Retrying PowerSync initialization...");
       setInitError(null);
       setRetryKey(_temp);
     };
-    $[56] = platform.logger;
-    $[57] = t25;
+    $[51] = platform.logger;
+    $[52] = t23;
   } else {
-    t25 = $[57];
+    t23 = $[52];
   }
-  const handleRetry = t25;
-  let t26;
-  if ($[58] !== backgroundSync?.callbacks || $[59] !== onBackgroundSyncSystemReadyProp || $[60] !== platform.logger) {
-    t26 = (system) => {
+  const handleRetry = t23;
+  let t24;
+  if ($[53] !== backgroundSync?.callbacks || $[54] !== onBackgroundSyncSystemReadyProp || $[55] !== platform.logger) {
+    t24 = (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;
+    $[53] = backgroundSync?.callbacks;
+    $[54] = onBackgroundSyncSystemReadyProp;
+    $[55] = platform.logger;
+    $[56] = t24;
   } else {
-    t26 = $[61];
+    t24 = $[56];
   }
   backgroundSync?.callbacks;
-  const handleBackgroundSyncSystemReady = t26;
-  let t27;
-  if ($[62] !== renderError || $[63] !== renderInitError) {
-    t27 = (error, retry) => {
+  const handleBackgroundSyncSystemReady = t24;
+  let t25;
+  if ($[57] !== renderError || $[58] !== renderInitError) {
+    t25 = (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;
+    $[57] = renderError;
+    $[58] = renderInitError;
+    $[59] = t25;
   } else {
-    t27 = $[64];
+    t25 = $[59];
   }
-  const errorFallback = t27;
-  let t28;
-  if ($[65] !== powerSyncSyncStatus || $[66] !== powerSyncUrl) {
-    t28 = !powerSyncUrl ? {
+  const errorFallback = t25;
+  let t26;
+  if ($[60] !== powerSyncSyncStatus || $[61] !== powerSyncUrl) {
+    t26 = !powerSyncUrl ? {
       hasSynced: true,
       connected: true,
       connecting: false,
       isOnline: true
     } : powerSyncSyncStatus;
-    $[65] = powerSyncSyncStatus;
-    $[66] = powerSyncUrl;
-    $[67] = t28;
+    $[60] = powerSyncSyncStatus;
+    $[61] = powerSyncUrl;
+    $[62] = t26;
   } else {
-    t28 = $[67];
+    t26 = $[62];
   }
-  const effectiveSyncStatus = t28;
-  let t29;
-  let t30;
-  if ($[68] !== effectiveSyncStatus || $[69] !== onSyncStatusChange) {
-    t29 = () => {
+  const effectiveSyncStatus = t26;
+  let t27;
+  let t28;
+  if ($[63] !== effectiveSyncStatus || $[64] !== onSyncStatusChange) {
+    t27 = () => {
       if (effectiveSyncStatus) {
         onSyncStatusChange?.(effectiveSyncStatus);
       }
     };
-    t30 = [effectiveSyncStatus, onSyncStatusChange];
-    $[68] = effectiveSyncStatus;
-    $[69] = onSyncStatusChange;
-    $[70] = t29;
-    $[71] = t30;
+    t28 = [effectiveSyncStatus, onSyncStatusChange];
+    $[63] = effectiveSyncStatus;
+    $[64] = onSyncStatusChange;
+    $[65] = t27;
+    $[66] = t28;
   } else {
-    t29 = $[70];
-    t30 = $[71];
+    t27 = $[65];
+    t28 = $[66];
   }
-  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");
+  useEffect3(t27, t28);
+  let t29;
+  let t30;
+  if ($[67] !== backgroundSync || $[68] !== children || $[69] !== dataLayer || $[70] !== effectiveSyncStatus || $[71] !== errorFallback || $[72] !== handleBackgroundSyncSystemReady || $[73] !== handlePowerSyncError || $[74] !== handleRetry || $[75] !== initError || $[76] !== onReady || $[77] !== platform.logger || $[78] !== powerSyncConfig || $[79] !== powerSyncInstance || $[80] !== powerSyncUrl || $[81] !== queryClient || $[82] !== renderError || $[83] !== renderInitError || $[84] !== retryKey || $[85] !== skipConflictProvider || $[86] !== skipStorageQueueProvider || $[87] !== supabaseClient || $[88] !== syncControl) {
+    t30 = /* @__PURE__ */ Symbol.for("react.early_return_sentinel");
     bb1: {
       const renderContent = () => {
         if (!powerSyncUrl) {
@@ -1646,58 +1727,58 @@ function OfflineDataProvider(t0) {
           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;
+      let t31;
+      if ($[91] !== dataLayer.config || $[92] !== effectiveSyncStatus || $[93] !== powerSyncInstance || $[94] !== queryClient || $[95] !== supabaseClient || $[96] !== syncControl) {
+        t31 = (content) => /* @__PURE__ */ jsx3(DataLayerProvider, { config: dataLayer.config, powerSyncInstance, supabaseClient, queryClient, powerSyncSyncStatus: effectiveSyncStatus, syncControl, children: content });
+        $[91] = dataLayer.config;
+        $[92] = effectiveSyncStatus;
+        $[93] = powerSyncInstance;
+        $[94] = queryClient;
+        $[95] = supabaseClient;
+        $[96] = syncControl;
+        $[97] = t31;
       } else {
-        t33 = $[102];
+        t31 = $[97];
       }
-      const renderWithDataLayer = t33;
+      const renderWithDataLayer = t31;
       if (dataLayer && !dataLayer.skip) {
-        t32 = renderWithDataLayer(renderContent());
+        t30 = renderWithDataLayer(renderContent());
         break bb1;
       }
-      t31 = renderContent();
+      t29 = 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;
+    $[67] = backgroundSync;
+    $[68] = children;
+    $[69] = dataLayer;
+    $[70] = effectiveSyncStatus;
+    $[71] = errorFallback;
+    $[72] = handleBackgroundSyncSystemReady;
+    $[73] = handlePowerSyncError;
+    $[74] = handleRetry;
+    $[75] = initError;
+    $[76] = onReady;
+    $[77] = platform.logger;
+    $[78] = powerSyncConfig;
+    $[79] = powerSyncInstance;
+    $[80] = powerSyncUrl;
+    $[81] = queryClient;
+    $[82] = renderError;
+    $[83] = renderInitError;
+    $[84] = retryKey;
+    $[85] = skipConflictProvider;
+    $[86] = skipStorageQueueProvider;
+    $[87] = supabaseClient;
+    $[88] = syncControl;
+    $[89] = t29;
+    $[90] = t30;
   } else {
-    t31 = $[94];
-    t32 = $[95];
+    t29 = $[89];
+    t30 = $[90];
   }
-  if (t32 !== /* @__PURE__ */ Symbol.for("react.early_return_sentinel")) {
-    return t32;
+  if (t30 !== /* @__PURE__ */ Symbol.for("react.early_return_sentinel")) {
+    return t30;
   }
-  return t31;
+  return t29;
 }
 function _temp(prev) {
   return prev + 1;
@@ -1705,8 +1786,10 @@ function _temp(prev) {
 
 export {
   ConflictBus,
+  UPLOAD_MAX_RETRIES,
+  UPLOAD_BACKOFF_DELAYS,
   PowerSyncProvider,
   ProviderBridge,
   OfflineDataProvider
 };
-//# sourceMappingURL=chunk-VB737IVN.js.map
+//# sourceMappingURL=chunk-JCGOZVWL.js.map