@pol-studios/powersync 1.0.6 → 1.0.10

package/dist/{chunk-R4YFWQ3Q.js → chunk-CUCAYK7Z.js}

@@ -1,56 +1,27 @@
+import {
+  DEFAULT_CONNECTION_HEALTH,
+  DEFAULT_SYNC_METRICS,
+  DEFAULT_SYNC_STATUS
+} from "./chunk-24RDMMCL.js";
 import {
   HEALTH_CHECK_INTERVAL_MS,
   HEALTH_CHECK_TIMEOUT_MS,
   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";
-
-// src/provider/types.ts
-var DEFAULT_SYNC_STATUS = {
-  connected: false,
-  connecting: false,
-  hasSynced: false,
-  lastSyncedAt: null,
-  uploading: false,
-  downloading: false,
-  downloadProgress: null,
-  failedTransactions: [],
-  hasUploadErrors: false,
-  permanentErrorCount: 0
-};
-var DEFAULT_CONNECTION_HEALTH = {
-  status: "disconnected",
-  latency: null,
-  lastHealthCheck: null,
-  consecutiveFailures: 0,
-  reconnectAttempts: 0
-};
-var DEFAULT_SYNC_METRICS = {
-  totalSyncs: 0,
-  successfulSyncs: 0,
-  failedSyncs: 0,
-  lastSyncDuration: null,
-  averageSyncDuration: null,
-  totalDataDownloaded: 0,
-  totalDataUploaded: 0,
-  lastError: null
-};
-var DEFAULT_SYNC_CONFIG = {
-  autoConnect: true,
-  syncInterval: 0,
-  enableHealthMonitoring: true,
-  enableMetrics: true
-};
+} from "./chunk-VACPAAQZ.js";
 
 // 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 +35,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 +50,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 +97,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 +153,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 +194,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 +223,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 +232,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 +356,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 +401,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 +428,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 +444,7 @@ var SyncStatusTracker = class _SyncStatusTracker {
         this._failedTransactions = this._failedTransactions.slice(-this._maxStoredFailures);
       }
     }
+    this._schedulePersist();
     this._notifyFailureListeners();
     this._notifyListeners();
   }
@@ -385,6 +455,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 +466,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 +536,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 +547,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 +575,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 +602,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 +688,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 +712,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 +985,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 +1020,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 +1048,8 @@ var HealthMonitor = class {
    */
   pause() {
     this._paused = true;
+    this._pendingTimers.forEach(clearTimeout);
+    this._pendingTimers.clear();
     this._updateHealth({
       ...this._health,
       status: "disconnected"
@@ -847,13 +1060,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 +1199,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);
       });
@@ -996,12 +1217,8 @@ var HealthMonitor = class {
 };
 
 export {
-  DEFAULT_SYNC_STATUS,
-  DEFAULT_CONNECTION_HEALTH,
-  DEFAULT_SYNC_METRICS,
-  DEFAULT_SYNC_CONFIG,
   SyncStatusTracker,
   MetricsCollector,
   HealthMonitor
 };
-//# sourceMappingURL=chunk-R4YFWQ3Q.js.map
+//# sourceMappingURL=chunk-CUCAYK7Z.js.map