@pol-studios/powersync 1.0.4 → 1.0.7

package/dist/chunk-FV2HXEIY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/retry.ts"],"sourcesContent":["/**\n * Exponential backoff retry utilities for resilient network operations.\n *\n * Provides configurable retry logic with exponential backoff, jitter,\n * and abort signal support for cancellation.\n */\n\n/**\n * Configuration for exponential backoff retry behavior.\n */\nexport interface BackoffConfig {\n  /** Maximum number of retry attempts (0 = no retries, just one attempt) */\n  maxRetries: number;\n  /** Base delay in milliseconds before first retry */\n  baseDelayMs: number;\n  /** Maximum delay cap in milliseconds */\n  maxDelayMs: number;\n  /** Multiplier applied to delay for each subsequent retry (typically 2) */\n  backoffMultiplier: number;\n}\n\n/**\n * Options for the withExponentialBackoff function.\n */\nexport interface BackoffOptions {\n  /** Optional AbortSignal for cancellation support */\n  signal?: AbortSignal;\n  /** Callback invoked before each retry attempt */\n  onRetry?: (attempt: number, delay: number, error: Error) => void;\n}\n\n/**\n * Error thrown when an operation is aborted via AbortSignal.\n */\nexport class AbortError extends Error {\n  constructor(message = 'Operation aborted') {\n    super(message);\n    this.name = 'AbortError';\n  }\n}\n\n/**\n * Error thrown when all retry attempts have been exhausted.\n */\nexport class RetryExhaustedError extends Error {\n  /** The last error that caused the final retry to fail */\n  readonly cause: Error;\n  /** Total number of attempts made */\n  readonly attempts: number;\n  constructor(cause: Error, attempts: number) {\n    super(`Retry exhausted after ${attempts} attempt(s): ${cause.message}`);\n    this.name = 'RetryExhaustedError';\n    this.cause = cause;\n    this.attempts = attempts;\n  }\n}\n\n/**\n * Calculates the delay for a given retry attempt using exponential backoff.\n *\n * Formula: min(baseDelay * (multiplier ^ attempt), maxDelay)\n *\n * @param attempt - The current attempt number (0-indexed)\n * @param config - Backoff configuration\n * @returns Delay in milliseconds (without jitter)\n *\n * @example\n * ```ts\n * const config = { baseDelayMs: 1000, maxDelayMs: 30000, backoffMultiplier: 2 };\n * calculateBackoffDelay(0, config); // 1000\n * calculateBackoffDelay(1, config); // 2000\n * calculateBackoffDelay(2, config); // 4000\n * calculateBackoffDelay(5, config); // 30000 (capped at maxDelayMs)\n * ```\n */\nexport function calculateBackoffDelay(attempt: number, config: Pick<BackoffConfig, 'baseDelayMs' | 'maxDelayMs' | 'backoffMultiplier'>): number {\n  const {\n    baseDelayMs,\n    maxDelayMs,\n    backoffMultiplier\n  } = config;\n\n  // Ensure non-negative attempt number\n  const safeAttempt = Math.max(0, attempt);\n\n  // Calculate exponential delay\n  const exponentialDelay = baseDelayMs * Math.pow(backoffMultiplier, safeAttempt);\n\n  // Cap at maxDelayMs\n  return Math.min(exponentialDelay, maxDelayMs);\n}\n\n/**\n * Adds jitter (±10%) to a delay value to prevent thundering herd.\n *\n * @param delay - Base delay in milliseconds\n * @returns Delay with random jitter applied\n */\nexport function addJitter(delay: number): number {\n  // Generate random factor between 0.9 and 1.1 (±10%)\n  const jitterFactor = 0.9 + Math.random() * 0.2;\n  return Math.round(delay * jitterFactor);\n}\n\n/**\n * Sleep utility that respects AbortSignal for cancellation.\n *\n * @param ms - Duration to sleep in milliseconds\n * @param signal - Optional AbortSignal for cancellation\n * @returns Promise that resolves after the delay or rejects if aborted\n * @throws {AbortError} If the signal is aborted during sleep\n *\n * @example\n * ```ts\n * const controller = new AbortController();\n *\n * // Sleep for 1 second\n * await sleep(1000);\n *\n * // Sleep with cancellation support\n * await sleep(1000, controller.signal);\n *\n * // Cancel the sleep\n * controller.abort();\n * ```\n */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise((resolve, reject) => {\n    // Check if already aborted\n    if (signal?.aborted) {\n      reject(new AbortError());\n      return;\n    }\n\n    // Handle zero or negative duration\n    if (ms <= 0) {\n      resolve();\n      return;\n    }\n    let timeoutId: ReturnType<typeof setTimeout> | undefined;\n    const handleAbort = () => {\n      if (timeoutId !== undefined) {\n        clearTimeout(timeoutId);\n      }\n      reject(new AbortError());\n    };\n\n    // Set up abort listener if signal provided\n    if (signal) {\n      signal.addEventListener('abort', handleAbort, {\n        once: true\n      });\n    }\n    timeoutId = setTimeout(() => {\n      // Clean up abort listener\n      if (signal) {\n        signal.removeEventListener('abort', handleAbort);\n      }\n      resolve();\n    }, ms);\n  });\n}\n\n/**\n * Default backoff configuration suitable for most network operations.\n */\nexport const DEFAULT_BACKOFF_CONFIG: BackoffConfig = {\n  maxRetries: 3,\n  baseDelayMs: 1000,\n  maxDelayMs: 30000,\n  backoffMultiplier: 2\n};\n\n/**\n * Executes a function with exponential backoff retry logic.\n *\n * Retries the provided function on failure using exponential backoff with jitter.\n * Supports cancellation via AbortSignal and provides hooks for retry observation.\n *\n * @param fn - Async function to execute with retry logic\n * @param config - Backoff configuration (maxRetries, delays, multiplier)\n * @param options - Optional abort signal and retry callback\n * @returns Promise resolving to the function result\n * @throws {AbortError} If operation is aborted via signal\n * @throws {RetryExhaustedError} If all retry attempts fail\n *\n * @example\n * ```ts\n * const controller = new AbortController();\n *\n * const result = await withExponentialBackoff(\n *   async () => {\n *     const response = await fetch('https://api.example.com/data');\n *     if (!response.ok) throw new Error('Request failed');\n *     return response.json();\n *   },\n *   {\n *     maxRetries: 3,\n *     baseDelayMs: 1000,\n *     maxDelayMs: 30000,\n *     backoffMultiplier: 2,\n *   },\n *   {\n *     signal: controller.signal,\n *     onRetry: (attempt, delay, error) => {\n *       console.log(`Retry ${attempt} in ${delay}ms: ${error.message}`);\n *     },\n *   }\n * );\n * ```\n */\nexport async function withExponentialBackoff<T>(fn: () => Promise<T>, config: BackoffConfig, options?: BackoffOptions): Promise<T> {\n  const {\n    maxRetries,\n    baseDelayMs,\n    maxDelayMs,\n    backoffMultiplier\n  } = config;\n  const {\n    signal,\n    onRetry\n  } = options ?? {};\n\n  // Check for immediate abort\n  if (signal?.aborted) {\n    throw new AbortError();\n  }\n\n  // Validate config\n  const safeMaxRetries = Math.max(0, Math.floor(maxRetries));\n  const totalAttempts = safeMaxRetries + 1; // Initial attempt + retries\n\n  let lastError: Error | undefined;\n  for (let attempt = 0; attempt < totalAttempts; attempt++) {\n    // Check for abort before each attempt\n    if (signal?.aborted) {\n      throw new AbortError();\n    }\n    try {\n      return await fn();\n    } catch (error) {\n      lastError = error instanceof Error ? error : new Error(String(error));\n\n      // Check if this was the last attempt\n      const isLastAttempt = attempt === totalAttempts - 1;\n      if (isLastAttempt) {\n        break;\n      }\n\n      // Check for abort before sleeping\n      if (signal?.aborted) {\n        throw new AbortError();\n      }\n\n      // Calculate delay with jitter\n      const baseDelay = calculateBackoffDelay(attempt, {\n        baseDelayMs,\n        maxDelayMs,\n        backoffMultiplier\n      });\n      const delayWithJitter = addJitter(baseDelay);\n\n      // Notify about upcoming retry\n      onRetry?.(attempt + 1, delayWithJitter, lastError);\n\n      // Wait before retry\n      await sleep(delayWithJitter, signal);\n    }\n  }\n\n  // All attempts exhausted\n  throw new RetryExhaustedError(lastError!, totalAttempts);\n}"],"mappings":";AAkCO,IAAM,aAAN,cAAyB,MAAM;AAAA,EACpC,YAAY,UAAU,qBAAqB;AACzC,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAKO,IAAM,sBAAN,cAAkC,MAAM;AAAA;AAAA,EAEpC;AAAA;AAAA,EAEA;AAAA,EACT,YAAY,OAAc,UAAkB;AAC1C,UAAM,yBAAyB,QAAQ,gBAAgB,MAAM,OAAO,EAAE;AACtE,SAAK,OAAO;AACZ,SAAK,QAAQ;AACb,SAAK,WAAW;AAAA,EAClB;AACF;AAoBO,SAAS,sBAAsB,SAAiB,QAAyF;AAC9I,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAGJ,QAAM,cAAc,KAAK,IAAI,GAAG,OAAO;AAGvC,QAAM,mBAAmB,cAAc,KAAK,IAAI,mBAAmB,WAAW;AAG9E,SAAO,KAAK,IAAI,kBAAkB,UAAU;AAC9C;AAQO,SAAS,UAAU,OAAuB;AAE/C,QAAM,eAAe,MAAM,KAAK,OAAO,IAAI;AAC3C,SAAO,KAAK,MAAM,QAAQ,YAAY;AACxC;AAwBO,SAAS,MAAM,IAAY,QAAqC;AACrE,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AAEtC,QAAI,QAAQ,SAAS;AACnB,aAAO,IAAI,WAAW,CAAC;AACvB;AAAA,IACF;AAGA,QAAI,MAAM,GAAG;AACX,cAAQ;AACR;AAAA,IACF;AACA,QAAI;AACJ,UAAM,cAAc,MAAM;AACxB,UAAI,cAAc,QAAW;AAC3B,qBAAa,SAAS;AAAA,MACxB;AACA,aAAO,IAAI,WAAW,CAAC;AAAA,IACzB;AAGA,QAAI,QAAQ;AACV,aAAO,iBAAiB,SAAS,aAAa;AAAA,QAC5C,MAAM;AAAA,MACR,CAAC;AAAA,IACH;AACA,gBAAY,WAAW,MAAM;AAE3B,UAAI,QAAQ;AACV,eAAO,oBAAoB,SAAS,WAAW;AAAA,MACjD;AACA,cAAQ;AAAA,IACV,GAAG,EAAE;AAAA,EACP,CAAC;AACH;AAKO,IAAM,yBAAwC;AAAA,EACnD,YAAY;AAAA,EACZ,aAAa;AAAA,EACb,YAAY;AAAA,EACZ,mBAAmB;AACrB;AAwCA,eAAsB,uBAA0B,IAAsB,QAAuB,SAAsC;AACjI,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI,WAAW,CAAC;AAGhB,MAAI,QAAQ,SAAS;AACnB,UAAM,IAAI,WAAW;AAAA,EACvB;AAGA,QAAM,iBAAiB,KAAK,IAAI,GAAG,KAAK,MAAM,UAAU,CAAC;AACzD,QAAM,gBAAgB,iBAAiB;AAEvC,MAAI;AACJ,WAAS,UAAU,GAAG,UAAU,eAAe,WAAW;AAExD,QAAI,QAAQ,SAAS;AACnB,YAAM,IAAI,WAAW;AAAA,IACvB;AACA,QAAI;AACF,aAAO,MAAM,GAAG;AAAA,IAClB,SAAS,OAAO;AACd,kBAAY,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;AAGpE,YAAM,gBAAgB,YAAY,gBAAgB;AAClD,UAAI,eAAe;AACjB;AAAA,MACF;AAGA,UAAI,QAAQ,SAAS;AACnB,cAAM,IAAI,WAAW;AAAA,MACvB;AAGA,YAAM,YAAY,sBAAsB,SAAS;AAAA,QAC/C;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AACD,YAAM,kBAAkB,UAAU,SAAS;AAG3C,gBAAU,UAAU,GAAG,iBAAiB,SAAS;AAGjD,YAAM,MAAM,iBAAiB,MAAM;AAAA,IACrC;AAAA,EACF;AAGA,QAAM,IAAI,oBAAoB,WAAY,aAAa;AACzD;","names":[]}

package/dist/chunk-GKF7TOMT.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-GKF7TOMT.js.map

package/dist/{chunk-OTJXIRWX.js → chunk-H772V6XQ.js}

@@ -4,14 +4,15 @@ import {
   LATENCY_DEGRADED_THRESHOLD_MS,
   MAX_CONSECUTIVE_FAILURES,
   STATUS_NOTIFY_THROTTLE_MS,
+  STORAGE_KEY_AUTO_OFFLINE,
   STORAGE_KEY_METRICS,
   STORAGE_KEY_PAUSED,
   STORAGE_KEY_SYNC_MODE
-} from "./chunk-EJ23MXPQ.js";
+} from "./chunk-CGL33PL4.js";
 import {
   classifyError,
   generateFailureId
-} from "./chunk-FPTDATY5.js";
+} from "./chunk-XQAJM2MW.js";
 
 // src/provider/types.ts
 var DEFAULT_SYNC_STATUS = {
@@ -51,6 +52,8 @@ var DEFAULT_SYNC_CONFIG = {
 };
 
 // src/sync/status-tracker.ts
+var STORAGE_KEY_COMPLETED_TRANSACTIONS = "@pol-powersync:completed_transactions";
+var STORAGE_KEY_FAILED_TRANSACTIONS = "@pol-powersync:failed_transactions";
 var SyncStatusTracker = class _SyncStatusTracker {
   storage;
   logger;
@@ -64,6 +67,13 @@ var SyncStatusTracker = class _SyncStatusTracker {
   _syncModeListeners = /* @__PURE__ */ new Set();
   // Force next upload flag for "Sync Now" functionality
   _forceNextUpload = false;
+  // Network reachability gate - blocks uploads instantly when network is unreachable
+  _networkReachable = true;
+  _networkRestoreTimer = null;
+  _networkRestoreDelayMs = 1500;
+  // 1.5 seconds delay before restoring
+  // Debounce timer for persist operations to avoid race conditions
+  _persistDebounceTimer = null;
   // Track download progress separately to preserve it when offline
   _lastProgress = null;
   // Failed transaction tracking
@@ -72,10 +82,15 @@ var SyncStatusTracker = class _SyncStatusTracker {
   _failureTTLMs = 24 * 60 * 60 * 1e3;
   // 24 hours
   _failureListeners = /* @__PURE__ */ new Set();
-  // Completed transaction tracking
+  // Completed transaction tracking (no limit - full audit trail)
   _completedTransactions = [];
-  _maxCompletedHistory = 20;
   _completedListeners = /* @__PURE__ */ new Set();
+  // Track when notifications were last displayed/dismissed for "auto-dismiss on display"
+  // This allows filtering completed transactions to only show new ones since last display
+  _lastNotificationTime = Date.now();
+  // Auto-offline flag: tracks whether offline mode was set automatically (network loss)
+  // vs manually (user chose offline). Persisted so auto-restore works after app restart.
+  _isAutoOffline = false;
   constructor(storage, logger, options = {}) {
     this.storage = storage;
     this.logger = logger;
@@ -114,6 +129,53 @@ var SyncStatusTracker = class _SyncStatusTracker {
     } catch (err) {
       this.logger.warn("[StatusTracker] Failed to load sync mode:", err);
     }
+    try {
+      const autoOfflineValue = await this.storage.getItem(STORAGE_KEY_AUTO_OFFLINE);
+      this._isAutoOffline = autoOfflineValue === "true";
+      this.logger.debug("[StatusTracker] Loaded isAutoOffline:", this._isAutoOffline);
+    } catch (err) {
+      this.logger.warn("[StatusTracker] Failed to load auto-offline flag:", err);
+    }
+    try {
+      const completedJson = await this.storage.getItem(STORAGE_KEY_COMPLETED_TRANSACTIONS);
+      if (completedJson) {
+        const parsed = JSON.parse(completedJson);
+        this._completedTransactions = parsed.map((item) => {
+          const remappedEntries = item.entries.map((e) => this.remapEntry(e)).filter((e) => e !== null);
+          return {
+            ...item,
+            completedAt: new Date(item.completedAt),
+            entries: remappedEntries
+          };
+        }).filter((item) => !isNaN(item.completedAt.getTime()) && item.entries.length > 0);
+        this.logger.debug("[StatusTracker] Loaded", this._completedTransactions.length, "completed transactions");
+      }
+    } catch (err) {
+      this.logger.warn("[StatusTracker] Failed to load completed transactions:", err);
+    }
+    try {
+      const failedJson = await this.storage.getItem(STORAGE_KEY_FAILED_TRANSACTIONS);
+      if (failedJson) {
+        const parsed = JSON.parse(failedJson);
+        this._failedTransactions = parsed.map((item) => {
+          const remappedEntries = item.entries.map((e) => this.remapEntry(e)).filter((e) => e !== null);
+          return {
+            ...item,
+            firstFailedAt: new Date(item.firstFailedAt),
+            lastFailedAt: new Date(item.lastFailedAt),
+            error: {
+              ...item.error,
+              timestamp: new Date(item.error.timestamp)
+            },
+            entries: remappedEntries
+          };
+        }).filter((item) => !isNaN(item.firstFailedAt.getTime()) && !isNaN(item.lastFailedAt.getTime()) && item.entries.length > 0);
+        this.logger.debug("[StatusTracker] Loaded", this._failedTransactions.length, "failed transactions");
+      }
+    } catch (err) {
+      this.logger.warn("[StatusTracker] Failed to load failed transactions:", err);
+    }
+    this.cleanupStaleFailures();
   }
   /**
    * Dispose the tracker and clear timers.
@@ -123,6 +185,14 @@ var SyncStatusTracker = class _SyncStatusTracker {
       clearTimeout(this._notifyTimer);
       this._notifyTimer = null;
     }
+    if (this._persistDebounceTimer) {
+      clearTimeout(this._persistDebounceTimer);
+      this._persistDebounceTimer = null;
+    }
+    if (this._networkRestoreTimer) {
+      clearTimeout(this._networkRestoreTimer);
+      this._networkRestoreTimer = null;
+    }
     this._listeners.clear();
     this._syncModeListeners.clear();
     this._failureListeners.clear();
@@ -156,17 +226,10 @@ var SyncStatusTracker = class _SyncStatusTracker {
     return this._state.syncMode;
   }
   /**
-   * Get whether sync is paused (offline mode).
-   * @deprecated Use getSyncMode() instead
-   */
-  isPaused() {
-    return this._state.syncMode === "offline";
-  }
-  /**
-   * Check if uploads are allowed based on current sync mode.
+   * Check if uploads are allowed based on current sync mode and network reachability.
    */
   canUpload() {
-    return this._state.syncMode === "push-pull";
+    return this._networkReachable && this._state.syncMode === "push-pull";
   }
   /**
    * Check if downloads are allowed based on current sync mode.
@@ -192,7 +255,7 @@ var SyncStatusTracker = class _SyncStatusTracker {
     }
   }
   /**
-   * Check if upload should proceed, considering force flag.
+   * Check if upload should proceed, considering force flag and network reachability.
    * NOTE: Does NOT auto-reset the flag - caller must use clearForceNextUpload()
    * after all uploads are complete. This prevents race conditions when
    * PowerSync calls uploadData() multiple times for multiple transactions.
@@ -201,8 +264,43 @@ var SyncStatusTracker = class _SyncStatusTracker {
     if (this._forceNextUpload) {
       return true;
     }
+    if (!this._networkReachable) {
+      return false;
+    }
     return this._state.syncMode === "push-pull";
   }
+  /**
+   * Set network reachability state.
+   * - When unreachable: Instantly blocks uploads (0ms)
+   * - When reachable: Delayed restore (1-2 seconds) to avoid flickering on brief disconnects
+   */
+  setNetworkReachable(reachable) {
+    if (this._networkRestoreTimer) {
+      clearTimeout(this._networkRestoreTimer);
+      this._networkRestoreTimer = null;
+    }
+    if (!reachable) {
+      if (this._networkReachable) {
+        this._networkReachable = false;
+        this.logger.debug("[StatusTracker] Network unreachable - uploads blocked instantly");
+      }
+    } else {
+      if (!this._networkReachable) {
+        this.logger.debug("[StatusTracker] Network reachable - scheduling delayed restore");
+        this._networkRestoreTimer = setTimeout(() => {
+          this._networkRestoreTimer = null;
+          this._networkReachable = true;
+          this.logger.debug("[StatusTracker] Network restored - uploads enabled");
+        }, this._networkRestoreDelayMs);
+      }
+    }
+  }
+  /**
+   * Get current network reachability state.
+   */
+  isNetworkReachable() {
+    return this._networkReachable;
+  }
   /**
    * Get pending mutations.
    */
@@ -290,12 +388,27 @@ var SyncStatusTracker = class _SyncStatusTracker {
     }
     this._notifyListeners(true);
   }
+  // ─── Auto-Offline Management ──────────────────────────────────────────────
   /**
-   * Set paused state.
-   * @deprecated Use setSyncMode() instead
+   * Get whether offline mode was set automatically (network loss) vs manually.
+   * Used to determine if sync should auto-resume when network returns.
    */
-  async setPaused(paused) {
-    await this.setSyncMode(paused ? "offline" : "push-pull");
+  getIsAutoOffline() {
+    return this._isAutoOffline;
+  }
+  /**
+   * Set the auto-offline flag and persist it.
+   * @param isAuto - true if offline was set automatically, false if user chose offline
+   */
+  async setIsAutoOffline(isAuto) {
+    if (this._isAutoOffline === isAuto) return;
+    this._isAutoOffline = isAuto;
+    try {
+      await this.storage.setItem(STORAGE_KEY_AUTO_OFFLINE, isAuto ? "true" : "false");
+      this.logger.debug("[StatusTracker] Auto-offline flag changed:", isAuto);
+    } catch (err) {
+      this.logger.warn("[StatusTracker] Failed to persist auto-offline flag:", err);
+    }
   }
   // ─── Subscriptions ─────────────────────────────────────────────────────────
   /**
@@ -320,30 +433,18 @@ var SyncStatusTracker = class _SyncStatusTracker {
       this._syncModeListeners.delete(listener);
     };
   }
-  /**
-   * Subscribe to paused state changes.
-   * @deprecated Use onSyncModeChange() instead
-   * @returns Unsubscribe function
-   */
-  onPausedChange(listener) {
-    const wrappedListener = (mode) => {
-      listener(mode === "offline");
-    };
-    this._syncModeListeners.add(wrappedListener);
-    listener(this._state.syncMode === "offline");
-    return () => {
-      this._syncModeListeners.delete(wrappedListener);
-    };
-  }
   // ─── Failed Transaction Tracking ────────────────────────────────────────────
   /**
    * Record a transaction failure.
    * If a failure for the same entries already exists, updates the retry count.
    * Otherwise, creates a new failure record.
+   *
+   * @param preserveMetadata - Optional. If provided, preserves retryCount and firstFailedAt from a previous failure.
    */
-  recordTransactionFailure(entries, error, isPermanent, affectedEntityIds, affectedTables) {
+  recordTransactionFailure(entries, error, isPermanent, affectedEntityIds, affectedTables, preserveMetadata) {
     const now = /* @__PURE__ */ new Date();
-    const entryIds = entries.map((e) => e.id).sort().join(",");
+    const normalizedEntries = this.normalizeEntries(entries);
+    const entryIds = normalizedEntries.map((e) => e.id).sort().join(",");
     const existingIndex = this._failedTransactions.findIndex((f) => {
       const existingIds = f.entries.map((e) => e.id).sort().join(",");
       return existingIds === entryIds;
@@ -359,11 +460,11 @@ var SyncStatusTracker = class _SyncStatusTracker {
       };
     } else {
       const newFailure = {
-        id: generateFailureId(entries),
-        entries,
+        id: generateFailureId(normalizedEntries),
+        entries: normalizedEntries,
         error,
-        retryCount: 1,
-        firstFailedAt: now,
+        retryCount: preserveMetadata?.retryCount ?? 1,
+        firstFailedAt: preserveMetadata?.firstFailedAt ?? now,
         lastFailedAt: now,
         isPermanent,
         affectedEntityIds,
@@ -375,6 +476,7 @@ var SyncStatusTracker = class _SyncStatusTracker {
         this._failedTransactions = this._failedTransactions.slice(-this._maxStoredFailures);
       }
     }
+    this._schedulePersist();
     this._notifyFailureListeners();
     this._notifyListeners();
   }
@@ -385,6 +487,7 @@ var SyncStatusTracker = class _SyncStatusTracker {
     const initialLength = this._failedTransactions.length;
     this._failedTransactions = this._failedTransactions.filter((f) => f.id !== failureId);
     if (this._failedTransactions.length !== initialLength) {
+      this._schedulePersist();
       this._notifyFailureListeners();
       this._notifyListeners();
     }
@@ -395,9 +498,32 @@ var SyncStatusTracker = class _SyncStatusTracker {
   clearAllFailures() {
     if (this._failedTransactions.length === 0) return;
     this._failedTransactions = [];
+    this._schedulePersist();
     this._notifyFailureListeners();
     this._notifyListeners();
   }
+  /**
+   * Remove a failed transaction from tracking and return its entries.
+   * This is a "pop" operation - the failure is removed from the list.
+   *
+   * Note: The actual CRUD entries remain in PowerSync's ps_crud table
+   * until successfully uploaded. This just removes from our tracking.
+   *
+   * @param failureId - The failure ID to remove
+   * @returns The CrudEntry[] that were in the failure, or null if not found
+   */
+  takeFailureForRetry(failureId) {
+    const failure = this._failedTransactions.find((f) => f.id === failureId);
+    if (!failure) {
+      this.logger.warn("[StatusTracker] Failure not found for retry:", failureId);
+      return null;
+    }
+    this._failedTransactions = this._failedTransactions.filter((f) => f.id !== failureId);
+    this._notifyFailureListeners();
+    this._schedulePersist();
+    this.logger.info("[StatusTracker] Retrieved failure for retry:", failureId, "entries:", failure.entries.length);
+    return failure.entries;
+  }
   /**
    * Get failures affecting a specific entity.
    */
@@ -442,6 +568,7 @@ var SyncStatusTracker = class _SyncStatusTracker {
     this._failedTransactions = this._failedTransactions.filter((f) => f.lastFailedAt.getTime() > cutoff);
     if (this._failedTransactions.length !== initialLength) {
       this.logger.debug(`[StatusTracker] Cleaned up ${initialLength - this._failedTransactions.length} stale failures`);
+      this._schedulePersist();
       this._notifyFailureListeners();
       this._notifyListeners();
     }
@@ -452,20 +579,19 @@ var SyncStatusTracker = class _SyncStatusTracker {
    * Creates a CompletedTransaction record and adds it to history.
    */
   recordTransactionComplete(entries) {
-    const affectedTables = [...new Set(entries.map((e) => e.table))];
-    const affectedEntityIds = [...new Set(entries.map((e) => e.id))];
+    const normalizedEntries = this.normalizeEntries(entries);
+    const affectedTables = [...new Set(normalizedEntries.map((e) => e.table))];
+    const affectedEntityIds = [...new Set(normalizedEntries.map((e) => e.id))];
     const id = `completed_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
     const completed = {
       id,
-      entries,
+      entries: normalizedEntries,
       completedAt: /* @__PURE__ */ new Date(),
       affectedTables,
       affectedEntityIds
     };
     this._completedTransactions.unshift(completed);
-    if (this._completedTransactions.length > this._maxCompletedHistory) {
-      this._completedTransactions = this._completedTransactions.slice(0, this._maxCompletedHistory);
-    }
+    this._schedulePersist();
     this._notifyCompletedListeners();
     this.logger.debug(`[StatusTracker] Recorded completed transaction: ${completed.id} (${entries.length} entries)`);
   }
@@ -481,9 +607,22 @@ var SyncStatusTracker = class _SyncStatusTracker {
   clearCompletedHistory() {
     if (this._completedTransactions.length === 0) return;
     this._completedTransactions = [];
+    this._schedulePersist();
     this._notifyCompletedListeners();
     this.logger.debug("[StatusTracker] Cleared completed transaction history");
   }
+  /**
+   * Clear a specific completed transaction by ID.
+   */
+  clearCompletedItem(completedId) {
+    const initialLength = this._completedTransactions.length;
+    this._completedTransactions = this._completedTransactions.filter((c) => c.id !== completedId);
+    if (this._completedTransactions.length !== initialLength) {
+      this._schedulePersist();
+      this._notifyCompletedListeners();
+      this.logger.debug("[StatusTracker] Cleared completed transaction:", completedId);
+    }
+  }
   /**
    * Subscribe to completed transaction changes.
    * @returns Unsubscribe function
@@ -495,19 +634,78 @@ var SyncStatusTracker = class _SyncStatusTracker {
       this._completedListeners.delete(listener);
     };
   }
+  // ─── Notification Tracking ─────────────────────────────────────────────────
+  /**
+   * Get completed transactions that occurred AFTER the last notification time.
+   * This is used for displaying "X changes synced" notifications to avoid
+   * showing stale counts from historical completed transactions.
+   */
+  getNewCompletedTransactions() {
+    return this._completedTransactions.filter((tx) => tx.completedAt.getTime() > this._lastNotificationTime);
+  }
+  /**
+   * Mark notifications as seen by updating the last notification time.
+   * Call this when the notification is displayed or dismissed.
+   */
+  markNotificationsAsSeen() {
+    this._lastNotificationTime = Date.now();
+    this.logger.debug("[StatusTracker] Notifications marked as seen");
+    this._notifyCompletedListeners();
+  }
+  /**
+   * Get the timestamp of when notifications were last displayed/dismissed.
+   */
+  getLastNotificationTime() {
+    return this._lastNotificationTime;
+  }
   // ─── Private Methods ───────────────────────────────────────────────────────
+  /**
+   * Schedule a debounced persist operation.
+   * This prevents race conditions from multiple rapid persist calls.
+   */
+  _schedulePersist() {
+    if (this._persistDebounceTimer) {
+      clearTimeout(this._persistDebounceTimer);
+    }
+    this._persistDebounceTimer = setTimeout(() => {
+      this._persistDebounceTimer = null;
+      this._persistTransactions();
+    }, 100);
+  }
+  /**
+   * Persist completed and failed transactions to storage.
+   */
+  async _persistTransactions() {
+    try {
+      await Promise.all([this.storage.setItem(STORAGE_KEY_COMPLETED_TRANSACTIONS, JSON.stringify(this._completedTransactions)), this.storage.setItem(STORAGE_KEY_FAILED_TRANSACTIONS, JSON.stringify(this._failedTransactions))]);
+    } catch (err) {
+      this.logger.warn("[StatusTracker] Failed to persist transactions:", err);
+    }
+  }
   _hasStatusChanged(newStatus) {
     const old = this._state.status;
     return old.connected !== newStatus.connected || old.connecting !== newStatus.connecting || old.hasSynced !== newStatus.hasSynced || old.uploading !== newStatus.uploading || old.downloading !== newStatus.downloading || old.lastSyncedAt?.getTime() !== newStatus.lastSyncedAt?.getTime() || old.downloadProgress?.current !== newStatus.downloadProgress?.current || old.downloadProgress?.target !== newStatus.downloadProgress?.target;
   }
+  /**
+   * Notify all listeners of status changes with throttling.
+   *
+   * Uses a "dirty" flag pattern: when throttled, we schedule a timer
+   * but get the CURRENT state when the timer fires, not the stale state
+   * from when the timer was scheduled. This ensures rapid state changes
+   * during the throttle window aren't lost.
+   */
   _notifyListeners(forceImmediate = false) {
     const now = Date.now();
     const timeSinceLastNotify = now - this._lastNotifyTime;
+    if (this._notifyTimer && !forceImmediate) {
+      return;
+    }
     if (this._notifyTimer) {
       clearTimeout(this._notifyTimer);
       this._notifyTimer = null;
     }
     const notify = () => {
+      this._notifyTimer = null;
       this._lastNotifyTime = Date.now();
       const status = this.getStatus();
       this.onStatusChange?.(status);
@@ -522,8 +720,8 @@ var SyncStatusTracker = class _SyncStatusTracker {
     if (forceImmediate || timeSinceLastNotify >= this.notifyThrottleMs) {
       notify();
     } else {
-      const delay = this.notifyThrottleMs - timeSinceLastNotify;
-      this._notifyTimer = setTimeout(notify, delay);
+      const delayMs = this.notifyThrottleMs - timeSinceLastNotify;
+      this._notifyTimer = setTimeout(notify, delayMs);
     }
   }
   _notifyFailureListeners() {
@@ -546,6 +744,46 @@ var SyncStatusTracker = class _SyncStatusTracker {
       }
     }
   }
+  /**
+   * Remap a CrudEntry from persisted JSON (handles toJSON() property remapping).
+   * PowerSync's CrudEntry.toJSON() remaps: opData→data, table→type, clientId→op_id, transactionId→tx_id
+   *
+   * @returns The remapped CrudEntry, or null if critical fields (table, id) are missing
+   */
+  remapEntry(entry) {
+    const table = entry.table ?? entry.type;
+    const id = entry.id;
+    if (!table || typeof table !== "string") {
+      this.logger.warn("[StatusTracker] Invalid CrudEntry: missing or invalid table field", entry);
+      return null;
+    }
+    if (!id || typeof id !== "string") {
+      this.logger.warn("[StatusTracker] Invalid CrudEntry: missing or invalid id field", entry);
+      return null;
+    }
+    return {
+      id,
+      clientId: entry.clientId ?? entry.op_id ?? 0,
+      op: entry.op,
+      table,
+      opData: entry.opData ?? entry.data,
+      transactionId: entry.transactionId ?? entry.tx_id
+    };
+  }
+  /**
+   * Normalize CrudEntry array to plain objects to avoid CrudEntry.toJSON() remapping issues.
+   * PowerSync's CrudEntry.toJSON() remaps property names which breaks deserialization.
+   */
+  normalizeEntries(entries) {
+    return entries.map((e) => ({
+      id: e.id,
+      clientId: e.clientId,
+      op: e.op,
+      table: e.table,
+      opData: e.opData,
+      transactionId: e.transactionId
+    }));
+  }
 };
 
 // src/sync/metrics-collector.ts
@@ -779,6 +1017,7 @@ var HealthMonitor = class {
   _listeners = /* @__PURE__ */ new Set();
   _running = false;
   _paused = false;
+  _pendingTimers = /* @__PURE__ */ new Set();
   constructor(logger, options = {}) {
     this.logger = logger;
     this.checkIntervalMs = options.checkIntervalMs ?? HEALTH_CHECK_INTERVAL_MS;
@@ -813,10 +1052,14 @@ var HealthMonitor = class {
     if (this._running) return;
     this.logger.info("[HealthMonitor] Starting");
     this._running = true;
-    this._checkHealth();
+    this._checkHealth().catch((err) => {
+      this.logger.warn("[HealthMonitor] Initial check error:", err);
+    });
     this._intervalId = setInterval(() => {
       if (!this._paused) {
-        this._checkHealth();
+        this._checkHealth().catch((err) => {
+          this.logger.warn("[HealthMonitor] Periodic check error:", err);
+        });
       }
     }, this.checkIntervalMs);
   }
@@ -837,6 +1080,8 @@ var HealthMonitor = class {
    */
   pause() {
     this._paused = true;
+    this._pendingTimers.forEach(clearTimeout);
+    this._pendingTimers.clear();
     this._updateHealth({
       ...this._health,
       status: "disconnected"
@@ -847,13 +1092,17 @@ var HealthMonitor = class {
    */
   resume() {
     this._paused = false;
-    this._checkHealth();
+    this._checkHealth().catch((err) => {
+      this.logger.warn("[HealthMonitor] Resume check error:", err);
+    });
   }
   /**
    * Dispose the monitor and clear all resources.
    */
   dispose() {
     this.stop();
+    this._pendingTimers.forEach(clearTimeout);
+    this._pendingTimers.clear();
     this._listeners.clear();
   }
   // ─── Getters ───────────────────────────────────────────────────────────────
@@ -982,12 +1231,16 @@ var HealthMonitor = class {
   _withTimeout(promise, timeoutMs) {
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
+        this._pendingTimers.delete(timer);
         reject(new Error(`Health check timeout after ${timeoutMs}ms`));
       }, timeoutMs);
+      this._pendingTimers.add(timer);
       promise.then((result) => {
+        this._pendingTimers.delete(timer);
         clearTimeout(timer);
         resolve(result);
       }, (error) => {
+        this._pendingTimers.delete(timer);
         clearTimeout(timer);
         reject(error);
       });
@@ -1004,4 +1257,4 @@ export {
   MetricsCollector,
   HealthMonitor
 };
-//# sourceMappingURL=chunk-OTJXIRWX.js.map
+//# sourceMappingURL=chunk-H772V6XQ.js.map